opencode-hive 1.2.0 → 1.3.1

package/dist/index.js

@@ -1,12 +1,16 @@
 import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -12927,9 +12931,9 @@ Each agent gets:
 
 \`\`\`typescript
 // Using Hive tools for parallel execution
-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" })
+hive_worktree_start({ task: "01-fix-abort-tests" })
+hive_worktree_start({ task: "02-fix-batch-tests" })
+hive_worktree_start({ task: "03-fix-race-condition-tests" })
 // All three run concurrently in isolated worktrees
 \`\`\`
 
@@ -13429,7 +13433,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_worktree_create()\`
+1. Mark as in_progress via \`hive_worktree_start()\`
 2. Follow each step exactly (plan has bite-sized steps)
 3. Run verifications as specified
 4. Mark as completed
@@ -13497,7 +13501,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_worktree_create\`.
+**This skill is for read-only research.** For parallel implementation work, use \`hive_skill("dispatching-parallel-agents")\` with \`hive_worktree_start\`.
 
 ## When to Use
 
@@ -13508,7 +13512,7 @@ When you need to answer "where/how does X work?" across multiple domains (codeba
 - Questions are independent (answer to A doesn't affect B)
 - User asks **3+ independent questions** (often as a numbered list or separate bullets)
 - No edits needed (read-only exploration)
-- User asks for an explorationthat likely spans multiple files/packages
+- User asks for an exploration that likely spans multiple files/packages
 - The work is read-only and the questions can be investigated independently
 
 **Only skip this skill when:**
@@ -14823,7 +14827,6 @@ Run \`hive_status()\` to detect phase:
 ## Universal (Always Active)
 
 ### Intent Classification
-
 | Intent | Signals | Action |
 |--------|---------|--------|
 | Trivial | Single file, <10 lines | Do directly |
@@ -14831,22 +14834,34 @@ Run \`hive_status()\` to detect phase:
 | Complex | 3+ files, multi-step | Full discovery → plan/delegate |
 | Research | Internal codebase exploration OR external data | Delegate to Scout (Explorer/Researcher/Retrieval) |
 
-### Canonical Delegation Threshold
+Intent Verbalization — verbalize before acting:
+> "I detect [type] intent — [reason]. Approach: [route]."
+
+| Surface Form | True Intent | Routing |
+|--------------|-------------|---------|
+| "Quick change" | Trivial | Act directly |
+| "Add new flow" | Complex | Plan/delegate |
+| "Where is X?" | Research | Scout exploration |
+| "Should we…?" | Ambiguous | Ask a question |
 
+### 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 \`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 → \`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)
+- Implementation → \`hive_worktree_start({ task: "01-task-name" })\` (creates worktree + Forager)
 
 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
+**When NOT to delegate:**
+- Single-file, <10-line changes — do directly
+- Sequential operations where you need the result of step N for step N+1
+- Questions answerable with one grep + one file read
 
+### Context Persistence
 Save discoveries with \`hive_context_write\`:
 - Requirements and decisions
 - User preferences
@@ -14855,14 +14870,12 @@ Save discoveries with \`hive_context_write\`:
 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:
 - [ ] Objective clear?
 - [ ] Scope defined?
 - [ ] No critical ambiguities?
 
 ### Turn Termination
-
 Valid endings:
 - Ask a concrete question
 - Update draft + ask a concrete question
@@ -14875,58 +14888,46 @@ NEVER end with:
 - "When you're ready..."
 
 ### Loading Skills (On-Demand)
-
 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() (Scout fan-out)
-- \`hive_skill("executing-plans")\` - step-by-step plan execution
-- \`hive_skill("systematic-debugging")\` - encountering bugs, test failures, or unexpected behavior
-- \`hive_skill("test-driven-development")\` - implementing features with TDD approach
-- \`hive_skill("verification-before-completion")\` - before claiming work is complete or creating PRs
-- \`hive_skill("docker-mastery")\` - working with Docker containers, debugging, docker-compose
-- \`hive_skill("agents-md-mastery")\` - bootstrapping/updating AGENTS.md, quality review
-
-Load ONE skill at a time. Only when you need guidance beyond this prompt.
-
+| Skill | Use when |
+|-------|----------|
+| \`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() |
+| \`hive_skill("executing-plans")\` | Step-by-step plan execution |
+| \`hive_skill("systematic-debugging")\` | Bugs, test failures, unexpected behavior |
+| \`hive_skill("test-driven-development")\` | TDD approach |
+| \`hive_skill("verification-before-completion")\` | Before claiming work is complete or creating PRs |
+| \`hive_skill("docker-mastery")\` | Docker containers, debugging, compose |
+| \`hive_skill("agents-md-mastery")\` | AGENTS.md updates, quality review |
+
+Load one skill at a time, only when guidance is needed.
 ---
 
 ## Planning Phase
-
 *Active when: no approved plan exists*
 
 ### When to Load Skills
-
 - Exploring vague requirements → \`hive_skill("brainstorming")\`
 - Writing detailed plan → \`hive_skill("writing-plans")\`
 
-### AI-Slop Flags
-
-| Pattern | Ask |
-|---------|-----|
+### Planning Checks
+| Signal | Prompt |
+|--------|--------|
 | Scope inflation | "Should I include X?" |
 | 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.
+| Fragile assumption | "If this assumption is wrong, what changes?" |
 
 ### Gap Classification
-
 | Gap | Action |
 |-----|--------|
-| Critical | ASK immediately |
+| Critical | Ask immediately |
 | Minor | Fix silently, note in summary |
 | Ambiguous | Apply default, disclose |
 
 ### Plan Output
-
 \`\`\`
 hive_feature_create({ name: "feature-name" })
 hive_plan_write({ content: "..." })
@@ -14937,78 +14938,83 @@ Plan includes: Discovery (Original Request, Interview Summary, Research Findings
 - References must use file:line format
 - Verify must include exact command + expected output
 
-Each task MUST declare dependencies with **Depends on**:
+Each task declares dependencies with **Depends on**:
 - **Depends on**: none for no dependencies / parallel starts
 - **Depends on**: 1, 3 for explicit task-number dependencies
 
 ### After Plan Written
-
 Ask user via \`question()\`: "Plan complete. Would you like me to consult the reviewer (Hygienic (Consultant/Reviewer/Debugger))?"
 
-If yes → \`task({ subagent_type: "hygienic", prompt: "Review plan..." })\`
+If yes → default to built-in \`hygienic-reviewer\`; choose a configured hygienic-derived reviewer only when its description in \`Configured Custom Subagents\` is a better match. Then run \`task({ subagent_type: "<chosen-reviewer>", prompt: "Review plan..." })\`.
 
 After review decision, offer execution choice (subagent-driven vs parallel session) consistent with writing-plans.
 
 ### Planning Iron Laws
-
-- Research BEFORE asking (use \`hive_skill("parallel-exploration")\` for multi-domain research)
+- 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 task()).
+- Keep planning read-only (local tools + Scout via task())
+Read-only exploration is allowed.
+Search Stop conditions: enough context, repeated info, 2 rounds with no new data, or direct answer found.
 
 ---
 
 ## Orchestration Phase
-
 *Active when: plan approved, tasks exist*
 
 ### Task Dependencies (Always Check)
-
 Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **blockedBy** info.
 - Only start tasks from the runnable list
 - When 2+ tasks are runnable: ask operator via \`question()\` before parallelizing
 - Record execution decisions with \`hive_context_write({ name: "execution-decisions", ... })\`
 
 ### When to Load Skills
-
 - Multiple independent tasks → \`hive_skill("dispatching-parallel-agents")\`
 - Executing step-by-step → \`hive_skill("executing-plans")\`
 
 ### Delegation Check
-
 1. Is there a specialized agent?
 2. Does this need external data? → Scout
-3. Default: DELEGATE (don't do yourself)
+3. Default: delegate (don't do yourself)
 
 ### Worker Spawning
-
 \`\`\`
-hive_worktree_create({ task: "01-task-name" })  // Creates worktree + Forager
+hive_worktree_start({ task: "01-task-name" })  // Creates worktree + Forager
 \`\`\`
 
 ### After Delegation
-
-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
-
-3 failures on same task → revert → ask user
+1. \`task()\` is blocking — when it returns, the worker is done
+2. After \`task()\` returns, immediately call \`hive_status()\` to check the new task state and find next runnable tasks before any resume attempt
+3. Use \`continueFrom: "blocked"\` only when status is exactly \`blocked\`
+4. If status is not \`blocked\`, do not use \`continueFrom: "blocked"\`; use \`hive_worktree_start({ feature, task })\` only for normal starts (\`pending\` / \`in_progress\`)
+5. Never loop \`continueFrom: "blocked"\` on non-blocked statuses
+6. If task status is blocked: read blocker info → \`question()\` → user decision → resume with \`continueFrom: "blocked"\`
+7. Skip polling — the result is available when \`task()\` returns
+
+### Batch Merge + Verify Workflow
+When multiple tasks are in flight, prefer **batch completion** over per-task verification:
+1. Dispatch a batch of runnable tasks (ask user before parallelizing).
+2. Wait for all workers to finish.
+3. Merge each completed task branch into the current branch.
+4. Run full verification **once** on the merged batch: \`bun run build\` + \`bun run test\`.
+5. If verification fails, diagnose with full context. Fix directly or re-dispatch targeted tasks as needed.
+
+### Failure Recovery (After 3 Consecutive Failures)
+1. Stop all further edits
+2. Revert to last known working state
+3. Document what was attempted
+4. Ask user via question() — present options and context
 
 ### Merge Strategy
-
-\`hive_merge({ task: "01-task-name" })\` after verification
+\`hive_merge({ task: "01-task-name" })\` for each task after the batch completes, then verify the batch
 
 ### 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.
+2. If yes → default to built-in \`hygienic-reviewer\`; choose a configured hygienic-derived reviewer only when its description in \`Configured Custom Subagents\` is a better match.
+3. Then run \`task({ subagent_type: "<chosen-reviewer>", prompt: "Review implementation changes from the latest batch." })\`.
+4. Apply feedback before starting the next batch.
 
 ### AGENTS.md Maintenance
-
 After feature completion (all tasks merged):
 1. Sync context findings to AGENTS.md: \`hive_agents_md({ action: "sync", feature: "feature-name" })\`
 2. Review the proposed diff with the user
@@ -15019,36 +15025,36 @@ For projects without AGENTS.md:
 - Generates initial documentation from codebase analysis
 
 ### Orchestration Iron Laws
-
 - Delegate by default
 - Verify all work completes
-- Use \`question()\` for user input (NEVER plain text)
+- Use \`question()\` for user input (never plain text)
 
 ---
 
 ## Iron Laws (Both Phases)
-
 **Always:**
-- Detect phase FIRST via hive_status
-- Follow ONLY the active phase section
+- Detect phase first via hive_status
+- Follow the active phase section
 - Delegate research to Scout, implementation to Forager
 - Ask user before consulting Hygienic (Consultant/Reviewer/Debugger)
 - Load skills on-demand, one at a time
 
+Investigate before acting: read referenced files before making claims about them.
+
 ### Hard Blocks
 
-NEVER violate:
+Do not violate:
 - Skip phase detection
 - Mix planning and orchestration in same action
 - Auto-load all skills at start
 
 ### Anti-Patterns
 
-BLOCKING violations:
+Blocking violations:
 - Ending a turn without a next action
 - Asking for user input in plain text instead of question()
 
-**User Input:** ALWAYS use \`question()\` tool for any user input - NEVER ask questions via plain text. This ensures structured responses.
+**User Input:** Use \`question()\` tool for any user input — structured prompts get structured responses. Plain text questions are easily missed or misinterpreted.
 `;
 
 // src/agents/architect.ts
