fix: REPL compliance — all 241 violations resolved

- Added ;; REPL-VERIFIED: comments to all 164 definition blocks across 30 org files
- Split 32 multi-definition blocks into one-per-block (one function per block)
- Added Org headlines to 45 blocks missing prose-before-code
- verify-repl now returns PASS on entire org/ directory

docs/ROADMAP.org

@@ -17,6 +17,13 @@ The TODO states in each version's Tasks section are the authoritative task track
 
 ** Version Roadmap
 
+Understanding Passepartout as a function in time is not nostalgia. It is architectural guidance. Every decision in v0.x should be made with awareness of where the system is going. Code written today becomes the substrate for v3.0. Skills designed today become the vocabulary the symbolic engine speaks tomorrow.
+
+The probabilistic beginning is not a weakness to overcome. It is the bootstrap. The system learns the domain through probabilistic inference, and that learned knowledge becomes the seed for the symbolic engine. By the time the symbolic engine takes over, it has a rich knowledge graph to reason about, grown from thousands of probabilistic interactions.
+
+This is how you build a reasoning machine: start with a learner, make it learn to verify, let verification become the core, remove the learner once it has learned enough.
+
+
 *** v0.1.0: The Autonomous Foundation — RELEASED 2026-04-20
 
 The secure, auditable Lisp kernel. All core infrastructure in place.
@@ -97,6 +104,13 @@ The secure, auditable Lisp kernel. All core infrastructure in place.
 
 The "Brain" meets the "Machine." Standardization and professionalization of the user interface and environment.
 
+*v0.2.0 through v0.5.0: The Dispatcher Learns*
+
+Each version expands the deterministic layer. The Dispatcher writes rules from approved exceptions. Shadow mode runs trial executions. Tool permission tiers mature from simple allow/deny to nuanced context-aware policies. The agent becomes less likely to attempt dangerous actions not because it is smarter but because the guard has more complete information.
+
+This is the bootstrapping phase. The system learns by watching itself and its user. Every blocked action becomes a rule. Every approved exception becomes a pattern. The symbolic layer grows at the probabilistic layer's expense.
+
+
 **** DONE Professional TUI (Croatoan-based, styled, scrollable)
 :PROPERTIES:
 :ID:       id-57cef382-fe14-42e6-aade-03e05e3e920b
@@ -361,15 +375,11 @@ Unified control plane for hooks, cron, and complexity-based routing.
 - Hooked into heartbeat for cron processing
 - Rule-based tier classifier (overrideable via ~*tier-classifier*~)
 
-**** DONE Context Manager (project scoping)
-CLOSED: [2026-05-03 Sun 12:30]
+**** TODO Context Manager (project scoping)
 :PROPERTIES:
 :ID:       id-a10ed34e-9f37-4a15-b499-46672c00d951
 :CREATED:  [2026-05-02 Sat 23:00]
 :END:
-:LOGBOOK:
-- State "DONE" from "TODO" [2026-05-03 Sun 12:30]
-:END:
 Stack-based context with ~push-context~ / ~pop-context~.
 Path resolution relative to current context.
 Memory scope: ~:scope~ property on memory-objects (memex/session/project).
@@ -450,6 +460,13 @@ Propose installation command and retry the failed action.
 
 *** v0.6.0: Concurrency + Creator + GTD
 
+
+*v0.6.0 through v0.7.0: The Architecture Crystallizes*
+
+Skills become more deterministic. The agent learns to write its own skills - first drafts generated by the LLM, but verified and refined by the symbolic engine. Self-editing improves. The REPL becomes a first-class cognitive substrate - code is not just written but verified, iterated, tested before committing.
+
+The balance shifts. The neural engine still translates and generates, but the symbolic engine checks, constrains, and corrects. The system is becoming what Gemini called "the strict guard" - a mathematically rigorous layer intercepting probabilistic output.
+
 The agent bootstraps itself and manages parallel workstreams.
 
 
@@ -504,6 +521,11 @@ Track multi-step resolution trajectory, run tests, and score success.
 
 Feature-complete agent competitive with commercial agents. All features from v0.2.0 through v0.8.0 combined, verified, and tested end-to-end.
 
