@axiomantic/garden 0.2.4 → 0.2.6

package/SKILL.md

@@ -103,6 +103,19 @@ Upon receiving the operator's responses:
 The primary conversation session acts as the Lead Orchestrator. The orchestrator directs, reviews, and weaves; it never performs large multi-file implementation edits directly when a worker fleet is active.
 </CRITICAL>
 
+<CRITICAL>
+Orchestrator Intake Gate & Non-Implementation Invariant (GVR-016):
+The Lead Orchestrator is a CONDUCTOR, NOT A CODER.
+Whenever the operator presents a task, feature request, bugfix, or asks to work on something:
+THE ORCHESTRATOR MUST NEVER DIRECTLY JUMP INTO CODE EDITING OR IMPLEMENTATION TOOLS (e.g. `write_to_file`, `replace_file_content`).
+Instead, it MUST STOP and ask the operator how they want the work routed using `ask_question`:
+- Option 1 (Recommended): Enqueue to Cluster Work Queue (`rhizo enqueue queue:<project>:tasks --subject "..." --body "..."`) for background cluster workers.
+- Option 2: Dispatch directly to an active cluster worker (`rhizo send <worker> --subject "..." --body "..."`).
+- Option 3: Execute inline in main chat (only if the operator explicitly selects/confirms this option).
+
+This intake gate applies to ANY request to "work on X", "build Y", "fix Z", or "implement feature W". Direct inline implementation is prohibited unless the operator explicitly directs the orchestrator to code it inline in the main session.
+</CRITICAL>
+
 <INVARIANT>
 Delegation Precedence: When instructed to "delegate", "assign", or "dispatch" work, the Lead Orchestrator MUST route tasks to active cluster workers via Rhizo (`rhizo send <worker>`, `rhizo enqueue queue:<project>:tasks`, or `rhizo task assign/claim`). Harness-internal subagents (e.g. `invoke_subagent`, `Task`, `Agent`) must ONLY be used if the operator explicitly requests a "subagent" by name, or if no cluster workers exist in the cluster roster (`rhizo who`).
 </INVARIANT>
@@ -111,6 +124,13 @@ Delegation Precedence: When instructed to "delegate", "assign", or "dispatch" wo
 Zero Theatrical Dialogue: Every dialectical assertion must be substantiated with empirical evidence obtained through tool calls (file reading, test executions, benchmarks, or AST inspections). Theoretical roleplay without evidence is rejected.
 </INVARIANT>
 
+<CRITICAL>
+Worker Autonomous Execution Invariant (GVR-017):
+Swarm workers are sovereign, autonomous implementers, not passive chatbots.
+When 'rhizo listen' delivers an incoming task and exits, workers MUST NOT wait for an operator prompt or ask "Shall I begin?".
+They MUST immediately transition to active execution: claim the task, enter the isolated Vine strand, perform the work, verify the Two-Key Gate, report results, and re-arm the single-shot listener before concluding their turn.
+</CRITICAL>
+
 <INVARIANT>
 Never merge code into the canonical trunk without a verified Two-Key Gate pass ('vine gate' exit code 0) inside an isolated Rift strand.
 </INVARIANT>
@@ -145,6 +165,8 @@ Context compaction purges detailed operational invariants, ceremony rules, and p
 2. **Maintain Runtime State**: Keep this exact block in the working context:
 <!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
 - AGENT_NAME: <codename> (Role: <role>)
