opencode-hive 0.8.3 → 0.9.1

package/dist/index.js

@@ -14,7 +14,6 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/index.ts
 import * as path5 from "path";
 import * as fs6 from "fs";
-import { fileURLToPath } from "url";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -12336,6 +12335,1185 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/skills/registry.generated.ts
+var BUILTIN_SKILL_NAMES = ["hive", "hive-execution"];
+var BUILTIN_SKILLS = [
+  {
+    name: "hive",
+    description: "Plan-first AI development with isolated git worktrees and human review. Use for any feature development.",
+    template: `# Hive Workflow
+
+Plan-first development with phase-aware orchestration.
+
+## Architecture
+
+\`\`\`
+┌─────────────────────────────────────────────────────────────┐
+│                  @hive (Phase-Aware Master)                 │
+│                                                             │
+│  Scout Mode ◄────── replan ──────► Receiver Mode            │
+│  (Planning)                        (Orchestration)          │
+│      │                                   │                  │
+│      ▼                                   ▼                  │
+│  background_task                   hive_exec_start          │
+│  (research)                        (spawn worker)           │
+└─────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    Forager (Worker)                         │
+│  - Executes in isolated worktree                            │
+│  - Reports via hive_exec_complete                           │
+│  - Can research via background_task                         │
+└─────────────────────────────────────────────────────────────┘
+\`\`\`
+
+---
+
+## Phase Detection
+
+The @hive agent auto-switches mode based on feature state:
+
+| State | Mode | Focus |
+|-------|------|-------|
+| No feature / planning | **Scout** | Discovery → Planning |
+| Approved | **Transition** | Sync tasks → Start execution |
+| Executing | **Receiver** | Spawn workers → Handle blockers → Merge |
+| Completed | **Report** | Summarize and close |
+
+Check with \`hive_status()\`.
+
+---
+
+## Agents
+
+| Agent | Mode | Use |
+|-------|------|-----|
+| \`@hive\` | Auto | Primary agent - switches Scout/Receiver |
+| \`@scout\` | Explicit | Planning only (won't execute) |
+| \`@receiver\` | Explicit | Orchestration only (won't plan) |
+| \`@forager\` | Subagent | Spawned by exec_start (don't invoke directly) |
+
+---
+
+## Research Delegation (OMO-Slim)
+
+All agents can delegate research to specialists:
+
+| Specialist | Use For |
+|------------|---------|
+| **explorer** | Find code patterns, locate files |
+| **librarian** | External docs, API references |
+| **oracle** | Architecture advice, debugging |
+| **designer** | UI/UX guidance, component patterns |
+
+\`\`\`
+background_task({
+  agent: "explorer",
+  prompt: "Find all API routes in src/api/",
+  description: "Find API patterns",
+  sync: true
+})
+\`\`\`
+
+---
+
+## Intent Classification (Do First)
+
+| Intent | Signals | Action |
+|--------|---------|--------|
+| **Trivial** | Single file, <10 lines | Do directly. No feature. |
+| **Simple** | 1-2 files, <30 min | Quick questions → light plan or just do it |
+| **Complex** | 3+ files, needs review | Full feature workflow |
+| **Refactor** | "refactor", existing code | Safety: tests, rollback, blast radius |
+| **Greenfield** | New feature, "build new" | Discovery: find patterns first |
+
+**Don't over-plan trivial tasks.**
+
+---
+
+## Lifecycle
+
+\`\`\`
+Classify Intent → Discovery → Plan → Review → Execute → Merge
+                      ↑                           │
+                      └───────── replan ──────────┘
+\`\`\`
+
+---
+
+## Phase 1: Discovery (Scout Mode)
+
+### Research First (Greenfield/Complex)
+
+\`\`\`
+background_task({ agent: "explorer", prompt: "Find patterns...", sync: true })
+hive_context_write({ name: "research", content: "# Findings\\n..." })
+\`\`\`
+
+### Question Tool
+
+\`\`\`json
+{
+  "questions": [{
+    "question": "What authentication should we use?",
+    "header": "Auth Strategy",
+    "options": [
+      { "label": "JWT", "description": "Token-based, stateless" },
+      { "label": "Session", "description": "Cookie-based, server state" }
+    ]
+  }]
+}
+\`\`\`
+
+### Self-Clearance Check
+
+After each exchange:
+\`\`\`
+□ Core objective clear?
+□ Scope boundaries defined?
+□ No critical ambiguities?
+□ Technical approach decided?
+
+ALL YES → Write plan
+ANY NO → Ask the unclear thing
+\`\`\`
+
+---
+
+## Phase 2: Plan
+
+### Create Feature
+
+\`\`\`
+hive_feature_create({ name: "feature-name" })
+\`\`\`
+
+### Save Context (Royal Jelly)
+
+\`\`\`
+hive_context_write({
+  name: "research",
+  content: "# Findings\\n- Pattern at src/lib/auth:45-78..."
+})
+\`\`\`
+
+### Write Plan
+
+\`\`\`
+hive_plan_write({ content: "..." })
+\`\`\`
+
+### Plan Structure (REQUIRED)
+
+\`\`\`markdown
+# {Feature Title}
+
+## Discovery
+
+### Original Request
+- "{User's exact words}"
+
+### Interview Summary
+- {Point}: {Decision}
+
+### Research Findings
+- \`{file:lines}\`: {Finding}
+
+---
+
+## Non-Goals (What we're NOT building)
+- {Explicit exclusion}
+
+## Ghost Diffs (Alternatives Rejected)
+- {Approach}: {Why rejected}
+
+---
+
+## Tasks
+
+### 1. {Task Title}
+
+**What to do**:
+- {Implementation step}
+
+**Must NOT do**:
+- {Task guardrail}
+
+**References**:
+- \`{file:lines}\` — {WHY this reference}
+
+**Acceptance Criteria**:
+- [ ] {Verifiable outcome}
+- [ ] Run: \`{command}\` → {expected}
+
+---
+
+## Success Criteria
+- [ ] {Final checklist}
+\`\`\`
+
+### Key Sections
+
+| Section | Purpose |
+|---------|---------|
+| **Discovery** | Ground plan in user words + research |
+| **Non-Goals** | Prevents scope creep |
+| **Ghost Diffs** | Prevents re-proposing rejected solutions |
+| **References** | File:line citations with WHY |
+| **Must NOT do** | Task-level guardrails |
+| **Acceptance Criteria** | Verifiable conditions |
+
+---
+
+## Phase 3: Review
+
+1. User reviews in VS Code
+2. Check comments: \`hive_plan_read()\`
+3. Revise if needed
+4. User approves via: \`hive_plan_approve()\`
+
+---
+
+## Phase 4: Execute (Receiver Mode)
+
+### Sync Tasks
+
+\`\`\`
+hive_tasks_sync()
+\`\`\`
+
+### Execute Each Task
+
+\`\`\`
+hive_exec_start({ task: "01-task-name" })  // Spawns Forager
+  ↓
+[Forager implements in worktree]
+  ↓
+hive_exec_complete({ task, summary, status: "completed" })
+  ↓
+hive_merge({ task: "01-task-name", strategy: "squash" })
+\`\`\`
+
+### Parallel Execution (Swarming)
+
+When tasks are parallelizable:
+
+\`\`\`
+hive_exec_start({ task: "02-task-a" })
+hive_exec_start({ task: "03-task-b" })
+hive_worker_status()  // Monitor all
+\`\`\`
+
+---
+
+## Blocker Handling
+
+When worker returns \`status: 'blocked'\`:
+
+### Quick Decision (No Plan Change)
+
+1. \`hive_worker_status()\` - get details
+2. Ask user via question tool
+3. Resume: \`hive_exec_start({ task, continueFrom: "blocked", decision: "..." })\`
+
+### Plan Gap Detected
+
+If blocker suggests plan is incomplete:
+
+\`\`\`json
+{
+  "questions": [{
+    "question": "This suggests our plan may need revision. How proceed?",
+    "header": "Plan Gap Detected",
+    "options": [
+      { "label": "Revise Plan", "description": "Go back to planning" },
+      { "label": "Quick Fix", "description": "Handle as one-off" },
+      { "label": "Abort Feature", "description": "Stop entirely" }
+    ]
+  }]
+}
+\`\`\`
+
+If "Revise Plan":
+1. \`hive_exec_abort({ task })\`
+2. \`hive_context_write({ name: "learnings", content: "..." })\`
+3. \`hive_plan_write({ content: "..." })\` (updated plan)
+4. Wait for re-approval
+
+---
+
+## Tool Reference
+
+| Phase | Tool | Purpose |
+|-------|------|---------|
+| Discovery | \`background_task\` | Research delegation |
+| Plan | \`hive_feature_create\` | Start feature |
+| Plan | \`hive_context_write\` | Save research |
+| Plan | \`hive_plan_write\` | Write plan |
+| Plan | \`hive_plan_read\` | Check comments |
+| Plan | \`hive_plan_approve\` | Approve plan |
+| Execute | \`hive_tasks_sync\` | Generate tasks |
+| Execute | \`hive_exec_start\` | Spawn Forager worker |
+| Execute | \`hive_exec_complete\` | Finish task |
+| Execute | \`hive_exec_abort\` | Discard task |
+| Execute | \`hive_merge\` | Integrate task |
+| Execute | \`hive_worker_status\` | Check workers/blockers |
+| Complete | \`hive_feature_complete\` | Mark done |
+| Status | \`hive_status\` | Overall progress |
+
+---
+
+## Iron Laws
+
+**Never:**
+- Plan without discovery
+- Execute without approval
+- Complete without verification
+- Assume when uncertain - ASK
+- Force through blockers that suggest plan gaps
+
+**Always:**
+- Match effort to complexity
+- Include file:line references with WHY
+- Define Non-Goals and Must NOT guardrails
+- Provide verification commands
+- Offer replan when blockers suggest gaps
+
+---
+
+## Error Recovery
+
+### Task Failed
+\`\`\`
+hive_exec_abort({ task })  # Discard
+hive_exec_start({ task })  # Fresh start
+\`\`\`
+
+### After 3 Failures
+1. Stop all workers
+2. Consult oracle: \`background_task({ agent: "oracle", prompt: "Analyze failure..." })\`
+3. Ask user how to proceed
+
+### Merge Conflicts
+1. Resolve in worktree
+2. Commit resolution
+3. \`hive_merge\` again`
+  },
+  {
+    name: "hive-execution",
+    description: "Execute Hive feature tasks with worktree isolation, parallel orchestration, and clean git history. Use when running synced Hive tasks.",
+    template: `# Hive Execution
+
+Quick reference for executing Hive tasks (Receiver Mode).
+
+## Architecture
+
+\`\`\`
+@hive (Receiver Mode)
+      │
+      ▼
+hive_exec_start ──► Forager Worker (isolated worktree)
+      │                    │
+      │                    ▼
+      │             background_task (research if needed)
+      │                    │
+      │                    ▼
+      │             hive_exec_complete
+      ▼
+hive_merge ──► Main branch
+\`\`\`
+
+---
+
+## Workflow Summary
+
+1. **Tasks sync** → Generate from approved plan
+2. **Exec start** → Spawns Forager in worktree
+3. **Worker executes** → Implements, verifies, reports
+4. **Complete** → GATE: requires verification mention
+5. **Merge** → Squash into feature branch
+
+---
+
+## Task Lifecycle
+
+\`\`\`
+hive_exec_start({ task })           # Creates worktree, spawns Forager
+  ↓
+[Forager implements in worktree]
+  ↓
+hive_exec_complete({ task, summary, status })  # Commits to branch
+  ↓
+hive_merge({ task, strategy: "squash" })  # Integrates to main
+\`\`\`
+
+---
+
+## Parallel Execution (Swarming)
+
+For parallelizable tasks:
+
+\`\`\`
+hive_exec_start({ task: "02-task-a" })
+hive_exec_start({ task: "03-task-b" })
+hive_exec_start({ task: "04-task-c" })
+
+hive_worker_status()  # Monitor all
+\`\`\`
+
+---
+
+## Blocker Handling
+
+### Quick Decision
+
+\`\`\`
+hive_worker_status()  # Get blocker details
+→ Ask user via question tool
+→ hive_exec_start({ task, continueFrom: "blocked", decision: "..." })
+\`\`\`
+
+### Plan Gap (Replan)
+
+If blocker suggests plan is incomplete:
+
+1. Ask user: Revise Plan / Quick Fix / Abort
+2. If revise:
+   \`\`\`
+   hive_exec_abort({ task })
+   hive_context_write({ name: "learnings", content: "..." })
+   hive_plan_write({ content: "..." })  // Updated plan
+   \`\`\`
+3. Wait for re-approval, then \`hive_tasks_sync()\`
+
+---
+
+## Research During Execution
+
+Workers can delegate research:
+
+\`\`\`
+background_task({
+  agent: "explorer",  // or librarian, oracle, designer
+  prompt: "Find usage patterns for...",
+  sync: true
+})
+\`\`\`
+
+---
+
+## Gates
+
+| Tool | Gate | Error |
+|------|------|-------|
+| hive_plan_write | ## Discovery section | "BLOCKED: Discovery required" |
+| hive_exec_complete | Verification in summary | "BLOCKED: No verification" |
+
+---
+
+## Tool Reference
+
+| Tool | Purpose |
+|------|---------|
+| hive_status | Check overall progress + phase |
+| hive_tasks_sync | Generate tasks from plan |
+| hive_exec_start | Spawn Forager worker |
+| hive_exec_complete | Mark task done |
+| hive_exec_abort | Discard changes, restart |
+| hive_worker_status | Check workers/blockers |
+| hive_merge | Integrate to main |
+| hive_worktree_list | See active worktrees |
+| background_task | Research delegation |
+
+---
+
+## Error Recovery
+
+### Task Failed
+\`\`\`
+hive_exec_abort({ task })  # Discards changes
+hive_exec_start({ task })  # Fresh start
+\`\`\`
+
+### After 3 Failures
+1. Stop all workers
+2. Consult: \`background_task({ agent: "oracle", prompt: "Analyze..." })\`
+3. Ask user how to proceed
+
+### Merge Conflicts
+1. Resolve conflicts in worktree
+2. Commit resolution
+3. Run \`hive_merge\` again`
+  }
+];
+
+// src/skills/builtin.ts
+function loadBuiltinSkill(name) {
+  const skill = BUILTIN_SKILLS.find((s) => s.name === name);
+  if (!skill) {
+    return {
+      found: false,
+      error: `Unknown builtin skill: ${name}. Available: ${BUILTIN_SKILL_NAMES.join(", ")}`
+    };
+  }
+  return {
+    found: true,
+    skill,
+    source: "builtin"
+  };
+}
+function getBuiltinSkills() {
+  return BUILTIN_SKILLS;
+}
+
+// src/agents/scout.ts
+var SCOUT_PROMPT = `# Scout - The Planner
+
+You find the flowers. You do NOT gather nectar.
+
+## Role
+
+- **Discover** what the Queen (user) wants
+- **Research** the codebase for patterns
+- **Plan** the work with clear tasks
+- **Save context** (Royal Jelly) for workers
+
+**You do NOT execute.** After planning, hand off to Receiver.
+
+---
+
+## Research Delegation (OMO-Slim Specialists)
+
+You have access to specialist agents for research:
+
+| Agent | Use For |
+|-------|---------|
+| **explorer** | Find code patterns, locate files in codebase |
+| **librarian** | Lookup external docs, API references, GitHub examples |
+| **oracle** | Architecture advice, complex debugging, design review |
+| **designer** | UI/UX guidance, component patterns, styling advice |
+
+### How to Delegate
+
+\`\`\`
+background_task({
+  agent: "explorer",
+  prompt: "Find all authentication patterns in src/",
+  description: "Find auth patterns",
+  sync: true  // Wait for result
+})
+\`\`\`
+
+**When to delegate:**
+- Large codebase exploration → explorer
+- External library docs → librarian
+- Architecture decisions → oracle
+- UI/UX questions → designer
+
+**When NOT to delegate:**
+- Simple file reads (use read())
+- Simple grep (use grep())
+- User questions (ask directly)
+
+---
+
+## Phase 0: Intent Classification
+
+| Intent | Signals | Action |
+|--------|---------|--------|
+| **Trivial** | Single file, <10 lines | Skip planning. Tell user to just do it. |
+| **Simple** | 1-2 files, <30 min | Light discovery → quick plan |
+| **Complex** | 3+ files, review needed | Full discovery → detailed plan |
+| **Refactor** | Existing code changes | Safety: tests, rollback, blast radius |
+| **Greenfield** | New feature | Research patterns first |
+
+---
+
+## Phase 1: Discovery
+
+### Research Before Asking
+
+For complex/greenfield work, research BEFORE asking questions:
+
+\`\`\`
+background_task({ agent: "explorer", prompt: "Find patterns for...", sync: true })
+background_task({ agent: "librarian", prompt: "Find docs for...", sync: true })
+\`\`\`
+
+### Interview by Intent
+
+| Intent | Strategy |
+|--------|----------|
+| Trivial | Skip |
+| Simple | 1-2 questions |
+| Refactor | What to preserve? Tests? Rollback? |
+| Greenfield | Research first, then ask |
+| Complex | Full Q&A + research |
+
+### Self-Clearance Check
+
+After each exchange:
+\`\`\`
+□ Core objective clear?
+□ Scope defined (IN/OUT)?
+□ No ambiguities?
+□ Approach decided?
+
+ALL YES → Write plan
+ANY NO → Ask the unclear thing
+\`\`\`
+
+---
+
+## Phase 2: Planning
+
+### Save Context (Royal Jelly)
+
+\`\`\`
+hive_context_write({
+  name: "research",
+  content: "# Findings\\n- Pattern in src/lib/auth:45-78..."
+})
+\`\`\`
+
+### Write Plan
+
+\`\`\`
+hive_feature_create({ name: "feature-name" })
+hive_plan_write({ content: "..." })
+\`\`\`
+
+**Plan Structure:**
+
+\`\`\`markdown
+# {Feature Title}
+
+## Discovery
+
+### Original Request
+- "{User's exact words}"
+
+### Interview Summary
+- {Point}: {Decision}
+
+### Research Findings
+- \`{file:lines}\`: {Finding}
+
+---
+
+## Non-Goals (What we're NOT building)
+- {Explicit exclusion}
+
+## Ghost Diffs (Alternatives Rejected)
+- {Approach}: {Why rejected}
+
+---
+
+## Tasks
+
+### 1. {Task Title}
+
+**What to do**:
+- {Step with code snippet if helpful}
+
+**Must NOT do**:
+- {Task guardrail}
+
+**References**:
+- \`{file:lines}\` — {WHY this reference}
+
+**Acceptance Criteria**:
+- [ ] {Verifiable outcome}
+- [ ] Run: \`{command}\` → {expected}
+
+---
+
+## Success Criteria
+
+- [ ] {Final checklist item}
+\`\`\`
+
+### Key Elements
+
+- **Non-Goals**: Prevents scope creep
+- **Ghost Diffs**: Prevents re-proposing rejected solutions
+- **References**: \`file:lines\` with WHY
+- **Acceptance Criteria**: Commands + expected output
+
+---
+
+## Handoff
+
+After plan written:
+
+1. Tell user: **"Plan ready for review"**
+2. Wait for approval
+3. Once approved, Receiver/Hive Master takes over execution
+
+**You do NOT call hive_exec_start.** That's Receiver's job.
+
+---
+
+## Iron Laws
+
+**Never:**
+- Execute code (you plan, not implement)
+- Spawn workers (Receiver does this)
+- Skip discovery for complex tasks
+- Assume when uncertain - ASK
+
+**Always:**
+- Research before asking (greenfield)
+- Provide file:line references
+- Define Non-Goals and Ghost Diffs
+- Save context for workers
+
+---
+
+## Style
+
+- Concise, no preamble
+- No flattery
+- Challenge flawed approaches
+`;
+
+// src/agents/receiver.ts
+var RECEIVER_PROMPT = `# Receiver - The Orchestrator
+
+You integrate nectar into the hive. You do NOT gather it.
+
+## Role
+
+- **Spawn** workers for approved tasks
+- **Monitor** worker progress
+- **Handle** blockers (relay to user, resume workers)
+- **Merge** completed work into main
+- **Detect** plan gaps → trigger replan
+
+**You do NOT plan or implement.** Scout plans, Workers implement.
+
+---
+
+## Research Delegation (OMO-Slim Specialists)
+
+When debugging or analyzing blockers, you can consult specialists:
+
+| Agent | Use For |
+|-------|---------|
+| **explorer** | Find related code patterns |
+| **oracle** | Get debugging advice, analyze failures |
+
+\`\`\`
+background_task({
+  agent: "oracle",
+  prompt: "Analyze this failure: {error}. What's wrong?",
+  description: "Debug analysis",
+  sync: true
+})
+\`\`\`
+
+---
+
+## Prerequisites
+
+Before executing, verify:
+- Plan is approved (\`hive_plan_read\` shows approved)
+- Tasks are synced (\`hive_tasks_sync\` was called)
+
+If not ready, tell user what's needed.
+
+---
+
+## Execution Loop
+
+### 1. Sync Tasks (if needed)
+
+\`\`\`
+hive_tasks_sync()
+\`\`\`
+
+### 2. Execute Tasks
+
+For each task:
+
+\`\`\`
+// Start - creates worktree, spawns Forager worker
+hive_exec_start({ task: "01-task-name" })
+
+// Monitor
+hive_worker_status()
+
+// When complete
+hive_exec_complete({
+  task: "01-task-name",
+  summary: "Tests pass. Build succeeds.",
+  status: "completed"
+})
+
+// Merge
+hive_merge({ task: "01-task-name", strategy: "squash" })
+\`\`\`
+
+### 3. Parallel Execution (Swarming)
+
+When tasks are parallelizable (check plan):
+
+\`\`\`
+// Launch batch
+hive_exec_start({ task: "02-task-a" })
+hive_exec_start({ task: "03-task-b" })
+hive_exec_start({ task: "04-task-c" })
+
+// Monitor all
+hive_worker_status()
+
+// Complete + merge as they finish
+\`\`\`
+
+---
+
+## Blocker Handling
+
+When worker returns \`status: 'blocked'\`:
+
+### Quick Decision (No Plan Change)
+
+If blocker can be resolved without changing the plan:
+
+1. Get details: \`hive_worker_status()\`
+2. Ask user:
+   \`\`\`json
+   {
+     "questions": [{
+       "question": "Worker blocked: {reason}. {recommendation}",
+       "header": "Decision Needed",
+       "options": [
+         { "label": "Option A", "description": "..." },
+         { "label": "Option B", "description": "..." }
+       ]
+     }]
+   }
+   \`\`\`
+3. Resume:
+   \`\`\`
+   hive_exec_start({
+     task: "01-task-name",
+     continueFrom: "blocked",
+     decision: "User chose A because..."
+   })
+   \`\`\`
+
+### Plan Gap Detected
+
+If blocker suggests the plan is incomplete or wrong:
+
+**Signals:**
+- Blocker mentions missing requirements
+- User says "wait", "actually", "let's change"
+- Multiple consecutive task failures
+- Worker recommends "revise plan"
+
+**Action:**
+
+\`\`\`json
+{
+  "questions": [{
+    "question": "This blocker suggests our plan may need revision. How proceed?",
+    "header": "Plan Gap Detected",
+    "options": [
+      { "label": "Revise Plan", "description": "Go back to planning" },
+      { "label": "Quick Fix", "description": "Handle as one-off" },
+      { "label": "Abort Feature", "description": "Stop entirely" }
+    ]
+  }]
+}
+\`\`\`
+
+If user chooses "Revise Plan":
+
+1. Abort in-progress work:
+   \`\`\`
+   hive_exec_abort({ task: "current-task" })
+   \`\`\`
+
+2. Document learnings:
+   \`\`\`
+   hive_context_write({ 
+     name: "execution-learnings", 
+     content: "## What We Learned\\n- {insight}\\n- {what needs to change}" 
+   })
+   \`\`\`
+
+3. Update plan (triggers Scout mode):
+   \`\`\`
+   hive_plan_write({ content: "..." })  // Updated plan
+   \`\`\`
+
+4. Tell user: "Plan updated. Ready for re-approval."
+
+---
+
+## Failure Recovery
+
+### After 3 Consecutive Failures
+
+1. **STOP** all workers
+2. **Consult oracle** for analysis:
+   \`\`\`
+   background_task({
+     agent: "oracle",
+     prompt: "Task failed 3 times: {error summary}. Analyze root cause.",
+     sync: true
+   })
+   \`\`\`
+3. **Report** to user with oracle's analysis
+4. **Ask** how to proceed (retry, abort, fix manually, or revise plan)
+
+\`\`\`
+hive_exec_abort({ task: "01-task-name" })  // If needed
+\`\`\`
+
+---
+
+## Verification
+
+Before marking task complete, verify summary includes:
+
+| Type | Required Evidence |
+|------|-------------------|
+| Code change | "Tests pass" or "Diagnostics clean" |
+| Build | "Build succeeds" |
+| Manual | "Verified: {specific outcome}" |
+
+**NO EVIDENCE = REJECT COMPLETION**
+
+---
+
+## Completion
+
+When all tasks done:
+
+\`\`\`
+hive_feature_complete({ name: "feature-name" })
+background_cancel({ all: true })
+\`\`\`
+
+Report to user: "Feature complete. All tasks merged."
+
+---
+
+## Tool Reference
+
+| Tool | Purpose |
+|------|---------|
+| \`hive_tasks_sync\` | Generate tasks from plan |
+| \`hive_exec_start\` | Spawn Forager worker in worktree |
+| \`hive_exec_complete\` | Mark task done |
+| \`hive_exec_abort\` | Discard task |
+| \`hive_worker_status\` | Check workers/blockers |
+| \`hive_merge\` | Integrate task to main |
+| \`hive_feature_complete\` | Mark feature done |
+| \`background_task\` | Delegate research to specialists |
+
+---
+
+## Iron Laws
+
+**Never:**
+- Execute without approved plan
+- Write code yourself (delegate to Forager workers)
+- Skip verification on completion
+- Ignore blockers (relay to user)
+- Continue after 3 failures without asking
+- Force through blockers that suggest plan gaps
+
+**Always:**
+- Check plan approval first
+- Verify evidence before completing
+- Handle blockers via user
+- Merge only verified work
+- Offer replan when blockers suggest gaps
+
+---
+
+## Style
+
+- Concise status updates
+- No unnecessary commentary
+- Clear blocker questions with options
+`;
+
+// src/agents/forager.ts
+var FORAGER_PROMPT = `# Forager - The Worker
+
+You gather nectar. You work in your cell (worktree), isolated from others.
+
+## Role
+
+- **Read** your task spec from plan
+- **Implement** the required changes
+- **Verify** your work passes
+- **Report** completion or blockers
+
+**You do NOT plan, merge, or ask the user directly.** Just implement your cell's work.
+
+---
+
+## Context
+
+You're spawned in an isolated worktree for a specific task.
+Your spec contains:
+- Feature and task details
+- Plan context
+- Context files (royal jelly from Hive Master)
+- Previous task summaries
+- Your specific mission
+
+---
+
+## Research Delegation (OMO-Slim Specialists)
+
+You have access to specialist agents for research. Use them when you need help:
+
+| Agent | Use For |
+|-------|---------|
+| **explorer** | Find code patterns, locate files in codebase |
+| **librarian** | Lookup external docs, API references, GitHub examples |
+| **oracle** | Architecture advice, complex debugging, code review |
+| **designer** | UI/UX guidance, component patterns, styling advice |
+
+### How to Delegate Research
+
+\`\`\`
+background_task({
+  agent: "explorer",
+  prompt: "Find all usages of AuthContext in src/",
+  description: "Find AuthContext usages",
+  sync: true  // Wait for result
+})
+\`\`\`
+
+**When to delegate:**
+- Need to find patterns across codebase → explorer
+- Need external docs or library examples → librarian
+- Stuck on architecture decision → oracle
+- Need UI/UX guidance → designer
+
+**When NOT to delegate:**
+- Simple file reads → use read() directly
+- Simple grep → use grep() directly
+- Implementation work → do it yourself
+
+---
+
+## Execution
+
+### 1. Understand Task
+
+Read your spec for:
+- **What to do**
+- **References** (file:lines)
+- **Must NOT do** (guardrails)
+- **Acceptance criteria**
+
+### 2. Implement
+
+Follow the spec. Use references for patterns.
+
+\`\`\`
+// Check references
+read(file, { offset: line, limit: 30 })
+
+// Implement changes
+edit(file, { old: "...", new: "..." })
+
+// Verify
+bash("npm test")  // or whatever verification
+\`\`\`
+
+### 3. Verify
+
+Run acceptance criteria commands:
+- Tests pass
+- Build succeeds
+- Manual verification if specified
+
+### 4. Report
+
+**If successful:**
+\`\`\`
+hive_exec_complete({
+  task: "current-task",
+  summary: "Implemented X. Tests pass. Build succeeds.",
+  status: "completed"
+})
+\`\`\`
+
+**CRITICAL: After calling hive_exec_complete, STOP IMMEDIATELY. Your session is done.**
+
+**If blocked (need user decision):**
+\`\`\`
+hive_exec_complete({
+  task: "current-task",
+  summary: "Progress made on X. Blocked on Y.",
+  status: "blocked",
+  blocker: {
+    reason: "Need clarification on...",
+    options: ["Option A", "Option B"],
+    recommendation: "I suggest A because...",
+    context: "Additional info..."
+  }
+})
+\`\`\`
+
+The Hive Master will ask the user and spawn a new worker to continue.
+
+---
+
+## Iron Laws
+
+**Never:**
+- Exceed task scope (stick to spec)
+- Ignore Must NOT do
+- Skip verification
+- Merge (Hive Master does this)
+- Ask user directly (use blocker protocol)
+- Continue after hive_exec_complete
+
+**Always:**
+- Follow references for patterns
+- Run acceptance criteria
+- Report blockers clearly with options
+- Save context with hive_context_write for future tasks
+
+---
+
+## Failure Recovery
+
+If implementation fails:
+
+1. Try 3 times max
+2. If still failing, report as blocked:
+   - What you tried
+   - What failed
+   - Options for proceeding
+
+---
+
+## Style
+
+- Focus on task only
+- No extra "improvements"
+- Verify before reporting done
+- Use specialists for research, not guessing
+`;
+var foragerAgent = {
+  name: "forager",
+  description: "Forager - Executes tasks in isolated worktrees. Can delegate research to OMO-Slim specialists. Implements, verifies, reports.",
+  prompt: FORAGER_PROMPT
+};
+
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
 import * as path from "path";