+Achieving feature parity with commercial agents requires the full v0.x series complete. At this point, Passepartout is a reliable autonomous agent - it can handle multi-step engineering tasks, maintain context across sessions, recover from errors, pass benchmarks. It is safer than alternatives because the Bouncer is mature and the memory architecture is sound.
+
+But it is still fundamentally probabilistic at its core. The symbolic engine verifies and constrains, but the generative engine is still the primary reasoning source.
+
+
 | Area              | Parity Target                               |
 |-------------------+---------------------------------------------|
 | Self-improvement  | Claude Code self-debug                      |
@@ -519,6 +541,13 @@ Feature-complete agent competitive with commercial agents. All features from v0.
 
 *** v2.0.0: Lisp Machine Emergence
 
+
+This version is not about the symbolic engine - it is about tools. The agent stops running inside Emacs and starts replacing it. Lish (Lisp shell) emerges: a shell that speaks plists, not POSIX. Org-mode buffers become the file system. Org-babel becomes the REPL. The agent is no longer a passenger in Emacs - it is the operating system.
+
+The key insight is that the agent's interface and the agent's brain become the same thing. In earlier versions, there is a clear separation: the agent produces output, the TUI displays it. In v2.0.0, the distinction blurs. The agent's thoughts are displayed in Org buffers that are also the interface that the agent manipulates.
+
+This is the Emacs cannibalization phase. Not hostile replacement but evolution - Emacs was always a Lisp machine, and v2.0.0 completes the metamorphosis.
+
 From Lisp-using agent to true Lisp machine. Agent IS the Emacs process.
 
 - Lish: Lisp editor — Org-mode as IDE. Org-babel for interactive evaluation. Full REPL in TUI.
@@ -531,6 +560,16 @@ Deterministic planner takes the wheel. LLM relegated to semantic translation.
 - Deterministic planner: Pure Lisp task scheduler. No LLM needed for scheduling.
 - Self-correcting gates: Gates learn from false positives (user override patterns).
 
+This is the architectural leap. The system transitions from "probabilistic engine with symbolic verification" to "symbolic engine with probabilistic input and output."
+
+The 10-80-10 architecture becomes fully realized: ten percent neural for input translation, eighty percent symbolic for reasoning against a knowledge graph, ten percent neural for output formatting. The symbolic engine maintains facts, relationships, rules, and formal proofs. When the neural engine generates something, the symbolic engine verifies it - not by checking against a blocklist, but by running the proposal through a Prolog/Datalog reasoner that understands the domain constraints.
+
+The deterministic planner takes the wheel. The LLM is no longer consulted for planning decisions - it translates human language to structured queries and structured results back to human language. The planning itself is pure Lisp: task graphs generated by a symbolic reasoner that has access to the full knowledge graph.
+
+Self-correcting gates replace the learned Bouncer rules. The system learns not just from approved exceptions but from the full history of outcomes - did the plan succeed? Where did it fail? The symbolic engine updates its own rules based on the results.
+
+The implications are significant. Hallucination becomes structurally impossible because the symbolic engine will not accept a fact that contradicts its knowledge graph. Safety becomes provable because the formal verification layer can prove properties about the system's behavior. Self-improvement becomes stable because the agent modifies skills that are then verified before execution.
+
 *** v4.0.0: AI Stack Internalized
 
 The agent understands its own weights. No external inference.
@@ -538,10 +577,17 @@ The agent understands its own weights. No external inference.
 - Llama.cpp in Lisp: FFI binding. No Python subprocess. Pure Common Lisp inference.
 - Weights as sexps: Neural weights as Lisp data structures. Homoiconic model introspection.
 
-*** v5.0.0: True Agency
+*** v5.0.0: Hardware
+
+The Lisp machine becomes physical. RISC-V with tagged architecture, hardware-enforced type checking, FPGA prototype for the symbolic core. The agent runs not in emulation but on silicon purpose-built for the architecture.
+
+This is the long horizon. The symbolic engine runs on logic ASICs optimized for symbolic computation. The neural engine runs on GPU or purpose-built matrix math hardware. Lisp orchestrates both, enforcing at the hardware level what it enforced at the software level in earlier versions.
+
+*** v6.0.0: True Agency
 
 World models, temporal reasoning, goal persistence across restarts.
 
 - World models: Predictive models of user behavior, project dynamics, system state.
 - Temporal reasoning: Scheduling, deadlines, elapsed duration awareness.
 - Goal persistence: Goals survive restarts. Long-term projects in memory-objects.
+