@axiomantic/garden 0.2.6 → 0.2.8

package/SKILL.md

@@ -69,16 +69,16 @@ When an operator initiates a project or requests multi-agent coordination, the s
    - *Option 1 (Recommended)*: Multi-Agent Swarm (Dedicated terminal tabs/coding harnesses over Rhizo & Vine).
    - *Option 2*: Single-Agent Inline (Sequential execution within current chat session).
 2. **Question 2: Swarm Composition & Team Sizing**:
-   - *Option 1 (Recommended)*: Balanced Triad (3 Workers: Systems Architect `@architect`, Adversarial Auditor `@auditor`, DevEx Lead `@implementer`).
-   - *Option 2*: Focused Duo (2 Workers: Implementation Lead `@implementer`, Adversarial Auditor `@auditor`).
+   - *Option 1 (Recommended)*: Balanced Triad (3 Workers: Systems Architect `@<project>-architect`, Adversarial Auditor `@<project>-auditor`, DevEx Lead `@<project>-implementer`).
+   - *Option 2*: Focused Duo (2 Workers: Implementation Lead `@<project>-implementer`, Adversarial Auditor `@<project>-auditor`).
    - *Option 3*: Custom Swarm (Operator specifies custom roles and headcount).
 3. **Question 3: Available AI Coding Harnesses**:
    - The operator specifies which coding environments they have available (Claude Code CLI, Antigravity, OpenCode, Pi, Cursor, Headless Terminal). Explain that workers can run in **any** combination of harnesses!
 4. **Question 4: Foundation Model Pairing & Equivalencies**:
    - Recommend optimal models with fallback equivalents:
-     - `@architect`: Gemini 3.8 Flash / Claude 3.5 Sonnet / GPT-4o (deep architecture comprehension).
-     - `@auditor`: Claude 3.5 Sonnet / Claude 3 Opus (strict negative controls, zero sloppy approvals).
-     - `@implementer`: Gemini 3.8 Flash / Claude 3.5 Sonnet (rapid, iterative coding velocity).
+     - `@<project>-architect`: Gemini 3.8 Flash / Claude 3.5 Sonnet / GPT-4o (deep architecture comprehension).
+     - `@<project>-auditor`: Claude 3.5 Sonnet / Claude 3 Opus (strict negative controls, zero sloppy approvals).
+     - `@<project>-implementer`: Gemini 3.8 Flash / Claude 3.5 Sonnet (rapid, iterative coding velocity).
      - *Air-gapped / Local*: Ollama / DeepSeek-R1.
 
 #### Automatic Fulfillment & 10-Backtick Prompt Generation:
@@ -92,9 +92,116 @@ Upon receiving the operator's responses:
    2. Copy the raw block inside each 10-backtick pre block below and paste it into its corresponding session.
    3. Once pasted, tell me here (or I will automatically detect them online via `rhizo who`).
    ```
-5. Register the orchestrator's presence (`rhizo open orchestrator`) and arm the listener.
+5. Register the orchestrator's presence (`rhizo open <project>-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
@@ -188,12 +295,11 @@ To prevent silent deadlocks when workers stall, crash, or fail to re-arm listene
 2. **Watchdog Window**: If a worker fails to respond within the expected turn window (e.g. 5–10 minutes) and `rhizo probe` reveals `NO_LISTENER` or unread inbox items:
    - **Escalate Immediately**: Prompt the operator via `ask_question` with the diagnostic status.
    - **Actionable Remediation**: Offer options to (1) re-arm the listener in the worker's terminal session (`rhizo listen <worker>`), (2) reboot the agent harness, or (3) reassign the task via `rhizo reroute <worker> <new_worker>`.