@@ -15189,28 +15195,18 @@ Delegate by default. Work yourself only when trivial.
 | Open-ended | "Improve", "Refactor" | Assess first, then delegate |
 | Ambiguous | Unclear scope | Ask ONE clarifying question |
 
-## Delegation Check (Before Acting)
+Intent Verbalization: "I detect [type] intent — [reason]. Routing to [action]."
 
-### Task Dependencies (Always Check)
-
-Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **blockedBy** info.
-- Only start tasks from the runnable list
-- 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\`.
+## Delegation Check (Before Acting)
 
-If tasks are missing **Depends on** metadata, ask the planner to revise the plan before executing.
+Use \`hive_status()\` to see runnable tasks and blockedBy info. Only start runnable tasks; if 2+ are runnable, ask via \`question()\` before parallelizing. Record execution decisions with \`hive_context_write({ name: "execution-decisions", ... })\`. If tasks lack **Depends on** metadata, ask the planner to revise. If Scout returns substantial findings (3+ files, architecture patterns, or key decisions), persist them via \`hive_context_write\`.
 
-### Standard Checks
+Standard checks: specialized agent? can I do it myself for sure? 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. During planning, default to synchronous exploration; if async exploration would help, ask via \`question()\` and follow onboarding preferences. Default: delegate. Research tools (grep_app, context7, websearch, ast_grep) — delegate to Scout, not direct use.
 
-1. Is there a specialized agent that matches?
-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.
-During Planning, default to synchronous exploration. If async exploration would help, ask the user via \`question()\` and follow the onboarding preferences.
-→ Default: DELEGATE
+**When NOT to delegate:**
+- Single-file, <10-line changes — do directly
+- Sequential operations where you need the result of step N for step N+1
+- Questions answerable with one grep + one file read
 
 ## Delegation Prompt Structure (All 6 Sections)
 
@@ -15218,46 +15214,61 @@ During Planning, default to synchronous exploration. If async exploration would
 1. TASK: Atomic, specific goal
 2. EXPECTED OUTCOME: Concrete deliverables
 3. REQUIRED TOOLS: Explicit tool whitelist
-4. MUST DO: Exhaustive requirements
-5. MUST NOT DO: Forbidden actions
+4. REQUIRED: Exhaustive requirements
+5. FORBIDDEN: Forbidden actions
 6. CONTEXT: File paths, patterns, constraints
 \`\`\`
 
 ## Worker Spawning
 
 \`\`\`
-hive_worktree_create({ task: "01-task-name" })
+hive_worktree_start({ 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.
 \`\`\`
 
-**Delegation Guidance:**
+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
+- After \`task()\` returns, call \`hive_status()\` immediately to check new state and find next runnable tasks before any resume attempt
+- Use \`continueFrom: "blocked"\` only when status is exactly \`blocked\`
+- If status is not \`blocked\`, do not use \`continueFrom: "blocked"\`; use \`hive_worktree_start({ feature, task })\` only for normal starts (\`pending\` / \`in_progress\`)
+- Never loop \`continueFrom: "blocked"\` on non-blocked statuses
 - For parallel fan-out, issue multiple \`task()\` calls in the same message
 
 ## After Delegation - VERIFY
 
-After every delegation, check:
-- Does it work as expected?
-- Followed existing codebase patterns?
-- Met MUST DO and MUST NOT DO requirements?
-- No unintended side effects?
+Your confidence ≈ 50% accurate. Always:
+- Read changed files (don’t trust self-reports)
+- Run lsp_diagnostics on modified files
+- Check acceptance criteria from spec
+
+Then confirm:
+- Works as expected
+- Follows codebase patterns
+- Meets requirements
+- No unintended side effects
+
+After completing and merging a batch, run full verification on the main branch: \`bun run build\`, \`bun run test\`. If failures occur, diagnose and fix or re-dispatch impacted tasks.
+
+## Search Stop Conditions
+
+- Stop when there is enough context
+- Stop when info repeats
+- Stop after 2 rounds with no new data
+- Stop when a direct answer is found
+- If still unclear, delegate or ask one focused question
 
 ## Blocker Handling
 
-When worker reports blocked:
-1. \`hive_status()\` — read blocker info
-2. \`question()\` — ask user (NEVER plain text)
-3. \`hive_worktree_create({ task, continueFrom: "blocked", decision })\`
+When worker reports blocked: \`hive_status()\` → confirm status is exactly \`blocked\` → read blocker info; \`question()\` → ask user (no plain text); \`hive_worktree_create({ task, continueFrom: "blocked", decision })\`. If status is not \`blocked\`, do not use blocked resume; only use \`hive_worktree_start({ feature, task })\` for normal starts (\`pending\` / \`in_progress\`).
 
 ## Failure Recovery (After 3 Consecutive Failures)
 
-1. STOP all further edits
-2. REVERT to last known working state
-3. DOCUMENT what was attempted
-4. ASK USER via question() — present options and context
+1. Stop all further edits
+2. Revert to last known working state
+3. Document what was attempted
+4. Ask user via question() — present options and context
 
 ## Merge Strategy
 
@@ -15265,21 +15276,17 @@ When worker reports blocked:
 hive_merge({ task: "01-task-name", strategy: "merge" })
 \`\`\`
 
-Merge only after verification passes.
+Merge after batch completes, then verify the merged result.
 
 ### 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.
+After completing and merging a batch: ask via \`question()\` if they want a Hygienic review.
+If yes, default to built-in \`hygienic-reviewer\`; choose a configured hygienic-derived reviewer only when its description in \`Configured Custom Subagents\` is a better match.
+Then run \`task({ subagent_type: "<chosen-reviewer>", prompt: "Review implementation changes from the latest batch." })\` and apply feedback before the next batch.
 
 ### AGENTS.md Maintenance
 
-After completing and merging a batch:
-1. Sync context findings to AGENTS.md: \`hive_agents_md({ action: "sync", feature: "feature-name" })\`
-2. Review the proposed diff with the user
-3. Apply approved changes to keep AGENTS.md current
+After feature completion (all tasks merged): sync context findings to AGENTS.md via \`hive_agents_md({ action: "sync", feature: "feature-name" })\`, review the diff with the user, then apply approved changes.
 
 For quality review of AGENTS.md content, load \`hive_skill("agents-md-mastery")\`.
 
@@ -15289,39 +15296,21 @@ For projects without AGENTS.md:
 
 ## Turn Termination
 
-Valid endings:
-- Worker delegation (hive_worktree_create)
-- Status check (hive_status)
-- User question (question())
-- Merge (hive_merge)
-
-NEVER end with:
-- "Let me know when you're ready"
-- Summary without next action
-- Waiting for something unspecified
-
-## Iron Laws
+Valid endings: worker delegation (hive_worktree_start/hive_worktree_create), status check (hive_status), user question (question()), merge (hive_merge).
+Avoid ending with: "Let me know when you're ready", "When you're ready...", summary without next action, or waiting for something unspecified.
 
-**Never:**
-- Work alone when specialists available
-- Skip delegation check
-- Skip verification after delegation
-- Continue after 3 failures without consulting
+## Guardrails
 
-**Always:**
-- Classify intent FIRST
-- Delegate by default
-- Verify delegate work
-- Use question() for user input (NEVER plain text)
-- Cancel background tasks only when stale or no longer needed
-
-**User Input:** ALWAYS use \`question()\` tool for any user input - NEVER ask questions via plain text. This ensures structured responses.
+Avoid: working alone when specialists are available; skipping delegation checks; skipping verification after delegation; continuing after 3 failures without consulting.
+Do: classify intent first; delegate by default; verify delegated work; use \`question()\` for user input (no plain text); cancel background tasks only when stale or no longer needed.
+Cancel background tasks only when stale or no longer needed.
+User input: use \`question()\` tool for any user input to ensure structured responses.
 `;
 
 // src/agents/scout.ts
 var SCOUT_BEE_PROMPT = `# Scout (Explorer/Researcher/Retrieval)
 
-Research BEFORE answering. Parallel execution by default.
+Research before answering; parallelize tool calls when investigating multiple independent questions.
 
 ## Request Classification
 
@@ -15344,18 +15333,13 @@ Success Looks Like: [concrete outcome]
 </analysis>
 \`\`\`
 
-### Phase 2: Parallel Execution (Default)
+### Phase 2: Parallel Execution
 
-ALWAYS run 3+ tools simultaneously:
+When investigating multiple independent questions, run related tools in parallel:
 \`\`\`
-// CORRECT: Parallel
 glob({ pattern: "**/*.ts" })
 grep({ pattern: "UserService" })
 context7_query-docs({ query: "..." })
-
-// WRONG: Sequential
-result1 = glob(...)
-result2 = grep(...)  // Wait for result1? NO!
 \`\`\`
 
 ### Phase 3: Structured Results
@@ -15374,12 +15358,29 @@ result2 = grep(...)  // Wait for result1? NO!
 </results>
 \`\`\`
 
+## Search Stop Conditions (After Research Protocol)
+
+Stop when any is true:
+- enough context to answer
+- repeated information across sources
+- two rounds with no new data
+- a direct answer is found
+
+## Evidence Check (Before Answering)
+
+- Every claim has a source (file:line, URL, snippet)
+- Avoid speculation; say "can't answer with available evidence" when needed
+
+## Investigate Before Answering
+
+- Read files before making claims about them
+
 ## Tool Strategy
 
 | Need | Tool |
 |------|------|
 | Type/Symbol info | LSP (goto_definition, find_references) |
-| Structural patterns | ast_grep_search |
+| Structural patterns | ast_grep_find_code |
 | Text patterns | grep |
 | File discovery | glob |
 | Git history | bash (git log, git blame) |
@@ -15389,19 +15390,11 @@ result2 = grep(...)  // Wait for result1? NO!
 
 ## External System Data (DB/API/3rd-party)
 
-When asked to retrieve raw data from external systems (MongoDB/Stripe/etc.):
-- Prefer targeted queries over broad dumps
-- Summarize findings; avoid flooding the orchestrator with raw records
+When asked to retrieve raw data from external systems:
+- Prefer targeted queries
+- Summarize findings; avoid raw dumps
 - Redact secrets and personal data
-- Provide minimal evidence and a concise summary
-- Note any access limitations or missing context
-
-## Documentation Discovery (External)
-
-1. \`websearch("library-name official documentation")\`
-2. Version check if specified
-3. Sitemap: \`webfetch(docs_url + "/sitemap.xml")\`
-4. Targeted fetch from sitemap
+- Note access limitations or missing context
 
 ## Evidence Format
 
@@ -15420,103 +15413,114 @@ When operating within a feature context:
   })
   \`\`\`
 
-## Iron Laws
+## Operating Rules
 
-**Never:**
-- Create, modify, or delete files (read-only)
-- Answer without research first
-- Execute tools sequentially when parallel possible
-- Skip intent analysis
-
-**Always:**
-- Classify request FIRST
-- Run 3+ tools in parallel
-- All paths MUST be absolute
+- Read-only behavior (no file changes)
+- Classify request first, then research
+- Use absolute paths for file references
 - Cite evidence for every claim
-- Use current year (2026) in web searches
+- Use the current year when reasoning about time-sensitive information
 `;
 
 // src/agents/forager.ts
 var FORAGER_BEE_PROMPT = `# Forager (Worker/Coder)
 
-Execute directly. NEVER delegate implementation. Work in isolation.
+You are an autonomous senior engineer. Once given direction, gather context, implement, and verify without waiting for prompts.
+
+Execute directly. Work in isolation. Do not delegate implementation.
 
-## Blocked Tools
+## Intent Extraction
 
-These tools are FORBIDDEN:
-- \`task\` — Orchestrator's job
-- \`hive_worktree_create\` — You ARE the spawned worker
-- \`hive_merge\` — Orchestrator's job
+| Spec says | True intent | Action |
+|---|---|---|
+| "Implement X" | Build + verify | Code → verify |
+| "Fix Y" | Root cause + minimal fix | Diagnose → fix → verify |
+| "Refactor Z" | Preserve behavior | Restructure → verify no regressions |
+| "Add tests" | Coverage | Write tests → verify |
+
+## Action Bias
+
+- Act directly: implement first, explain in commit summary. Complete all steps before reporting.
+- REQUIRED: keep going until done, make decisions, course-correct on failure
+
+Your tool access is scoped to your role. Use only the tools available to you.
 
 ## Allowed Research
 
 CAN use for quick lookups:
 - \`grep_app_searchGitHub\` — OSS patterns
 - \`context7_query-docs\` — Library docs
-- \`ast_grep_search\` — AST patterns
+- \`ast_grep_find_code_by_rule\` — AST patterns
+- \`ast_grep_scan-code\` — Code quality scan (best-effort verification)
+- \`ast_grep_find_code\` — Find code patterns (best-effort verification)
 - \`glob\`, \`grep\`, \`read\` — Codebase exploration
 
 ## Resolve Before Blocking
 
-Default to exploration, questions are LAST resort:
+Default to exploration, questions are LAST resort.
+Context inference: Before asking "what does X do?", READ X first.
+
+Apply in order before reporting as blocked:
 1. Read the referenced files and surrounding code
 2. Search for similar patterns in the codebase
-3. Try a reasonable approach based on conventions
-
-Only report as blocked when:
-- Multiple approaches failed (tried 3+)
-- Decision requires business logic you can't infer
-- External dependency is missing or broken
+3. Check docs via research tools
+4. Try a reasonable approach
+5. Last resort: report blocked
 
-Context inference: Before asking "what does X do?", READ X first.
+Investigate before acting. Do not speculate about code you have not read.
 
 ## Plan = READ ONLY
 
-CRITICAL: NEVER MODIFY THE PLAN FILE
-- May READ to understand task
-- MUST NOT edit, modify, or update plan
-- Only Orchestrator (Swarm) manages plan
+Do not modify the plan file.
+- Read to understand the task
+- Only the orchestrator manages plan updates
 
 ## Persistent Notes
 
-For substantial discoveries (architecture patterns, key decisions, gotchas that affect multiple tasks):
-Use \`hive_context_write({ name: "learnings", content: "..." })\` to persist for future workers.
+For substantial discoveries (architecture patterns, key decisions, gotchas that affect multiple tasks), use:
+\`hive_context_write({ name: "learnings", content: "..." })\`.
 
-## Execution Flow
+## Working Rules
 
-### 1. Understand Task
-Read spec for:
-- **What to do**
-- **References** (file:lines)
-- **Must NOT do** (guardrails)
-- **Acceptance criteria**
+- DRY/Search First: look for existing helpers before adding new code
+- Convention Following: check neighboring files and package.json, then follow existing patterns
+- Efficient Edits: read enough context before editing, batch logical edits
+- Tight Error Handling: avoid broad catches or silent defaults; propagate errors explicitly
+- Avoid Over-engineering: only implement what was asked for
+- Reversibility Preference: favor local, reversible actions; confirm before hard-to-reverse steps
+- Promise Discipline: do not commit to future work; if not done this turn, label it "Next steps"
+- No Comments: do not add comments unless the spec requests them
+- Concise Output: minimize output and avoid extra explanations unless asked
 
-### 2. Orient (Pre-flight Before Coding)
-Before writing code:
-- Confirm dependencies are satisfied and required context is present
-- Read the referenced files and surrounding code
-- Search for similar patterns in the codebase
-- Identify the exact files/sections to touch (from references)
-- Decide the first failing test you will write (TDD)
-- Identify the test command(s) and inputs you will run
-- Plan the minimum change to reach green
+## Execution Loop (max 3 iterations)
 
-### 3. Implement
-Follow spec exactly. Use references for patterns.
+EXPLORE → PLAN → EXECUTE → VERIFY → LOOP
 
-\`\`\`
-read(file, { offset: line, limit: 30 })  // Check references
-edit(file, { old: "...", new: "..." })   // Implement
-bash("npm test")                          // Verify
-\`\`\`
+- EXPLORE: read references, gather context, search for patterns
+- PLAN: decide the minimum change, files to touch, and verification commands
+- EXECUTE: edit using conventions, reuse helpers, batch changes
+- VERIFY: run best-effort checks (tests if available, ast_grep, lsp_diagnostics)
+- LOOP: if verification fails, diagnose and retry within the limit
 
-### 4. Verify
-Run acceptance criteria:
-- Tests pass
-- Build succeeds
-- lsp_diagnostics clean on changed files
+## Progress Updates
 
-### 5. Report
+Provide brief status at meaningful milestones.
+
+## Completion Checklist
+
+- All acceptance criteria met?
+- Best-effort verification done and recorded?
+- Re-read the spec — missed anything?
+- Said "I'll do X" — did you?
+- Plan closure: mark each intention as Done, Blocked, or Cancelled
+- Record exact commands and results
+
+## Failure Recovery
+
+If 3 different approaches fail: stop edits, revert local changes, document attempts, report blocked.
+If you have tried 3 approaches and still cannot finish safely, report as blocked.
+
+## Reporting
 
 **Success:**
 \`\`\`
@@ -15527,7 +15531,9 @@ hive_worktree_commit({
 })
 \`\`\`
 
-**CRITICAL: After hive_worktree_commit, STOP IMMEDIATELY.**
+Then inspect the tool response fields:
+- If \`ok=true\` and \`terminal=true\`: stop and hand off to orchestrator
+- If \`ok=false\` or \`terminal=false\`: DO NOT STOP. Follow \`nextAction\`, remediate, and retry \`hive_worktree_commit\`
 
 **Blocked (need user decision):**
 \`\`\`
@@ -15544,47 +15550,11 @@ hive_worktree_commit({
 })
 \`\`\`
 
-## Completion Checklist
-
-Before calling hive_worktree_commit:
-- All tests in scope are run and passing (Record exact commands and results)
-- Build succeeds if required (Record exact command and result)
-- lsp_diagnostics clean on changed files (Record exact command and result)
-- Changes match the spec and references
-- No extra scope creep or unrelated edits
-- Summary includes what changed, why, and verification status
-
-## Failure Recovery
-
-After 3 consecutive failures:
-1. STOP all further edits
-2. Document what was tried
-3. Report as blocked with options
-
-## Iron Laws
-
-### Docker Sandbox
-
-When sandbox mode is active, ALL bash commands automatically run inside a Docker container.
-- Your commands are transparently wrapped — you don't need to do anything special
-- File edits (Read, Write, Edit tools) still work on the host filesystem (worktree is mounted)
-- If a command must run on the host (e.g., git operations), report as blocked and ask the user
-- If a command fails with "docker: command not found", report as blocked — the host needs Docker installed
-- For deeper Docker expertise, load \`hive_skill("docker-mastery")\`
-
-**Never:**
-- Exceed task scope
-- Modify plan file
-- Use \`task\` or \`hive_worktree_create\`
-- Continue after hive_worktree_commit
-- Skip verification
+## Docker Sandbox
 
-**Always:**
-- Follow references for patterns
-- Run acceptance criteria
-- Report blockers with options
-- APPEND to notepads (never overwrite)
-- lsp_diagnostics before reporting done
+When sandbox mode is active, bash commands run inside Docker; file edits still apply to the host worktree.
+If a command must run on the host or Docker is missing, report blocked.
+For deeper Docker expertise, load \`hive_skill("docker-mastery")\`.
 `;
 
 // src/agents/hygienic.ts
