@axiomantic/garden 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Axiomantic / Agora Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+<div align="center">
+
+# Garden
+
+**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)
+[![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.*
+
+</div>
+
+---
+
+## What is Garden?
+
+**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.
+
+```mermaid
+flowchart TD
+    subgraph Layer3["Layer 3: Garden (Methodology, Ceremonies & Swarms)"]
+        direction TB
+        GardenSkill["garden (Master Entrypoint)"]
+        P1["choose-personas (Team & Models)"]
+        P2["launch-workers (tmux & Terminal Viewer)"]
+        P3["dialectical-pump (Research ➔ Design ➔ Audit)"]
+        P4["plan-implementation (Locks & Strands)"]
+        P5["orchestrate-swarm (Dispatch & Weave)"]
+        GardenSkill --> P1 --> P2 --> P3 --> P4 --> P5
+    end
+
+    subgraph Layer2["Layer 2: Vine (Workstream Integrator)"]
+        Strands["APFS CoW Strands (Sub-second isolated workspaces)"]
+        TwoKey["Two-Key Gate (Mechanical merge-tree + semantic test suite)"]
+        Weave["Trunk Weaving (Fast-forward verified branches)"]
+    end
+
+    subgraph Layer1["Layer 1: Rhizo (Inter-Agent Transport)"]
+        Bus["Redis Message Bus (O2O, Multicast, RPC)"]
+        Locks["Distributed Mutexes & Monotonic Fencing Tokens"]
+        Queues["Worker Queues with Leases & Dead-Letter Escalation"]
+    end
+
+    Layer3 --> Layer2
+    Layer3 --> Layer1
+    Layer2 -.-> Layer1
+```
+
+---
+
+## The 5 Core Skills (+ Master Entrypoint)
+
+Garden is organized into a clean, batteries-included catalog of self-explanatory skills:
+
+| Skill | Role | Description |
+| :--- | :--- | :--- |
+| **[`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). |
+| **[`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`. |
+
+---
+
+## System Prerequisites
+
+1. **`tmux`** (3.0+):
+   ```bash
+   brew install tmux
+   ```
+2. **`rhizo`** (Coordination Engine):
+   ```bash
+   npm install -g @axiomantic/rhizo
+   ```
+3. **`vine`** (Workspace Virtualization Engine):
+   ```bash
+   npm install -g @axiomantic/vine
+   ```
+4. **Redis or Valkey** (local or remote):
+   ```bash
+   brew install redis && brew services start redis
+   ```
+
+---
+
+## 30-Second Quickstart
+
+### 1. Launch Garden on Any Task
+In your primary AI coding assistant (Antigravity, Claude Code, OpenCode):
+
+```text
+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.
+
+### 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.
+
+### 4. The Dialectical Pump (`dialectical-pump`)
+The personas deliberate across three empirical stages:
+1. **Research**: Workers read code and run tests $\to$ synthesize `understanding.md` $\to$ verify against automated **Fact-Check Gate**.
+2. **Architecture**: Triad debates trade-offs $\to$ produces ratified `design.md`.
+3. **Audit**: Auditor generates `audit_report.md` $\to$ triad resolves every finding before coding begins.
+
+### 5. Ceremonial Planning (`plan-implementation`)
+Garden authors `implementation_plan.md`:
+- Schedules distributed fencing locks (`rhizo lock file:<path> --fencing`).
+- Assigns tasks and defines APFS CoW strands (`vine new <task_id> --worktree`).
+- Sets up dynamic progress checkboxes and harness To-Do tracking.
+
+### 6. Live Orchestration & Trunk Weaving (`orchestrate-swarm`)
+The main chat orchestrator dispatches work over Redis. Workers code in isolated strands, run unit tests, and verify the Two-Key Gate (`vine gate`). When passed, the orchestrator executes `vine weave` to fast-forward verified code into `main` with zero merge conflicts!
+
+---
+
+## Core Invariants
+
+1. **The Supreme 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.
+3. **Two-Key Gate Verification**:
+   No code is merged into the trunk without passing both Key 1 (in-memory `git merge-tree` mechanical check) and Key 2 (live semantic compiler and test suite run).
+4. **Zero Dirty Commits**:
+   All agent identity files, session state, and temporary lockfiles are strictly ignored in `.gitignore`.
+
+---
+
+## License
+
+MIT © Axiomantic / Garden Contributors

package/SKILL.md

@@ -0,0 +1,133 @@
+---
+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'."
+---
+
+# Garden: Multi-Agent Swarm Ceremony & Orchestration Engine
+
+> **The Sovereign Orchestration Layer for Autonomous AI Swarms**  
+> *Where `rhizo` is the transport nervous system and `vine` is the workspace integrator, `garden` is the institutional intellect, deliberation crucible, and master ceremony conductor.*
+
+---
+
+## 1. Architectural Architecture & Layering
+
+Garden coordinates teams of heterogeneous AI coding assistants across terminals and machines:
+
+```mermaid
+flowchart TD
+    subgraph Garden["Garden Layer (Methodology & Ceremonies)"]
+        Phase1["Phase 1: choose-personas (Team Selection & Models)"]
+        Phase2["Phase 2: launch-workers (tmux & Terminal Viewer)"]
+        Phase3["Phase 3: dialectical-pump (Research ➔ Design ➔ Audit)"]
+        Phase4["Phase 4: plan-implementation (Locking & Strands)"]
+        Phase5["Phase 5: orchestrate-swarm (Dispatch & Vine Weaving)"]
+    end
+
+    subgraph Infrastructure["Coordination Infrastructure"]
+        Rhizo["Rhizo (Redis Bus, Fencing Mutexes, Work Queues)"]
+        Vine["Vine (APFS CoW Strands, Two-Key Gate, Weaving)"]
+    end
+
+    Phase1 --> Phase2 --> Phase3 --> Phase4 --> Phase5
+    Phase2 -.-> Rhizo
+    Phase3 -.-> Rhizo
+    Phase4 -.-> Rhizo & Vine
+    Phase5 -.-> Rhizo & Vine
+```
+
+---
+
+## 2. The 5-Phase End-to-End Ceremony
+
+When invoked, the Orchestrator (the primary conversation chat) executes these five phases sequentially. Never skip phases or invert the order.
+
+```mermaid
+sequenceDiagram
+    autonumber
+    actor User as Human Operator
+    participant Orch as Main Chat (Orchestrator)
+    participant Swarm as Tmux Worker Swarm
+    participant Bus as Rhizo (Redis)
+    participant Gate as Vine (Strands & Gate)
+
+    User->>Orch: "garden: implement feature X"
+    Note over Orch: Phase 1: Team Calibration
+    Orch->>User: Suggests Persona Roster (Roles, Harnesses, Models) via ask_question
+    User-->>Orch: Ratifies / Adjusts Roster
+
+    Note over Orch: Phase 2: Fleet Provisioning
+    Orch->>Swarm: Executes launch-workers (tmux panes + Ghostty/Terminal viewer)
+    Swarm->>Bus: rhizo open + rhizo listen (Workers armed)
+
+    Note over Orch: Phase 3: Empirical Dialectic
+    Orch->>Swarm: Dispatches dialectical-pump
+    Note over Swarm: 1. Research ➔ understanding.md ➔ Fact-Check Gate<br/>2. Architecture ➔ design.md<br/>3. Adversarial Audit ➔ audit_report.md ➔ Remediation
+    Swarm-->>Orch: Ratified design.md & cleared audit report
+
+    Note over Orch: Phase 4: Master Planning
+    Orch->>Orch: Authors implementation_plan.md (Locks, Strands, To-Do list)
+
+    Note over Orch: Phase 5: Swarm Execution & Weaving
+    loop For Each Plan Task
+        Orch->>Bus: Dispatch task (rhizo send / enqueue)
+        Bus->>Swarm: Worker claims lease (rhizo claim)
+        Swarm->>Gate: Creates strand (vine new)
+        Swarm->>Swarm: Implements code + verifies tests
+        Swarm->>Gate: Verifies Two-Key Gate (vine gate)
+        Swarm->>Orch: Reports gate pass (rhizo reply)
+        Orch->>Gate: Fast-forward merge (vine weave)
+        Orch->>Orch: Updates plan checkbox & Harness To-Do
+    end
+    Orch->>User: Mission Accomplished Summary
+```
+
+---
+
+## 3. Phase Transition Protocols & Quality Gates
+
+### Gate 1 $\to$ 2: Persona Ratification Gate
+- **Condition**: Operator has confirmed the roster via `ask_question`.
+- **Artifact**: `garden-swarm.json` persisted in the project directory.
+- **Action**: Call `launch-workers`.
+
+### Gate 2 $\to$ 3: Cluster Readiness Gate
+- **Condition**: All worker panes booted, heartbeats active in Redis.
+- **Verification**: `rhizo who --json` confirms 100% of agents online and tagged.
+- **Action**: Call `dialectical-pump`.
+
+### Gate 3 $\to$ 4: Design Audit Clearance Gate
+- **Condition**:
+  1. `understanding.md` passed the Fact-Check Gate (zero ungrounded claims).
+  2. `design.md` authored and debated by the triadic pump.
+  3. `audit_report.md` contains 0 open `CRIT` or `BLOCKER` defects.
+- **Action**: Call `plan-implementation`.
+
+### Gate 4 $\to$ 5: Plan Alignment Gate
+- **Condition**: `implementation_plan.md` complete with task matrix, locking schedule, vine strand lifecycles, and emergent design addendum protocol.
+- **Action**: Call `orchestrate-swarm`.
+
+---
+
+## 4. Sub-Skill Reference Map
+
+When executing Garden, invoke the sub-skills at their designated phases:
+
+| Phase | Skill Name | Description | Primary Artifacts |
+| :--- | :--- | :--- | :--- |
+| **Phase 1** | [`choose-personas`](../choose-personas/SKILL.md) | Analyzes task, formulates 3 balanced personas with suggested **coding harness** and **model**, and confirms with operator. | `garden-swarm.json` |
+| **Phase 2** | [`launch-workers`](../launch-workers/SKILL.md) | Provisions tmux session with worker panes, registers `rhizo open`, arms listeners, and launches OS terminal viewer (Ghostty / Terminal.app). | Live tmux session, visible terminal |
+| **Phase 3** | [`dialectical-pump`](../dialectical-pump/SKILL.md) | Drives empirical multi-persona debate grounded in tool calls (file reading, test running, AST inspecting). Produces research, design, and audit docs. | `understanding.md`, `design.md`, `audit_report.md` |
+| **Phase 4** | [`plan-implementation`](../plan-implementation/SKILL.md) | Authors master implementation plan detailing task assignments, `rhizo` locks (`--fencing`), `vine` strands, dynamic checkboxes, and To-Do tracking. | `implementation_plan.md` |
+| **Phase 5** | [`orchestrate-swarm`](../orchestrate-swarm/SKILL.md) | Main-chat governor: dispatches tasks over Redis, tracks heartbeats, approves emergent design addenda, and executes `vine weave` upon Two-Key gate pass. | Completed code, woven trunk, git commits |
+
+---
+
+## 5. Invariants & Rules of Engagement
+
+1. **The Supreme Orchestrator Invariant**:
+   The primary conversation session acts as the Supreme Orchestrator. It coordinates, plans, reviews, and merges. It delegates intensive multi-file edits to the worker fleet.
+2. **Zero Theatrical Dialogue**:
+   In dialectical deliberations, every assertion must be backed by empirical evidence (line citations, test execution outputs, compiler errors).
+3. **No Unmanaged Daemons / Zero Dirty Commits**:
+   All coordination metadata (`.rhizo.*`, `.vine.*`, `*.lock`) must remain in `.gitignore`. Workers must adhere to the Two-Key Gate before any code touches the canonical trunk.

package/bin/run.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function findBinary() {
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  const arch = process.arch;
+  const platform = process.platform;
+
+  for (const name of ['garden']) {
+    const directBin = path.join(__dirname, `${name}${ext}`);
+    if (fs.existsSync(directBin)) return directBin;
+
+    const platformBin = path.join(__dirname, `${name}-${platform}-${arch}${ext}`);
+    if (fs.existsSync(platformBin)) return platformBin;
+
+    const vendorBin = path.join(__dirname, '..', 'vendor', 'bin', `${name}${ext}`);
+    if (fs.existsSync(vendorBin)) return vendorBin;
+  }
+
+  return null;
+}
+
+const binPath = findBinary();
+if (!binPath) {
+  console.error(`Error: @axiomantic/garden native binary not found for ${process.platform}-${process.arch}.`);
+  console.error(`Please visit https://github.com/axiomantic/garden/releases to download.`);
+  process.exit(1);
+}
+
+try {
+  fs.chmodSync(binPath, 0o755);
+} catch (_) {}
+
+const res = spawnSync(binPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: process.env
+});
+
+if (res.error) {
+  console.error(`Failed to execute binary: ${res.error.message}`);
+  process.exit(1);
+}
+
+process.exit(res.status !== null ? res.status : (res.signal ? 1 : 0));

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@axiomantic/garden",
+  "version": "0.1.0",
+  "description": "Multi-Agent Swarm Orchestration, Empirical Dialectics & Ceremonies on top of Rhizo & Vine",
+  "main": "bin/run.js",
+  "bin": {
+    "garden": "bin/run.js"
+  },
+  "skills": "./skills",
+  "files": [
+    "bin/",
+    "scripts/",
+    "skills/",
+    "SKILL.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/axiomantic/garden.git"
+  },
+  "keywords": [
+    "multi-agent",
+    "ai-agents",
+    "orchestration",
+    "tmux",
+    "dialectics",
+    "rhizo",
+    "vine",
+    "garden",
+    "swarm"
+  ],
+  "author": "Axiomantic",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/axiomantic/garden/issues"
+  },
+  "homepage": "https://github.com/axiomantic/garden#readme"
+}

