@axiomantic/garden 0.2.0 → 0.2.2

package/README.md

@@ -20,6 +20,15 @@
 
 **Garden** is an agentic engineering framework and skill library for orchestrating heterogeneous teams of AI coding assistants (Claude Code, OpenCode, Antigravity, Cursor, Codex).
 
+> [!NOTE]
+> ### Quick Note: Using Garden as your High-Level Swarm Wrapper
+> **Garden is the sovereign high-level multi-agent wrapper for all your engineering projects.**  
+> After installing `@axiomantic/garden`, `@axiomantic/rhizo`, and `@axiomantic/vine`, you don't need complex shell scripts, background daemon managers, or brittle terminal multiplexers. Whenever you start a session in your favorite coding harness (Antigravity, Claude Code, OpenCode, Cursor), simply tell the assistant:
+> ```text
+> "garden: I want to build [feature/system/project]"
+> ```
+> The session automatically acts as the **Lead Orchestrator**. It conducts a brief interactive intake interview to calibrate your desired team balance, coding harnesses, and model tiers. It then configures your project (`garden.toml` & `garden-swarm.json`) and prints ready-to-copy prompt cards wrapped in **10 backticks** (` ``````````markdown `). You paste these cards into separate terminal tabs or coding harnesses, and Garden coordinates the entire swarm over Rhizo (local Redis message bus) and Vine (isolated Rift copy-on-write workspaces)!
+
 Instead of treating AI agents as isolated single-turn chatbots, Garden provisions **prompt-bootstrapped worker swarms** across your favorite AI coding harnesses (Claude Code, OpenCode, Antigravity, Pi, Cursor), balances specialized personas with designated foundation models, drives **empirically grounded dialectical deliberation**, schedules distributed fencing mutexes, and integrates code through isolated APFS Copy-on-Write strands verified by Vine's Two-Key Gate.
 
 ```mermaid
@@ -153,22 +162,24 @@ In your primary AI coding assistant (Antigravity, Claude Code, OpenCode):
 User: "garden: Implement high-throughput batch claim leases with Redis pipeline support"
 ```
 
-### 2. Interactive Team Calibration (`choose-personas`)
-Garden inspects your repository and suggests a balanced persona roster with recommended harnesses and models:
-- **Marcus Vance** (Staff Systems Architect) $\to$ **Antigravity** | **Gemini 3.8 Flash**
-- **Caleb Thorne** (Refactoring & Code Quality Purist) $\to$ **Claude Code CLI** | **Claude 3 Opus**
-- **Elena Rostova** (DevEx & API Lead) $\to$ **Antigravity** | **Gemini 3.8 Flash**
-
-Confirm or adjust the roster with a single click.
+### 2. Interactive Project Intake Interview (Phase 0)
+The Orchestrator asks 4 quick interactive questions via `ask_question`:
+1. **Execution Mode**: Multi-Agent Swarm (Recommended) vs Single Session.
+2. **Team Sizing**: Standard Triad (3 Workers) vs Focused Duo (2 Workers) vs Custom.
+3. **Available Harnesses**: Claude Code CLI, OpenCode, Antigravity, Pi, Cursor, Terminal.
+4. **Model Preferences & Equivalents**:
+   - Systems Architect (`@architect`) $\to$ **Antigravity** or **OpenCode** | **Gemini 3.8 Flash** or **Claude 3.5 Sonnet**
+   - Adversarial Auditor (`@auditor`) $\to$ **Claude Code CLI** | **Claude 3.5 Sonnet** or **Claude 3 Opus**
+   - DevEx & Implementation Lead (`@implementer`) $\to$ **Antigravity** or **OpenCode** | **Gemini 3.8 Flash**
 
 ### 3. Prompt-Based Swarm Bootstrapping (`launch-workers`)
