@axiomantic/garden 0.2.3 → 0.2.5

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:
@@ -166,10 +188,12 @@ 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 & Debouncer Protocol (GVR-014)**:
-   - For harnesses supporting `schedule` (e.g. Antigravity), arm a debounced 15-minute watchdog timer (`schedule(DurationSeconds=900, Prompt="...", TimerCondition="any")`).
-   - Debouncer replaces (kills previous timer via `manage_task(Action='kill')` before arming a new one) on task dispatch, worker reports, and plan updates ("early and often"). Arriving worker traffic cancels the timer for free with 0 token overhead.
-   - When the timer fires, execute the short check: `rhizo watchdog check --agent <orchestrator> --json`. If `ACTION_REQUIRED: REARM_LISTENER`, revive `rhizo listen` in the background and debounce. When all tasks in the plan are complete (`- [x]`), stand down.
+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.
+   - **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`).
 
 ---
 

package/package.json

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

package/skills/garden/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:
@@ -166,10 +188,12 @@ 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 & Debouncer Protocol (GVR-014)**:
-   - For harnesses supporting `schedule` (e.g. Antigravity), arm a debounced 15-minute watchdog timer (`schedule(DurationSeconds=900, Prompt="...", TimerCondition="any")`).
-   - Debouncer replaces (kills previous timer via `manage_task(Action='kill')` before arming a new one) on task dispatch, worker reports, and plan updates ("early and often"). Arriving worker traffic cancels the timer for free with 0 token overhead.
-   - When the timer fires, execute the short check: `rhizo watchdog check --agent <orchestrator> --json`. If `ACTION_REQUIRED: REARM_LISTENER`, revive `rhizo listen` in the background and debounce. When all tasks in the plan are complete (`- [x]`), stand down.
+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.
+   - **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`).
 
 ---
 

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

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:
@@ -70,27 +85,34 @@ 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):
+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.
-- **Cadence**: 15 minutes (`DurationSeconds=900`, range 10m–30m / 600s–1800s). Defaulting to 15m avoids slurping token budgets while guaranteeing a 15m upper bound on any stall.
+- **Base Cadence & 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`).
+  - Quiescent Check 3 (Streak 3): 120 minutes (`DurationSeconds=7200`).
+  - Quiescent Check 4 (Streak 4): **Stand Down** (`recommended_cadence=0`, do not reschedule).
+- **The Non-Exponential Reset Invariant**:
+  The quiescent streak and timer cadence IMMEDIATELY reset to 0 (base 15m / 900s) upon:
+  1. Any listener failure or missing process (`ACTION_REQUIRED: REARM_LISTENER`).
+  2. Any unread inbox backlog (`ACTION_REQUIRED: UNREAD_MESSAGES`).
+  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=...)`.
-- **Debounce Triggers (Early and Often)**:
-  Run the debouncer subroutine on:
-  1. Task Dispatch (`rhizo send`, `rhizo enqueue`).
-  2. Worker Message / Gate Report receipt.
-  3. Implementation Plan updates (`implementation_plan.md` checkboxes).
-  4. Watchdog Wakeup turn (if tasks are still in flight).
-- **Stand Down Invariant**:
-  When all tasks in `implementation_plan.md` are complete (`- [x]` 100%), kill any running watchdog timer and do not reschedule.
+- **Stand Down Invariants**:
+  1. When all tasks in `implementation_plan.md` are complete (`- [x]` 100%), kill 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 a full 15 minutes.
+  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)**:
   Run `rhizo watchdog check --agent <name> --json`.
-  * If `ACTION_REQUIRED: REARM_LISTENER`: start `rhizo listen <name>` in background and debounce timer.
-  * If `ACTION_REQUIRED: UNREAD_MESSAGES`: drain messages with `rhizo drain 10 <name>`, start listener, and debounce.
-  * If `OK: LISTENING`: listener is healthy; debounce timer and return to sleep.
-  * If `STAND_DOWN: IDLE`: no tasks in flight; stand down.
+  * 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 `STAND_DOWN: MAX_STREAK_REACHED` or `STAND_DOWN: IDLE`: stand down and do NOT reschedule.
 </CRITICAL>
 
 ---