@@ -15690,6 +15660,33 @@ Before verdict, mentally execute 2-3 tasks:
 - Focus on worker success, not perfection
 `;
 
+// src/agents/custom-agents.ts
+function buildCustomSubagents({
+  customAgents,
+  baseAgents,
+  autoLoadedSkills = {}
+}) {
+  const derived = {};
+  for (const [agentName, customConfig] of Object.entries(customAgents)) {
+    const baseAgent = baseAgents[customConfig.baseAgent];
+    if (!baseAgent) {
+      continue;
+    }
+    const autoLoadedSkillsContent = autoLoadedSkills[agentName] ?? "";
+    derived[agentName] = {
+      model: customConfig.model ?? baseAgent.model,
+      variant: customConfig.variant ?? baseAgent.variant,
+      temperature: customConfig.temperature ?? baseAgent.temperature,
+      mode: "subagent",
+      description: customConfig.description,
+      prompt: baseAgent.prompt + autoLoadedSkillsContent,
+      tools: baseAgent.tools,
+      permission: baseAgent.permission
+    };
+  }
+  return derived;
+}
+
 // src/mcp/websearch.ts
 var websearchMcp = {
   type: "remote",
@@ -15759,15 +15756,29 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached2 = cache.get(mod);
+    if (cached2)
+      return cached2;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp2(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
@@ -16577,6 +16588,28 @@ var require_dist2 = __commonJS((exports) => {
   exports.createDeferred = deferred;
   exports.default = deferred;
 });
+var BUILT_IN_AGENT_NAMES = [
+  "hive-master",
+  "architect-planner",
+  "swarm-orchestrator",
+  "scout-researcher",
+  "forager-worker",
+  "hygienic-reviewer"
+];
+var CUSTOM_AGENT_BASES = ["forager-worker", "hygienic-reviewer"];
+var CUSTOM_AGENT_RESERVED_NAMES = [
+  ...BUILT_IN_AGENT_NAMES,
+  "hive",
+  "architect",
+  "swarm",
+  "scout",
+  "forager",
+  "hygienic",
+  "receiver",
+  "build",
+  "plan",
+  "code"
+];
 var DEFAULT_AGENT_MODELS = {
   "hive-master": "github-copilot/claude-opus-4.5",
   "architect-planner": "github-copilot/gpt-5.2-codex",
@@ -16592,6 +16625,21 @@ var DEFAULT_HIVE_CONFIG = {
   disableMcps: [],
   agentMode: "unified",
   sandbox: "none",
+  customAgents: {
+    "forager-example-template": {
+      baseAgent: "forager-worker",
+      description: "Example template only: rename or delete this entry before use. Do not expect planners/orchestrators to select this placeholder agent as configured.",
+      model: "anthropic/claude-sonnet-4-20250514",
+      temperature: 0.2,
+      variant: "high",
+      autoLoadSkills: ["test-driven-development"]
+    },
+    "hygienic-example-template": {
+      baseAgent: "hygienic-reviewer",
+      description: "Example template only: rename or delete this entry before use. Do not expect planners/orchestrators to select this placeholder agent as configured.",
+      autoLoadSkills: ["code-reviewer"]
+    }
+  },
   agents: {
     "hive-master": {
       model: DEFAULT_AGENT_MODELS["hive-master"],
@@ -16742,12 +16790,14 @@ function isLockStale(lockPath, staleTTL) {
 function acquireLockSync(filePath, options = {}) {
   const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
   const lockPath = getLockPath(filePath);
+  const lockDir = path2.dirname(lockPath);
   const startTime = Date.now();
   const lockContent = JSON.stringify({
     pid: process.pid,
     timestamp: new Date().toISOString(),
     filePath
   });
+  ensureDir(lockDir);
   while (true) {
     try {
       const fd = fs2.openSync(lockPath, fs2.constants.O_CREAT | fs2.constants.O_EXCL | fs2.constants.O_WRONLY);
@@ -16760,15 +16810,18 @@ function acquireLockSync(filePath, options = {}) {
       };
     } catch (err) {
       const error45 = err;
-      if (error45.code !== "EEXIST") {
+      if (error45.code === "ENOENT") {
+        ensureDir(lockDir);
+      } else if (error45.code === "EEXIST") {
+        if (isLockStale(lockPath, opts.staleLockTTL)) {
+          try {
+            fs2.unlinkSync(lockPath);
+            continue;
+          } catch {}
+        }
+      } else {
         throw error45;
       }
-      if (isLockStale(lockPath, opts.staleLockTTL)) {
-        try {
-          fs2.unlinkSync(lockPath);
-          continue;
-        } catch {}
-      }
       if (Date.now() - startTime >= opts.timeout) {
         throw new Error(`Failed to acquire lock on ${filePath} after ${opts.timeout}ms. ` + `Lock file: ${lockPath}`);
       }
@@ -16793,14 +16846,6 @@ function writeAtomic(filePath, content) {
 function writeJsonAtomic(filePath, data) {
   writeAtomic(filePath, JSON.stringify(data, null, 2));
 }
-function writeJsonLockedSync(filePath, data, options = {}) {
-  const release = acquireLockSync(filePath, options);
-  try {
-    writeJsonAtomic(filePath, data);
-  } finally {
-    release();
-  }
-}
 function deepMerge(target, patch) {
   const result = { ...target };
   for (const key of Object.keys(patch)) {
@@ -17329,23 +17374,31 @@ ${f.content}`).join(`
   }
   update(featureName, taskFolder, updates, lockOptions) {
     const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
-    const current = readJson(statusPath);
-    if (!current) {
+    if (!fileExists(statusPath)) {
       throw new Error(`Task '${taskFolder}' not found`);
     }
-    const updated = {
-      ...current,
-      ...updates,
-      schemaVersion: TASK_STATUS_SCHEMA_VERSION
-    };
-    if (updates.status === "in_progress" && !current.startedAt) {
-      updated.startedAt = new Date().toISOString();
-    }
-    if (updates.status === "done" && !current.completedAt) {
-      updated.completedAt = new Date().toISOString();
+    const release = acquireLockSync(statusPath, lockOptions);
+    try {
+      const current = readJson(statusPath);
+      if (!current) {
+        throw new Error(`Task '${taskFolder}' not found`);
+      }
+      const updated = {
+        ...current,
+        ...updates,
+        schemaVersion: TASK_STATUS_SCHEMA_VERSION
+      };
+      if (updates.status === "in_progress" && !current.startedAt) {
+        updated.startedAt = new Date().toISOString();
+      }
+      if (updates.status === "done" && !current.completedAt) {
+        updated.completedAt = new Date().toISOString();
+      }
+      writeJsonAtomic(statusPath, updated);
+      return updated;
+    } finally {
+      release();
     }
-    writeJsonLockedSync(statusPath, updated, lockOptions);
-    return updated;
   }
   patchBackgroundFields(featureName, taskFolder, patch, lockOptions) {
     const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
@@ -22160,6 +22213,8 @@ ${f.content}`);
 }
 class ConfigService {
   configPath;
+  cachedConfig = null;
+  cachedCustomAgentConfigs = null;
   constructor() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
     const configDir = path6.join(homeDir, ".config", "opencode");
@@ -22169,49 +22224,50 @@ class ConfigService {
     return this.configPath;
   }
   get() {
+    if (this.cachedConfig !== null) {
+      return this.cachedConfig;
+    }
     try {
       if (!fs10.existsSync(this.configPath)) {
-        return { ...DEFAULT_HIVE_CONFIG };
+        this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
+        this.cachedCustomAgentConfigs = null;
+        return this.cachedConfig;
       }
       const raw = fs10.readFileSync(this.configPath, "utf-8");
       const stored = JSON.parse(raw);
-      return {
+      const storedCustomAgents = this.isObjectRecord(stored.customAgents) ? stored.customAgents : {};
+      const mergedBuiltInAgents = BUILT_IN_AGENT_NAMES.reduce((acc, agentName) => {
+        acc[agentName] = {
+          ...DEFAULT_HIVE_CONFIG.agents?.[agentName],
+          ...stored.agents?.[agentName]
+        };
+        return acc;
+      }, {});
+      const merged = {
         ...DEFAULT_HIVE_CONFIG,
         ...stored,
         agents: {
           ...DEFAULT_HIVE_CONFIG.agents,
           ...stored.agents,
-          "hive-master": {
-            ...DEFAULT_HIVE_CONFIG.agents?.["hive-master"],
-            ...stored.agents?.["hive-master"]
-          },
-          "architect-planner": {
-            ...DEFAULT_HIVE_CONFIG.agents?.["architect-planner"],
-            ...stored.agents?.["architect-planner"]
-          },
-          "swarm-orchestrator": {
-            ...DEFAULT_HIVE_CONFIG.agents?.["swarm-orchestrator"],
-            ...stored.agents?.["swarm-orchestrator"]
-          },
-          "scout-researcher": {
-            ...DEFAULT_HIVE_CONFIG.agents?.["scout-researcher"],
-            ...stored.agents?.["scout-researcher"]
-          },
-          "forager-worker": {
-            ...DEFAULT_HIVE_CONFIG.agents?.["forager-worker"],
-            ...stored.agents?.["forager-worker"]
-          },
-          "hygienic-reviewer": {
-            ...DEFAULT_HIVE_CONFIG.agents?.["hygienic-reviewer"],
-            ...stored.agents?.["hygienic-reviewer"]
-          }
+          ...mergedBuiltInAgents
+        },
+        customAgents: {
+          ...DEFAULT_HIVE_CONFIG.customAgents,
+          ...storedCustomAgents
         }
       };
+      this.cachedConfig = merged;
+      this.cachedCustomAgentConfigs = null;
+      return this.cachedConfig;
     } catch {
-      return { ...DEFAULT_HIVE_CONFIG };
+      this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
+      this.cachedCustomAgentConfigs = null;
+      return this.cachedConfig;
     }
   }
   set(updates) {
+    this.cachedConfig = null;
+    this.cachedCustomAgentConfigs = null;
     const current = this.get();
     const merged = {
       ...current,
@@ -22219,13 +22275,19 @@ class ConfigService {
       agents: updates.agents ? {
         ...current.agents,
         ...updates.agents
-      } : current.agents
+      } : current.agents,
+      customAgents: updates.customAgents ? {
+        ...current.customAgents,
+        ...updates.customAgents
+      } : current.customAgents
     };
     const configDir = path6.dirname(this.configPath);
     if (!fs10.existsSync(configDir)) {
       fs10.mkdirSync(configDir, { recursive: true });
     }
     fs10.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+    this.cachedConfig = merged;
+    this.cachedCustomAgentConfigs = null;
     return merged;
   }
   exists() {
@@ -22239,20 +22301,94 @@ class ConfigService {
   }
   getAgentConfig(agent) {
     const config2 = this.get();
-    const agentConfig = config2.agents?.[agent] ?? {};
-    const defaultAutoLoadSkills = DEFAULT_HIVE_CONFIG.agents?.[agent]?.autoLoadSkills ?? [];
-    const userAutoLoadSkills = agentConfig.autoLoadSkills ?? [];
-    const isPlannerAgent = agent === "hive-master" || agent === "architect-planner";
-    const effectiveUserAutoLoadSkills = isPlannerAgent ? userAutoLoadSkills : userAutoLoadSkills.filter((skill) => skill !== "onboarding");
-    const effectiveDefaultAutoLoadSkills = isPlannerAgent ? defaultAutoLoadSkills : defaultAutoLoadSkills.filter((skill) => skill !== "onboarding");
-    const combinedAutoLoadSkills = [...effectiveDefaultAutoLoadSkills, ...effectiveUserAutoLoadSkills];
+    if (this.isBuiltInAgent(agent)) {
+      const agentConfig = config2.agents?.[agent] ?? {};
+      const defaultAutoLoadSkills = DEFAULT_HIVE_CONFIG.agents?.[agent]?.autoLoadSkills ?? [];
+      const effectiveAutoLoadSkills = this.resolveAutoLoadSkills(defaultAutoLoadSkills, agentConfig.autoLoadSkills ?? [], this.isPlannerAgent(agent));
+      return {
+        ...agentConfig,
+        autoLoadSkills: effectiveAutoLoadSkills
+      };
+    }
+    const customAgents = this.getCustomAgentConfigs();
+    return customAgents[agent] ?? {};
+  }
+  getCustomAgentConfigs() {
+    if (this.cachedCustomAgentConfigs !== null) {
+      return this.cachedCustomAgentConfigs;
+    }
+    const config2 = this.get();
+    const customAgents = this.isObjectRecord(config2.customAgents) ? config2.customAgents : {};
+    const resolved = {};
+    for (const [agentName, declaration] of Object.entries(customAgents)) {
+      if (this.isReservedCustomAgentName(agentName)) {
+        console.warn(`[hive:config] Skipping custom agent "${agentName}": reserved name`);
+        continue;
+      }
+      if (!this.isObjectRecord(declaration)) {
+        console.warn(`[hive:config] Skipping custom agent "${agentName}": invalid declaration (expected object)`);
+        continue;
+      }
+      const baseAgent = declaration["baseAgent"];
+      if (typeof baseAgent !== "string" || !this.isSupportedCustomAgentBase(baseAgent)) {
+        console.warn(`[hive:config] Skipping custom agent "${agentName}": unsupported baseAgent "${String(baseAgent)}"`);
+        continue;
+      }
+      const autoLoadSkillsValue = declaration["autoLoadSkills"];
+      const additionalAutoLoadSkills = Array.isArray(autoLoadSkillsValue) ? autoLoadSkillsValue.filter((skill) => typeof skill === "string") : [];
+      const baseAgentConfig = this.getAgentConfig(baseAgent);
+      const effectiveAutoLoadSkills = this.resolveAutoLoadSkills(baseAgentConfig.autoLoadSkills ?? [], additionalAutoLoadSkills, this.isPlannerAgent(baseAgent));
+      const descriptionValue = declaration["description"];
+      const description = typeof descriptionValue === "string" ? descriptionValue.trim() : "";
+      if (!description) {
+        console.warn(`[hive:config] Skipping custom agent "${agentName}": description must be a non-empty string`);
+        continue;
+      }
+      const modelValue = declaration["model"];
+      const temperatureValue = declaration["temperature"];
+      const variantValue = declaration["variant"];
+      const model = typeof modelValue === "string" ? modelValue.trim() || baseAgentConfig.model : baseAgentConfig.model;
+      const variant = typeof variantValue === "string" ? variantValue.trim() || baseAgentConfig.variant : baseAgentConfig.variant;
+      resolved[agentName] = {
+        baseAgent,
+        description,
+        model,
+        temperature: typeof temperatureValue === "number" ? temperatureValue : baseAgentConfig.temperature,
+        variant,
+        autoLoadSkills: effectiveAutoLoadSkills
+      };
+    }
+    this.cachedCustomAgentConfigs = resolved;
+    return this.cachedCustomAgentConfigs;
+  }
+  hasConfiguredAgent(agent) {
+    if (this.isBuiltInAgent(agent)) {
+      return true;
+    }
+    const customAgents = this.getCustomAgentConfigs();
+    return customAgents[agent] !== undefined;
+  }
+  isBuiltInAgent(agent) {
+    return BUILT_IN_AGENT_NAMES.includes(agent);
+  }
+  isReservedCustomAgentName(agent) {
+    return CUSTOM_AGENT_RESERVED_NAMES.includes(agent);
+  }
+  isSupportedCustomAgentBase(baseAgent) {
+    return CUSTOM_AGENT_BASES.includes(baseAgent);
+  }
+  isPlannerAgent(agent) {
+    return agent === "hive-master" || agent === "architect-planner";
+  }
+  isObjectRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  }
+  resolveAutoLoadSkills(baseAutoLoadSkills, additionalAutoLoadSkills, isPlannerAgent) {
+    const effectiveAdditionalSkills = isPlannerAgent ? additionalAutoLoadSkills : additionalAutoLoadSkills.filter((skill) => skill !== "onboarding");
+    const combinedAutoLoadSkills = [...baseAutoLoadSkills, ...effectiveAdditionalSkills];
     const uniqueAutoLoadSkills = Array.from(new Set(combinedAutoLoadSkills));
-    const disabledSkills = config2.disableSkills ?? [];
-    const effectiveAutoLoadSkills = uniqueAutoLoadSkills.filter((skill) => !disabledSkills.includes(skill));
-    return {
-      ...agentConfig,
-      autoLoadSkills: effectiveAutoLoadSkills
-    };
+    const disabledSkills = this.getDisabledSkills();
+    return uniqueAutoLoadSkills.filter((skill) => !disabledSkills.includes(skill));
   }
   isOmoSlimEnabled() {
     const config2 = this.get();
@@ -22273,6 +22409,22 @@ class ConfigService {
     const persistent = config2.persistentContainers ?? mode === "docker";
     return { mode, ...image && { image }, persistent };
   }
+  getHookCadence(hookName, options) {
+    const config2 = this.get();
+    const configuredCadence = config2.hook_cadence?.[hookName];
+    if (options?.safetyCritical && configuredCadence && configuredCadence > 1) {
+      console.warn(`[hive:cadence] Ignoring cadence > 1 for safety-critical hook: ${hookName}`);
+      return 1;
+    }
+    if (configuredCadence === undefined || configuredCadence === null) {
+      return 1;
+    }
+    if (configuredCadence <= 0 || !Number.isInteger(configuredCadence)) {
+      console.warn(`[hive:cadence] Invalid cadence ${configuredCadence} for ${hookName}, using 1`);
+      return 1;
+    }
+    return configuredCadence;
+  }
 }
 
 class AgentsMdService {
@@ -22729,8 +22881,16 @@ hive_worktree_commit({
 })
 \`\`\`
 
-**CRITICAL: After calling hive_worktree_commit, you MUST STOP IMMEDIATELY.**
-Do NOT continue working. Do NOT respond further. Your session is DONE.
+Then inspect the tool response fields:
+- If \`ok=true\` and \`terminal=true\`: stop the session
+- Otherwise: **DO NOT STOP**. Follow \`nextAction\`, remediate, and retry \`hive_worktree_commit\`
+
+**CRITICAL: Stop only on terminal commit result (ok=true and terminal=true).**
+If commit returns non-terminal (for example verification_required), DO NOT STOP.
+Follow result.nextAction, fix the issue, and call hive_worktree_commit again.
+
+Only when commit result is terminal should you stop.
+Do NOT continue working after a terminal result. Do NOT respond further. Your session is DONE.
 The Hive Master will take over from here.
 
 **Summary Guidance** (used verbatim for downstream task context):
@@ -23059,23 +23219,53 @@ function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
 }
 
 // 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;
 }
+function createVariantHook(configService) {
+  return async (input, output) => {
+    const { agent } = input;
+    if (!agent)
+      return;
+    if (!configService.hasConfiguredAgent(agent))
+      return;
+    if (output.message.variant !== undefined)
+      return;
+    const agentConfig = configService.getAgentConfig(agent);
+    const configuredVariant = normalizeVariant(agentConfig.variant);
+    if (configuredVariant !== undefined) {
+      output.message.variant = configuredVariant;
+    }
+  };
+}
+
+// src/hooks/system-hook.ts
+var fallbackTurnCounters = {};
+function shouldExecuteHook(hookName, configService, turnCounters, options) {
+  const cadence = configService?.getHookCadence(hookName, options) ?? 1;
+  const counters = turnCounters ?? fallbackTurnCounters;
+  counters[hookName] = (counters[hookName] || 0) + 1;
+  const currentTurn = counters[hookName];
+  if (cadence === 1) {
+    return true;
+  }
+  return (currentTurn - 1) % cadence === 0;
+}
+var HIVE_SYSTEM_PROMPT = `
+## Hive — Active Session
+
+**Important:** hive_worktree_commit commits to the task branch but does NOT merge.
+Use hive_merge to integrate changes into the current branch.
+`;
+
+// src/utils/compaction-prompt.ts
+var COMPACTION_RESUME_PROMPT = "You were compacted mid-task. " + "Resume by reading your worker-prompt.md (in the task worktree root) to recall your assignment. " + "Do not call status tools or re-read the full codebase. " + "Locate your last commit message or notes, then continue from where you left off.";
+function buildCompactionPrompt() {
+  return COMPACTION_RESUME_PROMPT;
+}
 
 // src/index.ts
 function formatSkillsXml(skills) {
@@ -23097,9 +23287,8 @@ function formatSkillsXml(skills) {
 ${skillsXml}
 </available_skills>`;
 }
-async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot) {
-  const agentConfig = configService.getAgentConfig(agentName);
-  const autoLoadSkills = agentConfig.autoLoadSkills ?? [];
+async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot, autoLoadSkillsOverride) {
+  const autoLoadSkills = autoLoadSkillsOverride ?? (configService.getAgentConfig(agentName).autoLoadSkills ?? []);
   if (autoLoadSkills.length === 0) {
     return "";
   }
@@ -23162,85 +23351,6 @@ No Hive skills available.` : base + formatSkillsXml(filteredSkills);
     }
   });
 }
-var HIVE_SYSTEM_PROMPT = `
-## Hive - Feature Development System
-
-Plan-first development: Write plan → User reviews → Approve → Execute tasks
-
-### Tools (14 total)
-
-| Domain | Tools |
-|--------|-------|
-| 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 |
-| Worktree | hive_worktree_create, hive_worktree_commit, hive_worktree_discard |
-| Merge | hive_merge |
-| Context | hive_context_write |
-| Status | hive_status |
-| Skill | hive_skill |
-
-### Workflow
-
-1. \`hive_feature_create(name)\` - Create feature
-2. \`hive_plan_write(content)\` - Write plan.md
-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_worktree_create(task)\` → work in worktree → \`hive_worktree_commit(task, summary)\`
-7. \`hive_merge(task)\` - Merge task branch into main (when ready)
-
-**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_worktree_create\` creates worktree and spawns worker automatically:
-
-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_status()\`
-2. Read the blocker info (reason, options, recommendation, context)
-3. Ask user via \`question()\` tool - NEVER plain text
-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.
-
-**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 multiple \`task()\` calls in the same message
-
-### Planning Phase - Context Management REQUIRED
-
-As you research and plan, CONTINUOUSLY save findings using \`hive_context_write\`:
-- Research findings (API patterns, library docs, codebase structure)
-- User preferences ("we use Zustand, not Redux")
-- Rejected alternatives ("tried X, too complex")
-- Architecture decisions ("auth lives in /lib/auth")
-
-**Update existing context files** when new info emerges - dont create duplicates.
-
-\`hive_tasks_sync\` parses \`### N. Task Name\` headers.
-
-### Execution Phase - Stay Aligned
-
-During execution, call \`hive_status\` periodically to:
-- Check current progress and pending work
-- See context files to read
-- Get reminded of next actions
-`;
 var plugin = async (ctx) => {
   const { directory, client } = ctx;
   const featureService = new FeatureService(directory);
@@ -23295,6 +23405,7 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
     }
     return null;
   };
+  const turnCounters = {};
   const checkDependencies = (feature, taskFolder) => {
     const taskStatus = taskService.getRawStatus(feature, taskFolder);
     if (!taskStatus) {
@@ -23332,8 +23443,397 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
     }
     return { allowed: true };
   };
+  const respond = (payload) => JSON.stringify(payload, null, 2);
+  const buildWorktreeLaunchResponse = async ({
+    feature,
+    task,
+    taskInfo,
+    worktree,
+    continueFrom,
+    decision
+  }) => {
+    taskService.update(feature, task, {
+      status: "in_progress",
+      baseCommit: worktree.commit
+    });
+    const planResult = planService.read(feature);
+    const allTasks = taskService.list(feature);
+    const rawContextFiles = contextService.list(feature).map((f) => ({
+      name: f.name,
+      content: f.content
+    }));
+    const rawPreviousTasks = allTasks.filter((t) => t.status === "done" && t.summary).map((t) => ({ name: t.folder, summary: t.summary }));
+    const taskBudgetResult = applyTaskBudget(rawPreviousTasks, { ...DEFAULT_BUDGET, feature });
+    const contextBudgetResult = applyContextBudget(rawContextFiles, { ...DEFAULT_BUDGET, feature });
+    const contextFiles = contextBudgetResult.files.map((f) => ({
+      name: f.name,
+      content: f.content
+    }));
+    const previousTasks = taskBudgetResult.tasks.map((t) => ({
+      name: t.name,
+      summary: t.summary
+    }));
+    const truncationEvents = [
+      ...taskBudgetResult.truncationEvents,
+      ...contextBudgetResult.truncationEvents
+    ];
+    const droppedTasksHint = taskBudgetResult.droppedTasksHint;
+    const taskOrder = parseInt(taskInfo.folder.match(/^(\d+)/)?.[1] || "0", 10);
+    const status = taskService.getRawStatus(feature, task);
+    const dependsOn = status?.dependsOn ?? [];
+    const specContent = taskService.buildSpecContent({
+      featureName: feature,
+      task: {
+        folder: task,
+        name: taskInfo.planTitle ?? taskInfo.name,
+        order: taskOrder,
+        description: undefined
+      },
+      dependsOn,
+      allTasks: allTasks.map((t) => ({
+        folder: t.folder,
+        name: t.name,
+        order: parseInt(t.folder.match(/^(\d+)/)?.[1] || "0", 10)
+      })),
+      planContent: planResult?.content ?? null,
+      contextFiles,
+      completedTasks: previousTasks
+    });
+    taskService.writeSpec(feature, task, specContent);
+    const workerPrompt = buildWorkerPrompt({
+      feature,
+      task,
+      taskOrder,
+      worktreePath: worktree.path,
+      branch: worktree.branch,
+      plan: planResult?.content || "No plan available",
+      contextFiles,
+      spec: specContent,
+      previousTasks,
+      continueFrom: continueFrom === "blocked" ? {
+        status: "blocked",
+        previousSummary: taskInfo.summary || "No previous summary",
+        decision: decision || "No decision provided"
+      } : undefined
+    });
+    const customAgentConfigs = configService.getCustomAgentConfigs();
+    const defaultAgent = "forager-worker";
+    const eligibleAgents = [
+      {
+        name: defaultAgent,
+        baseAgent: defaultAgent,
+        description: "Default implementation worker"
+      },
+      ...Object.entries(customAgentConfigs).filter(([, config2]) => config2.baseAgent === "forager-worker").sort(([left], [right]) => left.localeCompare(right)).map(([name, config2]) => ({
+        name,
+        baseAgent: config2.baseAgent,
+        description: config2.description
+      }))
+    ];
+    const agent = defaultAgent;
+    const rawStatus = taskService.getRawStatus(feature, task);
+    const attempt = (rawStatus?.workerSession?.attempt || 0) + 1;
+    const idempotencyKey = `hive-${feature}-${task}-${attempt}`;
+    taskService.patchBackgroundFields(feature, task, { idempotencyKey });
+    const contextContent = contextFiles.map((f) => f.content).join(`
+
+`);
+    const previousTasksContent = previousTasks.map((t) => `- **${t.name}**: ${t.summary}`).join(`
+`);
+    const promptMeta = calculatePromptMeta({
+      plan: planResult?.content || "",
+      context: contextContent,
+      previousTasks: previousTasksContent,
+      spec: specContent,
+      workerPrompt
+    });
+    const hiveDir = path8.join(directory, ".hive");
+    const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
+    const relativePromptPath = normalizePath(path8.relative(directory, workerPromptPath));
+    const PREVIEW_MAX_LENGTH = 200;
+    const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
+    const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
+    const taskToolInstructions = `## Delegation Required
+
+Choose one of the eligible forager-derived agents below.
+Default to \`${defaultAgent}\` if no specialist is a better match.
+
+${eligibleAgents.map((candidate) => `- \`${candidate.name}\` — ${candidate.description}`).join(`
+`)}
+
+Use OpenCode's built-in \`task\` tool with the chosen \`subagent_type\` and the provided \`taskToolCall.prompt\` value.
+\`taskToolCall.subagent_type\` is prefilled with the default for convenience; override it when a specialist in \`eligibleAgents\` is a better match.
+
+\`\`\`
+task({
+  subagent_type: "<chosen-agent>",
+  description: "Hive: ${task}",
+  prompt: "${taskToolPrompt}"
+})
+\`\`\`
+
+Use the \`@path\` attachment syntax in the prompt to reference the file. Do not inline the file contents.
+
+`;
+    const responseBase = {
+      success: true,
+      terminal: false,
+      worktreePath: worktree.path,
+      branch: worktree.branch,
+      mode: "delegate",
+      agent,
+      defaultAgent,
+      eligibleAgents,
+      delegationRequired: true,
+      workerPromptPath: relativePromptPath,
+      workerPromptPreview,
+      taskPromptMode: "opencode-at-file",
+      taskToolCall: {
+        subagent_type: agent,
+        description: `Hive: ${task}`,
+        prompt: taskToolPrompt
+      },
+      instructions: taskToolInstructions
+    };
+    const jsonPayload = JSON.stringify(responseBase, null, 2);
+    const payloadMeta = calculatePayloadMeta({
+      jsonPayload,
+      promptInlined: false,
+      promptReferencedByFile: true
+    });
+    const sizeWarnings = checkWarnings(promptMeta, payloadMeta);
+    const budgetWarnings = truncationEvents.map((event) => ({
+      type: event.type,
+      severity: "info",
+      message: event.message,
+      affected: event.affected,
+      count: event.count
+    }));
+    const allWarnings = [...sizeWarnings, ...budgetWarnings];
+    return respond({
+      ...responseBase,
+      promptMeta,
+      payloadMeta,
+      budgetApplied: {
+        maxTasks: DEFAULT_BUDGET.maxTasks,
+        maxSummaryChars: DEFAULT_BUDGET.maxSummaryChars,
+        maxContextChars: DEFAULT_BUDGET.maxContextChars,
+        maxTotalContextChars: DEFAULT_BUDGET.maxTotalContextChars,
+        tasksIncluded: previousTasks.length,
+        tasksDropped: rawPreviousTasks.length - previousTasks.length,
+        droppedTasksHint
+      },
+      warnings: allWarnings.length > 0 ? allWarnings : undefined
+    });
+  };
+  const executeWorktreeStart = async ({
+    task,
+    feature: explicitFeature
+  }) => {
+    const feature = resolveFeature(explicitFeature);
+    if (!feature) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: "No feature specified. Create a feature or provide feature param.",
+        reason: "feature_required",
+        task,
+        hints: [
+          "Create/select a feature first or pass the feature parameter explicitly.",
+          "Use hive_status to inspect the active feature state before retrying."
+        ]
+      });
+    }
+    const blockedMessage = checkBlocked(feature);
+    if (blockedMessage) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: blockedMessage,
+        reason: "feature_blocked",
+        feature,
+        task,
+        hints: [
+          "Wait for the human to unblock the feature before retrying.",
+          `If approved, remove .hive/features/${feature}/BLOCKED and retry hive_worktree_start.`
+        ]
+      });
+    }
+    const taskInfo = taskService.get(feature, task);
+    if (!taskInfo) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `Task "${task}" not found`,
+        reason: "task_not_found",
+        feature,
+        task,
+        hints: [
+          "Check the task folder name in tasks.json or hive_status output.",
+          "Run hive_tasks_sync if the approved plan has changed and tasks need regeneration."
+        ]
+      });
+    }
+    if (taskInfo.status === "done") {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `Task "${task}" is already completed (status: done). It cannot be restarted.`,
+        currentStatus: "done",
+        hints: [
+          "Use hive_merge to integrate the completed task branch if not already merged.",
+          "Use hive_status to see all task states and find the next runnable task."
+        ]
+      });
+    }
+    if (taskInfo.status === "blocked") {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `Task "${task}" is blocked and must be resumed with hive_worktree_create using continueFrom: 'blocked'.`,
+        currentStatus: "blocked",
+        feature,
+        task,
+        hints: [
+          'Ask the user the blocker question, then call hive_worktree_create({ task, continueFrom: "blocked", decision }).',
+          "Use hive_status to inspect blocker details before retrying."
+        ]
+      });
+    }
+    const depCheck = checkDependencies(feature, task);
+    if (!depCheck.allowed) {
+      return respond({
+        success: false,
+        terminal: true,
+        reason: "dependencies_not_done",
+        feature,
+        task,
+        error: depCheck.error,
+        hints: [
+          "Complete the required dependencies before starting this task.",
+          "Use hive_status to see current task states."
+        ]
+      });
+    }
+    const worktree = await worktreeService.create(feature, task);
+    return buildWorktreeLaunchResponse({ feature, task, taskInfo, worktree });
+  };
+  const executeBlockedResume = async ({
+    task,
+    feature: explicitFeature,
+    continueFrom,
+    decision
+  }) => {
+    const feature = resolveFeature(explicitFeature);
+    if (!feature) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: "No feature specified. Create a feature or provide feature param.",
+        reason: "feature_required",
+        task,
+        hints: [
+          "Create/select a feature first or pass the feature parameter explicitly.",
+          "Use hive_status to inspect the active feature state before retrying."
+        ]
+      });
+    }
+    const blockedMessage = checkBlocked(feature);
+    if (blockedMessage) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: blockedMessage,
+        reason: "feature_blocked",
+        feature,
+        task,
+        hints: [
+          "Wait for the human to unblock the feature before retrying.",
+          `If approved, remove .hive/features/${feature}/BLOCKED and retry hive_worktree_create.`
+        ]
+      });
+    }
+    const taskInfo = taskService.get(feature, task);
+    if (!taskInfo) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `Task "${task}" not found`,
+        reason: "task_not_found",
+        feature,
+        task,
+        hints: [
+          "Check the task folder name in tasks.json or hive_status output.",
+          "Run hive_tasks_sync if the approved plan has changed and tasks need regeneration."
+        ]
+      });
+    }
+    if (taskInfo.status === "done") {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `Task "${task}" is already completed (status: done). It cannot be restarted.`,
+        currentStatus: "done",
+        hints: [
+          "Use hive_merge to integrate the completed task branch if not already merged.",
+          "Use hive_status to see all task states and find the next runnable task."
+        ]
+      });
+    }
+    if (continueFrom !== "blocked") {
+      return respond({
+        success: false,
+        terminal: true,
+        error: "hive_worktree_create is only for resuming blocked tasks.",
+        reason: "blocked_resume_required",
+        currentStatus: taskInfo.status,
+        feature,
+        task,
+        hints: [
+          "Use hive_worktree_start({ feature, task }) to start a pending or in-progress task normally.",
+          'Use hive_worktree_create({ task, continueFrom: "blocked", decision }) only after hive_status confirms the task is blocked.'
+        ]
+      });
+    }
+    if (taskInfo.status !== "blocked") {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `continueFrom: 'blocked' was specified but task "${task}" is not in blocked state (current status: ${taskInfo.status}).`,
+        currentStatus: taskInfo.status,
+        hints: [
+          "Use hive_worktree_start({ feature, task }) for normal starts or re-dispatch.",
+          "Use hive_status to verify the current task status before retrying."
+        ]
+      });
+    }
+    const worktree = await worktreeService.get(feature, task);
+    if (!worktree) {
+      return respond({
+        success: false,
+        terminal: true,
+        error: `Cannot resume blocked task "${task}": no existing worktree record found.`,
+        currentStatus: taskInfo.status,
+        hints: [
+          "The worktree may have been removed manually. Use hive_worktree_discard to reset the task to pending, then restart it with hive_worktree_start.",
+          "Use hive_status to inspect the current state of the task and its worktree."
+        ]
+      });
+    }
+    return buildWorktreeLaunchResponse({
+      feature,
+      task,
+      taskInfo,
+      worktree,
+      continueFrom,
+      decision
+    });
+  };
   return {
     "experimental.chat.system.transform": async (input, output) => {
+      if (!shouldExecuteHook("experimental.chat.system.transform", configService, turnCounters)) {
+        return;
+      }
       output.system.push(HIVE_SYSTEM_PROMPT);
       const activeFeature = resolveFeature();
       if (activeFeature) {
@@ -23354,21 +23854,14 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
         }
       }
     },