-Garden generates raw markdown prompt cards wrapped in 10 backticks for each worker:
-```bash
-garden prompts
-```
-- The operator copies and pastes each prompt block into a separate terminal window or coding harness (Claude Code, OpenCode, Antigravity, Pi, Cursor).
-- Each session enters the project directory, sets `RHIZO_AGENT_NAME`, registers on the bus with `rhizo open`, and arms its single-shot listener with `rhizo listen`.
-- The Orchestrator verifies readiness via `rhizo who --json` before dispatching tasks.
+Garden writes `garden-swarm.json` and runs `garden prompts` to emit raw markdown prompt cards wrapped in **10 backticks** (` ``````````markdown `):
+- The Orchestrator tells the operator:
+  1. Open **Tab 1**: Launch `claude` (Claude 3.5 Sonnet) $\to$ Paste Prompt 1 (`@auditor`)
+  2. Open **Tab 2**: Launch `opencode` $\to$ Paste Prompt 2 (`@architect`)
+  3. Open **Tab 3**: Launch `antigravity` (Gemini 3.8 Flash) $\to$ Paste Prompt 3 (`@implementer`)
+- Each session enters the project directory, exports `RHIZO_AGENT_NAME`, registers on the Redis bus (`rhizo open`), and arms its single-shot listener (`rhizo listen`).
+- The Orchestrator confirms all workers are live via `rhizo who --json` before dispatching tasks!
 
 ### 4. The Dialectical Pump (`dialectical-pump`)
 The personas deliberate across three empirical stages:
@@ -187,9 +198,77 @@ The main chat orchestrator dispatches work over Redis. Workers code in isolated
 
 ---
 
+## CLI Reference
+
+| Command | Arguments | Description |
+| :--- | :--- | :--- |
+| `garden prompts` | `[--worker <name>] [--write [file]] [--json] [--project-dir <dir>] [--swarm-file <file>]` | Generate 10-backtick raw markdown prompt cards for pasting into worker sessions. |
+| `garden launch` | `[--worker <name>] [--write [file]] [--json] [--tmux] [--session-name <name>]` | Bootstrap swarm worker sessions (defaults to generating prompt cards). |
+| `garden status` | `[--json] [--session-name <name>]` | Telemetry query across active Rhizo agents, listener status, and Vine strands. |
+| `garden init` | `[<target_dir>] [--force]` | Initialize `garden.toml`, docs scaffold, and install guide in `AGENTS.md`. |
+| `garden teardown`| `[--session-name <name>] [--swarm-file <file>]` | Gracefully close registered swarm agents on the Redis bus. |
+| `garden guide` | `<install\|check\|uninstall> [path]` | Install or manage Garden Multi-Agent Swarm Guide in `AGENTS.md`. |
+
+---
+
+## Configuration & Swarm Manifest Reference
+
+> [!TIP]
+> For the complete specification of `garden.toml`, `garden-swarm.json` schemas, and environment variables, see the [Garden Configuration & Swarm Manifest Reference](docs/configuration.md).
+
+### Environment Variables
+
+| Variable | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `GARDEN_SWARM_FILE` | Path | `garden-swarm.json` | Explicit path to swarm manifest JSON file. |
+| `GARDEN_CONFIG` | Path | `garden.toml` | Explicit path to project `garden.toml`. |
+| `GARDEN_PROJECT_DIR`| Path | *Auto-detected* | Target repository root directory. |
+| `GARDEN_TERMINAL_APP`| String | `auto` | Preferred terminal viewer for tmux sessions (`Ghostty`, `Terminal`, `iTerm`, `none`). |
+
+### Example `garden-swarm.json`
+
+```json
+{
+  "project": "myproject",
+  "target_repo": "/Users/developer/Development/myproject",
+  "orchestrator": "orchestrator",
+  "workers": [
+    {
+      "name": "architect",
+      "persona": "Dr. Marcus Vance (Systems Architect)",
+      "role": "Systems Architect & Formal Invariant Specifier",
+      "harness": "Claude Code",
+      "model": "claude-3-5-sonnet",
+      "tags": ["design", "spec"],
+      "opposing_priority": "Formal mathematical correctness and zero architectural drift."
+    },
+    {
+      "name": "auditor",
+      "persona": "Lyra Sterling (Adversarial Quality Auditor)",
+      "role": "Adversarial Code Reviewer & Security Auditor",
+      "harness": "OpenCode",
+      "model": "gemini-3.8-flash",
+      "tags": ["audit", "testing"],
+      "opposing_priority": "Aggressive edge-case fault injection and invariant verification."
+    },
+    {
+      "name": "implementer",
+      "persona": "Elena Rostova (Lead Implementation Engineer)",
+      "role": "Polyglot Systems & Performance Engineer",
+      "harness": "Antigravity",
+      "model": "claude-3-5-sonnet",
+      "tags": ["implementation", "perf"],
+      "opposing_priority": "Rapid implementation velocity and minimal dependency footprint."
+    }
+  ]
+}
+```
+
+---
+
 ## Core Invariants
 
