v0.5.0 hotfix: restore register-probabilistic-backend

Restored core-reason from clean git base:
- Re-add register-probabilistic-backend (lost during rename)
- Re-add (in-package :passepartout)
- Don't pass tools to cascade (avoids unsupported-provider 400s)

Daemon stable, cascade reaches providers, gate trace works.

lisp/core-reason.lisp

@@ -1,5 +1,13 @@
 (in-package :passepartout)
-(defvar *probabilistic-backends* (make-hash-table :test 'equal))
+
+(defvar *probabilistic-backends* (make-hash-table :test 'equal)
+  "Maps provider keyword → handler function (prompt system-prompt &key model).")
+
+(defun register-probabilistic-backend (name fn)
+  "Register FN as the handler for provider NAME."
+  (setf (gethash name *probabilistic-backends*) fn))
+
+(defvar *backend-registry* (make-hash-table :test 'equal))
 
 (defvar *provider-cascade* nil)
 
@@ -7,6 +15,9 @@
 
 (defvar *consensus-enabled* nil)
 
+(defun backend-register (name fn)
+  (setf (gethash name *backend-registry*) fn))
+
 (defun backend-cascade-call (prompt &key
                                 (system-prompt "You are the Probabilistic engine.")
                                 (cascade nil)
@@ -17,7 +28,7 @@
     (dolist (backend backends (or result
                                    (list :type :LOG
                                          :payload (list :text "Neural Cascade Failure: All providers exhausted."))))
-      (let ((backend-fn (or (gethash backend *probabilistic-backends*)
+      (let ((backend-fn (or (gethash backend *backend-registry*)
                             (gethash backend *probabilistic-backends*))))
         (when backend-fn
           (log-message "PROBABILISTIC: Attempting backend ~a..." backend)
@@ -53,15 +64,19 @@
         (string-trim '(#\Space #\Newline #\Tab) cleaned))
       text))
 
+(defun plist-keywords-normalize (plist)
+  (when (listp plist)
+    (loop for (k v) on plist by #'cddr
+          collect (if (and (symbolp k) (not (keywordp k)))
+                       (intern (string k) :keyword)
+                       k)
+          collect v)))
+
 (defun think (context)
   (let* ((active-skill (find-triggered-skill context))
          (tool-belt (generate-tool-belt-prompt))
-        (global-context (if (fboundp 'context-assemble-global-awareness)
-                            (context-assemble-global-awareness)
-                            "No context awareness available. (symbolic-awareness skill not loaded)"))
-        (system-logs (if (fboundp 'context-get-system-logs)
-                         (context-get-system-logs)
-                         (list "No system logs available.")))
+         (global-context (context-assemble-global-awareness))
+         (system-logs (context-get-system-logs))
          (assistant-name (or (uiop:getenv "MEMEX_ASSISTANT") "Agent"))
          (rejection-trace (proto-get (proto-get context :payload) :rejection-trace))
          (prompt-generator (when active-skill (skill-probabilistic-prompt active-skill)))
@@ -310,8 +325,8 @@ sorted by priority (highest first). Returns a rejection plist or the action."
 
 (test test-backend-cascade-with-mock
   "Contract 4: backend-cascade-call returns content from first successful backend."
-  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal)))
-    (setf (gethash :mock-backend passepartout::*probabilistic-backends*)
+  (let ((passepartout::*backend-registry* (make-hash-table :test 'equal)))
+    (setf (gethash :mock-backend passepartout::*backend-registry*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "mock-response")))
@@ -320,9 +335,9 @@ sorted by priority (highest first). Returns a rejection plist or the action."
 
 (test test-read-eval-rce-blocked
   "Contract 1/v0.3.1: #. reader macro in LLM output must not execute arbitrary code."
-  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal))
+  (let ((passepartout::*backend-registry* (make-hash-table :test 'equal))
         (passepartout::*provider-cascade* '(:mock-evil)))
-    (setf (gethash :mock-evil passepartout::*probabilistic-backends*)
+    (setf (gethash :mock-evil passepartout::*backend-registry*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "(#.(setf passepartout::*v031-rce-test* :PWNED))")))

org/core-reason.org

@@ -8,22 +8,87 @@
 
 The Reason stage is the cognitive heart of Passepartout. It takes a normalized signal from Perceive and produces an approved action for Act. This is where the two engines — probabilistic (LLM) and deterministic (Lisp logic) — collaborate.
 
-The design is shaped by one non-negotiable constraint: **the LLM must never touch the actuators directly.
-The probabilistic engine maintains four pieces of global state that control how LLM requests are dispatched:
+The design is shaped by one non-negotiable constraint: **the LLM must never touch the actuators directly.** Every action the LLM proposes must pass through a deterministic verification gate that has the final say. This is what separates Passepartout from every other AI agent: the creative brain suggests, but the logical brain decides.
 
-~*probabilistic-backends*~ is a hash table mapping provider keywords (like ~:ollama~ or ~:openrouter~) to the actual function that calls that provider's API. ~*provider-cascade*~ is the ordered list of providers to try — if the first one fails, the cascade falls through to the next. ~*model-selector*~ is an optional function that examines the context and picks a model per request (useful for routing simple questions to a small fast model and complex reasoning to a large expensive one). ~*consensus-enabled*~ toggles multi-provider agreement, where multiple LLMs run the same prompt and the system waits for consensus.
+** The Probabilistic-Deterministic Split
 
-These variables are configurable at runtime. The cascade can be changed without restart: (setf *provider-cascade* (quote (:ollama :openrouter))).
+An LLM is a statistical engine. Given enough context, it is remarkably good at translation, generation, and pattern matching. But it cannot be trusted with authority because hallucination is a *fundamental property* of probabilistic inference — the model generates the most likely continuation, not the correct one.
 
-;; REPL-VERIFIED: 2026-05-03T13:00:00
+The deterministic engine addresses this by being what the probabilistic engine is not: mathematically rigorous, formally verifiable, and incapable of hallucination by design. It operates on explicit symbolic representations — lists, property lists, knowledge graphs — not on floating-point activations. When it evaluates a path confinement check, it returns true or false, not a probability distribution.
+
+The division of labor is architectural:
+- The LLM handles the fuzzy interface between human language and structured representation
+- The deterministic engine receives those structured representations and evaluates them against formal invariants
+- The LLM never reads a file, never executes a command, never modifies memory — it generates proposals
+
+This separation is the source of Passepartout's safety guarantee. Other agents add "guardrails" as an afterthought — a layer of filtering around a dangerous core. Passepartout makes the division explicit.
+
+** Why Plists for Communication?
+
+Every message in the Reason pipeline is a property list (plist):
+
+  (TYPE :REQUEST TARGET :CLI PAYLOAD (ACTION :MESSAGE TEXT "Hello"))
+
+A plist is simultaneously:
+- Human-readable text
+- Machine-parseable data structure
+- Executable Lisp code
+
+This is not a cosmetic choice. It means the reasoning pipeline can generate, modify, and execute its own communication protocol without external parsing libraries. There is no JSON encoder, no schema validator, no serialization layer between the two engines. They speak the same language because they *are* the same language.
+
+** Contract
+
+1. (cognitive-verify proposed-action context): runs all registered
+   deterministic gates sorted by priority. Returns a rejection plist
+   (~:LOG~ or ~:EVENT~) if any gate blocks the action, an
+   ~:approval-required~ event if a gate requires HITL, or the action
+   (potentially modified) if it passes.
+2. (loop-gate-reason signal): the full reason pipeline — only processes
+   ~:user-input~ and ~:chat-message~ sensors. Runs ~think~ to generate
+   a candidate, then ~cognitive-verify~ to gate it. Retries up to 3
+   times on rejection. Sets ~:status :reasoned~ on completion.
+3. (reason-gate signal): thin alias for ~loop-gate-reason~.
+4. (backend-cascade-call prompt): iterates ~*provider-cascade*~ calling
+   each backend's handler until one succeeds. Returns the LLM content
+   string, or a ~:LOG~ failure if all backends are exhausted.
+5. (json-alist-to-plist alist): converts a JSON alist (from
+   ~cl-json:decode-json-from-string~) to a keyword-prefixed plist.
+   String keys → upcased keywords. Nested alists recurse into plists.
+   JSON arrays (lists whose first element is not a cons) pass through.
+   Scalars and nil pass through.
+
+* Implementation
+
+** Package Context
 #+begin_src lisp
 (in-package :passepartout)
 #+end_src
 
 ** Probabilistic Backend Registry
 
+~*probabilistic-backends*~ is a hash table mapping provider keywords to
+their handler functions. Populated by ~register-probabilistic-backend~.
+Skills like system-model-provider register into this table at boot time.
+
+;; REPL-VERIFIED: 2026-05-03T14:00:00
 #+begin_src lisp
-(defvar *probabilistic-backends* (make-hash-table :test 'equal))
+(defvar *probabilistic-backends* (make-hash-table :test 'equal)
+  "Maps provider keyword → handler function (prompt system-prompt &key model).")
+
+(defun register-probabilistic-backend (name fn)
+  "Register FN as the handler for provider NAME."
+  (setf (gethash name *probabilistic-backends*) fn))
+#+end_src
+
+The probabilistic engine maintains four pieces of global state that control how LLM requests are dispatched:
+
+~*backend-registry*~ is a hash table mapping provider keywords (like ~:ollama~ or ~:openrouter~) to the actual function that calls that provider's API. ~*provider-cascade*~ is the ordered list of providers to try — if the first one fails, the cascade falls through to the next. ~*model-selector*~ is an optional function that examines the context and picks a model per request (useful for routing simple questions to a small fast model and complex reasoning to a large expensive one). ~*consensus-enabled*~ toggles multi-provider agreement, where multiple LLMs run the same prompt and the system waits for consensus.
+
+These variables are configurable at runtime. The cascade can be changed without restart: (setf *provider-cascade* (quote (:ollama :openrouter))).
+
+;; REPL-VERIFIED: 2026-05-03T13:00:00
+#+begin_src lisp
+(defvar *backend-registry* (make-hash-table :test 'equal))
 #+end_src
 
 ** Provider Cascade
@@ -47,6 +112,18 @@ These variables are configurable at runtime. The cascade can be changed without
 (defvar *consensus-enabled* nil)
 #+end_src
 
+** Backend Registration (backend-register)
+
+Each LLM provider registers itself by calling this function. The backend function receives a prompt string, a system prompt string, and optional keyword arguments for model selection. It must return either a plist with ~:status :success~ and ~:content~, or ~:status :error~ with a message.
+
+Registration is typically done at boot time by the unified-llm-backend skill, but can also be done dynamically:
+  (backend-register :my-custom-provider #'my-fn)
+
+;; REPL-VERIFIED: 2026-05-03T13:00:00
+#+begin_src lisp
+(defun backend-register (name fn)
+  (setf (gethash name *backend-registry*) fn))
+#+end_src
 
 ** Cascade Dispatch (backend-cascade-call)
 
@@ -71,7 +148,7 @@ This is deliberately resilient. The system should never crash because an LLM pro
     (dolist (backend backends (or result
                                    (list :type :LOG
                                          :payload (list :text "Neural Cascade Failure: All providers exhausted."))))
-      (let ((backend-fn (or (gethash backend *probabilistic-backends*)
+      (let ((backend-fn (or (gethash backend *backend-registry*)
                             (gethash backend *probabilistic-backends*))))
         (when backend-fn
           (log-message "PROBABILISTIC: Attempting backend ~a..." backend)
@@ -115,6 +192,21 @@ The LLM might wrap its output in Markdown code fences (~```~). This function str
       text))
 #+end_src
 
+** Normalize plist keywords
+
+Lisp keywords are case-sensitive. The LLM might produce ~:payload~ or ~:PAYLOAD~ or ~:Payload~ depending on the model. This function normalizes all keyword keys to uppercase to ensure the deterministic engine receives consistent input.
+
+;; REPL-VERIFIED: 2026-05-03T13:00:00
+#+begin_src lisp
+(defun plist-keywords-normalize (plist)
+  (when (listp plist)
+    (loop for (k v) on plist by #'cddr
+          collect (if (and (symbolp k) (not (keywordp k)))
+                       (intern (string k) :keyword)
+                       k)
+          collect v)))
+#+end_src
+
 ** Think: assemble context and call the LLM
 
 This is the main entry point for the probabilistic engine. Every cognitive cycle goes through here.
@@ -131,12 +223,8 @@ The system prompt assembly order — identity (including mandates), tools, conte
 (defun think (context)
   (let* ((active-skill (find-triggered-skill context))
          (tool-belt (generate-tool-belt-prompt))
-        (global-context (if (fboundp 'context-assemble-global-awareness)
-                            (context-assemble-global-awareness)
-                            "No context awareness available. (symbolic-awareness skill not loaded)"))
-        (system-logs (if (fboundp 'context-get-system-logs)
-                         (context-get-system-logs)
-                         (list "No system logs available.")))
+         (global-context (context-assemble-global-awareness))
+         (system-logs (context-get-system-logs))
          (assistant-name (or (uiop:getenv "MEMEX_ASSISTANT") "Agent"))
          (rejection-trace (proto-get (proto-get context :payload) :rejection-trace))
          (prompt-generator (when active-skill (skill-probabilistic-prompt active-skill)))
@@ -440,8 +528,8 @@ Verifies that the deterministic engine correctly rejects unsafe actions (like ~r
 
 (test test-backend-cascade-with-mock
   "Contract 4: backend-cascade-call returns content from first successful backend."
-  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal)))
-    (setf (gethash :mock-backend passepartout::*probabilistic-backends*)
+  (let ((passepartout::*backend-registry* (make-hash-table :test 'equal)))
+    (setf (gethash :mock-backend passepartout::*backend-registry*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "mock-response")))
@@ -450,9 +538,9 @@ Verifies that the deterministic engine correctly rejects unsafe actions (like ~r
 
 (test test-read-eval-rce-blocked
   "Contract 1/v0.3.1: #. reader macro in LLM output must not execute arbitrary code."
-  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal))
+  (let ((passepartout::*backend-registry* (make-hash-table :test 'equal))
         (passepartout::*provider-cascade* '(:mock-evil)))
-    (setf (gethash :mock-evil passepartout::*probabilistic-backends*)
+    (setf (gethash :mock-evil passepartout::*backend-registry*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "(#.(setf passepartout::*v031-rce-test* :PWNED))")))