opencodekit 0.17.9 → 0.17.10

package/dist/index.js

@@ -759,7 +759,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "opencodekit",
-  version: "0.17.9",
+  version: "0.17.10",
   description: "CLI tool for bootstrapping and managing OpenCodeKit projects",
   keywords: ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
   license: "MIT",
@@ -9244,21 +9244,21 @@ async function copyOpenCodeOnly(templateRoot, targetDir) {
 }
 var MODEL_PRESETS = {
   free: {
-    model: "opencode/kimi-k2.5-free",
+    model: "opencode/glm-5-free",
     agents: {
-      build: "opencode/kimi-k2.5-free",
-      plan: "opencode/kimi-k2.5-free",
+      build: "opencode/minimax-m2.5-free",
+      plan: "opencode/minimax-m2.5-free",
       review: "opencode/minimax-m2.5-free",
-      explore: "opencode/minimax-m2.5-free",
-      general: "opencode/minimax-m2.5-free",
-      looker: "opencode/kimi-k2.5-free",
-      vision: "opencode/kimi-k2.5-free",
-      scout: "opencode/minimax-m2.5-free",
-      painter: "opencode/kimi-k2.5-free"
+      explore: "opencode/glm-5-free",
+      general: "opencode/glm-5-free",
+      looker: "opencode/minimax-m2.5-free",
+      vision: "opencode/minimax-m2.5-free",
+      scout: "opencode/glm-5-free",
+      painter: "opencode/minimax-m2.5-free"
     }
   },
   recommend: {
-    model: "opencode/kimi-k2.5-free",
+    model: "opencode/minimax-m2.5-free",
     agents: {
       build: "github-copilot/claude-opus-4.6",
       plan: "openai/gpt-5.3-codex",
@@ -9266,7 +9266,7 @@ var MODEL_PRESETS = {
       explore: "proxypal/gemini-3-flash",
       general: "github-copilot/gpt-5.2-codex",
       looker: "proxypal/gemini-3-flash",
-      vision: "proxypal/gemini-3-pro-high",
+      vision: "proxypal/gemini-3.1-pro-high",
       scout: "proxypal/claude-sonnet-4-6",
       painter: "proxypal/gemini-3-pro-image"
     }

package/dist/template/.opencode/opencode.json

@@ -157,6 +157,10 @@
       "models": {
         "claude-haiku-4.5": {
           "attachment": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          },
           "options": {
             "thinking_budget": 10000,
             "type": "enabled"
@@ -181,6 +185,10 @@
         },
         "claude-opus-4.5": {
           "attachment": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          },
           "options": {
             "thinking_budget": 10000
           },
@@ -203,7 +211,7 @@
         "claude-opus-4.6": {
           "attachment": true,
           "limit": {
-            "context": 128000,
+            "context": 200000,
             "output": 64000
           },
           "options": {
@@ -248,8 +256,8 @@
         "claude-sonnet-4.6": {
           "attachment": true,
           "limit": {
-            "context": 128000,
-            "output": 32000
+            "context": 200000,
+            "output": 64000
           },
           "options": {
             "thinking": {
@@ -292,6 +300,10 @@
         },
         "claude-sonnet-4.5": {
           "attachment": true,
+          "limit": {
+            "context": 200000,
+            "output": 64000
+          },
           "options": {
             "thinking_budget": 10000
           },
@@ -313,6 +325,10 @@
         },
         "gpt-5.2": {
           "attachment": true,
+          "limit": {
+            "context": 400000,
+            "output": 128000
+          },
           "options": {
             "reasoningEffort": "medium",
             "reasoningSummary": "auto",
@@ -339,6 +355,10 @@
         },
         "gpt-5.2-codex": {
           "attachment": true,
+          "limit": {
+            "context": 400000,
+            "output": 128000
+          },
           "options": {
             "reasoningEffort": "medium",
             "reasoningSummary": "auto",
@@ -472,6 +492,37 @@
             "fast": {
               "disabled": true
             },
+            "xhigh": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "xhigh",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            },
+            "high": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "high",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            },
+            "medium": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "medium",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            }
+          }
+        },
+        "gpt-5.3-codex": {
+          "variants": {
+            "fast": {
+              "disabled": true
+            },
+            "xhigh": {
+              "include": ["reasoning.encrypted_content"],
+              "reasoningEffort": "xhigh",
+              "reasoningSummary": "auto",
+              "textVerbosity": "low"
+            },
             "high": {
               "include": ["reasoning.encrypted_content"],
               "reasoningEffort": "high",
@@ -498,47 +549,6 @@
             "top_p": 0.95
           },
           "reasoning": true
-        },
-        "kimi-k2.5-free": {
-          "limit": {
-            "context": 262144,
-            "output": 32768
-          },
-          "options": {
-            "interleaved": {
-              "field": "reasoning_content"
-            },
-            "thinking": {
-              "budgetTokens": 8192,
-              "reasoning_effort": "high",
-              "type": "enabled"
-            }
-          },
-          "reasoning": true,
-          "temperature": true,
-          "tool_call": true,
-          "variants": {
-            "high": {
-              "interleaved": {
-                "field": "reasoning_content"
-              },
-              "options": {
-                "reasoning_effort": "high",
-                "thinkingBudget": 16384,
-                "type": "enabled"
-              }
-            },
-            "max": {
-              "interleaved": {
-                "field": "reasoning_content"
-              },
-              "options": {
-                "reasoning_effort": "high",
-                "thinkingBudget": 32768,
-                "type": "enabled"
-              }
-            }
-          }
         }
       }
     },

package/dist/template/.opencode/package.json

@@ -11,7 +11,7 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.2.6"
+    "@opencode-ai/plugin": "1.2.10"
   },
   "devDependencies": {
     "@types/node": "^25.3.0",

package/dist/template/.opencode/skill/beads/SKILL.md

@@ -348,6 +348,102 @@ swarm({ operation: "sync", action: "pull" });
 3. **One task per session** - Restart after `br close`
 4. **Always sync and commit** - `br sync --flush-only` then `git add .beads/ && git commit`
 5. **Write notes for future agents** - Assume zero conversation context
+6. **Claim file paths before editing** - Use reserve to declare ownership (multi-agent only)
+
+## File Path Claiming (Multi-Agent Safety)
+
+At multi-agent scale, agents editing the same files cause merge conflicts. File path claiming prevents this by making ownership explicit before any edit happens.
+
+### When to Use
+
+- **Single agent**: Optional — no conflicts possible
+- **2-10 agents**: Recommended for files touched by multiple tasks
+- **10+ agents**: Required — every file must be claimed before editing
+
+### The Claim/Edit/Release Cycle
+
+```bash
+# 1. CLAIM: Declare intent to edit before touching the file
+br reserve <bead-id> --files "src/auth/service.ts,src/auth/types.ts"
+# → Marks files as owned by this bead
+# → Other agents see the reservation and must wait
+
+# 2. EDIT: Make your changes
+# (edit files as normal)
+
+# 3. VERIFY: Run gates before releasing
+npm run typecheck && npm run lint
+
+# 4. CLOSE: Release ownership when done
+br close <bead-id> --reason "Auth service implemented. Gates passed."
+# → Ownership released automatically on close
+```
+
+### Checking for Conflicts Before Claiming
+
+Before claiming, check if another bead already owns the file:
+
+```bash
+# See all reserved files across active beads
+br list --status in_progress --json | jq '.[].reserved_files'
+
+# If conflict detected:
+# → Wait for the other bead to close
+# → Or coordinate with the agent owning that bead
+```
+
+### Claiming in Delegation Packets
+
+Workers MUST declare file claims in their delegation packet:
+
+```markdown
+# Delegation Packet
+
+- TASK: task-1 - Implement auth service
+- FILES TO CLAIM BEFORE EDITING:
+  - src/auth/service.ts
+  - src/auth/types.ts
+  - src/auth/middleware.ts
+- MUST NOT EDIT (owned by other tasks):
+  - src/db/schema.ts (owned by task-0)
+  - src/config.ts (owned by task-2)
+```
+
+### Conflict Resolution Protocol
+
+When two agents want the same file:
+
+| Scenario                             | Resolution                                      |
+| ------------------------------------ | ----------------------------------------------- |
+| File not claimed                     | Claim it and proceed                            |
+| File claimed by completed bead       | Safe to claim (no active owner)                 |
+| File claimed by in_progress bead     | Wait for bead to close, then claim              |
+| Urgent: same file, different workers | Escalate to lead agent to split the file change |
+
+### Anti-Pattern: Claiming After Editing
+
+```bash
+# WRONG — edit first, claim after → conflict already happened
+edit src/auth/service.ts
+br reserve bead-1 --files "src/auth/service.ts"
+
+# RIGHT — claim first, then edit
+br reserve bead-1 --files "src/auth/service.ts"
+edit src/auth/service.ts
+```
+
+### Quick Reference: File Claiming
+
+```
+BEFORE EDITING (multi-agent):
+  br reserve <id> --files "src/file.ts"
+
+CHECK OWNERSHIP:
+  br list --status in_progress --json | jq '.[].reserved_files'
+
+RELEASE:
+  br close <id> --reason "..."  ← auto-releases files
+```
 
 ## Best Practices
 

package/dist/template/.opencode/skill/context-engineering/SKILL.md

@@ -59,3 +59,107 @@ Extend it by:
 ❌ Keeping old file reads after editing complete
 ❌ Reading entire files when you only need a function
 ❌ Ignoring AGENTS.md hierarchy
+
+## Static vs Runtime Context (Longshot Pattern)
+
+At scale (10+ agents), the difference between **static context** and **runtime context** is the difference between a coherent swarm and chaos.
+
+### Definitions
+
+| Type                | What It Is                                                   | When Loaded            | Example                                 |
+| ------------------- | ------------------------------------------------------------ | ---------------------- | --------------------------------------- |
+| **Static Context**  | Always-on knowledge — invariants, constraints, project shape | Always (auto-injected) | AGENTS.md, tech-stack.md, user.md       |
+| **Runtime Context** | Per-task injections — what THIS task needs right now         | Per-task               | Delegation packet, task spec, file list |
+
+### Why the Split Matters
+
+Without separation, context becomes soup:
+
+- Agent loads everything → hits token limit → degrades
+- Agents share stale context → conflicting decisions
+- No clear source of truth for "what is the objective"
+
+With separation:
+
+- Static = immune to session pollution (always fresh)
+- Runtime = scoped to task (cleaned up when done)
+- Result: agents stay coherent at 200-agent scale
+
+### Task Packet Format
+
+Every task dispatched to a worker agent MUST include an explicit context block:
+
+```markdown
+## Task Packet
+
+### Static Context (always available)
+
+- Project rules: AGENTS.md
+- Tech stack: .opencode/memory/project/tech-stack.md
+- Gotchas: .opencode/memory/project/gotchas.md
+
+### Runtime Context (this task only)
+
+- Objective: [one sentence]
+- Scope: [files this task may touch]
+- Constraints: [must_do / must_not_do]
+- Dependencies: [what was produced by prior tasks]
+- Verification: [acceptance commands]
+```
+
+### Injection Pattern
+
+When spawning workers, always inject runtime context explicitly:
+
+```typescript
+// WRONG: Vague prompt — agent guesses context
+Task({ prompt: "Implement auth service" });
+
+// RIGHT: Explicit static + runtime context split
+Task({
+  prompt: `## Static Context
+AGENTS.md governs all decisions. Tech stack: Bun, TypeScript strict mode.
+
+## Runtime Context
+Objective: Implement JWT auth service in src/auth/service.ts.
+Scope: Only modify src/auth/ directory.
+Dependencies: Schema defined in src/db/schema.ts (from task-1).
+Constraints:
+  MUST DO: Use zod for input validation
+  MUST NOT DO: Add new dependencies without approval
+Verification:
+  npm run typecheck && npm run lint && bun test src/auth/`,
+});
+```
+
+### Context Pollution Anti-Patterns
+
+| Anti-Pattern                                | Problem                           | Fix                                   |
+| ------------------------------------------- | --------------------------------- | ------------------------------------- |
+| Passing entire AGENTS.md as runtime context | Bloats token budget on every task | Load via static injection only        |
+| Runtime state persisting across waves       | Stale context poisons next wave   | Clear runtime state between waves     |
+| No objective in task packet                 | Agent drifts from goal            | Always include one-sentence objective |
+| Injection without scope                     | Agent modifies wrong files        | Always declare file scope             |
+
+### Static Context Files (Always Inject)
+
+These files are the project's invariant layer. Always available, never stale:
+
+```
+.opencode/memory/project/
+├── user.md          # User preferences, workflow rules
+├── tech-stack.md    # Frameworks, constraints
+├── gotchas.md       # Footguns, warnings
+└── project.md       # Vision, success criteria
+```
+
+### Runtime Context Files (Per-Task)
+
+These are created fresh per task and cleaned up after:
+
+```
+.beads/artifacts/<task-id>/
+├── delegation.md    # Task-specific instructions
+├── spec.md          # Technical requirements
+└── progress.txt     # Task state (append-only)
+```

package/dist/template/.opencode/skill/executing-plans/SKILL.md

@@ -56,6 +56,13 @@ If concerns: Wait for human to decide and resubmit
 
 **Default: First 3 tasks**
 
+**Before starting a batch**: create a wave-start git tag for safe rollback:
+
+```bash
+# Tag the safe point before this batch/wave
+git tag wave-${BATCH_NUMBER}-start
+```
+
 For each task:
 
 1. Mark as in_progress
@@ -63,12 +70,20 @@ For each task:
 3. Run verifications as specified
 4. Mark as completed
 
+**After batch passes all gates**: create a wave-complete tag:
+
+```bash
+# Seal the completed wave - confirms all gates passed
+git tag wave-${BATCH_NUMBER}-complete
+```
+
 ### Step 3: Report
 
 When batch complete:
 
 - Show what was implemented
 - Show verification output
+- Show wave tag created (e.g., `wave-1-complete`)
 - Say: "Ready for feedback."
 
 ### Step 4: Continue
@@ -87,6 +102,61 @@ After all tasks complete and verified:
 - **REQUIRED SUB-SKILL:** Use skill({ name: "finishing-a-development-branch" })
 - Follow that skill to verify tests, present options, execute choice
 
+## Wave-Level Rollback with Git Tags
+
+Git tags act as checkpoints between waves. If a wave fails irrecoverably, roll back to the last known-good state.
+
+### Tag Protocol
+
+| When                         | Command                         | Purpose                   |
+| ---------------------------- | ------------------------------- | ------------------------- |
+| Before starting any batch    | `git tag wave-N-start`          | Mark rollback point       |
+| After batch passes all gates | `git tag wave-N-complete`       | Seal confirmed-good state |
+| On irrecoverable failure     | `git reset --hard wave-N-start` | Restore to pre-wave state |
+| Listing all wave checkpoints | `git tag --list "wave-*"`       | Audit trail of execution  |
+
+### When to Rollback
+
+Roll back (with user confirmation) when:
+
+- Build gates fail twice consecutively in the same wave
+- Unexpected destructive changes were made
+- Drift check detects unrecoverable scope creep
+- Tests were broken and the cause is unclear
+
+**Always ask the user before running `git reset --hard`** - it discards uncommitted changes irreversibly.
+
+### Rollback Steps
+
+```bash
+# 1. Identify safe point
+git tag --list "wave-*"
+# e.g.: wave-1-complete  wave-2-start  wave-2-complete  wave-3-start
+
+# 2. Confirm with user: rollback to which tag?
+# e.g.: git reset --hard wave-2-complete (last known good)
+
+# 3. Execute rollback (ONLY after user confirms)
+git reset --hard wave-2-complete
+
+# 4. Verify state is clean
+npm run typecheck && npm run lint
+
+# 5. Re-plan the failed batch with new approach
+```
+
+### Tag Naming Convention
+
+```
+wave-1-start      # Before batch 1 starts
+wave-1-complete   # After batch 1 passes all gates
+wave-2-start      # Before batch 2 starts
+wave-2-complete   # After batch 2 passes all gates
+...
+```
+
+Use numeric batch numbers, not task names, for predictable reference.
+
 ## When to Stop and Ask for Help
 
 **STOP executing immediately when:**

package/dist/template/.opencode/skill/finishing-a-development-branch/SKILL.md

@@ -175,6 +175,107 @@ git worktree remove <worktree-path>
 | 3. Keep as-is    | -     | -    | ✓             | -              |
 | 4. Discard       | -     | -    | -             | ✓ (force)      |
 
+## Mandatory Build Gates (Longshot Pattern)
+
+**Build gates are non-optional before any merge/PR/close.** Advisory verification has failed at scale — gates must be enforced as hard blockers.
+
+### Gate Sequence
+
+Every bead MUST pass all three gates in order. No exceptions.
+
+```bash
+# Gate 1: Typecheck
+npm run typecheck
+# Must exit 0. If fails → STOP. Fix types first.
+
+# Gate 2: Lint
+npm run lint
+# Must exit 0. If fails → STOP. Run npm run lint:fix, then fix remaining.
+
+# Gate 3: Tests
+bun test
+# Must exit 0. If fails → STOP. Fix failing tests first.
+```
+
+### Gate Enforcement Script
+
+Run before every merge, PR creation, or bead close:
+
+```bash
+#!/bin/bash
+# Run mandatory gates — all must pass
+
+echo "Gate 1/3: Typecheck..."
+npm run typecheck || { echo "FAILED: Fix type errors before proceeding."; exit 1; }
+
+echo "Gate 2/3: Lint..."
+npm run lint || {
+  echo "Attempting auto-fix..."
+  npm run lint:fix
+  npm run lint || { echo "FAILED: Fix lint errors before proceeding."; exit 1; }
+}
+
+echo "Gate 3/3: Tests..."
+bun test || { echo "FAILED: Fix failing tests before proceeding."; exit 1; }
+
+echo "All gates passed. Safe to merge/PR/close."
+```
+
+### Gate Failure Response
+
+| Gate Failure | First Action                     | If Still Failing            |
+| ------------ | -------------------------------- | --------------------------- |
+| Typecheck    | Fix type errors at reported line | Use LSP hover for type info |
+| Lint         | Run `npm run lint:fix`           | Fix remaining manually      |
+| Tests        | Read failing test output         | Fix implementation or test  |
+
+### Hard Rules
+
+**NEVER:**
+
+- Close a bead without passing all 3 gates
+- Create a PR without passing all 3 gates
+- Merge locally without passing all 3 gates on merged result
+- Skip gates "because the change is small"
+
+**ALWAYS:**
+
+- Run gates after EVERY non-trivial file change
+- Re-run gates after fixing gate failures (to catch regressions)
+- Run gates on the merged result, not just the branch
+
+### Integration with Bead Workflow
+
+```bash
+# Before closing any bead:
+npm run typecheck && npm run lint && bun test
+
+# If all pass:
+br close <id> --reason "Implementation complete. All gates passed."
+br sync --flush-only
+
+# If any fail:
+# STOP. Fix. Re-run gates. Then close.
+```
+
+### Gate State in Delegation Packets
+
+Workers must include gate results in their completion report:
+
+```markdown
+## Completion Report
+
+### Gate Results
+
+- [ ] typecheck: PASS / FAIL (error: ...)
+- [ ] lint: PASS / FAIL (error: ...)
+- [ ] tests: PASS / FAIL (N failed, N passed)
+
+### Gate Command Used
+
+`npm run typecheck && npm run lint && bun test`
+```
+
 ## Common Mistakes
 
 **Skipping test verification**

package/dist/template/.opencode/skill/swarm-coordination/SKILL.md

@@ -15,10 +15,11 @@ Coordinate multiple agents working on independent tasks in parallel using Kimi K
 
 ## Overview
 
-**Swarm = Leader + Workers + Progress Tracking + Todo Persistence**
+**Swarm = Leader + Workers + Reconciler + Progress Tracking + Todo Persistence**
 
 - **Leader (build agent)**: Orchestrates the swarm - analyzes tasks, spawns workers, monitors progress, synthesizes results
 - **Workers (general/explore/review/plan agents)**: Execute independent tasks - read delegation, make changes, report progress
+- **Reconciler**: Watches for CI failures, detects broken builds, auto-spawns fix tasks - this is the self-healing mechanism
 - **Progress Tracker (swarm-progress.jsonl)**: Real-time progress updates with TUI visualization
 - **Todo Persistence (swarm-todos.json)**: Cross-session recovery for interrupted swarms
 
@@ -68,8 +69,8 @@ Coordinate multiple agents working on independent tasks in parallel using Kimi K
 │  - Monitors progress via swarm tool                             │
 │  - Synthesizes final results                                     │
 └─────────────────────────────────────────────────────────────────┘
-         │                    │                    │
-         ▼                    ▼                    ▼
+          │                    │                    │
+          ▼                    ▼                    ▼
 ┌─────────────┐      ┌─────────────┐      ┌─────────────┐
 │  WORKER-1   │      │  WORKER-2   │      │  WORKER-3   │
 │  (general)  │      │  (general)  │      │  (general)  │
@@ -79,15 +80,288 @@ Coordinate multiple agents working on independent tasks in parallel using Kimi K
 │ - Execute   │      │ - Execute   │      │ - Execute   │
 │ - Report    │      │ - Report    │      │ - Report    │
 └─────────────┘      └─────────────┘      └─────────────┘
-         │                    │                    │
-         └────────────────────┼────────────────────┘
-                              ▼
-                    ┌─────────────────┐
-                    │  PROGRESS +     │
-                    │  TODO PERSIST   │
-                    └─────────────────┘
+          │                    │                    │
+          └────────────────────┼────────────────────┘
+                               ▼
+                     ┌─────────────────┐
+                     │   RECONCILER    │
+                     │                 │
+                     │ - Watch CI      │
+                     │ - Detect broken │
+                     │ - Spawn fixes   │
+                     └─────────────────┘
+                               │
+                               ▼
+                     ┌─────────────────┐
+                     │  PROGRESS +     │
+                     │  TODO PERSIST   │
+                     └─────────────────┘
 ```
 
+## Reconciler Agent Pattern (Self-Healing)
+
+The reconciler is the key to scaling beyond 50+ agents. Without reconciliation, broken builds cascade and the swarm collapses. The reconciler provides **continuous self-healing** by watching for failures and spawning targeted fix tasks.
+
+### When to Use Reconciler
+
+- **50+ agents** running in parallel → **REQUIRED**
+- **10-50 agents** → Recommended
+- **<10 agents** → Optional (leader can handle)
+
+### Reconciler Responsibilities
+
+1. **Watch CI/Build Status**: Monitor build gates continuously
+2. **Detect Failures**: Identify which worker caused the failure
+3. **Analyze Root Cause**: Determine if it's a merge conflict, test failure, or type error
+4. **Spawn Fix Tasks**: Create targeted fix tasks with context about what failed
+5. **Verify Fix**: Wait for fix to pass gates before continuing
+
+### Reconciler vs Leader
+
+| Aspect         | Leader                        | Reconciler                    |
+| -------------- | ----------------------------- | ----------------------------- |
+| Focus          | Orchestration, spawning       | Recovery, fixing              |
+| Runs           | At swarm start, between waves | Continuously during execution |
+| On failure     | Spawns workers                | Spawns fix tasks              |
+| Failure impact | Can't start work              | Wave can't complete           |
+
+### Implementing Reconciler
+
+The reconciler runs in a loop during swarm execution:
+
+```typescript
+// Reconciler runs in background during swarm execution
+async function runReconciler(teamName: string, buildCommand: string) {
+  while (swarmActive) {
+    // 1. Check build status
+    const status = await swarm({
+      operation: "monitor",
+      operation: "status",
+      team_name: teamName,
+    });
+    const stats = JSON.parse(status).summary;
+
+    // 2. If there are errors, investigate
+    if (stats.errors > 0) {
+      // 3. Get error details
+      const errors = await getWorkerErrors(teamName);
+
+      for (const error of errors) {
+        // 4. Analyze root cause
+        const cause = await analyzeError(error);
+
+        // 5. Spawn fix task
+        const fixBead = await br create({
+          title: `Fix: ${cause.summary}`,
+          type: "bug",
+          description: `Detected by reconciler: ${error.message}. Root cause: ${cause.rootCause}. Suggested fix: ${cause.suggestion}`,
+        });
+
+        // 6. Assign to targeted worker
+        await Task({
+          subagent_type: "general",
+          description: `Fix ${error.worker}`,
+          prompt: `Fix the error in ${error.file}.
+
+Error: ${error.message}
+Root cause: ${cause.rootCause}
+Suggested fix: ${cause.suggestion}
+
+Run: ${buildCommand}
+Verify: npm run typecheck && npm run lint`,
+        });
+      }
+    }
+
+    // Wait before next check
+    await sleep(30000); // Check every 30 seconds
+  }
+}
+```
+
+### Error Analysis Patterns
+
+The reconciler categorizes errors:
+
+| Error Type     | Detection                        | Fix Strategy                 |
+| -------------- | -------------------------------- | ---------------------------- |
+| Merge conflict | "CONFLICT" in output, git status | Re-base, resolve, force push |
+| Type error     | "typecheck failed"               | Fix types, run typecheck     |
+| Test failure   | "test failed", "expect" mismatch | Fix test or implementation   |
+| Lint error     | "lint failed", formatting issues | Run lint:fix                 |
+| Build error    | "build failed", bundler errors   | Fix imports, dependencies    |
+
+### Spawning Fix Tasks
+
+When the reconciler spawns a fix task, it includes:
+
+```typescript
+// Create fix task with full context
+await br create({
+  title: `Fix: ${error.type} in ${error.file}`,
+  type: "bug",
+  description: `## Error Detected
+- Worker: ${error.worker}
+- File: ${error.file}
+- Error: ${error.message}
+- Timestamp: ${error.timestamp}
+
+## Root Cause Analysis
+${cause.explanation}
+
+## Suggested Fix
+${cause.suggestion}
+
+## Verification
+Run: ${buildCommand}
+Must pass before wave can complete.`,
+});
+```
+
+### Reconciler in Wave Execution
+
+Add reconciler monitoring to each wave:
+
+```typescript
+// Execute wave with reconciler
+async function executeWaveWithReconciler(wave, teamName) {
+  // Start reconciler in background
+  const reconciler = runReconciler(teamName, "npm run typecheck && npm run lint");
+
+  // Execute workers in this wave
+  await Promise.all(wave.tasks.map(spawnWorker));
+
+  // Wait for all workers + reconciler to complete
+  await reconciler;
+
+  // Verify wave output before proceeding
+  await bash("npm run typecheck && npm run lint");
+}
+```
+
+### Example: Full Swarm with Reconciler
+
+```typescript
+// Full swarm execution with reconciler
+async function runSwarmWithReconciler(tasks, teamName) {
+  // 1. Analyze and create waves
+  const waves = createWaves(tasks);
+
+  // 2. Execute each wave with reconciler
+  for (const wave of waves) {
+    console.log(`Executing wave ${wave.number} with ${wave.tasks.length} tasks`);
+
+    // Start reconciler for this wave
+    const reconcilerPromise = runReconciler(teamName, "npm run typecheck && npm run lint");
+
+    // Spawn workers
+    await Promise.all(wave.tasks.map((task) => spawnWorker(task, teamName)));
+
+    // Wait for reconciler to finish fixing any errors
+    await reconcilerPromise;
+
+    // Verify wave output
+    const result = await bash("npm run typecheck && npm run lint");
+    if (!result.success) {
+      throw new Error(`Wave ${wave.number} failed gates`);
+    }
+
+    console.log(`Wave ${wave.number} complete`);
+  }
+}
+```
+
+## Drift Check After Each Wave
+
+After every wave completes and before starting the next, run a **drift check** to verify the codebase has not deviated from the intended state. Accumulated drift between waves is the primary cause of cascading failures in large swarms.
+
+**Drift** = any difference between actual codebase state and the plan's expected state at a wave boundary.
+
+### What to Check
+
+| Check             | Command                                            | Passing Condition              |
+| ----------------- | -------------------------------------------------- | ------------------------------ |
+| Build gates       | `npm run typecheck && npm run lint`                | Zero errors                    |
+| Unexpected files  | `git diff --name-only HEAD`                        | Only planned files modified    |
+| Missing artifacts | Verify expected files exist                        | All declared outputs present   |
+| Scope adherence   | Compare `git status` vs wave's declared file scope | No out-of-scope files modified |
+
+### Drift Check Protocol
+
+Run after every wave, before spawning the next:
+
+```typescript
+async function driftCheckAfterWave(wave: Wave, expectedFiles: string[]) {
+  console.log(`\n=== DRIFT CHECK: Wave ${wave.number} ===`);
+
+  // 1. Build gates must pass
+  const gates = await bash("npm run typecheck && npm run lint");
+  if (!gates.success) {
+    throw new Error(`Wave ${wave.number} drift: build gates failed\n${gates.output}`);
+  }
+
+  // 2. Detect unexpected file modifications
+  const changedFiles = await bash("git diff --name-only HEAD");
+  const actualFiles = changedFiles.output.trim().split("\n").filter(Boolean);
+  const unexpected = actualFiles.filter((f) => !expectedFiles.includes(f));
+
+  if (unexpected.length > 0) {
+    console.warn(`⚠️  Unexpected files modified in wave ${wave.number}:`);
+    unexpected.forEach((f) => console.warn(`  - ${f}`));
+  }
+
+  // 3. Verify declared artifacts exist
+  for (const artifact of wave.expectedArtifacts ?? []) {
+    const exists = await bash(`test -f ${artifact} && echo "ok" || echo "missing"`);
+    if (exists.output.trim() === "missing") {
+      throw new Error(`Wave ${wave.number} drift: expected artifact missing: ${artifact}`);
+    }
+  }
+
+  console.log(`✓ Drift check passed: Wave ${wave.number}`);
+}
+```
+
+### Integration in Wave Execution
+
+Call drift check between every wave:
+
+```typescript
+for (let i = 0; i < waves.length; i++) {
+  const wave = waves[i];
+  const reconciler = runReconciler(teamName, "npm run typecheck && npm run lint");
+
+  await Promise.all(wave.tasks.map((task) => spawnWorker(task, teamName)));
+  await reconciler;
+
+  // MANDATORY: Drift check before next wave
+  await driftCheckAfterWave(
+    wave,
+    wave.tasks.flatMap((t) => t.assignedFiles),
+  );
+
+  console.log(`✓ Wave ${i + 1}/${waves.length} complete and verified`);
+}
+```
+
+### Drift Response Protocol
+
+| Drift Type               | Severity | Action                                           |
+| ------------------------ | -------- | ------------------------------------------------ |
+| Build gate failure       | Critical | Stop swarm, run reconciler, fix before next wave |
+| Unexpected file modified | Warning  | Review change, revert if out of scope            |
+| Missing artifact         | Critical | Re-run failed worker task, verify output         |
+| Scope creep              | Warning  | Escalate to user if >3 unexpected files changed  |
+
+### When Drift Is Unrecoverable
+
+If drift check fails twice in a row on the same wave:
+
+1. **Stop the swarm** - don't start next wave
+2. **Report to user**: exact drift details, failing gate output, list of unexpected files
+3. **Rollback option**: use `git reset --hard <wave-N-start-tag>` (see `executing-plans` skill)
+4. **Never paper over drift** - proceeding with known drift compounds into cascading failure
+
 ## Swarm Launch Flow - PARL Pattern (7 Steps)
 
 ### Step 0: Task Analysis (Anti-Serial-Collapse + Dependency Graph)
@@ -706,3 +980,84 @@ This renders the beautiful TUI block and shows:
 7. **Use dependency graph** - Spawn workers in parallelizable_groups order
 8. **Graceful shutdown** - Leader waits for all workers, syncs back to Beads
 9. **Use tmux for visibility** - Enable visual monitoring when available
+10. **Use reconciler at scale** - Required for 50+ agents, recommended for 10+
+11. **Reconciler watches continuously** - Spawns fix tasks on detected failures
+
+## Tier Enforcement (Longshot Pattern)
+
+For multi-agent execution at scale (10+ agents), enforce explicit tier hierarchy. This is the Longshot pattern that enabled 200 agents to build Minecraft.
+
+### Tier System
+
+| Tier            | Role                  | Swarm Equivalent | Responsibility                                                 |
+| --------------- | --------------------- | ---------------- | -------------------------------------------------------------- |
+| **planner**     | Lead orchestrator     | Build agent      | Analyzes scope, decomposes into sub-tasks, coordinates workers |
+| **sub-planner** | Mid-level coordinator | N/A              | Takes planner output, further decomposes, assigns to workers   |
+| **worker**      | Execution agent       | Worker agents    | Executes assigned work, reports progress                       |
+
+### When Tiers Are Required
+
+- **<10 agents**: Optional - flat decomposition works
+- **10-50 agents**: Recommended - planner + workers
+- **50+ agents**: Required - planner + sub-planners + workers
+
+### Enforcing Tier Boundaries
+
+The swarm leader enforces tier boundaries:
+
+```typescript
+// Tier enforcement in swarm execution
+async function enforceTiers(waves, tierConfig) {
+  // Wave 1: Planner tasks only
+  const planners = waves.filter((w) => w.tier === "planner");
+  await executeWave(planners);
+
+  // Wave 2: Sub-planner tasks (if any)
+  const subPlanners = waves.filter((w) => w.tier === "sub-planner");
+  await executeWave(subPlanners);
+
+  // Wave 3+: Worker tasks
+  const workers = waves.filter((w) => w.tier === "worker");
+  await executeWave(workers);
+}
+```
+
+### Handoff Contracts Between Tiers
+
+Each tier must declare handoff contracts:
+
+```typescript
+// Planner declares what it produces for sub-planners
+const plannerHandoff = {
+  produces: [
+    { artifact: "docs/auth-design.md", format: "markdown" },
+    { artifact: "tasks/auth-tasks.json", format: "json" },
+  ],
+  consumedBy: ["sub-planner-auth"],
+};
+
+// Worker declares what it consumes from sub-planners
+const workerHandoff = {
+  consumes: [{ artifact: "tasks/auth-tasks.json", format: "json" }],
+  produces: [{ artifact: "src/auth/service.ts", format: "typescript" }],
+};
+```
+
+### Anti-Pattern: Flat Decomposition at Scale
+
+Without tiers, 20 agents get 20 flat tasks → chaos:
+
+- Workers step on each other
+- No coordination between related work
+- Merge conflicts everywhere
+- No clear ownership
+
+With tiers (Longshot pattern):
+
+```
+Lead Planner → Sub-planner A → Worker 1, 2, 3
+              → Sub-planner B → Worker 4, 5, 6
+              Sub-planner C → Worker 7, 8, 9
+```
+
+This mirrors real engineering orgs: lead → tech lead → IC. The architecture is the differentiator.

package/dist/template/.opencode/skill/writing-plans/SKILL.md

@@ -90,10 +90,119 @@ Task C (User API): needs Task A, creates src/api/users.ts
 Wave 1: A, B (parallel)
 Wave 2: C (after Wave 1)
 
+````
+
+## Tiered Task Hierarchy
+
+For multi-agent execution at scale (10+ agents), use explicit tier declarations. This prevents flat decomposition that fails when many agents work in parallel.
+
+### Tier Definitions
+
+| Tier | Role | Description | Example |
+|------|------|-------------|---------|
+| **planner** | Lead orchestrator | Analyzes scope, decomposes into sub-tasks, coordinates workers | "Design auth system" |
+| **sub-planner** | Mid-level coordinator | Takes planner output, further decomposes, assigns to workers | "Break auth into API, model, middleware" |
+| **worker** | Execution agent | Executes assigned work, reports progress | "Implement auth service" |
+
+### When to Use Tiers
+
+- **<10 agents**: Optional - flat decomposition works
+- **10-50 agents**: Recommended - planner + workers
+- **50+ agents**: Required - planner + sub-planners + workers
+
+### Tier Declaration Format
+
+Add tier metadata to each task:
+
+```markdown
+### Task 1: Design Auth System
+
+**Tier:** planner
+
+**Files:**
+- Create: `docs/auth-design.md`
+
+This task decomposes the auth feature into sub-tasks for implementation.
+````
+
+### Handoff Contracts
+
+Tasks must declare what they produce for downstream tasks:
+
+```markdown
+### Handoff Contract
+
+**Produces:**
+
+- `docs/auth-design.md` - Architecture decision document
+
+**Consumed By:**
+
+- Task 2: Implement Auth Service
+- Task 3: Add Auth Tests
+```
+
+### Tier Enforcement in Plans
+
+```markdown
+# [Feature Name] Implementation Plan
+
+> **Tier Structure:**
+>
+> - **Planners (2):** Task 1, Task 5
+> - **Workers (6):** Tasks 2,3,4,6,7,8
+
+## Task Hierarchy
+
+### Tier 1: Planner Tasks (Orchestration)
+
+### Task 1: [Planner] Design Auth System
+
+### Task 5: [Planner] Design API Layer
+
+### Tier 2: Worker Tasks (Execution)
+
+### Task 2: [Worker] Implement Auth Service
+
+### Task 3: [Worker] Add Auth Middleware
+
+### Task 4: [Worker] Write Auth Tests
 ```
 
+### Wave Execution with Tiers
+
+When executing with tiers:
+
+1. **Planner waves** execute first (scope definition)
+2. **Worker waves** execute after planner output is ready
+3. **Sub-planners** sit between, bridging planner → worker
+
+```markdown
+Wave 1 (Planners): Task 1, Task 5
+Wave 2 (Workers): Tasks 2, 3, 4 (after Task 1)
+Wave 3 (Workers): Tasks 6, 7, 8 (after Task 5)
 ```
 
+### Anti-Pattern: Flat Decomposition at Scale
+
+Without tiers, 20 agents get 20 flat tasks → chaos:
+
+- Workers step on each other
+- No coordination between related work
+- Merge conflicts everywhere
+
+With tiers, the structure emerges:
+
+```
+Planner → Sub-planner A → Worker 1, 2, 3
+                     → Worker 4, 5
+        Sub-planner B → Worker 6, 7
+```
+
+This mirrors real engineering orgs: lead → tech lead → IC.
+
+`````
+
 ## Context Budget
 
 Target: ~50% context per plan execution
@@ -130,7 +239,8 @@ Maximum: 2-3 tasks per plan
 def test_specific_behavior():
     result = function(input)
     assert result == expected
-```
+`````
+
 ````
 
 **Step 2: Run test to verify it fails**
@@ -187,3 +297,4 @@ After saving the plan, offer execution choice:
 - Guide them to open new session in worktree
 - **REQUIRED SUB-SKILL:** New session uses skill({ name: "executing-plans" })
 ```
+````

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.17.9",
+	"version": "0.17.10",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",