-3. **Orchestrator Self-Audit Watchdog & Stepped Backoff Protocol (GVR-014, GVR-015)**:
-   - For harnesses supporting `schedule` (e.g. Antigravity), arm a debounced watchdog timer (`schedule(DurationSeconds=cadence, Prompt="...", TimerCondition="any")`).
-   - **Stepped Backoff & 4-Strike Cap**: Starts at base 15m (900s). On consecutive quiescent checks with a stable listener, backs off (15m $\rightarrow$ 30m $\rightarrow$ 60m $\rightarrow$ 120m) and stands down at check 4 (`recommended_cadence=0`), preventing infinite token-eating polling loops.
+3. **Orchestrator Self-Audit Watchdog (ONLY for OpenAI Codex / ChatGPT)**:
+   - **Antigravity & OpenCode Exemption**: In Google Antigravity and OpenCode, DO NOT schedule timers or cron tasks (`schedule(...)`). Antigravity natively and reactively wakes up on background process completion when `rhizo listen` delivers a message.
+   - **Codex / ChatGPT Watchdog Only**: In OpenAI Codex Desktop / CLI where background processes cannot reactively wake the harness, arm a scheduled watchdog timer or cron job with stepped backoff (15m $\rightarrow$ 30m $\rightarrow$ 60m $\rightarrow$ 120m $\rightarrow$ Stand Down at check 4).
    - **Reset Invariant**: Resets immediately to base 15m (streak 0) on any listener failure, unread inbox backlog, outbound task dispatch (`rhizo send`/`enqueue`), worker reply, or user chat prompt.
-   - **Replace, Never Stack**: Kills previous timer via `manage_task(Action='kill')` before arming a new one. Arriving worker traffic cancels the timer automatically with zero token overhead.
-   - When the timer fires, execute the short check: `rhizo watchdog check --agent <orchestrator> --json` and follow `next_action` (`SCHEDULE_TIMER` or `STAND_DOWN`).
+   - When the timer fires in Codex, execute the short check: `rhizo watchdog check --agent <orchestrator> --json` and follow `next_action` (`SCHEDULE_TIMER` or `STAND_DOWN`).
 
 ---
 

package/package.json

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

package/skills/choose-personas/SKILL.md

@@ -98,10 +98,10 @@ Once ratified, write `garden-swarm.json` to the target project directory:
   "project": "my-project",
   "created_at": "2026-09-28T12:00:00Z",
   "target_repo": "/Users/eek/Development/my-project",
