opencode-hive 1.3.5 → 1.4.3

package/dist/index.js

@@ -871,8 +871,8 @@ var require_dist2 = __commonJS((exports) => {
 });
 
 // src/index.ts
-import * as path11 from "path";
-import * as fs13 from "fs";
+import * as path13 from "path";
+import * as fs14 from "fs";
 import * as os from "os";
 
 // ../../node_modules/zod/v4/classic/external.js
@@ -13196,7 +13196,7 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // src/skills/registry.generated.ts
-var BUILTIN_SKILL_NAMES = ["agents-md-mastery", "brainstorming", "code-reviewer", "dispatching-parallel-agents", "docker-mastery", "executing-plans", "parallel-exploration", "systematic-debugging", "test-driven-development", "verification-before-completion", "writing-plans"];
+var BUILTIN_SKILL_NAMES = ["agents-md-mastery", "brainstorming", "code-reviewer", "dispatching-parallel-agents", "docker-mastery", "executing-plans", "parallel-exploration", "systematic-debugging", "test-driven-development", "verification-before-completion", "verification-reviewer", "writing-plans"];
 var BUILTIN_SKILLS = [
   {
     name: "agents-md-mastery",
@@ -14195,7 +14195,9 @@ Hive detects runtime from project files:
 - \`Dockerfile\` → Builds from project Dockerfile
 - Fallback → \`ubuntu:24.04\`
 
-**Override:** Set \`dockerImage\` in config (\`~/.config/opencode/agent_hive.json\`).
+**Override:** Set \`dockerImage\` in config (\`<project>/.hive/agent-hive.json\` preferred, legacy \`<project>/.opencode/agent_hive.json\`, \`~/.config/opencode/agent_hive.json\` fallback).
+
+If project config is missing, invalid JSON, or invalid shape, Hive reads global config next and then falls back to defaults, surfacing a runtime warning when the project config is invalid.
 
 ## Red Flags - STOP
 
@@ -14303,12 +14305,22 @@ When batch complete:
 ### Step 4.5: Post-Batch Hygienic Review
 
 After the batch report, ask the operator if they want a Hygienic code review for the batch.
-If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\` and apply feedback before starting the next batch.
+If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\`.
+Route review feedback through this decision tree before continuing:
+
+| Feedback type | Action |
+|---------------|--------|
+| Minor / local to the completed batch | **Inline fix** — apply directly, no new task |
+| New isolated work that does not affect downstream sequencing | **Manual task** — \`hive_task_create()\` for non-blocking ad-hoc work |
+| Changes downstream sequencing, dependencies, or scope | **Plan amendment** — update \`plan.md\`, then \`hive_tasks_sync({ refreshPending: true })\` to rewrite pending tasks from the amended plan |
+
+When amending the plan: append new task numbers at the end (do not renumber), update \`Depends on:\` entries to express the new DAG order, then sync.
 
 ### Step 5: Continue
-Based on feedback:
-- Apply changes if needed
-- Execute next batch
+After applying review feedback (or if none):
+- Re-check \`hive_status()\` for the updated **runnable** set — tasks whose dependencies are all satisfied
+- Tasks blocked by unmet dependencies stay blocked until predecessors complete
+- Execute the next batch of runnable tasks
 - Repeat until complete
 
 ### Step 6: Complete Development
@@ -14353,7 +14365,7 @@ After all tasks complete and verified:
 
 When you need to answer "where/how does X work?" across multiple domains (codebase, tests, docs, OSS), investigating sequentially wastes time. Each investigation is independent and can happen in parallel.
 
-**Core principle:** Decompose into independent sub-questions, spawn one task per sub-question, collect results asynchronously.
+**Core principle:** Decompose into independent sub-questions that fit in one context window, spawn one task per sub-question, then synthesize the bounded results.
 
 **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.
 
@@ -14383,7 +14395,7 @@ When you need to answer "where/how does X work?" across multiple domains (codeba
 
 ### 1. Decompose Into Independent Questions
 
-Split your investigation into 2-4 independent sub-questions. Good decomposition:
+Split your investigation into 2-4 independent sub-questions. Each sub-question should fit in one context window. If a request will not fit in one context window, narrow the slice, capture bounded findings, and return to Hive with recommended next steps instead of pushing toward an oversized final report. Good decomposition:
 
 | Domain | Question Example |
 |--------|------------------|
@@ -14396,6 +14408,11 @@ Split your investigation into 2-4 independent sub-questions. Good decomposition:
 - "What is X?" then "How is X used?" (second depends on first)
 - "Find the bug" then "Fix the bug" (not read-only)
 
+**Stop and return to Hive when:**
+- one more fan-out would broaden scope too far
+- a sub-question no longer fits in one context window
+- the next useful step is implementation rather than exploration
+
 ### 2. Spawn Tasks (Fan-Out)
 
 Launch all tasks before waiting for any results:
@@ -14435,27 +14452,21 @@ task({
 - Give each task a clear, focused \`description\`
 - Make prompts specific about what evidence to return
 
-### 3. Continue Working (Optional)
+### 3. Collect Results
 
-While tasks run, you can:
-- Work on other aspects of the problem
-- Prepare synthesis structure
-- Start drafting based on what you already know
+After the fan-out message, collect the task results through the normal \`task()\` return flow. Do not invent background polling or a separate async workflow.
 
-You'll receive a \`<system-reminder>\` notification when each task completes.
-
-### 4. Collect Results
+### 4. Synthesize Findings
 
 When each task completes, its result is returned directly. Collect the outputs from each task and proceed to synthesis.
 
-### 5. Synthesize Findings
+### 5. Cleanup (If Needed)
 
 Combine results from all tasks:
 - Cross-reference findings (file X mentioned by tasks A and B)
 - Identify gaps (task C found nothing, need different approach)
 - Build coherent answer from parallel evidence
-
-### 6. Cleanup (If Needed)
+- If the remaining work would no longer fit in one context window, return to Hive with bounded findings and recommended next steps
 
 No manual cancellation is required in task mode.
 
@@ -15385,6 +15396,116 @@ From 24 failure memories:
 Run the command. Read the output. THEN claim the result.
 
 This is non-negotiable.`
+  },
+  {
+    name: "verification-reviewer",
+    description: "Use when independently verifying implementation claims, post-merge review, or when a reviewer needs to falsify success assertions with command-and-output evidence",
+    template: `# Verification Reviewer
+
+## Overview
+
+Verify implementation claims by attempting to falsify them. Your job is not to confirm success; it is to find where success claims break down.
+
+**Core principle:** Try to prove claims wrong. If you cannot, they are likely correct.
+
+## When to Use
+
+Use this skill when:
+- Reviewing implementation changes that claim to be complete
+- Conducting post-merge verification of a task batch
+- A reviewer needs to independently confirm that acceptance criteria are met
+- Verifying that a bug fix actually resolves the reported symptom
+
+Do not use this skill for:
+- Plan or documentation review (use the default Hygienic review path)
+- Code style or architecture review (use \`code-reviewer\`)
+- Pre-implementation planning
+
+## The Iron Law
+
+\`\`\`
+RATIONALIZATIONS ARE NOT EVIDENCE
+\`\`\`
+
+"The code looks correct" is not verification.
+"It should work because..." is not verification.
+"The tests pass" without showing test output is not verification.
+
+Only command output, tool results, and observable behavior count as evidence.
+
+## Verification Protocol
+
+For each claim in the implementation:
+
+1. **Identify the claim**: What specific thing is being asserted?
+2. **Find the falsification test**: What command or check would fail if the claim is wrong?
+3. **Run the test**: Execute the command fresh. Do not rely on cached or previous results.
+4. **Record the evidence**: Quote the relevant output.
+5. **Verdict**: Does the evidence support or contradict the claim?
+
+## Verification Depth by Change Type
+
+Not all changes carry equal risk. Scale verification effort accordingly:
+
+| Change type | Verification depth | Examples |
+|---|---|---|
+| Config / docs / prompts | Spot-check: confirm the file exists, syntax is valid, key content is present | Skill files, AGENTS.md, prompt strings |
+| Logic changes | Targeted: run the relevant test suite, check edge cases mentioned in the plan | New utility function, bug fix, refactor |
+| API / interface changes | Broad: run full test suite, check downstream consumers, verify types compile | New tool, changed function signatures |
+| Data model / migration | Exhaustive: run tests, verify data integrity, check backward compatibility | Schema changes, serialization format changes |
+
+## Anti-Rationalization Checklist
+
+Before accepting any verification result, check yourself:
+
+| Rationalization | Reality |
+|---|---|
+| "The code looks correct to me" | Reading code is not running code |
+| "The author said it passes" | Author claims are hypotheses, not evidence |
+| "It passed last time" | Stale evidence is not evidence |
+| "The linter is clean" | Linting does not prove correctness |
+| "The types compile" | Type-checking does not prove runtime behavior |
+| "I ran a similar check" | Similar is not the same |
+| "It's a trivial change" | Trivial changes break builds regularly |
+
+## Output Format
+
+\`\`\`
+## Verification Report
+
+**Scope**: [What was reviewed - task name, PR, batch]
+
+### Claims Verified
+
+| # | Claim | Test | Evidence | Verdict |
+|---|-------|------|----------|---------|
+| 1 | [What was claimed] | [Command/check run] | [Output excerpt] | PASS / FAIL / INCONCLUSIVE |
+
+### Summary
+
+[1-3 sentences: overall assessment, any gaps, recommended actions]
+
+### Unverifiable Claims
+
+[List any claims that could not be independently verified and why]
+\`\`\`
+
+## Verification Failures
+
+When a claim fails verification:
+
+1. **Report the actual output** verbatim (do not summarize or interpret).
+2. **State what was expected** vs what was observed.
+3. **Do not suggest fixes** unless specifically asked. Your role is to identify the gap, not fill it.
+4. **Flag severity**: Does this block the work, or is it a minor discrepancy?
+
+## Key Principles
+
+- **Attempt falsification first.** Look for reasons the claim might be wrong before looking for reasons it is right.
+- **One claim, one test.** Do not batch multiple claims into a single verification step.
+- **Fresh runs only.** Re-run commands; do not reuse output from previous sessions or other agents.
+- **Quote output.** Paraphrasing introduces interpretation. Quote the relevant lines.
+- **Proportional effort.** Match verification depth to change risk. Do not spend 30 minutes verifying a typo fix.`
   },
   {
     name: "writing-plans",
@@ -15520,8 +15641,10 @@ All verification MUST be agent-executable (no human intervention):
 - Reference relevant skills with @ syntax
 - DRY, YAGNI, TDD, frequent commits
 - All acceptance criteria must be agent-executable (zero human intervention)
-- Treat \`plan.md\` as the human-facing review surface and execution truth
+- Treat \`context/overview.md\` as the human-facing review surface
+- \`plan.md\` remains execution truth
 - Every plan needs a concise human-facing summary before \`## Tasks\`
+- The \`Design Summary\` in \`plan.md\` should stay readable and review-friendly even though overview-first review happens in \`context/overview.md\`
 - Optional Mermaid is allowed only in that pre-task summary section
 - Mermaid is for dependency or sequence overview only and is never required
 - Keep Discovery, Non-Goals, diagrams, and tasks in the same \`plan.md\` file
@@ -15718,14 +15841,24 @@ Intent Verbalization — verbalize before acting:
 - 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.
+- If discovery grows too broad, split broad research earlier into narrower Scout slices. Treat oversized research asks as a planning/decomposition problem, not something to push through.
 
 ### 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_start({ task: "01-task-name" })\` (creates worktree + Forager)
 
+### Hive Network Lookup
+- \`hive_network_query\` is an optional lookup. Use it only when prior feature evidence would materially improve planning, orchestration, or review-routing decisions.
+- There is no startup lookup. First orient on live files and the current feature state.
+- planning, orchestration, and review roles get network access first.
+- Treat retrieved snippets as historical leads, not execution truth. live-file verification still required.
+- Do not route worker execution through network retrieval. \`hive-helper\` is not a network consumer; it benefits indirectly from better upstream decisions.
+
 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.
 
+**Synthesize Before Delegating:** Workers do not inherit your context or your conversation context. Relevant durable execution context is provided in \`spec.md\` under \`## Context\` when available. Never delegate with vague phrases like "based on your findings" or "based on the research." Restate the issue in concrete terms from the evidence you already have — include file paths, line ranges when known, expected result, and what done looks like. Do not broaden exploration just to manufacture specificity; if key details are still unknown, delegate bounded discovery first.
+
 **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
@@ -15737,7 +15870,13 @@ Save discoveries with \`hive_context_write\`:
 - User preferences
 - Research findings
 
-Use context files for durable worker notes, decisions, and research. Keep the human-facing plan summary in \`plan.md\`.
+Use the lightweight context model explicitly:
+- \`overview\` = human-facing summary/history
+- \`draft\` = planner scratchpad
+- \`execution-decisions\` = orchestration log
+- all other names = durable free-form context
+
+Treat the reserved names above as special-purpose files, not general notes. Use context files for durable worker notes, decisions, and research.
 
 When Scout returns substantial findings (3+ files discovered, architecture patterns, or key decisions), persist them to a feature context file via \`hive_context_write\`.
 
@@ -15814,8 +15953,8 @@ Each task declares dependencies with **Depends on**:
 - **Depends on**: none for no dependencies / parallel starts
 - **Depends on**: 1, 3 for explicit task-number dependencies
 
-\`plan.md\` is the primary human-facing summary and the execution truth.
-- Keep the summary before \`## Tasks\`.
+Refresh \`context/overview.md\` as the primary human-facing review surface, while \`plan.md\` remains execution truth.
+- Keep a readable \`Design Summary\` before \`## Tasks\` in \`plan.md\`.
 - Optional Mermaid is allowed only in the pre-task summary.
 - Never require Mermaid.
 - Use context files only for durable notes that help future execution.
@@ -15852,7 +15991,9 @@ Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **b
 ### Delegation Check
 1. Is there a specialized agent?
 2. Does this need external data? → Scout
-3. Default: delegate (don't do yourself)
+3. Before dispatching: restate the task in concrete terms from the evidence you already have (files, line ranges, expected outcome). Do not forward vague summaries. Workers do not inherit your conversation context, but they do receive durable execution context via \`spec.md\`.
+4. Default: delegate (don't do yourself)
+5. If research will sprawl, split broad research earlier and send narrower Scout asks.
 
 ### Worker Spawning
 \`\`\`
@@ -15863,18 +16004,21 @@ hive_worktree_start({ task: "01-task-name" })  // Creates worktree + Forager
 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
+4. Before every blocked resume, call \`hive_status()\` immediately beforehand and verify the task is still exactly \`blocked\`
+5. If status is not \`blocked\`, do not use \`continueFrom: "blocked"\`; use \`hive_worktree_start({ feature, task })\` only for normal starts (\`pending\` / \`in_progress\`)
+6. Never loop \`continueFrom: "blocked"\` on non-blocked statuses
+7. If any Hive tool response has \`terminal: true\`, treat it as final for that call and do not retry the same parameters
+8. If task status is blocked: read blocker info → \`question()\` → user decision → resume with \`continueFrom: "blocked"\`
+9. 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.
+3. Decide which completed task branches belong in the next merge batch.
+4. Delegate the merge batch to \`hive-helper\`, for example: \`task({ subagent_type: 'hive-helper', prompt: 'delegate the merge batch: merge completed tasks 01-task-name and 02-task-name into the current branch, resolve preserved conflicts locally, continue through the batch, and return a concise summary.' })\`.
+5. After the helper returns, inspect the merge summary and run full verification **once** on the merged batch: \`bun run build\` + \`bun run test\`.
+6. 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
@@ -15883,14 +16027,26 @@ When multiple tasks are in flight, prefer **batch completion** over per-task ver
 4. Ask user via question() — present options and context
 
 ### Merge Strategy
-\`hive_merge({ task: "01-task-name" })\` for each task after the batch completes, then verify the batch
+Hive decides when to merge, delegated \`hive-helper\` executes the batch, and Hive keeps post-batch verification.
+For bounded operational cleanup, Hive may also delegate hard-task cleanup to \`hive-helper\`: clarifying current feature/task/worktree state, summarizing interrupted wrap-up candidates, and creating a safe append-only manual follow-up when the work is isolated and does not change sequencing. Helper may inspect current feature state and summarize what is observably mergeable/resumable/blocked, but DAG-changing requests or anything that needs new sequencing must route back to Hive for plan amendment.
 
 ### 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 → 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.
+4. Route review feedback through this decision tree before starting the next batch:
+
+#### Review Follow-Up Routing
+
+| Feedback type | Action |
+|---------------|--------|
+| Minor / local to the completed batch | **Inline fix** — apply directly, no new task |
+| New isolated work that does not affect downstream sequencing | **Manual task** — \`hive_task_create()\` for non-blocking ad-hoc work; when the need comes from hard-task cleanup or wrap-up handling, Hive may delegate the safe append-only manual follow-up to \`hive-helper\` |
+| Changes downstream sequencing, dependencies, or scope | **Plan amendment** — update \`plan.md\`, then \`hive_tasks_sync({ refreshPending: true })\` to rewrite pending tasks from the amended plan |
+
+When amending the plan: append new task numbers at the end (do not renumber), update \`Depends on:\` entries to express the new DAG order, then sync. \`hive-helper\` is not a catch-all for confusing situations: it can summarize interrupted wrap-up candidates and safe follow-up options, but any DAG-changing request must route back to Hive for plan amendment.
+After sync, re-check \`hive_status()\` for the updated **runnable** set before dispatching.
 
 ### AGENTS.md Maintenance
 After feature completion (all tasks merged):
@@ -15953,6 +16109,8 @@ PLANNER, NOT IMPLEMENTER. "Do X" means "create plan for X".
 
 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.
 
+Use \`hive_network_query\` only as an optional lookup when prior feature evidence would materially improve the plan. There is no startup lookup; start with the live request and live files. planning, orchestration, and review roles get network access first. Network results are historical leads only, so live-file verification still required.
+
 ## Self-Clearance Check (After Every Exchange)
 
 □ Core objective clearly defined?
@@ -16033,8 +16191,8 @@ Each task MUST declare dependencies with **Depends on**:
 - **Depends on**: none for no dependencies / parallel starts
 - **Depends on**: 1, 3 for explicit task-number dependencies
 
-\`plan.md\` is the primary human-facing summary and the execution truth.
-- Keep the human-facing summary in \`plan.md\` before \`## Tasks\`.
+Refresh \`context/overview.md\` as the primary human-facing review surface, while \`plan.md\` remains execution truth.
+- Keep the human-facing \`Design Summary\` in \`plan.md\` before \`## Tasks\`.
 - Optional Mermaid is allowed only in the pre-task summary.
 - Mermaid is for dependency or sequence overview only and is never required.
 - Use context files only for durable notes that help future workers.
@@ -16063,6 +16221,7 @@ Each task MUST declare dependencies with **Depends on**:
 - Prefer \`task({ subagent_type: "scout-researcher", prompt: "..." })\` for single investigations.
 - Local \`read/grep/glob\` is acceptable only for a single known file and a bounded question.
 - When running parallel exploration, align with the skill guidance.
+- If discovery keeps widening, split broad research earlier into narrower Scout slices. Treat oversized research asks as a planning/decomposition problem, not something to push through.
 `;
 
 // src/agents/swarm.ts
@@ -16086,15 +16245,37 @@ Intent Verbalization: "I detect [type] intent — [reason]. Routing to [action].
 
 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\`.
 
-Maintain \`context/overview.md\` with \`hive_context_write({ name: "overview", content: ... })\` as the primary human-facing document. Keep \`plan.md\` / \`spec.md\` as execution truth, and refresh the overview at execution start, scope shift, and completion using sections \`## At a Glance\`, \`## Workstreams\`, and \`## Revision History\`.
+If discovery starts to sprawl, split broad research earlier into narrower Scout slices. Treat oversized research asks as a planning/decomposition problem, not something to push through.
+
+Maintain \`context/overview.md\` with \`hive_context_write({ name: "overview", content: ... })\` as the primary human-facing document. Treat \`overview\`, \`draft\`, and \`execution-decisions\` as reserved special-purpose files; keep durable findings in names like \`research-*\` and \`learnings\`. Keep \`plan.md\` / \`spec.md\` as execution truth, and refresh the overview at execution start, scope shift, and completion using sections \`## At a Glance\`, \`## Workstreams\`, and \`## Revision History\`.
 
 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.
 
+\`hive_network_query\` is an optional lookup for orchestration and review-routing decisions when prior feature evidence would materially improve the call. There is no startup lookup; orient on the live task and current repo state first. planning, orchestration, and review roles get network access first. Treat network snippets as historical leads only and keep live-file verification still required. \`hive-helper\` is not a network consumer.
+
 **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
 
+## Synthesize Before Delegating
+
+Workers do not inherit your context or your conversation context. Relevant durable execution context is available in \`spec.md\` under \`## Context\` when present. Before dispatching any work, prove you understand it by restating the problem in concrete terms from the evidence you already have.
+
+**Rules:**
+- Never delegate with vague phrases like "based on your findings", "based on the research", or "as discussed above" — the worker does not share your prior conversation state.
+- Restate the issue with specific file paths and line ranges when known.
+- State the expected result and what done looks like.
+- Do not broaden exploration just to manufacture specificity; delegate bounded discovery first when key details are still unknown.
+
+<Bad>
+"Implement the changes we discussed based on the research findings."
+</Bad>
+
+<Good>
+"In \`packages/core/src/services/task.ts:45-60\`, the \`resolveTask\` function silently swallows errors from \`loadConfig\`. Change it to propagate the error with the original message. Done = \`loadConfig\` failures surface to the caller, existing tests in \`task.test.ts\` still pass."
+</Good>
+
 ## Delegation Prompt Structure (All 6 Sections)
 
 \`\`\`
@@ -16119,8 +16300,10 @@ Delegation guidance:
 - \`task()\` is BLOCKING — returns when the worker is done
 - 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\`
+- Before every blocked resume, call \`hive_status()\` immediately beforehand and verify the task is still 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
+- If any Hive tool response has \`terminal: true\`, treat it as final for that call and do not retry the same parameters
 - For parallel fan-out, issue multiple \`task()\` calls in the same message
 
 ## After Delegation - VERIFY
@@ -16148,7 +16331,7 @@ After completing and merging a batch, run full verification on the main branch:
 
 ## Blocker Handling
 
-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\`).
+When worker reports blocked: \`hive_status()\` → confirm status is exactly \`blocked\` → read blocker info; \`question()\` → ask user (no plain text); call \`hive_status()\` again immediately before resume; only then \`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)
 
@@ -16159,17 +16342,32 @@ When worker reports blocked: \`hive_status()\` → confirm status is exactly \`b
 
 ## Merge Strategy
 
+Swarm decides when to merge, then delegate the merge batch to \`hive-helper\`, for example:
+
 \`\`\`
-hive_merge({ task: "01-task-name", strategy: "merge" })
+task({ subagent_type: 'hive-helper', prompt: 'delegate the merge batch: merge completed tasks 01-task-name and 02-task-name into the current branch, resolve preserved conflicts locally, continue through the batch, and return a concise summary.' })
 \`\`\`
 
-Merge after batch completes, then verify the merged result.
+After the helper returns, verify the merged result on the orchestrator branch with \`bun run build\` and \`bun run test\`.
+For bounded operational cleanup, Swarm may also delegate hard-task cleanup to \`hive-helper\`: clarifying current feature/task/worktree state, summarizing interrupted wrap-up candidates, and creating a safe append-only manual follow-up when the work is isolated and does not change sequencing. Helper may inspect current feature state and summarize what is observably mergeable/resumable/blocked, but DAG-changing requests or anything that needs new sequencing must route back to Swarm for plan amendment.
 
 ### Post-Batch Review (Hygienic)
 
 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.
+Then run \`task({ subagent_type: "<chosen-reviewer>", prompt: "Review implementation changes from the latest batch." })\`.
+Route review feedback through this decision tree before starting the next batch:
+
+#### Review Follow-Up Routing
+
+| Feedback type | Action |
+|---------------|--------|
+| Minor / local to the completed batch | **Inline fix** — apply directly, no new task |
+| New isolated work that does not affect downstream sequencing | **Manual task** — \`hive_task_create()\` for non-blocking ad-hoc work; when the need comes from hard-task cleanup or wrap-up handling, Swarm may delegate the safe append-only manual follow-up to \`hive-helper\` |
+| Changes downstream sequencing, dependencies, or scope | **Plan amendment** — update \`plan.md\`, then \`hive_tasks_sync({ refreshPending: true })\` to rewrite pending tasks from the amended plan |
+
+When amending the plan: append new task numbers at the end (do not renumber), update \`Depends on:\` entries to express the new DAG order, then sync. \`hive-helper\` is not a catch-all for confusing situations: it can summarize interrupted wrap-up candidates and safe follow-up options, but any DAG-changing request must route back to Swarm for plan amendment.
+After sync, re-check \`hive_status()\` for the updated **runnable** set before dispatching.
 
 ### AGENTS.md Maintenance
 
@@ -16210,6 +16408,8 @@ Research before answering; parallelize tool calls when investigating multiple in
 
 ## Research Protocol
 
+Research tasks must fit in one context window. If a request will not fit in one context window, narrow the slice, capture bounded findings, and return to Hive with recommended next steps instead of pushing toward an oversized final report.
+
 ### Phase 1: Intent Analysis (First)
 
 \`\`\`
@@ -16252,6 +16452,14 @@ Stop when any is true:
 - repeated information across sources
 - two rounds with no new data
 - a direct answer is found
+- scope keeps broadening, next steps stay ambiguous, or continued exploration feels risky — return to Hive with bounded findings and next-step recommendations
+
+## Synthesis Rules
+
+- When you have not read a file, do not speculate about its contents. State what is unknown and offer to investigate.
+- When results from multiple sources exist, provide a cited synthesis rather than dumping raw search output.
+- Every factual claim in the answer must link to a specific source (file:line, URL, snippet). If a claim cannot be sourced, omit it or mark it as unverified.
+- Prefer concise answers. If a longer treatment is needed, lead with a summary sentence, then expand.
 
 ## Evidence Check (Before Answering)
 
@@ -16264,12 +16472,23 @@ Stop when any is true:
 
 ## Tool Strategy
 
+### Preferred Search Sequence
+
+Start with local read-only tools before reaching for external sources:
+
+1. **Local discovery first**: \`glob\`, \`grep\`, \`read\`, \`ast_grep\` — cheapest and most precise for codebase questions.
+2. **Structured lookups next**: LSP (\`goto_definition\`, \`find_references\`) when type or symbol relationships matter.
+3. **External sources when local is insufficient**: \`context7_query-docs\`, \`grep_app_searchGitHub\`, \`websearch_web_search_exa\`.
+4. **Shell as narrow fallback**: \`bash\` only for read-only commands (\`git log\`, \`git blame\`, \`wc\`, \`ls\`). Never use bash for file writes, redirects, or state-changing operations.
+
+### Tool Reference
+
 | Need | Tool |
 |------|------|
-| Type/Symbol info | LSP (goto_definition, find_references) |
-| Structural patterns | ast_grep_find_code |
-| Text patterns | grep |
 | File discovery | glob |
+| Text patterns | grep |
+| Structural patterns | ast_grep_find_code |
+| Type/Symbol info | LSP (goto_definition, find_references) |
 | Git history | bash (git log, git blame) |
 | External docs | context7_query-docs |
 | OSS examples | grep_app_searchGitHub |
@@ -16299,14 +16518,31 @@ When operating within a feature context:
     content: "## {Topic}\\n\\nDate: {YYYY-MM-DD}\\n\\n## Context\\n\\n## Findings"
   })
   \`\`\`
+- Use reserved names like \`overview\`, \`draft\`, and \`execution-decisions\` only for their special-purpose workflows, not for general research notes.
+- Use \`hive_context_write\` only for meaningful checkpoints, not every small step.
 
 ## Operating Rules
 
-- Read-only behavior (no file changes)
 - Classify request first, then research
 - Use absolute paths for file references
 - Cite evidence for every claim
 - Use the current year when reasoning about time-sensitive information
+
+### Read-Only Contract
+
+Scout must never modify project state. This includes:
+- No file edits, creation, or deletion (no \`write\`, \`edit\`, \`bash\` writes)
+- No temporary files, scratch files, or redirect-based output (\`>\`, \`>>\`, \`tee\`)
+- No state-changing shell commands (\`rm\`, \`mv\`, \`cp\`, \`mkdir\`, \`chmod\`, \`git checkout\`, \`git commit\`, \`npm install\`, \`pip install\`)
+- No code execution beyond read-only queries (\`git log\`, \`git blame\`, \`wc\`, \`ls\`)
+
+When a task requires writing, tell the caller what to write and where, instead of writing it.
+
+### Speed and Efficiency
+
+- When a question has independent sub-parts, investigate them in parallel using batched tool calls.
+- Stop researching when you have enough direct evidence to answer. Use additional sources only when the first source leaves ambiguity.
+- If the first tool call answers the question directly, answer immediately rather than running the full research protocol.
 `;
 
 // src/agents/forager.ts
@@ -16331,6 +16567,7 @@ Execute directly. Work in isolation. Do not delegate implementation.
 - 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.
+Your task-local worker prompt lists exact tools and verification expectations. Defer to that prompt for tool scope and evidence requirements.
 
 ## Allowed Research
 
@@ -16367,6 +16604,8 @@ Do not modify the plan file.
 For substantial discoveries (architecture patterns, key decisions, gotchas that affect multiple tasks), use:
 \`hive_context_write({ name: "learnings", content: "..." })\`.
 
+Treat reserved names like \`overview\`, \`draft\`, and \`execution-decisions\` as special-purpose files rather than general worker notes.
+
 ## Working Rules
 
 - DRY/Search First: look for existing helpers before adding new code
@@ -16386,7 +16625,7 @@ EXPLORE → PLAN → EXECUTE → VERIFY → LOOP
 - 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)
+- VERIFY: run best-effort checks (tests if available, ast_grep, lsp_diagnostics). Record observed output; do not substitute explanation for execution.
 - LOOP: if verification fails, diagnose and retry within the limit
 
 ## Progress Updates
@@ -16444,6 +16683,53 @@ 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/hive-helper.ts
+var HIVE_HELPER_PROMPT = `# Hive Helper
+
+You are a runtime-only bounded hard-task operational assistant. You never plan, orchestrate, or broaden the assignment.
+
+## Bounded Modes
+
+- merge recovery
+- state clarification
+- safe manual-follow-up assistance
+
+## Core Rules
+
+- never plans, orchestrates, or broadens the assignment
+- use \`hive_merge\` first
+- if merge returns \`conflictState: 'preserved'\`, resolves locally in this helper session and continues the merge batch
+- may summarize observable state for the caller
+- may create safe append-only manual tasks when the requested follow-up fits the current approved DAG boundary
+- never update plan-backed task state
+- escalate DAG-changing requests back to Hive Master / Swarm for plan amendment
+- return only concise merged/state/task/blocker summary text
+
+## Scope
+
+- Merge completed task branches for the caller
+- Clarify current observable feature/task/worktree state after interruptions or ambiguity
+- Create safe append-only manual follow-up tasks within the existing approved DAG boundary
+- Handle preserved merge conflicts in this isolated helper session
+- Continue the requested merge batch until complete or blocked
+- Do not start worktrees, rewrite plans, update plan-backed task state, or broaden the assignment
+
+## Execution
+
+1. Call \`hive_merge\` first for the requested task branch.
+2. If the merge succeeds, continue to the next requested merge.
+3. If \`conflictState: 'preserved'\`, inspect and resolves locally, complete the merge, and continue the merge batch.
+4. When asked for state clarification, use observable \`hive_status\` output and summarize only what is present.
+5. When asked for manual follow-up assistance, create only safe append-only manual tasks that do not rewrite the approved DAG or alter plan-backed task state.
+6. If the request would change sequencing, dependencies, or plan scope, stop and escalate it back to Hive Master / Swarm for plan amendment.
+7. If you cannot safely resolve a conflict or satisfy the bounded request, stop and return a concise blocker summary.
+
+## Output
+
+Return only concise merged/state/task/blocker summary text.
+Do not include planning, orchestration commentary, or long narratives.
+`;
+
 // src/agents/hygienic.ts
 var HYGIENIC_BEE_PROMPT = `# Hygienic (Consultant/Reviewer/Debugger)
 
@@ -16458,6 +16744,14 @@ If you are asked to review IMPLEMENTATION (code changes, diffs, PRs) instead of
 2. Apply it and return its output format
 3. Still do NOT edit code (review only)
 
+If you are asked to VERIFY implementation claims (confirm acceptance criteria, validate that a fix works, post-merge verification):
+1. Load \`hive_skill("verification-reviewer")\`
+2. Follow its falsification-first protocol
+3. Return its evidence-backed report format
+4. Do NOT accept rationalizations as evidence — only command output and observable results count
+
+If \`hive_network_query\` results are included in a review, treat them as historical contrast with citations, never as authority over live repository state. Always prefer current diffs, files, and command output when they disagree.
+
 Self-check before every critique:
 > "Am I questioning APPROACH or DOCUMENTATION?"
 > APPROACH → Stay silent
@@ -16621,6 +16915,7 @@ var BUILT_IN_AGENT_NAMES = [
   "swarm-orchestrator",
   "scout-researcher",
   "forager-worker",
+  "hive-helper",
   "hygienic-reviewer"
 ];
 var CUSTOM_AGENT_BASES = ["forager-worker", "hygienic-reviewer"];
@@ -16643,6 +16938,7 @@ var DEFAULT_AGENT_MODELS = {
   "swarm-orchestrator": "github-copilot/claude-opus-4.5",
   "scout-researcher": "zai-coding-plan/glm-4.7",
   "forager-worker": "github-copilot/gpt-5.2-codex",
+  "hive-helper": "github-copilot/gpt-5.2-codex",
   "hygienic-reviewer": "github-copilot/gpt-5.2-codex"
 };
 var DEFAULT_HIVE_CONFIG = {
@@ -16702,6 +16998,11 @@ var DEFAULT_HIVE_CONFIG = {
       temperature: 0.3,
       autoLoadSkills: ["test-driven-development", "verification-before-completion"]
     },
+    "hive-helper": {
+      model: DEFAULT_AGENT_MODELS["hive-helper"],
+      temperature: 0.3,
+      autoLoadSkills: []
+    },
     "hygienic-reviewer": {
       model: DEFAULT_AGENT_MODELS["hygienic-reviewer"],
       temperature: 0.3,
@@ -17316,13 +17617,20 @@ class PlanService {
 // ../hive-core/src/services/taskService.ts
 import * as fs6 from "fs";
 var TASK_STATUS_SCHEMA_VERSION = 1;
+var EXECUTION_HISTORY_STATUSES = new Set([
+  "in_progress",
+  "done",
+  "blocked",
+  "failed",
+  "partial"
+]);
 
 class TaskService {
   projectRoot;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
   }
-  sync(featureName) {
+  sync(featureName, options) {
     const planPath = getPlanPath(this.projectRoot, featureName);
     const planContent = readText(planPath);
     if (!planContent) {
@@ -17338,12 +17646,13 @@ class TaskService {
       manual: []
     };
     const existingByName = new Map(existingTasks.map((t) => [t.folder, t]));
+    const refreshPending = options?.refreshPending === true;
     for (const existing of existingTasks) {
       if (existing.origin === "manual") {
         result.manual.push(existing.folder);
         continue;
       }
-      if (existing.status === "done" || existing.status === "in_progress") {
+      if (EXECUTION_HISTORY_STATUSES.has(existing.status)) {
         result.kept.push(existing.folder);
         continue;
       }
@@ -17356,6 +17665,12 @@ class TaskService {
       if (!stillInPlan) {
         this.deleteTask(featureName, existing.folder);
         result.removed.push(existing.folder);
+      } else if (refreshPending && existing.status === "pending") {
+        const planTask = planTasks.find((p) => p.folder === existing.folder);
+        if (planTask) {
+          this.refreshPendingTask(featureName, planTask, planTasks, planContent);
+        }
+        result.kept.push(existing.folder);
       } else {
         result.kept.push(existing.folder);
       }
@@ -17368,19 +17683,38 @@ class TaskService {
     }
     return result;
   }
-  create(featureName, name, order) {
-    const tasksPath = getTasksPath(this.projectRoot, featureName);
+  create(featureName, name, order, metadata) {
     const existingFolders = this.listFolders(featureName);
-    const nextOrder = order ?? this.getNextOrder(existingFolders);
-    const folder = `${String(nextOrder).padStart(2, "0")}-${name}`;
+    const nextOrder = this.getNextOrder(existingFolders);
+    if (order !== undefined && order !== nextOrder) {
+      throw new Error(`Manual tasks are append-only: requested order ${order} does not match the next available order ${nextOrder}. ` + `Intermediate insertion requires plan amendment.`);
+    }
+    if (metadata?.source === "review" && metadata.dependsOn && metadata.dependsOn.length > 0) {
+      throw new Error(`Review-sourced manual tasks cannot have explicit dependsOn. ` + `Cross-task dependencies require a plan amendment. ` + `Either remove the dependsOn field or amend the plan to express the dependency.`);
+    }
+    const dependsOn = metadata?.dependsOn ?? [];
+    this.validateManualTaskDependsOn(featureName, dependsOn);
+    const resolvedOrder = order ?? nextOrder;
+    const folder = `${String(resolvedOrder).padStart(2, "0")}-${name}`;
+    const collision = existingFolders.find((f) => {
+      const match = f.match(/^(\d+)-/);
+      return match && parseInt(match[1], 10) === resolvedOrder;
+    });
+    if (collision) {
+      throw new Error(`Task folder collision: order ${resolvedOrder} already exists as "${collision}". ` + `Choose a different order number or omit to auto-increment.`);
+    }
     const taskPath = getTaskPath(this.projectRoot, featureName, folder);
     ensureDir(taskPath);
     const status = {
       status: "pending",
       origin: "manual",
-      planTitle: name
+      planTitle: name,
+      dependsOn,
+      ...metadata ? { metadata: { ...metadata, dependsOn: undefined } } : {}
     };
     writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
+    const specContent = this.buildManualTaskSpec(featureName, folder, name, dependsOn, metadata);
+    writeText(getTaskSpecPath(this.projectRoot, featureName, folder), specContent);
     return folder;
   }
   createFromPlan(featureName, task, allTasks, planContent) {
@@ -17403,6 +17737,27 @@ class TaskService {
     });
     writeText(getTaskSpecPath(this.projectRoot, featureName, task.folder), specContent);
   }
+  refreshPendingTask(featureName, task, allTasks, planContent) {
+    const dependsOn = this.resolveDependencies(task, allTasks);
+    const statusPath = getTaskStatusPath(this.projectRoot, featureName, task.folder);
+    const current = readJson(statusPath);
+    if (current) {
+      const updated = {
+        ...current,
+        planTitle: task.name,
+        dependsOn
+      };
+      writeJson(statusPath, updated);
+    }
+    const specContent = this.buildSpecContent({
+      featureName,
+      task,
+      dependsOn,
+      allTasks,
+      planContent
+    });
+    writeText(getTaskSpecPath(this.projectRoot, featureName, task.folder), specContent);
+  }
   buildSpecContent(params) {
     const { featureName, task, dependsOn, allTasks, planContent, contextFiles = [], completedTasks = [] } = params;
     const getTaskType = (planSection2, taskName) => {
@@ -17564,6 +17919,10 @@ ${f.content}`).join(`
     writeText(specPath, content);
     return specPath;
   }
+  readSpec(featureName, taskFolder) {
+    const specPath = getTaskSpecPath(this.projectRoot, featureName, taskFolder);
+    return readText(specPath);
+  }
   update(featureName, taskFolder, updates, lockOptions) {
     const statusPath = getTaskStatusPath(this.projectRoot, featureName, taskFolder);
     if (!fileExists(statusPath)) {
@@ -17650,6 +18009,17 @@ ${f.content}`).join(`
     const orders = existingFolders.map((f) => parseInt(f.split("-")[0], 10)).filter((n) => !isNaN(n));
     return Math.max(...orders, 0) + 1;
   }
+  validateManualTaskDependsOn(featureName, dependsOn) {
+    for (const dependency of dependsOn) {
+      const dependencyStatus = this.getRawStatus(featureName, dependency);
+      if (!dependencyStatus) {
+        throw new Error(`Manual tasks are append-only: dependency "${dependency}" does not exist. ` + `Dependencies on unfinished work require plan amendment.`);
+      }
+      if (dependencyStatus.status !== "done") {
+        throw new Error(`Manual tasks are append-only: dependency "${dependency}" is ${dependencyStatus.status}, not done. ` + `Dependencies on unfinished work require plan amendment.`);
+      }
+    }
+  }
   parseTasksFromPlan(content) {
     const tasks = [];
     const lines = content.split(`
@@ -17860,6 +18230,63 @@ _Add detailed instructions here_
     const subtaskOrder = subtaskId.split(".")[1];
     return folders.find((f) => f.startsWith(`${subtaskOrder}-`)) || null;
   }
+  buildManualTaskSpec(featureName, folder, name, dependsOn, metadata) {
+    const lines = [
+      `# Task: ${folder}`,
+      "",
+      `## Feature: ${featureName}`,
+      "",
+      "## Dependencies",
+      ""
+    ];
+    if (dependsOn.length > 0) {
+      for (const dep of dependsOn) {
+        lines.push(`- ${dep}`);
+      }
+    } else {
+      lines.push("_None_");
+    }
+    lines.push("");
+    if (metadata?.goal) {
+      lines.push("## Goal", "", metadata.goal, "");
+    }
+    if (metadata?.description) {
+      lines.push("## Description", "", metadata.description, "");
+    }
+    if (metadata?.acceptanceCriteria && metadata.acceptanceCriteria.length > 0) {
+      lines.push("## Acceptance Criteria", "");
+      for (const criterion of metadata.acceptanceCriteria) {
+        lines.push(`- ${criterion}`);
+      }
+      lines.push("");
+    }
+    if (metadata?.files && metadata.files.length > 0) {
+      lines.push("## Files", "");
+      for (const file2 of metadata.files) {
+        lines.push(`- ${file2}`);
+      }
+      lines.push("");
+    }
+    if (metadata?.references && metadata.references.length > 0) {
+      lines.push("## References", "");
+      for (const ref of metadata.references) {
+        lines.push(`- ${ref}`);
+      }
+      lines.push("");
+    }
+    if (metadata?.source || metadata?.reason) {
+      lines.push("## Origin", "");
+      if (metadata?.source) {
+        lines.push(`**Source:** ${metadata.source}`);
+      }
+      if (metadata?.reason) {
+        lines.push(`**Reason:** ${metadata.reason}`);
+      }
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
   slugify(name) {
     return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   }
@@ -22084,19 +22511,27 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
+    let worktreeRemoved = false;
+    let branchDeleted = false;
+    let pruned = false;
     try {
       await git.raw(["worktree", "remove", worktreePath, "--force"]);
+      worktreeRemoved = true;
     } catch {
       await fs7.rm(worktreePath, { recursive: true, force: true });
+      worktreeRemoved = true;
     }
     try {
       await git.raw(["worktree", "prune"]);
+      pruned = true;
     } catch {}
     if (deleteBranch) {
       try {
         await git.deleteLocalBranch(branchName, true);
+        branchDeleted = true;
       } catch {}
     }
+    return { worktreeRemoved, branchDeleted, pruned };
   }
   async list(feature) {
     const worktreesDir = this.getWorktreesDir();
@@ -22228,34 +22663,61 @@ class WorktreeService {
       };
     }
   }
-  async merge(feature, step, strategy = "merge", message) {
+  async merge(feature, step, strategy = "merge", message, options = {}) {
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
+    const cleanupMode = options.cleanup ?? "none";
+    const preserveConflicts = options.preserveConflicts ?? false;
+    const emptyCleanup = {
+      worktreeRemoved: false,
+      branchDeleted: false,
+      pruned: false
+    };
     if (strategy === "rebase" && message) {
       return {
         success: false,
         merged: false,
+        strategy,
+        filesChanged: [],
+        conflicts: [],
+        conflictState: "none",
+        cleanup: emptyCleanup,
         error: "Custom merge message is not supported for rebase strategy"
       };
     }
+    let filesChanged = [];
     try {
       const branches = await git.branch();
       if (!branches.all.includes(branchName)) {
-        return { success: false, merged: false, error: `Branch ${branchName} not found` };
+        return {
+          success: false,
+          merged: false,
+          strategy,
+          filesChanged: [],
+          conflicts: [],
+          conflictState: "none",
+          cleanup: emptyCleanup,
+          error: `Branch ${branchName} not found`
+        };
       }
       const currentBranch = branches.current;
       const diffStat = await git.diff([`${currentBranch}...${branchName}`, "--stat"]);
-      const filesChanged = diffStat.split(`
+      filesChanged = diffStat.split(`
 `).filter((l) => l.trim() && l.includes("|")).map((l) => l.split("|")[0].trim());
       if (strategy === "squash") {
         await git.raw(["merge", "--squash", branchName]);
         const squashMessage = message || `hive: merge ${step} (squashed)`;
         const result = await git.commit(squashMessage);
+        const cleanup = cleanupMode === "none" ? emptyCleanup : await this.remove(feature, step, cleanupMode === "worktree+branch");
         return {
           success: true,
           merged: true,
+          strategy,
           sha: result.commit,
-          filesChanged
+          filesChanged,
+          conflicts: [],
+          conflictState: "none",
+          cleanup
         };
       } else if (strategy === "rebase") {
         const commits = await git.log([`${currentBranch}..${branchName}`]);
@@ -22264,40 +22726,62 @@ class WorktreeService {
           await git.raw(["cherry-pick", commit.hash]);
         }
         const head = (await git.revparse(["HEAD"])).trim();
+        const cleanup = cleanupMode === "none" ? emptyCleanup : await this.remove(feature, step, cleanupMode === "worktree+branch");
         return {
           success: true,
           merged: true,
+          strategy,
           sha: head,
-          filesChanged
+          filesChanged,
+          conflicts: [],
+          conflictState: "none",
+          cleanup
         };
       } else {
         const mergeMessage = message || `hive: merge ${step}`;
         const result = await git.merge([branchName, "--no-ff", "-m", mergeMessage]);
         const head = (await git.revparse(["HEAD"])).trim();
+        const cleanup = cleanupMode === "none" ? emptyCleanup : await this.remove(feature, step, cleanupMode === "worktree+branch");
         return {
           success: true,
           merged: !result.failed,
+          strategy,
           sha: head,
           filesChanged,
-          conflicts: result.conflicts?.map((c) => c.file || String(c)) || []
+          conflicts: result.conflicts?.map((c) => c.file || String(c)) || [],
+          conflictState: "none",
+          cleanup
         };
       }
     } catch (error45) {
       const err = error45;
       if (err.message?.includes("CONFLICT") || err.message?.includes("conflict")) {
-        await git.raw(["merge", "--abort"]).catch(() => {});
-        await git.raw(["rebase", "--abort"]).catch(() => {});
-        await git.raw(["cherry-pick", "--abort"]).catch(() => {});
+        const conflicts2 = await this.getActiveConflictFiles(git, err.message || "");
+        const conflictState = preserveConflicts ? "preserved" : "aborted";
+        if (!preserveConflicts) {
+          await git.raw(["merge", "--abort"]).catch(() => {});
+          await git.raw(["rebase", "--abort"]).catch(() => {});
+          await git.raw(["cherry-pick", "--abort"]).catch(() => {});
+        }
         return {
           success: false,
           merged: false,
-          error: "Merge conflicts detected",
-          conflicts: this.parseConflictsFromError(err.message || "")
+          strategy,
+          filesChanged,
+          conflicts: conflicts2,
+          conflictState,
+          cleanup: emptyCleanup,
+          error: "Merge conflicts detected"
         };
       }
       return {
         success: false,
         merged: false,
+        strategy,
+        filesChanged,
+        conflicts: [],
+        conflictState: "none",
+        cleanup: emptyCleanup,
         error: err.message || "Merge failed"
       };
     }
@@ -22325,11 +22809,31 @@ class WorktreeService {
     }
     return conflicts2;
   }
+  async getActiveConflictFiles(git, errorMessage) {
+    try {
+      const status = await git.status();
+      if (status.conflicted.length > 0) {
+        return [...new Set(status.conflicted)];
+      }
+    } catch {}
+    return this.parseConflictsFromError(errorMessage);
+  }
 }
 // ../hive-core/src/services/contextService.ts
 import * as fs8 from "fs";
 import * as path6 from "path";
 var RESERVED_OVERVIEW_CONTEXT = "overview";
+var DEFAULT_CONTEXT_CLASSIFICATION = {
+  role: "durable",
+  includeInExecution: true,
+  includeInAgentsMdSync: true,
+  includeInNetwork: true
+};
+var SPECIAL_CONTEXTS = {
+  overview: { role: "human", includeInExecution: false, includeInAgentsMdSync: false, includeInNetwork: false },
+  draft: { role: "scratchpad", includeInExecution: false, includeInAgentsMdSync: false, includeInNetwork: false },
+  "execution-decisions": { role: "operational", includeInExecution: false, includeInAgentsMdSync: false, includeInNetwork: false }
+};
 
 class ContextService {
   projectRoot;
@@ -22358,15 +22862,18 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     if (!fileExists(contextPath))
       return [];
-    const files = fs8.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
+    const files = fs8.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name).sort((a, b) => a.localeCompare(b));
     return files.map((name) => {
       const filePath = path6.join(contextPath, name);
       const stat2 = fs8.statSync(filePath);
       const content = readText(filePath) || "";
+      const normalizedName = name.replace(/\.md$/, "");
+      const classification = this.classifyContextName(normalizedName);
       return {
-        name: name.replace(/\.md$/, ""),
+        name: normalizedName,
         content,
-        updatedAt: stat2.mtime.toISOString()
+        updatedAt: stat2.mtime.toISOString(),
+        ...classification
       };
     });
   }
@@ -22374,7 +22881,13 @@ class ContextService {
     return this.list(featureName).find((file2) => file2.name === RESERVED_OVERVIEW_CONTEXT) ?? null;
   }
   listExecutionContext(featureName) {
-    return this.list(featureName).filter((file2) => file2.name !== RESERVED_OVERVIEW_CONTEXT);
+    return this.list(featureName).filter((file2) => file2.includeInExecution);
+  }
+  listAgentsMdSyncContext(featureName) {
+    return this.list(featureName).filter((file2) => file2.includeInAgentsMdSync);
+  }
+  listNetworkContext(featureName) {
+    return this.list(featureName).filter((file2) => file2.includeInNetwork);
   }
   delete(featureName, fileName) {
     const contextPath = getContextPath(this.projectRoot, featureName);
@@ -22433,10 +22946,101 @@ ${f.content}`);
     const normalized = name.replace(/\.md$/, "");
     return `${normalized}.md`;
   }
+  classifyContextName(name) {
+    return SPECIAL_CONTEXTS[name] ?? DEFAULT_CONTEXT_CLASSIFICATION;
+  }
 }
-// ../hive-core/src/services/sessionService.ts
+// ../hive-core/src/services/networkService.ts
 import * as fs9 from "fs";
 import * as path7 from "path";
+class NetworkService {
+  projectRoot;
+  contextService;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.contextService = new ContextService(projectRoot);
+  }
+  query(options) {
+    const normalizedQuery = normalizeText(options.query);
+    if (!normalizedQuery) {
+      return [];
+    }
+    const matchingFeatures = listFeatureDirectories(this.projectRoot).map((entry) => entry.logicalName).filter((featureName) => featureName !== options.currentFeature).sort((left, right) => left.localeCompare(right)).map((featureName) => ({
+      featureName,
+      matches: this.collectMatches(featureName, normalizedQuery, options)
+    })).filter((entry) => entry.matches.length > 0).slice(0, options.maxFeatures);
+    return matchingFeatures.flatMap((entry) => entry.matches);
+  }
+  collectMatches(featureName, normalizedQuery, options) {
+    const candidates = [];
+    const planMatch = this.matchPlan(featureName, normalizedQuery, options.maxSnippetChars);
+    if (planMatch) {
+      candidates.push(planMatch);
+    }
+    const contextMatches = this.contextService.listNetworkContext(featureName).sort((left, right) => left.name.localeCompare(right.name)).map((contextFile) => this.matchContext(featureName, contextFile, normalizedQuery, options.maxSnippetChars)).filter((result) => result !== null);
+    candidates.push(...contextMatches);
+    return candidates.sort((left, right) => {
+      if (left.sortRank !== right.sortRank) {
+        return left.sortRank - right.sortRank;
+      }
+      return left.sourceName.localeCompare(right.sourceName);
+    }).slice(0, options.maxSnippetsPerFeature).map(({ sortRank: _sortRank, ...result }) => result);
+  }
+  matchPlan(featureName, normalizedQuery, maxSnippetChars) {
+    const planPath = getPlanPath(this.projectRoot, featureName);
+    const content = readText(planPath);
+    if (content === null) {
+      return null;
+    }
+    const snippet = extractSnippet(content, normalizedQuery, maxSnippetChars);
+    if (!snippet) {
+      return null;
+    }
+    const stat2 = fs9.statSync(planPath);
+    return {
+      feature: featureName,
+      sourceType: "plan",
+      sourceName: "plan.md",
+      path: planPath,
+      updatedAt: stat2.mtime.toISOString(),
+      snippet,
+      sortRank: 0
+    };
+  }
+  matchContext(featureName, contextFile, normalizedQuery, maxSnippetChars) {
+    const snippet = extractSnippet(contextFile.content, normalizedQuery, maxSnippetChars);
+    if (!snippet) {
+      return null;
+    }
+    return {
+      feature: featureName,
+      sourceType: "context",
+      sourceName: contextFile.name,
+      path: path7.join(this.projectRoot, ".hive", "features", this.resolveDirectoryName(featureName), "context", `${contextFile.name}.md`),
+      updatedAt: contextFile.updatedAt,
+      snippet,
+      sortRank: 1
+    };
+  }
+  resolveDirectoryName(featureName) {
+    const match = listFeatureDirectories(this.projectRoot).find((entry) => entry.logicalName === featureName);
+    return match?.directoryName ?? featureName;
+  }
+}
+function normalizeText(value) {
+  return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function extractSnippet(content, normalizedQuery, maxSnippetChars) {
+  const normalizedContent = content.replace(/\s+/g, " ").trim();
+  const matchIndex = normalizedContent.toLowerCase().indexOf(normalizedQuery);
+  if (matchIndex === -1) {
+    return null;
+  }
+  return normalizedContent.slice(matchIndex, matchIndex + maxSnippetChars).trim();
+}
+// ../hive-core/src/services/sessionService.ts
+import * as fs10 from "fs";
+import * as path8 from "path";
 class SessionService {
   projectRoot;
   constructor(projectRoot) {
@@ -22447,10 +23051,14 @@ class SessionService {
       return;
     }
     const { sessionId: _sessionId, ...rest } = patch;
-    Object.assign(target, rest);
+    for (const [key, value] of Object.entries(rest)) {
+      if (value !== undefined || key === "directiveRecoveryState") {
+        target[key] = value;
+      }
+    }
   }
   getSessionsPath(featureName) {
-    return path7.join(getFeaturePath(this.projectRoot, featureName), "sessions.json");
+    return path8.join(getFeaturePath(this.projectRoot, featureName), "sessions.json");
   }
   getSessions(featureName) {
     const sessionsPath = this.getSessionsPath(featureName);
@@ -22458,7 +23066,7 @@ class SessionService {
   }
   saveSessions(featureName, data) {
     const sessionsPath = this.getSessionsPath(featureName);
-    ensureDir(path7.dirname(sessionsPath));
+    ensureDir(path8.dirname(sessionsPath));
     writeJson(sessionsPath, data);
   }
   getGlobalSessions() {
@@ -22467,12 +23075,12 @@ class SessionService {
   }
   saveGlobalSessions(data) {
     const globalPath = getGlobalSessionsPath(this.projectRoot);
-    ensureDir(path7.dirname(globalPath));
+    ensureDir(path8.dirname(globalPath));
     writeJson(globalPath, data);
   }
   updateGlobalSessions(mutator) {
     const globalPath = getGlobalSessionsPath(this.projectRoot);
-    ensureDir(path7.dirname(globalPath));
+    ensureDir(path8.dirname(globalPath));
     const release = acquireLockSync(globalPath);
     try {
       const data = readJson(globalPath) || { sessions: [] };
@@ -22590,10 +23198,10 @@ class SessionService {
     if (globalSession?.featureName) {
       return globalSession.featureName;
     }
-    const featuresPath = path7.join(this.projectRoot, ".hive", "features");
-    if (!fs9.existsSync(featuresPath))
+    const featuresPath = path8.join(this.projectRoot, ".hive", "features");
+    if (!fs10.existsSync(featuresPath))
       return null;
-    const features = fs9.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const features = fs10.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
     for (const feature of features) {
       const sessions = this.getSessions(feature);
       if (sessions.sessions.some((s) => s.sessionId === sessionId)) {
@@ -22635,16 +23243,26 @@ class SessionService {
   }
 }
 // ../hive-core/src/services/configService.ts
-import * as fs10 from "fs";
-import * as path8 from "path";
+import * as fs11 from "fs";
+import * as path9 from "path";
 class ConfigService {
   configPath;
+  projectConfigPath;
+  legacyProjectConfigPath;
   cachedConfig = null;
   cachedCustomAgentConfigs = null;
-  constructor() {
+  activeReadSourceType = "global";
+  activeReadPath;
+  lastFallbackWarning = null;
+  constructor(projectRoot) {
     const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-    const configDir = path8.join(homeDir, ".config", "opencode");
-    this.configPath = path8.join(configDir, "agent_hive.json");
+    const configDir = path9.join(homeDir, ".config", "opencode");
+    this.configPath = path9.join(configDir, "agent_hive.json");
+    this.activeReadPath = this.configPath;
+    if (projectRoot) {
+      this.projectConfigPath = path9.join(projectRoot, ".hive", "agent-hive.json");
+      this.legacyProjectConfigPath = path9.join(projectRoot, ".opencode", "agent_hive.json");
+    }
   }
   getPath() {
     return this.configPath;
@@ -22653,43 +23271,88 @@ class ConfigService {
     if (this.cachedConfig !== null) {
       return this.cachedConfig;
     }
-    try {
-      if (!fs10.existsSync(this.configPath)) {
-        this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
-        this.cachedCustomAgentConfigs = null;
+    if (this.projectConfigPath && fs11.existsSync(this.projectConfigPath)) {
+      const projectStored = this.readStoredConfig(this.projectConfigPath);
+      if (projectStored.ok) {
+        this.activeReadSourceType = "project";
+        this.activeReadPath = this.projectConfigPath;
+        this.lastFallbackWarning = null;
+        this.cachedConfig = this.mergeWithDefaults(projectStored.value);
         return this.cachedConfig;
       }
-      const raw = fs10.readFileSync(this.configPath, "utf-8");
-      const stored = JSON.parse(raw);
-      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,
-          ...mergedBuiltInAgents
-        },
-        customAgents: {
-          ...DEFAULT_HIVE_CONFIG.customAgents,
-          ...storedCustomAgents
-        }
-      };
-      this.cachedConfig = merged;
+      const fallbackReason2 = "reason" in projectStored ? projectStored.reason : "read_error";
+      this.lastFallbackWarning = this.createProjectFallbackWarning(this.projectConfigPath, fallbackReason2);
+    } else if (this.legacyProjectConfigPath && fs11.existsSync(this.legacyProjectConfigPath)) {
+      const projectStored = this.readStoredConfig(this.legacyProjectConfigPath);
+      if (projectStored.ok) {
+        this.activeReadSourceType = "project";
+        this.activeReadPath = this.legacyProjectConfigPath;
+        this.lastFallbackWarning = null;
+        this.cachedConfig = this.mergeWithDefaults(projectStored.value);
+        return this.cachedConfig;
+      }
+      const fallbackReason2 = "reason" in projectStored ? projectStored.reason : "read_error";
+      this.lastFallbackWarning = this.createProjectFallbackWarning(this.legacyProjectConfigPath, fallbackReason2);
+    }
+    if (!this.projectConfigPath && !this.legacyProjectConfigPath) {
+      this.lastFallbackWarning = null;
+    }
+    if (!fs11.existsSync(this.configPath)) {
+      this.activeReadSourceType = "global";
+      this.activeReadPath = this.configPath;
+      this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
       this.cachedCustomAgentConfigs = null;
+      if (this.lastFallbackWarning && this.lastFallbackWarning.fallbackType !== "defaults") {
+        this.lastFallbackWarning = {
+          message: `Failed to read project config at ${this.lastFallbackWarning.sourcePath}; global config at ${this.configPath} is missing; using defaults`,
+          sourceType: this.lastFallbackWarning.sourceType,
+          sourcePath: this.lastFallbackWarning.sourcePath,
+          fallbackType: "defaults",
+          reason: this.lastFallbackWarning.reason
+        };
+      }
       return this.cachedConfig;
-    } catch {
-      this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
+    }
+    const globalStored = this.readStoredConfig(this.configPath);
+    if (globalStored.ok) {
+      this.activeReadSourceType = "global";
+      this.activeReadPath = this.configPath;
+      this.cachedConfig = this.mergeWithDefaults(globalStored.value);
       this.cachedCustomAgentConfigs = null;
       return this.cachedConfig;
     }
+    const fallbackReason = "reason" in globalStored ? globalStored.reason : "read_error";
+    this.activeReadSourceType = "global";
+    this.activeReadPath = this.configPath;
+    this.cachedConfig = { ...DEFAULT_HIVE_CONFIG };
+    this.cachedCustomAgentConfigs = null;
+    if (this.lastFallbackWarning) {
+      this.lastFallbackWarning = {
+        message: `Failed to read project config at ${this.lastFallbackWarning.sourcePath}; global config at ${this.configPath} is also invalid; using defaults`,
+        sourceType: this.lastFallbackWarning.sourceType,
+        sourcePath: this.lastFallbackWarning.sourcePath,
+        fallbackType: "defaults",
+        reason: this.lastFallbackWarning.reason
+      };
+      return this.cachedConfig;
+    }
+    this.lastFallbackWarning = {
+      message: `Failed to read global config at ${this.configPath}; using defaults`,
+      sourceType: "global",
+      sourcePath: this.configPath,
+      fallbackType: "defaults",
+      reason: fallbackReason
+    };
+    return this.cachedConfig;
+  }
+  getActiveReadSourceType() {
+    return this.activeReadSourceType;
+  }
+  getActiveReadPath() {
+    return this.activeReadPath;
+  }
+  getLastFallbackWarning() {
+    return this.lastFallbackWarning;
   }
   set(updates) {
     this.cachedConfig = null;
@@ -22707,30 +23370,34 @@ class ConfigService {
         ...updates.customAgents
       } : current.customAgents
     };
-    const configDir = path8.dirname(this.configPath);
-    if (!fs10.existsSync(configDir)) {
-      fs10.mkdirSync(configDir, { recursive: true });
+    const configDir = path9.dirname(this.configPath);
+    if (!fs11.existsSync(configDir)) {
+      fs11.mkdirSync(configDir, { recursive: true });
     }
-    fs10.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+    fs11.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
     this.cachedConfig = merged;
     this.cachedCustomAgentConfigs = null;
     return merged;
   }
   exists() {
-    return fs10.existsSync(this.configPath);
+    return fs11.existsSync(this.configPath);
   }
   init() {
+    const resolved = this.get();
+    if (this.projectConfigPath || this.legacyProjectConfigPath) {
+      return resolved;
+    }
     if (!this.exists()) {
       return this.set(DEFAULT_HIVE_CONFIG);
     }
-    return this.get();
+    return resolved;
   }
   getAgentConfig(agent) {
     const config2 = this.get();
     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));
+      const effectiveAutoLoadSkills = agent === "hive-helper" ? defaultAutoLoadSkills : this.resolveAutoLoadSkills(defaultAutoLoadSkills, agentConfig.autoLoadSkills ?? [], this.isPlannerAgent(agent));
       return {
         ...agentConfig,
         autoLoadSkills: effectiveAutoLoadSkills
@@ -22851,10 +23518,139 @@ class ConfigService {
     }
     return configuredCadence;
   }
+  readStoredConfig(configPath) {
+    try {
+      const raw = fs11.readFileSync(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return { ok: false, reason: "validation_error" };
+      }
+      if (!this.isValidStoredConfig(parsed)) {
+        return { ok: false, reason: "validation_error" };
+      }
+      return { ok: true, value: parsed };
+    } catch (error45) {
+      if (error45 instanceof SyntaxError) {
+        return { ok: false, reason: "parse_error" };
+      }
+      return { ok: false, reason: "read_error" };
+    }
+  }
+  mergeWithDefaults(stored) {
+    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;
+    }, {});
+    return {
+      ...DEFAULT_HIVE_CONFIG,
+      ...stored,
+      agents: {
+        ...DEFAULT_HIVE_CONFIG.agents,
+        ...stored.agents,
+        ...mergedBuiltInAgents
+      },
+      customAgents: {
+        ...DEFAULT_HIVE_CONFIG.customAgents,
+        ...storedCustomAgents
+      }
+    };
+  }
+  createProjectFallbackWarning(projectConfigPath, reason) {
+    return {
+      message: `Failed to read project config at ${projectConfigPath}; using global config at ${this.configPath}`,
+      sourceType: "project",
+      sourcePath: projectConfigPath,
+      fallbackType: "global",
+      fallbackPath: this.configPath,
+      reason
+    };
+  }
+  isValidStoredConfig(value) {
+    if (!this.isObjectRecord(value)) {
+      return false;
+    }
+    const config2 = value;
+    if (config2.$schema !== undefined && typeof config2.$schema !== "string") {
+      return false;
+    }
+    if (config2.enableToolsFor !== undefined && !this.isStringArray(config2.enableToolsFor)) {
+      return false;
+    }
+    if (config2.disableSkills !== undefined && !this.isStringArray(config2.disableSkills)) {
+      return false;
+    }
+    if (config2.disableMcps !== undefined && !this.isStringArray(config2.disableMcps)) {
+      return false;
+    }
+    if (config2.omoSlimEnabled !== undefined && typeof config2.omoSlimEnabled !== "boolean") {
+      return false;
+    }
+    if (config2.agentMode !== undefined && config2.agentMode !== "unified" && config2.agentMode !== "dedicated") {
+      return false;
+    }
+    if (config2.agents !== undefined && !this.isObjectRecord(config2.agents)) {
+      return false;
+    }
+    if (this.isObjectRecord(config2.agents)) {
+      for (const declaration of Object.values(config2.agents)) {
+        if (!this.isValidAgentConfigDeclaration(declaration)) {
+          return false;
+        }
+      }
+    }
+    if (config2.sandbox !== undefined && config2.sandbox !== "none" && config2.sandbox !== "docker") {
+      return false;
+    }
+    if (config2.dockerImage !== undefined && typeof config2.dockerImage !== "string") {
+      return false;
+    }
+    if (config2.persistentContainers !== undefined && typeof config2.persistentContainers !== "boolean") {
+      return false;
+    }
+    if (config2.hook_cadence !== undefined && !this.isHookCadenceRecord(config2.hook_cadence)) {
+      return false;
+    }
+    return true;
+  }
+  isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+  }
+  isValidAgentConfigDeclaration(value) {
+    if (!this.isObjectRecord(value)) {
+      return false;
+    }
+    const declaration = value;
+    if (declaration.model !== undefined && typeof declaration.model !== "string") {
+      return false;
+    }
+    if (declaration.temperature !== undefined && typeof declaration.temperature !== "number") {
+      return false;
+    }
+    if (declaration.skills !== undefined && !this.isStringArray(declaration.skills)) {
+      return false;
+    }
+    if (declaration.autoLoadSkills !== undefined && !this.isStringArray(declaration.autoLoadSkills)) {
+      return false;
+    }
+    if (declaration.variant !== undefined && typeof declaration.variant !== "string") {
+      return false;
+    }
+    return true;
+  }
+  isHookCadenceRecord(value) {
+    if (!this.isObjectRecord(value)) {
+      return false;
+    }
+    return Object.values(value).every((entry) => typeof entry === "number");
+  }
 }
 // ../hive-core/src/services/agentsMdService.ts
-import * as fs11 from "fs";
-import * as path9 from "path";
+import * as fs12 from "fs";
+import * as path10 from "path";
 class AgentsMdService {
   rootDir;
   contextService;
@@ -22863,7 +23659,7 @@ class AgentsMdService {
     this.contextService = contextService;
   }
   async init() {
-    const agentsMdPath = path9.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path10.join(this.rootDir, "AGENTS.md");
     const existed = fileExists(agentsMdPath);
     if (existed) {
       const existing = readText(agentsMdPath);
@@ -22873,15 +23669,15 @@ class AgentsMdService {
     return { content, existed: false };
   }
   async sync(featureName) {
-    const contexts = this.contextService.list(featureName);
-    const agentsMdPath = path9.join(this.rootDir, "AGENTS.md");
-    const current = await fs11.promises.readFile(agentsMdPath, "utf-8").catch(() => "");
+    const contexts = this.contextService.listAgentsMdSyncContext(featureName);
+    const agentsMdPath = path10.join(this.rootDir, "AGENTS.md");
+    const current = await fs12.promises.readFile(agentsMdPath, "utf-8").catch(() => "");
     const findings = this.extractFindings(contexts);
     const proposals = this.generateProposals(findings, current);
     return { proposals, diff: this.formatDiff(current, proposals) };
   }
   apply(content) {
-    const agentsMdPath = path9.join(this.rootDir, "AGENTS.md");
+    const agentsMdPath = path10.join(this.rootDir, "AGENTS.md");
     const isNew = !fileExists(agentsMdPath);
     writeText(agentsMdPath, content);
     return { path: agentsMdPath, chars: content.length, isNew };
@@ -22941,7 +23737,7 @@ class AgentsMdService {
     return this.generateTemplate(detections);
   }
   async detectProjectInfo() {
-    const packageJsonPath = path9.join(this.rootDir, "package.json");
+    const packageJsonPath = path10.join(this.rootDir, "package.json");
     let packageJson = null;
     if (fileExists(packageJsonPath)) {
       try {
@@ -22961,26 +23757,26 @@ class AgentsMdService {
     return info;
   }
   detectPackageManager() {
-    if (fileExists(path9.join(this.rootDir, "bun.lockb")))
+    if (fileExists(path10.join(this.rootDir, "bun.lockb")))
       return "bun";
-    if (fileExists(path9.join(this.rootDir, "pnpm-lock.yaml")))
+    if (fileExists(path10.join(this.rootDir, "pnpm-lock.yaml")))
       return "pnpm";
-    if (fileExists(path9.join(this.rootDir, "yarn.lock")))
+    if (fileExists(path10.join(this.rootDir, "yarn.lock")))
       return "yarn";
-    if (fileExists(path9.join(this.rootDir, "package-lock.json")))
+    if (fileExists(path10.join(this.rootDir, "package-lock.json")))
       return "npm";
     return "npm";
   }
   detectLanguage() {
-    if (fileExists(path9.join(this.rootDir, "tsconfig.json")))
+    if (fileExists(path10.join(this.rootDir, "tsconfig.json")))
       return "TypeScript";
-    if (fileExists(path9.join(this.rootDir, "package.json")))
+    if (fileExists(path10.join(this.rootDir, "package.json")))
       return "JavaScript";
-    if (fileExists(path9.join(this.rootDir, "requirements.txt")))
+    if (fileExists(path10.join(this.rootDir, "requirements.txt")))
       return "Python";
-    if (fileExists(path9.join(this.rootDir, "go.mod")))
+    if (fileExists(path10.join(this.rootDir, "go.mod")))
       return "Go";
-    if (fileExists(path9.join(this.rootDir, "Cargo.toml")))
+    if (fileExists(path10.join(this.rootDir, "Cargo.toml")))
       return "Rust";
     return "Unknown";
   }
@@ -23060,24 +23856,24 @@ class AgentsMdService {
 }
 // ../hive-core/src/services/dockerSandboxService.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join10, sep } from "path";
+import { join as join11, sep } from "path";
 import { execSync } from "child_process";
 
 class DockerSandboxService {
   static detectImage(worktreePath) {
-    if (existsSync5(join10(worktreePath, "Dockerfile"))) {
+    if (existsSync5(join11(worktreePath, "Dockerfile"))) {
       return null;
     }
-    if (existsSync5(join10(worktreePath, "package.json"))) {
+    if (existsSync5(join11(worktreePath, "package.json"))) {
       return "node:22-slim";
     }
-    if (existsSync5(join10(worktreePath, "requirements.txt")) || existsSync5(join10(worktreePath, "pyproject.toml"))) {
+    if (existsSync5(join11(worktreePath, "requirements.txt")) || existsSync5(join11(worktreePath, "pyproject.toml"))) {
       return "python:3.12-slim";
     }
-    if (existsSync5(join10(worktreePath, "go.mod"))) {
+    if (existsSync5(join11(worktreePath, "go.mod"))) {
       return "golang:1.22-slim";
     }
-    if (existsSync5(join10(worktreePath, "Cargo.toml"))) {
+    if (existsSync5(join11(worktreePath, "Cargo.toml"))) {
       return "rust:1.77-slim";
     }
     return "ubuntu:24.04";
@@ -23261,11 +24057,31 @@ ${spec}
 Before writing code, confirm:
 1. Dependencies are satisfied and required context is present.
 2. The exact files/sections to touch (from references) are identified.
-3. The first failing test to write is clear (TDD).
+3. The verification path is clear: a failing test for new behavior, or the existing coverage to keep green for refactor-only work.
 4. The minimal change needed to reach green is planned.
 
 ---
 
+## TDD Protocol (Required)
+
+1. **Red**: Write failing test first
+2. **Green**: Minimal code to pass
+3. **Refactor**: Clean up, keep tests green
+
+When adding new behavior, write the test before the implementation.
+When refactoring existing tested code, keep tests green throughout; no new failing test is required.
+
+## Debugging Protocol (When stuck)
+
+1. **Reproduce**: Get consistent failure
+2. **Isolate**: Binary search to find cause
+3. **Hypothesize**: Form theory, test it
+4. **Fix**: Minimal change that resolves
+
+After 3 failed attempts at same fix: STOP and report blocker.
+
+---
+
 ## Blocker Protocol
 
 If you hit a blocker requiring human decision, **DO NOT** use the question tool directly.
@@ -23300,6 +24116,24 @@ This keeps the user focused on ONE conversation (Hive Master) instead of multipl
 
 ---
 
+## Verification Evidence
+
+Before claiming completion, verify your work with command-first evidence proportional to the change type:
+
+| Change type | Required verification |
+|---|---|
+| New behavior | Run tests covering the new code; record pass/fail counts |
+| Bug fix | Reproduce the original failure, then confirm the fix |
+| Refactor | Run existing tests; confirm no regressions |
+| Prompt / text-only | Run relevant local tests if available; otherwise do file-specific sanity checks such as generation, syntax/parse, or conflict-marker scans |
+
+**Rules:**
+- Run the command, then record observed output. Do not substitute explanation for execution.
+- If a check cannot be run (missing deps, no test runner in worktree), explicitly state "Not run: <reason>" instead of omitting it silently.
+- command-first means: execute first, interpret second. Never claim a result you have not observed.
+
+---
+
 ## Completion Protocol
 
 When your task is **fully complete**:
@@ -23323,10 +24157,10 @@ Optional body"
 - Do not provide message with hive_merge(..., strategy: 'rebase').
 
 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\`
+- If \`terminal=true\` (regardless of \`ok\`): stop immediately. This call is final and must not be retried with the same parameters.
+- If \`terminal=false\`: **DO NOT STOP**. Follow \`nextAction\`, remediate, and retry \`hive_worktree_commit\`
 
-**CRITICAL: Stop only on terminal commit result (ok=true and terminal=true).**
+**CRITICAL: Any terminal commit result is final for this call.**
 If commit returns non-terminal (for example verification_required), DO NOT STOP.
 Follow result.nextAction, fix the issue, and call hive_worktree_commit again.
 
@@ -23364,26 +24198,6 @@ hive_worktree_commit({
 
 ---
 
-## TDD Protocol (Required)
-
-1. **Red**: Write failing test first
-2. **Green**: Minimal code to pass
-3. **Refactor**: Clean up, keep tests green
-
-Never write implementation before test exists.
-Exception: Pure refactoring of existing tested code.
-
-## Debugging Protocol (When stuck)
-
-1. **Reproduce**: Get consistent failure
-2. **Isolate**: Binary search to find cause
-3. **Hypothesize**: Form theory, test it
-4. **Fix**: Minimal change that resolves
-
-After 3 failed attempts at same fix: STOP and report blocker.
-
----
-
 ## Tool Access
 
 **You have access to:**
@@ -23396,8 +24210,8 @@ After 3 failed attempts at same fix: STOP and report blocker.
 **You do NOT have access to (or should not use):**
 - \`question\` - Escalate via blocker protocol instead
 - \`hive_worktree_create\` - No spawning sub-workers
-- \`hive_merge\` - Only Hive Master merges
-- \`task\` - No recursive delegation
+- \`hive_merge\` - Only Hive/Swarm or delegated \`hive-helper\` merges; ordinary task workers must not merge or handle merge/wrap-up operational flows
+- \`task\` - No recursive delegation; only Hive/Swarm may delegate \`hive-helper\` for merge/wrap-up operational flows
 
 ---
 
@@ -23411,10 +24225,6 @@ After 3 failed attempts at same fix: STOP and report blocker.
 
 ---
 
-**User Input:** ALWAYS use \`question()\` tool for any user input - NEVER ask questions via plain text. This ensures structured responses.
-
----
-
 Begin your task now.
 `;
 }
@@ -23647,17 +24457,17 @@ function applyContextBudget(files, config2 = {}) {
 }
 
 // src/utils/prompt-file.ts
-import * as fs12 from "fs";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as path11 from "path";
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
-  const projectRoot = path10.dirname(hiveDir);
+  const projectRoot = path11.dirname(hiveDir);
   const featureDir = resolveFeatureDirectoryName(projectRoot, feature);
-  const promptDir = path10.join(hiveDir, "features", featureDir, "tasks", task);
-  const promptPath = path10.join(promptDir, "worker-prompt.md");
-  if (!fs12.existsSync(promptDir)) {
-    fs12.mkdirSync(promptDir, { recursive: true });
+  const promptDir = path11.join(hiveDir, "features", featureDir, "tasks", task);
+  const promptPath = path11.join(promptDir, "worker-prompt.md");
+  if (!fs13.existsSync(promptDir)) {
+    fs13.mkdirSync(promptDir, { recursive: true });
   }
-  fs12.writeFileSync(promptPath, prompt, "utf-8");
+  fs13.writeFileSync(promptPath, prompt, "utf-8");
   return promptPath;
 }
 
@@ -23674,6 +24484,7 @@ var BUILT_IN_AGENTS = {
   "swarm-orchestrator": { sessionKind: "primary", baseAgent: "swarm-orchestrator" },
   "forager-worker": { sessionKind: "task-worker", baseAgent: "forager-worker" },
   "scout-researcher": { sessionKind: "subagent", baseAgent: "scout-researcher" },
+  "hive-helper": { sessionKind: "subagent", baseAgent: "hive-helper" },
   "hygienic-reviewer": { sessionKind: "subagent", baseAgent: "hygienic-reviewer" }
 };
 var BASE_AGENT_KIND = {
@@ -23743,70 +24554,37 @@ var HIVE_SYSTEM_PROMPT = `
 Use hive_merge to integrate changes into the current branch.
 `;
 
-// src/utils/compaction-anchor.ts
-var AGENT_ROLE_MAP = {
-  "hive-master": "Hive",
-  "architect-planner": "Architect",
-  "swarm-orchestrator": "Swarm",
-  "forager-worker": "Forager",
-  "scout-researcher": "Scout",
-  "hygienic-reviewer": "Hygienic"
-};
-var BASE_AGENT_ROLE_MAP = {
-  "forager-worker": "Forager",
-  "hygienic-reviewer": "Hygienic",
-  "scout-researcher": "Scout"
-};
-function resolveRole(ctx) {
-  if (ctx.agent && AGENT_ROLE_MAP[ctx.agent]) {
-    return AGENT_ROLE_MAP[ctx.agent];
-  }
-  if (ctx.baseAgent && BASE_AGENT_ROLE_MAP[ctx.baseAgent]) {
-    return BASE_AGENT_ROLE_MAP[ctx.baseAgent];
-  }
-  return;
-}
-function resolveWorkerPromptPath(ctx) {
-  if (ctx.workerPromptPath) {
-    return ctx.workerPromptPath;
-  }
-  if (ctx.featureName && ctx.taskFolder) {
-    return `.hive/features/${ctx.featureName}/tasks/${ctx.taskFolder}/worker-prompt.md`;
-  }
-  return;
-}
-function buildCompactionReanchor(ctx) {
-  const role = resolveRole(ctx);
-  const kind = ctx.sessionKind ?? "unknown";
-  const workerPromptPath = resolveWorkerPromptPath(ctx);
-  const lines = [];
-  const context = [];
-  lines.push("Compaction recovery — you were compacted mid-session.");
-  if (role) {
-    lines.push(`Role: ${role}`);
-  }
-  lines.push("Do not switch roles.");
-  lines.push("Do not call status tools to rediscover state.");
-  lines.push("Do not re-read the full codebase.");
-  if (kind === "task-worker") {
-    lines.push("Do not delegate.");
-    if (workerPromptPath) {
-      lines.push("Re-read worker-prompt.md now to recall your assignment.");
-      context.push(workerPromptPath);
-    } else {
-      lines.push("Re-read worker-prompt.md from the Hive task metadata to recall your assignment.");
-    }
-  }
-  if ((kind === "primary" || kind === "subagent") && ctx.directivePrompt) {
-    lines.push("Original directive survives via post-compaction replay.");
+// src/utils/plugin-manifest.ts
+import * as path12 from "path";
+import { fileURLToPath } from "url";
+var HIVE_COMMANDS = [
+  {
+    key: "hive",
+    name: "/hive",
+    description: "Create a new feature: /hive <feature-name>"
   }
-  lines.push("Next action: resume from where you left off.");
-  return {
-    prompt: lines.join(`
-`),
-    context
-  };
-}
+];
+var HIVE_TOOL_NAMES = [
+  "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_network_query",
+  "hive_status",
+  "hive_skill",
+  "hive_agents_md"
+];
+var packageRoot = path12.resolve(path12.dirname(fileURLToPath(import.meta.url)), "../..");
 
 // src/index.ts
 function formatSkillsXml(skills) {
@@ -23921,28 +24699,51 @@ No Hive skills available.` : base + formatSkillsXml(filteredSkills);
 }
 var plugin = async (ctx) => {
   const { directory, client, worktree } = ctx;
+  const emitConfigWarning = (message) => {
+    const prefixedMessage = `[hive:config] ${message}`;
+    const maybeClient = client;
+    const notified = typeof maybeClient.notify === "function" && maybeClient.notify({
+      type: "warning",
+      level: "warning",
+      title: "Agent Hive Config Warning",
+      message: prefixedMessage
+    }) || typeof maybeClient.notification?.create === "function" && maybeClient.notification.create({
+      type: "warning",
+      level: "warning",
+      title: "Agent Hive Config Warning",
+      message: prefixedMessage
+    });
+    if (!notified) {
+      console.warn(prefixedMessage);
+    }
+  };
   const featureService = new FeatureService(directory);
   const planService = new PlanService(directory);
   const taskService = new TaskService(directory);
   const contextService = new ContextService(directory);
+  const networkService = new NetworkService(directory);
   const agentsMdService = new AgentsMdService(directory, contextService);
-  const configService = new ConfigService;
+  const configService = new ConfigService(directory);
   const sessionService = new SessionService(directory);
   const disabledMcps = configService.getDisabledMcps();
   const disabledSkills = configService.getDisabledSkills();
+  const configFallbackWarning = configService.getLastFallbackWarning()?.message ?? null;
+  if (configFallbackWarning) {
+    emitConfigWarning(configFallbackWarning);
+  }
   const builtinMcps = createBuiltinMcps(disabledMcps);
   const filteredSkills = getFilteredSkills(disabledSkills);
   const effectiveAutoLoadSkills = configService.getAgentConfig("hive-master").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path11.join(directory, ".hive")
+    hiveDir: path13.join(directory, ".hive")
   });
   const customAgentConfigsForClassification = getCustomAgentConfigsCompat(configService);
   const runtimeContext = detectContext(worktree || directory);
   const taskWorkerRecovery = runtimeContext.isWorktree && runtimeContext.feature && runtimeContext.task ? {
     featureName: runtimeContext.feature,
     taskFolder: runtimeContext.task,
-    workerPromptPath: path11.posix.join(".hive", "features", resolveFeatureDirectoryName(directory, runtimeContext.feature), "tasks", runtimeContext.task, "worker-prompt.md")
+    workerPromptPath: path13.posix.join(".hive", "features", resolveFeatureDirectoryName(directory, runtimeContext.feature), "tasks", runtimeContext.task, "worker-prompt.md")
   } : undefined;
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
@@ -23990,10 +24791,12 @@ var plugin = async (ctx) => {
   const buildDirectiveReplayText = (session) => {
     if (!session.directivePrompt)
       return null;
-    const role = session.agent === "scout-researcher" || session.baseAgent === "scout-researcher" ? "Scout" : session.agent === "hygienic-reviewer" || session.baseAgent === "hygienic-reviewer" ? "Hygienic" : session.agent === "architect-planner" || session.baseAgent === "architect-planner" ? "Architect" : session.agent === "swarm-orchestrator" || session.baseAgent === "swarm-orchestrator" ? "Swarm" : session.agent === "hive-master" || session.baseAgent === "hive-master" ? "Hive" : "current role";
+    const role = session.agent === "scout-researcher" || session.baseAgent === "scout-researcher" ? "Scout" : session.agent === "hive-helper" || session.baseAgent === "hive-helper" ? "Hive Helper" : session.agent === "hygienic-reviewer" || session.baseAgent === "hygienic-reviewer" ? "Hygienic" : session.agent === "architect-planner" || session.baseAgent === "architect-planner" ? "Architect" : session.agent === "swarm-orchestrator" || session.baseAgent === "swarm-orchestrator" ? "Swarm" : session.agent === "hive-master" || session.baseAgent === "hive-master" ? "Hive" : "current role";
     return [
       `Post-compaction recovery: You are still ${role}.`,
       "Resume the original assignment below. Do not replace it with a new goal.",
+      "Do not broaden the scope or re-read the full codebase.",
+      "If the exact next step is not explicit in the original assignment, return control to the parent/orchestrator immediately instead of improvising.",
       "",
       session.directivePrompt
     ].join(`
@@ -24002,12 +24805,45 @@ var plugin = async (ctx) => {
   const shouldUseDirectiveReplay = (session) => {
     return session?.sessionKind === "primary" || session?.sessionKind === "subagent";
   };
+  const getDirectiveReplayCompactionPatch = (session) => {
+    if (!session?.directivePrompt || !shouldUseDirectiveReplay(session)) {
+      return null;
+    }
+    if (session.directiveRecoveryState === "escalated") {
+      return null;
+    }
+    if (session.directiveRecoveryState === "consumed") {
+      return {
+        directiveRecoveryState: "escalated",
+        replayDirectivePending: true
+      };
+    }
+    return {
+      directiveRecoveryState: "available",
+      replayDirectivePending: true
+    };
+  };
+  const shouldUseWorkerReplay = (session) => {
+    return session?.sessionKind === "task-worker" && !!session.featureName && !!session.taskFolder && !!session.workerPromptPath;
+  };
+  const buildWorkerReplayText = (session) => {
+    if (!session.featureName || !session.taskFolder || !session.workerPromptPath)
+      return null;
+    const role = "Forager";
+    return [
+      `Post-compaction recovery: You are still the ${role} worker for task ${session.taskFolder}.`,
+      `Resume only this task. Do not merge, do not start the next task, and do not replace this assignment with a new goal.`,
+      `Do not call orchestration tools unless the worker prompt explicitly says so.`,
+      `Re-read @${session.workerPromptPath} and continue from the existing worktree state.`
+    ].join(`
+`);
+  };
   const checkBlocked = (feature) => {
-    const fs14 = __require("fs");
+    const fs15 = __require("fs");
     const featureDir = resolveFeatureDirectoryName(directory, feature);
-    const blockedPath = path11.join(directory, ".hive", "features", featureDir, "BLOCKED");
-    if (fs14.existsSync(blockedPath)) {
-      const reason = fs14.readFileSync(blockedPath, "utf-8").trim();
+    const blockedPath = path13.join(directory, ".hive", "features", featureDir, "BLOCKED");
+    if (fs15.existsSync(blockedPath)) {
+      const reason = fs15.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
 
 ${reason || "(No reason provided)"}
@@ -24070,7 +24906,7 @@ To unblock: Remove .hive/features/${featureDir}/BLOCKED`;
     });
     const planResult = planService.read(feature);
     const allTasks = taskService.list(feature);
-    const executionContextFiles = typeof contextService.listExecutionContext === "function" ? contextService.listExecutionContext(feature) : contextService.list(feature).filter((f) => f.name !== "overview");
+    const executionContextFiles = contextService.listExecutionContext(feature);
     const rawContextFiles = executionContextFiles.map((f) => ({
       name: f.name,
       content: f.content
@@ -24094,25 +24930,31 @@ To unblock: Remove .hive/features/${featureDir}/BLOCKED`;
     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);
+    let specContent;
+    const existingManualSpec = status?.origin === "manual" ? taskService.readSpec(feature, task) : null;
+    if (existingManualSpec) {
+      specContent = existingManualSpec;
+    } else {
+      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,
@@ -24160,9 +25002,9 @@ To unblock: Remove .hive/features/${featureDir}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path11.join(directory, ".hive");
+    const hiveDir = path13.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path11.relative(directory, workerPromptPath));
+    const relativePromptPath = normalizePath(path13.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}`;
@@ -24412,9 +25254,13 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       return respond({
         success: false,
         terminal: true,
+        reason: "task_not_blocked",
+        canRetry: false,
+        retryReason: `Task is in ${taskInfo.status} state. Run hive_status() and follow the current status flow instead of blocked resume.`,
         error: `continueFrom: 'blocked' was specified but task "${task}" is not in blocked state (current status: ${taskInfo.status}).`,
         currentStatus: taskInfo.status,
         hints: [
+          "This blocked-resume call cannot be retried with the same parameters.",
           "Use hive_worktree_start({ feature, task }) for normal starts or re-dispatch.",
           "Use hive_status to verify the current task status before retrying."
         ]
@@ -24449,63 +25295,15 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       }
       const sessionID = input.event.properties.sessionID;
       const existing = sessionService.getGlobal(sessionID);
-      if (!existing?.directivePrompt || !shouldUseDirectiveReplay(existing)) {
+      const directiveReplayPatch = getDirectiveReplayCompactionPatch(existing);
+      if (directiveReplayPatch) {
+        sessionService.trackGlobal(sessionID, directiveReplayPatch);
         return;
       }
-      sessionService.trackGlobal(sessionID, { replayDirectivePending: true });
-    },
-    "experimental.chat.system.transform": async (input, output) => {
-      if (!shouldExecuteHook("experimental.chat.system.transform", configService, turnCounters)) {
+      if (shouldUseWorkerReplay(existing)) {
+        sessionService.trackGlobal(sessionID, { replayDirectivePending: true });
         return;
       }
-      output.system.push(HIVE_SYSTEM_PROMPT);
-      const activeFeature = resolveFeature();
-      if (activeFeature) {
-        const info = featureService.getInfo(activeFeature);
-        if (info) {
-          const featureInfo = info;
-          let statusHint = `
-### Current Hive Status
-`;
-          statusHint += `**Active Feature**: ${info.name} (${info.status})
-`;
-          statusHint += `**Progress**: ${info.tasks.filter((t) => t.status === "done").length}/${info.tasks.length} tasks
-`;
-          if (featureInfo.hasOverview) {
-            statusHint += `**Overview**: available at .hive/features/${resolveFeatureDirectoryName(directory, info.name)}/context/overview.md (primary human-facing doc)
-`;
-          } else if (info.hasPlan) {
-            statusHint += `**Overview**: missing - write it with hive_context_write({ name: "overview", content })
-`;
-          }
-          if (info.commentCount > 0) {
-            statusHint += `**Comments**: ${info.commentCount} unresolved (plan: ${featureInfo.reviewCounts?.plan ?? 0}, overview: ${featureInfo.reviewCounts?.overview ?? 0})
-`;
-          }
-          output.system.push(statusHint);
-        }
-      }
-    },
-    "experimental.session.compacting": async (_input, output) => {
-      const session = sessionService.getGlobal(_input.sessionID);
-      if (session) {
-        const ctx2 = {
-          agent: session.agent,
-          baseAgent: session.baseAgent,
-          sessionKind: session.sessionKind,
-          featureName: session.featureName,
-          taskFolder: session.taskFolder,
-          workerPromptPath: session.workerPromptPath,
-          directivePrompt: session.directivePrompt
-        };
-        const reanchor = buildCompactionReanchor(ctx2);
-        output.prompt = reanchor.prompt;
-        output.context.push(...reanchor.context);
-      } else {
-        const reanchor = buildCompactionReanchor({});
-        output.prompt = reanchor.prompt;
-        output.context.push(...reanchor.context);
-      }
     },
     "chat.message": createVariantHook(configService, sessionService, customAgentConfigsForClassification, taskWorkerRecovery),
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -24526,14 +25324,47 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
 `);
         const existingDirective = session?.directivePrompt;
         if (directiveText && directiveText !== existingDirective && shouldUseDirectiveReplay(session ?? { sessionKind: "subagent" })) {
-          sessionService.trackGlobal(sessionID, { directivePrompt: directiveText });
+          sessionService.trackGlobal(sessionID, {
+            directivePrompt: directiveText,
+            directiveRecoveryState: undefined,
+            replayDirectivePending: false
+          });
         }
       }
       const refreshed = sessionService.getGlobal(sessionID);
-      if (!refreshed?.replayDirectivePending || !shouldUseDirectiveReplay(refreshed)) {
-        if (refreshed?.replayDirectivePending && !shouldUseDirectiveReplay(refreshed)) {
+      if (!refreshed?.replayDirectivePending) {
+        return;
+      }
+      if (shouldUseWorkerReplay(refreshed)) {
+        const workerText = buildWorkerReplayText(refreshed);
+        if (!workerText) {
           sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
+          return;
         }
+        const now2 = Date.now();
+        output.messages.push({
+          info: {
+            id: `msg_replay_${sessionID}`,
+            sessionID,
+            role: "user",
+            time: { created: now2 }
+          },
+          parts: [
+            {
+              id: `prt_replay_${sessionID}`,
+              sessionID,
+              messageID: `msg_replay_${sessionID}`,
+              type: "text",
+              text: workerText,
+              synthetic: true
+            }
+          ]
+        });
+        sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
+        return;
+      }
+      if (!shouldUseDirectiveReplay(refreshed)) {
+        sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
         return;
       }
       const replayText = buildDirectiveReplayText(refreshed);
@@ -24560,7 +25391,10 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
           }
         ]
       });
-      sessionService.trackGlobal(sessionID, { replayDirectivePending: false });
+      sessionService.trackGlobal(sessionID, {
+        replayDirectivePending: false,
+        directiveRecoveryState: refreshed.directiveRecoveryState === "available" ? "consumed" : refreshed.directiveRecoveryState
+      });
     },
     "tool.execute.before": async (input, output) => {
       if (!shouldExecuteHook("tool.execute.before", configService, turnCounters, { safetyCritical: true })) {
@@ -24583,7 +25417,7 @@ Use the \`@path\` attachment syntax in the prompt to reference the file. Do not
       const workdir = output.args?.workdir;
       if (!workdir)
         return;
-      const hiveWorktreeBase = path11.join(directory, ".hive", ".worktrees");
+      const hiveWorktreeBase = path13.join(directory, ".hive", ".worktrees");
       if (!workdir.startsWith(hiveWorktreeBase))
         return;
       const wrapped = DockerSandboxService.wrapCommand(workdir, command, sandboxConfig);
@@ -24730,11 +25564,12 @@ Expand your Discovery section and try again.`;
         }
       }),
       hive_tasks_sync: tool({
-        description: "Generate tasks from approved plan",
+        description: "Generate tasks from approved plan. When refreshPending is true, refresh pending plan tasks from current plan.md and delete removed pending tasks. Manual tasks and tasks with execution history are preserved.",
         args: {
-          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
+          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)"),
+          refreshPending: tool.schema.boolean().optional().describe("When true, refresh pending plan tasks from current plan.md (rewrite dependsOn, planTitle, spec.md) and delete pending tasks removed from plan")
         },
-        async execute({ feature: explicitFeature }) {
+        async execute({ feature: explicitFeature, refreshPending }) {
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
@@ -24742,26 +25577,52 @@ Expand your Discovery section and try again.`;
           if (!featureData || featureData.status === "planning") {
             return "Error: Plan must be approved first";
           }
-          const result = taskService.sync(feature);
+          const result = taskService.sync(feature, { refreshPending });
           if (featureData.status === "approved") {
             featureService.updateStatus(feature, "executing");
           }
-          return `Tasks synced: ${result.created.length} created, ${result.removed.length} removed, ${result.kept.length} kept`;
+          return `Tasks synced: ${result.created.length} created, ${result.removed.length} removed, ${result.kept.length} kept, ${result.manual.length} manual`;
         }
       }),
       hive_task_create: tool({
-        description: "Create manual task (not from plan)",
+        description: "Create append-only manual task (not from plan). Omit order to use the next slot. Explicit dependsOn defaults to [] and is only allowed when every dependency already exists and is done. Provide structured metadata for useful spec.md and worker prompt.",
         args: {
           name: tool.schema.string().describe("Task name"),
-          order: tool.schema.number().optional().describe("Task order"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
+          order: tool.schema.number().optional().describe("Task order. Omit to use the next append-only slot; explicit order must equal that next slot."),
+          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)"),
+          description: tool.schema.string().optional().describe("What the worker needs to achieve"),
+          goal: tool.schema.string().optional().describe("Why this task exists and what done means"),
+          acceptanceCriteria: tool.schema.array(tool.schema.string()).optional().describe("Specific observable outcomes"),
+          references: tool.schema.array(tool.schema.string()).optional().describe("File paths or line ranges relevant to this task"),
+          files: tool.schema.array(tool.schema.string()).optional().describe("Files likely to be modified"),
+          dependsOn: tool.schema.array(tool.schema.string()).optional().describe("Task folder names this task depends on (default: [] for no dependencies). Explicit dependsOn is allowed only when every dependency already exists and is done; review-sourced tasks must omit it."),
+          reason: tool.schema.string().optional().describe("Why this task was created"),
+          source: tool.schema.string().optional().describe("Origin: review, operator, or ad_hoc")
         },
-        async execute({ name, order, feature: explicitFeature }) {
+        async execute({ name, order, feature: explicitFeature, description, goal, acceptanceCriteria, references, files, dependsOn, reason, source }) {
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
-          const folder = taskService.create(feature, name, order);
+          const metadata = {};
+          if (description)
+            metadata.description = description;
+          if (goal)
+            metadata.goal = goal;
+          if (acceptanceCriteria)
+            metadata.acceptanceCriteria = acceptanceCriteria;
+          if (references)
+            metadata.references = references;
+          if (files)
+            metadata.files = files;
+          if (dependsOn)
+            metadata.dependsOn = dependsOn;
+          if (reason)
+            metadata.reason = reason;
+          if (source)
+            metadata.source = source;
+          const folder = taskService.create(feature, name, order, Object.keys(metadata).length > 0 ? metadata : undefined);
           return `Manual task created: ${folder}
+Dependencies: [${(dependsOn ?? []).join(", ")}]
 Reminder: start work with hive_worktree_start to use its worktree, and ensure any subagents work in that worktree too.`;
         }
       }),
@@ -24864,7 +25725,7 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
             });
           }
           const featureDir = resolveFeatureDirectoryName(directory, feature);
-          const workerPromptPath = path11.posix.join(".hive", "features", featureDir, "tasks", task, "worker-prompt.md");
+          const workerPromptPath = path13.posix.join(".hive", "features", featureDir, "tasks", task, "worker-prompt.md");
           bindFeatureSession(feature, toolContext, { taskFolder: task, workerPromptPath });
           let verificationNote;
           if (status === "completed") {
@@ -24996,37 +25857,49 @@ Reminder: start work with hive_worktree_start to use its worktree, and ensure an
           task: tool.schema.string().describe("Task folder name to merge"),
           strategy: tool.schema.enum(["merge", "squash", "rebase"]).optional().describe("Merge strategy (default: merge)"),
           message: tool.schema.string().optional().describe("Optional merge message for merge/squash. Empty uses default."),
+          preserveConflicts: tool.schema.boolean().optional().describe("Keep merge conflict state intact instead of auto-aborting (default: false)."),
+          cleanup: tool.schema.enum(["none", "worktree", "worktree+branch"]).optional().describe("Cleanup mode after a successful merge (default: none)."),
           feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
         },
-        async execute({ task, strategy = "merge", message, feature: explicitFeature }) {
+        async execute({ task, strategy = "merge", message, preserveConflicts, cleanup, feature: explicitFeature }) {
+          const failure = (error45) => respond({
+            success: false,
+            merged: false,
+            strategy,
+            filesChanged: [],
+            conflicts: [],
+            conflictState: "none",
+            cleanup: {
+              worktreeRemoved: false,
+              branchDeleted: false,
+              pruned: false
+            },
+            error: error45,
+            message: `Merge failed: ${error45}`
+          });
           const feature = resolveFeature(explicitFeature);
           if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
+            return failure("No feature specified. Create a feature or provide feature param.");
           const taskInfo = taskService.get(feature, task);
           if (!taskInfo)
-            return `Error: Task "${task}" not found`;
+            return failure(`Task "${task}" not found`);
           if (taskInfo.status !== "done")
-            return "Error: Task must be completed before merging. Use hive_worktree_commit first.";
-          const result = await worktreeService.merge(feature, task, strategy, message);
-          if (!result.success) {
-            if (result.conflicts && result.conflicts.length > 0) {
-              return `Merge failed with conflicts in:
-${result.conflicts.map((f) => `- ${f}`).join(`
-`)}
-
-Resolve conflicts manually or try a different strategy.`;
-            }
-            return `Merge failed: ${result.error}`;
-          }
-          return `Task "${task}" merged successfully using ${strategy} strategy.
-Commit: ${result.sha}
-Files changed: ${result.filesChanged?.length || 0}`;
+            return failure("Task must be completed before merging. Use hive_worktree_commit first.");
+          const result = await worktreeService.merge(feature, task, strategy, message, {
+            preserveConflicts,
+            cleanup
+          });
+          const responseMessage = result.success ? `Task "${task}" merged successfully using ${strategy} strategy.` : `Merge failed: ${result.error}`;
+          return respond({
+            ...result,
+            message: responseMessage
+          });
         }
       }),
       hive_context_write: tool({
-        description: "Write a context file for the feature. Context files store persistent notes, decisions, and reference material.",
+        description: "Write a context file for the feature. System-known names: overview = human-facing summary/history, draft = planner scratchpad, execution-decisions = orchestration log; all other names stay durable free-form context.",
         args: {
-          name: tool.schema.string().describe('Context file name (e.g., "decisions", "architecture", "notes")'),
+          name: tool.schema.string().describe('Context file name (e.g., "overview", "draft", "execution-decisions", "learnings"). overview is the human-facing summary/history file, draft is planner scratchpad, execution-decisions is the orchestration log; other names remain durable free-form context.'),
           content: tool.schema.string().describe("Markdown content to write"),
           feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
         },
@@ -25036,7 +25909,29 @@ Files changed: ${result.filesChanged?.length || 0}`;
             return "Error: No feature specified. Create a feature or provide feature param.";
           bindFeatureSession(feature, toolContext);
           const filePath = contextService.write(feature, name, content);
-          return `Context file written: ${filePath}`;
+          return `Context file written: ${filePath}. Known names: overview = human-facing summary/history, draft = planner scratchpad, execution-decisions = orchestration log; all other context names remain durable free-form notes.`;
+        }
+      }),
+      hive_network_query: tool({
+        description: "Query prior features for deterministic plan/context snippets. Returns JSON with query, currentFeature, and snippet results only. Callers must opt in to using the returned snippets.",
+        args: {
+          feature: tool.schema.string().optional().describe("Current feature to exclude from results. Defaults to active feature when available."),
+          query: tool.schema.string().describe("Case-insensitive substring query over plan.md and network-safe context")
+        },
+        async execute({ feature: explicitFeature, query }) {
+          const currentFeature = resolveFeature(explicitFeature) ?? null;
+          const results = networkService.query({
+            currentFeature: currentFeature ?? undefined,
+            query,
+            maxFeatures: 10,
+            maxSnippetsPerFeature: 3,
+            maxSnippetChars: 240
+          });
+          return respond({
+            query,
+            currentFeature,
+            results
+          });
         }
       }),
       hive_status: tool({
@@ -25081,23 +25976,23 @@ Files changed: ${result.filesChanged?.length || 0}`;
           }
           const plan = planService.read(feature);
           const tasks = taskService.list(feature);
-          const contextFiles = contextService.list(feature);
-          const overview = contextFiles.find((file2) => file2.name === "overview") ?? null;
+          const featureContextFiles = contextService.list(feature);
+          const overview = contextService.getOverview(feature);
           const readThreads = (filePath) => {
-            if (!fs13.existsSync(filePath)) {
+            if (!fs14.existsSync(filePath)) {
               return null;
             }
             try {
-              const data = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+              const data = JSON.parse(fs14.readFileSync(filePath, "utf-8"));
               return data.threads ?? [];
             } catch {
               return [];
             }
           };
-          const featurePath = path11.join(directory, ".hive", "features", resolveFeatureDirectoryName(directory, feature));
-          const reviewDir = path11.join(featurePath, "comments");
-          const planThreads = readThreads(path11.join(reviewDir, "plan.json")) ?? readThreads(path11.join(featurePath, "comments.json"));
-          const overviewThreads = readThreads(path11.join(reviewDir, "overview.json"));
+          const featurePath = path13.join(directory, ".hive", "features", resolveFeatureDirectoryName(directory, feature));
+          const reviewDir = path13.join(featurePath, "comments");
+          const planThreads = readThreads(path13.join(reviewDir, "plan.json")) ?? readThreads(path13.join(featurePath, "comments.json"));
+          const overviewThreads = readThreads(path13.join(reviewDir, "overview.json"));
           const reviewCounts = {
             plan: planThreads?.length ?? 0,
             overview: overviewThreads?.length ?? 0
@@ -25118,14 +26013,21 @@ Files changed: ${result.filesChanged?.length || 0}`;
               } : null
             };
           }));
-          const contextSummary = contextFiles.map((c) => ({
+          const contextSummary = featureContextFiles.map((c) => ({
             name: c.name,
             chars: c.content.length,
-            updatedAt: c.updatedAt
+            updatedAt: c.updatedAt,
+            role: c.role,
+            includeInExecution: c.includeInExecution,
+            includeInAgentsMdSync: c.includeInAgentsMdSync,
+            includeInNetwork: c.includeInNetwork
           }));
           const pendingTasks = tasksSummary.filter((t) => t.status === "pending");
           const inProgressTasks = tasksSummary.filter((t) => t.status === "in_progress");
           const doneTasks = tasksSummary.filter((t) => t.status === "done");
+          const doneTasksWithLiveWorktrees = tasksSummary.filter((t) => t.status === "done" && t.worktree).map((t) => t.folder);
+          const dirtyWorktrees = tasksSummary.filter((t) => t.worktree && t.worktree.hasChanges === true).map((t) => t.folder);
+          const nonInProgressTasksWithWorktrees = tasksSummary.filter((t) => t.status !== "in_progress" && t.worktree).map((t) => t.folder);
           const tasksWithDeps = tasksSummary.map((t) => ({
             folder: t.folder,
             status: t.status,
@@ -25137,12 +26039,25 @@ Files changed: ${result.filesChanged?.length || 0}`;
             dependsOn: effectiveDeps.get(task.folder)
           }));
           const { runnable, blocked: blockedBy } = computeRunnableAndBlocked(normalizedTasks);
+          const ambiguityFlags = [];
+          if (doneTasksWithLiveWorktrees.length > 0) {
+            ambiguityFlags.push("done_task_has_live_worktree");
+          }
+          if (dirtyWorktrees.some((folder) => nonInProgressTasksWithWorktrees.includes(folder))) {
+            ambiguityFlags.push("dirty_non_in_progress_worktree");
+          }
+          if (runnable.length > 1) {
+            ambiguityFlags.push("multiple_runnable_tasks");
+          }
+          if (pendingTasks.length > 0 && runnable.length === 0) {
+            ambiguityFlags.push("pending_tasks_blocked");
+          }
           const getNextAction = (planStatus2, tasks2, runnableTasks, hasPlan, hasOverview) => {
             if (planStatus2 === "review") {
               return "Wait for plan approval or revise based on comments";
             }
             if (!hasPlan || planStatus2 === "draft") {
-              return "Write or revise plan with hive_plan_write. Keep plan.md as the human-facing review artifact; pre-task Mermaid overview diagrams are optional.";
+              return "Write or revise plan with hive_plan_write. Refresh context/overview.md first for human review; plan.md remains execution truth and pre-task Mermaid overview diagrams are optional.";
             }
             if (tasks2.length === 0) {
               return "Generate tasks from plan with hive_tasks_sync";
@@ -25197,10 +26112,31 @@ Files changed: ${result.filesChanged?.length || 0}`;
               runnable,
               blockedBy
             },
+            helperStatus: {
+              doneTasksWithLiveWorktrees,
+              dirtyWorktrees,
+              nonInProgressTasksWithWorktrees,
+              manualTaskPolicy: {
+                order: {
+                  omitted: "append_next_order",
+                  explicitNextOrder: "append_next_order",
+                  explicitOtherOrder: "plan_amendment_required"
+                },
+                dependsOn: {
+                  omitted: "store_empty_array",
+                  explicitDoneTargetsOnly: "allowed",
+                  explicitMissingTarget: "plan_amendment_required",
+                  explicitNotDoneTarget: "plan_amendment_required",
+                  reviewSourceWithExplicitDependsOn: "plan_amendment_required"
+                }
+              },
+              ambiguityFlags
+            },
             context: {
-              fileCount: contextFiles.length,
+              fileCount: featureContextFiles.length,
               files: contextSummary
             },
+            warning: configFallbackWarning ?? undefined,
             nextAction: getNextAction(planStatus, tasksSummary, runnable, !!plan, !!overview)
           });
         }
@@ -25248,8 +26184,8 @@ ${result.diff}
       })
     },
     command: {
-      hive: {
-        description: "Create a new feature: /hive <feature-name>",
+      [HIVE_COMMANDS[0].key]: {
+        description: HIVE_COMMANDS[0].description,
         async run(args) {
           const name = args.trim();
           if (!name)
@@ -25260,27 +26196,8 @@ ${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) {
+        for (const tool3 of HIVE_TOOL_NAMES) {
           if (!allowed.includes(tool3)) {
             result[tool3] = false;
           }
@@ -25303,7 +26220,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         variant: hiveUserConfig.variant,
         temperature: hiveUserConfig.temperature ?? 0.5,
         description: "Hive (Hybrid) - Plans + orchestrates. Detects phase, loads skills on-demand.",
-        prompt: QUEEN_BEE_PROMPT + hiveAutoLoadedSkills + (agentMode === "unified" ? customSubagentAppendix : ""),
+        prompt: QUEEN_BEE_PROMPT + HIVE_SYSTEM_PROMPT + hiveAutoLoadedSkills + (agentMode === "unified" ? customSubagentAppendix : ""),
         permission: {
           question: "allow",
           skill: "allow",
@@ -25318,8 +26235,8 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         variant: architectUserConfig.variant,
         temperature: architectUserConfig.temperature ?? 0.7,
         description: "Architect (Planner) - Plans features, interviews, writes plans. NEVER executes.",
-        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"]),
+        prompt: ARCHITECT_BEE_PROMPT + HIVE_SYSTEM_PROMPT + architectAutoLoadedSkills + (agentMode === "dedicated" ? customSubagentAppendix : ""),
+        tools: agentTools(["hive_feature_create", "hive_plan_write", "hive_plan_read", "hive_context_write", "hive_network_query", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
           task: "allow",
@@ -25337,7 +26254,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         variant: swarmUserConfig.variant,
         temperature: swarmUserConfig.temperature ?? 0.5,
         description: "Swarm (Orchestrator) - Orchestrates execution. Delegates, spawns workers, verifies, merges.",
-        prompt: SWARM_BEE_PROMPT + swarmAutoLoadedSkills + (agentMode === "dedicated" ? customSubagentAppendix : ""),
+        prompt: SWARM_BEE_PROMPT + HIVE_SYSTEM_PROMPT + swarmAutoLoadedSkills + (agentMode === "dedicated" ? customSubagentAppendix : ""),
         tools: agentTools([
           "hive_feature_create",
           "hive_feature_complete",
@@ -25351,6 +26268,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
           "hive_worktree_discard",
           "hive_merge",
           "hive_context_write",
+          "hive_network_query",
           "hive_status",
           "hive_skill",
           "hive_agents_md"
@@ -25370,7 +26288,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         temperature: scoutUserConfig.temperature ?? 0.5,
         mode: "subagent",
         description: "Scout (Explorer/Researcher/Retrieval) - Researches codebase + external docs/data.",
-        prompt: SCOUT_BEE_PROMPT + scoutAutoLoadedSkills,
+        prompt: SCOUT_BEE_PROMPT + HIVE_SYSTEM_PROMPT + scoutAutoLoadedSkills,
         tools: agentTools(["hive_plan_read", "hive_context_write", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
@@ -25388,7 +26306,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         temperature: foragerUserConfig.temperature ?? 0.3,
         mode: "subagent",
         description: "Forager (Worker/Coder) - Executes tasks directly in isolated worktrees. Never delegates.",
-        prompt: FORAGER_BEE_PROMPT + foragerAutoLoadedSkills,
+        prompt: FORAGER_BEE_PROMPT + HIVE_SYSTEM_PROMPT + foragerAutoLoadedSkills,
         tools: agentTools(["hive_plan_read", "hive_worktree_commit", "hive_context_write", "hive_skill"]),
         permission: {
           task: "deny",
@@ -25396,6 +26314,21 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
           skill: "allow"
         }
       };
+      const hiveHelperUserConfig = configService.getAgentConfig("hive-helper");
+      const hiveHelperConfig = {
+        model: hiveHelperUserConfig.model,
+        variant: hiveHelperUserConfig.variant,
+        temperature: hiveHelperUserConfig.temperature ?? 0.3,
+        mode: "subagent",
+        description: "Hive Helper - Runtime-only bounded hard-task operational assistant for merge recovery, state clarification, and safe manual follow-up assistance.",
+        prompt: HIVE_HELPER_PROMPT + HIVE_SYSTEM_PROMPT,
+        tools: agentTools(["hive_merge", "hive_status", "hive_context_write", "hive_task_create", "hive_skill"]),
+        permission: {
+          task: "deny",
+          delegate: "deny",
+          skill: "allow"
+        }
+      };
       const hygienicUserConfig = configService.getAgentConfig("hygienic-reviewer");
       const hygienicAutoLoadedSkills = await buildAutoLoadedSkillsContent("hygienic-reviewer", configService, directory);
       const hygienicConfig = {
@@ -25404,8 +26337,8 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         temperature: hygienicUserConfig.temperature ?? 0.3,
         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"]),
+        prompt: HYGIENIC_BEE_PROMPT + HIVE_SYSTEM_PROMPT + hygienicAutoLoadedSkills,
+        tools: agentTools(["hive_plan_read", "hive_context_write", "hive_network_query", "hive_status", "hive_skill"]),
         permission: {
           edit: "deny",
           task: "deny",
@@ -25419,6 +26352,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         "swarm-orchestrator": swarmConfig,
         "scout-researcher": scoutConfig,
         "forager-worker": foragerConfig,
+        "hive-helper": hiveHelperConfig,
         "hygienic-reviewer": hygienicConfig
       };
       const customAutoLoadedSkills = Object.fromEntries(await Promise.all(Object.entries(customAgentConfigs).map(async ([customAgentName, customAgentConfig]) => {
@@ -25442,12 +26376,14 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         allAgents["hive-master"] = builtInAgentConfigs["hive-master"];
         allAgents["scout-researcher"] = builtInAgentConfigs["scout-researcher"];
         allAgents["forager-worker"] = builtInAgentConfigs["forager-worker"];
+        allAgents["hive-helper"] = builtInAgentConfigs["hive-helper"];
         allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
       } else {
         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["hive-helper"] = builtInAgentConfigs["hive-helper"];
         allAgents["hygienic-reviewer"] = builtInAgentConfigs["hygienic-reviewer"];
       }
       Object.assign(allAgents, customSubagents);
@@ -25467,6 +26403,7 @@ ${Object.entries(customAgentConfigs).sort(([left], [right]) => left.localeCompar
         delete configAgent["swarm-orchestrator"];
         delete configAgent["scout-researcher"];
         delete configAgent["forager-worker"];
+        delete configAgent["hive-helper"];
         delete configAgent["hygienic-reviewer"];
         Object.assign(configAgent, allAgents);
       }