-    "chat.message": async (input, output) => {
-      const { agent } = input;
-      if (!agent)
-        return;
-      if (!isHiveAgent(agent))
-        return;
-      if (output.message.variant !== undefined)
-        return;
-      const agentConfig = configService.getAgentConfig(agent);
-      const configuredVariant = normalizeVariant(agentConfig.variant);
-      if (configuredVariant !== undefined) {
-        output.message.variant = configuredVariant;
-      }
+    "experimental.session.compacting": async (_input, output) => {
+      output.context.push(buildCompactionPrompt());
     },
+    "chat.message": createVariantHook(configService),
     "tool.execute.before": async (input, output) => {
+      if (!shouldExecuteHook("tool.execute.before", configService, turnCounters, { safetyCritical: true })) {
+        return;
+      }
       if (input.tool !== "bash")
         return;
       const sandboxConfig = configService.getSandboxConfig();
@@ -23557,7 +24050,7 @@ Expand your Discovery section 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_worktree_create to use its worktree, and ensure any subagents work in that worktree too.`;
+Reminder: start work with hive_worktree_start to use its worktree, and ensure any subagents work in that worktree too.`;
         }
       }),
       hive_task_update: tool({
@@ -23579,202 +24072,30 @@ Reminder: start work with hive_worktree_create to use its worktree, and ensure a
           return `Task "${task}" updated: status=${updated.status}`;
         }
       }),