package/scripts/launch_tmux_swarm.sh

@@ -0,0 +1,233 @@
+#!/usr/bin/env bash
+# scripts/launch_tmux_swarm.sh
+# Provisions a dedicated tmux session for a Garden worker swarm, registers identities
+# on the Rhizo Redis bus, arms listeners, and opens a visible terminal viewer (Ghostty/Terminal.app).
+
+set -euo pipefail
+
+usage() {
+  cat <<EOF
+Usage: $(basename "$0") [options]
+
+Options:
+  --session-name <name>    tmux session name (default: garden-<dirname>)
+  --project-dir <path>     Target project working directory (default: current directory)
+  --swarm-file <path>      Path to garden-swarm.json manifest
+  --terminal-app <app>     Terminal viewer app: Ghostty | Terminal | iTerm | none (default: auto)
+  --force                  Kill existing tmux session if running
+  --help                   Show this help message
+EOF
+  exit 0
+}
+
+SESSION_NAME=""
+PROJECT_DIR="$(pwd)"
+SWARM_FILE=""
+TERMINAL_APP="auto"
+FORCE=0
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --session-name)
+      SESSION_NAME="$2"
+      shift 2
+      ;;
+    --project-dir)
+      PROJECT_DIR="$(cd "$2" && pwd)"
+      shift 2
+      ;;
+    --swarm-file)
+      SWARM_FILE="$2"
+      shift 2
+      ;;
+    --terminal-app)
+      TERMINAL_APP="$2"
+      shift 2
+      ;;
+    --force)
+      FORCE=1
+      shift
+      ;;
+    --help|-h)
+      usage
+      ;;
+    *)
+      echo "Unknown option: $1" >&2
+      usage
+      ;;
+  esac
+done
+
+# Prerequisite Checks
+if ! command -v tmux >/dev/null 2>&1; then
+  echo "Error: tmux is required but not found in PATH." >&2
+  echo "Install via Homebrew: brew install tmux" >&2
+  exit 1
+fi
+
+if ! command -v rhizo >/dev/null 2>&1; then
+  echo "Error: rhizo is required but not found in PATH." >&2
+  echo "Install via npm: npm install -g @axiomantic/rhizo" >&2
+  exit 1
+fi
+
+RHIZO_BIN="rhizo"
+
+if [[ -z "$SESSION_NAME" ]]; then
+  PROJECT_BASE="$(basename "$PROJECT_DIR" | tr '[:upper:]' '[:lower:]' | tr -c 'a-z0-9_-' '_')"
+  SESSION_NAME="garden-${PROJECT_BASE}"
+fi
+
+if tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
+  if [[ $FORCE -eq 1 ]]; then
+    echo "[garden] Killing existing tmux session: $SESSION_NAME"
+    tmux kill-session -t "$SESSION_NAME"
+  else
+    echo "Error: tmux session '$SESSION_NAME' already exists. Use --force to recreate." >&2
+    exit 1
+  fi
+fi
+
+# Parse swarm workers from JSON manifest or default trio
+declare -a WORKER_NAMES=()
+declare -a WORKER_TAGS=()
+declare -a WORKER_COMMANDS=()
+
+if [[ -z "$SWARM_FILE" && -f "$PROJECT_DIR/garden-swarm.json" ]]; then
+  SWARM_FILE="$PROJECT_DIR/garden-swarm.json"
+fi
+
+if [[ -n "$SWARM_FILE" && -f "$SWARM_FILE" ]]; then
+  if ! command -v jq >/dev/null 2>&1 && ! command -v python3 >/dev/null 2>&1; then
+    echo "Error: python3 or jq is required to parse $SWARM_FILE" >&2
+    exit 1
+  fi
+
+  # Parse JSON using python3 into tab-separated lines: name <tab> tags <tab> command
+  PARSED_LINES=$(python3 -c "
+import json, sys
+with open('$SWARM_FILE', 'r') as f:
+    data = json.load(f)
+workers = data.get('workers', [])
+for w in workers:
+    name = w.get('name', 'worker')
+    tags = ','.join(w.get('tags', []))
+    cmd = w.get('startup_command', '')
+    print(f'{name}\t{tags}\t{cmd}')
+")
+
+  while IFS=$'\t' read -r wname wtags wcmd; do
+    [[ -z "$wname" ]] && continue
+    WORKER_NAMES+=("$wname")
+    WORKER_TAGS+=("$wtags")
+    WORKER_COMMANDS+=("$wcmd")
+  done <<< "$PARSED_LINES"
+fi
+
+# Fallback default trio if no manifest was provided
+if [[ ${#WORKER_NAMES[@]} -eq 0 ]]; then
+  WORKER_NAMES=("architect" "auditor" "implementer")
+  WORKER_TAGS=("systems,architecture" "qa,audit,review" "dev,devex,build")
+  WORKER_COMMANDS=("" "" "")
+fi
+
+echo "[garden] Provisioning tmux session: $SESSION_NAME for project: $PROJECT_DIR"
+
+# 1. Create first worker window (index 0)
+FIRST_NAME="${WORKER_NAMES[0]}"
+FIRST_TAGS="${WORKER_TAGS[0]}"
+FIRST_CMD="${WORKER_COMMANDS[0]}"
+
+tmux new-session -d -s "$SESSION_NAME" -n "$FIRST_NAME" -c "$PROJECT_DIR"
+tmux send-keys -t "$SESSION_NAME:0" "cd $(printf %q "$PROJECT_DIR")" C-m
+tmux send-keys -t "$SESSION_NAME:0" "export RHIZO_AGENT_NAME=$(printf %q "$FIRST_NAME")" C-m
+tmux send-keys -t "$SESSION_NAME:0" "$RHIZO_BIN open $(printf %q "$FIRST_NAME") $(printf %q "$FIRST_TAGS")" C-m
+
+if [[ -n "$FIRST_CMD" ]]; then
+  tmux send-keys -t "$SESSION_NAME:0" "$FIRST_CMD" C-m
+else
+  tmux send-keys -t "$SESSION_NAME:0" "$RHIZO_BIN listen $(printf %q "$FIRST_NAME")" C-m
+fi
+
+# 2. Create subsequent worker windows
+for (( i=1; i<${#WORKER_NAMES[@]}; i++ )); do
+  WNAME="${WORKER_NAMES[$i]}"
+  WTAGS="${WORKER_TAGS[$i]}"
+  WCMD="${WORKER_COMMANDS[$i]}"
+
+  tmux new-window -t "$SESSION_NAME" -n "$WNAME" -c "$PROJECT_DIR"
+  tmux send-keys -t "$SESSION_NAME:$i" "cd $(printf %q "$PROJECT_DIR")" C-m
+  tmux send-keys -t "$SESSION_NAME:$i" "export RHIZO_AGENT_NAME=$(printf %q "$WNAME")" C-m
+  tmux send-keys -t "$SESSION_NAME:$i" "$RHIZO_BIN open $(printf %q "$WNAME") $(printf %q "$WTAGS")" C-m
+
+  if [[ -n "$WCMD" ]]; then
+    tmux send-keys -t "$SESSION_NAME:$i" "$WCMD" C-m
+  else
+    tmux send-keys -t "$SESSION_NAME:$i" "$RHIZO_BIN listen $(printf %q "$WNAME")" C-m
+  fi
+done
+
+# Select window 0 initially
+tmux select-window -t "$SESSION_NAME:0"
+
+echo "[garden] Spawned ${#WORKER_NAMES[@]} worker windows in tmux session '$SESSION_NAME'."
+
+# 3. Launch OS-level Terminal Viewer
+if [[ "$TERMINAL_APP" == "auto" ]]; then
+  if [[ -d "/Applications/Ghostty.app" ]]; then
+    TERMINAL_APP="Ghostty"
+  elif [[ -d "/Applications/iTerm.app" ]]; then
+    TERMINAL_APP="iTerm"
+  elif [[ "$(uname -s)" == "Darwin" ]]; then
+    TERMINAL_APP="Terminal"
+  else
+    TERMINAL_APP="none"
+  fi
+fi
+
+if [[ "$TERMINAL_APP" != "none" && "$(uname -s)" == "Darwin" ]]; then
+  echo "[garden] Launching viewer in $TERMINAL_APP..."
+  case "$TERMINAL_APP" in
+    Ghostty|ghostty)
+      # Launch Ghostty with attach command
+      open -a Ghostty --args -e tmux attach-session -t "$SESSION_NAME" || true
+      ;;
+    iTerm|iterm)
+      osascript -e "
+        tell application \"iTerm\"
+          activate
+          set newWindow to (create window with default profile)
+          tell current session of newWindow
+            write text \"tmux attach-session -t $SESSION_NAME\"
+          end tell
+        end tell
+      " >/dev/null 2>&1 || true
+      ;;
+    Terminal|terminal)
+      osascript -e "
+        tell application \"Terminal\"
+          activate
+          do script \"tmux attach-session -t $SESSION_NAME\"
+        end tell
+      " >/dev/null 2>&1 || true
+      ;;
+    *)
+      echo "[garden] Unknown terminal app '$TERMINAL_APP'; skipping auto-launch." >&2
+      ;;
+  esac
+fi
+
+# Output JSON summary for caller agents / orchestrator
+cat <<EOF
+{
+  "status": "ready",
+  "session_name": "$SESSION_NAME",
+  "project_dir": "$PROJECT_DIR",
+  "terminal_app": "$TERMINAL_APP",
+  "workers": [
+$(for (( i=0; i<${#WORKER_NAMES[@]}; i++ )); do
+    echo "    {\"window\": $i, \"name\": \"${WORKER_NAMES[$i]}\", \"tags\": \"${WORKER_TAGS[$i]}\"}$(if [[ $i -lt $((${#WORKER_NAMES[@]} - 1)) ]]; then echo ","; fi)"
+  done)
+  ]
+}
+EOF