-1. **The Supreme Orchestrator Invariant**:
+1. **The Lead Orchestrator Invariant**:
    The main chat session coordinates, reviews, and integrates. Intensive multi-file edits are executed by the worker fleet in isolated strands.
 2. **Empirical Grounding Protocol (Zero Theatrical Dialogue)**:
    Dialectical deliberations must cite hard evidence from real tool calls (line citations, test outputs, compiler errors). Theatrical roleplay is strictly banned.

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: garden
-description: "Master entrypoint and end-to-end ceremony director for multi-agent swarms operating on top of Rhizo (transport) and Vine (workspace integrator). Guides the user and orchestrator session through the full lifecycle: persona selection with harness/model pairing, prompt-based worker fleet bootstrapping with 10-backtick copy-paste prompt cards, 3-stage empirical dialectical pump (research, design, audit), master implementation planning with locking/strand schedules, and live swarm execution with Two-Key gate verification and fast-forward trunk weaving. Triggers: 'garden', 'run garden', 'swarm this project', 'orchestrate with garden', 'start garden swarm', 'run the full garden ceremony'."
+description: "Master entrypoint and end-to-end ceremony director for multi-agent swarms operating on top of Rhizo (transport) and Vine (workspace integrator). Guides the user and orchestrator session through the full lifecycle: conversational project intake interview, persona selection with harness/model pairing, prompt-based worker fleet bootstrapping with 10-backtick copy-paste prompt cards, 3-stage empirical dialectical pump (research, design, audit), master implementation planning with locking/strand schedules, and live swarm execution with Two-Key gate verification and fast-forward trunk weaving. Triggers: 'garden', 'run garden', 'swarm this project', 'orchestrate with garden', 'start garden swarm', 'run the full garden ceremony', 'start a project with garden', 'start a project with rhizo', 'set up a multi-agent team', 'use rhizo for this project', 'set up a swarm', 'coordinate multiple agents on this project', 'set up agents for this project'."
 ---
 
 # Garden: Multi-Agent Swarm Ceremony & Orchestration Engine
