opencode-hive 1.0.7 → 1.1.0

package/dist/index.js

@@ -13,7 +13,6 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import * as path7 from "path";
-import * as fs9 from "fs";
 import * as os from "os";
 
 // ../../node_modules/zod/v4/classic/external.js
@@ -12388,7 +12387,8 @@ Start by understanding the current project context, then ask questions one at a
 - **YAGNI ruthlessly** - Remove unnecessary features from all designs
 - **Explore alternatives** - Always propose 2-3 approaches before settling
 - **Incremental validation** - Present design in sections, validate each
-- **Be flexible** - Go back and clarify when something doesn't make sense`
+- **Be flexible** - Go back and clarify when something doesn't make sense
+- **Challenge assumptions** - Surface fragile assumptions, ask what changes if they fail, offer lean fallback options`
   },
   {
     name: "code-reviewer",
@@ -12675,9 +12675,9 @@ Each agent gets:
 
 \`\`\`typescript
 // Using Hive tools for parallel execution
-hive_exec_start({ task: "01-fix-abort-tests" })
-hive_exec_start({ task: "02-fix-batch-tests" })
-hive_exec_start({ task: "03-fix-race-condition-tests" })
+hive_worktree_create({ task: "01-fix-abort-tests" })
+hive_worktree_create({ task: "02-fix-batch-tests" })
+hive_worktree_create({ task: "03-fix-race-condition-tests" })
 // All three run concurrently in isolated worktrees
 \`\`\`
 
@@ -12832,7 +12832,7 @@ Only \`done\` satisfies dependencies (not \`blocked\`, \`failed\`, \`partial\`,
 ### Step 3: Execute Batch
 
 For each task in the batch:
-1. Mark as in_progress via \`hive_exec_start()\`
+1. Mark as in_progress via \`hive_worktree_create()\`
 2. Follow each step exactly (plan has bite-sized steps)
 3. Run verifications as specified
 4. Mark as completed
@@ -12843,6 +12843,11 @@ When batch complete:
 - Show verification output
 - Say: "Ready for feedback."
 
+### Step 4.5: Post-Batch Hygienic Review
+
+After the batch report, ask the operator if they want a Hygienic code review for the batch.
+If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\` and apply feedback before starting the next batch.
+
 ### Step 5: Continue
 Based on feedback:
 - Apply changes if needed
@@ -12944,7 +12949,7 @@ Ask one at a time, with the provided options. Store the answers in \`.hive/conte
   },
   {
     name: "parallel-exploration",
-    description: "Use when you need parallel, read-only exploration with hive_background_* or task() (Scout fan-out)",
+    description: "Use when you need parallel, read-only exploration with task() (Scout fan-out)",
     template: `# Parallel Exploration (Scout Fan-Out)
 
 ## Overview