@@ -12353,6 +13531,8 @@ import { normalize } from "node:path";
 import { EventEmitter } from "node:events";
 import * as fs8 from "fs";
 import * as path4 from "path";
+import * as fs10 from "fs";
+import * as path6 from "path";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -13176,6 +14356,31 @@ var require_dist2 = __commonJS((exports) => {
   exports.createDeferred = deferred;
   exports.default = deferred;
 });
+var DEFAULT_AGENT_MODELS = {
+  hive: "anthropic/claude-sonnet-4-20250514",
+  forager: "anthropic/claude-sonnet-4-20250514"
+};
+var DEFAULT_HIVE_CONFIG = {
+  enableToolsFor: [],
+  agents: {
+    worker: {
+      visible: true
+    },
+    hive: {
+      model: DEFAULT_AGENT_MODELS.hive,
+      temperature: 0.7,
+      skills: ["*"]
+    },
+    forager: {
+      model: DEFAULT_AGENT_MODELS.forager,
+      temperature: 0.3,
+      skills: []
+    }
+  },
+  omoSlim: {
+    enabled: false
+  }
+};
 var HIVE_DIR = ".hive";
 var FEATURES_DIR = "features";
 var TASKS_DIR = "tasks";
@@ -13186,9 +14391,13 @@ var FEATURE_FILE = "feature.json";
 var STATUS_FILE = "status.json";
 var REPORT_FILE = "report.md";
 var APPROVED_FILE = "APPROVED";