+      hive_worktree_start: tool({
+        description: "Create worktree and begin work on pending/in-progress task. Spawns Forager worker automatically.",
+        args: {
+          task: tool.schema.string().describe("Task folder name"),
+          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
+        },
+        async execute({ task, feature: explicitFeature }) {
+          return executeWorktreeStart({ task, feature: explicitFeature });
+        }
+      }),
       hive_worktree_create: tool({
-        description: "Create worktree and begin work on task. Spawns Forager worker automatically.",
+        description: "Resume a blocked task in its existing worktree. Spawns Forager worker automatically.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
           feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)"),
           continueFrom: tool.schema.enum(["blocked"]).optional().describe("Resume a blocked task"),
           decision: tool.schema.string().optional().describe("Answer to blocker question when continuing")
         },
-        async execute({ task, feature: explicitFeature, continueFrom, decision }, toolContext) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          const blockedMessage = checkBlocked(feature);
-          if (blockedMessage)
-            return blockedMessage;
-          const taskInfo = taskService.get(feature, task);
-          if (!taskInfo)
-            return `Error: Task "${task}" not found`;
-          if (taskInfo.status === "done")
-            return "Error: Task already completed";
-          if (continueFrom === "blocked" && taskInfo.status !== "blocked") {
-            return "Error: Task is not in blocked state. Use without continueFrom.";
-          }
-          if (continueFrom !== "blocked") {
-            const depCheck = checkDependencies(feature, task);
-            if (!depCheck.allowed) {
-              return JSON.stringify({
-                success: false,
-                error: depCheck.error,
-                hints: [
-                  "Complete the required dependencies before starting this task.",
-                  "Use hive_status to see current task states."
-                ]
-              });
-            }
-          }
-          let worktree;
-          if (continueFrom === "blocked") {
-            worktree = await worktreeService.get(feature, task);
-            if (!worktree)
-              return "Error: No worktree found for blocked task";
-          } else {
-            worktree = await worktreeService.create(feature, task);
-          }
-          taskService.update(feature, task, {
-            status: "in_progress",
-            baseCommit: worktree.commit
-          });
-          const planResult = planService.read(feature);
-          const allTasks = taskService.list(feature);
-          const rawContextFiles = contextService.list(feature).map((f) => ({
-            name: f.name,
-            content: f.content
-          }));
-          const rawPreviousTasks = allTasks.filter((t) => t.status === "done" && t.summary).map((t) => ({ name: t.folder, summary: t.summary }));
-          const taskBudgetResult = applyTaskBudget(rawPreviousTasks, { ...DEFAULT_BUDGET, feature });
-          const contextBudgetResult = applyContextBudget(rawContextFiles, { ...DEFAULT_BUDGET, feature });
-          const contextFiles = contextBudgetResult.files.map((f) => ({
-            name: f.name,
-            content: f.content
-          }));
-          const previousTasks = taskBudgetResult.tasks.map((t) => ({
-            name: t.name,
-            summary: t.summary
-          }));
-          const truncationEvents = [
-            ...taskBudgetResult.truncationEvents,
-            ...contextBudgetResult.truncationEvents
-          ];
-          const droppedTasksHint = taskBudgetResult.droppedTasksHint;
-          const taskOrder = parseInt(taskInfo.folder.match(/^(\d+)/)?.[1] || "0", 10);
-          const status = taskService.getRawStatus(feature, task);
-          const dependsOn = status?.dependsOn ?? [];
-          const specContent = taskService.buildSpecContent({
-            featureName: feature,
-            task: {
-              folder: task,
-              name: taskInfo.planTitle ?? taskInfo.name,
-              order: taskOrder,
-              description: undefined
-            },
-            dependsOn,
-            allTasks: allTasks.map((t) => ({
-              folder: t.folder,
-              name: t.name,
-              order: parseInt(t.folder.match(/^(\d+)/)?.[1] || "0", 10)
-            })),
-            planContent: planResult?.content ?? null,
-            contextFiles,
-            completedTasks: previousTasks
-          });
-          taskService.writeSpec(feature, task, specContent);
-          const workerPrompt = buildWorkerPrompt({
-            feature,
-            task,
-            taskOrder: parseInt(taskInfo.folder.match(/^(\d+)/)?.[1] || "0", 10),
-            worktreePath: worktree.path,
-            branch: worktree.branch,
-            plan: planResult?.content || "No plan available",
-            contextFiles,
-            spec: specContent,
-            previousTasks,
-            continueFrom: continueFrom === "blocked" ? {
-              status: "blocked",
-              previousSummary: taskInfo.summary || "No previous summary",
-              decision: decision || "No decision provided"
-            } : undefined
-          });
-          const agent = "forager-worker";
-          const rawStatus = taskService.getRawStatus(feature, task);
-          const attempt = (rawStatus?.workerSession?.attempt || 0) + 1;
-          const idempotencyKey = `hive-${feature}-${task}-${attempt}`;
-          taskService.patchBackgroundFields(feature, task, { idempotencyKey });
-          const contextContent = contextFiles.map((f) => f.content).join(`
-
-`);
-          const previousTasksContent = previousTasks.map((t) => `- **${t.name}**: ${t.summary}`).join(`
-`);
-          const promptMeta = calculatePromptMeta({
-            plan: planResult?.content || "",
-            context: contextContent,
-            previousTasks: previousTasksContent,
-            spec: specContent,
-            workerPrompt
-          });
-          const hiveDir = path8.join(directory, ".hive");
-          const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-          const relativePromptPath = normalizePath(path8.relative(directory, workerPromptPath));
-          const PREVIEW_MAX_LENGTH = 200;
-          const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
-          const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
-          const taskToolInstructions = `## Delegation Required
-
-Use OpenCode's built-in \`task\` tool to spawn a Forager (Worker/Coder) worker.
-
-\`\`\`
-task({
-  subagent_type: "${agent}",
-  description: "Hive: ${task}",
-  prompt: "${taskToolPrompt}"
-})
-\`\`\`
-
-Use the \`@path\` attachment syntax in the prompt to reference the file. Do not inline the file contents.
-
-`;
-          const responseBase = {
-            worktreePath: worktree.path,
-            branch: worktree.branch,
-            mode: "delegate",
-            agent,
-            delegationRequired: true,
-            workerPromptPath: relativePromptPath,
-            workerPromptPreview,
-            taskPromptMode: "opencode-at-file",
-            taskToolCall: {
-              subagent_type: agent,
-              description: `Hive: ${task}`,
-              prompt: taskToolPrompt
-            },
-            instructions: taskToolInstructions
-          };
-          const jsonPayload = JSON.stringify(responseBase, null, 2);
-          const payloadMeta = calculatePayloadMeta({
-            jsonPayload,
-            promptInlined: false,
-            promptReferencedByFile: true
-          });
-          const sizeWarnings = checkWarnings(promptMeta, payloadMeta);
-          const budgetWarnings = truncationEvents.map((event) => ({
-            type: event.type,
-            severity: "info",
-            message: event.message,
-            affected: event.affected,
-            count: event.count
-          }));
-          const allWarnings = [...sizeWarnings, ...budgetWarnings];
-          return JSON.stringify({
-            ...responseBase,
-            promptMeta,
-            payloadMeta,
-            budgetApplied: {
-              maxTasks: DEFAULT_BUDGET.maxTasks,
-              maxSummaryChars: DEFAULT_BUDGET.maxSummaryChars,
-              maxContextChars: DEFAULT_BUDGET.maxContextChars,
-              maxTotalContextChars: DEFAULT_BUDGET.maxTotalContextChars,
-              tasksIncluded: previousTasks.length,
-              tasksDropped: rawPreviousTasks.length - previousTasks.length,
-              droppedTasksHint
-            },
-            warnings: allWarnings.length > 0 ? allWarnings : undefined
-          }, null, 2);
+        async execute({ task, feature: explicitFeature, continueFrom, decision }) {
+          return executeBlockedResume({ task, feature: explicitFeature, continueFrom, decision });
         }
       }),
       hive_worktree_commit: tool({
-        description: "Complete task: commit changes to branch, write report. Supports blocked/failed/partial status for worker communication.",
+        description: "Complete task: commit changes to branch, write report. Supports blocked/failed/partial status for worker communication. Returns JSON with ok/terminal semantics for worker control flow.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
           summary: tool.schema.string().describe("Summary of what was done"),
@@ -23788,29 +24109,54 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
           feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
         },
         async execute({ task, summary, status = "completed", blocker, feature: explicitFeature }) {
+          const respond2 = (payload) => JSON.stringify(payload, null, 2);
           const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
+          if (!feature) {
+            return respond2({
+              ok: false,
+              terminal: false,
+              status: "error",
+              reason: "feature_required",
+              task,
+              taskState: "unknown",
+              message: "No feature specified. Create a feature or provide feature param.",
+              nextAction: "Provide feature explicitly or create/select an active feature, then retry hive_worktree_commit."
+            });
+          }
           const taskInfo = taskService.get(feature, task);
-          if (!taskInfo)
-            return `Error: Task "${task}" not found`;
-          if (taskInfo.status !== "in_progress" && taskInfo.status !== "blocked")
-            return "Error: Task not in progress";
+          if (!taskInfo) {
+            return respond2({
+              ok: false,
+              terminal: false,
+              status: "error",
+              reason: "task_not_found",
+              feature,
+              task,
+              taskState: "unknown",
+              message: `Task "${task}" not found`,
+              nextAction: "Check the task folder name in your worker-prompt.md and retry hive_worktree_commit with the correct task id."
+            });
+          }
+          if (taskInfo.status !== "in_progress" && taskInfo.status !== "blocked") {
+            return respond2({
+              ok: false,
+              terminal: false,
+              status: "error",
+              reason: "invalid_task_state",
+              feature,
+              task,
+              taskState: taskInfo.status,
+              message: "Task not in progress",
+              nextAction: "Only in_progress or blocked tasks can be committed. Start/resume the task first."
+            });
+          }
+          let verificationNote;
           if (status === "completed") {
-            const verificationKeywords = ["test", "build", "lint", "vitest", "jest", "npm run", "pnpm", "cargo", "pytest", "verified", "passes", "succeeds"];
+            const verificationKeywords = ["test", "build", "lint", "vitest", "jest", "npm run", "pnpm", "cargo", "pytest", "verified", "passes", "succeeds", "ast-grep", "scan"];
             const summaryLower = summary.toLowerCase();
             const hasVerificationMention = verificationKeywords.some((kw) => summaryLower.includes(kw));
             if (!hasVerificationMention) {
-              return `BLOCKED: No verification detected in summary.
-
-Before claiming completion, you must:
-1. Run tests (vitest, jest, pytest, etc.)
-2. Run build (npm run build, cargo build, etc.)
-3. Include verification results in summary
-
-Example summary: "Implemented auth flow. Tests pass (vitest). Build succeeds."
-
-Re-run with updated summary showing verification results.`;
+              verificationNote = "No verification evidence in summary. Orchestrator should run build+test after merge.";
             }
           }
           if (status === "blocked") {
@@ -23820,16 +24166,42 @@ Re-run with updated summary showing verification results.`;
               blocker
             });
             const worktree2 = await worktreeService.get(feature, task);
-            return JSON.stringify({
+            return respond2({
+              ok: true,
+              terminal: true,
               status: "blocked",
+              reason: "user_decision_required",
+              feature,
               task,
+              taskState: "blocked",
               summary,
               blocker,
               worktreePath: worktree2?.path,
-              message: 'Task blocked. Hive Master will ask user and resume with hive_worktree_create(continueFrom: "blocked", decision: answer)'
-            }, null, 2);
+              branch: worktree2?.branch,
+              message: 'Task blocked. Hive Master will ask user and resume with hive_worktree_create(continueFrom: "blocked", decision: answer)',
+              nextAction: 'Wait for orchestrator to collect user decision and resume with continueFrom: "blocked".'
+            });
           }
           const commitResult = await worktreeService.commitChanges(feature, task, `hive(${task}): ${summary.slice(0, 50)}`);
+          if (status === "completed" && !commitResult.committed && commitResult.message !== "No changes to commit") {
+            return respond2({
+              ok: false,
+              terminal: false,
+              status: "rejected",
+              reason: "commit_failed",
+              feature,
+              task,
+              taskState: taskInfo.status,
+              summary,
+              commit: {
+                committed: commitResult.committed,
+                sha: commitResult.sha,
+                message: commitResult.message
+              },
+              message: `Commit failed: ${commitResult.message || "unknown error"}`,
+              nextAction: "Resolve git/worktree issue, then call hive_worktree_commit again."
+            });
+          }
           const diff = await worktreeService.getDiff(feature, task);
           const statusLabel = status === "completed" ? "success" : status;
           const reportLines = [
@@ -23859,13 +24231,31 @@ Re-run with updated summary showing verification results.`;
           } else {
             reportLines.push("---", "", "## Changes", "", "_No file changes detected_", "");
           }
-          taskService.writeReport(feature, task, reportLines.join(`
+          const reportPath = taskService.writeReport(feature, task, reportLines.join(`
 `));
           const finalStatus = status === "completed" ? "done" : status;
           taskService.update(feature, task, { status: finalStatus, summary });
           const worktree = await worktreeService.get(feature, task);
-          return `Task "${task}" ${status}. Changes committed to branch ${worktree?.branch || "unknown"}.
-Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "unknown"}.`;
+          return respond2({
+            ok: true,
+            terminal: true,
+            status,
+            feature,
+            task,
+            taskState: finalStatus,
+            summary,
+            ...verificationNote && { verificationNote },
+            commit: {
+              committed: commitResult.committed,
+              sha: commitResult.sha,
+              message: commitResult.message
+            },
+            worktreePath: worktree?.path,
+            branch: worktree?.branch,
+            reportPath,
+            message: `Task "${task}" ${status}.`,
+            nextAction: "Use hive_merge to integrate changes. Worktree is preserved for review."
+          });
         }
       }),
       hive_worktree_discard: tool({
@@ -23936,23 +24326,40 @@ Files changed: ${result.filesChanged?.length || 0}`;
           feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
         },
         async execute({ feature: explicitFeature }) {
+          const respond2 = (payload) => JSON.stringify(payload, null, 2);
           const feature = resolveFeature(explicitFeature);
           if (!feature) {
-            return JSON.stringify({
+            return respond2({
+              success: false,
+              terminal: true,
+              reason: "feature_required",
               error: "No feature specified and no active feature found",
               hint: "Use hive_feature_create to create a new feature"
             });
           }
           const featureData = featureService.get(feature);
           if (!featureData) {
-            return JSON.stringify({
+            return respond2({
+              success: false,
+              terminal: true,
+              reason: "feature_not_found",
               error: `Feature '${feature}' not found`,
               availableFeatures: featureService.list()
             });
           }
           const blocked = checkBlocked(feature);
-          if (blocked)
-            return blocked;
+          if (blocked) {
+            return respond2({
+              success: false,
+              terminal: true,
+              blocked: true,
+              error: blocked,
+              hints: [
+                "Read the blocker details and resolve them before retrying hive_status.",
+                `Remove .hive/features/${feature}/BLOCKED once the blocker is resolved.`
+              ]
+            });
+          }
           const plan = planService.read(feature);
           const tasks = taskService.list(feature);
           const contextFiles = contextService.list(feature);
@@ -24009,7 +24416,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_worktree_create: ${runnableTasks[0]}`;
+              return `Start next task with hive_worktree_start: ${runnableTasks[0]}`;
             }
             const pending = tasks2.find((t) => t.status === "pending");
             if (pending) {
@@ -24018,7 +24425,7 @@ Files changed: ${result.filesChanged?.length || 0}`;
             return "All tasks complete. Review and merge or complete feature.";
           };
           const planStatus = featureData.status === "planning" ? "draft" : featureData.status === "approved" ? "approved" : featureData.status === "executing" ? "locked" : "none";
-          return JSON.stringify({
+          return respond2({
             feature: {
               name: feature,
               status: featureData.status,
@@ -24101,7 +24508,43 @@ ${result.diff}
       }
     },
     config: async (opencodeConfig) => {
+      function agentTools(allowed) {
+        const allHiveTools = [
+          "hive_feature_create",
+          "hive_feature_complete",
+          "hive_plan_write",
+          "hive_plan_read",
+          "hive_plan_approve",
+          "hive_tasks_sync",
+          "hive_task_create",
+          "hive_task_update",
+          "hive_worktree_start",
+          "hive_worktree_create",
+          "hive_worktree_commit",
+          "hive_worktree_discard",
+          "hive_merge",
+          "hive_context_write",
+          "hive_status",
+          "hive_skill",
+          "hive_agents_md"
+        ];
+        const result = {};
+        for (const tool3 of allHiveTools) {
+          if (!allowed.includes(tool3)) {
+            result[tool3] = false;
+          }
+        }
+        return result;
+      }
       configService.init();
+      const hiveConfigData = configService.get();
+      const agentMode = hiveConfigData.agentMode ?? "unified";
+      const customAgentConfigs = configService.getCustomAgentConfigs();
+      const customSubagentAppendix = Object.keys(customAgentConfigs).length === 0 ? "" : `
+
+## Configured Custom Subagents
+${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompare(right)).map(([name, config2]) => `- \`${name}\` — derived from \`${config2.baseAgent}\`; ${config2.description}`).join(`
+`)}`;
       const hiveUserConfig = configService.getAgentConfig("hive-master");
       const hiveAutoLoadedSkills = await buildAutoLoadedSkillsContent("hive-master", configService, directory);
       const hiveConfig = {
@@ -24109,7 +24552,7 @@ ${result.diff}
         variant: hiveUserConfig.variant,
         temperature: hiveUserConfig.temperature ?? 0.5,
         description: "Hive (Hybrid) - Plans + orchestrates. Detects phase, loads skills on-demand.",
-        prompt: QUEEN_BEE_PROMPT + hiveAutoLoadedSkills,
+        prompt: QUEEN_BEE_PROMPT + hiveAutoLoadedSkills + (agentMode === "unified" ? customSubagentAppendix : ""),
         permission: {
           question: "allow",
           skill: "allow",
@@ -24124,7 +24567,8 @@ ${result.diff}
         variant: architectUserConfig.variant,
         temperature: architectUserConfig.temperature ?? 0.7,
         description: "Architect (Planner) - Plans features, interviews, writes plans. NEVER executes.",
-        prompt: ARCHITECT_BEE_PROMPT + architectAutoLoadedSkills,
+        prompt: ARCHITECT_BEE_PROMPT + architectAutoLoadedSkills + (agentMode === "dedicated" ? customSubagentAppendix : ""),
+        tools: agentTools(["hive_feature_create", "hive_plan_write", "hive_plan_read", "hive_context_write", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
           task: "allow",
@@ -24142,7 +24586,24 @@ ${result.diff}
         variant: swarmUserConfig.variant,
         temperature: swarmUserConfig.temperature ?? 0.5,
         description: "Swarm (Orchestrator) - Orchestrates execution. Delegates, spawns workers, verifies, merges.",
-        prompt: SWARM_BEE_PROMPT + swarmAutoLoadedSkills,
+        prompt: SWARM_BEE_PROMPT + swarmAutoLoadedSkills + (agentMode === "dedicated" ? customSubagentAppendix : ""),
+        tools: agentTools([
+          "hive_feature_create",
+          "hive_feature_complete",
+          "hive_plan_read",
+          "hive_plan_approve",
+          "hive_tasks_sync",
+          "hive_task_create",
+          "hive_task_update",
+          "hive_worktree_start",
+          "hive_worktree_create",
+          "hive_worktree_discard",
+          "hive_merge",
+          "hive_context_write",
+          "hive_status",
+          "hive_skill",
+          "hive_agents_md"
+        ]),
         permission: {
           question: "allow",
           skill: "allow",
@@ -24159,6 +24620,7 @@ ${result.diff}
         mode: "subagent",
         description: "Scout (Explorer/Researcher/Retrieval) - Researches codebase + external docs/data.",
         prompt: SCOUT_BEE_PROMPT + scoutAutoLoadedSkills,
+        tools: agentTools(["hive_plan_read", "hive_context_write", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
           task: "deny",
@@ -24176,6 +24638,7 @@ ${result.diff}
         mode: "subagent",
         description: "Forager (Worker/Coder) - Executes tasks directly in isolated worktrees. Never delegates.",
         prompt: FORAGER_BEE_PROMPT + foragerAutoLoadedSkills,
+        tools: agentTools(["hive_plan_read", "hive_worktree_commit", "hive_context_write", "hive_skill"]),
         permission: {
           task: "deny",
           delegate: "deny",
@@ -24191,6 +24654,7 @@ ${result.diff}
         mode: "subagent",
         description: "Hygienic (Consultant/Reviewer/Debugger) - Reviews plan documentation quality. OKAY/REJECT verdict.",
         prompt: HYGIENIC_BEE_PROMPT + hygienicAutoLoadedSkills,
+        tools: agentTools(["hive_plan_read", "hive_context_write", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
           task: "deny",
@@ -24198,21 +24662,44 @@ ${result.diff}
           skill: "allow"
         }
       };
-      const hiveConfigData = configService.get();
-      const agentMode = hiveConfigData.agentMode ?? "unified";
+      const builtInAgentConfigs = {
+        "hive-master": hiveConfig,
+        "architect-planner": architectConfig,
+        "swarm-orchestrator": swarmConfig,
+        "scout-researcher": scoutConfig,
+        "forager-worker": foragerConfig,
+        "hygienic-reviewer": hygienicConfig
+      };
+      const customAutoLoadedSkills = Object.fromEntries(await Promise.all(Object.entries(customAgentConfigs).map(async ([customAgentName, customAgentConfig]) => {
+        const inheritedBaseSkills = customAgentConfig.baseAgent === "forager-worker" ? foragerUserConfig.autoLoadSkills ?? [] : hygienicUserConfig.autoLoadSkills ?? [];
+        const deltaAutoLoadSkills = (customAgentConfig.autoLoadSkills ?? []).filter((skill) => !inheritedBaseSkills.includes(skill));
+        return [
+          customAgentName,
+          await buildAutoLoadedSkillsContent(customAgentName, configService, directory, deltaAutoLoadSkills)
+        ];
+      })));
+      const customSubagents = buildCustomSubagents({
+        customAgents: customAgentConfigs,
+        baseAgents: {
+          "forager-worker": foragerConfig,
+          "hygienic-reviewer": hygienicConfig
+        },
+        autoLoadedSkills: customAutoLoadedSkills
+      });
       const allAgents = {};
       if (agentMode === "unified") {
-        allAgents["hive-master"] = hiveConfig;
-        allAgents["scout-researcher"] = scoutConfig;
-        allAgents["forager-worker"] = foragerConfig;
-        allAgents["hygienic-reviewer"] = hygienicConfig;
+        allAgents["hive-master"] = builtInAgentConfigs["hive-master"];
+        allAgents["scout-researcher"] = builtInAgentConfigs["scout-researcher"];
+        allAgents["forager-worker"] = builtInAgentConfigs["forager-worker"];
+        allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
       } else {
-        allAgents["architect-planner"] = architectConfig;
-        allAgents["swarm-orchestrator"] = swarmConfig;
-        allAgents["scout-researcher"] = scoutConfig;
-        allAgents["forager-worker"] = foragerConfig;
-        allAgents["hygienic-reviewer"] = hygienicConfig;
+        allAgents["architect-planner"] = builtInAgentConfigs["architect-planner"];
+        allAgents["swarm-orchestrator"] = builtInAgentConfigs["swarm-orchestrator"];
+        allAgents["scout-researcher"] = builtInAgentConfigs["scout-researcher"];
+        allAgents["forager-worker"] = builtInAgentConfigs["forager-worker"];
+        allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
       }
+      Object.assign(allAgents, customSubagents);
       const configAgent = opencodeConfig.agent;
       if (!configAgent) {
         opencodeConfig.agent = allAgents;