@axiomantic/garden 0.1.6 → 0.2.1

package/README.md

@@ -5,9 +5,9 @@
 **Multi-Agent Swarm Orchestration, Empirical Dialectics & Ceremonies on top of Rhizo & Vine**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![tmux](https://img.shields.io/badge/tmux-3.0%2B-green.svg)](https://github.com/tmux/tmux)
-[![Rhizo](https://img.shields.io/badge/Rhizo-0.1.3%2B-red.svg)](https://github.com/axiomantic/rhizo)
-[![Vine](https://img.shields.io/badge/Vine-0.1.0%2B-purple.svg)](https://github.com/axiomantic/vine)
+[![Rhizo](https://img.shields.io/badge/Rhizo-0.2.1%2B-red.svg)](https://github.com/axiomantic/rhizo)
+[![Vine](https://img.shields.io/badge/Vine-0.2.0%2B-purple.svg)](https://github.com/axiomantic/vine)
+[![Swarm](https://img.shields.io/badge/Swarm-Prompt--Bootstrapped-brightgreen.svg)](README.md)
 [![Platform](https://img.shields.io/badge/Platform-macOS%20%7C%20Linux-blue.svg)](README.md)
 
 *Where `rhizo` provides inter-agent transport and `vine` provides workspace virtualization, `garden` provides the institutional intellect, empirical deliberation, and synchronized swarm execution.*
@@ -20,7 +20,7 @@
 
 **Garden** is an agentic engineering framework and skill library for orchestrating heterogeneous teams of AI coding assistants (Claude Code, OpenCode, Antigravity, Cursor, Codex).
 
-Instead of treating AI agents as isolated single-turn chatbots, Garden provisions **coordinated worker swarms** inside multiplexed `tmux` sessions, balances specialized personas with designated foundation models and harnesses, 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.
+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
 flowchart TD
@@ -28,7 +28,7 @@ flowchart TD
         direction TB
         GardenSkill["garden (Master Entrypoint)"]
         P1["choose-personas (Team & Models)"]
-        P2["launch-workers (tmux & Terminal Viewer)"]
+        P2["launch-workers (Prompt-Based Session Bootstrapping)"]
         P3["dialectical-pump (Research ➔ Design ➔ Audit)"]
         P4["plan-implementation (Locks & Strands)"]
         P5["orchestrate-swarm (Dispatch & Weave)"]
@@ -62,19 +62,19 @@ Garden is organized into a clean, batteries-included catalog of self-explanatory
 | :--- | :--- | :--- |
 | **[`garden`](skills/garden/SKILL.md)** | **Master Entrypoint** | The sovereign ceremony director. Guides orchestrator and operator step-by-step across all phases from initial task to woven code. |
 | **[`choose-personas`](skills/choose-personas/SKILL.md)** | **Team Calibration** | Formulates a balanced triad of specialized personas (e.g. Architect, Auditor, DevEx Lead) with explicitly recommended **coding harnesses** and **model tiers**, confirmed interactively with the operator. |
-| **[`launch-workers`](skills/launch-workers/SKILL.md)** | **Fleet Provisioning** | Boots a structured `tmux` session with named worker panes, injects environment variables, registers identities via `rhizo open`, arms listeners, and pops open your preferred OS terminal viewer (Ghostty / Terminal.app). |
+| **[`launch-workers`](skills/launch-workers/SKILL.md)** | **Session Bootstrapping** | Generates self-contained, 10-backtick raw markdown prompt cards for pasting into separate terminal sessions (Claude Code, OpenCode, Antigravity, Pi). Configures environment variables, registers identities via `rhizo open`, and arms single-shot listeners. |
 | **[`dialectical-pump`](skills/dialectical-pump/SKILL.md)** | **Empirical Deliberation** | Drives multi-perspective thesis/antithesis/synthesis debates. Strictly prohibits theatrical roleplay: every turn requires tool execution (reading files, running tests, checking ASTs). Produces `understanding.md`, `design.md`, and `audit_report.md`. |
 | **[`plan-implementation`](skills/plan-implementation/SKILL.md)** | **Master Scheduling** | Authors `implementation_plan.md` defining task assignment matrices, `rhizo` distributed fencing locks, `vine` strand workflows, dynamic markdown checkboxes, harness To-Do integration, and emergent design addenda. |
 | **[`orchestrate-swarm`](skills/orchestrate-swarm/SKILL.md)** | **Main-Chat Governor** | Governs execution from the primary chat session: dispatches tasks over Redis, tracks heartbeats, ratifies emergent design addenda, verifies Two-Key gate passes, and triggers `vine weave`. |
 
 ## Standalone Yet Designed for the Axiomantic Triad
 
-Garden is completely standalone and can direct multi-agent dialectics, persona selection, and tmux worker swarms on any codebase.
+Garden is completely standalone and can direct multi-agent dialectics, persona selection, and prompt-bootstrapped worker swarms on any codebase.
 
 However, Garden is designed from the ground up to pair seamlessly with **Rhizo** and **Vine**:
 - [**Rhizo**](https://github.com/axiomantic/rhizo) (Transport & Concurrency): Inter-agent messaging bus, monotonic fencing locks, and task queues over Redis.
 - [**Vine**](https://github.com/axiomantic/vine) (Workspaces & Verification): Sub-second APFS Copy-on-Write strands, polyglot build-cache normalization, and the Two-Key integration gate (`git merge-tree` mechanical + compiler/test suite semantic checks).
-- **Garden** (Swarm Ceremonies): Tmux worker fleet provisioning, 3-stage empirical dialectical pump (research, architecture, audit), and master ceremonial implementation planning.
+- **Garden** (Swarm Ceremonies): Prompt-based worker session bootstrapping, 3-stage empirical dialectical pump (research, architecture, audit), and master ceremonial implementation planning.
 
 ---
 
@@ -127,22 +127,20 @@ garden guide install
 
 ## System Prerequisites
 
-1. **`tmux`** (3.0+):
-   ```bash
-   brew install tmux
-   ```
-2. **`rhizo`** (Coordination Engine):
+1. **`rhizo`** (Coordination Engine):
    ```bash
    npm install -g @axiomantic/rhizo
    ```
-3. **`vine`** (Workspace Virtualization Engine):
+2. **`vine`** (Workspace Virtualization Engine):
    ```bash
-   npm install -g @axiomantic/vine
+   npm install -g @axiomantic/vine rift-snapshot
    ```
-4. **Redis or Valkey** (local or remote):
+3. **Redis or Valkey** (local or remote):
    ```bash
    brew install redis && brew services start redis
    ```
+4. **`tmux`** (Optional):
+   Only required if explicitly running legacy headless panes via `garden launch --tmux`.
 
 ---
 
@@ -163,12 +161,14 @@ Garden inspects your repository and suggests a balanced persona roster with reco
 
 Confirm or adjust the roster with a single click.
 
-### 3. Automatic Fleet Provisioning (`launch-workers`)
-Garden executes [`scripts/launch_tmux_swarm.sh`](scripts/launch_tmux_swarm.sh):
-- Creates tmux session `garden-<project>` with dedicated panes for each worker.
-- Sets environment variables and registers each agent via `rhizo open`.
-- Arms background listeners (`rhizo listen`).
-- Automatically pops open a visible **Ghostty** or **Terminal.app** window on macOS so you can watch the swarm running live.
+### 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.
 
 ### 4. The Dialectical Pump (`dialectical-pump`)
 The personas deliberate across three empirical stages:
@@ -187,6 +187,74 @@ 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**:

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, tmux worker fleet provisioning with live terminal viewer, 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: 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'."
 ---
 
 # Garden: Multi-Agent Swarm Ceremony & Orchestration Engine
@@ -25,7 +25,7 @@ Garden directs multi-agent swarms using Rhizo for transport and Vine for workspa
 flowchart TD
     subgraph Garden["Garden Layer (Methodology & Ceremonies)"]
         Phase1["Phase 1: choose-personas (Team Selection & Models)"]
-        Phase2["Phase 2: launch-workers (tmux & Terminal Viewer)"]
+        Phase2["Phase 2: launch-workers (Prompt-Based Session Bootstrapping)"]
         Phase3["Phase 3: dialectical-pump (Research ➔ Design ➔ Audit)"]
         Phase4["Phase 4: plan-implementation (Locking & Strands)"]
         Phase5["Phase 5: orchestrate-swarm (Dispatch & Vine Weaving)"]
@@ -52,7 +52,7 @@ Execute all five phases sequentially. Never skip phases or invert the order.
 | Phase | Sub-Skill | 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) | Provision tmux session, register agents, launch viewer. | `rhizo who --json` confirms 100% of workers active. |
+| **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 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. |
@@ -76,3 +76,40 @@ Never merge code into the canonical trunk without a verified Two-Key Gate pass (
 <FORBIDDEN>
 Never stage coordination metadata (*.lock, .rhizo.*, .vine.json, workspaces/) into Git. Keep all agent state ignored.
 </FORBIDDEN>
+
+<CRITICAL>
+Compaction Preservation Rider (GVR-010):
+Whenever context summarization or compaction occurs, the coding harness MUST preserve the `SWARM_RUNTIME_STATE` block verbatim in the compacted summary preamble so the agent immediately retains its operational identity, assigned workspace, peers, and active listeners without operator re-prompting.
+
+Maintain this exact block in the working context:
+<!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
+- AGENT_NAME: <codename> (Role: <role>)
+- WORKSPACE_MODE: Root Trunk | Strand (<path>)
+- ACTIVE_STRAND: <branch> (Parent: <parent_branch>)
+- ACTIVE_PEERS:
+  * <peer_codename> (<project>: <current_task_description>)
+- ACTIVE_LISTENER: <task_id_or_pid> (Listening on inbox: <codename>)
+- ACTIVE_FENCING_TOKENS: <lock_key>=<token_int>
+<!-- END_SWARM_RUNTIME_STATE -->
+</CRITICAL>
+
+---
+
+## 4. Responsiveness Watchdog & Operator Escalation Protocol (GVR-011)
+
+To prevent silent deadlocks when workers stall, crash, or fail to re-arm listeners:
+1. **Health Probing**: Run `rhizo probe <agent> [--json]` to inspect listener PID liveness, inbox unread depth, and heartbeat age.
+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>`.
+
+---
+
+## 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.1.6",
+  "version": "0.2.1",
   "description": "Multi-Agent Swarm Orchestration, Empirical Dialectics & Ceremonies on top of Rhizo & Vine",
   "main": "bin/run.js",
   "bin": {

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, tmux worker fleet provisioning with live terminal viewer, 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: 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'."
 ---
 
 # Garden: Multi-Agent Swarm Ceremony & Orchestration Engine
@@ -25,7 +25,7 @@ Garden directs multi-agent swarms using Rhizo for transport and Vine for workspa
 flowchart TD
     subgraph Garden["Garden Layer (Methodology & Ceremonies)"]
         Phase1["Phase 1: choose-personas (Team Selection & Models)"]
-        Phase2["Phase 2: launch-workers (tmux & Terminal Viewer)"]
+        Phase2["Phase 2: launch-workers (Prompt-Based Session Bootstrapping)"]
         Phase3["Phase 3: dialectical-pump (Research ➔ Design ➔ Audit)"]
         Phase4["Phase 4: plan-implementation (Locking & Strands)"]
         Phase5["Phase 5: orchestrate-swarm (Dispatch & Vine Weaving)"]
@@ -52,7 +52,7 @@ Execute all five phases sequentially. Never skip phases or invert the order.
 | Phase | Sub-Skill | 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) | Provision tmux session, register agents, launch viewer. | `rhizo who --json` confirms 100% of workers active. |
+| **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 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. |
@@ -76,3 +76,45 @@ Never merge code into the canonical trunk without a verified Two-Key Gate pass (
 <FORBIDDEN>
 Never stage coordination metadata (*.lock, .rhizo.*, .vine.json, workspaces/) into Git. Keep all agent state ignored.
 </FORBIDDEN>
+
+<CRITICAL>
+Compaction Preservation Rider (GVR-010):
+Whenever context summarization or compaction occurs, the coding harness MUST preserve the `SWARM_RUNTIME_STATE` block verbatim in the compacted summary preamble so the agent immediately retains its operational identity, assigned workspace, peers, and active listeners without operator re-prompting.
+
+Maintain this exact block in the working context:
+<!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
+- AGENT_NAME: <codename> (Role: <role>)
+- WORKSPACE_MODE: Root Trunk | Strand (<path>)
+- ACTIVE_STRAND: <branch> (Parent: <parent_branch>)
+- ACTIVE_PEERS:
+  * <peer_codename> (<project>: <current_task_description>)
+- ACTIVE_LISTENER: <task_id_or_pid> (Listening on inbox: <codename>)
+- ACTIVE_FENCING_TOKENS: <lock_key>=<token_int>
+<!-- END_SWARM_RUNTIME_STATE -->
+</CRITICAL>
+
+---
+
+## 4. Responsiveness Watchdog & Operator Escalation Protocol (GVR-011)
+
+To prevent silent deadlocks when workers stall, crash, or fail to re-arm listeners:
+1. **Health Probing**: Run `rhizo probe <agent> [--json]` to inspect listener PID liveness, inbox unread depth, and heartbeat age.
+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

@@ -1,106 +1,118 @@
 ---
 name: launch-workers
-description: "Provisions an active worker fleet inside a dedicated tmux session and launches an OS-level terminal viewer (Ghostty / Terminal.app). Reads garden-swarm.json, creates named tmux windows/panes for each worker, configures environment variables (RHIZO_AGENT_NAME, project path), registers each agent in Redis with rhizo open, arms background listeners, and runs AppleScript or open commands on macOS to display the live worker windows to the operator. Verifies cluster heartbeat readiness via rhizo who --json before handing off. Triggers: 'launch workers', 'spin up workers', 'start worker swarm', 'open tmux swarm', 'launch fleet'."
+description: "Generates and formats X distinct copy-pasteable bootstrap prompts for new agent sessions (Claude Code, Pi, OpenCode, Antigravity, etc.) to join the Garden work group on Rhizo and Vine. Reads garden-swarm.json, configures identities, environment setup (RHIZO_AGENT_NAME, cd, rhizo open), single-shot listener discipline, task claiming, and Vine strand isolation. Spits out prompt blocks wrapped in 10 backticks for clean, unrendered raw markdown copying, and verifies cluster heartbeat readiness via rhizo who --json before handing off. Triggers: 'launch workers', 'spin up workers', 'start worker swarm', 'generate worker prompts', 'bootstrap swarm', 'launch fleet'."
 ---
 
-# `launch-workers`: Automated Tmux Swarm Provisioning & Terminal Viewer
+# `launch-workers`: Prompt-Based Swarm Bootstrapping & Work Group Onboarding
 
-> **From Manifest to Live Terminals in Under 2 Seconds**  
-> *Tmux multiplexes the background worker processes while OS-level desktop scripting opens your preferred terminal app so you can observe the swarm in real time.*
+> **From Manifest to Coordinated Sessions Across Any AI Harness**  
+> *Garden generates self-contained, 10-backtick-fenced prompt cards for the human operator to paste into separate terminal tabs or coding harnesses (Claude Code, OpenCode, Antigravity, Pi, Cursor). Each session is immediately grounded in its identity, joins the Rhizo work group, and arms its listener.*
 
 ---
 
-## 1. System Requirements & Invariants
-
-1. **`tmux` is Required**:
-   - `tmux 3.0+` must be installed on the host (`command -v tmux`). If missing, fail fast and instruct the operator to install (`brew install tmux`).
-2. **`rhizo` is Required**:
-   - Rhizo engine must be present (`npm install -g @axiomantic/rhizo`).
-3. **No Terminal Fallbacks**:
-   - Workers are strictly managed inside tmux windows/panes. We do not detach headless rogue background processes with `nohup` or `&`.
-4. **Desktop Viewer Priority on macOS**:
-   - Automatically detects installed terminal emulators:
-     - **Priority 1: Ghostty** (`/Applications/Ghostty.app`)
-     - **Priority 2: iTerm2** (`/Applications/iTerm.app`)
-     - **Priority 3: macOS Terminal** (`/System/Applications/Utilities/Terminal.app`)
-   - Pops open a visible terminal window running `tmux attach-session -t garden-<project>`.
+## 1. System Philosophy & Invariants
+
+1. **Human-in-the-Loop Session Autonomy**:
+   - We do not blindly spawn tmux background processes or attempt to drive terminal multiplexers with fragile subshell scripting.
+   - The operator chooses the harness and model for each worker (e.g. Claude Code CLI in one tab, OpenCode in another, Antigravity in a third).
+2. **Raw Markdown 10-Backtick Fencing**:
+   <CRITICAL>
+   When outputting prompt cards in stdout, artifacts, or chat, every prompt block MUST be wrapped in exactly 10 backticks:
+   ``````````markdown
+   ...
+   ``````````
+   This guarantees that nested backtick fences (```bash) and internal markdown headers inside the prompts do NOT prematurely terminate the code block or render markdown, preserving pristine raw text for one-click clipboard copying.
+   </CRITICAL>
+3. **Single-Shot Listener Discipline**:
+   <CRITICAL>
+   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**:
+   - Never stage coordination state (`.rhizo.*`, `*.lock`, `.vine.json`, `workspaces/`) into Git.
 
 ---
 
-## 2. The Provisioning Flow
+## 2. The Bootstrapping Flow
 
 ```mermaid
 sequenceDiagram
     autonumber
     participant Orch as Main Chat (Orchestrator)
-    participant Script as launch_tmux_swarm.sh
-    participant Tmux as tmux Daemon
-    participant OS as macOS Window Server (Ghostty / Terminal)
+    participant Garden as garden prompts / launch
+    participant Op as Human Operator
+    participant Workers as New Terminal Sessions (Claude, OpenCode, etc.)
     participant Redis as Rhizo (Redis Bus)
 
-    Orch->>Script: Invokes with --swarm-file garden-swarm.json
-    Script->>Tmux: Creates session garden-<project>
-    loop For Each Worker in Manifest
-        Script->>Tmux: Creates named window/pane
-        Script->>Tmux: Injects RHIZO_AGENT_NAME & cd <project>
-        Script->>Tmux: Sends rhizo open <name> "<tags>"
-        Script->>Tmux: Arms listener (rhizo listen or custom startup command)
-        Tmux->>Redis: Registers heartbeat & listener lock
+    Orch->>Garden: Runs garden prompts (or garden launch)
+    Garden-->>Orch: Emits X prompt cards wrapped in 10 backticks
+    Orch->>Op: Displays formatted prompt blocks to operator
+    Op->>Workers: Pastes Prompt #1 into Session 1, Prompt #2 into Session 2...
+    loop Each Pasted Worker Session
+        Workers->>Workers: Sets RHIZO_AGENT_NAME & enters target directory
+        Workers->>Redis: Runs rhizo open <name> "<tags>"
+        Workers->>Redis: Runs rhizo listen <name> (blocks waiting for tasks)
     end
-    Script->>OS: Opens Ghostty/Terminal attached to tmux session
-    Script-->>Orch: Returns JSON status
-    Orch->>Redis: Verifies cluster readiness (rhizo who --json)
+    Orch->>Redis: Runs rhizo who --json to verify readiness gate
+    Redis-->>Orch: All workers active and listening
+    Orch->>Op: Confirms swarm is ready for task dispatch
 ```
 
 ---
 
 ## 3. Execution Procedure
 
-### Step 1: Run the Swarm Provisioner
-Execute [`scripts/launch_tmux_swarm.sh`](file:///Users/eek/Development/garden/scripts/launch_tmux_swarm.sh) with the active project path and manifest:
+### Step 1: Generate Worker Bootstrap Prompts
+Run `garden prompts` (or `garden launch`) from the project root:
 
 ```bash
-/Users/eek/Development/garden/scripts/launch_tmux_swarm.sh \
-  --project-dir "$(pwd)" \
-  --swarm-file "garden-swarm.json" \
-  --force
+# Output all worker prompts to terminal (and optionally write to file):
+garden prompts --write garden-prompts.md
+
+# Or generate for a specific worker:
+garden prompts --worker architect
 ```
 
-- `--force`: Kills any stale prior session with the same project name before provisioning a clean fleet.
-- Automatically launches Ghostty or Terminal.app on macOS attached to the new session.
+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)
+
+### 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)
 
-### Step 2: Verify Cluster Readiness Gate
-Before dispatching tasks, verify that every worker from `garden-swarm.json` is actively registered in Redis and displaying valid heartbeats:
+### Step 3: Verify Cluster Readiness Gate
+Before dispatching tasks, verify that every worker has registered in Redis and is showing active heartbeats:
 
 ```bash
 rhizo who --json
 ```
 
 **Pass Criteria**:
-1. All worker names in `garden-swarm.json` appear in `active_agents`.
+1. All worker codenames from the manifest appear in `active_agents`.
 2. Heartbeats have active TTLs (> 0).
-3. Assigned tags match the manifest.
-
-### Step 3: Inspect Terminal Buffer (Health Check)
-To check the initial logs or output of any worker without leaving your chat:
-
-```bash
-# Capture last 20 lines of worker 'architect' (window 0)
-tmux capture-pane -p -t garden-<project>:0 | tail -n 20
-```
+3. `rhizo probe <agent>` shows an active listener PID ready to receive work.
 
 ---
 
 ## 4. Teardown & Swarm Cleanup
 
-When the entire project is completed, or when canceling a run:
+When the swarm mission is completed, or when canceling a run:
 
 ```bash
 # Gracefully deregister all swarm agents from Redis:
+garden teardown
+```
+
+Or manually:
+```bash
 for worker in $(python3 -c "import json; [print(w['name']) for w in json.load(open('garden-swarm.json'))['workers']]"); do
   rhizo close "$worker" 2>/dev/null || true
 done
-
-# Terminate the tmux session:
-tmux kill-session -t garden-<project> 2>/dev/null || true
 ```

package/skills/orchestrate-swarm/SKILL.md

@@ -17,6 +17,54 @@ The main chat session assumes the role of **Supreme Orchestrator**:
 - **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.
 
+<CRITICAL>
+Compaction Preservation Rider (GVR-010):
+Whenever context summarization or compaction occurs, the coding harness MUST preserve the `SWARM_RUNTIME_STATE` block verbatim in the compacted summary preamble so the agent immediately retains its operational identity, assigned workspace, peers, and active listeners without operator re-prompting.
+
+Maintain this exact block in the working context:
+<!-- SWARM_RUNTIME_STATE: DO NOT DISCARD OR ABBREVIATE IN COMPACTION -->
+- AGENT_NAME: <codename> (Role: Supreme Orchestrator)
+- WORKSPACE_MODE: Root Trunk (/Users/eek/Development/<project>)
+- ACTIVE_STRAND: canonical trunk
+- ACTIVE_PEERS:
+  * <peer_codename> (<project>: <current_task_description>)
+- ACTIVE_LISTENER: <task_id_or_pid> (Listening on inbox: <codename>)
+- ACTIVE_FENCING_TOKENS: <lock_key>=<token_int>
+<!-- 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 Supreme 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
@@ -59,15 +107,57 @@ Depending on the task distribution model in `implementation_plan.md`:
     --body '{"task_id": "task-test-harness", "strand": "strand/task-test-harness"}'
   ```
 
-### SOP 2: Monitoring Swarm Health & Heartbeats
-Check active workers and ensure no listener has stalled or timed out:
+- **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
 ```
 
-If a worker is waiting for a lease or has held a lock too long, inspect its active tmux pane:
+#### 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
+rhizo probe <worker> --json
+```
+The probe returns:
+- `inbox_depth`: Number of unconsumed messages (if > 0, the worker hasn't picked up the task).
+- `listener`: Whether the listener process PID is active (`LISTENING (pid: N)`) or dead (`NO_LISTENER`).
+- `heartbeat`: Last seen age in seconds and heartbeat TTL.
+
+#### 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`.
+2. **Present Diagnostic**:
+   - Alert: `⚠️ SWARM STALL DETECTED: @<worker> has not responded to <subject>`
+   - Diagnostic: `Inbox: N unread | Listener: NO_LISTENER | Status: STALE`
+3. **Select Remediation Action**:
+   - Option 1 (Re-arm): Execute `rhizo listen <worker>` in the worker's assigned terminal pane.
+   - Option 2 (Reboot): Restart the worker harness process in that pane.
+   - Option 3 (Reassign): Re-route the task atomically to another active worker:
+     ```bash
+     rhizo reroute <stalled_worker> <new_worker> --all
+     ```
+
+If a worker is waiting for a lease or has held a lock too long, probe its listener and inbox status:
 ```bash
-tmux capture-pane -p -t garden-<project>:1 | tail -n 25
+rhizo probe <worker>
 ```
 
 ### SOP 3: Verifying Two-Key Gate & Weaving
@@ -117,12 +207,6 @@ When all checkboxes in `implementation_plan.md` are marked `- [x]`:
 1. Run final repository-wide test suite and linter on the canonical trunk.
 2. Gracefully deregister all swarm agents:
    ```bash
-   for worker in $(python3 -c "import json; [print(w['name']) for w in json.load(open('garden-swarm.json'))['workers']]"); do
-     rhizo close "$worker" 2>/dev/null || true
-   done
-   ```
-3. Kill the tmux session:
-   ```bash
-   tmux kill-session -t garden-<project> 2>/dev/null || true
+   garden teardown
    ```
-4. Output the final executive summary to the human operator.
+3. Output the final executive summary to the human operator.