@@ -24,8 +24,9 @@ Garden directs multi-agent swarms using Rhizo for transport and Vine for workspa
 ```mermaid
 flowchart TD
     subgraph Garden["Garden Layer (Methodology & Ceremonies)"]
-        Phase1["Phase 1: choose-personas (Team Selection & Models)"]
-        Phase2["Phase 2: launch-workers (Prompt-Based Session Bootstrapping)"]
+        Phase0["Phase 0: Interactive Intake Interview (Scope, Team & Models)"]
+        Phase1["Phase 1: choose-personas (Ratify garden-swarm.json)"]
+        Phase2["Phase 2: launch-workers (10-Backtick Prompt Cards & Sessions)"]
         Phase3["Phase 3: dialectical-pump (Research ➔ Design ➔ Audit)"]
         Phase4["Phase 4: plan-implementation (Locking & Strands)"]
         Phase5["Phase 5: orchestrate-swarm (Dispatch & Vine Weaving)"]
@@ -36,7 +37,7 @@ flowchart TD
         Vine["Vine (Rift Strands, Two-Key Gate, Weaving)"]
     end
 
-    Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5
+    Phase0 --> Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5
     Phase2 -.-> Rhizo
     Phase3 -.-> Rhizo
     Phase4 -.-> Rhizo & Vine
@@ -45,24 +46,61 @@ flowchart TD
 
 ---
 
-## 2. The 5-Phase End-to-End Ceremony
+## 2. The End-to-End Ceremony Workflow
 
-Execute all five phases sequentially. Never skip phases or invert the order.
+Execute phases sequentially. Never skip phases or invert the order.
 
-| Phase | Sub-Skill | Action | Quality Gate to Proceed |
+| Phase | Sub-Skill / Step | Action | Quality Gate to Proceed |
 | :--- | :--- | :--- | :--- |
-| **Phase 1** | [`choose-personas`](../choose-personas/SKILL.md) | Formulate 3 balanced personas with harness/model pairings. | Operator ratifies `garden-swarm.json`. |
-| **Phase 2** | [`launch-workers`](../launch-workers/SKILL.md) | Generate 10-backtick worker prompt cards for operator pasting into sessions. | `rhizo who --json` confirms 100% of workers active. |
+| **Phase 0** | **Intake Gate** | Conduct interactive interview via `ask_question`: execution mode, swarm size, harnesses, and models. | Operator submits preferences. |
+| **Phase 1** | [`choose-personas`](../choose-personas/SKILL.md) | Synthesize and write `garden-swarm.json` reflecting the interview. | Valid JSON written to repo root. |
+| **Phase 2** | [`launch-workers`](../launch-workers/SKILL.md) | Output 10-backtick raw markdown prompt cards and numbered session instructions. | `rhizo who --json` confirms 100% of workers active & listening. |
 | **Phase 3** | [`dialectical-pump`](../dialectical-pump/SKILL.md) | Grounded triadic deliberation: research, design, adversarial audit. | Zero open `CRIT` or `BLOCKER` defects in `audit_report.md`. |
 | **Phase 4** | [`plan-implementation`](../plan-implementation/SKILL.md) | Author master implementation plan with locking schedules and strands. | Complete `implementation_plan.md` with task-locking matrix. |
 | **Phase 5** | [`orchestrate-swarm`](../orchestrate-swarm/SKILL.md) | Main-chat governor: task dispatch, heartbeat monitoring, trunk weaving. | All plan tasks woven via `vine weave` after passing Two-Key Gate. |
 
 ---
 
+### Phase 0: Interactive Project Intake & Swarm Calibration
+
+When an operator initiates a project or requests multi-agent coordination, the session MUST NOT silently guess configuration or begin writing code directly. It immediately invokes `ask_question` to conduct the **Interactive Intake Interview**:
+
+1. **Question 1: Execution Mode**:
+   - *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 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).
+     - *Air-gapped / Local*: Ollama / DeepSeek-R1.
+
+#### Automatic Fulfillment & 10-Backtick Prompt Generation:
+Upon receiving the operator's responses:
+1. Run `garden init` if `garden.toml` or `AGENTS.md` is not yet initialized.
+2. Generate `garden-swarm.json` reflecting the chosen workers, roles, harnesses, and models.
+3. Run `garden prompts` to generate the raw markdown prompt cards wrapped in **10 backticks** (` ``````````markdown `).
+4. Present the operator with clear, numbered instructions:
+   ```text
+   1. Open X terminal tabs or windows in your selected coding harnesses.
+   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.
+6. Poll or await cluster readiness gate (`rhizo who --json`) before proceeding to Phase 3.
+
+---
+
 ## 3. Core Operational Invariants
 
 <CRITICAL>
-The primary conversation session acts as the Supreme Orchestrator. The orchestrator directs, reviews, and weaves; it never performs large multi-file implementation edits directly when a worker fleet is active.
+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>
 
 <INVARIANT>
@@ -102,3 +140,19 @@ 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.
+
+---
+
+## 5. Configuration & Swarm Manifest Reference
+
+See [`docs/configuration.md`](../../docs/configuration.md) for full details on:
+- **Environment Variables**: `GARDEN_SWARM_FILE`, `GARDEN_CONFIG`, `GARDEN_PROJECT_DIR`, and `GARDEN_TERMINAL_APP`.
+- **`garden.toml`**: Project-level defaults (`name`, `preferred_terminal`, `session_prefix`, `default_triad`).
+- **`garden-swarm.json`**: Swarm specification schema (`project`, `target_repo`, `orchestrator`, `shared_workspace`, `workers` array: `name`, `persona`, `role`, `harness`, `model`, `tags`, `system_prompt`, `opposing_priority`).
+- **The 10-Backtick Protocol**: Clean raw markdown formatting for copy-paste worker bootstrap prompts.
+
+

package/package.json

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

package/skills/choose-personas/SKILL.md