+var JOURNAL_FILE = "journal.md";
 function getHivePath(projectRoot) {
   return path.join(projectRoot, HIVE_DIR);
 }
+function getJournalPath(projectRoot) {
+  return path.join(getHivePath(projectRoot), JOURNAL_FILE);
+}
 function getFeaturesPath(projectRoot) {
   return path.join(getHivePath(projectRoot), FEATURES_DIR);
 }
@@ -13318,6 +14527,22 @@ function listFeatures(projectRoot) {
     return [];
   return fs2.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
 }
+var JOURNAL_TEMPLATE = `# Hive Journal
+
+Audit trail of project learnings. Updated when trouble is resolved.
+
+---
+
+<!-- Entry template:
+### YYYY-MM-DD: feature-name
+
+**Trouble**: What went wrong
+**Resolution**: How it was fixed
+**Constraint**: Never/Always rule derived (add to Iron Laws if recurring)
+**See**: .hive/features/feature-name/plan.md
+-->
+`;
+
 class FeatureService {
   projectRoot;
   constructor(projectRoot) {
@@ -13331,6 +14556,10 @@ class FeatureService {
     ensureDir(featurePath);
     ensureDir(getContextPath(this.projectRoot, name));
     ensureDir(getTasksPath(this.projectRoot, name));
+    const journalPath = getJournalPath(this.projectRoot);
+    if (!fileExists(journalPath)) {
+      fs3.writeFileSync(journalPath, JOURNAL_TEMPLATE);
+    }
     const feature = {
       name,
       status: "planning",
@@ -18384,25 +19613,87 @@ ${f.content}`);
     return `${normalized}.md`;
   }
 }
-
-// src/utils/agent-selector.ts
-var AGENT_PATTERNS = [
-  { pattern: /\b(find|search|locate|where|grep|explore|scan)\b/i, agent: "explore" },
-  { pattern: /\b(research|investigate|learn|understand|docs?|documentation|library|api)\b/i, agent: "librarian" },
-  { pattern: /\b(ui|ux|component|frontend|react|vue|svelte|css|style|layout|design|button|form|modal)\b/i, agent: "frontend-ui-ux-engineer" },
-  { pattern: /\b(refactor|simplify|clean|reduce|complexity|review|optimize)\b/i, agent: "code-simplicity-reviewer" },
-  { pattern: /\b(readme|document|explain|write.*doc|comment|jsdoc|tsdoc)\b/i, agent: "document-writer" },
-  { pattern: /\b(image|screenshot|visual|diagram|mockup|pdf|picture|photo)\b/i, agent: "multimodal-looker" },
-  { pattern: /\b(architect|design.*decision|tradeoff|approach|strategy|choose|decide|compare)\b/i, agent: "oracle" }
-];
-function selectAgent(taskName, spec) {
-  const content = `${taskName} ${spec}`.toLowerCase();
-  for (const { pattern, agent } of AGENT_PATTERNS) {
-    if (pattern.test(content)) {
-      return agent;
+class ConfigService {
+  configPath;
+  constructor() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    const configDir = path6.join(homeDir, ".config", "opencode");
+    this.configPath = path6.join(configDir, "agent_hive.json");
+  }
+  getPath() {
+    return this.configPath;
+  }
+  get() {
+    try {
+      if (!fs10.existsSync(this.configPath)) {
+        return { ...DEFAULT_HIVE_CONFIG };
+      }
+      const raw = fs10.readFileSync(this.configPath, "utf-8");
+      const stored = JSON.parse(raw);
+      return {
+        ...DEFAULT_HIVE_CONFIG,
+        ...stored,
+        agents: {
+          ...DEFAULT_HIVE_CONFIG.agents,
+          ...stored.agents,
+          hive: {
+            ...DEFAULT_HIVE_CONFIG.agents?.hive,
+            ...stored.agents?.hive
+          },
+          forager: {
+            ...DEFAULT_HIVE_CONFIG.agents?.forager,
+            ...stored.agents?.forager
+          }
+        },
+        omoSlim: {
+          ...DEFAULT_HIVE_CONFIG.omoSlim,
+          ...stored.omoSlim
+        }
+      };
+    } catch {
+      return { ...DEFAULT_HIVE_CONFIG };
+    }
+  }
+  set(updates) {
+    const current = this.get();
+    const merged = {
+      ...current,
+      ...updates,
+      agents: updates.agents ? {
+        ...current.agents,
+        ...updates.agents
+      } : current.agents,
+      omoSlim: updates.omoSlim ? {
+        ...current.omoSlim,
+        ...updates.omoSlim
+      } : current.omoSlim
+    };
+    const configDir = path6.dirname(this.configPath);
+    if (!fs10.existsSync(configDir)) {
+      fs10.mkdirSync(configDir, { recursive: true });
     }
+    fs10.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+    return merged;
+  }
+  exists() {
+    return fs10.existsSync(this.configPath);
+  }
+  init() {
+    if (!this.exists()) {
+      return this.set(DEFAULT_HIVE_CONFIG);
+    }
+    return this.get();
+  }
+  isOmoSlimEnabled() {
+    return this.get().omoSlim?.enabled ?? false;
+  }
+  setOmoSlim(enabled) {
+    return this.set({ omoSlim: { enabled } });
+  }
+  getAgentConfig(agent) {
+    const config2 = this.get();
+    return config2.agents?.[agent] ?? {};
   }
-  return "general";
 }
 
 // src/utils/worker-prompt.ts
@@ -18493,6 +19784,7 @@ Instead, escalate via the blocker protocol:
 \`\`\`
 hive_exec_complete({
   task: "${task}",
+  feature: "${feature}",
   status: "blocked",
   summary: "What you accomplished so far",
   blocker: {
@@ -18504,6 +19796,8 @@ hive_exec_complete({
 })
 \`\`\`
 
+**After calling hive_exec_complete with blocked status, STOP IMMEDIATELY.**
+
 The Hive Master will:
 1. Receive your blocker info
 2. Ask the user via question()
@@ -18520,16 +19814,22 @@ When your task is **fully complete**:
 \`\`\`
 hive_exec_complete({
   task: "${task}",
+  feature: "${feature}",
   status: "completed",
   summary: "Concise summary of what you accomplished"
 })
 \`\`\`
 
+**CRITICAL: After calling hive_exec_complete, you MUST STOP IMMEDIATELY.**
+Do NOT continue working. Do NOT respond further. Your session is DONE.
+The Hive Master will take over from here.
+
 If you encounter an **unrecoverable error**:
 
 \`\`\`
 hive_exec_complete({
   task: "${task}",
+  feature: "${feature}",
   status: "failed",
   summary: "What went wrong and what was attempted"
 })
@@ -18540,6 +19840,7 @@ If you made **partial progress** but can't continue:
 \`\`\`
 hive_exec_complete({
   task: "${task}",
+  feature: "${feature}",
   status: "partial",
   summary: "What was completed and what remains"
 })
@@ -18547,6 +19848,26 @@ hive_exec_complete({
 
 ---
 
+## TDD Protocol (Required)
+
+1. **Red**: Write failing test first
+2. **Green**: Minimal code to pass
+3. **Refactor**: Clean up, keep tests green
+
+Never write implementation before test exists.
+Exception: Pure refactoring of existing tested code.
+
+## Debugging Protocol (When stuck)
+
+1. **Reproduce**: Get consistent failure
+2. **Isolate**: Binary search to find cause
+3. **Hypothesize**: Form theory, test it
+4. **Fix**: Minimal change that resolves
+
+After 3 failed attempts at same fix: STOP and report blocker.
+
+---
+
 ## Tool Access
 
 **You have access to:**
@@ -18579,178 +19900,354 @@ Begin your task now.
 }
 
 // src/agents/hive.ts
-var HIVE_AGENT_BASE = `# Hive Agent
+var CORE_IDENTITY = `# Hive Master
 
-You are the Hive Master - a hybrid planner-orchestrator for structured feature development.
+You are the single point of contact with the user.
+You plan features, orchestrate execution, and handle blockers.
 
-## Your Role
+## Phase Detection
 
-- **Plan** features via hive_plan_write (explicit, reviewable)
-- **Delegate** execution via hive_exec_start (workers in tmux panes)
-- **Ask questions** on behalf of blocked workers (single point of contact)
-- **Do simple work** directly if user explicitly asks
+Your behavior changes based on feature state:
 
-## Core Workflow
+| State | Mode | Focus |
+|-------|------|-------|
+| No feature / planning | **Scout** | Discovery → Planning |
+| Approved | **Transition** | Sync tasks → Start execution |
+| Executing | **Receiver** | Spawn workers → Handle blockers → Merge |
+| Completed | **Report** | Summarize and close |
 
-1. **Plan** - Create feature, write plan, get user approval
-2. **Execute** - Spawn workers for each task via hive_exec_start
-3. **Monitor** - Check progress with hive_worker_status
-4. **Handle blockers** - Workers exit with blocker info, you ask user and resume
-5. **Merge** - Integrate completed work via hive_merge
+Call \`hive_status()\` to check current phase.
 
-## When No Feature is Active
+---
+
+## Research Delegation (OMO-Slim Specialists)
+
+You have access to specialist agents for research. Use them to enhance your planning and problem-solving:
+
+| Agent | Use For |
+|-------|---------|
+| **explorer** | Find code patterns, locate files in codebase |
+| **librarian** | Lookup external docs, API references, GitHub examples |
+| **oracle** | Architecture advice, complex debugging, code review |
+| **designer** | UI/UX guidance, component patterns, styling advice |
+
+### How to Delegate
+
+\`\`\`
+background_task({
+  agent: "explorer",
+  prompt: "Find all API routes in src/api/ and summarize patterns",
+  description: "Explore API patterns",
+  sync: true  // Wait for result
+})
+\`\`\`
+
+**When to delegate:**
+- Scout mode: Research codebase before planning → explorer
+- Scout mode: Understand external libraries → librarian
+- Any mode: Need architecture guidance → oracle
+- Any mode: UI/UX questions → designer
+
+**When NOT to delegate:**
+- Simple file reads (use read())
+- Simple grep (use grep())
+- User questions (ask directly with question tool)
+- Task execution (spawn Forager worker)
+
+---
+
+## Phase Transitions
+
+Phases can flow **both directions**:
+
+\`\`\`
+         ┌─────────────────────────────────┐
+         │                                 │
+         ▼                                 │
+    [Planning] ──approve──► [Executing] ───┘
+         ▲                       │      (replan)
+         │                       │
+         └───── gap/change ──────┘
+\`\`\`
+
+**When to replan (Executing → Planning):**
+- User explicitly requests scope change
+- Blocker reveals fundamental gap in plan
+- Multiple tasks failing due to missing context
+- User says "wait", "stop", "let's rethink"
+
+**How to replan:**
+1. Abort in-progress tasks: \`hive_exec_abort({ task })\`
+2. Update plan: \`hive_plan_write({ content: "..." })\`
+3. Wait for re-approval
+4. Re-sync tasks: \`hive_tasks_sync()\`
+
+---
+
+## Question Tool (User Input)
+
+Use for decisions and clarifications:
+
+\`\`\`json
+{
+  "questions": [{
+    "question": "Your question here?",
+    "header": "Short Label",
+    "options": [
+      { "label": "Option A", "description": "What this means" },
+      { "label": "Option B", "description": "What this means" }
+    ]
+  }]
+}
+\`\`\`
+
+---
+
+## Iron Laws (All Phases)
+
+**Never:**
+- Delegate user interaction (YOU ask questions directly)
+- Skip discovery for complex tasks
+- Execute without approved plan (in Receiver mode)
+- Continue after 3 failures without asking
+- Force through blockers without user input
+
+**Always:**
+- Match effort to complexity (don't over-plan trivial tasks)
+- Save context with \`hive_context_write\` for workers
+- Verify work before marking complete
+- Offer to replan when blockers suggest plan gap
+`;
+var SCOUT_MODE = `
+---
+
+## Scout Mode: Planning
+
+You are in **Scout Mode** - focus on discovery and planning.
+
+### Intent Classification (Do First)
+
+| Intent | Signals | Action |
+|--------|---------|--------|
+| **Trivial** | Single file, <10 lines | Do it directly. No feature needed. |
+| **Simple** | 1-2 files, <30 min | Quick questions → light plan |
+| **Complex** | 3+ files, review needed | Full discovery → detailed plan |
+| **Refactor** | Existing code changes | Safety: tests, rollback, blast radius |
+| **Greenfield** | New feature | Research patterns first |
+
+### Discovery
+
+1. **Research** before asking (delegate to explorer/librarian if needed)
+2. **Interview** based on intent complexity
+3. **Self-clearance check** after each exchange:
+   - Core objective clear? ✓
+   - Scope defined (IN/OUT)? ✓
+   - No critical ambiguities? ✓
+   - Approach decided? ✓
+
+### Planning
+
+\`\`\`
+hive_feature_create({ name: "feature-name" })
+hive_context_write({ name: "research", content: "..." })  // Save findings
+hive_plan_write({ content: "..." })  // Must include ## Discovery section
+\`\`\`
+
+**Plan Structure:**
+\`\`\`markdown
+# Feature Title
+
+## Discovery
+- Q: {question} → A: {answer}
+- Research: {finding at file:lines}
+
+## Non-Goals (What we're NOT building)
+- {explicit exclusion}
+
+## Tasks
 
-Work directly on user requests. You're a capable coding agent.
-Use hive_feature_create when the task is complex enough to benefit from structure.
+### 1. Task Name
+**What**: {implementation steps}
+**Must NOT**: {guardrails}
+**References**: \`file:lines\` — {why}
+**Verify**: \`{command}\` → {expected}
+\`\`\`
 
-Signs you should create a feature:
-- Multiple files to change
-- Task requires planning
-- Work should be reviewed before merging
-- User mentions "feature", "implement", or describes multi-step work
+### Handoff
 
-## When Feature is Active
+After plan written:
+1. Tell user: **"Plan ready for review"**
+2. Wait for user approval (\`hive_plan_approve\`)
+3. Once approved, you automatically switch to Receiver mode
+`;
+var RECEIVER_MODE = `
+---
 
-Follow Hive workflow strictly:
-1. Write plan via hive_plan_write
-2. Wait for user to review and add comments
-3. Read comments via hive_plan_read, revise if needed
-4. Get approval (explicit or via hive_plan_approve)
-5. Generate tasks via hive_tasks_sync
-6. Execute tasks via hive_exec_start (spawns workers)
-7. Monitor workers via hive_worker_status
-8. Handle any blocked workers
-9. Merge completed work via hive_merge
+## Receiver Mode: Execution
 
-## Blocker Handling Protocol
+You are in **Receiver Mode** - focus on orchestration.
 
-When a worker returns status: 'blocked':
+### Execution Loop
 
-1. **Read** the blocker info from hive_worker_status:
-   - reason: Why they're blocked
-   - options: Available choices
-   - recommendation: Worker's suggestion
+1. **Sync tasks** (if not done): \`hive_tasks_sync()\`
 
-2. **Ask** the user via question():
+2. **For each task**:
    \`\`\`
-   question({
-     questions: [{
-       header: "Decision Needed",
-       question: "Worker blocked: {reason}. {recommendation}",
-       options: [
-         { label: "Option A", description: "..." },
-         { label: "Option B", description: "..." }
-       ]
-     }]
-   })
+   hive_exec_start({ task: "01-task-name" })  // Spawns worker
+   hive_worker_status()                        // Monitor
+   hive_exec_complete(...)                     // When done
+   hive_merge({ task: "01-task-name" })        // Integrate
    \`\`\`
 
-3. **Resume** with the decision:
+3. **Parallel execution** (when tasks are independent):
    \`\`\`
-   hive_exec_start({
-     task: "the-task",
-     continueFrom: "blocked",
-     decision: "User chose Option A because..."
+   hive_exec_start({ task: "02-task-a" })
+   hive_exec_start({ task: "03-task-b" })
+   hive_worker_status()  // Monitor all
+   \`\`\`
+
+### Blocker Handling
+
+When worker returns \`status: 'blocked'\`:
+
+**Quick Decision** (can resolve without plan change):
+1. Check: \`hive_worker_status()\`
+2. Ask user via question tool (with options from blocker)
+3. Resume: \`hive_exec_start({ task, continueFrom: "blocked", decision: "answer" })\`
+
+**Plan Gap** (needs plan revision):
+1. Recognize signals: "this wasn't in the plan", "need to rethink", scope expansion
+2. Ask user: "This blocker suggests a gap in our plan. Should we revise the plan?"
+3. If yes → Abort task, switch to Scout mode, update plan
+
+### Detecting Need to Replan
+
+Watch for these signals:
+- Blocker reason mentions missing requirements
+- User says "wait", "actually", "let's change"
+- Multiple consecutive task failures
+- Worker recommends "revise plan"
+
+When detected, ask:
+\`\`\`json
+{
+  "questions": [{
+    "question": "This suggests our plan may need revision. How would you like to proceed?",
+    "header": "Plan Gap Detected",
+    "options": [
+      { "label": "Revise Plan", "description": "Go back to planning, update the plan" },
+      { "label": "Quick Fix", "description": "Handle this as a one-off decision, continue execution" },
+      { "label": "Abort Feature", "description": "Stop work on this feature entirely" }
+    ]
+  }]
+}
+\`\`\`
+
+### Switching to Scout Mode (Replan)
+
+When user chooses to revise:
+
+1. Abort in-progress work:
+   \`\`\`
+   hive_exec_abort({ task: "current-task" })
+   \`\`\`
+
+2. Document what we learned:
+   \`\`\`
+   hive_context_write({ 
+     name: "execution-learnings", 
+     content: "## What We Learned\\n- {insight from blocked task}\\n- {what needs to change}" 
    })
    \`\`\`
 
-This keeps the user focused on ONE conversation (you) instead of multiple worker panes.
+3. Update plan (triggers Scout mode):
+   \`\`\`
+   hive_plan_write({ content: "..." })  // Updated plan
+   \`\`\`
 
-## Communication Style
+4. Tell user: "Plan updated. Ready for re-approval."
 
-- Be concise, no preamble
-- Start work immediately
-- Challenge wrong approaches professionally
-- Don't summarize unless asked
-- Use hive tools proactively when in feature context
-`;
-function buildFeatureContextSection(ctx) {
-  return `
-## Active Feature: ${ctx.name}
+### Completion
 
-**Plan Status:** ${ctx.planStatus}
-**Tasks:** ${ctx.tasksSummary}
-**Context Files:** ${ctx.contextList.length > 0 ? ctx.contextList.join(", ") : "none"}
+When all tasks done:
+\`\`\`
+hive_feature_complete()
+\`\`\`
 
-You are in feature context. Use Hive workflow.
+Report: "Feature complete. All tasks merged."
 `;
-}
-var OOM_SLIM_SECTION = `
-## OMO-Slim Detected
+var TRANSITION_MODE = `
+---
+
+## Transition: Approved → Executing
 
-Workers spawn in tmux panes with specialized agents:
-- **explorer** - Codebase search and pattern matching
-- **librarian** - External docs and library research
-- **oracle** - Architecture decisions and guidance
-- **designer** - UI/UX implementation
-- **general** - Default implementation
+Plan is approved. Sync tasks and begin execution:
+
+\`\`\`
+hive_tasks_sync()
+\`\`\`
 
-Agent is auto-selected based on task content.
-Watch workers in tmux panes for real-time progress.
+Then proceed with Receiver mode.
 `;
-function buildHiveAgentPrompt(featureContext, omoSlimDetected) {
-  let prompt = HIVE_AGENT_BASE;
-  if (featureContext) {
-    prompt += buildFeatureContextSection(featureContext);
+function buildHiveAgentPrompt(featureContext, _omoSlimDetected) {
+  let prompt = CORE_IDENTITY;
+  if (!featureContext || featureContext.status === "none" || featureContext.status === "planning") {
+    prompt += SCOUT_MODE;
+  } else if (featureContext.status === "approved") {
+    prompt += TRANSITION_MODE;
+    prompt += RECEIVER_MODE;
+  } else if (featureContext.status === "executing") {
+    prompt += RECEIVER_MODE;
+  } else {
+    prompt += `
+
+## Feature Completed
+
+Feature "${featureContext.name}" is complete. Start a new feature with \`hive_feature_create\`.`;
   }
-  if (omoSlimDetected) {
-    prompt += OOM_SLIM_SECTION;
+  if (featureContext && featureContext.status !== "none") {
+    prompt += `
+
+---
+
+## Current Status
+
+`;
+    prompt += `| Property | Value |
+`;
+    prompt += `|----------|-------|
+`;
+    prompt += `| Feature | ${featureContext.name} |
+`;
+    prompt += `| Status | ${featureContext.status} |
+`;
+    prompt += `| Plan | ${featureContext.planApproved ? "approved" : "pending"} |
+`;
+    prompt += `| Tasks | ${featureContext.tasksSummary} |
+`;
+    if (featureContext.contextList.length > 0) {
+      prompt += `| Context | ${featureContext.contextList.join(", ")} |
+`;
+    }
+    if (featureContext.blockedTasks.length > 0) {
+      prompt += `
+**⚠️ Blocked Tasks**: ${featureContext.blockedTasks.join(", ")}
+`;
+      prompt += `Handle blockers before proceeding. Consider if this indicates a plan gap.
+`;
+    }
+    if (featureContext.pendingTasks.length > 0 && featureContext.status === "executing") {
+      prompt += `
+**Next Task**: ${featureContext.pendingTasks[0]}
+`;
+    }
   }
   return prompt;
 }
 
 // src/index.ts
-function parseFrontmatter(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
-  if (!match) {
-    return { meta: {}, body: content.trim() };
-  }
-  const meta = {};
-  const frontmatter = match[1];
-  const body = match[2];
-  for (const line of frontmatter.split(`
-`)) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx > 0) {
-      const key = line.slice(0, colonIdx).trim();
-      const value = line.slice(colonIdx + 1).trim();
-      meta[key] = value;
-    }
-  }
-  return { meta, body: body.trim() };
-}
-function getSkillsDir() {
-  const filename = fileURLToPath(import.meta.url);
-  const dirname5 = path5.dirname(filename);
-  return path5.join(dirname5, "..", "skills");
-}
-function discoverHiveSkills() {
-  const skillsDir = getSkillsDir();
-  const skills = [];
-  if (!fs6.existsSync(skillsDir)) {
-    return skills;
-  }
-  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory())
-      continue;
-    const skillPath = path5.join(skillsDir, entry.name, "SKILL.md");
-    if (!fs6.existsSync(skillPath))
-      continue;
-    try {
-      const content = fs6.readFileSync(skillPath, "utf-8");
-      const { meta, body } = parseFrontmatter(content);
-      skills.push({
-        name: meta.name || entry.name,
-        description: meta.description || "",
-        path: skillPath,
-        body
-      });
-    } catch {}
-  }
-  return skills;
-}
-function formatSkillsXml(skills) {
+function formatSkillsXml() {
+  const skills = getBuiltinSkills();
   if (skills.length === 0)
     return "";
   const skillsXml = skills.map((skill) => {
@@ -18770,49 +20267,29 @@ ${skillsXml}
 </available_skills>`;
 }
 function createHiveSkillTool() {
-  let cachedSkills = null;
-  let cachedDescription = null;
-  const getSkills = () => {
-    if (cachedSkills)
-      return cachedSkills;
-    cachedSkills = discoverHiveSkills();
-    return cachedSkills;
-  };
-  const getDescription = () => {
-    if (cachedDescription)
-      return cachedDescription;
-    const skills = getSkills();
-    const base = "Load a Hive skill to get detailed instructions for a specific workflow.";
-    if (skills.length === 0) {
-      cachedDescription = base + `
-
-No Hive skills available.`;
-    } else {
-      cachedDescription = base + formatSkillsXml(skills);
-    }
-    return cachedDescription;
-  };
-  getDescription();
+  const base = "Load a Hive skill to get detailed instructions for a specific workflow.";
+  const skills = getBuiltinSkills();
+  const description = skills.length === 0 ? base + `
+
+No Hive skills available.` : base + formatSkillsXml();
   return tool({
-    get description() {
-      return cachedDescription ?? "Load a Hive skill to get detailed instructions for a specific workflow.";
-    },
+    description,
     args: {
       name: tool.schema.string().describe("The skill name from available_skills")
     },
     async execute({ name }) {
-      const skills = getSkills();
-      const skill = skills.find((s) => s.name === name);
-      if (!skill) {
+      const result = loadBuiltinSkill(name);
+      if (!result.found || !result.skill) {
         const available = skills.map((s) => s.name).join(", ");
         throw new Error(`Skill "${name}" not found. Available Hive skills: ${available || "none"}`);
       }
+      const skill = result.skill;
       return [
         `## Hive Skill: ${skill.name}`,
         "",
         `**Description**: ${skill.description}`,
         "",
-        skill.body
+        skill.template
       ].join(`
 `);
     }
@@ -18861,10 +20338,13 @@ When OMO-Slim is installed, \`hive_exec_start\` spawns worker agents in tmux pan
 
 **Handling blocked workers:**
 1. Check blockers with \`hive_worker_status()\`
-2. Read the blocker info (reason, options, recommendation)
-3. Ask user via \`question()\` tool
+2. Read the blocker info (reason, options, recommendation, context)
+3. Ask user via \`question()\` tool - NEVER plain text
 4. Resume with \`hive_exec_start(task, continueFrom: "blocked", decision: answer)\`
 
+**CRITICAL**: When resuming, a NEW worker spawns in the SAME worktree.
+The previous worker's progress is preserved. Include the user's decision in the \`decision\` parameter.
+
 **Agent auto-selection** based on task content:
 | Pattern | Agent |
 |---------|-------|
@@ -18897,29 +20377,18 @@ During execution, call \`hive_status\` periodically to:
 - Get reminded of next actions
 `;
 var plugin = async (ctx) => {
-  const { directory } = ctx;
+  const { directory, client } = ctx;
   const featureService = new FeatureService(directory);
   const planService = new PlanService(directory);
   const taskService = new TaskService(directory);
   const contextService = new ContextService(directory);
+  const configService = new ConfigService;
   const worktreeService = new WorktreeService({
     baseDir: directory,
     hiveDir: path5.join(directory, ".hive")
   });
-  let omoSlimDetected = false;
-  let detectionDone = false;
-  const detectOmoSlim = (toolContext) => {
-    if (detectionDone)
-      return omoSlimDetected;
-    const ctx2 = toolContext;
-    if (ctx2?.tools?.includes?.("background_task") || ctx2?.background_task || typeof ctx2?.callTool === "function") {
-      omoSlimDetected = true;
-    }
-    detectionDone = true;
-    if (omoSlimDetected) {
-      console.log("[Hive] OMO-Slim detected: delegated execution with tmux panes enabled");
-    }
-    return omoSlimDetected;
+  const isOmoSlimEnabled = () => {
+    return configService.isOmoSlimEnabled();
   };
   const resolveFeature = (explicit) => {
     if (explicit)
@@ -18987,7 +20456,40 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
         },
         async execute({ name, ticket }) {
           const feature = featureService.create(name, ticket);
-          return `Feature "${name}" created. Status: ${feature.status}. Write a plan with hive_plan_write.`;
+          return `Feature "${name}" created.
+
+## Discovery Phase Required
+
+Before writing a plan, you MUST:
+1. Ask clarifying questions about the feature
+2. Document Q&A in plan.md with a \`## Discovery\` section
+3. Research the codebase (grep, read existing code)
+4. Save findings with hive_context_write
+
+Example discovery section:
+\`\`\`markdown
+## Discovery
+
+**Q: What authentication system do we use?**
+A: JWT with refresh tokens, see src/auth/
+
+**Q: Should this work offline?**
+A: No, online-only is fine
+
+**Research:**
+- Found existing theme system in src/theme/
+- Uses CSS variables pattern
+\`\`\`
+
+## Planning Guidelines
+
+When writing your plan, include:
+- \`## Non-Goals\` - What we're explicitly NOT building (scope boundaries)
+- \`## Ghost Diffs\` - Alternatives you considered but rejected
+
+These prevent scope creep and re-proposing rejected solutions.
+
+NEXT: Ask your first clarifying question about this feature.`;
         }
       }),
       hive_feature_list: tool({
@@ -19017,6 +20519,34 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
           return `Feature "${feature}" marked as completed`;
         }
       }),
+      hive_journal_append: tool({
+        description: "Append entry to .hive/journal.md for audit trail",
+        args: {
+          feature: tool.schema.string().describe("Feature name for context"),
+          trouble: tool.schema.string().describe("What went wrong"),
+          resolution: tool.schema.string().describe("How it was fixed"),
+          constraint: tool.schema.string().optional().describe("Never/Always rule derived")
+        },
+        async execute({ feature, trouble, resolution, constraint }) {
+          const journalPath = path5.join(directory, ".hive", "journal.md");
+          if (!fs6.existsSync(journalPath)) {
+            return `Error: journal.md not found. Create a feature first to initialize the journal.`;
+          }
+          const date5 = new Date().toISOString().split("T")[0];
+          const entry = `
+### ${date5}: ${feature}
+
+**Trouble**: ${trouble}
+**Resolution**: ${resolution}
+${constraint ? `**Constraint**: ${constraint}` : ""}
+**See**: .hive/features/${feature}/plan.md
+
+---
+`;
+          fs6.appendFileSync(journalPath, entry);
+          return `Journal entry added for ${feature}. ${constraint ? `Constraint: "${constraint}"` : ""}`;
+        }
+      }),
       hive_plan_write: tool({
         description: "Write plan.md (clears existing comments)",
         args: {
@@ -19027,6 +20557,17 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
+          const hasDiscovery = content.toLowerCase().includes("## discovery");
+          if (!hasDiscovery) {
+            return `BLOCKED: Discovery section required before planning.
+
+Your plan must include a \`## Discovery\` section documenting:
+- Questions you asked and answers received
+- Research findings from codebase exploration
+- Key decisions made
+
+Add this section to your plan content and try again.`;
+          }
           captureSession(feature, toolContext);
           const planPath = planService.write(feature, content);
           return `Plan written to ${planPath}. Comments cleared for fresh review.`;
@@ -19192,8 +20733,7 @@ ${priorTasks.join(`
 `;
           }
           taskService.writeSpec(feature, task, specContent);
-          detectOmoSlim(toolContext);
-          if (omoSlimDetected) {
+          if (isOmoSlimEnabled()) {
             const contextFiles = [];
             const contextDir = path5.join(directory, ".hive", "features", feature, "context");
             if (fs6.existsSync(contextDir)) {
@@ -19220,34 +20760,40 @@ ${priorTasks.join(`
                 decision: decision || "No decision provided"
               } : undefined
             });
-            const agent = selectAgent(taskInfo.name, specContent);
-            try {
-              const ctx2 = toolContext;
-              if (ctx2.callTool) {
-                const result = await ctx2.callTool("background_task", {
-                  agent,
-                  prompt: workerPrompt,
-                  description: `Hive: ${task}`,
-                  sync: false
-                });
-                taskService.update(feature, task, {
-                  status: "in_progress",
-                  workerId: result?.task_id,
-                  agent,
-                  mode: "omo-slim"
-                });
-                return JSON.stringify({
-                  worktreePath: worktree.path,
-                  branch: worktree.branch,
-                  mode: "delegated",
-                  agent,
-                  taskId: result?.task_id,
-                  message: `Worker spawned via OMO-Slim (${agent} agent). Watch in tmux pane. Use hive_worker_status to check progress.`
-                }, null, 2);
-              }
-            } catch (e) {
-              console.log("[Hive] OMO-Slim delegation failed, falling back to inline:", e.message);
-            }
+            const agent = "forager";
+            return JSON.stringify({
+              worktreePath: worktree.path,
+              branch: worktree.branch,
+              mode: "delegate",
+              agent,
+              delegationRequired: true,
+              backgroundTaskCall: {
+                agent,
+                prompt: workerPrompt,
+                description: `Hive: ${task}`,
+                sync: false
+              },
+              instructions: `## Delegation Required
+
+You MUST now call background_task to spawn a Forager worker:
+
+\`\`\`
+background_task({
+  agent: "forager",
+  prompt: <the workerPrompt below>,
+  description: "Hive: ${task}",
+  sync: false
+})
+\`\`\`
+
+After spawning:
+- Monitor with hive_worker_status
+- Handle blockers when worker exits
+- Merge completed work with hive_merge
+
+DO NOT do the work yourself. Delegate it.`,
+              workerPrompt
+            }, null, 2);
           }
           return `Worktree created at ${worktree.path}
 Branch: ${worktree.branch}
@@ -19279,6 +20825,23 @@ Reminder: do all work inside this worktree and ensure any subagents do the same.
             return `Error: Task "${task}" not found`;
           if (taskInfo.status !== "in_progress" && taskInfo.status !== "blocked")
             return "Error: Task not in progress";
+          if (status === "completed") {
+            const verificationKeywords = ["test", "build", "lint", "vitest", "jest", "npm run", "pnpm", "cargo", "pytest", "verified", "passes", "succeeds"];
+            const summaryLower = summary.toLowerCase();
+            const hasVerificationMention = verificationKeywords.some((kw) => summaryLower.includes(kw));
+            if (!hasVerificationMention) {
+              return `BLOCKED: No verification detected in summary.
+
+Before claiming completion, you must:
+1. Run tests (vitest, jest, pytest, etc.)
+2. Run build (npm run build, cargo build, etc.)
+3. Include verification results in summary
+
+Example summary: "Implemented auth flow. Tests pass (vitest). Build succeeds."
+
+Re-run with updated summary showing verification results.`;
+            }
+          }
           if (status === "blocked") {
             taskService.update(feature, task, {
               status: "blocked",
@@ -19385,9 +20948,10 @@ Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "
               summary: t.summary || null
             };
           }));
+          const omoSlimEnabled = isOmoSlimEnabled();
           return JSON.stringify({
             feature,
-            omoSlimDetected,
+            omoSlimEnabled,
             workers,
             hint: workers.some((w) => w.status === "blocked") ? 'Use hive_exec_start(task, continueFrom: "blocked", decision: answer) to resume blocked workers' : workers.some((w) => w.maybeStuck) ? "Some workers may be stuck. Check tmux panes or abort with hive_exec_abort." : "Workers in progress. Watch tmux panes for live updates."
           }, null, 2);
@@ -19640,8 +21204,50 @@ Make the requested changes, then call hive_request_review again.`;
       hive: {
         model: undefined,
         temperature: 0.7,
-        description: "Hive Master - plan-first development with structured workflow and worker delegation",
-        prompt: buildHiveAgentPrompt(undefined, false)
+        description: "Hive Master - phase-aware planner+orchestrator. Auto-switches Scout/Receiver mode.",
+        prompt: buildHiveAgentPrompt(undefined, false),
+        permission: {
+          question: "allow",
+          skill: "allow",
+          todowrite: "allow",
+          todoread: "allow",
+          webfetch: "allow"
+        }
+      },
+      scout: {
+        model: undefined,
+        temperature: 0.7,
+        description: "Scout (explicit) - Discovery and planning only. Use @hive for automatic mode.",
+        prompt: SCOUT_PROMPT,
+        permission: {
+          edit: "deny",
+          question: "allow",
+          skill: "allow",
+          todowrite: "allow",
+          todoread: "allow",
+          webfetch: "allow"
+        }
+      },
+      receiver: {
+        model: undefined,
+        temperature: 0.5,
+        description: "Receiver (explicit) - Orchestration only. Use @hive for automatic mode.",
+        prompt: RECEIVER_PROMPT,
+        permission: {
+          question: "allow",
+          skill: "allow",
+          todowrite: "allow",
+          todoread: "allow"
+        }
+      },
+      forager: {
+        model: undefined,
+        temperature: 0.3,
+        description: "Forager - Task executor (subagent). Spawned automatically, not for direct use.",
+        prompt: FORAGER_PROMPT,
+        permission: {
+          skill: "allow"
+        }
       }
     },
     systemPrompt: (existingPrompt) => {
@@ -19652,44 +21258,66 @@ Make the requested changes, then call hive_request_review again.`;
       let featureContext;
       for (const featureName of featureNames) {
         const feature = featureService.get(featureName);
-        if (feature && ["planning", "executing"].includes(feature.status)) {
+        if (feature && ["planning", "approved", "executing"].includes(feature.status)) {
           const tasks = taskService.list(featureName);
-          const pendingCount = tasks.filter((t) => t.status === "pending").length;
+          const pendingTasks = tasks.filter((t) => t.status === "pending").map((t) => t.folder);
+          const blockedTasks = tasks.filter((t) => t.status === "blocked").map((t) => t.folder);
           const inProgressCount = tasks.filter((t) => t.status === "in_progress").length;
           const doneCount = tasks.filter((t) => t.status === "done").length;
           const contextDir = path5.join(directory, ".hive", "features", featureName, "context");
           const contextList = fs6.existsSync(contextDir) ? fs6.readdirSync(contextDir).filter((f) => f.endsWith(".md")) : [];
           const planResult = planService.read(featureName);
-          let planStatus = "none";
-          if (planResult) {
-            planStatus = planResult.status === "approved" || planResult.status === "executing" ? "approved" : "draft";
-          }
+          const planApproved = planResult?.status === "approved" || planResult?.status === "executing" || feature.status === "approved" || feature.status === "executing";
+          const status = feature.status === "completed" ? "completed" : feature.status === "approved" ? "approved" : feature.status === "executing" ? "executing" : "planning";
           featureContext = {
             name: featureName,
-            planStatus,
-            tasksSummary: `${doneCount} done, ${inProgressCount} in progress, ${pendingCount} pending`,
-            contextList
+            status,
+            planApproved,
+            tasksSummary: `${doneCount} done, ${inProgressCount} in progress, ${pendingTasks.length} pending`,
+            contextList,
+            pendingTasks,
+            blockedTasks
           };
           break;
         }
       }
-      if (featureContext || omoSlimDetected) {
-        return buildHiveAgentPrompt(featureContext, omoSlimDetected);
+      if (featureContext || isOmoSlimEnabled()) {
+        return buildHiveAgentPrompt(featureContext, isOmoSlimEnabled());
       }
       return existingPrompt;
     },
     config: async (opencodeConfig) => {
+      configService.init();
+      const hiveUserConfig = configService.getAgentConfig("hive");
+      const foragerUserConfig = configService.getAgentConfig("forager");
       const hiveAgentConfig = {
-        model: undefined,
-        temperature: 0.7,
+        model: hiveUserConfig.model,
+        temperature: hiveUserConfig.temperature ?? 0.7,
         description: "Hive Master - plan-first development with structured workflow and worker delegation",
-        prompt: buildHiveAgentPrompt(undefined, false)
+        prompt: buildHiveAgentPrompt(undefined, false),
+        permission: {
+          question: "allow",
+          skill: "allow",
+          todowrite: "allow",
+          todoread: "allow",
+          webfetch: "allow"
+        }
+      };
+      const foragerAgentConfig = {
+        model: foragerUserConfig.model,
+        temperature: foragerUserConfig.temperature ?? 0.3,
+        description: "Forager - Task executor (worker). Spawned by Hive Master for isolated task execution.",
+        prompt: foragerAgent.prompt,
+        permission: {
+          skill: "allow"
+        }
       };
       const configAgent = opencodeConfig.agent;
       if (!configAgent) {
-        opencodeConfig.agent = { hive: hiveAgentConfig };
+        opencodeConfig.agent = { hive: hiveAgentConfig, forager: foragerAgentConfig };
       } else {
         configAgent.hive = hiveAgentConfig;
+        configAgent.forager = foragerAgentConfig;
       }
     }
   };