@@ -12955,11 +12960,7 @@ When you need to answer "where/how does X work?" across multiple domains (codeba
 
 **Safe in Planning mode:** This is read-only exploration. It is OK to use during exploratory research even when there is no feature, no plan, and no approved tasks.
 
-**This skill is for read-only research.** For parallel implementation work, use \`hive_skill("dispatching-parallel-agents")\` with \`hive_exec_start\`.
-
-**Two valid execution paths:**
-- **Path A (Hive background tools):** Use \`hive_background_task\`, \`hive_background_output\`, \`hive_background_cancel\` when available.
-- **Path B (Task mode):** Use native \`task()\` for delegation when background tools are not registered.
+**This skill is for read-only research.** For parallel implementation work, use \`hive_skill("dispatching-parallel-agents")\` with \`hive_worktree_create\`.
 
 ## When to Use
 
@@ -12998,51 +12999,16 @@ Split your investigation into 2-4 independent sub-questions. Good decomposition:
 - "What is X?" then "How is X used?" (second depends on first)
 - "Find the bug" then "Fix the bug" (not read-only)
 
-### 2. Spawn Background Tasks (Fan-Out)
+### 2. Spawn Tasks (Fan-Out)
 
 Launch all tasks before waiting for any results:
 
 \`\`\`typescript
-// Path A: Hive background tools (when available)
-// Fan-out: spawn all tasks first
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find hive_background_task implementation",
-  prompt: \`Where is hive_background_task implemented and registered?
-    - Find the tool definition
-    - Find the plugin registration
-    - Return file paths with line numbers\`,
-  sync: false
-})
-
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Analyze background task concurrency",
-  prompt: \`How does background task concurrency/queueing work?
-    - Find the manager/scheduler code
-    - Document the concurrency model
-    - Return file paths with evidence\`,
-  sync: false
-})
-
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find parent notification mechanism",
-  prompt: \`How does parent notification work for background tasks?
-    - Where is the notification built?
-    - How is it sent to the parent session?
-    - Return file paths with evidence\`,
-  sync: false
-})
-\`\`\`
-
-\`\`\`typescript
-// Path B: Task mode (native task tool)
 // Parallelize by issuing multiple task() calls in the same assistant message.
 task({
   subagent_type: 'scout-researcher',
-  description: 'Find hive_background_task implementation',
-  prompt: \`Where is hive_background_task implemented and registered?
+  description: 'Find API route implementation',
+  prompt: \`Where are API routes implemented and registered?
     - Find the tool definition
     - Find the plugin registration
     - Return file paths with line numbers\`,
@@ -13068,8 +13034,7 @@ task({
 \`\`\`
 
 **Key points:**
-- Use \`agent: "scout-researcher"\` for read-only exploration
-- Use \`sync: false\` to return immediately (non-blocking)
+- Use \`subagent_type: 'scout-researcher'\` for read-only exploration
 - Give each task a clear, focused \`description\`
 - Make prompts specific about what evidence to return
 
@@ -13084,35 +13049,7 @@ You'll receive a \`<system-reminder>\` notification when each task completes.
 
 ### 4. Collect Results
 
-When notified of completion, retrieve results:
-
-\`\`\`typescript
-// Path A: Hive background tools
-// Get output from completed task
-hive_background_output({
-  task_id: "task-abc123",
-  block: false  // Don't wait, task already done
-})
-\`\`\`
-
-**For incremental output (long-running tasks):**
-
-\`\`\`typescript
-// First call - get initial output
-hive_background_output({
-  task_id: "task-abc123",
-  block: true,      // Wait for output
-  timeout: 30000    // 30 second timeout
-})
-// Returns: { output: "...", cursor: "5" }
-
-// Later call - get new output since cursor
-hive_background_output({
-  task_id: "task-abc123",
-  cursor: "5",      // Resume from message 5
-  block: true
-})
-\`\`\`
+When each task completes, its result is returned directly. Collect the outputs from each task and proceed to synthesis.
 
 ### 5. Synthesize Findings
 
@@ -13123,16 +13060,7 @@ Combine results from all tasks:
 
 ### 6. Cleanup (If Needed)
 
-Cancel tasks that are no longer needed:
-
-\`\`\`typescript
-// Path A: Hive background tools
-// Cancel specific task
-hive_background_cancel({ task_id: "task-abc123" })
-
-// Cancel all your background tasks
-hive_background_cancel({ all: true })
-\`\`\`
+No manual cancellation is required in task mode.
 
 ## Prompt Templates
 
@@ -13180,48 +13108,20 @@ Return:
 
 ## Real Example
 
-**Investigation:** "How does the background task system work?"
+**Investigation:** "How does the API routing system work?"
 
 **Decomposition:**
-1. Implementation: Where is \`hive_background_task\` tool defined?
-2. Concurrency: How does task scheduling/queueing work?
-3. Notifications: How does parent session get notified?
+1. Implementation: Where are API routes defined?
+2. Routing: How does route registration work?
+3. Notifications: How are errors surfaced to the caller?
 
 **Fan-out:**
 \`\`\`typescript
-// Path A: Hive background tools
-// Task 1: Implementation
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find hive_background_task implementation",
-  prompt: "Where is hive_background_task implemented? Find tool definition and registration.",
-  sync: false
-})
-
-// Task 2: Concurrency
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Analyze concurrency model",
-  prompt: "How does background task concurrency work? Find the manager/scheduler.",
-  sync: false
-})
-
-// Task 3: Notifications
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find notification mechanism",
-  prompt: "How are parent sessions notified of task completion?",
-  sync: false
-})
-\`\`\`
-
-\`\`\`typescript
-// Path B: Task mode (native task tool)
 // Parallelize by issuing multiple task() calls in the same assistant message.
 task({
   subagent_type: 'scout-researcher',
-  description: 'Find hive_background_task implementation',
-  prompt: 'Where is hive_background_task implemented? Find tool definition and registration.',
+  description: 'Find API route implementation',
+  prompt: 'Where are API routes implemented? Find tool definition and registration.',
 });
 
 task({
@@ -13249,20 +13149,12 @@ task({
 **Spawning sequentially (defeats the purpose):**
 \`\`\`typescript
 // BAD: Wait for each before spawning next
-const result1 = await hive_background_task({ ..., sync: true })
-const result2 = await hive_background_task({ ..., sync: true })
-\`\`\`
-
-\`\`\`typescript
-// GOOD: Spawn all, then collect
-hive_background_task({ ..., sync: false })  // Returns immediately
-hive_background_task({ ..., sync: false })  // Returns immediately
-hive_background_task({ ..., sync: false })  // Returns immediately
-// ... later, collect results with hive_background_output
+await task({ ... });
+await task({ ... });
 \`\`\`
 
 \`\`\`typescript
-// GOOD (task mode): Spawn all in the same assistant message
+// GOOD: Spawn all in the same assistant message
 task({ ... });
 task({ ... });
 task({ ... });
@@ -13291,9 +13183,7 @@ task({ ... });
 
 After using this pattern, verify:
 - [ ] All tasks spawned before collecting any results (true fan-out)
-- [ ] Received notifications for completed tasks (Path A)
-- [ ] Successfully retrieved output with \`hive_background_output\` (Path A)
-- [ ] Verified \`task()\` fan-out pattern used when in task mode (Path B)
+- [ ] Verified \`task()\` fan-out pattern used for parallel exploration
 - [ ] Synthesized findings into coherent answer`
   },
   {
@@ -14374,7 +14264,7 @@ Hybrid agent: plans AND orchestrates. Phase-aware, skills on-demand.
 
 ## Phase Detection (First Action)
 
-Run \`hive_status()\` or \`hive_feature_list()\` to detect phase:
+Run \`hive_status()\` to detect phase:
 
 | Feature State | Phase | Active Section |
 |---------------|-------|----------------|
@@ -14400,18 +14290,16 @@ Run \`hive_status()\` or \`hive_feature_list()\` to detect phase:
 ### Canonical Delegation Threshold
 
 - Delegate to Scout when you cannot name the file path upfront, expect to inspect 2+ files, or the question is open-ended ("how/where does X work?").
-- Prefer \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` for single investigations; use \`sync: false\` only for multi-scout fan-out.
+- Prefer \`task({ subagent_type: "scout-researcher", prompt: "..." })\` for single investigations.
 - Local \`read/grep/glob\` is acceptable only for a single known file and a bounded question.
 
 ### Delegation
 
-- Single-scout research → \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` (blocks until complete, simpler flow)
-- Parallel exploration → Load \`hive_skill("parallel-exploration")\` and follow the task vs hive mode delegation guidance.
-- Implementation → \`hive_exec_start(task)\` (spawns Forager)
+- Single-scout research → \`task({ subagent_type: "scout-researcher", prompt: "..." })\`
+- Parallel exploration → Load \`hive_skill("parallel-exploration")\` and follow the task mode delegation guidance.
+- Implementation → \`hive_worktree_create({ task: "01-task-name" })\` (creates worktree + Forager)
 
-In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
-
-During Planning, default to synchronous exploration (\`sync: true\`). If async/parallel exploration would help, ask the user via \`question()\`.
+During Planning, use \`task({ subagent_type: "scout-researcher", ... })\` for exploration (BLOCKING — returns when done). For parallel exploration, issue multiple \`task()\` calls in the same message.
 
 ### Context Persistence
 
@@ -14420,6 +14308,8 @@ Save discoveries with \`hive_context_write\`:
 - User preferences
 - Research findings
 
+When Scout returns substantial findings (3+ files discovered, architecture patterns, or key decisions), persist them to a feature context file via \`hive_context_write\`.
+
 ### Checkpoints
 
 Before major transitions, verify:
@@ -14433,7 +14323,7 @@ Load when detailed guidance needed:
 - \`hive_skill("brainstorming")\` - exploring ideas and requirements
 - \`hive_skill("writing-plans")\` - structuring implementation plans
 - \`hive_skill("dispatching-parallel-agents")\` - parallel task delegation
-- \`hive_skill("parallel-exploration")\` - parallel read-only research via task() or hive_background_task (Scout fan-out)
+- \`hive_skill("parallel-exploration")\` - parallel read-only research via task() (Scout fan-out)
 - \`hive_skill("executing-plans")\` - step-by-step plan execution
 
 Load ONE skill at a time. Only when you need guidance beyond this prompt.
@@ -14457,6 +14347,14 @@ Load ONE skill at a time. Only when you need guidance beyond this prompt.
 | Premature abstraction | "Abstract or inline?" |
 | Over-validation | "Minimal or comprehensive checks?" |
 
+### Challenge User Assumptions
+
+When a proposal relies on fragile assumptions, challenge them explicitly:
+
+- Identify the assumption and state it plainly.
+- Ask what changes if the assumption is wrong.
+- Offer a lean fallback that still meets core goals.
+
 ### Gap Classification
 
 | Gap | Action |
@@ -14493,7 +14391,7 @@ After review decision, offer execution choice (subagent-driven vs parallel sessi
 
 - Research BEFORE asking (use \`hive_skill("parallel-exploration")\` for multi-domain research)
 - Save draft as working memory
-- Don't implement (no edits/worktrees). Read-only exploration is allowed (local tools + Scout via hive_background_task).
+- Don't implement (no edits/worktrees). Read-only exploration is allowed (local tools + Scout via task()).
 
 ---
 
@@ -14522,24 +14420,15 @@ Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **b
 ### Worker Spawning
 
 \`\`\`
-hive_exec_start({ task: "01-task-name" })  // Creates worktree + Forager
+hive_worktree_create({ task: "01-task-name" })  // Creates worktree + Forager
 \`\`\`
 
 ### After Delegation
 
-1. Wait for the completion notification (no polling required)
-2. Use \`hive_worker_status()\` for spot checks or if you suspect notifications did not deliver
-3. Use \`hive_background_output\` only if interim output is explicitly needed, or after completion
-4. When calling \`hive_background_output\`, choose a timeout (30-120s) based on task size
-5. If blocked: \`question()\` → user decision → \`continueFrom: "blocked"\`
-
-### Observation Polling (Recommended)
-
-- Prefer completion notifications over polling
-- Use \`hive_worker_status()\` for observation-based spot checks
-- Avoid tight loops with \`hive_background_output\`; if needed, wait 30-60s between checks
-- If you suspect notifications did not deliver, do a single \`hive_worker_status()\` check first
-- If you need to fetch final results, call \`hive_background_output({ task_id, block: false })\` after the completion notice
+1. \`task()\` is BLOCKING — when it returns, the worker is DONE
+2. Immediately call \`hive_status()\` to check the new task state and find next runnable tasks
+3. If task status is blocked: read blocker info → \`question()\` → user decision → resume with \`continueFrom: "blocked"\`
+4. Do NOT wait for notifications or poll — the result is already available when \`task()\` returns
 
 ### Failure Recovery
 
@@ -14549,6 +14438,13 @@ hive_exec_start({ task: "01-task-name" })  // Creates worktree + Forager
 
 \`hive_merge({ task: "01-task-name" })\` after verification
 
+### Post-Batch Review (Hygienic)
+
+After completing and merging a batch:
+1. Ask the user via \`question()\` if they want a Hygienic code review for the batch.
+2. If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\`.
+3. Apply feedback before starting the next batch.
+
 ### Orchestration Iron Laws
 
 - Delegate by default
@@ -14587,9 +14483,9 @@ PLANNER, NOT IMPLEMENTER. "Do X" means "create plan for X".
 | Simple | 1-2 files, <30 min | Light interview → 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 BEFORE asking. Delegate to Scout via \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` for single investigations. |
+| Greenfield | New feature | Research patterns BEFORE asking. Delegate to Scout via \`task({ subagent_type: "scout-researcher", prompt: "..." })\` for single investigations. |
 
-During Planning, default to synchronous exploration (\`sync: true\`). If async/parallel exploration would help, ask the user via \`question()\`.
+During Planning, use \`task({ subagent_type: "scout-researcher", ... })\` for exploration (BLOCKING — returns when done). For parallel exploration, issue multiple \`task()\` calls in the same message.
 
 ## Self-Clearance Check (After Every Exchange)
 
@@ -14609,6 +14505,7 @@ ANY NO → Ask the unclear thing
 | Premature abstraction | "Extracted to utility" | "Abstract or inline?" |
 | Over-validation | "15 error checks for 3 inputs" | "Minimal or comprehensive error handling?" |
 | Documentation bloat | "Added JSDoc everywhere" | "None, minimal, or full docs?" |
+| Fragile assumption | "Assuming X is always true" | "If X is wrong, what should change?" |
 
 ## Gap Classification (Self-Review)
 
@@ -14666,9 +14563,9 @@ Each task MUST declare dependencies with **Depends on**:
 ### Canonical Delegation Threshold
 
 - Delegate to Scout when you cannot name the file path upfront, expect to inspect 2+ files, or the question is open-ended ("how/where does X work?").
-- Prefer \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` for single investigations; use \`sync: false\` only for multi-scout fan-out.
+- Prefer \`task({ subagent_type: "scout-researcher", prompt: "..." })\` for single investigations.
 - Local \`read/grep/glob\` is acceptable only for a single known file and a bounded question.
-- When calling \`hive_background_output\`, choose a timeout (30-120s) based on task size.
+- When running parallel exploration, align with the skill guidance.
 `;
 
 // src/agents/swarm.ts
@@ -14695,6 +14592,8 @@ Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **b
 - When 2+ tasks are runnable: ask operator via \`question()\` before parallelizing
 - Record execution decisions with \`hive_context_write({ name: "execution-decisions", ... })\`
 
+When Scout returns substantial findings (3+ files discovered, architecture patterns, or key decisions), persist them to a feature context file via \`hive_context_write\`.
+
 If tasks are missing **Depends on** metadata, ask the planner to revise the plan before executing.
 
 ### Standard Checks
@@ -14703,7 +14602,7 @@ If tasks are missing **Depends on** metadata, ask the planner to revise the plan
 2. Can I do it myself FOR SURE? REALLY?
 3. Does this require external system data (DBs/APIs/3rd-party tools)?
 → If external data needed: Load \`hive_skill("parallel-exploration")\` for parallel Scout fan-out
-In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
+In task mode, use task() for research fan-out.
 During Planning, default to synchronous exploration. If async exploration would help, ask the user via \`question()\` and follow the onboarding preferences.
 → Default: DELEGATE
 
@@ -14721,17 +14620,16 @@ During Planning, default to synchronous exploration. If async exploration would
 ## Worker Spawning
 
 \`\`\`
-hive_exec_start({ task: "01-task-name" })
-// If delegationRequired returned:
-hive_background_task({ agent: "forager-worker", prompt: "...", sync: false })
+hive_worktree_create({ task: "01-task-name" })
 // If external system data is needed (parallel exploration):
 // Load hive_skill("parallel-exploration") for the full playbook, then:
-// In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
+// In task mode, use task() for research fan-out.
 \`\`\`
 
-**Sync Mode Guidance:**
-- \`sync: true\` — Use for single-scout research when you need the result before continuing
-- \`sync: false\` — Use for parallel fan-out (multiple scouts) or when you can proceed without waiting
+**Delegation Guidance:**
+- \`task()\` is BLOCKING — returns when the worker is done
+- Call \`hive_status()\` immediately after to check new state and find next runnable tasks
+- For parallel fan-out, issue multiple \`task()\` calls in the same message
 
 ## After Delegation - ALWAYS VERIFY
 
@@ -14742,9 +14640,9 @@ hive_background_task({ agent: "forager-worker", prompt: "...", sync: false })
 ## Blocker Handling
 
 When worker reports blocked:
-1. \`hive_worker_status()\` — read blocker info
+1. \`hive_status()\` — read blocker info
 2. \`question()\` — ask user (NEVER plain text)
-3. \`hive_exec_start({ task, continueFrom: "blocked", decision })\`
+3. \`hive_worktree_create({ task, continueFrom: "blocked", decision })\`
 
 ## Failure Recovery (After 3 Consecutive Failures)
 
@@ -14762,6 +14660,13 @@ hive_merge({ task: "01-task-name", strategy: "merge" })
 
 Merge only after verification passes.
 
+## Post-Batch Review (Hygienic)
+
+After completing and merging a batch:
+1. Ask the user via \`question()\` if they want a Hygienic code review for the batch.
+2. If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\`.
+3. Apply feedback before starting the next batch.
+
 ## Iron Laws
 
 **Never:**
@@ -14871,6 +14776,89 @@ When asked to retrieve raw data from external systems (MongoDB/Stripe/etc.):
 - GitHub: Permalinks with commit SHA
 - Docs: URL with section anchor
 
+## Persistence
+
+When operating within a feature context (background task with feature parameter):
+- If findings are substantial (3+ files discovered, architecture patterns, or key decisions):
+  Use \`hive_context_write\` to persist findings:
+  \`\`\`
+  hive_context_write({
+    name: "research-{topic-slug}",
+    content: "## Research: {Topic}
+
+Date: {date}
+
+## Context
+
+## research-findings
+
+# Research Findings for Hive Improvements v2
+
+## Worker Prompt Builder (\`worker-prompt.ts:48\`)
+- \`buildWorkerPrompt(params: WorkerPromptParams): string\`
+- Receives: feature, task, taskOrder, worktreePath, branch, plan, contextFiles, spec, previousTasks, continueFrom
+- Only uses: feature, task, taskOrder, worktreePath, branch, spec, continueFrom
+- plan/contextFiles/previousTasks passed but NOT used (already embedded in spec)
+- 10 sections: Assignment, Continuation(optional), Mission(=spec), Blocker Protocol, Completion Protocol, TDD, Debugging, Tools, Guidelines, User Input
+- **ZERO task-type awareness** — all workers get identical protocols
+- Budget: 100KB soft limit (advisory, not enforced)
+
+## Task Completion Flow (\`index.ts:974-1088\`)
+- \`hive_exec_complete\` accepts: task, summary (string), status (completed|blocked|failed|partial), blocker (optional)
+- Summary stored in: status.json, report.md, commit message (first 50 chars)
+- **Summary is free-form string** — no structure enforced
+- Completed summaries collected for next task: \`allTasks.filter(t => t.status === 'done' && t.summary)\`
+- Injected into spec as \`## Completed Tasks\` → \`- taskName: summary\`
+
+## TaskService (\`taskService.ts\`)
+- \`buildSpecContent()\` (lines 168-225): builds spec with Dependencies, Plan Section, Context, Completed Tasks
+- \`parseTasksFromPlan()\` (lines 532-602): regex \`/^###\\s+(\\d+)\\.\\s+(.+)$/\` for task headers
+- \`resolveDependencies()\` (lines 248-268): explicit deps or implicit sequential (N depends on N-1)
+- Types: TaskStatus has \`summary?: string\`, TaskInfo has \`summary?: string\`
+
+## Forager Agent (\`forager.ts:8-117\`)
+- Execution flow: Understand → Implement → Verify → Report
+- **NO orient/pre-flight phase** — jumps straight to understanding task spec
+- Can read codebase, use research tools (grep_app, context7, ast_grep)
+- Cannot: delegate (task/hive_exec_start), modify plan, use hive_merge
+- Notepads: \`.hive/features/{feature}/notepads/{learnings,issues,decisions}.md\` (append-only)
+
+## Hygienic Agent (\`hygienic.ts:8-105\`)
+- Reviews plan DOCUMENTATION quality, not design
+- 4 criteria: Clarity, Verifiability, Completeness, Big Picture
+- Verdict: OKAY or REJECT with 4-category assessment
+- When asked to review implementation → loads \`hive_skill("code-reviewer")\`
+- **Currently only invoked for plan review** (from Hive and Architect agents)
+- Cannot delegate/spawn workers
+
+## Scout Agent (\`scout.ts:8-112\`)
+- Read-only research agent
+- Classifies requests: CONCEPTUAL, IMPLEMENTATION, CODEBASE, COMPREHENSIVE
+- Output format: \`<results><files>...<answer>...<next_steps>...</results>\`
+- **Does NOT persist findings** — returns to orchestrator only
+- Parallel execution by default (3+ tools simultaneously)
+
+## Code-Reviewer Skill (\`skills/code-reviewer/SKILL.md\`)
+- Loaded by Hygienic when reviewing implementation
+- Output: APPROVE | REQUEST_CHANGES | NEEDS_DISCUSSION
+- Reviews: plan adherence, correctness, simplicity/YAGNI, risk
+- Already exists but underused (Hygienic only loads it when explicitly asked)
+
+## Plan Format
+- Headers: \`### N. Task Name\`
+- Sections: Depends on, What to do, Must NOT do, References (file:lines), Acceptance Criteria
+- Dependencies: \`none\` | \`1\` | \`1,3\` | implicit sequential
+
+## Skills (10 total)
+writing-plans, executing-plans, dispatching-parallel-agents, parallel-exploration, code-reviewer, onboarding, brainstorming, verification-before-completion, test-driven-development, systematic-debugging
+
+## Notepad System
+- Location: \`.hive/features/{feature}/notepads/{learnings,issues,decisions}.md\`
+- Workers append-only
+- **NOT automatically injected into next batch** — context injection only reads from \`contexts/\` directory"
+  })
+  \`\`\`
+
 ## Iron Laws
 
 **Never:**
@@ -14896,7 +14884,7 @@ Execute directly. NEVER delegate implementation. Work in isolation.
 
 These tools are FORBIDDEN:
 - \`task\` — Orchestrator's job
-- \`hive_exec_start\` — You ARE the spawned worker
+- \`hive_worktree_create\` — You ARE the spawned worker
 - \`hive_merge\` — Orchestrator's job
 
 ## Allowed Research
@@ -14914,14 +14902,10 @@ CRITICAL: NEVER MODIFY THE PLAN FILE
 - MUST NOT edit, modify, or update plan
 - Only Orchestrator (Swarm) manages plan
 
-## Notepad Location
+## Persistent Notes
 
-Path: \`.hive/features/{feature}/notepads/\`
-- learnings.md: Patterns, conventions, successful approaches
-- issues.md: Problems, blockers, gotchas
-- decisions.md: Architectural choices and rationales
-
-IMPORTANT: Always APPEND — never overwrite.
+For substantial discoveries (architecture patterns, key decisions, gotchas that affect multiple tasks):
+Use \`hive_context_write({ name: "learnings", content: "..." })\` to persist for future workers.
 
 ## Execution Flow
 
@@ -14932,7 +14916,14 @@ Read spec for:
 - **Must NOT do** (guardrails)
 - **Acceptance criteria**
 
-### 2. Implement
+### 2. Orient (Pre-flight Before Coding)
+Before writing code:
+- Confirm dependencies are satisfied and required context is present
+- Identify the exact files/sections to touch (from references)
+- Decide the first failing test you will write (TDD)
+- Plan the minimum change to reach green
+
+### 3. Implement
 Follow spec exactly. Use references for patterns.
 
 \`\`\`
@@ -14941,28 +14932,28 @@ edit(file, { old: "...", new: "..." })   // Implement
 bash("npm test")                          // Verify
 \`\`\`
 
-### 3. Verify
+### 4. Verify
 Run acceptance criteria:
 - Tests pass
 - Build succeeds
 - lsp_diagnostics clean on changed files
 
-### 4. Report
+### 5. Report
 
 **Success:**
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "current-task",
   summary: "Implemented X. Tests pass.",
   status: "completed"
 })
 \`\`\`
 
-**CRITICAL: After hive_exec_complete, STOP IMMEDIATELY.**
+**CRITICAL: After hive_worktree_commit, STOP IMMEDIATELY.**
 
 **Blocked (need user decision):**
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "current-task",
   summary: "Progress on X. Blocked on Y.",
   status: "blocked",
@@ -14987,8 +14978,8 @@ After 3 consecutive failures:
 **Never:**
 - Exceed task scope
 - Modify plan file
-- Use \`task\` or \`hive_exec_start\`
-- Continue after hive_exec_complete
+- Use \`task\` or \`hive_worktree_create\`
+- Continue after hive_worktree_commit
 - Skip verification
 
 **Always:**
@@ -15995,7 +15986,6 @@ var DEFAULT_HIVE_CONFIG = {
   disableSkills: [],
   disableMcps: [],
   agentMode: "unified",
-  delegateMode: "task",
   agents: {
     "hive-master": {
       model: DEFAULT_AGENT_MODELS["hive-master"],
@@ -16049,16 +16039,12 @@ 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 normalizePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function getHivePath(projectRoot) {
   return path2.join(projectRoot, HIVE_DIR);
 }
-function getJournalPath(projectRoot) {
-  return path2.join(getHivePath(projectRoot), JOURNAL_FILE);
-}
 function getFeaturesPath(projectRoot) {
   return path2.join(getHivePath(projectRoot), FEATURES_DIR);
 }
@@ -16295,22 +16281,6 @@ function listFeatures(projectRoot) {
     return [];
   return fs22.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) {
@@ -16324,10 +16294,6 @@ 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",
@@ -16596,6 +16562,27 @@ class TaskService {
   }
   buildSpecContent(params) {
     const { featureName, task, dependsOn, allTasks, planContent, contextFiles = [], completedTasks = [] } = params;
+    const getTaskType = (planSection2, taskName) => {
+      if (!planSection2) {
+        return null;
+      }
+      const fileTypeMatches = Array.from(planSection2.matchAll(/-\s*(Create|Modify|Test):/gi)).map((match) => match[1].toLowerCase());
+      const fileTypes = new Set(fileTypeMatches);
+      if (fileTypes.size === 0) {
+        return taskName.toLowerCase().includes("test") ? "testing" : null;
+      }
+      if (fileTypes.size === 1) {
+        const onlyType = Array.from(fileTypes)[0];
+        if (onlyType === "create")
+          return "greenfield";
+        if (onlyType === "test")
+          return "testing";
+      }
+      if (fileTypes.has("modify")) {
+        return "modification";
+      }
+      return null;
+    };
     const specLines = [
       `# Task: ${task.folder}`,
       "",
@@ -16624,6 +16611,10 @@ class TaskService {
       specLines.push("_No plan section available._");
     }
     specLines.push("");
+    const taskType = getTaskType(planSection, task.name);
+    if (taskType) {
+      specLines.push("## Task Type", "", taskType, "");
+    }
     if (contextFiles.length > 0) {
       const contextCompiled = contextFiles.map((f) => `## ${f.name}
 
@@ -21632,13 +21623,6 @@ class ConfigService {
     const config2 = this.get();
     return config2.disableMcps ?? [];
   }
-  getDelegateMode() {
-    const config2 = this.get();
-    return config2.delegateMode ?? "task";
-  }
-  isHiveBackgroundEnabled() {
-    return this.getDelegateMode() === "hive";
-  }
 }
 function computeRunnableAndBlocked(tasks) {
   const statusByFolder = new Map;
@@ -21747,16 +21731,26 @@ ${spec}
 
 ---
 
+## Pre-implementation Checklist
+
+Before writing code, confirm:
+1. Dependencies are satisfied and required context is present.
+2. The exact files/sections to touch (from references) are identified.
+3. The first failing test to write is clear (TDD).
+4. The minimal change needed to reach green is planned.
+
+---
+
 ## Blocker Protocol
 
 If you hit a blocker requiring human decision, **DO NOT** use the question tool directly.
 Instead, escalate via the blocker protocol:
 
 1. **Save your progress** to the worktree (commit if appropriate)
-2. **Call hive_exec_complete** with blocker info:
+2. **Call hive_worktree_commit** with blocker info:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "blocked",
@@ -21770,7 +21764,7 @@ hive_exec_complete({
 })
 \`\`\`
 
-**After calling hive_exec_complete with blocked status, STOP IMMEDIATELY.**
+**After calling hive_worktree_commit with blocked status, STOP IMMEDIATELY.**
 
 The Hive Master will:
 1. Receive your blocker info
@@ -21786,7 +21780,7 @@ This keeps the user focused on ONE conversation (Hive Master) instead of multipl
 When your task is **fully complete**:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "completed",
@@ -21794,14 +21788,20 @@ hive_exec_complete({
 })
 \`\`\`
 
-**CRITICAL: After calling hive_exec_complete, you MUST STOP IMMEDIATELY.**
+**CRITICAL: After calling hive_worktree_commit, you MUST STOP IMMEDIATELY.**
 Do NOT continue working. Do NOT respond further. Your session is DONE.
 The Hive Master will take over from here.
 
+**Summary Guidance** (used verbatim for downstream task context):
+1. Start with **what changed** (files/areas touched).
+2. Mention **why** if it affects future tasks.
+3. Note **verification evidence** (tests/build/lint) or explicitly say "Not run".
+4. Keep it **2-4 sentences** max.
+
 If you encounter an **unrecoverable error**:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "failed",
@@ -21812,7 +21812,7 @@ hive_exec_complete({
 If you made **partial progress** but can't continue:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "partial",
@@ -21846,16 +21846,16 @@ After 3 failed attempts at same fix: STOP and report blocker.
 
 **You have access to:**
 - All standard tools (read, write, edit, bash, glob, grep)
-- \`hive_exec_complete\` - Signal task done/blocked/failed
-- \`hive_exec_abort\` - Abort and discard changes
+- \`hive_worktree_commit\` - Signal task done/blocked/failed
+- \`hive_worktree_discard\` - Abort and discard changes
 - \`hive_plan_read\` - Re-read plan if needed
 - \`hive_context_write\` - Save learnings for future tasks
 
 **You do NOT have access to (or should not use):**
 - \`question\` - Escalate via blocker protocol instead
-- \`hive_exec_start\` - No spawning sub-workers
+- \`hive_worktree_create\` - No spawning sub-workers
 - \`hive_merge\` - Only Hive Master merges
-- \`hive_background_task\` / \`task\` - No recursive delegation
+- \`task\` - No recursive delegation
 
 ---
 
@@ -21865,7 +21865,7 @@ After 3 failed attempts at same fix: STOP and report blocker.
 2. **Stay in scope** - Only do what the spec asks
 3. **Escalate blockers** - Don't guess on important decisions
 4. **Save context** - Use hive_context_write for discoveries
-5. **Complete cleanly** - Always call hive_exec_complete when done
+5. **Complete cleanly** - Always call hive_worktree_commit when done
 
 ---
 
@@ -22107,63 +22107,6 @@ function applyContextBudget(files, config2 = {}) {
 // src/utils/prompt-file.ts
 import * as fs6 from "fs";
 import * as path5 from "path";
-function findWorkspaceRoot(startDir) {
-  try {
-    let current = path5.resolve(startDir);
-    while (true) {
-      const hivePath = path5.join(current, ".hive");
-      if (fs6.existsSync(hivePath) && fs6.statSync(hivePath).isDirectory()) {
-        return current;
-      }
-      const parent = path5.dirname(current);
-      if (parent === current) {
-        return null;
-      }
-      current = parent;
-    }
-  } catch {
-    return null;
-  }
-}
-function isValidPromptFilePath(filePath, workspaceRoot) {
-  try {
-    const normalizedFilePath = path5.resolve(filePath);
-    const normalizedWorkspace = path5.resolve(workspaceRoot);
-    let normalizedFilePathForCompare = normalizePath(normalizedFilePath);
-    let normalizedWorkspaceForCompare = normalizePath(normalizedWorkspace);
-    if (process.platform === "win32") {
-      normalizedFilePathForCompare = normalizedFilePathForCompare.toLowerCase();
-      normalizedWorkspaceForCompare = normalizedWorkspaceForCompare.toLowerCase();
-    }
-    if (!normalizedFilePathForCompare.startsWith(normalizedWorkspaceForCompare + "/") && normalizedFilePathForCompare !== normalizedWorkspaceForCompare) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolvePromptFromFile(promptFilePath, workspaceRoot) {
-  if (!isValidPromptFilePath(promptFilePath, workspaceRoot)) {
-    return {
-      error: `Prompt file path "${promptFilePath}" is outside the workspace. ` + `Only files within "${workspaceRoot}" are allowed.`
-    };
-  }
-  const resolvedPath = path5.resolve(promptFilePath);
-  if (!fs6.existsSync(resolvedPath)) {
-    return {
-      error: `Prompt file not found: "${resolvedPath}"`
-    };
-  }
-  try {
-    const content = fs6.readFileSync(resolvedPath, "utf-8");
-    return { content };
-  } catch (err) {
-    return {
-      error: `Failed to read prompt file: ${err instanceof Error ? err.message : "Unknown error"}`
-    };
-  }
-}
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
   const promptDir = path5.join(hiveDir, "features", feature, "tasks", task);
   const promptPath = path5.join(promptDir, "worker-prompt.md");
@@ -22174,1470 +22117,77 @@ function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
   return promptPath;
 }
 
-// src/background/types.ts
-var VALID_TRANSITIONS = {
-  spawned: ["pending", "running", "error", "cancelled"],
-  pending: ["running", "error", "cancelled"],
-  running: ["completed", "error", "cancelled", "blocked", "failed"],
-  completed: [],
-  error: [],
-  cancelled: [],
-  blocked: ["running", "cancelled"],
-  failed: []
-};
-function isTerminalStatus(status) {
-  return VALID_TRANSITIONS[status].length === 0;
-}
-function isValidTransition(from, to) {
-  return VALID_TRANSITIONS[from].includes(to);
-}
-// src/background/store.ts
-function generateTaskId() {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `task-${timestamp}-${random}`;
-}
-
-class BackgroundTaskStore {
-  tasks = new Map;
-  idempotencyIndex = new Map;
-  create(options) {
-    if (options.idempotencyKey) {
-      const existingId = this.idempotencyIndex.get(options.idempotencyKey);
-      if (existingId) {
-        throw new Error(`Idempotency key "${options.idempotencyKey}" already exists for task "${existingId}". ` + `Use getByIdempotencyKey() to retrieve the existing task.`);
-      }
-    }
-    const taskId = generateTaskId();
-    const now = new Date().toISOString();
-    const record2 = {
-      taskId,
-      sessionId: options.sessionId,
-      agent: options.agent,
-      description: options.description,
-      status: "spawned",
-      provider: "hive",
-      idempotencyKey: options.idempotencyKey,
-      createdAt: now,
-      lastActiveAt: now,
-      parentSessionId: options.parentSessionId,
-      parentMessageId: options.parentMessageId,
-      parentAgent: options.parentAgent,
-      notifyParent: options.notifyParent,
-      hiveFeature: options.hiveFeature,
-      hiveTaskFolder: options.hiveTaskFolder,
-      workdir: options.workdir
-    };
-    this.tasks.set(taskId, record2);
-    if (options.idempotencyKey) {
-      this.idempotencyIndex.set(options.idempotencyKey, taskId);
-    }
-    return record2;
-  }
-  get(taskId) {
-    return this.tasks.get(taskId);
-  }
-  getByIdempotencyKey(key) {
-    const taskId = this.idempotencyIndex.get(key);
-    if (!taskId)
-      return;
-    return this.tasks.get(taskId);
-  }
-  getByHiveTask(feature, taskFolder) {
-    for (const task of this.tasks.values()) {
-      if (task.hiveFeature === feature && task.hiveTaskFolder === taskFolder) {
-        return task;
-      }
-    }
+// src/hooks/variant-hook.ts
+var HIVE_AGENT_NAMES = [
+  "hive-master",
+  "architect-planner",
+  "swarm-orchestrator",
+  "scout-researcher",
+  "forager-worker",
+  "hygienic-reviewer"
+];
+function isHiveAgent(agent) {
+  return agent !== undefined && HIVE_AGENT_NAMES.includes(agent);
+}
+function normalizeVariant(variant) {
+  if (variant === undefined)
     return;
-  }
-  updateStatus(taskId, newStatus, updates) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      throw new Error(`Task "${taskId}" not found`);
-    }
-    if (!isValidTransition(task.status, newStatus)) {
-      throw new Error(`Invalid state transition: ${task.status} -> ${newStatus} for task "${taskId}"`);
-    }
-    const now = new Date().toISOString();
-    if (newStatus === "running" && !task.startedAt) {
-      task.startedAt = now;
-    }
-    if (isTerminalStatus(newStatus) && !task.completedAt) {
-      task.completedAt = now;
-    }
-    task.status = newStatus;
-    task.lastActiveAt = now;
-    if (updates?.errorMessage !== undefined) {
-      task.errorMessage = updates.errorMessage;
-    }
-    if (updates?.progress !== undefined) {
-      task.progress = { ...task.progress, ...updates.progress };
-    }
-    return task;
-  }
-  updateProgress(taskId, progress) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      throw new Error(`Task "${taskId}" not found`);
-    }
-    const now = new Date().toISOString();
-    task.lastActiveAt = now;
-    task.progress = { ...task.progress, ...progress };
-    return task;
-  }
-  delete(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task)
-      return false;
-    if (task.idempotencyKey) {
-      this.idempotencyIndex.delete(task.idempotencyKey);
-    }
-    return this.tasks.delete(taskId);
-  }
-  list(filter) {
-    let tasks = Array.from(this.tasks.values());
-    if (filter?.status) {
-      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-      tasks = tasks.filter((t) => statuses.includes(t.status));
-    }
-    if (filter?.parentSessionId) {
-      tasks = tasks.filter((t) => t.parentSessionId === filter.parentSessionId);
-    }
-    if (filter?.hiveFeature) {
-      tasks = tasks.filter((t) => t.hiveFeature === filter.hiveFeature);
-    }
-    return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  }
-  getActive() {
-    return this.list().filter((t) => !isTerminalStatus(t.status));
-  }
-  countByStatus() {
-    const counts = {
-      spawned: 0,
-      pending: 0,
-      running: 0,
-      completed: 0,
-      error: 0,
-      cancelled: 0,
-      blocked: 0,
-      failed: 0
-    };
-    for (const task of this.tasks.values()) {
-      counts[task.status]++;
-    }
-    return counts;
-  }
-  clear() {
-    this.tasks.clear();
-    this.idempotencyIndex.clear();
-  }
-  get size() {
-    return this.tasks.size;
-  }
+  const trimmed2 = variant.trim();
+  return trimmed2.length > 0 ? trimmed2 : undefined;
 }
-var globalStore = null;
-function getStore() {
-  if (!globalStore) {
-    globalStore = new BackgroundTaskStore;
-  }
-  return globalStore;
+
+// src/index.ts
+function formatSkillsXml(skills) {
+  if (skills.length === 0)
+    return "";
+  const skillsXml = skills.map((skill) => {
+    return [
+      "  <skill>",
+      `    <name>${skill.name}</name>`,
+      `    <description>(hive - Skill) ${skill.description}</description>`,
+      "  </skill>"
+    ].join(`
+`);
+  }).join(`
+`);
+  return `
+
+<available_skills>
+${skillsXml}
+</available_skills>`;
 }
-// src/background/agent-gate.ts
-var BLOCKED_AGENTS = new Set([
-  "orchestrator",
-  "hive",
-  "hive-master",
-  "swarm-orchestrator",
-  "conductor",
-  "main"
-]);
-var RESTRICTED_AGENTS = new Set([
-  "admin",
-  "root",
-  "superuser"
-]);
-
-class AgentGate {
-  client;
-  cachedAgents = null;
-  cacheExpiry = 0;
-  cacheTtlMs = 30000;
-  constructor(client) {
-    this.client = client;
-  }
-  async discoverAgents() {
-    const now = Date.now();
-    if (this.cachedAgents && now < this.cacheExpiry) {
-      return this.cachedAgents;
-    }
-    try {
-      const result = await this.client.app.agents({});
-      const agents = result.data ?? [];
-      this.cachedAgents = agents;
-      this.cacheExpiry = now + this.cacheTtlMs;
-      return agents;
-    } catch (error45) {
-      if (this.cachedAgents) {
-        return this.cachedAgents;
-      }
-      throw new Error(`Failed to discover agents: ${error45 instanceof Error ? error45.message : "Unknown error"}`);
-    }
+async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot) {
+  const agentConfig = configService.getAgentConfig(agentName);
+  const autoLoadSkills = agentConfig.autoLoadSkills ?? [];
+  if (autoLoadSkills.length === 0) {
+    return "";
   }
-  async validate(agentName, options = {}) {
-    const name = agentName.trim().toLowerCase();
-    if (BLOCKED_AGENTS.has(name)) {
-      return {
-        valid: false,
-        error: `Agent "${agentName}" is an orchestrator agent and cannot be spawned as a background worker. ` + `Use a worker agent like "forager-worker", "scout-researcher", or "hygienic-reviewer".`
-      };
-    }
-    if (options.additionalBlocked?.includes(name)) {
-      return {
-        valid: false,
-        error: `Agent "${agentName}" is blocked by configuration.`
-      };
-    }
-    if (RESTRICTED_AGENTS.has(name) && !options.allowRestricted) {
-      return {
-        valid: false,
-        error: `Agent "${agentName}" is restricted and requires explicit allowance. ` + `Set allowRestricted: true to spawn this agent.`
-      };
-    }
-    let agents;
-    try {
-      agents = await this.discoverAgents();
-    } catch (error45) {
-      return {
-        valid: false,
-        error: error45 instanceof Error ? error45.message : "Failed to discover agents"
-      };
+  const homeDir = process.env.HOME || os.homedir();
+  const skillTemplates = [];
+  for (const skillId of autoLoadSkills) {
+    const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
+    if (builtinSkill) {
+      skillTemplates.push(builtinSkill.template);
+      continue;
     }
-    const agent = agents.find((a) => a.name.toLowerCase() === name);
-    if (!agent) {
-      const available = agents.filter((a) => !BLOCKED_AGENTS.has(a.name.toLowerCase())).map((a) => `  • ${a.name}${a.description ? ` - ${a.description}` : ""}`).join(`
-`);
-      return {
-        valid: false,
-        error: `Agent "${agentName}" not found in registry.
-
-Available agents:
-${available || "(none)"}`
-      };
+    const fileResult = await loadFileSkill(skillId, projectRoot, homeDir);
+    if (fileResult.found && fileResult.skill) {
+      skillTemplates.push(fileResult.skill.template);
+      continue;
     }
-    return {
-      valid: true,
-      agent
-    };
-  }
-  async getWorkerAgents() {
-    const agents = await this.discoverAgents();
-    return agents.filter((a) => {
-      const name = a.name.toLowerCase();
-      return !BLOCKED_AGENTS.has(name) && !RESTRICTED_AGENTS.has(name);
-    });
-  }
-  clearCache() {
-    this.cachedAgents = null;
-    this.cacheExpiry = 0;
-  }
-  isBlocked(agentName) {
-    return BLOCKED_AGENTS.has(agentName.trim().toLowerCase());
+    console.warn(`[hive] Unknown skill id "${skillId}" for agent "${agentName}"`);
   }
-  isRestricted(agentName) {
-    return RESTRICTED_AGENTS.has(agentName.trim().toLowerCase());
+  if (skillTemplates.length === 0) {
+    return "";
   }
+  return `
+
+` + skillTemplates.join(`
+
+`);
 }
-function createAgentGate(client) {
-  return new AgentGate(client);
-}
-// src/background/concurrency.ts
-var DEFAULT_CONFIG = {
-  defaultLimit: 3,
-  agentLimits: {},
-  modelLimits: {},
-  queueTimeoutMs: 5 * 60 * 1000,
-  minDelayBetweenStartsMs: 1000
-};
-
-class ConcurrencyManager {
-  config;
-  counts = new Map;
-  queues = new Map;
-  lastStartTimes = new Map;
-  constructor(config2 = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config2 };
-  }
-  getLimit(key) {
-    if (key.includes("/")) {
-      const modelLimit = this.config.modelLimits[key];
-      if (modelLimit !== undefined) {
-        return modelLimit === 0 ? Infinity : modelLimit;
-      }
-      const provider = key.split("/")[0];
-      const providerLimit = this.config.modelLimits[provider];
-      if (providerLimit !== undefined) {
-        return providerLimit === 0 ? Infinity : providerLimit;
-      }
-    }
-    const agentLimit = this.config.agentLimits[key];
-    if (agentLimit !== undefined) {
-      return agentLimit === 0 ? Infinity : agentLimit;
-    }
-    return this.config.defaultLimit === 0 ? Infinity : this.config.defaultLimit;
-  }
-  async acquire(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity) {
-      return;
-    }
-    await this.enforceRateLimit(key);
-    const current = this.counts.get(key) ?? 0;
-    if (current < limit) {
-      this.counts.set(key, current + 1);
-      this.lastStartTimes.set(key, Date.now());
-      return;
-    }
-    return new Promise((resolve2, reject) => {
-      const queue = this.queues.get(key) ?? [];
-      const entry = {
-        resolve: () => {
-          if (entry.settled)
-            return;
-          entry.settled = true;
-          clearTimeout(entry.timeoutId);
-          this.lastStartTimes.set(key, Date.now());
-          resolve2();
-        },
-        reject: (error45) => {
-          if (entry.settled)
-            return;
-          entry.settled = true;
-          clearTimeout(entry.timeoutId);
-          reject(error45);
-        },
-        settled: false,
-        enqueuedAt: Date.now(),
-        timeoutId: setTimeout(() => {
-          if (!entry.settled) {
-            entry.settled = true;
-            const q = this.queues.get(key);
-            if (q) {
-              const idx = q.indexOf(entry);
-              if (idx !== -1)
-                q.splice(idx, 1);
-            }
-            reject(new Error(`Concurrency queue timeout for key "${key}" after ${this.config.queueTimeoutMs}ms`));
-          }
-        }, this.config.queueTimeoutMs)
-      };
-      queue.push(entry);
-      this.queues.set(key, queue);
-    });
-  }
-  release(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity) {
-      return;
-    }
-    const queue = this.queues.get(key);
-    while (queue && queue.length > 0) {
-      const next = queue.shift();
-      if (!next.settled) {
-        next.resolve();
-        return;
-      }
-    }
-    const current = this.counts.get(key) ?? 0;
-    if (current > 0) {
-      this.counts.set(key, current - 1);
-    }
-  }
-  tryAcquire(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity) {
-      return true;
-    }
-    const current = this.counts.get(key) ?? 0;
-    if (current < limit) {
-      this.counts.set(key, current + 1);
-      this.lastStartTimes.set(key, Date.now());
-      return true;
-    }
-    return false;
-  }
-  cancelWaiters(key) {
-    const queue = this.queues.get(key);
-    if (!queue)
-      return 0;
-    let cancelled = 0;
-    for (const entry of queue) {
-      if (!entry.settled) {
-        entry.reject(new Error(`Concurrency queue cancelled for key: ${key}`));
-        cancelled++;
-      }
-    }
-    this.queues.delete(key);
-    return cancelled;
-  }
-  clear() {
-    for (const key of this.queues.keys()) {
-      this.cancelWaiters(key);
-    }
-    this.counts.clear();
-    this.queues.clear();
-    this.lastStartTimes.clear();
-  }
-  getCount(key) {
-    return this.counts.get(key) ?? 0;
-  }
-  getQueueLength(key) {
-    const queue = this.queues.get(key);
-    if (!queue)
-      return 0;
-    return queue.filter((e) => !e.settled).length;
-  }
-  getAvailable(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity)
-      return Infinity;
-    const current = this.counts.get(key) ?? 0;
-    return Math.max(0, limit - current);
-  }
-  isAtCapacity(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity)
-      return false;
-    const current = this.counts.get(key) ?? 0;
-    return current >= limit;
-  }
-  getStatus() {
-    const status = {};
-    for (const [key, count] of this.counts.entries()) {
-      status[key] = {
-        count,
-        limit: this.getLimit(key),
-        queued: this.getQueueLength(key)
-      };
-    }
-    for (const key of this.queues.keys()) {
-      if (!status[key]) {
-        status[key] = {
-          count: 0,
-          limit: this.getLimit(key),
-          queued: this.getQueueLength(key)
-        };
-      }
-    }
-    return status;
-  }
-  async enforceRateLimit(key) {
-    const lastStart = this.lastStartTimes.get(key);
-    if (!lastStart)
-      return;
-    const elapsed = Date.now() - lastStart;
-    const delay2 = this.config.minDelayBetweenStartsMs - elapsed;
-    if (delay2 > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, delay2));
-    }
-  }
-}
-function createConcurrencyManager(config2) {
-  return new ConcurrencyManager(config2);
-}
-// src/background/poller.ts
-var DEFAULT_CONFIG2 = {
-  pollIntervalMs: 5000,
-  maxPollIntervalMs: 30000,
-  stuckThresholdMs: 10 * 60 * 1000,
-  minRuntimeBeforeStuckMs: 30 * 1000,
-  stableCountThreshold: 3
-};
-
-class BackgroundPoller {
-  store;
-  client;
-  config;
-  handlers;
-  pollingState = new Map;
-  pollInterval = null;
-  isPolling = false;
-  currentIntervalMs;
-  constructor(store, client, config2 = {}, handlers = {}) {
-    this.store = store;
-    this.client = client;
-    this.config = { ...DEFAULT_CONFIG2, ...config2 };
-    this.handlers = handlers;
-    this.currentIntervalMs = this.config.pollIntervalMs;
-  }
-  start() {
-    if (this.pollInterval)
-      return;
-    this.pollInterval = setInterval(() => {
-      this.poll().catch((err) => {
-        console.warn("[BackgroundPoller] Poll error:", err);
-      });
-    }, this.currentIntervalMs);
-    this.pollInterval.unref();
-  }
-  stop() {
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = null;
-    }
-    this.isPolling = false;
-  }
-  isRunning() {
-    return this.pollInterval !== null;
-  }
-  getObservations() {
-    const observations = [];
-    const activeTasks = this.store.getActive();
-    for (const task of activeTasks) {
-      const state = this.pollingState.get(task.taskId);
-      const observation = this.buildObservation(task, state);
-      observations.push(observation);
-    }
-    return observations;
-  }
-  getTaskObservation(taskId) {
-    const task = this.store.get(taskId);
-    if (!task)
-      return null;
-    const state = this.pollingState.get(taskId);
-    return this.buildObservation(task, state);
-  }
-  async poll() {
-    if (this.isPolling)
-      return;
-    this.isPolling = true;
-    try {
-      const activeTasks = this.store.getActive();
-      if (activeTasks.length === 0) {
-        this.stop();
-        return;
-      }
-      let sessionStatuses = {};
-      try {
-        const statusResult = await this.client.session.status?.();
-        sessionStatuses = statusResult?.data ?? {};
-      } catch {}
-      for (const task of activeTasks) {
-        if (task.status !== "running")
-          continue;
-        await this.pollTask(task, sessionStatuses);
-      }
-      this.adjustPollingInterval(activeTasks);
-    } finally {
-      this.isPolling = false;
-    }
-  }
-  async pollTask(task, sessionStatuses) {
-    const state = this.pollingState.get(task.taskId) ?? {
-      lastMessageCount: 0,
-      stablePolls: 0,
-      lastPollAt: Date.now(),
-      consecutiveErrors: 0
-    };
-    try {
-      const sessionType = sessionStatuses[task.sessionId]?.type;
-      const messagesResult = await this.client.session.messages({
-        path: { id: task.sessionId }
-      });
-      const messages = messagesResult.data ?? [];
-      const currentMessageCount = messages.length;
-      const now = new Date().toISOString();
-      if (currentMessageCount > state.lastMessageCount) {
-        state.stablePolls = 0;
-        this.store.updateProgress(task.taskId, {
-          messageCount: currentMessageCount,
-          lastMessageAt: now
-        });
-      } else {
-        state.stablePolls++;
-      }
-      state.lastMessageCount = currentMessageCount;
-      state.lastPollAt = Date.now();
-      state.consecutiveErrors = 0;
-      this.pollingState.set(task.taskId, state);
-      const isIdle = sessionType === "idle" || sessionType === "completed";
-      if (isIdle) {
-        this.handlers.onSessionIdle?.(task.sessionId, "status");
-        return;
-      }
-      if (!sessionType && currentMessageCount > 0 && state.stablePolls >= this.config.stableCountThreshold) {
-        try {
-          const session = await this.client.session.get({ path: { id: task.sessionId } });
-          const status = session.data?.status;
-          if (status === "idle" || status === "completed") {
-            this.handlers.onSessionIdle?.(task.sessionId, "status");
-            return;
-          }
-        } catch {}
-        this.handlers.onSessionIdle?.(task.sessionId, "stable");
-      }
-    } catch (error45) {
-      state.consecutiveErrors++;
-      state.lastPollAt = Date.now();
-      this.pollingState.set(task.taskId, state);
-      if (state.consecutiveErrors >= 3) {
-        console.warn(`[BackgroundPoller] Multiple errors polling task ${task.taskId}:`, error45);
-      }
-    }
-  }
-  buildObservation(task, state) {
-    const now = Date.now();
-    const stablePolls = state?.stablePolls ?? 0;
-    const lastActivityAt = task.progress?.lastMessageAt ?? task.lastActiveAt ?? null;
-    let maybeStuck = false;
-    if (task.status === "running" && task.startedAt) {
-      const startedAt = new Date(task.startedAt).getTime();
-      const runtime = now - startedAt;
-      if (runtime >= this.config.minRuntimeBeforeStuckMs) {
-        const lastActivity = lastActivityAt ? new Date(lastActivityAt).getTime() : startedAt;
-        const timeSinceActivity = now - lastActivity;
-        maybeStuck = timeSinceActivity >= this.config.stuckThresholdMs;
-      }
-    }
-    return {
-      taskId: task.taskId,
-      sessionId: task.sessionId,
-      status: task.status,
-      messageCount: task.progress?.messageCount ?? 0,
-      lastActivityAt,
-      maybeStuck,
-      stablePolls,
-      isStable: stablePolls >= this.config.stableCountThreshold
-    };
-  }
-  adjustPollingInterval(activeTasks) {
-    const now = Date.now();
-    let recentActivityCount = 0;
-    for (const task of activeTasks) {
-      const state = this.pollingState.get(task.taskId);
-      if (state && state.stablePolls < 2) {
-        recentActivityCount++;
-      }
-    }
-    const stableRatio = activeTasks.length > 0 ? (activeTasks.length - recentActivityCount) / activeTasks.length : 0;
-    if (stableRatio > 0.8) {
-      this.currentIntervalMs = Math.min(this.currentIntervalMs * 1.5, this.config.maxPollIntervalMs);
-    } else if (recentActivityCount > 0) {
-      this.currentIntervalMs = this.config.pollIntervalMs;
-    }
-    if (this.pollInterval && Math.abs(this.currentIntervalMs - this.config.pollIntervalMs) > 1000) {
-      this.stop();
-      this.start();
-    }
-  }
-  cleanupTask(taskId) {
-    this.pollingState.delete(taskId);
-  }
-  clear() {
-    this.stop();
-    this.pollingState.clear();
-  }
-}
-function createPoller(store, client, config2, handlers) {
-  return new BackgroundPoller(store, client, config2, handlers);
-}
-// src/background/manager.ts
-class BackgroundManager {
-  store;
-  agentGate;
-  client;
-  taskService;
-  concurrencyManager;
-  poller;
-  enforceHiveSequential;
-  constructor(options) {
-    this.client = options.client;
-    this.store = options.store ?? getStore();
-    this.agentGate = createAgentGate(options.client);
-    this.taskService = new TaskService(options.projectRoot);
-    this.concurrencyManager = createConcurrencyManager(options.concurrency);
-    this.poller = createPoller(this.store, options.client, options.poller, {
-      onSessionIdle: (sessionId) => this.handleSessionIdle(sessionId)
-    });
-    this.enforceHiveSequential = options.enforceHiveSequential ?? true;
-  }
-  async spawn(options) {
-    if (options.idempotencyKey) {
-      const existing = this.store.getByIdempotencyKey(options.idempotencyKey);
-      if (existing) {
-        return {
-          task: existing,
-          wasExisting: true
-        };
-      }
-    }
-    if (options.hiveFeature && options.hiveTaskFolder) {
-      const existing = this.store.getByHiveTask(options.hiveFeature, options.hiveTaskFolder);
-      if (existing && !isTerminalStatus(existing.status)) {
-        return {
-          task: existing,
-          wasExisting: true
-        };
-      }
-      if (this.enforceHiveSequential) {
-        const orderingCheck = this.checkHiveTaskOrdering(options.hiveFeature, options.hiveTaskFolder);
-        if (!orderingCheck.allowed) {
-          return {
-            task: null,
-            wasExisting: false,
-            error: orderingCheck.error
-          };
-        }
-      }
-    }
-    const validation = await this.agentGate.validate(options.agent);
-    if (!validation.valid) {
-      return {
-        task: null,
-        wasExisting: false,
-        error: validation.error
-      };
-    }
-    const concurrencyKey = options.agent;
-    try {
-      await this.concurrencyManager.acquire(concurrencyKey);
-    } catch (error45) {
-      return {
-        task: null,
-        wasExisting: false,
-        error: `Concurrency limit reached: ${error45 instanceof Error ? error45.message : "Unknown error"}`
-      };
-    }
-    let sessionId;
-    try {
-      const sessionResult = await this.client.session.create({
-        body: {
-          title: `Background: ${options.description}`,
-          parentID: options.parentSessionId
-        }
-      });
-      if (!sessionResult.data?.id) {
-        this.concurrencyManager.release(concurrencyKey);
-        return {
-          task: null,
-          wasExisting: false,
-          error: "Failed to create OpenCode session"
-        };
-      }
-      sessionId = sessionResult.data.id;
-    } catch (error45) {
-      this.concurrencyManager.release(concurrencyKey);
-      return {
-        task: null,
-        wasExisting: false,
-        error: `Failed to create session: ${error45 instanceof Error ? error45.message : "Unknown error"}`
-      };
-    }
-    const notifyParent = options.notifyParent ?? !options.sync;
-    const task = this.store.create({
-      agent: options.agent,
-      description: options.description,
-      sessionId,
-      idempotencyKey: options.idempotencyKey,
-      parentSessionId: options.parentSessionId,
-      parentMessageId: options.parentMessageId,
-      parentAgent: options.parentAgent,
-      notifyParent,
-      hiveFeature: options.hiveFeature,
-      hiveTaskFolder: options.hiveTaskFolder,
-      workdir: options.workdir
-    });
-    if (options.hiveFeature && options.hiveTaskFolder) {
-      try {
-        const attempt = options.attempt ?? 1;
-        this.taskService.patchBackgroundFields(options.hiveFeature, options.hiveTaskFolder, {
-          idempotencyKey: options.idempotencyKey,
-          workerSession: {
-            taskId: task.taskId,
-            sessionId: task.sessionId,
-            agent: task.agent,
-            mode: "delegate",
-            attempt
-          }
-        });
-      } catch (error45) {
-        console.warn(`[BackgroundManager] Failed to persist to .hive: ${error45 instanceof Error ? error45.message : "Unknown"}`);
-      }
-    }
-    this.store.updateStatus(task.taskId, "running");
-    this.poller.start();
-    const normalizedVariant = options.variant?.trim() || undefined;
-    this.client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        agent: options.agent,
-        parts: [{ type: "text", text: options.prompt }],
-        tools: {
-          background_task: false,
-          delegate: false,
-          hive_background_task: false,
-          hive_background_output: false,
-          hive_background_cancel: false,
-          task: false
-        },
-        ...normalizedVariant !== undefined && { variant: normalizedVariant }
-      }
-    }).catch((error45) => {
-      this.updateStatus(task.taskId, "error", { errorMessage: error45.message });
-      this.concurrencyManager.release(concurrencyKey);
-      this.poller.cleanupTask(task.taskId);
-    });
-    return {
-      task: this.store.get(task.taskId),
-      wasExisting: false
-    };
-  }
-  checkHiveTaskOrdering(feature, taskFolder) {
-    const taskStatus = this.taskService.getRawStatus(feature, taskFolder);
-    if (taskStatus?.dependsOn !== undefined) {
-      return this.checkDependencies(feature, taskFolder, taskStatus.dependsOn);
-    }
-    return this.checkNumericOrdering(feature, taskFolder);
-  }
-  checkDependencies(feature, taskFolder, dependsOn) {
-    if (dependsOn.length === 0) {
-      return { allowed: true };
-    }
-    const unmetDeps = [];
-    for (const depFolder of dependsOn) {
-      const depStatus = this.taskService.getRawStatus(feature, depFolder);
-      if (!depStatus || depStatus.status !== "done") {
-        unmetDeps.push({
-          folder: depFolder,
-          status: depStatus?.status ?? "unknown"
-        });
-      }
-    }
-    if (unmetDeps.length > 0) {
-      const depList = unmetDeps.map((d) => `"${d.folder}" (${d.status})`).join(", ");
-      return {
-        allowed: false,
-        error: `Dependency constraint: Task "${taskFolder}" cannot start - dependencies not done: ${depList}. ` + `Only tasks with status 'done' satisfy dependencies.`
-      };
-    }
-    return { allowed: true };
-  }
-  checkNumericOrdering(feature, taskFolder) {
-    const orderMatch = taskFolder.match(/^(\d+)-/);
-    if (!orderMatch) {
-      return { allowed: true };
-    }
-    const taskOrder = parseInt(orderMatch[1], 10);
-    if (taskOrder <= 1) {
-      return { allowed: true };
-    }
-    const activeTasks = this.store.list({
-      hiveFeature: feature,
-      status: ["spawned", "pending", "running"]
-    });
-    for (const activeTask of activeTasks) {
-      if (!activeTask.hiveTaskFolder)
-        continue;
-      const activeOrderMatch = activeTask.hiveTaskFolder.match(/^(\d+)-/);
-      if (!activeOrderMatch)
-        continue;
-      const activeOrder = parseInt(activeOrderMatch[1], 10);
-      if (activeOrder < taskOrder) {
-        return {
-          allowed: false,
-          error: `Sequential ordering enforced: Task "${taskFolder}" cannot start while earlier task "${activeTask.hiveTaskFolder}" is still ${activeTask.status}. ` + `Complete or cancel the earlier task first. ` + `(Hive default: sequential execution for safety)`
-        };
-      }
-    }
-    return { allowed: true };
-  }
-  getTask(taskId) {
-    return this.store.get(taskId);
-  }
-  getTaskByIdempotencyKey(key) {
-    return this.store.getByIdempotencyKey(key);
-  }
-  getTaskByHiveTask(feature, taskFolder) {
-    return this.store.getByHiveTask(feature, taskFolder);
-  }
-  updateStatus(taskId, status, options) {
-    const task = this.store.updateStatus(taskId, status, options);
-    if (task.hiveFeature && task.hiveTaskFolder) {
-      try {
-        this.taskService.patchBackgroundFields(task.hiveFeature, task.hiveTaskFolder, {
-          workerSession: {
-            sessionId: task.sessionId,
-            lastHeartbeatAt: new Date().toISOString()
-          }
-        });
-      } catch {}
-    }
-    if (isTerminalStatus(task.status) && task.parentSessionId && task.notifyParent !== false) {
-      this.notifyParentSession(task);
-    }
-    return task;
-  }
-  async notifyParentSession(task) {
-    if (!task.parentSessionId)
-      return;
-    const statusLabel = task.status.toUpperCase();
-    const errorLine = task.errorMessage ? `
-**Error:** ${task.errorMessage}` : "";
-    const notification = `<system-reminder>
-[BACKGROUND TASK ${statusLabel}]
-
-**ID:** \`${task.taskId}\`
-**Description:** ${task.description}
-**Agent:** ${task.agent}${errorLine}
-
- Use \`hive_background_output({ task_id: "${task.taskId}" })\` to retrieve the result.
-</system-reminder>`;
-    try {
-      await this.client.session.prompt({
-        path: { id: task.parentSessionId },
-        body: {
-          agent: task.parentAgent || "hive",
-          parts: [{ type: "text", text: notification }]
-        }
-      });
-    } catch {}
-  }
-  async cancel(taskId) {
-    const task = this.store.get(taskId);
-    if (!task) {
-      throw new Error(`Task "${taskId}" not found`);
-    }
-    if (isTerminalStatus(task.status)) {
-      throw new Error(`Cannot cancel task in terminal status: ${task.status}`);
-    }
-    try {
-      await this.client.session.abort({
-        path: { id: task.sessionId }
-      });
-    } catch {}
-    this.concurrencyManager.release(task.agent);
-    this.poller.cleanupTask(taskId);
-    return this.updateStatus(taskId, "cancelled");
-  }
-  async cancelAll(parentSessionId) {
-    const tasks = this.store.list({
-      parentSessionId,
-      status: ["spawned", "pending", "running"]
-    });
-    const results = [];
-    for (const task of tasks) {
-      try {
-        const cancelled = await this.cancel(task.taskId);
-        results.push(cancelled);
-      } catch {}
-    }
-    return results;
-  }
-  list(filter) {
-    return this.store.list(filter);
-  }
-  getActive() {
-    return this.store.getActive();
-  }
-  handleSessionIdle(sessionId) {
-    const tasks = this.store.list();
-    const task = tasks.find((t) => t.sessionId === sessionId);
-    if (task && task.status === "running") {
-      this.concurrencyManager.release(task.agent);
-      this.poller.cleanupTask(task.taskId);
-      this.updateStatus(task.taskId, "completed");
-    }
-  }
-  handleMessageEvent(sessionId, messageText) {
-    const tasks = this.store.list();
-    const task = tasks.find((t) => t.sessionId === sessionId);
-    if (task && task.status === "running") {
-      this.store.updateProgress(task.taskId, {
-        lastMessage: messageText?.slice(0, 200),
-        lastMessageAt: new Date().toISOString(),
-        messageCount: (task.progress?.messageCount ?? 0) + 1
-      });
-    }
-  }
-  getAgentGate() {
-    return this.agentGate;
-  }
-  getConcurrencyManager() {
-    return this.concurrencyManager;
-  }
-  getPoller() {
-    return this.poller;
-  }
-  getObservations() {
-    return this.poller.getObservations();
-  }
-  getTaskObservation(taskId) {
-    return this.poller.getTaskObservation(taskId);
-  }
-  getCounts() {
-    return this.store.countByStatus();
-  }
-  shutdown() {
-    this.poller.stop();
-    this.concurrencyManager.clear();
-  }
-}
-function createBackgroundManager(options) {
-  return new BackgroundManager(options);
-}
-// src/utils/format.ts
-function formatElapsed(ms) {
-  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-  if (totalSeconds < 60) {
-    return `${totalSeconds}s`;
-  }
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (totalMinutes < 60) {
-    return `${totalMinutes}m ${seconds}s`;
-  }
-  const hours = Math.floor(totalMinutes / 60);
-  const minutes = totalMinutes % 60;
-  return `${hours}h ${minutes}m`;
-}
-function formatRelativeTime(isoDate) {
-  const timestamp = new Date(isoDate).getTime();
-  const now = Date.now();
-  const elapsedMs = Math.max(0, now - timestamp);
-  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
-  if (totalSeconds < 60) {
-    return `${totalSeconds}s ago`;
-  }
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  if (totalMinutes < 60) {
-    return `${totalMinutes}m ago`;
-  }
-  const totalHours = Math.floor(totalMinutes / 60);
-  return `${totalHours}h ago`;
-}
-
-// src/hooks/variant-hook.ts
-var HIVE_AGENT_NAMES = [
-  "hive-master",
-  "architect-planner",
-  "swarm-orchestrator",
-  "scout-researcher",
-  "forager-worker",
-  "hygienic-reviewer"
-];
-function isHiveAgent(agent) {
-  return agent !== undefined && HIVE_AGENT_NAMES.includes(agent);
-}
-function normalizeVariant(variant) {
-  if (variant === undefined)
-    return;
-  const trimmed2 = variant.trim();
-  return trimmed2.length > 0 ? trimmed2 : undefined;
-}
-
-// src/tools/background-tools.ts
-function createBackgroundTools(manager, client, configService) {
-  async function maybeFinalizeIfIdle(sessionId) {
-    try {
-      const statusFn = client.session.status;
-      if (statusFn) {
-        const statusResult = await statusFn();
-        const entry = statusResult.data?.[sessionId];
-        const type = entry?.type;
-        if (type === "idle" || type === "completed") {
-          manager.handleSessionIdle(sessionId);
-          return;
-        }
-      }
-    } catch {}
-    try {
-      const sessionResult = await client.session.get({ path: { id: sessionId } });
-      const data = sessionResult.data;
-      const status = data?.status ?? data?.type;
-      if (status === "idle" || status === "completed") {
-        manager.handleSessionIdle(sessionId);
-      }
-    } catch {}
-  }
-  return {
-    hive_background_task: tool({
-      description: "Spawn a background agent task. Use sync=true to wait for completion (returns output). If sync=false (default), the parent session receives a completion <system-reminder> and you can call hive_background_output to fetch the result.",
-      args: {
-        agent: tool.schema.string().describe('Agent to use (e.g., "forager-worker", "scout-researcher")'),
-        prompt: tool.schema.string().optional().describe("Task instructions/prompt (required if promptFile not provided)"),
-        promptFile: tool.schema.string().optional().describe("Path to file containing prompt (alternative to inline prompt)"),
-        description: tool.schema.string().describe("Human-readable task description"),
-        sync: tool.schema.boolean().optional().describe("Wait for completion (default: false)"),
-        idempotencyKey: tool.schema.string().optional().describe("Key for safe retries"),
-        workdir: tool.schema.string().optional().describe("Working directory for task"),
-        feature: tool.schema.string().optional().describe("Hive feature name (for Hive-linked tasks)"),
-        task: tool.schema.string().optional().describe("Hive task folder (for Hive-linked tasks)"),
-        attempt: tool.schema.number().optional().describe("Hive attempt number (for Hive-linked tasks)")
-      },
-      async execute({
-        agent,
-        prompt,
-        promptFile,
-        description,
-        sync = false,
-        idempotencyKey,
-        workdir,
-        feature,
-        task: hiveTask,
-        attempt
-      }, toolContext) {
-        const ctx = toolContext;
-        const ALLOWED_CALLERS = new Set([
-          "hive-master",
-          "architect-planner",
-          "swarm-orchestrator"
-        ]);
-        const callerAgent = ctx?.agent;
-        if (!callerAgent || !ALLOWED_CALLERS.has(callerAgent)) {
-          const output = {
-            provider: "hive",
-            task_id: "",
-            session_id: "",
-            status: "error",
-            error: `Agent "${callerAgent ?? "unknown"}" is not allowed to spawn background tasks. Only orchestrator agents (${[...ALLOWED_CALLERS].join(", ")}) can delegate.`
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        let resolvedPrompt = prompt;
-        if (promptFile) {
-          const baseDir = workdir || process.cwd();
-          const workspaceRoot = findWorkspaceRoot(baseDir) ?? baseDir;
-          const fileResult = await resolvePromptFromFile(promptFile, workspaceRoot);
-          if (fileResult.error) {
-            const output = {
-              provider: "hive",
-              task_id: "",
-              session_id: "",
-              status: "error",
-              error: `Failed to read prompt file: ${fileResult.error}`
-            };
-            return JSON.stringify(output, null, 2);
-          }
-          resolvedPrompt = fileResult.content;
-        }
-        if (!resolvedPrompt) {
-          const output = {
-            provider: "hive",
-            task_id: "",
-            session_id: "",
-            status: "error",
-            error: "Either prompt or promptFile is required"
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        let variant;
-        if (configService && isHiveAgent(agent)) {
-          const agentConfig = configService.getAgentConfig(agent);
-          variant = normalizeVariant(agentConfig.variant);
-        }
-        const result = await manager.spawn({
-          agent,
-          prompt: resolvedPrompt,
-          description,
-          idempotencyKey,
-          workdir,
-          parentSessionId: ctx?.sessionID,
-          parentMessageId: ctx?.messageID,
-          parentAgent: ctx?.agent,
-          notifyParent: !sync,
-          hiveFeature: feature,
-          hiveTaskFolder: hiveTask,
-          sync,
-          attempt,
-          variant
-        });
-        if (result.error) {
-          const output = {
-            provider: "hive",
-            task_id: "",
-            session_id: "",
-            status: "error",
-            error: result.error
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        const taskRecord = result.task;
-        if (!sync) {
-          const output = {
-            provider: "hive",
-            task_id: taskRecord.taskId,
-            session_id: taskRecord.sessionId,
-            status: taskRecord.status
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        const pollInterval = 1000;
-        const maxWait = 30 * 60 * 1000;
-        const startTime = Date.now();
-        while (true) {
-          let current = manager.getTask(taskRecord.taskId);
-          if (!current) {
-            return JSON.stringify({
-              provider: "hive",
-              task_id: taskRecord.taskId,
-              session_id: taskRecord.sessionId,
-              status: "error",
-              error: "Task disappeared from store"
-            }, null, 2);
-          }
-          if (!isTerminalStatus(current.status)) {
-            await maybeFinalizeIfIdle(current.sessionId);
-            current = manager.getTask(taskRecord.taskId);
-          }
-          if (current && isTerminalStatus(current.status)) {
-            const outputText = await getTaskOutput(client, current.sessionId);
-            const output = {
-              provider: "hive",
-              task_id: current.taskId,
-              session_id: current.sessionId,
-              status: current.status,
-              output: outputText,
-              done: true
-            };
-            if (current.errorMessage) {
-              output.error = current.errorMessage;
-            }
-            return JSON.stringify(output, null, 2);
-          }
-          if (Date.now() - startTime > maxWait) {
-            return JSON.stringify({
-              provider: "hive",
-              task_id: current?.taskId ?? taskRecord.taskId,
-              session_id: current?.sessionId ?? taskRecord.sessionId,
-              status: current?.status ?? "unknown",
-              error: "Sync wait timed out after 30 minutes",
-              done: false
-            }, null, 2);
-          }
-          await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-        }
-      }
-    }),
-    hive_background_output: tool({
-      description: "Get output from a background task. For sync=false tasks, wait for the completion <system-reminder> and then call with block=false to fetch the result; use block=true only when you need interim output. When blocking, pick a timeout based on task complexity (typically 30-120s).",
-      args: {
-        task_id: tool.schema.string().describe("Task ID to get output from"),
-        block: tool.schema.boolean().optional().describe("Block waiting for new output (default: false)"),
-        timeout: tool.schema.number().optional().describe("Timeout in ms when blocking (default: 60000)"),
-        cursor: tool.schema.string().optional().describe("Cursor for incremental output (message count)")
-      },
-      async execute({ task_id, block = false, timeout = 60000, cursor }) {
-        const task = manager.getTask(task_id);
-        if (!task) {
-          return JSON.stringify({
-            error: `Task "${task_id}" not found`,
-            task_id
-          }, null, 2);
-        }
-        const cursorCount = cursor ? parseInt(cursor, 10) : 0;
-        if (block && !isTerminalStatus(task.status)) {
-          const startTime = Date.now();
-          const pollInterval = 1000;
-          while (Date.now() - startTime < timeout) {
-            const current2 = manager.getTask(task_id);
-            if (!current2)
-              break;
-            const currentCount = current2.progress?.messageCount ?? 0;
-            if (currentCount > cursorCount || isTerminalStatus(current2.status)) {
-              break;
-            }
-            await maybeFinalizeIfIdle(current2.sessionId);
-            const afterFinalize = manager.getTask(task_id);
-            if (afterFinalize && isTerminalStatus(afterFinalize.status)) {
-              break;
-            }
-            await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-          }
-        }
-        const current = manager.getTask(task_id);
-        if (!current) {
-          return JSON.stringify({
-            error: `Task "${task_id}" disappeared`,
-            task_id
-          }, null, 2);
-        }
-        if (!isTerminalStatus(current.status)) {
-          await maybeFinalizeIfIdle(current.sessionId);
-        }
-        const finalized = manager.getTask(task_id);
-        if (!finalized) {
-          return JSON.stringify({
-            error: `Task "${task_id}" disappeared`,
-            task_id
-          }, null, 2);
-        }
-        const output = await getTaskOutput(client, finalized.sessionId, cursorCount);
-        const messageCount = finalized.progress?.messageCount ?? 0;
-        const observationSnapshot = manager.getTaskObservation(task_id);
-        const lastActivityAt = observationSnapshot?.lastActivityAt ?? null;
-        const startedAt = finalized.startedAt ? new Date(finalized.startedAt).getTime() : Date.now();
-        const elapsedMs = Date.now() - startedAt;
-        const lastMessage = finalized.progress?.lastMessage;
-        const lastMessagePreview = lastMessage ? `${lastMessage.slice(0, 200)}${lastMessage.length > 200 ? "..." : ""}` : null;
-        const observation = {
-          elapsedMs,
-          elapsedFormatted: formatElapsed(elapsedMs),
-          messageCount: observationSnapshot?.messageCount ?? 0,
-          lastActivityAgo: lastActivityAt ? formatRelativeTime(lastActivityAt) : "never",
-          lastActivityAt,
-          lastMessagePreview,
-          maybeStuck: observationSnapshot?.maybeStuck ?? false
-        };
-        return JSON.stringify({
-          task_id: finalized.taskId,
-          session_id: finalized.sessionId,
-          status: finalized.status,
-          done: isTerminalStatus(finalized.status),
-          output,
-          cursor: messageCount.toString(),
-          progress: finalized.progress,
-          observation
-        }, null, 2);
-      }
-    }),
-    hive_background_cancel: tool({
-      description: "Cancel running background task(s). Use all=true to cancel all tasks for current session.",
-      args: {
-        task_id: tool.schema.string().optional().describe("Specific task ID to cancel"),
-        idempotencyKey: tool.schema.string().optional().describe("Cancel task by idempotency key"),
-        all: tool.schema.boolean().optional().describe("Cancel all tasks for current session")
-      },
-      async execute({ task_id, idempotencyKey, all }, toolContext) {
-        const ctx = toolContext;
-        if (all) {
-          if (!ctx?.sessionID) {
-            return JSON.stringify({
-              error: "Cannot cancel all: no parent session context",
-              cancelled: 0
-            }, null, 2);
-          }
-          const cancelled2 = await manager.cancelAll(ctx.sessionID);
-          return JSON.stringify({
-            cancelled: cancelled2.length,
-            tasks: cancelled2.map((t) => ({
-              task_id: t.taskId,
-              status: t.status
-            }))
-          }, null, 2);
-        }
-        let task;
-        if (task_id) {
-          task = manager.getTask(task_id);
-        } else if (idempotencyKey) {
-          task = manager.getTaskByIdempotencyKey(idempotencyKey);
-        }
-        if (!task) {
-          return JSON.stringify({
-            error: task_id ? `Task "${task_id}" not found` : idempotencyKey ? `No task found with idempotency key "${idempotencyKey}"` : "Must provide task_id, idempotencyKey, or all=true"
-          }, null, 2);
-        }
-        if (isTerminalStatus(task.status)) {
-          return JSON.stringify({
-            task_id: task.taskId,
-            status: task.status,
-            message: `Task already in terminal status: ${task.status}`
-          }, null, 2);
-        }
-        const cancelled = await manager.cancel(task.taskId);
-        return JSON.stringify({
-          task_id: cancelled.taskId,
-          status: cancelled.status,
-          message: "Task cancelled successfully"
-        }, null, 2);
-      }
-    })
-  };
-}
-async function getTaskOutput(client, sessionId, afterCount = 0) {
-  try {
-    const messagesResult = await client.session.messages({
-      path: { id: sessionId }
-    });
-    const messages = messagesResult.data ?? [];
-    const newMessages = messages.slice(afterCount);
-    const outputParts = [];
-    for (const msg of newMessages) {
-      const message = msg;
-      if (!message.parts)
-        continue;
-      for (const part of message.parts) {
-        if (part.type === "text" && part.text) {
-          outputParts.push(part.text);
-        } else if (part.type === "tool-result" && part.result) {
-          const result = typeof part.result === "string" ? part.result : JSON.stringify(part.result);
-          if (result.length > 500) {
-            outputParts.push(`[Tool: ${part.name}] ${result.slice(0, 500)}...`);
-          } else {
-            outputParts.push(`[Tool: ${part.name}] ${result}`);
-          }
-        }
-      }
-    }
-    return outputParts.join(`
-
-`);
-  } catch (error45) {
-    return `[Error fetching output: ${error45 instanceof Error ? error45.message : "Unknown"}]`;
-  }
-}
-
-// src/index.ts
-function formatSkillsXml(skills) {
-  if (skills.length === 0)
-    return "";
-  const skillsXml = skills.map((skill) => {
-    return [
-      "  <skill>",
-      `    <name>${skill.name}</name>`,
-      `    <description>(hive - Skill) ${skill.description}</description>`,
-      "  </skill>"
-    ].join(`
-`);
-  }).join(`
-`);
-  return `
-
-<available_skills>
-${skillsXml}
-</available_skills>`;
-}
-async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot) {
-  const agentConfig = configService.getAgentConfig(agentName);
-  const autoLoadSkills = agentConfig.autoLoadSkills ?? [];
-  if (autoLoadSkills.length === 0) {
-    return "";
-  }
-  const homeDir = process.env.HOME || os.homedir();
-  const skillTemplates = [];
-  for (const skillId of autoLoadSkills) {
-    const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
-    if (builtinSkill) {
-      skillTemplates.push(builtinSkill.template);
-      continue;
-    }
-    const fileResult = await loadFileSkill(skillId, projectRoot, homeDir);
-    if (fileResult.found && fileResult.skill) {
-      skillTemplates.push(fileResult.skill.template);
-      continue;
-    }
-    console.warn(`[hive] Unknown skill id "${skillId}" for agent "${agentName}"`);
-  }
-  if (skillTemplates.length === 0) {
-    return "";
-  }
-  return `
-
-` + skillTemplates.join(`
-
-`);
-}
-function createHiveSkillTool(filteredSkills) {
-  const base = `Load a Hive skill to get detailed instructions for a specific workflow.
+function createHiveSkillTool(filteredSkills) {
+  const base = `Load a Hive skill to get detailed instructions for a specific workflow.
 
 Use this when a task matches an available skill's description. The descriptions below ("Use when...", "Use before...") are triggers; when one applies, you MUST load that skill before proceeding.`;
   const description = filteredSkills.length === 0 ? base + `
@@ -23676,16 +22226,15 @@ var HIVE_SYSTEM_PROMPT = `
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (19 total)
+### Tools (14 total)
 
 | Domain | Tools |
 |--------|-------|
-| Feature | hive_feature_create, hive_feature_list, hive_feature_complete |
+| Feature | hive_feature_create, hive_feature_complete |
 | Plan | hive_plan_write, hive_plan_read, hive_plan_approve |
 | Task | hive_tasks_sync, hive_task_create, hive_task_update |
-| Exec | hive_exec_start, hive_exec_complete, hive_exec_abort |
-| Worker | hive_worker_status |
-| Merge | hive_merge, hive_worktree_list |
+| Worktree | hive_worktree_create, hive_worktree_commit, hive_worktree_discard |
+| Merge | hive_merge |
 | Context | hive_context_write |
 | Status | hive_status |
 | Skill | hive_skill |
@@ -23697,42 +22246,40 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 3. User adds comments in VSCode → \`hive_plan_read\` to see them
 4. Revise plan → User approves
 5. \`hive_tasks_sync()\` - Generate tasks from plan
-6. \`hive_exec_start(task)\` → work in worktree → \`hive_exec_complete(task, summary)\`
+6. \`hive_worktree_create(task)\` → work in worktree → \`hive_worktree_commit(task, summary)\`
 7. \`hive_merge(task)\` - Merge task branch into main (when ready)
 
-**Important:** \`hive_exec_complete\` commits changes to task branch but does NOT merge.
+**Important:** \`hive_worktree_commit\` commits changes to task branch but does NOT merge.
 Use \`hive_merge\` to explicitly integrate changes. Worktrees persist until manually removed.
 
 ### Delegated Execution
 
-\`hive_exec_start\` creates worktree and spawns worker automatically:
+\`hive_worktree_create\` creates worktree and spawns worker automatically:
 
-1. \`hive_exec_start(task)\` → Creates worktree + spawns Forager (Worker/Coder) worker
-2. Worker executes → calls \`hive_exec_complete(status: "completed")\`
-3. Worker blocked → calls \`hive_exec_complete(status: "blocked", blocker: {...})\`
+1. \`hive_worktree_create(task)\` → Creates worktree + spawns Forager (Worker/Coder) worker
+2. Worker executes → calls \`hive_worktree_commit(status: "completed")\`
+3. Worker blocked → calls \`hive_worktree_commit(status: "blocked", blocker: {...})\`
 
 **Handling blocked workers:**
-1. Check blockers with \`hive_worker_status()\`
+1. Check blockers with \`hive_status()\`
 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)\`
+4. Resume with \`hive_worktree_create(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.
 
-**Observation Polling (Recommended):**
-- Prefer completion notifications over polling
-- Use \`hive_worker_status()\` for observation-based spot checks
-- Avoid tight loops with \`hive_background_output\`; if needed, wait 30-60s between checks
-- If you suspect notifications did not deliver, do a single \`hive_worker_status()\` check first
-- If you need final results, call \`hive_background_output({ task_id, block: false })\` after the completion notice
+**After task() Returns:**
+- task() is BLOCKING — when it returns, the worker is DONE
+- Call \`hive_status()\` immediately to check the new task state and find next runnable tasks
+- No notifications or polling needed — the result is already available
 
 **For research**, use MCP tools or parallel exploration:
 - \`grep_app_searchGitHub\` - Find code in OSS
 - \`context7_query-docs\` - Library documentation
 - \`websearch_web_search_exa\` - Web search via Exa
 - \`ast_grep_search\` - AST-based search
-- For exploratory fan-out, load \`hive_skill("parallel-exploration")\` and use \`hive_background_task(agent: "scout-researcher", sync: false, ...)\`
+- For exploratory fan-out, load \`hive_skill("parallel-exploration")\` and use multiple \`task()\` calls in the same message
 
 ### Planning Phase - Context Management REQUIRED
 
@@ -23743,7 +22290,6 @@ As you research and plan, CONTINUOUSLY save findings using \`hive_context_write\
 - Architecture decisions ("auth lives in /lib/auth")
 
 **Update existing context files** when new info emerges - dont create duplicates.
-Workers depend on context for background. Without it, they work blind.
 
 \`hive_tasks_sync\` parses \`### N. Task Name\` headers.
 
@@ -23770,13 +22316,6 @@ var plugin = async (ctx) => {
     baseDir: directory,
     hiveDir: path7.join(directory, ".hive")
   });
-  const backgroundManager = createBackgroundManager({
-    client,
-    projectRoot: directory
-  });
-  const delegateMode = configService.getDelegateMode();
-  const useHiveBackground = delegateMode === "hive";
-  const backgroundTools = createBackgroundTools(backgroundManager, client, configService);
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
   };
@@ -23801,10 +22340,10 @@ var plugin = async (ctx) => {
     }
   };
   const checkBlocked = (feature) => {
-    const fs11 = __require("fs");
+    const fs9 = __require("fs");
     const blockedPath = path7.join(directory, ".hive", "features", feature, "BLOCKED");
-    if (fs11.existsSync(blockedPath)) {
-      const reason = fs11.readFileSync(blockedPath, "utf-8").trim();
+    if (fs9.existsSync(blockedPath)) {
+      const reason = fs9.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
 
 ${reason || "(No reason provided)"}
@@ -23890,11 +22429,6 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
     mcp: builtinMcps,
     tool: {
       hive_skill: createHiveSkillTool(filteredSkills),
-      ...useHiveBackground && {
-        hive_background_task: backgroundTools.hive_background_task,
-        hive_background_output: backgroundTools.hive_background_output,
-        hive_background_cancel: backgroundTools.hive_background_cancel
-      },
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
         args: {
@@ -23939,22 +22473,6 @@ These prevent scope creep and re-proposing rejected solutions.
 NEXT: Ask your first clarifying question about this feature.`;
         }
       }),
-      hive_feature_list: tool({
-        description: "List all features",
-        args: {},
-        async execute() {
-          const features = featureService.list();
-          const active = resolveFeature();
-          if (features.length === 0)
-            return "No features found.";
-          const list = features.map((f) => {
-            const info = featureService.getInfo(f);
-            return `${f === active ? "* " : "  "}${f} (${info?.status || "unknown"})`;
-          });
-          return list.join(`
-`);
-        }
-      }),
       hive_feature_complete: tool({
         description: "Mark feature as completed (irreversible)",
         args: { name: tool.schema.string().optional().describe("Feature name (defaults to active)") },
@@ -23966,34 +22484,6 @@ NEXT: Ask your first clarifying question about this feature.`;
           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 = path7.join(directory, ".hive", "journal.md");
-          if (!fs9.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
-
----
-`;
-          fs9.appendFileSync(journalPath, entry);
-          return `Journal entry added for ${feature}. ${constraint ? `Constraint: "${constraint}"` : ""}`;
-        }
-      }),
       hive_plan_write: tool({
         description: "Write plan.md (clears existing comments)",
         args: {
@@ -24087,7 +22577,7 @@ Add this section to your plan content and try again.`;
             return "Error: No feature specified. Create a feature or provide feature param.";
           const folder = taskService.create(feature, name, order);
           return `Manual task created: ${folder}
-Reminder: start work with hive_exec_start to use its worktree, and ensure any subagents work in that worktree too.`;
+Reminder: start work with hive_worktree_create to use its worktree, and ensure any subagents work in that worktree too.`;
         }
       }),
       hive_task_update: tool({
@@ -24109,7 +22599,7 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
           return `Task "${task}" updated: status=${updated.status}`;
         }
       }),
-      hive_exec_start: tool({
+      hive_worktree_create: tool({
         description: "Create worktree and begin work on task. Spawns Forager worker automatically.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
@@ -24239,16 +22729,6 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
           const relativePromptPath = normalizePath(path7.relative(directory, workerPromptPath));
           const PREVIEW_MAX_LENGTH = 200;
           const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
-          const hiveBackgroundInstructions = `## Delegation Required
-
-Call the hive_background_task tool to spawn a Forager (Worker/Coder) worker.
-
-\`backgroundTaskCall\` contains the canonical tool arguments.
-
-- Add \`sync: true\` if you need the result in this session.
-- Otherwise omit \`sync\`. Wait for the completion notification (no polling required). After the <system-reminder> arrives, call \`hive_background_output({ task_id: "<id>", block: false })\` once to fetch the final result.
-
-Troubleshooting: if you see "Unknown parameter: workdir", your hive_background_task tool is not Hive's provider. Ensure agent-hive loads after other background_* tool providers, then re-run hive_exec_start.`;
           const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
           const taskToolInstructions = `## Delegation Required
 
@@ -24264,39 +22744,22 @@ task({
 
 Use the \`@path\` attachment syntax in the prompt to reference the file. Do not inline the file contents.
 
-Note: delegateMode is set to 'task' in agent_hive.json. To use Hive's background tools instead, set delegateMode to 'hive'.`;
-          const delegationInstructions = useHiveBackground ? hiveBackgroundInstructions : taskToolInstructions;
+`;
           const responseBase = {
             worktreePath: worktree.path,
             branch: worktree.branch,
             mode: "delegate",
-            delegateMode,
             agent,
             delegationRequired: true,
             workerPromptPath: relativePromptPath,
             workerPromptPreview,
-            ...!useHiveBackground && {
-              taskPromptMode: "opencode-at-file"
-            },
-            ...useHiveBackground && {
-              backgroundTaskCall: {
-                promptFile: workerPromptPath,
-                description: `Hive: ${task}`,
-                workdir: worktree.path,
-                idempotencyKey,
-                feature,
-                task,
-                attempt
-              }
+            taskPromptMode: "opencode-at-file",
+            taskToolCall: {
+              subagent_type: agent,
+              description: `Hive: ${task}`,
+              prompt: taskToolPrompt
             },
-            ...!useHiveBackground && {
-              taskToolCall: {
-                subagent_type: agent,
-                description: `Hive: ${task}`,
-                prompt: taskToolPrompt
-              }
-            },
-            instructions: delegationInstructions
+            instructions: taskToolInstructions
           };
           const jsonPayload = JSON.stringify(responseBase, null, 2);
           const payloadMeta = calculatePayloadMeta({
@@ -24330,7 +22793,7 @@ Note: delegateMode is set to 'task' in agent_hive.json. To use Hive's background
           }, null, 2);
         }
       }),
-      hive_exec_complete: tool({
+      hive_worktree_commit: tool({
         description: "Complete task: commit changes to branch, write report. Supports blocked/failed/partial status for worker communication.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
@@ -24383,7 +22846,7 @@ Re-run with updated summary showing verification results.`;
               summary,
               blocker,
               worktreePath: worktree2?.path,
-              message: 'Task blocked. Hive Master will ask user and resume with hive_exec_start(continueFrom: "blocked", decision: answer)'
+              message: 'Task blocked. Hive Master will ask user and resume with hive_worktree_create(continueFrom: "blocked", decision: answer)'
             }, null, 2);
           }
           const commitResult = await worktreeService.commitChanges(feature, task, `hive(${task}): ${summary.slice(0, 50)}`);
@@ -24425,7 +22888,7 @@ Re-run with updated summary showing verification results.`;
 Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "unknown"}.`;
         }
       }),
-      hive_exec_abort: tool({
+      hive_worktree_discard: tool({
         description: "Abort task: discard changes, reset status",
         args: {
           task: tool.schema.string().describe("Task folder name"),
@@ -24440,102 +22903,6 @@ Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "
           return `Task "${task}" aborted. Status reset to pending.`;
         }
       }),
-      hive_worker_status: tool({
-        description: "Check status of delegated workers. Shows running workers, blockers, and progress.",
-        args: {
-          task: tool.schema.string().optional().describe("Specific task to check, or omit for all"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task: specificTask, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          const STUCK_THRESHOLD = 10 * 60 * 1000;
-          const HEARTBEAT_STALE_THRESHOLD = 5 * 60 * 1000;
-          const now = Date.now();
-          const PREVIEW_MAX_LENGTH = 200;
-          const tasks = taskService.list(feature);
-          const inProgressTasks = tasks.filter((t) => (t.status === "in_progress" || t.status === "blocked") && (!specificTask || t.folder === specificTask));
-          if (inProgressTasks.length === 0) {
-            return specificTask ? `No active worker for task "${specificTask}"` : "No active workers.";
-          }
-          const workers = await Promise.all(inProgressTasks.map(async (t) => {
-            const worktree = await worktreeService.get(feature, t.folder);
-            const rawStatus = taskService.getRawStatus(feature, t.folder);
-            const workerSession = rawStatus?.workerSession;
-            const backgroundRecord = backgroundManager.getTaskByHiveTask(feature, t.folder);
-            const observation = backgroundRecord ? backgroundManager.getTaskObservation(backgroundRecord.taskId) : null;
-            let maybeStuck = false;
-            let lastActivityAt = null;
-            if (observation?.lastActivityAt) {
-              lastActivityAt = new Date(observation.lastActivityAt).getTime();
-            } else if (workerSession?.lastHeartbeatAt) {
-              lastActivityAt = new Date(workerSession.lastHeartbeatAt).getTime();
-              const heartbeatStale = now - lastActivityAt > HEARTBEAT_STALE_THRESHOLD;
-              const noRecentMessages = !workerSession.messageCount || workerSession.messageCount === 0;
-              maybeStuck = heartbeatStale && t.status === "in_progress";
-            } else if (rawStatus?.startedAt) {
-              lastActivityAt = new Date(rawStatus.startedAt).getTime();
-              maybeStuck = now - lastActivityAt > STUCK_THRESHOLD && t.status === "in_progress";
-            }
-            if (typeof observation?.maybeStuck === "boolean") {
-              maybeStuck = observation.maybeStuck;
-            }
-            const startedAtIso = backgroundRecord?.startedAt || rawStatus?.startedAt || null;
-            const startedAtMs = startedAtIso ? new Date(startedAtIso).getTime() : null;
-            const elapsedMs = startedAtMs ? Math.max(0, now - startedAtMs) : 0;
-            const lastActivityIso = observation?.lastActivityAt || workerSession?.lastHeartbeatAt || rawStatus?.startedAt || null;
-            const lastActivityAgo = lastActivityIso ? formatRelativeTime(lastActivityIso) : "never";
-            const messageCount = observation?.messageCount ?? backgroundRecord?.progress?.messageCount ?? workerSession?.messageCount ?? 0;
-            const lastMessagePreview = backgroundRecord?.progress?.lastMessage ? backgroundRecord.progress.lastMessage.slice(0, PREVIEW_MAX_LENGTH) : null;
-            return {
-              task: t.folder,
-              name: t.name,
-              status: t.status,
-              taskId: backgroundRecord?.taskId || workerSession?.taskId || null,
-              description: backgroundRecord?.description || null,
-              startedAt: startedAtIso,
-              workerSession: workerSession || null,
-              sessionId: workerSession?.sessionId || null,
-              agent: workerSession?.agent || "inline",
-              mode: workerSession?.mode || "inline",
-              attempt: workerSession?.attempt || 1,
-              messageCount: workerSession?.messageCount || 0,
-              lastHeartbeatAt: workerSession?.lastHeartbeatAt || null,
-              workerId: workerSession?.workerId || null,
-              worktreePath: worktree?.path || null,
-              branch: worktree?.branch || null,
-              maybeStuck,
-              activity: {
-                elapsedMs,
-                elapsedFormatted: formatElapsed(elapsedMs),
-                messageCount,
-                lastActivityAgo,
-                lastMessagePreview,
-                maybeStuck
-              },
-              blocker: rawStatus?.blocker || null,
-              summary: t.summary || null
-            };
-          }));
-          const stuckWorkers = workers.filter((worker) => worker.activity?.maybeStuck).length;
-          const 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. Use hive_background_output({ task_id }) to check output, or abort with hive_exec_abort." : "Workers in progress. Wait for the completion notification (no polling required). Use hive_worker_status for spot checks; use hive_background_output only if interim output is explicitly needed.";
-          const guidance = stuckWorkers > 0 ? `
-
-⚠️ ${stuckWorkers} worker(s) may be stuck (no activity for 10+ minutes). Consider cancelling or investigating.` : "";
-          return JSON.stringify({
-            feature,
-            delegateMode,
-            omoSlimEnabled: isOmoSlimEnabled(),
-            backgroundTaskProvider: useHiveBackground ? "hive" : "task",
-            workers,
-            summary: {
-              stuckWorkers
-            },
-            hint: hint + guidance
-          }, null, 2);
-        }
-      }),
       hive_merge: tool({
         description: "Merge completed task branch into current branch (explicit integration)",
         args: {
@@ -24551,7 +22918,7 @@ Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "
           if (!taskInfo)
             return `Error: Task "${task}" not found`;
           if (taskInfo.status !== "done")
-            return "Error: Task must be completed before merging. Use hive_exec_complete first.";
+            return "Error: Task must be completed before merging. Use hive_worktree_commit first.";
           const result = await worktreeService.merge(feature, task, strategy);
           if (!result.success) {
             if (result.conflicts && result.conflicts.length > 0) {
@@ -24568,27 +22935,6 @@ Commit: ${result.sha}
 Files changed: ${result.filesChanged?.length || 0}`;
         }
       }),
-      hive_worktree_list: tool({
-        description: "List all worktrees for current feature",
-        args: {
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          const worktrees = await worktreeService.list(feature);
-          if (worktrees.length === 0)
-            return "No worktrees found for this feature.";
-          const lines = ["| Task | Branch | Has Changes |", "|------|--------|-------------|"];
-          for (const wt of worktrees) {
-            const hasChanges = await worktreeService.hasUncommittedChanges(wt.feature, wt.step);
-            lines.push(`| ${wt.step} | ${wt.branch} | ${hasChanges ? "Yes" : "No"} |`);
-          }
-          return lines.join(`
-`);
-        }
-      }),
       hive_context_write: tool({
         description: "Write a context file for the feature. Context files store persistent notes, decisions, and reference material.",
         args: {
@@ -24630,16 +22976,22 @@ Files changed: ${result.filesChanged?.length || 0}`;
           const plan = planService.read(feature);
           const tasks = taskService.list(feature);
           const contextFiles = contextService.list(feature);
-          const tasksSummary = tasks.map((t) => {
+          const tasksSummary = await Promise.all(tasks.map(async (t) => {
             const rawStatus = taskService.getRawStatus(feature, t.folder);
+            const worktree = await worktreeService.get(feature, t.folder);
+            const hasChanges = worktree ? await worktreeService.hasUncommittedChanges(worktree.feature, worktree.step) : null;
             return {
               folder: t.folder,
               name: t.name,
               status: t.status,
               origin: t.origin || "plan",
-              dependsOn: rawStatus?.dependsOn ?? null
+              dependsOn: rawStatus?.dependsOn ?? null,
+              worktree: worktree ? {
+                branch: worktree.branch,
+                hasChanges
+              } : null
             };
-          });
+          }));
           const contextSummary = contextFiles.map((c) => ({
             name: c.name,
             chars: c.content.length,
@@ -24677,7 +23029,7 @@ Files changed: ${result.filesChanged?.length || 0}`;
               return `${runnableTasks.length} tasks are ready to start in parallel: ${runnableTasks.join(", ")}`;
             }
             if (runnableTasks.length === 1) {
-              return `Start next task with hive_exec_start: ${runnableTasks[0]}`;
+              return `Start next task with hive_worktree_create: ${runnableTasks[0]}`;
             }
             const pending = tasks2.find((t) => t.status === "pending");
             if (pending) {
@@ -24714,81 +23066,6 @@ Files changed: ${result.filesChanged?.length || 0}`;
             nextAction: getNextAction(planStatus, tasksSummary, runnable)
           });
         }
-      }),
-      hive_request_review: tool({
-        description: "Request human review of completed task. BLOCKS until human approves or requests changes. Call after completing work, before merging.",
-        args: {
-          task: tool.schema.string().describe("Task folder name"),
-          summary: tool.schema.string().describe("Summary of what you did for human to review"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task, summary, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified.";
-          const taskDir = path7.join(directory, ".hive", "features", feature, "tasks", task);
-          if (!fs9.existsSync(taskDir)) {
-            return `Error: Task '${task}' not found in feature '${feature}'`;
-          }
-          const reportPath = path7.join(taskDir, "report.md");
-          const existingReport = fs9.existsSync(reportPath) ? fs9.readFileSync(reportPath, "utf-8") : `# Task Report
-`;
-          const attemptCount = (existingReport.match(/## Attempt \d+/g) || []).length + 1;
-          const timestamp = new Date().toISOString();
-          const newContent = existingReport + `
-## Attempt ${attemptCount}
-
-**Requested**: ${timestamp}
-
-### Summary
-
-${summary}
-
-`;
-          fs9.writeFileSync(reportPath, newContent);
-          const pendingPath = path7.join(taskDir, "PENDING_REVIEW");
-          fs9.writeFileSync(pendingPath, JSON.stringify({
-            attempt: attemptCount,
-            requestedAt: timestamp,
-            summary: summary.substring(0, 200) + (summary.length > 200 ? "..." : "")
-          }, null, 2));
-          const pollInterval = 2000;
-          const maxWait = 30 * 60 * 1000;
-          const startTime = Date.now();
-          while (fs9.existsSync(pendingPath)) {
-            if (Date.now() - startTime > maxWait) {
-              return "Review timed out after 30 minutes. Human did not respond.";
-            }
-            await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-          }
-          const resultPath = path7.join(taskDir, "REVIEW_RESULT");
-          if (!fs9.existsSync(resultPath)) {
-            return "Review cancelled (PENDING_REVIEW removed but no REVIEW_RESULT).";
-          }
-          const result = fs9.readFileSync(resultPath, "utf-8").trim();
-          fs9.appendFileSync(reportPath, `### Review Result
-
-${result}
-
----
-
-`);
-          if (result.toUpperCase() === "APPROVED") {
-            return `✅ APPROVED
-
-Your work has been approved. You may now merge:
-
-  hive_merge(task="${task}")
-
-After merging, proceed to the next task.`;
-          } else {
-            return `\uD83D\uDD04 Changes Requested
-
-${result}
-
-Make the requested changes, then call hive_request_review again.`;
-          }
-        }
       })
     },
     command: {
@@ -24802,27 +23079,13 @@ Make the requested changes, then call hive_request_review again.`;
         }
       }
     },
-    event: async ({ event }) => {
-      if (event.type === "session.idle") {
-        const sessionId = event.properties.sessionID;
-        if (sessionId) {
-          backgroundManager.handleSessionIdle(sessionId);
-        }
-      }
-      if (event.type === "message.updated") {
-        const info = event.properties.info;
-        const sessionId = info?.sessionID;
-        if (sessionId) {
-          backgroundManager.handleMessageEvent(sessionId);
-        }
-      }
-    },
     config: async (opencodeConfig) => {
       configService.init();
       const hiveUserConfig = configService.getAgentConfig("hive-master");
       const hiveAutoLoadedSkills = await buildAutoLoadedSkillsContent("hive-master", configService, directory);
       const hiveConfig = {
         model: hiveUserConfig.model,
+        variant: hiveUserConfig.variant,
         temperature: hiveUserConfig.temperature ?? 0.5,
         description: "Hive (Hybrid) - Plans + orchestrates. Detects phase, loads skills on-demand.",
         prompt: QUEEN_BEE_PROMPT + hiveAutoLoadedSkills,
@@ -24830,16 +23093,14 @@ Make the requested changes, then call hive_request_review again.`;
           question: "allow",
           skill: "allow",
           todowrite: "allow",
-          todoread: "allow",
-          hive_background_task: "allow",
-          hive_background_output: "allow",
-          hive_background_cancel: "allow"
+          todoread: "allow"
         }
       };
       const architectUserConfig = configService.getAgentConfig("architect-planner");
       const architectAutoLoadedSkills = await buildAutoLoadedSkillsContent("architect-planner", configService, directory);
       const architectConfig = {
         model: architectUserConfig.model,
+        variant: architectUserConfig.variant,
         temperature: architectUserConfig.temperature ?? 0.7,
         description: "Architect (Planner) - Plans features, interviews, writes plans. NEVER executes.",
         prompt: ARCHITECT_BEE_PROMPT + architectAutoLoadedSkills,
@@ -24850,16 +23111,14 @@ Make the requested changes, then call hive_request_review again.`;
           skill: "allow",
           todowrite: "allow",
           todoread: "allow",
-          webfetch: "allow",
-          hive_background_task: "allow",
-          hive_background_output: "allow",
-          hive_background_cancel: "allow"
+          webfetch: "allow"
         }
       };
       const swarmUserConfig = configService.getAgentConfig("swarm-orchestrator");
       const swarmAutoLoadedSkills = await buildAutoLoadedSkillsContent("swarm-orchestrator", configService, directory);
       const swarmConfig = {
         model: swarmUserConfig.model,
+        variant: swarmUserConfig.variant,
         temperature: swarmUserConfig.temperature ?? 0.5,
         description: "Swarm (Orchestrator) - Orchestrates execution. Delegates, spawns workers, verifies, merges.",
         prompt: SWARM_BEE_PROMPT + swarmAutoLoadedSkills,
@@ -24867,25 +23126,20 @@ Make the requested changes, then call hive_request_review again.`;
           question: "allow",
           skill: "allow",
           todowrite: "allow",
-          todoread: "allow",
-          hive_background_task: "allow",
-          hive_background_output: "allow",
-          hive_background_cancel: "allow"
+          todoread: "allow"
         }
       };
       const scoutUserConfig = configService.getAgentConfig("scout-researcher");
       const scoutAutoLoadedSkills = await buildAutoLoadedSkillsContent("scout-researcher", configService, directory);
       const scoutConfig = {
         model: scoutUserConfig.model,
+        variant: scoutUserConfig.variant,
         temperature: scoutUserConfig.temperature ?? 0.5,
         mode: "subagent",
         description: "Scout (Explorer/Researcher/Retrieval) - Researches codebase + external docs/data.",
         prompt: SCOUT_BEE_PROMPT + scoutAutoLoadedSkills,
         permission: {
           edit: "deny",
-          hive_background_task: "deny",
-          hive_background_output: "deny",
-          hive_background_cancel: "deny",
           task: "deny",
           delegate: "deny",
           skill: "allow",
@@ -24896,14 +23150,12 @@ Make the requested changes, then call hive_request_review again.`;
       const foragerAutoLoadedSkills = await buildAutoLoadedSkillsContent("forager-worker", configService, directory);
       const foragerConfig = {
         model: foragerUserConfig.model,
+        variant: foragerUserConfig.variant,
         temperature: foragerUserConfig.temperature ?? 0.3,
         mode: "subagent",
         description: "Forager (Worker/Coder) - Executes tasks directly in isolated worktrees. Never delegates.",
         prompt: FORAGER_BEE_PROMPT + foragerAutoLoadedSkills,
         permission: {
-          hive_background_task: "deny",
-          hive_background_output: "deny",
-          hive_background_cancel: "deny",
           task: "deny",
           delegate: "deny",
           skill: "allow"
@@ -24913,15 +23165,13 @@ Make the requested changes, then call hive_request_review again.`;
       const hygienicAutoLoadedSkills = await buildAutoLoadedSkillsContent("hygienic-reviewer", configService, directory);
       const hygienicConfig = {
         model: hygienicUserConfig.model,
+        variant: hygienicUserConfig.variant,
         temperature: hygienicUserConfig.temperature ?? 0.3,
         mode: "subagent",
         description: "Hygienic (Consultant/Reviewer/Debugger) - Reviews plan documentation quality. OKAY/REJECT verdict.",
         prompt: HYGIENIC_BEE_PROMPT + hygienicAutoLoadedSkills,
         permission: {
           edit: "deny",
-          hive_background_task: "deny",
-          hive_background_output: "deny",
-          hive_background_cancel: "deny",
           task: "deny",
           delegate: "deny",
           skill: "allow"