@@ -97,36 +97,38 @@ 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",
   "workers": [
     {
       "name": "architect",
       "persona": "Marcus Vance",
       "role": "Staff Systems Architect",
-      "harness": "antigravity",
-      "model": "gemini-3-8-flash",
-      "tags": ["systems", "architecture", "coordinator"],
-      "system_prompt": "You are Marcus Vance, Staff Systems Architect...",
-      "startup_command": "rhizo listen architect"
+      "harness": "Antigravity / OpenCode",
+      "model": "Gemini 3.8 Flash / Claude 3.5 Sonnet",
+      "tags": ["my-project", "systems", "architecture", "invariants"],
+      "system_prompt": "You are Marcus Vance, Staff Systems Architect for project my-project...",
+      "opposing_priority": "Structural purity, invariant guarantees, and long-term maintainability over hasty quick fixes."
     },
     {
       "name": "auditor",
       "persona": "Caleb Thorne",
-      "role": "Code Quality & Refactoring Purist",
-      "harness": "claude-code",
-      "model": "claude-3-5-sonnet",
-      "tags": ["qa", "audit", "purist"],
-      "system_prompt": "You are Caleb Thorne, Refactoring Purist...",
-      "startup_command": "claude --agent auditor"
+      "role": "Verification & Adversarial Auditor",
+      "harness": "Claude Code CLI / Antigravity",
+      "model": "Claude 3.5 Sonnet / Claude 3 Opus",
+      "tags": ["my-project", "qa", "audit", "verifier", "purist"],
+      "system_prompt": "You are Caleb Thorne, Verification & Adversarial Auditor for project my-project...",
+      "opposing_priority": "Adversarial skepticism, rigorous negative controls, and proof over convenience."
     },
     {
       "name": "implementer",
       "persona": "Elena Rostova",
       "role": "DevEx & Implementation Lead",
-      "harness": "antigravity",
-      "model": "gemini-3-8-flash",
-      "tags": ["dev", "devex", "build"],
-      "system_prompt": "You are Elena Rostova, DevEx Lead...",
-      "startup_command": "rhizo listen implementer"
+      "harness": "Antigravity / OpenCode",
+      "model": "Gemini 3.8 Flash / Claude 3.5 Sonnet",
+      "tags": ["my-project", "dev", "devex", "build", "implementation"],
+      "system_prompt": "You are Elena Rostova, DevEx & Implementation Lead for project my-project...",
+      "opposing_priority": "High-velocity implementation, pragmatic delivery, and developer ergonomics."
     }
   ]
 }
@@ -134,9 +136,12 @@ Once ratified, write `garden-swarm.json` to the target project directory:
 
 ---
 
-## 4. Verification & Handoff
+## 4. Verification & Automatic Prompt Generation Handoff
 
 Before concluding:
 1. Verify `garden-swarm.json` is syntactically valid JSON.
 2. Confirm each worker has unique `name` and non-empty `tags`.
-3. Proceed directly to [`launch-workers`](../launch-workers/SKILL.md).
+3. Proceed directly to [`launch-workers`](../launch-workers/SKILL.md):
+   - Call `garden prompts` to generate the 10-backtick raw markdown blocks.
+   - Present the operator with numbered terminal tab setup instructions.
+   - Await cluster readiness verification via `rhizo who --json`.

package/skills/garden/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: garden
-description: "Master entrypoint and end-to-end ceremony director for multi-agent swarms operating on top of Rhizo (transport) and Vine (workspace integrator). Guides the user and orchestrator session through the full lifecycle: persona selection with harness/model pairing, prompt-based worker fleet bootstrapping with 10-backtick copy-paste prompt cards, 3-stage empirical dialectical pump (research, design, audit), master implementation planning with locking/strand schedules, and live swarm execution with Two-Key gate verification and fast-forward trunk weaving. Triggers: 'garden', 'run garden', 'swarm this project', 'orchestrate with garden', 'start garden swarm', 'run the full garden ceremony'."
+description: "Master entrypoint and end-to-end ceremony director for multi-agent swarms operating on top of Rhizo (transport) and Vine (workspace integrator). Guides the user and orchestrator session through the full lifecycle: conversational project intake interview, persona selection with harness/model pairing, prompt-based worker fleet bootstrapping with 10-backtick copy-paste prompt cards, 3-stage empirical dialectical pump (research, design, audit), master implementation planning with locking/strand schedules, and live swarm execution with Two-Key gate verification and fast-forward trunk weaving. Triggers: 'garden', 'run garden', 'swarm this project', 'orchestrate with garden', 'start garden swarm', 'run the full garden ceremony', 'start a project with garden', 'start a project with rhizo', 'set up a multi-agent team', 'use rhizo for this project', 'set up a swarm', 'coordinate multiple agents on this project', 'set up agents for this project'."
 ---
 
 # Garden: Multi-Agent Swarm Ceremony & Orchestration Engine