-  "orchestrator": "orchestrator",
+  "orchestrator": "my-project-orchestrator",
   "workers": [
     {
-      "name": "architect",
+      "name": "my-project-architect",
       "persona": "Marcus Vance",
       "role": "Staff Systems Architect",
       "harness": "Antigravity / OpenCode",
@@ -111,7 +111,7 @@ Once ratified, write `garden-swarm.json` to the target project directory:
       "opposing_priority": "Structural purity, invariant guarantees, and long-term maintainability over hasty quick fixes."
     },
     {
-      "name": "auditor",
+      "name": "my-project-auditor",
       "persona": "Caleb Thorne",
       "role": "Verification & Adversarial Auditor",
       "harness": "Claude Code CLI / Antigravity",
@@ -121,7 +121,7 @@ Once ratified, write `garden-swarm.json` to the target project directory:
       "opposing_priority": "Adversarial skepticism, rigorous negative controls, and proof over convenience."
     },
     {
-      "name": "implementer",
+      "name": "my-project-implementer",
       "persona": "Elena Rostova",
       "role": "DevEx & Implementation Lead",
       "harness": "Antigravity / OpenCode",

package/skills/garden/SKILL.md

@@ -69,16 +69,16 @@ When an operator initiates a project or requests multi-agent coordination, the s
    - *Option 1 (Recommended)*: Multi-Agent Swarm (Dedicated terminal tabs/coding harnesses over Rhizo & Vine).
    - *Option 2*: Single-Agent Inline (Sequential execution within current chat session).
 2. **Question 2: Swarm Composition & Team Sizing**:
-   - *Option 1 (Recommended)*: Balanced Triad (3 Workers: Systems Architect `@architect`, Adversarial Auditor `@auditor`, DevEx Lead `@implementer`).
-   - *Option 2*: Focused Duo (2 Workers: Implementation Lead `@implementer`, Adversarial Auditor `@auditor`).
+   - *Option 1 (Recommended)*: Balanced Triad (3 Workers: Systems Architect `@<project>-architect`, Adversarial Auditor `@<project>-auditor`, DevEx Lead `@<project>-implementer`).
+   - *Option 2*: Focused Duo (2 Workers: Implementation Lead `@<project>-implementer`, Adversarial Auditor `@<project>-auditor`).
    - *Option 3*: Custom Swarm (Operator specifies custom roles and headcount).
 3. **Question 3: Available AI Coding Harnesses**:
    - The operator specifies which coding environments they have available (Claude Code CLI, Antigravity, OpenCode, Pi, Cursor, Headless Terminal). Explain that workers can run in **any** combination of harnesses!
 4. **Question 4: Foundation Model Pairing & Equivalencies**:
    - Recommend optimal models with fallback equivalents:
-     - `@architect`: Gemini 3.8 Flash / Claude 3.5 Sonnet / GPT-4o (deep architecture comprehension).
-     - `@auditor`: Claude 3.5 Sonnet / Claude 3 Opus (strict negative controls, zero sloppy approvals).
-     - `@implementer`: Gemini 3.8 Flash / Claude 3.5 Sonnet (rapid, iterative coding velocity).
+     - `@<project>-architect`: Gemini 3.8 Flash / Claude 3.5 Sonnet / GPT-4o (deep architecture comprehension).
+     - `@<project>-auditor`: Claude 3.5 Sonnet / Claude 3 Opus (strict negative controls, zero sloppy approvals).
+     - `@<project>-implementer`: Gemini 3.8 Flash / Claude 3.5 Sonnet (rapid, iterative coding velocity).
      - *Air-gapped / Local*: Ollama / DeepSeek-R1.
 
 #### Automatic Fulfillment & 10-Backtick Prompt Generation:
@@ -92,7 +92,7 @@ Upon receiving the operator's responses:
    2. Copy the raw block inside each 10-backtick pre block below and paste it into its corresponding session.
    3. Once pasted, tell me here (or I will automatically detect them online via `rhizo who`).
    ```
-5. Register the orchestrator's presence (`rhizo open orchestrator`) and arm the listener.
+5. Register the orchestrator's presence (`rhizo open <project>-orchestrator`) and arm the listener.
 6. Poll or await cluster readiness gate (`rhizo who --json`) before proceeding to Phase 3.
 
 
@@ -295,12 +295,11 @@ To prevent silent deadlocks when workers stall, crash, or fail to re-arm listene
 2. **Watchdog Window**: If a worker fails to respond within the expected turn window (e.g. 5–10 minutes) and `rhizo probe` reveals `NO_LISTENER` or unread inbox items:
    - **Escalate Immediately**: Prompt the operator via `ask_question` with the diagnostic status.
    - **Actionable Remediation**: Offer options to (1) re-arm the listener in the worker's terminal session (`rhizo listen <worker>`), (2) reboot the agent harness, or (3) reassign the task via `rhizo reroute <worker> <new_worker>`.
-3. **Orchestrator Self-Audit Watchdog & Stepped Backoff Protocol (GVR-014, GVR-015)**:
-   - For harnesses supporting `schedule` (e.g. Antigravity), arm a debounced watchdog timer (`schedule(DurationSeconds=cadence, Prompt="...", TimerCondition="any")`).
-   - **Stepped Backoff & 4-Strike Cap**: Starts at base 15m (900s). On consecutive quiescent checks with a stable listener, backs off (15m $\rightarrow$ 30m $\rightarrow$ 60m $\rightarrow$ 120m) and stands down at check 4 (`recommended_cadence=0`), preventing infinite token-eating polling loops.
+3. **Orchestrator Self-Audit Watchdog (ONLY for OpenAI Codex / ChatGPT)**:
+   - **Antigravity & OpenCode Exemption**: In Google Antigravity and OpenCode, DO NOT schedule timers or cron tasks (`schedule(...)`). Antigravity natively and reactively wakes up on background process completion when `rhizo listen` delivers a message.
+   - **Codex / ChatGPT Watchdog Only**: In OpenAI Codex Desktop / CLI where background processes cannot reactively wake the harness, arm a scheduled watchdog timer or cron job with stepped backoff (15m $\rightarrow$ 30m $\rightarrow$ 60m $\rightarrow$ 120m $\rightarrow$ Stand Down at check 4).
    - **Reset Invariant**: Resets immediately to base 15m (streak 0) on any listener failure, unread inbox backlog, outbound task dispatch (`rhizo send`/`enqueue`), worker reply, or user chat prompt.
-   - **Replace, Never Stack**: Kills previous timer via `manage_task(Action='kill')` before arming a new one. Arriving worker traffic cancels the timer automatically with zero token overhead.
-   - When the timer fires, execute the short check: `rhizo watchdog check --agent <orchestrator> --json` and follow `next_action` (`SCHEDULE_TIMER` or `STAND_DOWN`).
+   - When the timer fires in Codex, execute the short check: `rhizo watchdog check --agent <orchestrator> --json` and follow `next_action` (`SCHEDULE_TIMER` or `STAND_DOWN`).
 
 ---
 

package/skills/launch-workers/SKILL.md

@@ -77,22 +77,22 @@ Run `garden prompts` (or `garden launch`) from the project root:
 garden prompts --write garden-prompts.md
 
 # Or generate for a specific worker:
-garden prompts --worker architect
+garden prompts --worker <project>-architect  # (or suffix shorthand: --worker architect)
 ```
 
 If `garden-swarm.json` exists in the repository, Garden uses its configured personas, mandates, harnesses, and models. If missing, Garden automatically synthesizes the standard balanced triad:
-- `@architect` (Marcus Vance - Staff Systems Architect)
-- `@auditor` (Caleb Thorne - Verification & Adversarial Auditor)
-- `@implementer` (Elena Rostova - DevEx & Implementation Lead)
+- `@<project>-architect` (Marcus Vance - Staff Systems Architect)
+- `@<project>-auditor` (Caleb Thorne - Verification & Adversarial Auditor)
+- `@<project>-implementer` (Elena Rostova - DevEx & Implementation Lead)
 
 ### Step 2: Present & Paste Prompts into Sessions
 The Orchestrator presents the generated prompt blocks to the operator with clear, structured guidance:
 
 1. **Numbered Terminal Tab / Session Instructions**:
    Provide a concise setup list instructing the operator on how many sessions to open and which harness/model to configure for each:
-   - **Session 1 (@architect)**: e.g. Antigravity or OpenCode with Gemini 3.8 Flash / Claude 3.5 Sonnet $\to$ Paste Card 1
-   - **Session 2 (@auditor)**: e.g. Claude Code CLI with Claude 3.5 Sonnet / Claude 3 Opus $\to$ Paste Card 2
-   - **Session 3 (@implementer)**: e.g. Antigravity or OpenCode with Gemini 3.8 Flash $\to$ Paste Card 3
+   - **Session 1 (@<project>-architect)**: e.g. Antigravity or OpenCode with Gemini 3.8 Flash / Claude 3.5 Sonnet $\to$ Paste Card 1
+   - **Session 2 (@<project>-auditor)**: e.g. Claude Code CLI with Claude 3.5 Sonnet / Claude 3 Opus $\to$ Paste Card 2
+   - **Session 3 (@<project>-implementer)**: e.g. Antigravity or OpenCode with Gemini 3.8 Flash $\to$ Paste Card 3
 2. **Harness & Model Agnostic Flexibility**:
    Explicitly reassure the operator: *"Workers can run in ANY coding harness (Claude Code, OpenCode, Antigravity, Pi, Cursor) and use any equivalent model tier. Coordination occurs strictly over Rhizo (local Redis) and Vine (Rift strands)."*
 3. **10-Backtick Raw Markdown Formatting**:
@@ -104,8 +104,9 @@ The Orchestrator presents the generated prompt blocks to the operator with clear
    - `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. **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:
+5. **Scheduled Health Check Template (ONLY for OpenAI Codex / ChatGPT CLI)**:
+   In Google Antigravity (using background `run_command`) and OpenCode (using background ear), DO NOT configure scheduled tasks; reactive background process completion handles wakeups natively.
+   In Codex Desktop / CLI where sessions cannot wake from background process exits without external stimulation, 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.

package/skills/orchestrate-swarm/SKILL.md

@@ -85,9 +85,9 @@ Whenever the Lead Orchestrator dispatches a task, broadcasts instructions, or aw
 
 FORBIDDEN: Never yield the conversation turn to the operator after dispatching work without an active background listener running. Yielding a turn without a listener severs the swarm's physical lifeline, trapping worker replies in Redis and causing silent swarm stalls.
 
-Safety Net (Scheduled Timer Watchdog & Debouncer Protocol — Stepped Backoff & 4-Strike Cap):
-In harnesses supporting `schedule` (e.g. Google Antigravity), arm a debounced watchdog timer to ensure an orchestrator session is never abandoned if a listener fails to arm or terminates prematurely.
-- **Base Cadence & Stepped Backoff**:
+Safety Net (Scheduled Watchdog Protocol — ONLY for OpenAI Codex / ChatGPT):
+- **Antigravity & OpenCode Exemption**: In Google Antigravity (using background `run_command(CommandLine="rhizo listen <orchestrator>", IsDaemon=false, WaitMsBeforeAsync=500)`) and OpenCode (using background ear), DO NOT schedule timers or cron tasks (`schedule(...)`). Antigravity's task manager natively and reactively resumes execution on process exit when `rhizo listen` delivers a message, with zero timer overhead.
+- **Codex / ChatGPT Watchdog Only**: In OpenAI Codex Desktop / CLI where background processes cannot reactively wake the harness, arm a scheduled watchdog timer or cron job using stepped backoff:
   - Initial / After Activity: Base 15 minutes (`DurationSeconds=900`).
   - Quiescent Check 1 (Streak 1): 30 minutes (`DurationSeconds=1800`).
   - Quiescent Check 2 (Streak 2): 60 minutes (`DurationSeconds=3600`).
@@ -100,18 +100,14 @@ In harnesses supporting `schedule` (e.g. Google Antigravity), arm a debounced wa
   3. Any outbound task dispatch (`rhizo send`, `rhizo enqueue`, `rhizo reply`).
   4. Any worker gate report or message receipt.
   5. Any operator interaction or new prompt in chat.
-- **Replace, Never Stack Invariant**:
-  Harnesses prohibit concurrent timers with `TimerCondition="any"`. Before setting a timer, inspect running tasks with `manage_task(Action='list')`. If an existing watchdog task is active (`toolName == "schedule"` or prompt includes `[RHIZO WATCHDOG]`), cancel it via `manage_task(Action='kill', TaskId=...)`.
 - **Stand Down Invariants**:
-  1. When all tasks in `implementation_plan.md` are complete (`- [x]` 100%), kill any running watchdog timer and do not reschedule.
+  1. When all tasks in `implementation_plan.md` are complete (`- [x]` 100%), cancel any running watchdog timer and do not reschedule.
   2. When the watchdog reaches `substatus: "MAX_STREAK_REACHED"` (streak 4/4), stand down and do not reschedule. The background listener process (`rhizo listen`) remains continuously active on Redis `BRPOP` and will wake the session on any new message.
-- **Zero-Token Happy Path**:
-  Because `TimerCondition="any"` is set, any arriving worker message or background task completion automatically cancels the timer early before it expires. The timer only fires if the orchestrator was silent and deaf for the full cadence duration.
-- **The Short Check (When Timer Fires)**:
+- **The Short Check (When Timer Fires in Codex)**:
   Run `rhizo watchdog check --agent <name> --json`.
   * If `ACTION_REQUIRED: REARM_LISTENER`: start `rhizo listen <name>` in background and schedule base timer (`DurationSeconds=900`).
   * If `ACTION_REQUIRED: UNREAD_MESSAGES`: drain messages with `rhizo drain 10 <name>`, start listener, and schedule base timer (`DurationSeconds=900`).
-  * If `OK: LISTENING`: listener is healthy; check `recommended_cadence`. If `next_action == "SCHEDULE_TIMER"`, schedule timer with `DurationSeconds=recommended_cadence` and return to sleep with minimal or no user-facing chat output.
+  * If `OK: LISTENING`: listener is healthy; check `recommended_cadence`. If `next_action == "SCHEDULE_TIMER"`, schedule timer with `DurationSeconds=recommended_cadence`.
   * If `STAND_DOWN: MAX_STREAK_REACHED` or `STAND_DOWN: IDLE`: stand down and do NOT reschedule.
 </CRITICAL>
 
@@ -231,7 +227,7 @@ Depending on the task distribution model in `implementation_plan.md`:
 
 - **Direct Assignment (O2O)**:
   ```bash
-  rhizo send --to architect \
+  rhizo send --to <project>-architect \
     --subject "Task 1.1: Core Data Structures" \
     --body '{"task_id": "task-core-ds", "instructions": "Implement AST node kinds and message serializers. Use vine strand.", "strand": "strand/task-core-ds"}'
   ```
@@ -246,7 +242,7 @@ Depending on the task distribution model in `implementation_plan.md`:
 - **Mandatory Turn-End Listener Arming**:
   Immediately after executing `rhizo send` or `rhizo enqueue`, arm your single-shot background listener before completing your turn:
   ```bash
-  run_command(CommandLine="rhizo listen orchestrator", IsDaemon=false, WaitMsBeforeAsync=500)
+  run_command(CommandLine="rhizo listen <project>-orchestrator", IsDaemon=false, WaitMsBeforeAsync=500)
   ```
   *(Never end your turn without this active background task; without it, worker gate reports cannot wake you up).*
 

package/skills/plan-implementation/SKILL.md

@@ -31,20 +31,20 @@ The generated implementation plan must follow this exact template:
 ## 1. Swarm Roster & Role Mapping
 | Worker Name | Persona | Role | Assigned Subsystems |
 | :--- | :--- | :--- | :--- |
-| `architect` | Marcus Vance | Staff Systems Architect | Core data structures, API contracts |
-| `auditor` | Caleb Thorne | Refactoring Purist | Unit tests, negative controls, linter |
-| `implementer` | Elena Rostova | DevEx & Implementation Lead | CLI commands, adapters, docs |
+| `<project>-architect` | Marcus Vance | Staff Systems Architect | Core data structures, API contracts |
+| `<project>-auditor` | Caleb Thorne | Refactoring Purist | Unit tests, negative controls, linter |
+| `<project>-implementer` | Elena Rostova | DevEx & Implementation Lead | CLI commands, adapters, docs |
 
 ---
 
 ## 2. Distributed Locking & Concurrency Schedule
 Before modifying any shared or non-mergeable file, the designated worker must obtain an atomic lease:
 - **Lock Target**: `file:src/config.nim`
-  - *Owner*: `architect`
+  - *Owner*: `<project>-architect`
   - *Command*: `rhizo lock file:src/config.nim 600 --fencing`
   - *Monotonic Fencing Counter*: Record token in task execution log.
 - **Lock Target**: `file:migrations/001_schema.sql`
-  - *Owner*: `implementer`
+  - *Owner*: `<project>-implementer`
   - *Command*: `rhizo lock file:migrations/001_schema.sql 300 --fencing`
 
 ---
@@ -74,14 +74,14 @@ For all parallel development tracks:
 ## 4. Phase-by-Phase Task Checklist
 
 ### Phase 1: Core Engine Primitives
-- [ ] **Task 1.1: Core Data Structures** (`architect`)
+- [ ] **Task 1.1: Core Data Structures** (`<project>-architect`)
   - *Strand*: `strand/task-core-ds`
   - *Lock*: `rhizo lock file:src/types.nim 300 --fencing`
   - *Actions*: Define AST node kinds and message serializers.
   - *Verification*: `nim c -r tests/test_types.nim`
   - *Weave*: `vine gate && vine weave && rhizo unlock file:src/types.nim`
 
-- [ ] **Task 1.2: Test Harness & Negative Controls** (`auditor`)
+- [ ] **Task 1.2: Test Harness & Negative Controls** (`<project>-auditor`)
   - *Strand*: `strand/task-test-harness`
   - *Actions*: Implement negative assertion tests for malformed JSON.
   - *Verification*: `pytest tests/test_harness.py`