opencode-hive 1.2.0 → 1.3.0

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);
@@ -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)
 
 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,12 +14938,11 @@ 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..." })\`
@@ -14950,65 +14950,68 @@ If yes → \`task({ subagent_type: "hygienic", 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
 \`\`\`
 
 ### After Delegation
-
-1. \`task()\` is BLOCKING — when it returns, the worker is DONE
+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
+3. The delegated task MUST transition out of \`in_progress\`; if still \`in_progress\`, resume worker with explicit instruction to resolve commit response and retry
+4. If task status is blocked: read blocker info → \`question()\` → user decision → resume with \`continueFrom: "blocked"\`
+5. 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.
 
 ### 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 +15022,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 +15192,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,8 +15211,8 @@ 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
 \`\`\`
 
@@ -15232,32 +15225,45 @@ hive_worktree_create({ task: "01-task-name" })
 // 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
+- Invariant: delegated task must not remain \`in_progress\`; if it does, treat as non-terminal completion and resume/retry worker with explicit commit-result handling
 - 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()\` → read blocker info; \`question()\` → ask user (no plain text); \`hive_worktree_create({ task, continueFrom: "blocked", decision })\`.
 
 ## 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 +15271,15 @@ 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, run \`task({ subagent_type: "hygienic", 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 +15289,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_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
-
-**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
+## Guardrails
 
-**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 +15326,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 +15351,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 +15383,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 +15406,114 @@ When operating within a feature context:
   })
   \`\`\`
 
-## Iron Laws
-
-**Never:**
-- Create, modify, or delete files (read-only)
-- Answer without research first
-- Execute tools sequentially when parallel possible
-- Skip intent analysis
+## Operating Rules
 
-**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.
+
+## Intent Extraction
+
+| 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 |
 
-## Blocked Tools
+## Action Bias
 
-These tools are FORBIDDEN:
-- \`task\` — Orchestrator's job
-- \`hive_worktree_create\` — You ARE the spawned worker
-- \`hive_merge\` — Orchestrator's job
+- 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
+3. Check docs via research tools
+4. Try a reasonable approach
+5. Last resort: report blocked
 
-Only report as blocked when:
-- Multiple approaches failed (tried 3+)
-- Decision requires business logic you can't infer
-- External dependency is missing or broken
-
-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
+
+Provide brief status at meaningful milestones.
+
+## Completion Checklist
 
-### 5. Report
+- 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 +15524,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 +15543,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")\`
+## Docker Sandbox
 
-**Never:**
-- Exceed task scope
-- Modify plan file
-- Use \`task\` or \`hive_worktree_create\`
-- Continue after hive_worktree_commit
-- Skip verification
-
-**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
@@ -15759,15 +15722,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);
@@ -16742,12 +16719,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 +16739,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 +16775,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 +17303,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 +22142,7 @@ ${f.content}`);
 }
 class ConfigService {
   configPath;
+  cachedConfig = null;
   constructor() {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
     const configDir = path6.join(homeDir, ".config", "opencode");
@@ -22169,13 +22152,17 @@ 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 };
+        return this.cachedConfig;
       }
       const raw = fs10.readFileSync(this.configPath, "utf-8");
       const stored = JSON.parse(raw);
-      return {
+      const merged = {
         ...DEFAULT_HIVE_CONFIG,
         ...stored,
         agents: {
@@ -22207,11 +22194,15 @@ class ConfigService {
           }
         }
       };
+      this.cachedConfig = merged;
+      return this.cachedConfig;
     } catch {
-      return { ...DEFAULT_HIVE_CONFIG };
+      this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
+      return this.cachedConfig;
     }
   }
   set(updates) {
+    this.cachedConfig = null;
     const current = this.get();
     const merged = {
       ...current,
@@ -22226,6 +22217,7 @@ class ConfigService {
       fs10.mkdirSync(configDir, { recursive: true });
     }
     fs10.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+    this.cachedConfig = merged;
     return merged;
   }
   exists() {
@@ -22273,6 +22265,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 +22737,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):
@@ -23077,6 +23093,31 @@ function normalizeVariant(variant) {
   return trimmed2.length > 0 ? trimmed2 : undefined;
 }
 
+// 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) {
   if (skills.length === 0)
@@ -23162,85 +23203,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 +23257,7 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
     }
     return null;
   };
+  const turnCounters = {};
   const checkDependencies = (feature, taskFolder) => {
     const taskStatus = taskService.getRawStatus(feature, taskFolder);
     if (!taskStatus) {
@@ -23334,6 +23297,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
   };
   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,6 +23320,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
         }
       }
     },
+    "experimental.session.compacting": async (_input, output) => {
+      output.context.push(buildCompactionPrompt());
+    },
     "chat.message": async (input, output) => {
       const { agent } = input;
       if (!agent)
@@ -23369,6 +23338,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
       }
     },
     "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();
@@ -23774,7 +23746,7 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
         }
       }),
       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 +23760,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 respond = (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 respond({
+              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 respond({
+              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 respond({
+              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 +23817,42 @@ Re-run with updated summary showing verification results.`;
               blocker
             });
             const worktree2 = await worktreeService.get(feature, task);
-            return JSON.stringify({
+            return respond({
+              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 respond({
+              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 +23882,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 respond({
+            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({
@@ -24101,6 +24142,33 @@ ${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_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 hiveUserConfig = configService.getAgentConfig("hive-master");
       const hiveAutoLoadedSkills = await buildAutoLoadedSkillsContent("hive-master", configService, directory);
@@ -24125,6 +24193,7 @@ ${result.diff}
         temperature: architectUserConfig.temperature ?? 0.7,
         description: "Architect (Planner) - Plans features, interviews, writes plans. NEVER executes.",
         prompt: ARCHITECT_BEE_PROMPT + architectAutoLoadedSkills,
+        tools: agentTools(["hive_feature_create", "hive_plan_write", "hive_plan_read", "hive_context_write", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
           task: "allow",
@@ -24143,6 +24212,22 @@ ${result.diff}
         temperature: swarmUserConfig.temperature ?? 0.5,
         description: "Swarm (Orchestrator) - Orchestrates execution. Delegates, spawns workers, verifies, merges.",
         prompt: SWARM_BEE_PROMPT + swarmAutoLoadedSkills,
+        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_create",
+          "hive_worktree_discard",
+          "hive_merge",
+          "hive_context_write",
+          "hive_status",
+          "hive_skill",
+          "hive_agents_md"
+        ]),
         permission: {
           question: "allow",
           skill: "allow",
@@ -24159,6 +24244,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 +24262,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 +24278,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",