@@ -24,8 +24,9 @@ Garden directs multi-agent swarms using Rhizo for transport and Vine for workspa
 ```mermaid
 flowchart TD
     subgraph Garden["Garden Layer (Methodology & Ceremonies)"]
-        Phase1["Phase 1: choose-personas (Team Selection & Models)"]
-        Phase2["Phase 2: launch-workers (Prompt-Based Session Bootstrapping)"]
+        Phase0["Phase 0: Interactive Intake Interview (Scope, Team & Models)"]
+        Phase1["Phase 1: choose-personas (Ratify garden-swarm.json)"]
+        Phase2["Phase 2: launch-workers (10-Backtick Prompt Cards & Sessions)"]
         Phase3["Phase 3: dialectical-pump (Research ➔ Design ➔ Audit)"]
         Phase4["Phase 4: plan-implementation (Locking & Strands)"]
         Phase5["Phase 5: orchestrate-swarm (Dispatch & Vine Weaving)"]
@@ -36,7 +37,7 @@ flowchart TD
         Vine["Vine (Rift Strands, Two-Key Gate, Weaving)"]
     end
 
-    Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5
+    Phase0 --> Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5
     Phase2 -.-> Rhizo
     Phase3 -.-> Rhizo
     Phase4 -.-> Rhizo & Vine
@@ -45,24 +46,61 @@ flowchart TD
 
 ---
 
-## 2. The 5-Phase End-to-End Ceremony
+## 2. The End-to-End Ceremony Workflow
 
-Execute all five phases sequentially. Never skip phases or invert the order.
+Execute phases sequentially. Never skip phases or invert the order.
 
-| Phase | Sub-Skill | Action | Quality Gate to Proceed |
+| Phase | Sub-Skill / Step | Action | Quality Gate to Proceed |
 | :--- | :--- | :--- | :--- |
-| **Phase 1** | [`choose-personas`](../choose-personas/SKILL.md) | Formulate 3 balanced personas with harness/model pairings. | Operator ratifies `garden-swarm.json`. |
-| **Phase 2** | [`launch-workers`](../launch-workers/SKILL.md) | Generate 10-backtick worker prompt cards for operator pasting into sessions. | `rhizo who --json` confirms 100% of workers active. |
+| **Phase 0** | **Intake Gate** | Conduct interactive interview via `ask_question`: execution mode, swarm size, harnesses, and models. | Operator submits preferences. |
+| **Phase 1** | [`choose-personas`](../choose-personas/SKILL.md) | Synthesize and write `garden-swarm.json` reflecting the interview. | Valid JSON written to repo root. |
+| **Phase 2** | [`launch-workers`](../launch-workers/SKILL.md) | Output 10-backtick raw markdown prompt cards and numbered session instructions. | `rhizo who --json` confirms 100% of workers active & listening. |
 | **Phase 3** | [`dialectical-pump`](../dialectical-pump/SKILL.md) | Grounded triadic deliberation: research, design, adversarial audit. | Zero open `CRIT` or `BLOCKER` defects in `audit_report.md`. |
 | **Phase 4** | [`plan-implementation`](../plan-implementation/SKILL.md) | Author master implementation plan with locking schedules and strands. | Complete `implementation_plan.md` with task-locking matrix. |
 | **Phase 5** | [`orchestrate-swarm`](../orchestrate-swarm/SKILL.md) | Main-chat governor: task dispatch, heartbeat monitoring, trunk weaving. | All plan tasks woven via `vine weave` after passing Two-Key Gate. |
 
 ---
 
+### Phase 0: Interactive Project Intake & Swarm Calibration
+
+When an operator initiates a project or requests multi-agent coordination, the session MUST NOT silently guess configuration or begin writing code directly. It immediately invokes `ask_question` to conduct the **Interactive Intake Interview**:
+
+1. **Question 1: Execution Mode**:
+   - *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 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).
+     - *Air-gapped / Local*: Ollama / DeepSeek-R1.
+
+#### Automatic Fulfillment & 10-Backtick Prompt Generation:
+Upon receiving the operator's responses:
+1. Run `garden init` if `garden.toml` or `AGENTS.md` is not yet initialized.
+2. Generate `garden-swarm.json` reflecting the chosen workers, roles, harnesses, and models.
+3. Run `garden prompts` to generate the raw markdown prompt cards wrapped in **10 backticks** (` ``````````markdown `).
+4. Present the operator with clear, numbered instructions:
+   ```text
+   1. Open X terminal tabs or windows in your selected coding harnesses.
+   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.
+6. Poll or await cluster readiness gate (`rhizo who --json`) before proceeding to Phase 3.
+
+---
+
 ## 3. Core Operational Invariants
 
 <CRITICAL>