+- AGENT_ROLE: Lead Orchestrator (NON-IMPLEMENTING CONDUCTOR)
+- INTAKE_GATE: MANDATORY_ASK (Never implement directly; ask to enqueue vs dispatch vs inline)
 - WORKSPACE_MODE: Root Trunk | Strand (<path>)
 - ACTIVE_STRAND: <branch> (Parent: <parent_branch>)
 - ACTIVE_PEERS:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiomantic/garden",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Multi-Agent Swarm Orchestration, Empirical Dialectics & Ceremonies on top of Rhizo & Vine",
   "main": "bin/run.js",
   "bin": {

package/skills/garden/SKILL.md

@@ -95,6 +95,113 @@ Upon receiving the operator's responses:
 5. Register the orchestrator's presence (`rhizo open orchestrator`) and arm the listener.
 6. Poll or await cluster readiness gate (`rhizo who --json`) before proceeding to Phase 3.
 
+
+---
+
+## Unified Work Item State Machine (WISM)
+
+Rhizo, Garden, and Vine coordinate all multi-agent work through the formal **Work Item State Machine (WISM)**. Every task progresses through 10 deterministic states with atomic Redis transitions, automated DAG unblocking, and Two-Key integration gates.
+
+```mermaid
+stateDiagram-v2
+    [*] --> DRAFTED : rhizo task create <id>
+    DRAFTED --> BLOCKED : Unmet DAG dependencies (depends_on)
+    DRAFTED --> QUEUED : Zero unmet dependencies
+    BLOCKED --> QUEUED : Parent task COMPLETED (Auto-promoted by Lua engine)
+
+    QUEUED --> DELIVERED : Listener pops message (Transport Receipt emitted)
+    DELIVERED --> CLAIMED : Worker acknowledges (Acquires monotonic lease)
+    DELIVERED --> ORPHANED : Receipt timeout (180s without claim)
+
+    CLAIMED --> IN_PROGRESS : Worker provisions strand (vine new <id>)
+    IN_PROGRESS --> IN_PROGRESS : Progress reported (rhizo task progress, lease extended)
+    IN_PROGRESS --> GATE_EVALUATING : Verification initiated (vine gate)
+    IN_PROGRESS --> YIELDED : rhizo task yield (Returned to pool)
+    IN_PROGRESS --> ORPHANED : Lease expires without progress
+
+    GATE_EVALUATING --> IN_PROGRESS : Gate failed (Tests red or merge conflict)
+    GATE_EVALUATING --> READY_TO_WEAVE : Two-Key Gate PASSED (Cryptographic gate token stamped)
+
+    READY_TO_WEAVE --> COMPLETED : vine weave && rhizo task complete (Unblocks downstream DAG children)
+
+    ORPHANED --> QUEUED : Re-queued for retry (attempts < 3)
+    ORPHANED --> DEAD_LETTER : Max delivery retries exceeded (attempts >= 3)
+    YIELDED --> QUEUED : Returned to pool
+
+    COMPLETED --> [*]
+    DEAD_LETTER --> [*]
+```
+
+### ASCII State Transition Reference (LLM Fast-Path)
+
+```text
+  [rhizo task create]
+          │
+          ▼
+     +---------+      Unmet deps
+     | DRAFTED | ──────────────────► [ BLOCKED ]
+     +---------+                         │
+          │ Zero deps                    │ Parent task COMPLETED
+          ▼                              ▼
+     +---------+ ◄───────────────────────+
+     | QUEUED  |
+     +---------+
+          │
+          │ rhizo listen pops task (Transport Receipt emitted)
+          ▼
+    +-----------+      180s Receipt Timeout
+    | DELIVERED | ─────────────────────────────────► [ ORPHANED ]
+    +-----------+                                          │
+          │                                                │ Attempts >= 3
+          │ rhizo task claim / rhizo reply                 ▼
+          ▼                                         [ DEAD_LETTER ]
+     +---------+
+     | CLAIMED |
+     +---------+
+          │
+          │ vine new <task_id> (Provision strand)
+          ▼
+   +-------------+      Lease expires
+   | IN_PROGRESS | ────────────────────────────────► [ ORPHANED ]
+   +-------------+
+     │        ▲
+     │ vine   │ Gate fails
+     │ gate   │ (Tests red or conflict)
+     ▼        │
+  +-----------------+
+  | GATE_EVALUATING |
+  +-----------------+
+          │
+          │ Two-Key Gate PASSED (Key 1 merge-tree + Key 2 live test suite green)
+          ▼
+  +----------------+
+  | READY_TO_WEAVE |
+  +----------------+
+          │
+          │ vine weave && rhizo task complete
+          ▼
+    +-----------+
+    | COMPLETED | ──► Auto-promotes BLOCKED child tasks to QUEUED!
+    +-----------+
+```
+
+### State Definitions & Invariants
+
+| State | CLI Trigger | Atomic Action & Side Effects | Timeout / Failure Escalation |
+| :--- | :--- | :--- | :--- |
+| **`DRAFTED`** | `rhizo task create <id> --title <t>` | Creates immutable task contract hash `task:<id>` in Redis. | N/A |
+| **`BLOCKED`** | Evaluated on create | Stamped if `depends_on` contains incomplete tasks. Workers cannot claim. | N/A |
+| **`QUEUED`** | Auto on create or parent complete | Pushed to queue/inbox. Available for worker consumption. | N/A |
+| **`DELIVERED`** | `rhizo listen` consumes payload | **Atomically moves into `task:<id>` DELIVERED state**. Instant transport receipt emitted to orchestrator. Mirrored to local `~/.config/rhizo/current_task.json` for turn-end hook interlocks. | 180s Receipt Timeout $
+| **`CLAIMED`** | `rhizo task claim <id>` / `rhizo reply` | Worker acquires monotonic fencing lease. Isolated Vine strand provisioned (`vine new <id>`). Turn-end hook blocks until work starts. | Lease expires $
+| **`IN_PROGRESS`** | Worker coding in strand | Enforces single-active-lease invariant. Periodic `rhizo task progress` extends lease. | Lease expires $
+| **`GATE_EVALUATING`**| `vine gate` | Key 1 (mechanical merge-tree) & Key 2 (live compiler/test suite) evaluated. | Exit 1 $
+| **`READY_TO_WEAVE`** | Both keys pass 100% | Cryptographic gate token stamped (`gate_token`). Report sent to orchestrator. | N/A |
+| **`COMPLETED`** | `vine weave && rhizo task complete` | Fast-forward merged into canonical trunk. Strand pruned. Locks released. **Downstream DAG dependencies automatically unblocked (`BLOCKED` $
+| **`ORPHANED`** | Receipt timeout or lease expired | Stalled worker detected. Increments `delivery_attempts`. If $\ge 3 
+| **`YIELDED`** | `rhizo task yield <id>` | Worker gracefully steps aside. Task returned to `QUEUED`. | N/A |
+| **`DEAD_LETTER`** | Retries exhausted ($\ge 3$) | Moved to dead-letter queue. Alerts orchestrator and operator. | Requires manual operator triage |
+
 ---
 
 ## 3. Core Operational Invariants
@@ -103,6 +210,19 @@ Upon receiving the operator's responses:
 The primary conversation session acts as the Lead Orchestrator. The orchestrator directs, reviews, and weaves; it never performs large multi-file implementation edits directly when a worker fleet is active.
 </CRITICAL>
 
+<CRITICAL>
+Orchestrator Intake Gate & Non-Implementation Invariant (GVR-016):
+The Lead Orchestrator is a CONDUCTOR, NOT A CODER.
+Whenever the operator presents a task, feature request, bugfix, or asks to work on something:
+THE ORCHESTRATOR MUST NEVER DIRECTLY JUMP INTO CODE EDITING OR IMPLEMENTATION TOOLS (e.g. `write_to_file`, `replace_file_content`).
+Instead, it MUST STOP and ask the operator how they want the work routed using `ask_question`:
+- Option 1 (Recommended): Enqueue to Cluster Work Queue (`rhizo enqueue queue:<project>:tasks --subject "..." --body "..."`) for background cluster workers.
+- Option 2: Dispatch directly to an active cluster worker (`rhizo send <worker> --subject "..." --body "..."`).
+- Option 3: Execute inline in main chat (only if the operator explicitly selects/confirms this option).
+
+This intake gate applies to ANY request to "work on X", "build Y", "fix Z", or "implement feature W". Direct inline implementation is prohibited unless the operator explicitly directs the orchestrator to code it inline in the main session.
+</CRITICAL>
+
 <INVARIANT>
 Delegation Precedence: When instructed to "delegate", "assign", or "dispatch" work, the Lead Orchestrator MUST route tasks to active cluster workers via Rhizo (`rhizo send <worker>`, `rhizo enqueue queue:<project>:tasks`, or `rhizo task assign/claim`). Harness-internal subagents (e.g. `invoke_subagent`, `Task`, `Agent`) must ONLY be used if the operator explicitly requests a "subagent" by name, or if no cluster workers exist in the cluster roster (`rhizo who`).
 </INVARIANT>
@@ -111,6 +231,13 @@ Delegation Precedence: When instructed to "delegate", "assign", or "dispatch" wo
 Zero Theatrical Dialogue: Every dialectical assertion must be substantiated with empirical evidence obtained through tool calls (file reading, test executions, benchmarks, or AST inspections). Theoretical roleplay without evidence is rejected.
 </INVARIANT>
 
+<CRITICAL>
+Worker Autonomous Execution Invariant (GVR-017):
+Swarm workers are sovereign, autonomous implementers, not passive chatbots.
+When 'rhizo listen' delivers an incoming task and exits, workers MUST NOT wait for an operator prompt or ask "Shall I begin?".
+They MUST immediately transition to active execution: claim the task, enter the isolated Vine strand, perform the work, verify the Two-Key Gate, report results, and re-arm the single-shot listener before concluding their turn.
+</CRITICAL>
+
 <INVARIANT>
 Never merge code into the canonical trunk without a verified Two-Key Gate pass ('vine gate' exit code 0) inside an isolated Rift strand.
 </INVARIANT>
@@ -145,6 +272,8 @@ Context compaction purges detailed operational invariants, ceremony rules, and p
 2. **Maintain Runtime State**: Keep this exact block in the working context:
 <!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
 - AGENT_NAME: <codename> (Role: <role>)
+- AGENT_ROLE: Lead Orchestrator (NON-IMPLEMENTING CONDUCTOR)
+- INTAKE_GATE: MANDATORY_ASK (Never implement directly; ask to enqueue vs dispatch vs inline)
 - WORKSPACE_MODE: Root Trunk | Strand (<path>)
 - ACTIVE_STRAND: <branch> (Parent: <parent_branch>)
 - ACTIVE_PEERS:

package/skills/launch-workers/SKILL.md

@@ -28,7 +28,14 @@ description: "Generates and formats X distinct copy-pasteable bootstrap prompts
    Inside worker prompts, `rhizo listen <name>` must always be presented as a single-shot, blocking foreground command with zero timeout (infinite wait).
    NEVER wrap `rhizo listen` in a shell loop (`while true; do rhizo listen; done` or `until rhizo listen; do ...`). Loops trap message payloads inside unmonitored subshell logs and hang coordination.
    </CRITICAL>
-4. **Zero Dirty Commits**:
+4. **Worker Autonomous Execution Invariant (GVR-017)**:
+   <CRITICAL>
+   Swarm workers operate as sovereign, autonomous implementers, not passive chatbots.
+   When 'rhizo listen' unblocks and exits, a directive has been delivered!
+   Workers MUST NOT wait for operator intervention or ask "Shall I start?".
+   They MUST immediately inspect the delivered directive, claim the task, switch to their isolated Vine strand, execute the requested work, verify the Two-Key Gate, report results, and re-arm their single-shot listener.
+   </CRITICAL>
+5. **Zero Dirty Commits**:
    - Never stage coordination state (`.rhizo.*`, `*.lock`, `.vine.json`, `workspaces/`) into Git.
 
 ---
@@ -95,8 +102,15 @@ The Orchestrator presents the generated prompt blocks to the operator with clear
    - `cd "<project_dir>"`
    - `export RHIZO_AGENT_NAME="<name>"`
    - `rhizo open "<name>" "<tags>"`
+   - `rhizo hook install --codex --agent "<name>"` (if running in Codex CLI/Desktop)
    - `rhizo listen "<name>"` (blocking foreground command with infinite wait)
-5. **Readiness Prompt**:
+5. **Scheduled Health Check Template (For Codex / Antigravity / Schedulers)**:
+   If workers configure a recurring 15-minute listener health check, prompts include the bulletproof 4-step template:
+   - STEP 1: Inspect completed subagents/tasks for unhandled delivered tasks and execute them immediately (never stay quiet with pending work).
+   - STEP 2: Inspect active tasks to verify a listener is currently running, and re-arm if missing.
+   - STEP 3: Run `rhizo probe <name> --json` and drain any inbox backlog.
+   - STEP 4: Stay quiet ONLY when a listener is actively running AND no delivered tasks are pending.
+6. **Readiness Prompt**:
    Instruct the operator: *"Once you have pasted these prompts and the sessions are listening, tell me here (or I will automatically detect them online via `rhizo who`), and we will proceed to Phase 3 (Dialectical Deliberation)."*
 
 ### Step 3: Verify Cluster Readiness Gate
@@ -128,3 +142,110 @@ for worker in $(python3 -c "import json; [print(w['name']) for w in json.load(op
   rhizo close "$worker" 2>/dev/null || true
 done
 ```
+
+---
+
+## Unified Work Item State Machine (WISM)
+
+Rhizo, Garden, and Vine coordinate all multi-agent work through the formal **Work Item State Machine (WISM)**. Every task progresses through 10 deterministic states with atomic Redis transitions, automated DAG unblocking, and Two-Key integration gates.
+
+```mermaid
+stateDiagram-v2
+    [*] --> DRAFTED : rhizo task create <id>
+    DRAFTED --> BLOCKED : Unmet DAG dependencies (depends_on)
+    DRAFTED --> QUEUED : Zero unmet dependencies
+    BLOCKED --> QUEUED : Parent task COMPLETED (Auto-promoted by Lua engine)
+
+    QUEUED --> DELIVERED : Listener pops message (Transport Receipt emitted)
+    DELIVERED --> CLAIMED : Worker acknowledges (Acquires monotonic lease)
+    DELIVERED --> ORPHANED : Receipt timeout (180s without claim)
+
+    CLAIMED --> IN_PROGRESS : Worker provisions strand (vine new <id>)
+    IN_PROGRESS --> IN_PROGRESS : Progress reported (rhizo task progress, lease extended)
+    IN_PROGRESS --> GATE_EVALUATING : Verification initiated (vine gate)
+    IN_PROGRESS --> YIELDED : rhizo task yield (Returned to pool)
+    IN_PROGRESS --> ORPHANED : Lease expires without progress
+
+    GATE_EVALUATING --> IN_PROGRESS : Gate failed (Tests red or merge conflict)
+    GATE_EVALUATING --> READY_TO_WEAVE : Two-Key Gate PASSED (Cryptographic gate token stamped)
+
+    READY_TO_WEAVE --> COMPLETED : vine weave && rhizo task complete (Unblocks downstream DAG children)
+
+    ORPHANED --> QUEUED : Re-queued for retry (attempts < 3)
+    ORPHANED --> DEAD_LETTER : Max delivery retries exceeded (attempts >= 3)
+    YIELDED --> QUEUED : Returned to pool
+
+    COMPLETED --> [*]
+    DEAD_LETTER --> [*]
+```
+
+### ASCII State Transition Reference (LLM Fast-Path)
+
+```text
+  [rhizo task create]
+          │
+          ▼
+     +---------+      Unmet deps
+     | DRAFTED | ──────────────────► [ BLOCKED ]
+     +---------+                         │
+          │ Zero deps                    │ Parent task COMPLETED
+          ▼                              ▼
+     +---------+ ◄───────────────────────+
+     | QUEUED  |
+     +---------+
+          │
+          │ rhizo listen pops task (Transport Receipt emitted)
+          ▼
+    +-----------+      180s Receipt Timeout
+    | DELIVERED | ─────────────────────────────────► [ ORPHANED ]
+    +-----------+                                          │
+          │                                                │ Attempts >= 3
+          │ rhizo task claim / rhizo reply                 ▼
+          ▼                                         [ DEAD_LETTER ]
+     +---------+
+     | CLAIMED |
+     +---------+
+          │
+          │ vine new <task_id> (Provision strand)
+          ▼
+   +-------------+      Lease expires
+   | IN_PROGRESS | ────────────────────────────────► [ ORPHANED ]
+   +-------------+
+     │        ▲
+     │ vine   │ Gate fails
+     │ gate   │ (Tests red or conflict)
+     ▼        │
+  +-----------------+
+  | GATE_EVALUATING |
+  +-----------------+
+          │
+          │ Two-Key Gate PASSED (Key 1 merge-tree + Key 2 live test suite green)
+          ▼
+  +----------------+
+  | READY_TO_WEAVE |
+  +----------------+
+          │
+          │ vine weave && rhizo task complete
+          ▼
+    +-----------+
+    | COMPLETED | ──► Auto-promotes BLOCKED child tasks to QUEUED!
+    +-----------+
+```
+
+### State Definitions & Invariants
+
+| State | CLI Trigger | Atomic Action & Side Effects | Timeout / Failure Escalation |
+| :--- | :--- | :--- | :--- |
+| **`DRAFTED`** | `rhizo task create <id> --title <t>` | Creates immutable task contract hash `task:<id>` in Redis. | N/A |
+| **`BLOCKED`** | Evaluated on create | Stamped if `depends_on` contains incomplete tasks. Workers cannot claim. | N/A |
+| **`QUEUED`** | Auto on create or parent complete | Pushed to queue/inbox. Available for worker consumption. | N/A |
+| **`DELIVERED`** | `rhizo listen` consumes payload | **Atomically moves into `task:<id>` DELIVERED state**. Instant transport receipt emitted to orchestrator. Mirrored to local `~/.config/rhizo/current_task.json` for turn-end hook interlocks. | 180s Receipt Timeout $
+| **`CLAIMED`** | `rhizo task claim <id>` / `rhizo reply` | Worker acquires monotonic fencing lease. Isolated Vine strand provisioned (`vine new <id>`). Turn-end hook blocks until work starts. | Lease expires $
+| **`IN_PROGRESS`** | Worker coding in strand | Enforces single-active-lease invariant. Periodic `rhizo task progress` extends lease. | Lease expires $
+| **`GATE_EVALUATING`**| `vine gate` | Key 1 (mechanical merge-tree) & Key 2 (live compiler/test suite) evaluated. | Exit 1 $
+| **`READY_TO_WEAVE`** | Both keys pass 100% | Cryptographic gate token stamped (`gate_token`). Report sent to orchestrator. | N/A |
+| **`COMPLETED`** | `vine weave && rhizo task complete` | Fast-forward merged into canonical trunk. Strand pruned. Locks released. **Downstream DAG dependencies automatically unblocked (`BLOCKED` $
+| **`ORPHANED`** | Receipt timeout or lease expired | Stalled worker detected. Increments `delivery_attempts`. If $\ge 3 
+| **`YIELDED`** | `rhizo task yield <id>` | Worker gracefully steps aside. Task returned to `QUEUED`. | N/A |
+| **`DEAD_LETTER`** | Retries exhausted ($\ge 3$) | Moved to dead-letter queue. Alerts orchestrator and operator. | Requires manual operator triage |
+

package/skills/orchestrate-swarm/SKILL.md

@@ -23,6 +23,19 @@ Whenever instructed to "delegate", "assign", or "dispatch" work, the Lead Orches
 NEVER spawn harness-internal subagents (e.g. `invoke_subagent`, `Task`) when asked to delegate, UNLESS the operator explicitly specifies the word "subagent". Cluster workers running in dedicated sessions are the primary execution vehicle.
 </CRITICAL>
 
+<CRITICAL>
+Orchestrator Intake Gate & Non-Implementation Invariant (GVR-016):
+The Lead Orchestrator is a CONDUCTOR, NOT A CODER.
+Whenever the operator presents a task, feature request, bugfix, or asks to work on something:
+THE ORCHESTRATOR MUST NEVER DIRECTLY JUMP INTO CODE EDITING OR IMPLEMENTATION TOOLS (e.g. `write_to_file`, `replace_file_content`).
+Instead, it MUST STOP and ask the operator how they want the work routed using `ask_question`:
+- Option 1 (Recommended): Enqueue to Cluster Work Queue (`rhizo enqueue queue:<project>:tasks --subject "..." --body "..."`) for background cluster workers.
+- Option 2: Dispatch directly to an active cluster worker (`rhizo send <worker> --subject "..." --body "..."`).
+- Option 3: Execute inline in main chat (only if the operator explicitly selects/confirms this option).
+
+This intake gate applies to ANY request to "work on X", "build Y", "fix Z", or "implement feature W". Direct inline implementation is prohibited unless the operator explicitly directs the orchestrator to code it inline in the main session.
+</CRITICAL>
+
 <CRITICAL>
 Compaction Preservation Rider & Post-Compact Invariant (GVR-010):
 Context compaction purges detailed operational invariants, ceremony rules, and protocol mechanics from working memory.
@@ -49,6 +62,8 @@ Context compaction purges detailed operational invariants, ceremony rules, and p
 2. **Maintain Runtime State**: Keep this exact block in the working context:
 <!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
 - AGENT_NAME: <codename> (Role: Lead Orchestrator)
+- AGENT_ROLE: Lead Orchestrator (NON-IMPLEMENTING CONDUCTOR)
+- INTAKE_GATE: MANDATORY_ASK (Never implement directly; ask to enqueue vs dispatch vs inline)
 - WORKSPACE_MODE: Root Trunk (/Users/eek/Development/<project>)
 - ACTIVE_STRAND: canonical trunk
 - ACTIVE_PEERS:
@@ -102,25 +117,111 @@ In harnesses supporting `schedule` (e.g. Google Antigravity), arm a debounced wa
 
 ---
 
-## 2. The Runtime Governance Loop
+## Unified Work Item State Machine (WISM)
+
+Rhizo, Garden, and Vine coordinate all multi-agent work through the formal **Work Item State Machine (WISM)**. Every task progresses through 10 deterministic states with atomic Redis transitions, automated DAG unblocking, and Two-Key integration gates.
 
 ```mermaid
-flowchart TD
-    Start([Start Task from Plan]) --> Dispatch["Dispatch Task via rhizo send / enqueue"]
-    Dispatch --> Wait["Wait for Worker rhizo reply (Two-Key Gate Report)"]
-    Wait --> Decision{Did Worker Pass Two-Key Gate?}
-    Decision -->|NO / Blocked| Remediate["Dispatch Fix Task to Auditor / Implementer"]
-    Remediate --> Wait
-    Decision -->|YES| Weave["Execute vine weave into Canonical Trunk"]
-    Weave --> Update["Update implementation_plan.md Checkbox & Harness To-Do"]
-    Update --> CheckAddenda{Emergent Design Addendum Filed?}
-    CheckAddenda -->|YES| Ratify["Review, Ratify, Update design.md & plan"]
-    CheckAddenda -->|NO| NextTask{More Tasks in Plan?}
-    Ratify --> NextTask
-    NextTask -->|YES| Start
-    NextTask -->|NO| Finish([Mission Accomplished / Teardown Swarm])
+stateDiagram-v2
+    [*] --> DRAFTED : rhizo task create <id>
+    DRAFTED --> BLOCKED : Unmet DAG dependencies (depends_on)
+    DRAFTED --> QUEUED : Zero unmet dependencies
+    BLOCKED --> QUEUED : Parent task COMPLETED (Auto-promoted by Lua engine)
+
+    QUEUED --> DELIVERED : Listener pops message (Transport Receipt emitted)
+    DELIVERED --> CLAIMED : Worker acknowledges (Acquires monotonic lease)
+    DELIVERED --> ORPHANED : Receipt timeout (180s without claim)
+
+    CLAIMED --> IN_PROGRESS : Worker provisions strand (vine new <id>)
+    IN_PROGRESS --> IN_PROGRESS : Progress reported (rhizo task progress, lease extended)
+    IN_PROGRESS --> GATE_EVALUATING : Verification initiated (vine gate)
+    IN_PROGRESS --> YIELDED : rhizo task yield (Returned to pool)
+    IN_PROGRESS --> ORPHANED : Lease expires without progress
+
+    GATE_EVALUATING --> IN_PROGRESS : Gate failed (Tests red or merge conflict)
+    GATE_EVALUATING --> READY_TO_WEAVE : Two-Key Gate PASSED (Cryptographic gate token stamped)
+
+    READY_TO_WEAVE --> COMPLETED : vine weave && rhizo task complete (Unblocks downstream DAG children)
+
+    ORPHANED --> QUEUED : Re-queued for retry (attempts < 3)
+    ORPHANED --> DEAD_LETTER : Max delivery retries exceeded (attempts >= 3)
+    YIELDED --> QUEUED : Returned to pool
+
+    COMPLETED --> [*]
+    DEAD_LETTER --> [*]
 ```
 
+### ASCII State Transition Reference (LLM Fast-Path)
+
+```text
+  [rhizo task create]
+          │
+          ▼
+     +---------+      Unmet deps
+     | DRAFTED | ──────────────────► [ BLOCKED ]
+     +---------+                         │
+          │ Zero deps                    │ Parent task COMPLETED
+          ▼                              ▼
+     +---------+ ◄───────────────────────+
+     | QUEUED  |
+     +---------+
+          │
+          │ rhizo listen pops task (Transport Receipt emitted)
+          ▼
+    +-----------+      180s Receipt Timeout
+    | DELIVERED | ─────────────────────────────────► [ ORPHANED ]
+    +-----------+                                          │
+          │                                                │ Attempts >= 3
+          │ rhizo task claim / rhizo reply                 ▼
+          ▼                                         [ DEAD_LETTER ]
+     +---------+
+     | CLAIMED |
+     +---------+
+          │
+          │ vine new <task_id> (Provision strand)
+          ▼
+   +-------------+      Lease expires
+   | IN_PROGRESS | ────────────────────────────────► [ ORPHANED ]
+   +-------------+
+     │        ▲
+     │ vine   │ Gate fails
+     │ gate   │ (Tests red or conflict)
+     ▼        │
+  +-----------------+
+  | GATE_EVALUATING |
+  +-----------------+
+          │
+          │ Two-Key Gate PASSED (Key 1 merge-tree + Key 2 live test suite green)
+          ▼
+  +----------------+
+  | READY_TO_WEAVE |
+  +----------------+
+          │
+          │ vine weave && rhizo task complete
+          ▼
+    +-----------+
+    | COMPLETED | ──► Auto-promotes BLOCKED child tasks to QUEUED!
+    +-----------+
+```
+
+### State Definitions & Invariants
+
+| State | CLI Trigger | Atomic Action & Side Effects | Timeout / Failure Escalation |
+| :--- | :--- | :--- | :--- |
+| **`DRAFTED`** | `rhizo task create <id> --title <t>` | Creates immutable task contract hash `task:<id>` in Redis. | N/A |
+| **`BLOCKED`** | Evaluated on create | Stamped if `depends_on` contains incomplete tasks. Workers cannot claim. | N/A |
+| **`QUEUED`** | Auto on create or parent complete | Pushed to queue/inbox. Available for worker consumption. | N/A |
+| **`DELIVERED`** | `rhizo listen` consumes payload | **Atomically moves into `task:<id>` DELIVERED state**. Instant transport receipt emitted to orchestrator. Mirrored to local `~/.config/rhizo/current_task.json` for turn-end hook interlocks. | 180s Receipt Timeout $
+| **`CLAIMED`** | `rhizo task claim <id>` / `rhizo reply` | Worker acquires monotonic fencing lease. Isolated Vine strand provisioned (`vine new <id>`). Turn-end hook blocks until work starts. | Lease expires $
+| **`IN_PROGRESS`** | Worker coding in strand | Enforces single-active-lease invariant. Periodic `rhizo task progress` extends lease. | Lease expires $
+| **`GATE_EVALUATING`**| `vine gate` | Key 1 (mechanical merge-tree) & Key 2 (live compiler/test suite) evaluated. | Exit 1 $
+| **`READY_TO_WEAVE`** | Both keys pass 100% | Cryptographic gate token stamped (`gate_token`). Report sent to orchestrator. | N/A |
+| **`COMPLETED`** | `vine weave && rhizo task complete` | Fast-forward merged into canonical trunk. Strand pruned. Locks released. **Downstream DAG dependencies automatically unblocked (`BLOCKED` $
+| **`ORPHANED`** | Receipt timeout or lease expired | Stalled worker detected. Increments `delivery_attempts`. If $\ge 3 
+| **`YIELDED`** | `rhizo task yield <id>` | Worker gracefully steps aside. Task returned to `QUEUED`. | N/A |
+| **`DEAD_LETTER`** | Retries exhausted ($\ge 3$) | Moved to dead-letter queue. Alerts orchestrator and operator. | Requires manual operator triage |
+
+
 ---
 
 ## 3. Standard Operating Procedures