-The primary conversation session acts as the Supreme Orchestrator. The orchestrator directs, reviews, and weaves; it never performs large multi-file implementation edits directly when a worker fleet is active.
+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>
 
 <INVARIANT>
@@ -102,3 +140,19 @@ 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.
+
+---
+
+## 5. Configuration & Swarm Manifest Reference
+
+See [`docs/configuration.md`](../../docs/configuration.md) for full details on:
+- **Environment Variables**: `GARDEN_SWARM_FILE`, `GARDEN_CONFIG`, `GARDEN_PROJECT_DIR`, and `GARDEN_TERMINAL_APP`.
+- **`garden.toml`**: Project-level defaults (`name`, `preferred_terminal`, `session_prefix`, `default_triad`).
+- **`garden-swarm.json`**: Swarm specification schema (`project`, `target_repo`, `orchestrator`, `shared_workspace`, `workers` array: `name`, `persona`, `role`, `harness`, `model`, `tags`, `system_prompt`, `opposing_priority`).
+- **The 10-Backtick Protocol**: Clean raw markdown formatting for copy-paste worker bootstrap prompts.
+
+

package/skills/launch-workers/SKILL.md

@@ -79,13 +79,25 @@ If `garden-swarm.json` exists in the repository, Garden uses its configured pers
 - `@implementer` (Elena Rostova - DevEx & Implementation Lead)
 
 ### Step 2: Present & Paste Prompts into Sessions
-The operator opens a separate terminal window, tab, or harness session for each worker, then copies and pastes the corresponding raw block from the 10-backtick pre block.
-
-Each prompt immediately instructs the agent to:
-1. `cd "<project_dir>"`
-2. `export RHIZO_AGENT_NAME="<name>"`
-3. `rhizo open "<name>" "<tags>"`
-4. `rhizo listen "<name>"` (blocking until the Orchestrator delivers a task)
+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
+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**:
+   Ensure every prompt card is displayed inside ` ``````````markdown ` fences so the operator can copy the clean, unrendered text with a single click.
+4. **Immediate Autonomous Onboarding**:
+   Each prompt instructs the pasted session to immediately:
+   - `cd "<project_dir>"`
+   - `export RHIZO_AGENT_NAME="<name>"`
+   - `rhizo open "<name>" "<tags>"`
+   - `rhizo listen "<name>"` (blocking foreground command with infinite wait)
+5. **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
 Before dispatching tasks, verify that every worker has registered in Redis and is showing active heartbeats:

package/skills/orchestrate-swarm/SKILL.md

@@ -1,18 +1,18 @@
 ---
 name: orchestrate-swarm
-description: "Directs live multi-agent swarm execution from the primary chat session acting as Supreme Orchestrator. Dispatches tasks over the Rhizo Redis bus, monitors worker heartbeats with rhizo who, governs task leasing and dead-letter queues, ratifies emergent design addenda, verifies Two-Key Gate reports from workers, executes fast-forward trunk merges via vine weave, and dynamically maintains implementation plan checkboxes and harness To-Do tools. Triggers: 'orchestrate swarm', 'run implementation plan', 'execute swarm tasks', 'manage workers', 'drive plan'."
+description: "Directs live multi-agent swarm execution from the primary chat session acting as Lead Orchestrator. Dispatches tasks over the Rhizo Redis bus, monitors worker heartbeats with rhizo who, governs task leasing and dead-letter queues, ratifies emergent design addenda, verifies Two-Key Gate reports from workers, executes fast-forward trunk merges via vine weave, and dynamically maintains implementation plan checkboxes and harness To-Do tools. Triggers: 'orchestrate swarm', 'run implementation plan', 'execute swarm tasks', 'manage workers', 'drive plan'."
 ---
 
 # `orchestrate-swarm`: Main-Chat Swarm Governance & Trunk Integration
 
 > **The Sovereign Conductor of Autonomous Execution**  
-> *The Supreme Orchestrator does not write the low-level code lines; it directs the symphony. It dispatches work over Redis, unblocks dependencies, enforces the Two-Key Gate, and weaves clean strands into the trunk.*
+> *The Lead Orchestrator does not write the low-level code lines; it directs the symphony. It dispatches work over Redis, unblocks dependencies, enforces the Two-Key Gate, and weaves clean strands into the trunk.*
 
 ---
 
-## 1. The Role of the Supreme Orchestrator
+## 1. The Role of the Lead Orchestrator
 
-The main chat session assumes the role of **Supreme Orchestrator**:
+The main chat session assumes the role of **Lead Orchestrator**:
 - **Non-Interference**: Never perform massive multi-file edits directly when workers are active in isolated strands.
 - **Strict Transport Discipline**: All task assignments, handoffs, and cancellation interrupts flow exclusively over the Rhizo Redis bus (`rhizo send`, `rhizo reply`, `rhizo enqueue`).
 - **Gated Integration**: Never run `git merge` directly. Only weave branches that have passed both Key 1 (mechanical merge-tree) and Key 2 (live compiler/tests) inside their Vine strands.
@@ -23,7 +23,7 @@ Whenever context summarization or compaction occurs, the coding harness MUST pre
 
 Maintain this exact block in the working context:
 <!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
-- AGENT_NAME: <codename> (Role: Supreme Orchestrator)
+- AGENT_NAME: <codename> (Role: Lead Orchestrator)
 - WORKSPACE_MODE: Root Trunk (/Users/eek/Development/<project>)
 - ACTIVE_STRAND: canonical trunk
 - ACTIVE_PEERS:
@@ -33,6 +33,38 @@ Maintain this exact block in the working context:
 <!-- END_SWARM_RUNTIME_STATE -->
 </CRITICAL>
 
+<CRITICAL>
+Orchestrator Turn-End Listener Invariant (GVR-014):
+Coding harnesses (Antigravity, Claude Code, OpenCode) are event-driven: when the model yields a turn with text output, execution is completely suspended. Redis inbox state changes CANNOT wake an idle harness without an active child process registered in the task manager.
+
+Whenever the Lead Orchestrator dispatches a task, broadcasts instructions, or awaits worker responses, THE FINAL ACTION OF THAT TURN MUST BE ARMING A BACKGROUND LISTENER:
+`run_command(CommandLine="rhizo listen <orchestrator>", IsDaemon=false, WaitMsBeforeAsync=500)`
+
+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):
+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.
+- **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.
+- **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.
+- **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.
+</CRITICAL>
+
 ---
 
 ## 2. The Runtime Governance Loop
@@ -75,12 +107,30 @@ Depending on the task distribution model in `implementation_plan.md`:
     --body '{"task_id": "task-test-harness", "strand": "strand/task-test-harness"}'
   ```
 
+- **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)
+  ```
+  *(Never end your turn without this active background task; without it, worker gate reports cannot wake you up).*
+
 ### SOP 2: Monitoring Swarm Health, Watchdog & Escalation (GVR-011)
 Check active workers and cluster status:
 ```bash
 rhizo who --json
 ```
 
+#### Orchestrator Self-Audit Watchdog
+Verify that the orchestrator itself is actively listening while tasks are in-flight:
+```bash
+rhizo watchdog check [--agent <orchestrator>] [--json]
+```
+Returns:
+- `status: OK (LISTENING)`: Listener process active and healthy.
+- `status: ACTION_REQUIRED (REARM_LISTENER)`: In-flight tasks exist but listener is dead/missing. Re-arm immediately.
+- `status: ACTION_REQUIRED (UNREAD_MESSAGES)`: Unconsumed inbox messages waiting. Drain immediately.
+- `status: STAND_DOWN (IDLE)`: Zero in-flight tasks and zero unread messages. Stand down.
+
 #### Responsiveness Watchdog & Health Probing
 When waiting for a worker to finish an assigned task, run a health probe if no message is received within the expected window (e.g. 5–10 minutes):
 ```bash
@@ -93,7 +143,7 @@ The probe returns:
 
 #### Operator Escalation Protocol
 If `rhizo probe` indicates a stalled or dead worker (`NO_LISTENER` or `STALE` with unread inbox messages):
-1. **Never Hang Silently**: The Supreme Orchestrator must immediately surface an escalation to the operator via `ask_question`.
+1. **Never Hang Silently**: The Lead Orchestrator must immediately surface an escalation to the operator via `ask_question`.
 2. **Present Diagnostic**:
    - Alert: `⚠️ SWARM STALL DETECTED: @<worker> has not responded to <subject>`
    - Diagnostic: `Inbox: N unread | Listener: NO_LISTENER | Status: STALE`