opencode-hive 1.0.7 → 1.2.0

package/dist/index.js

@@ -12,8 +12,7 @@ var __export = (target, all) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import * as path7 from "path";
-import * as fs9 from "fs";
+import * as path8 from "path";
 import * as os from "os";
 
 // ../../node_modules/zod/v4/classic/external.js
@@ -12337,8 +12336,260 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // src/skills/registry.generated.ts
-var BUILTIN_SKILL_NAMES = ["brainstorming", "code-reviewer", "dispatching-parallel-agents", "executing-plans", "onboarding", "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", "writing-plans"];
 var BUILTIN_SKILLS = [
+  {
+    name: "agents-md-mastery",
+    description: "Use when bootstrapping, updating, or reviewing AGENTS.md — teaches what makes effective agent memory, how to structure sections, signal vs noise filtering, and when to prune stale entries",
+    template: `# AGENTS.md Mastery
+
+## Overview
+
+**AGENTS.md is pseudo-memory loaded at session start.** Every line shapes agent behavior for the entire session. Quality beats quantity. Write for agents, not humans.
+
+Unlike code comments or READMEs, AGENTS.md entries persist across all agent sessions. A bad entry misleads agents hundreds of times. A missing entry causes the same mistake repeatedly.
+
+**Core principle:** Optimize for agent comprehension and behavioral change, not human readability.
+
+## The Iron Law
+
+\`\`\`
+EVERY ENTRY MUST CHANGE AGENT BEHAVIOR
+\`\`\`
+
+If an entry doesn't:
+- Prevent a specific mistake
+- Enable a capability the agent would otherwise miss
+- Override a default assumption that breaks in this codebase
+
+...then it doesn't belong in AGENTS.md.
+
+**Test:** Would a fresh agent session make a mistake without this entry? If no → noise.
+
+## When to Use
+
+| Trigger | Action |
+|---------|--------|
+| New project bootstrap | Write initial AGENTS.md with build/test/style basics |
+| Feature completion | Sync new learnings via \`hive_agents_md\` tool |
+| Periodic review | Audit for stale/redundant entries (quarterly) |
+| Quality issues | Agent repeating mistakes? Check if AGENTS.md has the fix |
+
+## What Makes Good Agent Memory
+
+### Signal Entries (Keep)
+
+✅ **Project-specific conventions:**
+- "We use Zustand, not Redux — never add Redux"
+- "Auth lives in \`/lib/auth\` — never create auth elsewhere"
+- "Run \`bun test\` not \`npm test\` (we don't use npm)"
+
+✅ **Non-obvious patterns:**
+- "Use \`.js\` extension for local imports (ESM requirement)"
+- "Worktrees don't share \`node_modules\` — run \`bun install\` in each"
+- "SandboxConfig is in \`dockerSandboxService.ts\`, NOT \`types.ts\`"
+
+✅ **Gotchas that break builds:**
+- "Never use \`ensureDirSync\` — doesn't exist. Use \`ensureDir\` (sync despite name)"
+- "Import from \`../utils/paths.js\` not \`./paths\` (ESM strict)"
+
+### Noise Entries (Remove)
+
+❌ **Agent already knows:**
+- "This project uses TypeScript" (agent detects from files)
+- "We follow semantic versioning" (universal convention)
+- "Use descriptive variable names" (generic advice)
+
+❌ **Irrelevant metadata:**
+- "Created on January 2024"
+- "Originally written by X"
+- "License: MIT" (in LICENSE file already)
+
+❌ **Describes what code does:**
+- "FeatureService manages features" (agent can read code)
+- "The system uses git worktrees" (observable from commands)
+
+### Rule of Thumb
+
+**Signal:** Changes how agent acts  
+**Noise:** Documents what agent observes
+
+## Section Structure for Fast Comprehension
+
+Agents read AGENTS.md top-to-bottom once at session start. Put high-value info first:
+
+\`\`\`markdown
+# Project Name
+
+## Build & Test Commands
+# ← Agents need this IMMEDIATELY
+bun run build
+bun run test
+bun run release:check
+
+## Code Style
+# ← Prevents syntax/import errors
+- Semicolons: Yes
+- Quotes: Single
+- Imports: Use \`.js\` extension
+
+## Architecture
+# ← Key directories, where things live
+packages/
+├── hive-core/      # Shared logic
+├── opencode-hive/  # Plugin
+└── vscode-hive/    # Extension
+
+## Important Patterns
+# ← How to do common tasks correctly
+Use \`readText\` from paths.ts, not fs.readFileSync
+
+## Gotchas & Anti-Patterns
+# ← Things that break or mislead
+NEVER use \`ensureDirSync\` — doesn't exist
+\`\`\`
+
+**Keep total under 500 lines.** Beyond that, agents lose focus and miss critical entries.
+
+## The Sync Workflow
+
+After completing a feature, sync learnings to AGENTS.md:
+
+1. **Trigger sync:**
+   \`\`\`typescript
+   hive_agents_md({ action: 'sync', feature: 'feature-name' })
+   \`\`\`
+
+2. **Review each proposal:**
+   - Read the proposed change
+   - Ask: "Does this change agent behavior?"
+   - Check: Is this already obvious from code/files?
+
+3. **Accept signal, reject noise:**
+   - ❌ "TypeScript is used" → Agent detects this
+   - ✅ "Use \`.js\` extension for imports" → Prevents build failures
+
+4. **Apply approved changes:**
+   \`\`\`typescript
+   hive_agents_md({ action: 'apply' })
+   \`\`\`
+
+**Warning:** Don't auto-approve all proposals. One bad entry pollutes all future sessions.
+
+## When to Prune
+
+Remove entries when they become:
+
+**Outdated:**
+- "We use Redux" → Project migrated to Zustand
+- "Node 16 compatibility required" → Now on Node 22
+
+**Redundant:**
+- "Use single quotes" + "Strings use single quotes" → Keep one
+- Near-duplicates in different sections
+
+**Too generic:**
+- "Write clear code" → Applies to any project
+- "Test your changes" → Universal advice
+
+**Describing code:**
+- "TaskService manages tasks" → Agent can read \`TaskService\` class
+- "Worktrees are in \`.hive/.worktrees/\`" → Observable from filesystem
+
+**Proven unnecessary:**
+- Entry added 6 months ago, but agents haven't hit that issue since
+
+## Red Flags
+
+| Warning Sign | Why It's Bad | Fix |
+|-------------|-------------|-----|
+| AGENTS.md > 800 lines | Agents lose focus, miss critical info | Prune aggressively |
+| Describes what code does | Agent can read code | Remove descriptions |
+| Missing build/test commands | First thing agents need | Add at top |
+| No gotchas section | Agents repeat past mistakes | Document failure modes |
+| Generic best practices | Doesn't change behavior | Remove or make specific |
+| Outdated patterns | Misleads agents | Prune during sync |
+
+## Anti-Patterns
+
+| Anti-Pattern | Better Approach |
+|-------------|----------------|
+| "Document everything" | Document only what changes behavior |
+| "Keep for historical record" | Version control is history |
+| "Might be useful someday" | Add when proven necessary |
+| "Explains the system" | Agents read code for that |
+| "Comprehensive reference" | AGENTS.md is a filter, not docs |
+
+## Good Examples
+
+**Build Commands (High value, agents need immediately):**
+\`\`\`markdown
+## Build & Test Commands
+bun run build              # Build all packages
+bun run test               # Run all tests
+bun run release:check      # Full CI check
+\`\`\`
+
+**Project-Specific Convention (Prevents mistakes):**
+\`\`\`markdown
+## Code Style
+- Imports: Use \`.js\` extension for local imports (ESM requirement)
+- Paths: Import from \`../utils/paths.js\` never \`./paths\`
+\`\`\`
+
+**Non-Obvious Gotcha (Prevents build failure):**
+\`\`\`markdown
+## Important Patterns
+Use \`ensureDir\` from paths.ts — sync despite name
+NEVER use \`ensureDirSync\` (doesn't exist)
+\`\`\`
+
+## Bad Examples
+
+**Generic advice (agent already knows):**
+\`\`\`markdown
+## Best Practices
+- Use meaningful variable names
+- Write unit tests
+- Follow DRY principle
+\`\`\`
+
+**Describes code (agent can read it):**
+\`\`\`markdown
+## Architecture
+The FeatureService class manages features. It has methods
+for create, read, update, and delete operations.
+\`\`\`
+
+**Irrelevant metadata:**
+\`\`\`markdown
+## Project History
+Created in January 2024 by the platform team.
+Originally built for internal use.
+\`\`\`
+
+## Verification
+
+Before finalizing AGENTS.md updates:
+
+- [ ] Every entry answers: "What mistake does this prevent?"
+- [ ] No generic advice that applies to all projects
+- [ ] Build/test commands are first
+- [ ] Gotchas section exists and is populated
+- [ ] Total length under 500 lines (800 absolute max)
+- [ ] No entries describing what code does
+- [ ] Fresh agent session would benefit from each entry
+
+## Summary
+
+AGENTS.md is **behavioral memory**, not documentation:
+- Write for agents, optimize for behavior change
+- Signal = prevents mistakes, Noise = describes observables
+- Sync after features, prune quarterly
+- Test: Would agent make a mistake without this entry?
+
+**Quality > quantity. Every line counts.**`
+  },
   {
     name: "brainstorming",
     description: "Use before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.",
@@ -12388,7 +12639,8 @@ Start by understanding the current project context, then ask questions one at a
 - **YAGNI ruthlessly** - Remove unnecessary features from all designs
 - **Explore alternatives** - Always propose 2-3 approaches before settling
 - **Incremental validation** - Present design in sections, validate each
-- **Be flexible** - Go back and clarify when something doesn't make sense`
+- **Be flexible** - Go back and clarify when something doesn't make sense
+- **Challenge assumptions** - Surface fragile assumptions, ask what changes if they fail, offer lean fallback options`
   },
   {
     name: "code-reviewer",
@@ -12675,9 +12927,9 @@ Each agent gets:
 
 \`\`\`typescript
 // Using Hive tools for parallel execution
-hive_exec_start({ task: "01-fix-abort-tests" })
-hive_exec_start({ task: "02-fix-batch-tests" })
-hive_exec_start({ task: "03-fix-race-condition-tests" })
+hive_worktree_create({ task: "01-fix-abort-tests" })
+hive_worktree_create({ task: "02-fix-batch-tests" })
+hive_worktree_create({ task: "03-fix-race-condition-tests" })
 // All three run concurrently in isolated worktrees
 \`\`\`
 
@@ -12795,6 +13047,351 @@ From debugging session (2025-10-03):
 - All investigations completed concurrently
 - All fixes integrated successfully
 - Zero conflicts between agent changes`
+  },
+  {
+    name: "docker-mastery",
+    description: "Use when working with Docker containers — debugging container failures, writing Dockerfiles, docker-compose for integration tests, image optimization, or deploying containerized applications",
+    template: `# Docker Mastery
+
+## Overview
+
+Docker is a **platform for building, shipping, and running applications**, not just isolation.
+
+Agents should think in containers: reproducible environments, declarative dependencies, isolated execution.
+
+**Core principle:** Containers are not virtual machines. They share the kernel but isolate processes, filesystems, and networks.
+
+**Violating the letter of these guidelines is violating the spirit of containerization.**
+
+## The Iron Law
+
+\`\`\`
+UNDERSTAND THE CONTAINER BEFORE DEBUGGING INSIDE IT
+\`\`\`
+
+Before exec'ing into a container or adding debug commands:
+1. Check the image (what's installed?)
+2. Check mounts (what host files are visible?)
+3. Check environment variables (what config is passed?)
+4. Check the Dockerfile (how was it built?)
+
+Random debugging inside containers wastes time. Context first, then debug.
+
+## When to Use
+
+Use this skill when working with:
+- **Container build failures** - Dockerfile errors, missing dependencies
+- **Test environment setup** - Reproducible test environments across machines
+- **Integration test orchestration** - Multi-service setups (DB + API + tests)
+- **Dockerfile authoring** - Writing efficient, maintainable Dockerfiles
+- **Image size optimization** - Reducing image size, layer caching
+- **Deployment** - Containerized application deployment
+- **Sandbox debugging** - Issues with Hive's Docker sandbox mode
+
+**Use this ESPECIALLY when:**
+- Tests pass locally but fail in CI (environment mismatch)
+- "Works on my machine" problems
+- Need to test against specific dependency versions
+- Multiple services must coordinate (database + API)
+- Building for production deployment
+
+## Core Concepts
+
+### Images vs Containers
+
+- **Image**: Read-only template (built from Dockerfile)
+- **Container**: Running instance of an image (ephemeral by default)
+
+\`\`\`bash
+# Build once
+docker build -t myapp:latest .
+
+# Run many times
+docker run --rm myapp:latest
+docker run --rm -e DEBUG=true myapp:latest
+\`\`\`
+
+**Key insight:** Changes inside containers are lost unless committed or volumes are used.
+
+### Volumes & Mounts
+
+Mount host directories into containers for persistence and code sharing:
+
+\`\`\`bash
+# Mount current directory to /app in container
+docker run -v $(pwd):/app myapp:latest
+
+# Hive worktrees are mounted automatically
+# Your code edits (via Read/Write/Edit tools) affect the host
+# Container sees the same files at runtime
+\`\`\`
+
+**How Hive uses this:** Worktree is mounted into container, so file tools work on host, bash commands run in container.
+
+### Multi-Stage Builds
+
+Minimize image size by using multiple FROM statements:
+
+\`\`\`dockerfile
+# Build stage (large, has compilers)
+FROM node:22 AS builder
+WORKDIR /app
+COPY package.json bun.lockb ./
+RUN bun install
+COPY . .
+RUN bun run build
+
+# Runtime stage (small, production only)
+FROM node:22-slim
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+CMD ["node", "dist/index.js"]
+\`\`\`
+
+**Result:** Builder tools (TypeScript, bundlers) not included in final image.
+
+### Docker Compose for Multi-Service Setups
+
+Define multiple services in \`docker-compose.yml\`:
+
+\`\`\`yaml
+version: '3.8'
+services:
+  db:
+    image: postgres:15
+    environment:
+      POSTGRES_PASSWORD: testpass
+    ports:
+      - "5432:5432"
+  
+  api:
+    build: .
+    environment:
+      DATABASE_URL: postgres://db:5432/testdb
+    depends_on:
+      - db
+    ports:
+      - "3000:3000"
+\`\`\`
+
+Run with: \`docker-compose up -d\`
+Teardown with: \`docker-compose down\`
+
+### Network Modes
+
+- **bridge** (default): Isolated network, containers can talk to each other by name
+- **host**: Container uses host's network directly (no isolation)
+- **none**: No network access
+
+**When to use host mode:** Debugging network issues, accessing host services directly.
+
+## Common Patterns
+
+### Debug a Failing Container
+
+**Problem:** Container exits immediately, logs unclear.
+
+**Pattern:**
+1. Run interactively with shell:
+   \`\`\`bash
+   docker run -it --entrypoint sh myapp:latest
+   \`\`\`
+2. Inspect filesystem, check if dependencies exist:
+   \`\`\`bash
+   ls /app
+   which node
+   cat /etc/os-release
+   \`\`\`
+3. Run command manually to see full error:
+   \`\`\`bash
+   node dist/index.js
+   \`\`\`
+
+### Integration Tests with Docker Compose
+
+**Pattern:**
+1. Define services in \`docker-compose.test.yml\`
+2. Add wait logic (wait for DB to be ready)
+3. Run tests
+4. Teardown
+
+\`\`\`yaml
+# docker-compose.test.yml
+services:
+  db:
+    image: postgres:15
+    environment:
+      POSTGRES_PASSWORD: test
+  test:
+    build: .
+    command: bun run test:integration
+    depends_on:
+      - db
+    environment:
+      DATABASE_URL: postgres://postgres:test@db:5432/testdb
+\`\`\`
+
+\`\`\`bash
+docker-compose -f docker-compose.test.yml up --abort-on-container-exit
+docker-compose -f docker-compose.test.yml down
+\`\`\`
+
+### Optimize Dockerfile
+
+**Anti-pattern:**
+\`\`\`dockerfile
+FROM node:22
+WORKDIR /app
+COPY . .              # Copies everything (including node_modules, .git)
+RUN bun install       # Invalidates cache on any file change
+CMD ["bun", "run", "start"]
+\`\`\`
+
+**Optimized:**
+\`\`\`dockerfile
+FROM node:22-slim     # Use slim variant
+WORKDIR /app
+
+# Copy dependency files first (cache layer)
+COPY package.json bun.lockb ./
+RUN bun install --production
+
+# Copy source code (changes frequently)
+COPY src ./src
+COPY tsconfig.json ./
+
+CMD ["bun", "run", "start"]
+\`\`\`
+
+**Add \`.dockerignore\`:**
+\`\`\`
+node_modules
+.git
+.env
+*.log
+dist
+.DS_Store
+\`\`\`
+
+### Handle Missing Dependencies
+
+**Problem:** Command fails with "not found" in container.
+
+**Pattern:**
+1. Check if dependency is in image:
+   \`\`\`bash
+   docker run -it myapp:latest which git
+   \`\`\`
+2. If missing, add to Dockerfile:
+   \`\`\`dockerfile
+   RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+   \`\`\`
+3. Or use a richer base image (e.g., \`node:22\` instead of \`node:22-slim\`).
+
+## Hive Sandbox Integration
+
+### How Hive Wraps Commands
+
+When sandbox mode is active (\`sandbox: 'docker'\` in config):
+1. Hive hook intercepts bash commands before execution
+2. Wraps with \`docker run --rm -v <worktree>:/workspace -w /workspace <image> sh -c "<command>"\`
+3. Command runs in container, but file edits (Read/Write/Edit) still affect host
+
+**Workers are unaware** — they issue normal bash commands, Hive handles containerization.
+
+### When Host Access is Needed
+
+Some operations MUST run on host:
+- **Git operations** (commit, push, branch) — repo state is on host
+- **Host-level tools** (Docker itself, system config)
+- **Cross-worktree operations** (accessing main repo from worktree)
+
+**Pattern:** Use \`HOST:\` prefix to escape sandbox:
+\`\`\`bash
+HOST: git status
+HOST: docker ps
+\`\`\`
+
+**If you need host access frequently:** Report as blocked and ask user if sandbox should be disabled for this task.
+
+### Persistent vs Ephemeral Containers
+
+**Current (v1.2.0):** Each command runs \`docker run --rm\` (ephemeral). State does NOT persist.
+
+Example: \`npm install lodash\` in one command → not available in next command.
+
+**Workaround:** Install dependencies in Dockerfile, not at runtime.
+
+**Future:** \`docker exec\` will reuse containers, persisting state across commands.
+
+### Auto-Detected Images
+
+Hive detects runtime from project files:
+- \`package.json\` → \`node:22-slim\`
+- \`requirements.txt\` / \`pyproject.toml\` → \`python:3.12-slim\`
+- \`go.mod\` → \`golang:1.22-slim\`
+- \`Cargo.toml\` → \`rust:1.77-slim\`
+- \`Dockerfile\` → Builds from project Dockerfile
+- Fallback → \`ubuntu:24.04\`
+
+**Override:** Set \`dockerImage\` in config (\`~/.config/opencode/agent_hive.json\`).
+
+## Red Flags - STOP
+
+If you catch yourself:
+- Installing packages on host instead of in Dockerfile
+- Running \`docker build\` without \`.dockerignore\` (cache invalidation)
+- Using \`latest\` tag in production (non-reproducible)
+- Ignoring container exit codes (hides failures)
+- Assuming state persists between \`docker run --rm\` commands
+- Using absolute host paths in Dockerfile (not portable)
+- Copying secrets into image layers (leaks credentials)
+
+**ALL of these mean: STOP. Review pattern.**
+
+## Anti-Patterns
+
+| Excuse | Reality |
+|--------|---------|
+| "I'll just run it on host" | Container mismatch bugs are worse to debug later. Build happens in container anyway. |
+| "Works in my container, don't need CI" | CI uses different cache state. Always test in CI-like environment. |
+| "I'll optimize the Dockerfile later" | Later never comes. Large images slow down deployments now. |
+| "latest tag is fine for dev" | Dev should match prod. Pin versions or face surprises. |
+| "Don't need .dockerignore, COPY is fast" | Invalidates cache on every file change. Wastes minutes per build. |
+| "Install at runtime, not in image" | Ephemeral containers lose state. Slows down every command. |
+| "Skip depends_on, services start fast" | Race conditions in integration tests. Use wait-for-it or health checks. |
+
+## Verification Before Completion
+
+Before marking Docker work complete:
+
+- [ ] Container runs successfully: \`docker run --rm <image> <command>\` exits 0
+- [ ] Tests pass inside container (not just on host)
+- [ ] No host pollution (dependencies installed in container, not host)
+- [ ] \`.dockerignore\` exists if using \`COPY . .\`
+- [ ] Image tags are pinned (not \`latest\`) for production
+- [ ] Multi-stage build used if applicable (separate build/runtime)
+- [ ] Integration tests teardown properly (\`docker-compose down\`)
+
+**If any fail:** Don't claim success. Fix or report blocker.
+
+## Quick Reference
+
+| Task | Command Pattern |
+|------|----------------|
+| **Debug container** | \`docker run -it --entrypoint sh <image>\` |
+| **Run with mounts** | \`docker run -v $(pwd):/app <image>\` |
+| **Multi-service tests** | \`docker-compose up --abort-on-container-exit\` |
+| **Check image contents** | \`docker run --rm <image> ls /app\` |
+| **Optimize build** | Add \`.dockerignore\`, use multi-stage, pin versions |
+| **Escape Hive sandbox** | Prefix with \`HOST:\` (e.g., \`HOST: git status\`) |
+
+## Related Skills
+
+- **hive_skill:systematic-debugging** - When container behavior is unexpected
+- **hive_skill:test-driven-development** - Write tests that run in containers
+- **hive_skill:verification-before-completion** - Verify tests pass in container before claiming done`
   },
   {
     name: "executing-plans",
@@ -12832,7 +13429,7 @@ Only \`done\` satisfies dependencies (not \`blocked\`, \`failed\`, \`partial\`,
 ### Step 3: Execute Batch
 
 For each task in the batch:
-1. Mark as in_progress via \`hive_exec_start()\`
+1. Mark as in_progress via \`hive_worktree_create()\`
 2. Follow each step exactly (plan has bite-sized steps)
 3. Run verifications as specified
 4. Mark as completed
@@ -12843,6 +13440,11 @@ When batch complete:
 - Show verification output
 - Say: "Ready for feedback."
 
+### Step 4.5: Post-Batch Hygienic Review
+
+After the batch report, ask the operator if they want a Hygienic code review for the batch.
+If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\` and apply feedback before starting the next batch.
+
 ### Step 5: Continue
 Based on feedback:
 - Apply changes if needed
@@ -12852,8 +13454,8 @@ Based on feedback:
 ### Step 6: Complete Development
 
 After all tasks complete and verified:
-- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
-- **REQUIRED SUB-SKILL:** Use hive_skill:finishing-a-development-branch
+- Announce: "I'm using the verification-before-completion skill to complete this work."
+- **REQUIRED SUB-SKILL:** Use hive_skill:verification-before-completion
 - Follow that skill to verify tests, present options, execute choice
 
 ## When to Stop and Ask for Help
@@ -12881,70 +13483,10 @@ After all tasks complete and verified:
 - Reference skills when plan says to
 - Between batches: just report and wait
 - Stop when blocked, don't guess`
-  },
-  {
-    name: "onboarding",
-    description: "Ask about workflow preferences and store them in .hive/contexts/preferences.md before proceeding.",
-    template: `# Onboarding Preferences
-
-## Overview
-
-Gather workflow preferences so the assistant can match the user's desired working style.
-
-## When to Ask
-
-- **Immediately when the skill is loaded**, before any other work.
-- If \`.hive/contexts/preferences.md\` does not exist, start onboarding.
-- If later a decision is ambiguous and preferences are missing, ask again.
-
-## Preference Storage
-
-Use \`hive_context_write\` to write \`.hive/contexts/preferences.md\` with this exact template:
-
-\`\`\`
-# Preferences
-
-## Exploration Style
-sync
-
-## Research Depth
-medium
-
-## Confirmation Level
-standard
-
-## Commit Behavior
-ask-before-commit
-\`\`\`
-
-## If Preferences Already Exist
-
-Follow the same pattern used in \`packages/vscode-hive/src/tools/plan.ts\`:
-
-1. Use \`contextService.list(feature)\` to detect existing contexts.
-2. Ask **"Preferences already exist. Keep or overwrite?"** using the \`question()\` tool.
-3. If keep → continue using existing preferences.
-4. If overwrite → collect new answers and write them with \`hive_context_write\`.
-
-## Questions to Ask (Always use \`question()\`)
-
-Ask one at a time, with the provided options. Store the answers in \`.hive/contexts/preferences.md\`.
-
-1. **Exploration Style:** sync | async
-2. **Research Depth:** shallow | medium | deep
-3. **Confirmation Level:** minimal | standard | high
-4. **Commit Behavior:** ask-before-commit | auto-commit | never-commit
-
-## Requirements
-
-- Use the \`question()\` tool (no plain text questions).
-- Ask immediately when the skill loads if preferences are missing.
-- If later a decision is ambiguous and preferences are missing, ask again.
-- Always store answers using \`hive_context_write\` with the template above.`
   },
   {
     name: "parallel-exploration",
-    description: "Use when you need parallel, read-only exploration with hive_background_* or task() (Scout fan-out)",
+    description: "Use when you need parallel, read-only exploration with task() (Scout fan-out)",
     template: `# Parallel Exploration (Scout Fan-Out)
 
 ## Overview
@@ -12955,11 +13497,7 @@ When you need to answer "where/how does X work?" across multiple domains (codeba
 
 **Safe in Planning mode:** This is read-only exploration. It is OK to use during exploratory research even when there is no feature, no plan, and no approved tasks.
 
-**This skill is for read-only research.** For parallel implementation work, use \`hive_skill("dispatching-parallel-agents")\` with \`hive_exec_start\`.
-
-**Two valid execution paths:**
-- **Path A (Hive background tools):** Use \`hive_background_task\`, \`hive_background_output\`, \`hive_background_cancel\` when available.
-- **Path B (Task mode):** Use native \`task()\` for delegation when background tools are not registered.
+**This skill is for read-only research.** For parallel implementation work, use \`hive_skill("dispatching-parallel-agents")\` with \`hive_worktree_create\`.
 
 ## When to Use
 
@@ -12998,51 +13536,16 @@ Split your investigation into 2-4 independent sub-questions. Good decomposition:
 - "What is X?" then "How is X used?" (second depends on first)
 - "Find the bug" then "Fix the bug" (not read-only)
 
-### 2. Spawn Background Tasks (Fan-Out)
+### 2. Spawn Tasks (Fan-Out)
 
 Launch all tasks before waiting for any results:
 
 \`\`\`typescript
-// Path A: Hive background tools (when available)
-// Fan-out: spawn all tasks first
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find hive_background_task implementation",
-  prompt: \`Where is hive_background_task implemented and registered?
-    - Find the tool definition
-    - Find the plugin registration
-    - Return file paths with line numbers\`,
-  sync: false
-})
-
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Analyze background task concurrency",
-  prompt: \`How does background task concurrency/queueing work?
-    - Find the manager/scheduler code
-    - Document the concurrency model
-    - Return file paths with evidence\`,
-  sync: false
-})
-
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find parent notification mechanism",
-  prompt: \`How does parent notification work for background tasks?
-    - Where is the notification built?
-    - How is it sent to the parent session?
-    - Return file paths with evidence\`,
-  sync: false
-})
-\`\`\`
-
-\`\`\`typescript
-// Path B: Task mode (native task tool)
 // Parallelize by issuing multiple task() calls in the same assistant message.
 task({
   subagent_type: 'scout-researcher',
-  description: 'Find hive_background_task implementation',
-  prompt: \`Where is hive_background_task implemented and registered?
+  description: 'Find API route implementation',
+  prompt: \`Where are API routes implemented and registered?
     - Find the tool definition
     - Find the plugin registration
     - Return file paths with line numbers\`,
@@ -13068,8 +13571,7 @@ task({
 \`\`\`
 
 **Key points:**
-- Use \`agent: "scout-researcher"\` for read-only exploration
-- Use \`sync: false\` to return immediately (non-blocking)
+- Use \`subagent_type: 'scout-researcher'\` for read-only exploration
 - Give each task a clear, focused \`description\`
 - Make prompts specific about what evidence to return
 
@@ -13084,35 +13586,7 @@ You'll receive a \`<system-reminder>\` notification when each task completes.
 
 ### 4. Collect Results
 
-When notified of completion, retrieve results:
-
-\`\`\`typescript
-// Path A: Hive background tools
-// Get output from completed task
-hive_background_output({
-  task_id: "task-abc123",
-  block: false  // Don't wait, task already done
-})
-\`\`\`
-
-**For incremental output (long-running tasks):**
-
-\`\`\`typescript
-// First call - get initial output
-hive_background_output({
-  task_id: "task-abc123",
-  block: true,      // Wait for output
-  timeout: 30000    // 30 second timeout
-})
-// Returns: { output: "...", cursor: "5" }
-
-// Later call - get new output since cursor
-hive_background_output({
-  task_id: "task-abc123",
-  cursor: "5",      // Resume from message 5
-  block: true
-})
-\`\`\`
+When each task completes, its result is returned directly. Collect the outputs from each task and proceed to synthesis.
 
 ### 5. Synthesize Findings
 
@@ -13123,18 +13597,9 @@ Combine results from all tasks:
 
 ### 6. Cleanup (If Needed)
 
-Cancel tasks that are no longer needed:
+No manual cancellation is required in task mode.
 
-\`\`\`typescript
-// Path A: Hive background tools
-// Cancel specific task
-hive_background_cancel({ task_id: "task-abc123" })
-
-// Cancel all your background tasks
-hive_background_cancel({ all: true })
-\`\`\`
-
-## Prompt Templates
+## Prompt Templates
 
 ### Codebase Slice
 
@@ -13180,48 +13645,20 @@ Return:
 
 ## Real Example
 
-**Investigation:** "How does the background task system work?"
+**Investigation:** "How does the API routing system work?"
 
 **Decomposition:**
-1. Implementation: Where is \`hive_background_task\` tool defined?
-2. Concurrency: How does task scheduling/queueing work?
-3. Notifications: How does parent session get notified?
+1. Implementation: Where are API routes defined?
+2. Routing: How does route registration work?
+3. Notifications: How are errors surfaced to the caller?
 
 **Fan-out:**
 \`\`\`typescript
-// Path A: Hive background tools
-// Task 1: Implementation
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find hive_background_task implementation",
-  prompt: "Where is hive_background_task implemented? Find tool definition and registration.",
-  sync: false
-})
-
-// Task 2: Concurrency
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Analyze concurrency model",
-  prompt: "How does background task concurrency work? Find the manager/scheduler.",
-  sync: false
-})
-
-// Task 3: Notifications
-hive_background_task({
-  agent: "scout-researcher",
-  description: "Find notification mechanism",
-  prompt: "How are parent sessions notified of task completion?",
-  sync: false
-})
-\`\`\`
-
-\`\`\`typescript
-// Path B: Task mode (native task tool)
 // Parallelize by issuing multiple task() calls in the same assistant message.
 task({
   subagent_type: 'scout-researcher',
-  description: 'Find hive_background_task implementation',
-  prompt: 'Where is hive_background_task implemented? Find tool definition and registration.',
+  description: 'Find API route implementation',
+  prompt: 'Where are API routes implemented? Find tool definition and registration.',
 });
 
 task({
@@ -13249,20 +13686,12 @@ task({
 **Spawning sequentially (defeats the purpose):**
 \`\`\`typescript
 // BAD: Wait for each before spawning next
-const result1 = await hive_background_task({ ..., sync: true })
-const result2 = await hive_background_task({ ..., sync: true })
-\`\`\`
-
-\`\`\`typescript
-// GOOD: Spawn all, then collect
-hive_background_task({ ..., sync: false })  // Returns immediately
-hive_background_task({ ..., sync: false })  // Returns immediately
-hive_background_task({ ..., sync: false })  // Returns immediately
-// ... later, collect results with hive_background_output
+await task({ ... });
+await task({ ... });
 \`\`\`
 
 \`\`\`typescript
-// GOOD (task mode): Spawn all in the same assistant message
+// GOOD: Spawn all in the same assistant message
 task({ ... });
 task({ ... });
 task({ ... });
@@ -13291,9 +13720,7 @@ task({ ... });
 
 After using this pattern, verify:
 - [ ] All tasks spawned before collecting any results (true fan-out)
-- [ ] Received notifications for completed tasks (Path A)
-- [ ] Successfully retrieved output with \`hive_background_output\` (Path A)
-- [ ] Verified \`task()\` fan-out pattern used when in task mode (Path B)
+- [ ] Verified \`task()\` fan-out pattern used for parallel exploration
 - [ ] Synthesized findings into coherent answer`
   },
   {
@@ -13947,7 +14374,7 @@ Never fix bugs without a test.
 
 ## Testing Anti-Patterns
 
-When adding mocks or test utilities, read @testing-anti-patterns.md to avoid common pitfalls:
+When adding mocks or test utilities, avoid common pitfalls:
 - Testing mock behavior instead of real behavior
 - Adding test-only methods to production classes
 - Mocking without understanding dependencies
@@ -14210,6 +14637,12 @@ Always include **Depends on** for each task. Use \`none\` to enable parallel sta
 **Verify**:
 - [ ] Run: \`{command}\` → {expected}
 - [ ] {Additional acceptance criteria}
+
+All verification MUST be agent-executable (no human intervention):
+✅ \`bun test\` → all pass
+✅ \`curl -X POST /api/x\` → 201
+❌ "User manually tests..."
+❌ "Visually confirm..."
 \`\`\`\`
 
 ## Remember
@@ -14218,6 +14651,7 @@ Always include **Depends on** for each task. Use \`none\` to enable parallel sta
 - Exact commands with expected output
 - Reference relevant skills with @ syntax
 - DRY, YAGNI, TDD, frequent commits
+- All acceptance criteria must be agent-executable (zero human intervention)
 
 ## Execution Handoff
 
@@ -14374,7 +14808,7 @@ Hybrid agent: plans AND orchestrates. Phase-aware, skills on-demand.
 
 ## Phase Detection (First Action)
 
-Run \`hive_status()\` or \`hive_feature_list()\` to detect phase:
+Run \`hive_status()\` to detect phase:
 
 | Feature State | Phase | Active Section |
 |---------------|-------|----------------|
@@ -14400,18 +14834,16 @@ Run \`hive_status()\` or \`hive_feature_list()\` to detect phase:
 ### Canonical Delegation Threshold
 
 - Delegate to Scout when you cannot name the file path upfront, expect to inspect 2+ files, or the question is open-ended ("how/where does X work?").
-- Prefer \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` for single investigations; use \`sync: false\` only for multi-scout fan-out.
+- Prefer \`task({ subagent_type: "scout-researcher", prompt: "..." })\` for single investigations.
 - Local \`read/grep/glob\` is acceptable only for a single known file and a bounded question.
 
 ### Delegation
 
-- Single-scout research → \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` (blocks until complete, simpler flow)
-- Parallel exploration → Load \`hive_skill("parallel-exploration")\` and follow the task vs hive mode delegation guidance.
-- Implementation → \`hive_exec_start(task)\` (spawns Forager)
-
-In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
+- Single-scout research → \`task({ subagent_type: "scout-researcher", prompt: "..." })\`
+- Parallel exploration → Load \`hive_skill("parallel-exploration")\` and follow the task mode delegation guidance.
+- Implementation → \`hive_worktree_create({ task: "01-task-name" })\` (creates worktree + Forager)
 
-During Planning, default to synchronous exploration (\`sync: true\`). If async/parallel exploration would help, ask the user via \`question()\`.
+During Planning, use \`task({ subagent_type: "scout-researcher", ... })\` for exploration (BLOCKING — returns when done). For parallel exploration, issue multiple \`task()\` calls in the same message.
 
 ### Context Persistence
 
@@ -14420,6 +14852,8 @@ Save discoveries with \`hive_context_write\`:
 - User preferences
 - Research findings
 
+When Scout returns substantial findings (3+ files discovered, architecture patterns, or key decisions), persist them to a feature context file via \`hive_context_write\`.
+
 ### Checkpoints
 
 Before major transitions, verify:
@@ -14427,14 +14861,32 @@ Before major transitions, verify:
 - [ ] Scope defined?
 - [ ] No critical ambiguities?
 
+### Turn Termination
+
+Valid endings:
+- Ask a concrete question
+- Update draft + ask a concrete question
+- Explicitly state you are waiting on background work (tool/task)
+- Auto-transition to the next required action
+
+NEVER end with:
+- "Let me know if you have questions"
+- Summary without a follow-up action
+- "When you're ready..."
+
 ### Loading Skills (On-Demand)
 
 Load when detailed guidance needed:
 - \`hive_skill("brainstorming")\` - exploring ideas and requirements
 - \`hive_skill("writing-plans")\` - structuring implementation plans
 - \`hive_skill("dispatching-parallel-agents")\` - parallel task delegation
-- \`hive_skill("parallel-exploration")\` - parallel read-only research via task() or hive_background_task (Scout fan-out)
+- \`hive_skill("parallel-exploration")\` - parallel read-only research via task() (Scout fan-out)
 - \`hive_skill("executing-plans")\` - step-by-step plan execution
+- \`hive_skill("systematic-debugging")\` - encountering bugs, test failures, or unexpected behavior
+- \`hive_skill("test-driven-development")\` - implementing features with TDD approach
+- \`hive_skill("verification-before-completion")\` - before claiming work is complete or creating PRs
+- \`hive_skill("docker-mastery")\` - working with Docker containers, debugging, docker-compose
+- \`hive_skill("agents-md-mastery")\` - bootstrapping/updating AGENTS.md, quality review
 
 Load ONE skill at a time. Only when you need guidance beyond this prompt.
 
@@ -14457,6 +14909,14 @@ Load ONE skill at a time. Only when you need guidance beyond this prompt.
 | Premature abstraction | "Abstract or inline?" |
 | Over-validation | "Minimal or comprehensive checks?" |
 
+### Challenge User Assumptions
+
+When a proposal relies on fragile assumptions, challenge them explicitly:
+
+- Identify the assumption and state it plainly.
+- Ask what changes if the assumption is wrong.
+- Offer a lean fallback that still meets core goals.
+
 ### Gap Classification
 
 | Gap | Action |
@@ -14493,7 +14953,7 @@ After review decision, offer execution choice (subagent-driven vs parallel sessi
 
 - Research BEFORE asking (use \`hive_skill("parallel-exploration")\` for multi-domain research)
 - Save draft as working memory
-- Don't implement (no edits/worktrees). Read-only exploration is allowed (local tools + Scout via hive_background_task).
+- Don't implement (no edits/worktrees). Read-only exploration is allowed (local tools + Scout via task()).
 
 ---
 
@@ -14522,24 +14982,15 @@ Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **b
 ### Worker Spawning
 
 \`\`\`
-hive_exec_start({ task: "01-task-name" })  // Creates worktree + Forager
+hive_worktree_create({ task: "01-task-name" })  // Creates worktree + Forager
 \`\`\`
 
 ### After Delegation
 
-1. Wait for the completion notification (no polling required)
-2. Use \`hive_worker_status()\` for spot checks or if you suspect notifications did not deliver
-3. Use \`hive_background_output\` only if interim output is explicitly needed, or after completion
-4. When calling \`hive_background_output\`, choose a timeout (30-120s) based on task size
-5. If blocked: \`question()\` → user decision → \`continueFrom: "blocked"\`
-
-### Observation Polling (Recommended)
-
-- Prefer completion notifications over polling
-- Use \`hive_worker_status()\` for observation-based spot checks
-- Avoid tight loops with \`hive_background_output\`; if needed, wait 30-60s between checks
-- If you suspect notifications did not deliver, do a single \`hive_worker_status()\` check first
-- If you need to fetch final results, call \`hive_background_output({ task_id, block: false })\` after the completion notice
+1. \`task()\` is BLOCKING — when it returns, the worker is DONE
+2. Immediately call \`hive_status()\` to check the new task state and find next runnable tasks
+3. If task status is blocked: read blocker info → \`question()\` → user decision → resume with \`continueFrom: "blocked"\`
+4. Do NOT wait for notifications or poll — the result is already available when \`task()\` returns
 
 ### Failure Recovery
 
@@ -14549,6 +15000,24 @@ hive_exec_start({ task: "01-task-name" })  // Creates worktree + Forager
 
 \`hive_merge({ task: "01-task-name" })\` after verification
 
+### Post-Batch Review (Hygienic)
+
+After completing and merging a batch:
+1. Ask the user via \`question()\` if they want a Hygienic code review for the batch.
+2. If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\`.
+3. Apply feedback before starting the next batch.
+
+### AGENTS.md Maintenance
+
+After feature completion (all tasks merged):
+1. Sync context findings to AGENTS.md: \`hive_agents_md({ action: "sync", feature: "feature-name" })\`
+2. Review the proposed diff with the user
+3. Apply approved changes to keep AGENTS.md current
+
+For projects without AGENTS.md:
+- Bootstrap with \`hive_agents_md({ action: "init" })\`
+- Generates initial documentation from codebase analysis
+
 ### Orchestration Iron Laws
 
 - Delegate by default
@@ -14566,11 +15035,19 @@ hive_exec_start({ task: "01-task-name" })  // Creates worktree + Forager
 - Ask user before consulting Hygienic (Consultant/Reviewer/Debugger)
 - Load skills on-demand, one at a time
 
-**Never:**
+### Hard Blocks
+
+NEVER violate:
 - Skip phase detection
 - Mix planning and orchestration in same action
 - Auto-load all skills at start
 
+### Anti-Patterns
+
+BLOCKING violations:
+- Ending a turn without a next action
+- Asking for user input in plain text instead of question()
+
 **User Input:** ALWAYS use \`question()\` tool for any user input - NEVER ask questions via plain text. This ensures structured responses.
 `;
 
@@ -14581,25 +15058,38 @@ PLANNER, NOT IMPLEMENTER. "Do X" means "create plan for X".
 
 ## Intent Classification (First)
 
-| Intent | Signals | Action |
-|--------|---------|--------|
-| Trivial | Single file, <10 lines | Do directly. No plan needed. |
-| Simple | 1-2 files, <30 min | Light interview → quick plan |
-| Complex | 3+ files, review needed | Full discovery → detailed plan |
-| Refactor | Existing code changes | Safety: tests, rollback, blast radius |
-| Greenfield | New feature | Research patterns BEFORE asking. Delegate to Scout via \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` for single investigations. |
+| Intent | Signals | Strategy | Action |
+|--------|---------|----------|--------|
+| Trivial | Single file, <10 lines | N/A | Do directly. No plan needed. |
+| Simple | 1-2 files, <30 min | Quick assessment | Light interview → quick plan |
+| Complex | 3+ files, review needed | Full discovery | Full discovery → detailed plan |
+| Refactor | Existing code changes | Safety-first: behavior preservation | Tests → blast radius → plan |
+| Greenfield | New feature | Discovery-first: explore before asking | Research → interview → plan |
+| Architecture | Cross-cutting, multi-system | Strategic: consult Scout | Deep research → plan |
 
-During Planning, default to synchronous exploration (\`sync: true\`). If async/parallel exploration would help, ask the user via \`question()\`.
+During Planning, use \`task({ subagent_type: "scout-researcher", ... })\` for exploration (BLOCKING — returns when done). For parallel exploration, issue multiple \`task()\` calls in the same message.
 
 ## Self-Clearance Check (After Every Exchange)
 
-□ Core objective clear?
-□ Scope defined (IN/OUT)?
-□ No critical ambiguities?
-□ Approach decided?
+□ Core objective clearly defined?
+□ Scope boundaries established (IN/OUT)?
+□ No critical ambiguities remaining?
+□ Technical approach decided?
+□ Test strategy confirmed (TDD/tests-after/none)?
+□ No blocking questions outstanding?
 
-ALL YES → Write plan
-ANY NO → Ask the unclear thing
+ALL YES → Announce "Requirements clear. Generating plan." → Write plan
+ANY NO → Ask the specific unclear thing
+
+## Test Strategy (Ask Before Planning)
+
+For Build and Refactor intents, ASK:
+"Should this include automated tests?"
+- TDD: Red-Green-Refactor per task
+- Tests after: Add test tasks after implementation
+- None: No unit/integration tests
+
+Record decision in draft. Embed in plan tasks.
 
 ## AI-Slop Flags
 
@@ -14609,6 +15099,7 @@ ANY NO → Ask the unclear thing
 | Premature abstraction | "Extracted to utility" | "Abstract or inline?" |
 | Over-validation | "15 error checks for 3 inputs" | "Minimal or comprehensive error handling?" |
 | Documentation bloat | "Added JSDoc everywhere" | "None, minimal, or full docs?" |
+| Fragile assumption | "Assuming X is always true" | "If X is wrong, what should change?" |
 
 ## Gap Classification (Self-Review)
 
@@ -14618,6 +15109,18 @@ ANY NO → Ask the unclear thing
 | MINOR | FIX silently, note in summary |
 | AMBIGUOUS | Apply default, DISCLOSE in summary |
 
+## Turn Termination
+
+Valid endings:
+- Question to user (via question() tool)
+- Draft update + next question
+- Auto-transition to plan generation
+
+NEVER end with:
+- "Let me know if you have questions"
+- Summary without follow-up action
+- "When you're ready..."
+
 ## Draft as Working Memory
 
 Create draft on first exchange. Update after EVERY user response:
@@ -14666,9 +15169,9 @@ Each task MUST declare dependencies with **Depends on**:
 ### Canonical Delegation Threshold
 
 - Delegate to Scout when you cannot name the file path upfront, expect to inspect 2+ files, or the question is open-ended ("how/where does X work?").
-- Prefer \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` for single investigations; use \`sync: false\` only for multi-scout fan-out.
+- Prefer \`task({ subagent_type: "scout-researcher", prompt: "..." })\` for single investigations.
 - Local \`read/grep/glob\` is acceptable only for a single known file and a bounded question.
-- When calling \`hive_background_output\`, choose a timeout (30-120s) based on task size.
+- When running parallel exploration, align with the skill guidance.
 `;
 
 // src/agents/swarm.ts
@@ -14695,6 +15198,8 @@ Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **b
 - When 2+ tasks are runnable: ask operator via \`question()\` before parallelizing
 - Record execution decisions with \`hive_context_write({ name: "execution-decisions", ... })\`
 
+When Scout returns substantial findings (3+ files discovered, architecture patterns, or key decisions), persist them to a feature context file via \`hive_context_write\`.
+
 If tasks are missing **Depends on** metadata, ask the planner to revise the plan before executing.
 
 ### Standard Checks
@@ -14703,7 +15208,7 @@ If tasks are missing **Depends on** metadata, ask the planner to revise the plan
 2. Can I do it myself FOR SURE? REALLY?
 3. Does this require external system data (DBs/APIs/3rd-party tools)?
 → If external data needed: Load \`hive_skill("parallel-exploration")\` for parallel Scout fan-out
-In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
+In task mode, use task() for research fan-out.
 During Planning, default to synchronous exploration. If async exploration would help, ask the user via \`question()\` and follow the onboarding preferences.
 → Default: DELEGATE
 
@@ -14721,38 +15226,38 @@ During Planning, default to synchronous exploration. If async exploration would
 ## Worker Spawning
 
 \`\`\`
-hive_exec_start({ task: "01-task-name" })
-// If delegationRequired returned:
-hive_background_task({ agent: "forager-worker", prompt: "...", sync: false })
+hive_worktree_create({ task: "01-task-name" })
 // If external system data is needed (parallel exploration):
 // Load hive_skill("parallel-exploration") for the full playbook, then:
-// In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
+// In task mode, use task() for research fan-out.
 \`\`\`
 
-**Sync Mode Guidance:**
-- \`sync: true\` — Use for single-scout research when you need the result before continuing
-- \`sync: false\` — Use for parallel fan-out (multiple scouts) or when you can proceed without waiting
+**Delegation Guidance:**
+- \`task()\` is BLOCKING — returns when the worker is done
+- Call \`hive_status()\` immediately after to check new state and find next runnable tasks
+- For parallel fan-out, issue multiple \`task()\` calls in the same message
 
-## After Delegation - ALWAYS VERIFY
+## After Delegation - VERIFY
 
+After every delegation, check:
 - Does it work as expected?
-- Followed existing codebase pattern?
-- Followed MUST DO and MUST NOT DO?
+- Followed existing codebase patterns?
+- Met MUST DO and MUST NOT DO requirements?
+- No unintended side effects?
 
 ## Blocker Handling
 
 When worker reports blocked:
-1. \`hive_worker_status()\` — read blocker info
+1. \`hive_status()\` — read blocker info
 2. \`question()\` — ask user (NEVER plain text)
-3. \`hive_exec_start({ task, continueFrom: "blocked", decision })\`
+3. \`hive_worktree_create({ task, continueFrom: "blocked", decision })\`
 
 ## Failure Recovery (After 3 Consecutive Failures)
 
 1. STOP all further edits
 2. REVERT to last known working state
 3. DOCUMENT what was attempted
-4. Consult: \`task({ subagent_type: "oracle", prompt: "Analyze..." })\`
-5. If Oracle cannot resolve → ASK USER
+4. ASK USER via question() — present options and context
 
 ## Merge Strategy
 
@@ -14762,6 +15267,39 @@ hive_merge({ task: "01-task-name", strategy: "merge" })
 
 Merge only after verification passes.
 
+### Post-Batch Review (Hygienic)
+
+After completing and merging a batch:
+1. Ask the user via \`question()\` if they want a Hygienic code review for the batch.
+2. If yes, run \`task({ subagent_type: "hygienic", prompt: "Review implementation changes from the latest batch." })\`.
+3. Apply feedback before starting the next batch.
+
+### AGENTS.md Maintenance
+
+After completing and merging a batch:
+1. Sync context findings to AGENTS.md: \`hive_agents_md({ action: "sync", feature: "feature-name" })\`
+2. Review the proposed diff with the user
+3. Apply approved changes to keep AGENTS.md current
+
+For quality review of AGENTS.md content, load \`hive_skill("agents-md-mastery")\`.
+
+For projects without AGENTS.md:
+- Bootstrap with \`hive_agents_md({ action: "init" })\`
+- Generates initial documentation from codebase analysis
+
+## Turn Termination
+
+Valid endings:
+- Worker delegation (hive_worktree_create)
+- Status check (hive_status)
+- User question (question())
+- Merge (hive_merge)
+
+NEVER end with:
+- "Let me know when you're ready"
+- Summary without next action
+- Waiting for something unspecified
+
 ## Iron Laws
 
 **Never:**
@@ -14871,6 +15409,17 @@ When asked to retrieve raw data from external systems (MongoDB/Stripe/etc.):
 - GitHub: Permalinks with commit SHA
 - Docs: URL with section anchor
 
+## Persistence
+
+When operating within a feature context:
+- If findings are substantial (3+ files, architecture patterns, or key decisions):
+  \`\`\`
+  hive_context_write({
+    name: "research-{topic}",
+    content: "## {Topic}\\n\\nDate: {YYYY-MM-DD}\\n\\n## Context\\n\\n## Findings"
+  })
+  \`\`\`
+
 ## Iron Laws
 
 **Never:**
@@ -14896,7 +15445,7 @@ Execute directly. NEVER delegate implementation. Work in isolation.
 
 These tools are FORBIDDEN:
 - \`task\` — Orchestrator's job
-- \`hive_exec_start\` — You ARE the spawned worker
+- \`hive_worktree_create\` — You ARE the spawned worker
 - \`hive_merge\` — Orchestrator's job
 
 ## Allowed Research
@@ -14907,6 +15456,20 @@ CAN use for quick lookups:
 - \`ast_grep_search\` — AST patterns
 - \`glob\`, \`grep\`, \`read\` — Codebase exploration
 
+## Resolve Before Blocking
+
+Default to exploration, questions are LAST resort:
+1. Read the referenced files and surrounding code
+2. Search for similar patterns in the codebase
+3. Try a reasonable approach based on conventions
+
+Only report as blocked when:
+- Multiple approaches failed (tried 3+)
+- Decision requires business logic you can't infer
+- External dependency is missing or broken
+
+Context inference: Before asking "what does X do?", READ X first.
+
 ## Plan = READ ONLY
 
 CRITICAL: NEVER MODIFY THE PLAN FILE
@@ -14914,14 +15477,10 @@ CRITICAL: NEVER MODIFY THE PLAN FILE
 - MUST NOT edit, modify, or update plan
 - Only Orchestrator (Swarm) manages plan
 
-## Notepad Location
+## Persistent Notes
 
-Path: \`.hive/features/{feature}/notepads/\`
-- learnings.md: Patterns, conventions, successful approaches
-- issues.md: Problems, blockers, gotchas
-- decisions.md: Architectural choices and rationales
-
-IMPORTANT: Always APPEND — never overwrite.
+For substantial discoveries (architecture patterns, key decisions, gotchas that affect multiple tasks):
+Use \`hive_context_write({ name: "learnings", content: "..." })\` to persist for future workers.
 
 ## Execution Flow
 
@@ -14932,7 +15491,17 @@ Read spec for:
 - **Must NOT do** (guardrails)
 - **Acceptance criteria**
 
-### 2. Implement
+### 2. Orient (Pre-flight Before Coding)
+Before writing code:
+- Confirm dependencies are satisfied and required context is present
+- Read the referenced files and surrounding code
+- Search for similar patterns in the codebase
+- Identify the exact files/sections to touch (from references)
+- Decide the first failing test you will write (TDD)
+- Identify the test command(s) and inputs you will run
+- Plan the minimum change to reach green
+
+### 3. Implement
 Follow spec exactly. Use references for patterns.
 
 \`\`\`
@@ -14941,28 +15510,28 @@ edit(file, { old: "...", new: "..." })   // Implement
 bash("npm test")                          // Verify
 \`\`\`
 
-### 3. Verify
+### 4. Verify
 Run acceptance criteria:
 - Tests pass
 - Build succeeds
 - lsp_diagnostics clean on changed files
 
-### 4. Report
+### 5. Report
 
 **Success:**
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "current-task",
   summary: "Implemented X. Tests pass.",
   status: "completed"
 })
 \`\`\`
 
-**CRITICAL: After hive_exec_complete, STOP IMMEDIATELY.**
+**CRITICAL: After hive_worktree_commit, STOP IMMEDIATELY.**
 
 **Blocked (need user decision):**
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "current-task",
   summary: "Progress on X. Blocked on Y.",
   status: "blocked",
@@ -14975,6 +15544,16 @@ hive_exec_complete({
 })
 \`\`\`
 
+## Completion Checklist
+
+Before calling hive_worktree_commit:
+- All tests in scope are run and passing (Record exact commands and results)
+- Build succeeds if required (Record exact command and result)
+- lsp_diagnostics clean on changed files (Record exact command and result)
+- Changes match the spec and references
+- No extra scope creep or unrelated edits
+- Summary includes what changed, why, and verification status
+
 ## Failure Recovery
 
 After 3 consecutive failures:
@@ -14984,11 +15563,20 @@ After 3 consecutive failures:
 
 ## Iron Laws
 
+### Docker Sandbox
+
+When sandbox mode is active, ALL bash commands automatically run inside a Docker container.
+- Your commands are transparently wrapped — you don't need to do anything special
+- File edits (Read, Write, Edit tools) still work on the host filesystem (worktree is mounted)
+- If a command must run on the host (e.g., git operations), report as blocked and ask the user
+- If a command fails with "docker: command not found", report as blocked — the host needs Docker installed
+- For deeper Docker expertise, load \`hive_skill("docker-mastery")\`
+
 **Never:**
 - Exceed task scope
 - Modify plan file
-- Use \`task\` or \`hive_exec_start\`
-- Continue after hive_exec_complete
+- Use \`task\` or \`hive_worktree_create\`
+- Continue after hive_worktree_commit
 - Skip verification
 
 **Always:**
@@ -15026,7 +15614,10 @@ Self-check before every critique:
 
 ### 2. Verification & Acceptance Criteria
 - Are criteria measurable and concrete?
-- Red flags: "should work", "looks good", "properly handles"
+- Are they agent-executable (tool-runnable) without human judgment?
+- Do they specify exact commands + expected signals (exit code, output text, counts)?
+- Red flags: "should work", "looks good", "properly handles", "verify manually"
+- If manual checks are required, the plan must explain why automation is impossible
 
 ### 3. Context Completeness (90% Confidence)
 - Could a capable worker execute with 90% confidence?
@@ -15158,6 +15749,11 @@ import * as fs8 from "fs";
 import * as path4 from "path";
 import * as fs10 from "fs";
 import * as path6 from "path";
+import * as fs11 from "fs";
+import * as path7 from "path";
+import { existsSync as existsSync5 } from "fs";
+import { join as join8, sep } from "path";
+import { execSync } from "child_process";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -15995,7 +16591,7 @@ var DEFAULT_HIVE_CONFIG = {
   disableSkills: [],
   disableMcps: [],
   agentMode: "unified",
-  delegateMode: "task",
+  sandbox: "none",
   agents: {
     "hive-master": {
       model: DEFAULT_AGENT_MODELS["hive-master"],
@@ -16049,16 +16645,12 @@ var FEATURE_FILE = "feature.json";
 var STATUS_FILE = "status.json";
 var REPORT_FILE = "report.md";
 var APPROVED_FILE = "APPROVED";
-var JOURNAL_FILE = "journal.md";
 function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function getHivePath(projectRoot) {
   return path2.join(projectRoot, HIVE_DIR);
 }
-function getJournalPath(projectRoot) {
-  return path2.join(getHivePath(projectRoot), JOURNAL_FILE);
-}
 function getFeaturesPath(projectRoot) {
   return path2.join(getHivePath(projectRoot), FEATURES_DIR);
 }
@@ -16295,22 +16887,6 @@ function listFeatures(projectRoot) {
     return [];
   return fs22.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
 }
-var JOURNAL_TEMPLATE = `# Hive Journal
-
-Audit trail of project learnings. Updated when trouble is resolved.
-
----
-
-<!-- Entry template:
-### YYYY-MM-DD: feature-name
-
-**Trouble**: What went wrong
-**Resolution**: How it was fixed
-**Constraint**: Never/Always rule derived (add to Iron Laws if recurring)
-**See**: .hive/features/feature-name/plan.md
--->
-`;
-
 class FeatureService {
   projectRoot;
   constructor(projectRoot) {
@@ -16324,10 +16900,6 @@ class FeatureService {
     ensureDir(featurePath);
     ensureDir(getContextPath(this.projectRoot, name));
     ensureDir(getTasksPath(this.projectRoot, name));
-    const journalPath = getJournalPath(this.projectRoot);
-    if (!fileExists(journalPath)) {
-      fs3.writeFileSync(journalPath, JOURNAL_TEMPLATE);
-    }
     const feature = {
       name,
       status: "planning",
@@ -16596,6 +17168,27 @@ class TaskService {
   }
   buildSpecContent(params) {
     const { featureName, task, dependsOn, allTasks, planContent, contextFiles = [], completedTasks = [] } = params;
+    const getTaskType = (planSection2, taskName) => {
+      if (!planSection2) {
+        return null;
+      }
+      const fileTypeMatches = Array.from(planSection2.matchAll(/-\s*(Create|Modify|Test):/gi)).map((match) => match[1].toLowerCase());
+      const fileTypes = new Set(fileTypeMatches);
+      if (fileTypes.size === 0) {
+        return taskName.toLowerCase().includes("test") ? "testing" : null;
+      }
+      if (fileTypes.size === 1) {
+        const onlyType = Array.from(fileTypes)[0];
+        if (onlyType === "create")
+          return "greenfield";
+        if (onlyType === "test")
+          return "testing";
+      }
+      if (fileTypes.has("modify")) {
+        return "modification";
+      }
+      return null;
+    };
     const specLines = [
       `# Task: ${task.folder}`,
       "",
@@ -16624,6 +17217,10 @@ class TaskService {
       specLines.push("_No plan section available._");
     }
     specLines.push("");
+    const taskType = getTaskType(planSection, task.name);
+    if (taskType) {
+      specLines.push("## Task Type", "", taskType, "");
+    }
     if (contextFiles.length > 0) {
       const contextCompiled = contextFiles.map((f) => `## ${f.name}
 
@@ -21474,6 +22071,12 @@ class ContextService {
     ensureDir(contextPath);
     const filePath = path4.join(contextPath, this.normalizeFileName(fileName));
     writeText(filePath, content);
+    const totalChars = this.list(featureName).reduce((sum, c) => sum + c.content.length, 0);
+    if (totalChars > 20000) {
+      return `${filePath}
+
+⚠️ Context total: ${totalChars} chars (exceeds 20,000). Consider archiving older contexts with contextService.archive().`;
+    }
     return filePath;
   }
   read(featureName, fileName) {
@@ -21519,6 +22122,37 @@ ${f.content}`);
 
 `);
   }
+  archive(featureName) {
+    const contexts = this.list(featureName);
+    if (contexts.length === 0)
+      return { archived: [], archivePath: "" };
+    const contextPath = getContextPath(this.projectRoot, featureName);
+    const archiveDir = path4.join(contextPath, "..", "archive");
+    ensureDir(archiveDir);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const archived = [];
+    for (const ctx of contexts) {
+      const archiveName = `${timestamp}_${ctx.name}.md`;
+      const src = path4.join(contextPath, `${ctx.name}.md`);
+      const dest = path4.join(archiveDir, archiveName);
+      fs8.copyFileSync(src, dest);
+      fs8.unlinkSync(src);
+      archived.push(ctx.name);
+    }
+    return { archived, archivePath: archiveDir };
+  }
+  stats(featureName) {
+    const contexts = this.list(featureName);
+    if (contexts.length === 0)
+      return { count: 0, totalChars: 0 };
+    const sorted2 = [...contexts].sort((a, b) => new Date(a.updatedAt).getTime() - new Date(b.updatedAt).getTime());
+    return {
+      count: contexts.length,
+      totalChars: contexts.reduce((sum, c) => sum + c.content.length, 0),
+      oldest: sorted2[0].name,
+      newest: sorted2[sorted2.length - 1].name
+    };
+  }
   normalizeFileName(name) {
     const normalized = name.replace(/\.md$/, "");
     return `${normalized}.md`;
@@ -21632,12 +22266,303 @@ class ConfigService {
     const config2 = this.get();
     return config2.disableMcps ?? [];
   }
-  getDelegateMode() {
+  getSandboxConfig() {
     const config2 = this.get();
-    return config2.delegateMode ?? "task";
+    const mode = config2.sandbox ?? "none";
+    const image = config2.dockerImage;
+    const persistent = config2.persistentContainers ?? mode === "docker";
+    return { mode, ...image && { image }, persistent };
+  }
+}
+
+class AgentsMdService {
+  rootDir;
+  contextService;
+  constructor(rootDir, contextService) {
+    this.rootDir = rootDir;
+    this.contextService = contextService;
+  }
+  async init() {
+    const agentsMdPath = path7.join(this.rootDir, "AGENTS.md");
+    const existed = fileExists(agentsMdPath);
+    if (existed) {
+      const existing = readText(agentsMdPath);
+      return { content: existing || "", existed: true };
+    }
+    const content = await this.scanAndGenerate();
+    return { content, existed: false };
+  }
+  async sync(featureName) {
+    const contexts = this.contextService.list(featureName);
+    const agentsMdPath = path7.join(this.rootDir, "AGENTS.md");
+    const current = await fs11.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 = path7.join(this.rootDir, "AGENTS.md");
+    const isNew = !fileExists(agentsMdPath);
+    writeText(agentsMdPath, content);
+    return { path: agentsMdPath, chars: content.length, isNew };
+  }
+  extractFindings(contexts) {
+    const findings = [];
+    const patterns = [
+      /we\s+use\s+[^.\n]+/gi,
+      /prefer\s+[^.\n]+\s+over\s+[^.\n]+/gi,
+      /don't\s+use\s+[^.\n]+/gi,
+      /do\s+not\s+use\s+[^.\n]+/gi,
+      /(?:build|test|dev)\s+command:\s*[^.\n]+/gi,
+      /[a-zA-Z]+\s+lives?\s+in\s+\/[^\s.\n]+/gi
+    ];
+    for (const context of contexts) {
+      const lines = context.content.split(`
+`);
+      for (const line of lines) {
+        const trimmed2 = line.trim();
+        if (!trimmed2 || trimmed2.startsWith("#"))
+          continue;
+        for (const pattern of patterns) {
+          const matches = trimmed2.match(pattern);
+          if (matches) {
+            for (const match of matches) {
+              const finding = match.trim();
+              if (finding && !findings.includes(finding)) {
+                findings.push(finding);
+              }
+            }
+          }
+        }
+      }
+    }
+    return findings;
+  }
+  generateProposals(findings, current) {
+    const proposals = [];
+    const currentLower = current.toLowerCase();
+    for (const finding of findings) {
+      const findingLower = finding.toLowerCase();
+      if (!currentLower.includes(findingLower)) {
+        proposals.push(finding);
+      }
+    }
+    return proposals;
+  }
+  formatDiff(current, proposals) {
+    if (proposals.length === 0)
+      return "";
+    const lines = proposals.map((p) => `+ ${p}`);
+    return lines.join(`
+`);
+  }
+  async scanAndGenerate() {
+    const detections = await this.detectProjectInfo();
+    return this.generateTemplate(detections);
+  }
+  async detectProjectInfo() {
+    const packageJsonPath = path7.join(this.rootDir, "package.json");
+    let packageJson = null;
+    if (fileExists(packageJsonPath)) {
+      try {
+        const content = readText(packageJsonPath);
+        packageJson = content ? JSON.parse(content) : null;
+      } catch {}
+    }
+    const info = {
+      packageManager: this.detectPackageManager(),
+      language: this.detectLanguage(),
+      testFramework: this.detectTestFramework(packageJson),
+      buildCommand: packageJson?.scripts?.build || null,
+      testCommand: packageJson?.scripts?.test || null,
+      devCommand: packageJson?.scripts?.dev || null,
+      isMonorepo: this.detectMonorepo(packageJson)
+    };
+    return info;
+  }
+  detectPackageManager() {
+    if (fileExists(path7.join(this.rootDir, "bun.lockb")))
+      return "bun";
+    if (fileExists(path7.join(this.rootDir, "pnpm-lock.yaml")))
+      return "pnpm";
+    if (fileExists(path7.join(this.rootDir, "yarn.lock")))
+      return "yarn";
+    if (fileExists(path7.join(this.rootDir, "package-lock.json")))
+      return "npm";
+    return "npm";
+  }
+  detectLanguage() {
+    if (fileExists(path7.join(this.rootDir, "tsconfig.json")))
+      return "TypeScript";
+    if (fileExists(path7.join(this.rootDir, "package.json")))
+      return "JavaScript";
+    if (fileExists(path7.join(this.rootDir, "requirements.txt")))
+      return "Python";
+    if (fileExists(path7.join(this.rootDir, "go.mod")))
+      return "Go";
+    if (fileExists(path7.join(this.rootDir, "Cargo.toml")))
+      return "Rust";
+    return "Unknown";
+  }
+  detectTestFramework(packageJson) {
+    if (!packageJson)
+      return null;
+    const deps = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    if (deps?.vitest)
+      return "vitest";
+    if (deps?.jest)
+      return "jest";
+    if (this.detectPackageManager() === "bun")
+      return "bun test";
+    if (deps?.pytest)
+      return "pytest";
+    return null;
+  }
+  detectMonorepo(packageJson) {
+    if (!packageJson)
+      return false;
+    return !!packageJson.workspaces;
+  }
+  generateTemplate(info) {
+    const sections = [];
+    sections.push(`# Agent Guidelines
+`);
+    sections.push(`## Overview
+`);
+    sections.push(`This project uses AI-assisted development. Follow these guidelines.
+`);
+    sections.push(`## Build & Test Commands
+`);
+    sections.push("```bash");
+    if (info.isMonorepo) {
+      sections.push("# This is a monorepo using bun workspaces");
+    }
+    if (info.buildCommand) {
+      sections.push(`# Build`);
+      sections.push(`${info.packageManager} run build`);
+      sections.push("");
+    }
+    if (info.testCommand) {
+      sections.push(`# Run tests`);
+      sections.push(`${info.packageManager} ${info.testCommand === "bun test" ? "test" : "run test"}`);
+      sections.push("");
+    }
+    if (info.devCommand) {
+      sections.push(`# Development mode`);
+      sections.push(`${info.packageManager} run dev`);
+    }
+    sections.push("```\n");
+    sections.push(`## Technology Stack
+`);
+    sections.push(`- **Language**: ${info.language}`);
+    sections.push(`- **Package Manager**: ${info.packageManager}`);
+    if (info.testFramework) {
+      sections.push(`- **Test Framework**: ${info.testFramework}`);
+    }
+    if (info.isMonorepo) {
+      sections.push(`- **Structure**: Monorepo with workspaces`);
+    }
+    sections.push("");
+    sections.push(`## Code Style
+`);
+    sections.push(`Follow existing patterns in the codebase.
+`);
+    sections.push(`## Architecture Principles
+`);
+    sections.push(`Document key architectural decisions here.
+`);
+    return sections.join(`
+`);
+  }
+}
+
+class DockerSandboxService {
+  static detectImage(worktreePath) {
+    if (existsSync5(join8(worktreePath, "Dockerfile"))) {
+      return null;
+    }
+    if (existsSync5(join8(worktreePath, "package.json"))) {
+      return "node:22-slim";
+    }
+    if (existsSync5(join8(worktreePath, "requirements.txt")) || existsSync5(join8(worktreePath, "pyproject.toml"))) {
+      return "python:3.12-slim";
+    }
+    if (existsSync5(join8(worktreePath, "go.mod"))) {
+      return "golang:1.22-slim";
+    }
+    if (existsSync5(join8(worktreePath, "Cargo.toml"))) {
+      return "rust:1.77-slim";
+    }
+    return "ubuntu:24.04";
+  }
+  static buildRunCommand(worktreePath, command, image) {
+    const escapedCommand = command.replace(/'/g, "'\\''");
+    return `docker run --rm -v ${worktreePath}:/app -w /app ${image} sh -c '${escapedCommand}'`;
+  }
+  static containerName(worktreePath) {
+    const parts = worktreePath.split(sep);
+    const worktreeIdx = parts.indexOf(".worktrees");
+    if (worktreeIdx === -1 || worktreeIdx + 2 >= parts.length) {
+      return `hive-sandbox-${Date.now()}`;
+    }
+    const feature = parts[worktreeIdx + 1];
+    const task = parts[worktreeIdx + 2];
+    const name = `hive-${feature}-${task}`.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+    return name.slice(0, 63);
+  }
+  static ensureContainer(worktreePath, image) {
+    const name = this.containerName(worktreePath);
+    try {
+      execSync(`docker inspect --format='{{.State.Running}}' ${name}`, { stdio: "pipe" });
+      return name;
+    } catch {
+      execSync(`docker run -d --name ${name} -v ${worktreePath}:/app -w /app ${image} tail -f /dev/null`, { stdio: "pipe" });
+      return name;
+    }
+  }
+  static buildExecCommand(containerName, command) {
+    const escapedCommand = command.replace(/'/g, "'\\''");
+    return `docker exec ${containerName} sh -c '${escapedCommand}'`;
+  }
+  static stopContainer(worktreePath) {
+    const name = this.containerName(worktreePath);
+    try {
+      execSync(`docker rm -f ${name}`, { stdio: "ignore" });
+    } catch {}
+  }
+  static isDockerAvailable() {
+    try {
+      execSync("docker info", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
   }
-  isHiveBackgroundEnabled() {
-    return this.getDelegateMode() === "hive";
+  static wrapCommand(worktreePath, command, config2) {
+    if (command.startsWith("HOST: ")) {
+      return command.substring(6);
+    }
+    if (config2.mode === "none") {
+      return command;
+    }
+    let image;
+    if (config2.image) {
+      image = config2.image;
+    } else {
+      image = this.detectImage(worktreePath);
+      if (image === null) {
+        return command;
+      }
+    }
+    if (config2.persistent) {
+      const containerName = this.ensureContainer(worktreePath, image);
+      return this.buildExecCommand(containerName, command);
+    } else {
+      return this.buildRunCommand(worktreePath, command, image);
+    }
   }
 }
 function computeRunnableAndBlocked(tasks) {
@@ -21747,16 +22672,26 @@ ${spec}
 
 ---
 
+## Pre-implementation Checklist
+
+Before writing code, confirm:
+1. Dependencies are satisfied and required context is present.
+2. The exact files/sections to touch (from references) are identified.
+3. The first failing test to write is clear (TDD).
+4. The minimal change needed to reach green is planned.
+
+---
+
 ## Blocker Protocol
 
 If you hit a blocker requiring human decision, **DO NOT** use the question tool directly.
 Instead, escalate via the blocker protocol:
 
 1. **Save your progress** to the worktree (commit if appropriate)
-2. **Call hive_exec_complete** with blocker info:
+2. **Call hive_worktree_commit** with blocker info:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "blocked",
@@ -21770,7 +22705,7 @@ hive_exec_complete({
 })
 \`\`\`
 
-**After calling hive_exec_complete with blocked status, STOP IMMEDIATELY.**
+**After calling hive_worktree_commit with blocked status, STOP IMMEDIATELY.**
 
 The Hive Master will:
 1. Receive your blocker info
@@ -21786,7 +22721,7 @@ This keeps the user focused on ONE conversation (Hive Master) instead of multipl
 When your task is **fully complete**:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "completed",
@@ -21794,14 +22729,20 @@ hive_exec_complete({
 })
 \`\`\`
 
-**CRITICAL: After calling hive_exec_complete, you MUST STOP IMMEDIATELY.**
+**CRITICAL: After calling hive_worktree_commit, you MUST STOP IMMEDIATELY.**
 Do NOT continue working. Do NOT respond further. Your session is DONE.
 The Hive Master will take over from here.
 
+**Summary Guidance** (used verbatim for downstream task context):
+1. Start with **what changed** (files/areas touched).
+2. Mention **why** if it affects future tasks.
+3. Note **verification evidence** (tests/build/lint) or explicitly say "Not run".
+4. Keep it **2-4 sentences** max.
+
 If you encounter an **unrecoverable error**:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "failed",
@@ -21812,7 +22753,7 @@ hive_exec_complete({
 If you made **partial progress** but can't continue:
 
 \`\`\`
-hive_exec_complete({
+hive_worktree_commit({
   task: "${task}",
   feature: "${feature}",
   status: "partial",
@@ -21846,16 +22787,16 @@ After 3 failed attempts at same fix: STOP and report blocker.
 
 **You have access to:**
 - All standard tools (read, write, edit, bash, glob, grep)
-- \`hive_exec_complete\` - Signal task done/blocked/failed
-- \`hive_exec_abort\` - Abort and discard changes
+- \`hive_worktree_commit\` - Signal task done/blocked/failed
+- \`hive_worktree_discard\` - Abort and discard changes
 - \`hive_plan_read\` - Re-read plan if needed
 - \`hive_context_write\` - Save learnings for future tasks
 
 **You do NOT have access to (or should not use):**
 - \`question\` - Escalate via blocker protocol instead
-- \`hive_exec_start\` - No spawning sub-workers
+- \`hive_worktree_create\` - No spawning sub-workers
 - \`hive_merge\` - Only Hive Master merges
-- \`hive_background_task\` / \`task\` - No recursive delegation
+- \`task\` - No recursive delegation
 
 ---
 
@@ -21865,7 +22806,7 @@ After 3 failed attempts at same fix: STOP and report blocker.
 2. **Stay in scope** - Only do what the spec asks
 3. **Escalate blockers** - Don't guess on important decisions
 4. **Save context** - Use hive_context_write for discoveries
-5. **Complete cleanly** - Always call hive_exec_complete when done
+5. **Complete cleanly** - Always call hive_worktree_commit when done
 
 ---
 
@@ -22107,63 +23048,6 @@ function applyContextBudget(files, config2 = {}) {
 // src/utils/prompt-file.ts
 import * as fs6 from "fs";
 import * as path5 from "path";
-function findWorkspaceRoot(startDir) {
-  try {
-    let current = path5.resolve(startDir);
-    while (true) {
-      const hivePath = path5.join(current, ".hive");
-      if (fs6.existsSync(hivePath) && fs6.statSync(hivePath).isDirectory()) {
-        return current;
-      }
-      const parent = path5.dirname(current);
-      if (parent === current) {
-        return null;
-      }
-      current = parent;
-    }
-  } catch {
-    return null;
-  }
-}
-function isValidPromptFilePath(filePath, workspaceRoot) {
-  try {
-    const normalizedFilePath = path5.resolve(filePath);
-    const normalizedWorkspace = path5.resolve(workspaceRoot);
-    let normalizedFilePathForCompare = normalizePath(normalizedFilePath);
-    let normalizedWorkspaceForCompare = normalizePath(normalizedWorkspace);
-    if (process.platform === "win32") {
-      normalizedFilePathForCompare = normalizedFilePathForCompare.toLowerCase();
-      normalizedWorkspaceForCompare = normalizedWorkspaceForCompare.toLowerCase();
-    }
-    if (!normalizedFilePathForCompare.startsWith(normalizedWorkspaceForCompare + "/") && normalizedFilePathForCompare !== normalizedWorkspaceForCompare) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function resolvePromptFromFile(promptFilePath, workspaceRoot) {
-  if (!isValidPromptFilePath(promptFilePath, workspaceRoot)) {
-    return {
-      error: `Prompt file path "${promptFilePath}" is outside the workspace. ` + `Only files within "${workspaceRoot}" are allowed.`
-    };
-  }
-  const resolvedPath = path5.resolve(promptFilePath);
-  if (!fs6.existsSync(resolvedPath)) {
-    return {
-      error: `Prompt file not found: "${resolvedPath}"`
-    };
-  }
-  try {
-    const content = fs6.readFileSync(resolvedPath, "utf-8");
-    return { content };
-  } catch (err) {
-    return {
-      error: `Failed to read prompt file: ${err instanceof Error ? err.message : "Unknown error"}`
-    };
-  }
-}
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
   const promptDir = path5.join(hiveDir, "features", feature, "tasks", task);
   const promptPath = path5.join(promptDir, "worker-prompt.md");
@@ -22174,1451 +23058,58 @@ function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
   return promptPath;
 }
 
-// src/background/types.ts
-var VALID_TRANSITIONS = {
-  spawned: ["pending", "running", "error", "cancelled"],
-  pending: ["running", "error", "cancelled"],
-  running: ["completed", "error", "cancelled", "blocked", "failed"],
-  completed: [],
-  error: [],
-  cancelled: [],
-  blocked: ["running", "cancelled"],
-  failed: []
-};
-function isTerminalStatus(status) {
-  return VALID_TRANSITIONS[status].length === 0;
-}
-function isValidTransition(from, to) {
-  return VALID_TRANSITIONS[from].includes(to);
-}
-// src/background/store.ts
-function generateTaskId() {
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 8);
-  return `task-${timestamp}-${random}`;
-}
-
-class BackgroundTaskStore {
-  tasks = new Map;
-  idempotencyIndex = new Map;
-  create(options) {
-    if (options.idempotencyKey) {
-      const existingId = this.idempotencyIndex.get(options.idempotencyKey);
-      if (existingId) {
-        throw new Error(`Idempotency key "${options.idempotencyKey}" already exists for task "${existingId}". ` + `Use getByIdempotencyKey() to retrieve the existing task.`);
-      }
-    }
-    const taskId = generateTaskId();
-    const now = new Date().toISOString();
-    const record2 = {
-      taskId,
-      sessionId: options.sessionId,
-      agent: options.agent,
-      description: options.description,
-      status: "spawned",
-      provider: "hive",
-      idempotencyKey: options.idempotencyKey,
-      createdAt: now,
-      lastActiveAt: now,
-      parentSessionId: options.parentSessionId,
-      parentMessageId: options.parentMessageId,
-      parentAgent: options.parentAgent,
-      notifyParent: options.notifyParent,
-      hiveFeature: options.hiveFeature,
-      hiveTaskFolder: options.hiveTaskFolder,
-      workdir: options.workdir
-    };
-    this.tasks.set(taskId, record2);
-    if (options.idempotencyKey) {
-      this.idempotencyIndex.set(options.idempotencyKey, taskId);
-    }
-    return record2;
-  }
-  get(taskId) {
-    return this.tasks.get(taskId);
-  }
-  getByIdempotencyKey(key) {
-    const taskId = this.idempotencyIndex.get(key);
-    if (!taskId)
-      return;
-    return this.tasks.get(taskId);
-  }
-  getByHiveTask(feature, taskFolder) {
-    for (const task of this.tasks.values()) {
-      if (task.hiveFeature === feature && task.hiveTaskFolder === taskFolder) {
-        return task;
-      }
-    }
+// src/hooks/variant-hook.ts
+var HIVE_AGENT_NAMES = [
+  "hive-master",
+  "architect-planner",
+  "swarm-orchestrator",
+  "scout-researcher",
+  "forager-worker",
+  "hygienic-reviewer"
+];
+function isHiveAgent(agent) {
+  return agent !== undefined && HIVE_AGENT_NAMES.includes(agent);
+}
+function normalizeVariant(variant) {
+  if (variant === undefined)
     return;
+  const trimmed2 = variant.trim();
+  return trimmed2.length > 0 ? trimmed2 : undefined;
+}
+
+// src/index.ts
+function formatSkillsXml(skills) {
+  if (skills.length === 0)
+    return "";
+  const skillsXml = skills.map((skill) => {
+    return [
+      "  <skill>",
+      `    <name>${skill.name}</name>`,
+      `    <description>(hive - Skill) ${skill.description}</description>`,
+      "  </skill>"
+    ].join(`
+`);
+  }).join(`
+`);
+  return `
+
+<available_skills>
+${skillsXml}
+</available_skills>`;
+}
+async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot) {
+  const agentConfig = configService.getAgentConfig(agentName);
+  const autoLoadSkills = agentConfig.autoLoadSkills ?? [];
+  if (autoLoadSkills.length === 0) {
+    return "";
   }
-  updateStatus(taskId, newStatus, updates) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      throw new Error(`Task "${taskId}" not found`);
-    }
-    if (!isValidTransition(task.status, newStatus)) {
-      throw new Error(`Invalid state transition: ${task.status} -> ${newStatus} for task "${taskId}"`);
-    }
-    const now = new Date().toISOString();
-    if (newStatus === "running" && !task.startedAt) {
-      task.startedAt = now;
-    }
-    if (isTerminalStatus(newStatus) && !task.completedAt) {
-      task.completedAt = now;
-    }
-    task.status = newStatus;
-    task.lastActiveAt = now;
-    if (updates?.errorMessage !== undefined) {
-      task.errorMessage = updates.errorMessage;
-    }
-    if (updates?.progress !== undefined) {
-      task.progress = { ...task.progress, ...updates.progress };
-    }
-    return task;
-  }
-  updateProgress(taskId, progress) {
-    const task = this.tasks.get(taskId);
-    if (!task) {
-      throw new Error(`Task "${taskId}" not found`);
-    }
-    const now = new Date().toISOString();
-    task.lastActiveAt = now;
-    task.progress = { ...task.progress, ...progress };
-    return task;
-  }
-  delete(taskId) {
-    const task = this.tasks.get(taskId);
-    if (!task)
-      return false;
-    if (task.idempotencyKey) {
-      this.idempotencyIndex.delete(task.idempotencyKey);
-    }
-    return this.tasks.delete(taskId);
-  }
-  list(filter) {
-    let tasks = Array.from(this.tasks.values());
-    if (filter?.status) {
-      const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
-      tasks = tasks.filter((t) => statuses.includes(t.status));
-    }
-    if (filter?.parentSessionId) {
-      tasks = tasks.filter((t) => t.parentSessionId === filter.parentSessionId);
-    }
-    if (filter?.hiveFeature) {
-      tasks = tasks.filter((t) => t.hiveFeature === filter.hiveFeature);
-    }
-    return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  }
-  getActive() {
-    return this.list().filter((t) => !isTerminalStatus(t.status));
-  }
-  countByStatus() {
-    const counts = {
-      spawned: 0,
-      pending: 0,
-      running: 0,
-      completed: 0,
-      error: 0,
-      cancelled: 0,
-      blocked: 0,
-      failed: 0
-    };
-    for (const task of this.tasks.values()) {
-      counts[task.status]++;
-    }
-    return counts;
-  }
-  clear() {
-    this.tasks.clear();
-    this.idempotencyIndex.clear();
-  }
-  get size() {
-    return this.tasks.size;
-  }
-}
-var globalStore = null;
-function getStore() {
-  if (!globalStore) {
-    globalStore = new BackgroundTaskStore;
-  }
-  return globalStore;
-}
-// src/background/agent-gate.ts
-var BLOCKED_AGENTS = new Set([
-  "orchestrator",
-  "hive",
-  "hive-master",
-  "swarm-orchestrator",
-  "conductor",
-  "main"
-]);
-var RESTRICTED_AGENTS = new Set([
-  "admin",
-  "root",
-  "superuser"
-]);
-
-class AgentGate {
-  client;
-  cachedAgents = null;
-  cacheExpiry = 0;
-  cacheTtlMs = 30000;
-  constructor(client) {
-    this.client = client;
-  }
-  async discoverAgents() {
-    const now = Date.now();
-    if (this.cachedAgents && now < this.cacheExpiry) {
-      return this.cachedAgents;
-    }
-    try {
-      const result = await this.client.app.agents({});
-      const agents = result.data ?? [];
-      this.cachedAgents = agents;
-      this.cacheExpiry = now + this.cacheTtlMs;
-      return agents;
-    } catch (error45) {
-      if (this.cachedAgents) {
-        return this.cachedAgents;
-      }
-      throw new Error(`Failed to discover agents: ${error45 instanceof Error ? error45.message : "Unknown error"}`);
-    }
-  }
-  async validate(agentName, options = {}) {
-    const name = agentName.trim().toLowerCase();
-    if (BLOCKED_AGENTS.has(name)) {
-      return {
-        valid: false,
-        error: `Agent "${agentName}" is an orchestrator agent and cannot be spawned as a background worker. ` + `Use a worker agent like "forager-worker", "scout-researcher", or "hygienic-reviewer".`
-      };
-    }
-    if (options.additionalBlocked?.includes(name)) {
-      return {
-        valid: false,
-        error: `Agent "${agentName}" is blocked by configuration.`
-      };
-    }
-    if (RESTRICTED_AGENTS.has(name) && !options.allowRestricted) {
-      return {
-        valid: false,
-        error: `Agent "${agentName}" is restricted and requires explicit allowance. ` + `Set allowRestricted: true to spawn this agent.`
-      };
-    }
-    let agents;
-    try {
-      agents = await this.discoverAgents();
-    } catch (error45) {
-      return {
-        valid: false,
-        error: error45 instanceof Error ? error45.message : "Failed to discover agents"
-      };
-    }
-    const agent = agents.find((a) => a.name.toLowerCase() === name);
-    if (!agent) {
-      const available = agents.filter((a) => !BLOCKED_AGENTS.has(a.name.toLowerCase())).map((a) => `  • ${a.name}${a.description ? ` - ${a.description}` : ""}`).join(`
-`);
-      return {
-        valid: false,
-        error: `Agent "${agentName}" not found in registry.
-
-Available agents:
-${available || "(none)"}`
-      };
-    }
-    return {
-      valid: true,
-      agent
-    };
-  }
-  async getWorkerAgents() {
-    const agents = await this.discoverAgents();
-    return agents.filter((a) => {
-      const name = a.name.toLowerCase();
-      return !BLOCKED_AGENTS.has(name) && !RESTRICTED_AGENTS.has(name);
-    });
-  }
-  clearCache() {
-    this.cachedAgents = null;
-    this.cacheExpiry = 0;
-  }
-  isBlocked(agentName) {
-    return BLOCKED_AGENTS.has(agentName.trim().toLowerCase());
-  }
-  isRestricted(agentName) {
-    return RESTRICTED_AGENTS.has(agentName.trim().toLowerCase());
-  }
-}
-function createAgentGate(client) {
-  return new AgentGate(client);
-}
-// src/background/concurrency.ts
-var DEFAULT_CONFIG = {
-  defaultLimit: 3,
-  agentLimits: {},
-  modelLimits: {},
-  queueTimeoutMs: 5 * 60 * 1000,
-  minDelayBetweenStartsMs: 1000
-};
-
-class ConcurrencyManager {
-  config;
-  counts = new Map;
-  queues = new Map;
-  lastStartTimes = new Map;
-  constructor(config2 = {}) {
-    this.config = { ...DEFAULT_CONFIG, ...config2 };
-  }
-  getLimit(key) {
-    if (key.includes("/")) {
-      const modelLimit = this.config.modelLimits[key];
-      if (modelLimit !== undefined) {
-        return modelLimit === 0 ? Infinity : modelLimit;
-      }
-      const provider = key.split("/")[0];
-      const providerLimit = this.config.modelLimits[provider];
-      if (providerLimit !== undefined) {
-        return providerLimit === 0 ? Infinity : providerLimit;
-      }
-    }
-    const agentLimit = this.config.agentLimits[key];
-    if (agentLimit !== undefined) {
-      return agentLimit === 0 ? Infinity : agentLimit;
-    }
-    return this.config.defaultLimit === 0 ? Infinity : this.config.defaultLimit;
-  }
-  async acquire(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity) {
-      return;
-    }
-    await this.enforceRateLimit(key);
-    const current = this.counts.get(key) ?? 0;
-    if (current < limit) {
-      this.counts.set(key, current + 1);
-      this.lastStartTimes.set(key, Date.now());
-      return;
-    }
-    return new Promise((resolve2, reject) => {
-      const queue = this.queues.get(key) ?? [];
-      const entry = {
-        resolve: () => {
-          if (entry.settled)
-            return;
-          entry.settled = true;
-          clearTimeout(entry.timeoutId);
-          this.lastStartTimes.set(key, Date.now());
-          resolve2();
-        },
-        reject: (error45) => {
-          if (entry.settled)
-            return;
-          entry.settled = true;
-          clearTimeout(entry.timeoutId);
-          reject(error45);
-        },
-        settled: false,
-        enqueuedAt: Date.now(),
-        timeoutId: setTimeout(() => {
-          if (!entry.settled) {
-            entry.settled = true;
-            const q = this.queues.get(key);
-            if (q) {
-              const idx = q.indexOf(entry);
-              if (idx !== -1)
-                q.splice(idx, 1);
-            }
-            reject(new Error(`Concurrency queue timeout for key "${key}" after ${this.config.queueTimeoutMs}ms`));
-          }
-        }, this.config.queueTimeoutMs)
-      };
-      queue.push(entry);
-      this.queues.set(key, queue);
-    });
-  }
-  release(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity) {
-      return;
-    }
-    const queue = this.queues.get(key);
-    while (queue && queue.length > 0) {
-      const next = queue.shift();
-      if (!next.settled) {
-        next.resolve();
-        return;
-      }
-    }
-    const current = this.counts.get(key) ?? 0;
-    if (current > 0) {
-      this.counts.set(key, current - 1);
-    }
-  }
-  tryAcquire(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity) {
-      return true;
-    }
-    const current = this.counts.get(key) ?? 0;
-    if (current < limit) {
-      this.counts.set(key, current + 1);
-      this.lastStartTimes.set(key, Date.now());
-      return true;
-    }
-    return false;
-  }
-  cancelWaiters(key) {
-    const queue = this.queues.get(key);
-    if (!queue)
-      return 0;
-    let cancelled = 0;
-    for (const entry of queue) {
-      if (!entry.settled) {
-        entry.reject(new Error(`Concurrency queue cancelled for key: ${key}`));
-        cancelled++;
-      }
-    }
-    this.queues.delete(key);
-    return cancelled;
-  }
-  clear() {
-    for (const key of this.queues.keys()) {
-      this.cancelWaiters(key);
-    }
-    this.counts.clear();
-    this.queues.clear();
-    this.lastStartTimes.clear();
-  }
-  getCount(key) {
-    return this.counts.get(key) ?? 0;
-  }
-  getQueueLength(key) {
-    const queue = this.queues.get(key);
-    if (!queue)
-      return 0;
-    return queue.filter((e) => !e.settled).length;
-  }
-  getAvailable(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity)
-      return Infinity;
-    const current = this.counts.get(key) ?? 0;
-    return Math.max(0, limit - current);
-  }
-  isAtCapacity(key) {
-    const limit = this.getLimit(key);
-    if (limit === Infinity)
-      return false;
-    const current = this.counts.get(key) ?? 0;
-    return current >= limit;
-  }
-  getStatus() {
-    const status = {};
-    for (const [key, count] of this.counts.entries()) {
-      status[key] = {
-        count,
-        limit: this.getLimit(key),
-        queued: this.getQueueLength(key)
-      };
-    }
-    for (const key of this.queues.keys()) {
-      if (!status[key]) {
-        status[key] = {
-          count: 0,
-          limit: this.getLimit(key),
-          queued: this.getQueueLength(key)
-        };
-      }
-    }
-    return status;
-  }
-  async enforceRateLimit(key) {
-    const lastStart = this.lastStartTimes.get(key);
-    if (!lastStart)
-      return;
-    const elapsed = Date.now() - lastStart;
-    const delay2 = this.config.minDelayBetweenStartsMs - elapsed;
-    if (delay2 > 0) {
-      await new Promise((resolve2) => setTimeout(resolve2, delay2));
-    }
-  }
-}
-function createConcurrencyManager(config2) {
-  return new ConcurrencyManager(config2);
-}
-// src/background/poller.ts
-var DEFAULT_CONFIG2 = {
-  pollIntervalMs: 5000,
-  maxPollIntervalMs: 30000,
-  stuckThresholdMs: 10 * 60 * 1000,
-  minRuntimeBeforeStuckMs: 30 * 1000,
-  stableCountThreshold: 3
-};
-
-class BackgroundPoller {
-  store;
-  client;
-  config;
-  handlers;
-  pollingState = new Map;
-  pollInterval = null;
-  isPolling = false;
-  currentIntervalMs;
-  constructor(store, client, config2 = {}, handlers = {}) {
-    this.store = store;
-    this.client = client;
-    this.config = { ...DEFAULT_CONFIG2, ...config2 };
-    this.handlers = handlers;
-    this.currentIntervalMs = this.config.pollIntervalMs;
-  }
-  start() {
-    if (this.pollInterval)
-      return;
-    this.pollInterval = setInterval(() => {
-      this.poll().catch((err) => {
-        console.warn("[BackgroundPoller] Poll error:", err);
-      });
-    }, this.currentIntervalMs);
-    this.pollInterval.unref();
-  }
-  stop() {
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = null;
-    }
-    this.isPolling = false;
-  }
-  isRunning() {
-    return this.pollInterval !== null;
-  }
-  getObservations() {
-    const observations = [];
-    const activeTasks = this.store.getActive();
-    for (const task of activeTasks) {
-      const state = this.pollingState.get(task.taskId);
-      const observation = this.buildObservation(task, state);
-      observations.push(observation);
-    }
-    return observations;
-  }
-  getTaskObservation(taskId) {
-    const task = this.store.get(taskId);
-    if (!task)
-      return null;
-    const state = this.pollingState.get(taskId);
-    return this.buildObservation(task, state);
-  }
-  async poll() {
-    if (this.isPolling)
-      return;
-    this.isPolling = true;
-    try {
-      const activeTasks = this.store.getActive();
-      if (activeTasks.length === 0) {
-        this.stop();
-        return;
-      }
-      let sessionStatuses = {};
-      try {
-        const statusResult = await this.client.session.status?.();
-        sessionStatuses = statusResult?.data ?? {};
-      } catch {}
-      for (const task of activeTasks) {
-        if (task.status !== "running")
-          continue;
-        await this.pollTask(task, sessionStatuses);
-      }
-      this.adjustPollingInterval(activeTasks);
-    } finally {
-      this.isPolling = false;
-    }
-  }
-  async pollTask(task, sessionStatuses) {
-    const state = this.pollingState.get(task.taskId) ?? {
-      lastMessageCount: 0,
-      stablePolls: 0,
-      lastPollAt: Date.now(),
-      consecutiveErrors: 0
-    };
-    try {
-      const sessionType = sessionStatuses[task.sessionId]?.type;
-      const messagesResult = await this.client.session.messages({
-        path: { id: task.sessionId }
-      });
-      const messages = messagesResult.data ?? [];
-      const currentMessageCount = messages.length;
-      const now = new Date().toISOString();
-      if (currentMessageCount > state.lastMessageCount) {
-        state.stablePolls = 0;
-        this.store.updateProgress(task.taskId, {
-          messageCount: currentMessageCount,
-          lastMessageAt: now
-        });
-      } else {
-        state.stablePolls++;
-      }
-      state.lastMessageCount = currentMessageCount;
-      state.lastPollAt = Date.now();
-      state.consecutiveErrors = 0;
-      this.pollingState.set(task.taskId, state);
-      const isIdle = sessionType === "idle" || sessionType === "completed";
-      if (isIdle) {
-        this.handlers.onSessionIdle?.(task.sessionId, "status");
-        return;
-      }
-      if (!sessionType && currentMessageCount > 0 && state.stablePolls >= this.config.stableCountThreshold) {
-        try {
-          const session = await this.client.session.get({ path: { id: task.sessionId } });
-          const status = session.data?.status;
-          if (status === "idle" || status === "completed") {
-            this.handlers.onSessionIdle?.(task.sessionId, "status");
-            return;
-          }
-        } catch {}
-        this.handlers.onSessionIdle?.(task.sessionId, "stable");
-      }
-    } catch (error45) {
-      state.consecutiveErrors++;
-      state.lastPollAt = Date.now();
-      this.pollingState.set(task.taskId, state);
-      if (state.consecutiveErrors >= 3) {
-        console.warn(`[BackgroundPoller] Multiple errors polling task ${task.taskId}:`, error45);
-      }
-    }
-  }
-  buildObservation(task, state) {
-    const now = Date.now();
-    const stablePolls = state?.stablePolls ?? 0;
-    const lastActivityAt = task.progress?.lastMessageAt ?? task.lastActiveAt ?? null;
-    let maybeStuck = false;
-    if (task.status === "running" && task.startedAt) {
-      const startedAt = new Date(task.startedAt).getTime();
-      const runtime = now - startedAt;
-      if (runtime >= this.config.minRuntimeBeforeStuckMs) {
-        const lastActivity = lastActivityAt ? new Date(lastActivityAt).getTime() : startedAt;
-        const timeSinceActivity = now - lastActivity;
-        maybeStuck = timeSinceActivity >= this.config.stuckThresholdMs;
-      }
-    }
-    return {
-      taskId: task.taskId,
-      sessionId: task.sessionId,
-      status: task.status,
-      messageCount: task.progress?.messageCount ?? 0,
-      lastActivityAt,
-      maybeStuck,
-      stablePolls,
-      isStable: stablePolls >= this.config.stableCountThreshold
-    };
-  }
-  adjustPollingInterval(activeTasks) {
-    const now = Date.now();
-    let recentActivityCount = 0;
-    for (const task of activeTasks) {
-      const state = this.pollingState.get(task.taskId);
-      if (state && state.stablePolls < 2) {
-        recentActivityCount++;
-      }
-    }
-    const stableRatio = activeTasks.length > 0 ? (activeTasks.length - recentActivityCount) / activeTasks.length : 0;
-    if (stableRatio > 0.8) {
-      this.currentIntervalMs = Math.min(this.currentIntervalMs * 1.5, this.config.maxPollIntervalMs);
-    } else if (recentActivityCount > 0) {
-      this.currentIntervalMs = this.config.pollIntervalMs;
-    }
-    if (this.pollInterval && Math.abs(this.currentIntervalMs - this.config.pollIntervalMs) > 1000) {
-      this.stop();
-      this.start();
-    }
-  }
-  cleanupTask(taskId) {
-    this.pollingState.delete(taskId);
-  }
-  clear() {
-    this.stop();
-    this.pollingState.clear();
-  }
-}
-function createPoller(store, client, config2, handlers) {
-  return new BackgroundPoller(store, client, config2, handlers);
-}
-// src/background/manager.ts
-class BackgroundManager {
-  store;
-  agentGate;
-  client;
-  taskService;
-  concurrencyManager;
-  poller;
-  enforceHiveSequential;
-  constructor(options) {
-    this.client = options.client;
-    this.store = options.store ?? getStore();
-    this.agentGate = createAgentGate(options.client);
-    this.taskService = new TaskService(options.projectRoot);
-    this.concurrencyManager = createConcurrencyManager(options.concurrency);
-    this.poller = createPoller(this.store, options.client, options.poller, {
-      onSessionIdle: (sessionId) => this.handleSessionIdle(sessionId)
-    });
-    this.enforceHiveSequential = options.enforceHiveSequential ?? true;
-  }
-  async spawn(options) {
-    if (options.idempotencyKey) {
-      const existing = this.store.getByIdempotencyKey(options.idempotencyKey);
-      if (existing) {
-        return {
-          task: existing,
-          wasExisting: true
-        };
-      }
-    }
-    if (options.hiveFeature && options.hiveTaskFolder) {
-      const existing = this.store.getByHiveTask(options.hiveFeature, options.hiveTaskFolder);
-      if (existing && !isTerminalStatus(existing.status)) {
-        return {
-          task: existing,
-          wasExisting: true
-        };
-      }
-      if (this.enforceHiveSequential) {
-        const orderingCheck = this.checkHiveTaskOrdering(options.hiveFeature, options.hiveTaskFolder);
-        if (!orderingCheck.allowed) {
-          return {
-            task: null,
-            wasExisting: false,
-            error: orderingCheck.error
-          };
-        }
-      }
-    }
-    const validation = await this.agentGate.validate(options.agent);
-    if (!validation.valid) {
-      return {
-        task: null,
-        wasExisting: false,
-        error: validation.error
-      };
-    }
-    const concurrencyKey = options.agent;
-    try {
-      await this.concurrencyManager.acquire(concurrencyKey);
-    } catch (error45) {
-      return {
-        task: null,
-        wasExisting: false,
-        error: `Concurrency limit reached: ${error45 instanceof Error ? error45.message : "Unknown error"}`
-      };
-    }
-    let sessionId;
-    try {
-      const sessionResult = await this.client.session.create({
-        body: {
-          title: `Background: ${options.description}`,
-          parentID: options.parentSessionId
-        }
-      });
-      if (!sessionResult.data?.id) {
-        this.concurrencyManager.release(concurrencyKey);
-        return {
-          task: null,
-          wasExisting: false,
-          error: "Failed to create OpenCode session"
-        };
-      }
-      sessionId = sessionResult.data.id;
-    } catch (error45) {
-      this.concurrencyManager.release(concurrencyKey);
-      return {
-        task: null,
-        wasExisting: false,
-        error: `Failed to create session: ${error45 instanceof Error ? error45.message : "Unknown error"}`
-      };
-    }
-    const notifyParent = options.notifyParent ?? !options.sync;
-    const task = this.store.create({
-      agent: options.agent,
-      description: options.description,
-      sessionId,
-      idempotencyKey: options.idempotencyKey,
-      parentSessionId: options.parentSessionId,
-      parentMessageId: options.parentMessageId,
-      parentAgent: options.parentAgent,
-      notifyParent,
-      hiveFeature: options.hiveFeature,
-      hiveTaskFolder: options.hiveTaskFolder,
-      workdir: options.workdir
-    });
-    if (options.hiveFeature && options.hiveTaskFolder) {
-      try {
-        const attempt = options.attempt ?? 1;
-        this.taskService.patchBackgroundFields(options.hiveFeature, options.hiveTaskFolder, {
-          idempotencyKey: options.idempotencyKey,
-          workerSession: {
-            taskId: task.taskId,
-            sessionId: task.sessionId,
-            agent: task.agent,
-            mode: "delegate",
-            attempt
-          }
-        });
-      } catch (error45) {
-        console.warn(`[BackgroundManager] Failed to persist to .hive: ${error45 instanceof Error ? error45.message : "Unknown"}`);
-      }
-    }
-    this.store.updateStatus(task.taskId, "running");
-    this.poller.start();
-    const normalizedVariant = options.variant?.trim() || undefined;
-    this.client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        agent: options.agent,
-        parts: [{ type: "text", text: options.prompt }],
-        tools: {
-          background_task: false,
-          delegate: false,
-          hive_background_task: false,
-          hive_background_output: false,
-          hive_background_cancel: false,
-          task: false
-        },
-        ...normalizedVariant !== undefined && { variant: normalizedVariant }
-      }
-    }).catch((error45) => {
-      this.updateStatus(task.taskId, "error", { errorMessage: error45.message });
-      this.concurrencyManager.release(concurrencyKey);
-      this.poller.cleanupTask(task.taskId);
-    });
-    return {
-      task: this.store.get(task.taskId),
-      wasExisting: false
-    };
-  }
-  checkHiveTaskOrdering(feature, taskFolder) {
-    const taskStatus = this.taskService.getRawStatus(feature, taskFolder);
-    if (taskStatus?.dependsOn !== undefined) {
-      return this.checkDependencies(feature, taskFolder, taskStatus.dependsOn);
-    }
-    return this.checkNumericOrdering(feature, taskFolder);
-  }
-  checkDependencies(feature, taskFolder, dependsOn) {
-    if (dependsOn.length === 0) {
-      return { allowed: true };
-    }
-    const unmetDeps = [];
-    for (const depFolder of dependsOn) {
-      const depStatus = this.taskService.getRawStatus(feature, depFolder);
-      if (!depStatus || depStatus.status !== "done") {
-        unmetDeps.push({
-          folder: depFolder,
-          status: depStatus?.status ?? "unknown"
-        });
-      }
-    }
-    if (unmetDeps.length > 0) {
-      const depList = unmetDeps.map((d) => `"${d.folder}" (${d.status})`).join(", ");
-      return {
-        allowed: false,
-        error: `Dependency constraint: Task "${taskFolder}" cannot start - dependencies not done: ${depList}. ` + `Only tasks with status 'done' satisfy dependencies.`
-      };
-    }
-    return { allowed: true };
-  }
-  checkNumericOrdering(feature, taskFolder) {
-    const orderMatch = taskFolder.match(/^(\d+)-/);
-    if (!orderMatch) {
-      return { allowed: true };
-    }
-    const taskOrder = parseInt(orderMatch[1], 10);
-    if (taskOrder <= 1) {
-      return { allowed: true };
-    }
-    const activeTasks = this.store.list({
-      hiveFeature: feature,
-      status: ["spawned", "pending", "running"]
-    });
-    for (const activeTask of activeTasks) {
-      if (!activeTask.hiveTaskFolder)
-        continue;
-      const activeOrderMatch = activeTask.hiveTaskFolder.match(/^(\d+)-/);
-      if (!activeOrderMatch)
-        continue;
-      const activeOrder = parseInt(activeOrderMatch[1], 10);
-      if (activeOrder < taskOrder) {
-        return {
-          allowed: false,
-          error: `Sequential ordering enforced: Task "${taskFolder}" cannot start while earlier task "${activeTask.hiveTaskFolder}" is still ${activeTask.status}. ` + `Complete or cancel the earlier task first. ` + `(Hive default: sequential execution for safety)`
-        };
-      }
-    }
-    return { allowed: true };
-  }
-  getTask(taskId) {
-    return this.store.get(taskId);
-  }
-  getTaskByIdempotencyKey(key) {
-    return this.store.getByIdempotencyKey(key);
-  }
-  getTaskByHiveTask(feature, taskFolder) {
-    return this.store.getByHiveTask(feature, taskFolder);
-  }
-  updateStatus(taskId, status, options) {
-    const task = this.store.updateStatus(taskId, status, options);
-    if (task.hiveFeature && task.hiveTaskFolder) {
-      try {
-        this.taskService.patchBackgroundFields(task.hiveFeature, task.hiveTaskFolder, {
-          workerSession: {
-            sessionId: task.sessionId,
-            lastHeartbeatAt: new Date().toISOString()
-          }
-        });
-      } catch {}
-    }
-    if (isTerminalStatus(task.status) && task.parentSessionId && task.notifyParent !== false) {
-      this.notifyParentSession(task);
-    }
-    return task;
-  }
-  async notifyParentSession(task) {
-    if (!task.parentSessionId)
-      return;
-    const statusLabel = task.status.toUpperCase();
-    const errorLine = task.errorMessage ? `
-**Error:** ${task.errorMessage}` : "";
-    const notification = `<system-reminder>
-[BACKGROUND TASK ${statusLabel}]
-
-**ID:** \`${task.taskId}\`
-**Description:** ${task.description}
-**Agent:** ${task.agent}${errorLine}
-
- Use \`hive_background_output({ task_id: "${task.taskId}" })\` to retrieve the result.
-</system-reminder>`;
-    try {
-      await this.client.session.prompt({
-        path: { id: task.parentSessionId },
-        body: {
-          agent: task.parentAgent || "hive",
-          parts: [{ type: "text", text: notification }]
-        }
-      });
-    } catch {}
-  }
-  async cancel(taskId) {
-    const task = this.store.get(taskId);
-    if (!task) {
-      throw new Error(`Task "${taskId}" not found`);
-    }
-    if (isTerminalStatus(task.status)) {
-      throw new Error(`Cannot cancel task in terminal status: ${task.status}`);
-    }
-    try {
-      await this.client.session.abort({
-        path: { id: task.sessionId }
-      });
-    } catch {}
-    this.concurrencyManager.release(task.agent);
-    this.poller.cleanupTask(taskId);
-    return this.updateStatus(taskId, "cancelled");
-  }
-  async cancelAll(parentSessionId) {
-    const tasks = this.store.list({
-      parentSessionId,
-      status: ["spawned", "pending", "running"]
-    });
-    const results = [];
-    for (const task of tasks) {
-      try {
-        const cancelled = await this.cancel(task.taskId);
-        results.push(cancelled);
-      } catch {}
-    }
-    return results;
-  }
-  list(filter) {
-    return this.store.list(filter);
-  }
-  getActive() {
-    return this.store.getActive();
-  }
-  handleSessionIdle(sessionId) {
-    const tasks = this.store.list();
-    const task = tasks.find((t) => t.sessionId === sessionId);
-    if (task && task.status === "running") {
-      this.concurrencyManager.release(task.agent);
-      this.poller.cleanupTask(task.taskId);
-      this.updateStatus(task.taskId, "completed");
-    }
-  }
-  handleMessageEvent(sessionId, messageText) {
-    const tasks = this.store.list();
-    const task = tasks.find((t) => t.sessionId === sessionId);
-    if (task && task.status === "running") {
-      this.store.updateProgress(task.taskId, {
-        lastMessage: messageText?.slice(0, 200),
-        lastMessageAt: new Date().toISOString(),
-        messageCount: (task.progress?.messageCount ?? 0) + 1
-      });
-    }
-  }
-  getAgentGate() {
-    return this.agentGate;
-  }
-  getConcurrencyManager() {
-    return this.concurrencyManager;
-  }
-  getPoller() {
-    return this.poller;
-  }
-  getObservations() {
-    return this.poller.getObservations();
-  }
-  getTaskObservation(taskId) {
-    return this.poller.getTaskObservation(taskId);
-  }
-  getCounts() {
-    return this.store.countByStatus();
-  }
-  shutdown() {
-    this.poller.stop();
-    this.concurrencyManager.clear();
-  }
-}
-function createBackgroundManager(options) {
-  return new BackgroundManager(options);
-}
-// src/utils/format.ts
-function formatElapsed(ms) {
-  const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-  if (totalSeconds < 60) {
-    return `${totalSeconds}s`;
-  }
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (totalMinutes < 60) {
-    return `${totalMinutes}m ${seconds}s`;
-  }
-  const hours = Math.floor(totalMinutes / 60);
-  const minutes = totalMinutes % 60;
-  return `${hours}h ${minutes}m`;
-}
-function formatRelativeTime(isoDate) {
-  const timestamp = new Date(isoDate).getTime();
-  const now = Date.now();
-  const elapsedMs = Math.max(0, now - timestamp);
-  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000));
-  if (totalSeconds < 60) {
-    return `${totalSeconds}s ago`;
-  }
-  const totalMinutes = Math.floor(totalSeconds / 60);
-  if (totalMinutes < 60) {
-    return `${totalMinutes}m ago`;
-  }
-  const totalHours = Math.floor(totalMinutes / 60);
-  return `${totalHours}h ago`;
-}
-
-// src/hooks/variant-hook.ts
-var HIVE_AGENT_NAMES = [
-  "hive-master",
-  "architect-planner",
-  "swarm-orchestrator",
-  "scout-researcher",
-  "forager-worker",
-  "hygienic-reviewer"
-];
-function isHiveAgent(agent) {
-  return agent !== undefined && HIVE_AGENT_NAMES.includes(agent);
-}
-function normalizeVariant(variant) {
-  if (variant === undefined)
-    return;
-  const trimmed2 = variant.trim();
-  return trimmed2.length > 0 ? trimmed2 : undefined;
-}
-
-// src/tools/background-tools.ts
-function createBackgroundTools(manager, client, configService) {
-  async function maybeFinalizeIfIdle(sessionId) {
-    try {
-      const statusFn = client.session.status;
-      if (statusFn) {
-        const statusResult = await statusFn();
-        const entry = statusResult.data?.[sessionId];
-        const type = entry?.type;
-        if (type === "idle" || type === "completed") {
-          manager.handleSessionIdle(sessionId);
-          return;
-        }
-      }
-    } catch {}
-    try {
-      const sessionResult = await client.session.get({ path: { id: sessionId } });
-      const data = sessionResult.data;
-      const status = data?.status ?? data?.type;
-      if (status === "idle" || status === "completed") {
-        manager.handleSessionIdle(sessionId);
-      }
-    } catch {}
-  }
-  return {
-    hive_background_task: tool({
-      description: "Spawn a background agent task. Use sync=true to wait for completion (returns output). If sync=false (default), the parent session receives a completion <system-reminder> and you can call hive_background_output to fetch the result.",
-      args: {
-        agent: tool.schema.string().describe('Agent to use (e.g., "forager-worker", "scout-researcher")'),
-        prompt: tool.schema.string().optional().describe("Task instructions/prompt (required if promptFile not provided)"),
-        promptFile: tool.schema.string().optional().describe("Path to file containing prompt (alternative to inline prompt)"),
-        description: tool.schema.string().describe("Human-readable task description"),
-        sync: tool.schema.boolean().optional().describe("Wait for completion (default: false)"),
-        idempotencyKey: tool.schema.string().optional().describe("Key for safe retries"),
-        workdir: tool.schema.string().optional().describe("Working directory for task"),
-        feature: tool.schema.string().optional().describe("Hive feature name (for Hive-linked tasks)"),
-        task: tool.schema.string().optional().describe("Hive task folder (for Hive-linked tasks)"),
-        attempt: tool.schema.number().optional().describe("Hive attempt number (for Hive-linked tasks)")
-      },
-      async execute({
-        agent,
-        prompt,
-        promptFile,
-        description,
-        sync = false,
-        idempotencyKey,
-        workdir,
-        feature,
-        task: hiveTask,
-        attempt
-      }, toolContext) {
-        const ctx = toolContext;
-        const ALLOWED_CALLERS = new Set([
-          "hive-master",
-          "architect-planner",
-          "swarm-orchestrator"
-        ]);
-        const callerAgent = ctx?.agent;
-        if (!callerAgent || !ALLOWED_CALLERS.has(callerAgent)) {
-          const output = {
-            provider: "hive",
-            task_id: "",
-            session_id: "",
-            status: "error",
-            error: `Agent "${callerAgent ?? "unknown"}" is not allowed to spawn background tasks. Only orchestrator agents (${[...ALLOWED_CALLERS].join(", ")}) can delegate.`
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        let resolvedPrompt = prompt;
-        if (promptFile) {
-          const baseDir = workdir || process.cwd();
-          const workspaceRoot = findWorkspaceRoot(baseDir) ?? baseDir;
-          const fileResult = await resolvePromptFromFile(promptFile, workspaceRoot);
-          if (fileResult.error) {
-            const output = {
-              provider: "hive",
-              task_id: "",
-              session_id: "",
-              status: "error",
-              error: `Failed to read prompt file: ${fileResult.error}`
-            };
-            return JSON.stringify(output, null, 2);
-          }
-          resolvedPrompt = fileResult.content;
-        }
-        if (!resolvedPrompt) {
-          const output = {
-            provider: "hive",
-            task_id: "",
-            session_id: "",
-            status: "error",
-            error: "Either prompt or promptFile is required"
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        let variant;
-        if (configService && isHiveAgent(agent)) {
-          const agentConfig = configService.getAgentConfig(agent);
-          variant = normalizeVariant(agentConfig.variant);
-        }
-        const result = await manager.spawn({
-          agent,
-          prompt: resolvedPrompt,
-          description,
-          idempotencyKey,
-          workdir,
-          parentSessionId: ctx?.sessionID,
-          parentMessageId: ctx?.messageID,
-          parentAgent: ctx?.agent,
-          notifyParent: !sync,
-          hiveFeature: feature,
-          hiveTaskFolder: hiveTask,
-          sync,
-          attempt,
-          variant
-        });
-        if (result.error) {
-          const output = {
-            provider: "hive",
-            task_id: "",
-            session_id: "",
-            status: "error",
-            error: result.error
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        const taskRecord = result.task;
-        if (!sync) {
-          const output = {
-            provider: "hive",
-            task_id: taskRecord.taskId,
-            session_id: taskRecord.sessionId,
-            status: taskRecord.status
-          };
-          return JSON.stringify(output, null, 2);
-        }
-        const pollInterval = 1000;
-        const maxWait = 30 * 60 * 1000;
-        const startTime = Date.now();
-        while (true) {
-          let current = manager.getTask(taskRecord.taskId);
-          if (!current) {
-            return JSON.stringify({
-              provider: "hive",
-              task_id: taskRecord.taskId,
-              session_id: taskRecord.sessionId,
-              status: "error",
-              error: "Task disappeared from store"
-            }, null, 2);
-          }
-          if (!isTerminalStatus(current.status)) {
-            await maybeFinalizeIfIdle(current.sessionId);
-            current = manager.getTask(taskRecord.taskId);
-          }
-          if (current && isTerminalStatus(current.status)) {
-            const outputText = await getTaskOutput(client, current.sessionId);
-            const output = {
-              provider: "hive",
-              task_id: current.taskId,
-              session_id: current.sessionId,
-              status: current.status,
-              output: outputText,
-              done: true
-            };
-            if (current.errorMessage) {
-              output.error = current.errorMessage;
-            }
-            return JSON.stringify(output, null, 2);
-          }
-          if (Date.now() - startTime > maxWait) {
-            return JSON.stringify({
-              provider: "hive",
-              task_id: current?.taskId ?? taskRecord.taskId,
-              session_id: current?.sessionId ?? taskRecord.sessionId,
-              status: current?.status ?? "unknown",
-              error: "Sync wait timed out after 30 minutes",
-              done: false
-            }, null, 2);
-          }
-          await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-        }
-      }
-    }),
-    hive_background_output: tool({
-      description: "Get output from a background task. For sync=false tasks, wait for the completion <system-reminder> and then call with block=false to fetch the result; use block=true only when you need interim output. When blocking, pick a timeout based on task complexity (typically 30-120s).",
-      args: {
-        task_id: tool.schema.string().describe("Task ID to get output from"),
-        block: tool.schema.boolean().optional().describe("Block waiting for new output (default: false)"),
-        timeout: tool.schema.number().optional().describe("Timeout in ms when blocking (default: 60000)"),
-        cursor: tool.schema.string().optional().describe("Cursor for incremental output (message count)")
-      },
-      async execute({ task_id, block = false, timeout = 60000, cursor }) {
-        const task = manager.getTask(task_id);
-        if (!task) {
-          return JSON.stringify({
-            error: `Task "${task_id}" not found`,
-            task_id
-          }, null, 2);
-        }
-        const cursorCount = cursor ? parseInt(cursor, 10) : 0;
-        if (block && !isTerminalStatus(task.status)) {
-          const startTime = Date.now();
-          const pollInterval = 1000;
-          while (Date.now() - startTime < timeout) {
-            const current2 = manager.getTask(task_id);
-            if (!current2)
-              break;
-            const currentCount = current2.progress?.messageCount ?? 0;
-            if (currentCount > cursorCount || isTerminalStatus(current2.status)) {
-              break;
-            }
-            await maybeFinalizeIfIdle(current2.sessionId);
-            const afterFinalize = manager.getTask(task_id);
-            if (afterFinalize && isTerminalStatus(afterFinalize.status)) {
-              break;
-            }
-            await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-          }
-        }
-        const current = manager.getTask(task_id);
-        if (!current) {
-          return JSON.stringify({
-            error: `Task "${task_id}" disappeared`,
-            task_id
-          }, null, 2);
-        }
-        if (!isTerminalStatus(current.status)) {
-          await maybeFinalizeIfIdle(current.sessionId);
-        }
-        const finalized = manager.getTask(task_id);
-        if (!finalized) {
-          return JSON.stringify({
-            error: `Task "${task_id}" disappeared`,
-            task_id
-          }, null, 2);
-        }
-        const output = await getTaskOutput(client, finalized.sessionId, cursorCount);
-        const messageCount = finalized.progress?.messageCount ?? 0;
-        const observationSnapshot = manager.getTaskObservation(task_id);
-        const lastActivityAt = observationSnapshot?.lastActivityAt ?? null;
-        const startedAt = finalized.startedAt ? new Date(finalized.startedAt).getTime() : Date.now();
-        const elapsedMs = Date.now() - startedAt;
-        const lastMessage = finalized.progress?.lastMessage;
-        const lastMessagePreview = lastMessage ? `${lastMessage.slice(0, 200)}${lastMessage.length > 200 ? "..." : ""}` : null;
-        const observation = {
-          elapsedMs,
-          elapsedFormatted: formatElapsed(elapsedMs),
-          messageCount: observationSnapshot?.messageCount ?? 0,
-          lastActivityAgo: lastActivityAt ? formatRelativeTime(lastActivityAt) : "never",
-          lastActivityAt,
-          lastMessagePreview,
-          maybeStuck: observationSnapshot?.maybeStuck ?? false
-        };
-        return JSON.stringify({
-          task_id: finalized.taskId,
-          session_id: finalized.sessionId,
-          status: finalized.status,
-          done: isTerminalStatus(finalized.status),
-          output,
-          cursor: messageCount.toString(),
-          progress: finalized.progress,
-          observation
-        }, null, 2);
-      }
-    }),
-    hive_background_cancel: tool({
-      description: "Cancel running background task(s). Use all=true to cancel all tasks for current session.",
-      args: {
-        task_id: tool.schema.string().optional().describe("Specific task ID to cancel"),
-        idempotencyKey: tool.schema.string().optional().describe("Cancel task by idempotency key"),
-        all: tool.schema.boolean().optional().describe("Cancel all tasks for current session")
-      },
-      async execute({ task_id, idempotencyKey, all }, toolContext) {
-        const ctx = toolContext;
-        if (all) {
-          if (!ctx?.sessionID) {
-            return JSON.stringify({
-              error: "Cannot cancel all: no parent session context",
-              cancelled: 0
-            }, null, 2);
-          }
-          const cancelled2 = await manager.cancelAll(ctx.sessionID);
-          return JSON.stringify({
-            cancelled: cancelled2.length,
-            tasks: cancelled2.map((t) => ({
-              task_id: t.taskId,
-              status: t.status
-            }))
-          }, null, 2);
-        }
-        let task;
-        if (task_id) {
-          task = manager.getTask(task_id);
-        } else if (idempotencyKey) {
-          task = manager.getTaskByIdempotencyKey(idempotencyKey);
-        }
-        if (!task) {
-          return JSON.stringify({
-            error: task_id ? `Task "${task_id}" not found` : idempotencyKey ? `No task found with idempotency key "${idempotencyKey}"` : "Must provide task_id, idempotencyKey, or all=true"
-          }, null, 2);
-        }
-        if (isTerminalStatus(task.status)) {
-          return JSON.stringify({
-            task_id: task.taskId,
-            status: task.status,
-            message: `Task already in terminal status: ${task.status}`
-          }, null, 2);
-        }
-        const cancelled = await manager.cancel(task.taskId);
-        return JSON.stringify({
-          task_id: cancelled.taskId,
-          status: cancelled.status,
-          message: "Task cancelled successfully"
-        }, null, 2);
-      }
-    })
-  };
-}
-async function getTaskOutput(client, sessionId, afterCount = 0) {
-  try {
-    const messagesResult = await client.session.messages({
-      path: { id: sessionId }
-    });
-    const messages = messagesResult.data ?? [];
-    const newMessages = messages.slice(afterCount);
-    const outputParts = [];
-    for (const msg of newMessages) {
-      const message = msg;
-      if (!message.parts)
-        continue;
-      for (const part of message.parts) {
-        if (part.type === "text" && part.text) {
-          outputParts.push(part.text);
-        } else if (part.type === "tool-result" && part.result) {
-          const result = typeof part.result === "string" ? part.result : JSON.stringify(part.result);
-          if (result.length > 500) {
-            outputParts.push(`[Tool: ${part.name}] ${result.slice(0, 500)}...`);
-          } else {
-            outputParts.push(`[Tool: ${part.name}] ${result}`);
-          }
-        }
-      }
-    }
-    return outputParts.join(`
-
-`);
-  } catch (error45) {
-    return `[Error fetching output: ${error45 instanceof Error ? error45.message : "Unknown"}]`;
-  }
-}
-
-// src/index.ts
-function formatSkillsXml(skills) {
-  if (skills.length === 0)
-    return "";
-  const skillsXml = skills.map((skill) => {
-    return [
-      "  <skill>",
-      `    <name>${skill.name}</name>`,
-      `    <description>(hive - Skill) ${skill.description}</description>`,
-      "  </skill>"
-    ].join(`
-`);
-  }).join(`
-`);
-  return `
-
-<available_skills>
-${skillsXml}
-</available_skills>`;
-}
-async function buildAutoLoadedSkillsContent(agentName, configService, projectRoot) {
-  const agentConfig = configService.getAgentConfig(agentName);
-  const autoLoadSkills = agentConfig.autoLoadSkills ?? [];
-  if (autoLoadSkills.length === 0) {
-    return "";
-  }
-  const homeDir = process.env.HOME || os.homedir();
-  const skillTemplates = [];
-  for (const skillId of autoLoadSkills) {
-    const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
-    if (builtinSkill) {
-      skillTemplates.push(builtinSkill.template);
-      continue;
+  const homeDir = process.env.HOME || os.homedir();
+  const skillTemplates = [];
+  for (const skillId of autoLoadSkills) {
+    const builtinSkill = BUILTIN_SKILLS.find((entry) => entry.name === skillId);
+    if (builtinSkill) {
+      skillTemplates.push(builtinSkill.template);
+      continue;
     }
     const fileResult = await loadFileSkill(skillId, projectRoot, homeDir);
     if (fileResult.found && fileResult.skill) {
@@ -23676,16 +23167,15 @@ var HIVE_SYSTEM_PROMPT = `
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (19 total)
+### Tools (14 total)
 
 | Domain | Tools |
 |--------|-------|
-| Feature | hive_feature_create, hive_feature_list, hive_feature_complete |
+| Feature | hive_feature_create, hive_feature_complete |
 | Plan | hive_plan_write, hive_plan_read, hive_plan_approve |
 | Task | hive_tasks_sync, hive_task_create, hive_task_update |
-| Exec | hive_exec_start, hive_exec_complete, hive_exec_abort |
-| Worker | hive_worker_status |
-| Merge | hive_merge, hive_worktree_list |
+| Worktree | hive_worktree_create, hive_worktree_commit, hive_worktree_discard |
+| Merge | hive_merge |
 | Context | hive_context_write |
 | Status | hive_status |
 | Skill | hive_skill |
@@ -23697,42 +23187,40 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 3. User adds comments in VSCode → \`hive_plan_read\` to see them
 4. Revise plan → User approves
 5. \`hive_tasks_sync()\` - Generate tasks from plan
-6. \`hive_exec_start(task)\` → work in worktree → \`hive_exec_complete(task, summary)\`
+6. \`hive_worktree_create(task)\` → work in worktree → \`hive_worktree_commit(task, summary)\`
 7. \`hive_merge(task)\` - Merge task branch into main (when ready)
 
-**Important:** \`hive_exec_complete\` commits changes to task branch but does NOT merge.
+**Important:** \`hive_worktree_commit\` commits changes to task branch but does NOT merge.
 Use \`hive_merge\` to explicitly integrate changes. Worktrees persist until manually removed.
 
 ### Delegated Execution
 
-\`hive_exec_start\` creates worktree and spawns worker automatically:
+\`hive_worktree_create\` creates worktree and spawns worker automatically:
 
-1. \`hive_exec_start(task)\` → Creates worktree + spawns Forager (Worker/Coder) worker
-2. Worker executes → calls \`hive_exec_complete(status: "completed")\`
-3. Worker blocked → calls \`hive_exec_complete(status: "blocked", blocker: {...})\`
+1. \`hive_worktree_create(task)\` → Creates worktree + spawns Forager (Worker/Coder) worker
+2. Worker executes → calls \`hive_worktree_commit(status: "completed")\`
+3. Worker blocked → calls \`hive_worktree_commit(status: "blocked", blocker: {...})\`
 
 **Handling blocked workers:**
-1. Check blockers with \`hive_worker_status()\`
+1. Check blockers with \`hive_status()\`
 2. Read the blocker info (reason, options, recommendation, context)
 3. Ask user via \`question()\` tool - NEVER plain text
-4. Resume with \`hive_exec_start(task, continueFrom: "blocked", decision: answer)\`
+4. Resume with \`hive_worktree_create(task, continueFrom: "blocked", decision: answer)\`
 
 **CRITICAL**: When resuming, a NEW worker spawns in the SAME worktree.
 The previous worker's progress is preserved. Include the user's decision in the \`decision\` parameter.
 
-**Observation Polling (Recommended):**
-- Prefer completion notifications over polling
-- Use \`hive_worker_status()\` for observation-based spot checks
-- Avoid tight loops with \`hive_background_output\`; if needed, wait 30-60s between checks
-- If you suspect notifications did not deliver, do a single \`hive_worker_status()\` check first
-- If you need final results, call \`hive_background_output({ task_id, block: false })\` after the completion notice
+**After task() Returns:**
+- task() is BLOCKING — when it returns, the worker is DONE
+- Call \`hive_status()\` immediately to check the new task state and find next runnable tasks
+- No notifications or polling needed — the result is already available
 
 **For research**, use MCP tools or parallel exploration:
 - \`grep_app_searchGitHub\` - Find code in OSS
 - \`context7_query-docs\` - Library documentation
 - \`websearch_web_search_exa\` - Web search via Exa
 - \`ast_grep_search\` - AST-based search
-- For exploratory fan-out, load \`hive_skill("parallel-exploration")\` and use \`hive_background_task(agent: "scout-researcher", sync: false, ...)\`
+- For exploratory fan-out, load \`hive_skill("parallel-exploration")\` and use multiple \`task()\` calls in the same message
 
 ### Planning Phase - Context Management REQUIRED
 
@@ -23743,7 +23231,6 @@ As you research and plan, CONTINUOUSLY save findings using \`hive_context_write\
 - Architecture decisions ("auth lives in /lib/auth")
 
 **Update existing context files** when new info emerges - dont create duplicates.
-Workers depend on context for background. Without it, they work blind.
 
 \`hive_tasks_sync\` parses \`### N. Task Name\` headers.
 
@@ -23760,6 +23247,7 @@ var plugin = async (ctx) => {
   const planService = new PlanService(directory);
   const taskService = new TaskService(directory);
   const contextService = new ContextService(directory);
+  const agentsMdService = new AgentsMdService(directory, contextService);
   const configService = new ConfigService;
   const disabledMcps = configService.getDisabledMcps();
   const disabledSkills = configService.getDisabledSkills();
@@ -23768,15 +23256,8 @@ var plugin = async (ctx) => {
   const effectiveAutoLoadSkills = configService.getAgentConfig("hive-master").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path7.join(directory, ".hive")
-  });
-  const backgroundManager = createBackgroundManager({
-    client,
-    projectRoot: directory
+    hiveDir: path8.join(directory, ".hive")
   });
-  const delegateMode = configService.getDelegateMode();
-  const useHiveBackground = delegateMode === "hive";
-  const backgroundTools = createBackgroundTools(backgroundManager, client, configService);
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
   };
@@ -23801,10 +23282,10 @@ var plugin = async (ctx) => {
     }
   };
   const checkBlocked = (feature) => {
-    const fs11 = __require("fs");
-    const blockedPath = path7.join(directory, ".hive", "features", feature, "BLOCKED");
-    if (fs11.existsSync(blockedPath)) {
-      const reason = fs11.readFileSync(blockedPath, "utf-8").trim();
+    const fs9 = __require("fs");
+    const blockedPath = path8.join(directory, ".hive", "features", feature, "BLOCKED");
+    if (fs9.existsSync(blockedPath)) {
+      const reason = fs9.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
 
 ${reason || "(No reason provided)"}
@@ -23887,14 +23368,34 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
         output.message.variant = configuredVariant;
       }
     },
+    "tool.execute.before": async (input, output) => {
+      if (input.tool !== "bash")
+        return;
+      const sandboxConfig = configService.getSandboxConfig();
+      if (sandboxConfig.mode === "none")
+        return;
+      const command = output.args?.command?.trim();
+      if (!command)
+        return;
+      if (/^HOST:\s*/i.test(command)) {
+        const strippedCommand = command.replace(/^HOST:\s*/i, "");
+        console.warn(`[hive:sandbox] HOST bypass: ${strippedCommand.slice(0, 80)}${strippedCommand.length > 80 ? "..." : ""}`);
+        output.args.command = strippedCommand;
+        return;
+      }
+      const workdir = output.args?.workdir;
+      if (!workdir)
+        return;
+      const hiveWorktreeBase = path8.join(directory, ".hive", ".worktrees");
+      if (!workdir.startsWith(hiveWorktreeBase))
+        return;
+      const wrapped = DockerSandboxService.wrapCommand(workdir, command, sandboxConfig);
+      output.args.command = wrapped;
+      output.args.workdir = undefined;
+    },
     mcp: builtinMcps,
     tool: {
       hive_skill: createHiveSkillTool(filteredSkills),
-      ...useHiveBackground && {
-        hive_background_task: backgroundTools.hive_background_task,
-        hive_background_output: backgroundTools.hive_background_output,
-        hive_background_cancel: backgroundTools.hive_background_cancel
-      },
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
         args: {
@@ -23939,22 +23440,6 @@ These prevent scope creep and re-proposing rejected solutions.
 NEXT: Ask your first clarifying question about this feature.`;
         }
       }),
-      hive_feature_list: tool({
-        description: "List all features",
-        args: {},
-        async execute() {
-          const features = featureService.list();
-          const active = resolveFeature();
-          if (features.length === 0)
-            return "No features found.";
-          const list = features.map((f) => {
-            const info = featureService.getInfo(f);
-            return `${f === active ? "* " : "  "}${f} (${info?.status || "unknown"})`;
-          });
-          return list.join(`
-`);
-        }
-      }),
       hive_feature_complete: tool({
         description: "Mark feature as completed (irreversible)",
         args: { name: tool.schema.string().optional().describe("Feature name (defaults to active)") },
@@ -23966,34 +23451,6 @@ NEXT: Ask your first clarifying question about this feature.`;
           return `Feature "${feature}" marked as completed`;
         }
       }),
-      hive_journal_append: tool({
-        description: "Append entry to .hive/journal.md for audit trail",
-        args: {
-          feature: tool.schema.string().describe("Feature name for context"),
-          trouble: tool.schema.string().describe("What went wrong"),
-          resolution: tool.schema.string().describe("How it was fixed"),
-          constraint: tool.schema.string().optional().describe("Never/Always rule derived")
-        },
-        async execute({ feature, trouble, resolution, constraint }) {
-          const journalPath = path7.join(directory, ".hive", "journal.md");
-          if (!fs9.existsSync(journalPath)) {
-            return `Error: journal.md not found. Create a feature first to initialize the journal.`;
-          }
-          const date5 = new Date().toISOString().split("T")[0];
-          const entry = `
-### ${date5}: ${feature}
-
-**Trouble**: ${trouble}
-**Resolution**: ${resolution}
-${constraint ? `**Constraint**: ${constraint}` : ""}
-**See**: .hive/features/${feature}/plan.md
-
----
-`;
-          fs9.appendFileSync(journalPath, entry);
-          return `Journal entry added for ${feature}. ${constraint ? `Constraint: "${constraint}"` : ""}`;
-        }
-      }),
       hive_plan_write: tool({
         description: "Write plan.md (clears existing comments)",
         args: {
@@ -24004,8 +23461,8 @@ ${constraint ? `**Constraint**: ${constraint}` : ""}
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
-          const hasDiscovery = content.toLowerCase().includes("## discovery");
-          if (!hasDiscovery) {
+          const discoveryMatch = content.match(/^##\s+Discovery\s*$/im);
+          if (!discoveryMatch) {
             return `BLOCKED: Discovery section required before planning.
 
 Your plan must include a \`## Discovery\` section documenting:
@@ -24014,6 +23471,19 @@ Your plan must include a \`## Discovery\` section documenting:
 - Key decisions made
 
 Add this section to your plan content and try again.`;
+          }
+          const afterDiscovery = content.slice(discoveryMatch.index + discoveryMatch[0].length);
+          const nextHeading = afterDiscovery.search(/^##\s+/m);
+          const discoveryContent = nextHeading > -1 ? afterDiscovery.slice(0, nextHeading).trim() : afterDiscovery.trim();
+          if (discoveryContent.length < 100) {
+            return `BLOCKED: Discovery section is too thin (${discoveryContent.length} chars, minimum 100).
+
+A substantive Discovery section should include:
+- Original request quoted
+- Interview summary (key decisions)
+- Research findings with file:line references
+
+Expand your Discovery section and try again.`;
           }
           captureSession(feature, toolContext);
           const planPath = planService.write(feature, content);
@@ -24087,7 +23557,7 @@ Add this section to your plan content and try again.`;
             return "Error: No feature specified. Create a feature or provide feature param.";
           const folder = taskService.create(feature, name, order);
           return `Manual task created: ${folder}
-Reminder: start work with hive_exec_start to use its worktree, and ensure any subagents work in that worktree too.`;
+Reminder: start work with hive_worktree_create to use its worktree, and ensure any subagents work in that worktree too.`;
         }
       }),
       hive_task_update: tool({
@@ -24109,7 +23579,7 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
           return `Task "${task}" updated: status=${updated.status}`;
         }
       }),
-      hive_exec_start: tool({
+      hive_worktree_create: tool({
         description: "Create worktree and begin work on task. Spawns Forager worker automatically.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
@@ -24234,21 +23704,11 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
             spec: specContent,
             workerPrompt
           });
-          const hiveDir = path7.join(directory, ".hive");
+          const hiveDir = path8.join(directory, ".hive");
           const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-          const relativePromptPath = normalizePath(path7.relative(directory, workerPromptPath));
+          const relativePromptPath = normalizePath(path8.relative(directory, workerPromptPath));
           const PREVIEW_MAX_LENGTH = 200;
           const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
-          const hiveBackgroundInstructions = `## Delegation Required
-
-Call the hive_background_task tool to spawn a Forager (Worker/Coder) worker.
-
-\`backgroundTaskCall\` contains the canonical tool arguments.
-
-- Add \`sync: true\` if you need the result in this session.
-- Otherwise omit \`sync\`. Wait for the completion notification (no polling required). After the <system-reminder> arrives, call \`hive_background_output({ task_id: "<id>", block: false })\` once to fetch the final result.
-
-Troubleshooting: if you see "Unknown parameter: workdir", your hive_background_task tool is not Hive's provider. Ensure agent-hive loads after other background_* tool providers, then re-run hive_exec_start.`;
           const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
           const taskToolInstructions = `## Delegation Required
 
@@ -24264,39 +23724,22 @@ task({
 
 Use the \`@path\` attachment syntax in the prompt to reference the file. Do not inline the file contents.
 
-Note: delegateMode is set to 'task' in agent_hive.json. To use Hive's background tools instead, set delegateMode to 'hive'.`;
-          const delegationInstructions = useHiveBackground ? hiveBackgroundInstructions : taskToolInstructions;
+`;
           const responseBase = {
             worktreePath: worktree.path,
             branch: worktree.branch,
             mode: "delegate",
-            delegateMode,
             agent,
             delegationRequired: true,
             workerPromptPath: relativePromptPath,
             workerPromptPreview,
-            ...!useHiveBackground && {
-              taskPromptMode: "opencode-at-file"
-            },
-            ...useHiveBackground && {
-              backgroundTaskCall: {
-                promptFile: workerPromptPath,
-                description: `Hive: ${task}`,
-                workdir: worktree.path,
-                idempotencyKey,
-                feature,
-                task,
-                attempt
-              }
+            taskPromptMode: "opencode-at-file",
+            taskToolCall: {
+              subagent_type: agent,
+              description: `Hive: ${task}`,
+              prompt: taskToolPrompt
             },
-            ...!useHiveBackground && {
-              taskToolCall: {
-                subagent_type: agent,
-                description: `Hive: ${task}`,
-                prompt: taskToolPrompt
-              }
-            },
-            instructions: delegationInstructions
+            instructions: taskToolInstructions
           };
           const jsonPayload = JSON.stringify(responseBase, null, 2);
           const payloadMeta = calculatePayloadMeta({
@@ -24330,7 +23773,7 @@ Note: delegateMode is set to 'task' in agent_hive.json. To use Hive's background
           }, null, 2);
         }
       }),
-      hive_exec_complete: tool({
+      hive_worktree_commit: tool({
         description: "Complete task: commit changes to branch, write report. Supports blocked/failed/partial status for worker communication.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
@@ -24383,7 +23826,7 @@ Re-run with updated summary showing verification results.`;
               summary,
               blocker,
               worktreePath: worktree2?.path,
-              message: 'Task blocked. Hive Master will ask user and resume with hive_exec_start(continueFrom: "blocked", decision: answer)'
+              message: 'Task blocked. Hive Master will ask user and resume with hive_worktree_create(continueFrom: "blocked", decision: answer)'
             }, null, 2);
           }
           const commitResult = await worktreeService.commitChanges(feature, task, `hive(${task}): ${summary.slice(0, 50)}`);
@@ -24425,7 +23868,7 @@ Re-run with updated summary showing verification results.`;
 Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "unknown"}.`;
         }
       }),
-      hive_exec_abort: tool({
+      hive_worktree_discard: tool({
         description: "Abort task: discard changes, reset status",
         args: {
           task: tool.schema.string().describe("Task folder name"),
@@ -24440,102 +23883,6 @@ Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "
           return `Task "${task}" aborted. Status reset to pending.`;
         }
       }),
-      hive_worker_status: tool({
-        description: "Check status of delegated workers. Shows running workers, blockers, and progress.",
-        args: {
-          task: tool.schema.string().optional().describe("Specific task to check, or omit for all"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task: specificTask, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          const STUCK_THRESHOLD = 10 * 60 * 1000;
-          const HEARTBEAT_STALE_THRESHOLD = 5 * 60 * 1000;
-          const now = Date.now();
-          const PREVIEW_MAX_LENGTH = 200;
-          const tasks = taskService.list(feature);
-          const inProgressTasks = tasks.filter((t) => (t.status === "in_progress" || t.status === "blocked") && (!specificTask || t.folder === specificTask));
-          if (inProgressTasks.length === 0) {
-            return specificTask ? `No active worker for task "${specificTask}"` : "No active workers.";
-          }
-          const workers = await Promise.all(inProgressTasks.map(async (t) => {
-            const worktree = await worktreeService.get(feature, t.folder);
-            const rawStatus = taskService.getRawStatus(feature, t.folder);
-            const workerSession = rawStatus?.workerSession;
-            const backgroundRecord = backgroundManager.getTaskByHiveTask(feature, t.folder);
-            const observation = backgroundRecord ? backgroundManager.getTaskObservation(backgroundRecord.taskId) : null;
-            let maybeStuck = false;
-            let lastActivityAt = null;
-            if (observation?.lastActivityAt) {
-              lastActivityAt = new Date(observation.lastActivityAt).getTime();
-            } else if (workerSession?.lastHeartbeatAt) {
-              lastActivityAt = new Date(workerSession.lastHeartbeatAt).getTime();
-              const heartbeatStale = now - lastActivityAt > HEARTBEAT_STALE_THRESHOLD;
-              const noRecentMessages = !workerSession.messageCount || workerSession.messageCount === 0;
-              maybeStuck = heartbeatStale && t.status === "in_progress";
-            } else if (rawStatus?.startedAt) {
-              lastActivityAt = new Date(rawStatus.startedAt).getTime();
-              maybeStuck = now - lastActivityAt > STUCK_THRESHOLD && t.status === "in_progress";
-            }
-            if (typeof observation?.maybeStuck === "boolean") {
-              maybeStuck = observation.maybeStuck;
-            }
-            const startedAtIso = backgroundRecord?.startedAt || rawStatus?.startedAt || null;
-            const startedAtMs = startedAtIso ? new Date(startedAtIso).getTime() : null;
-            const elapsedMs = startedAtMs ? Math.max(0, now - startedAtMs) : 0;
-            const lastActivityIso = observation?.lastActivityAt || workerSession?.lastHeartbeatAt || rawStatus?.startedAt || null;
-            const lastActivityAgo = lastActivityIso ? formatRelativeTime(lastActivityIso) : "never";
-            const messageCount = observation?.messageCount ?? backgroundRecord?.progress?.messageCount ?? workerSession?.messageCount ?? 0;
-            const lastMessagePreview = backgroundRecord?.progress?.lastMessage ? backgroundRecord.progress.lastMessage.slice(0, PREVIEW_MAX_LENGTH) : null;
-            return {
-              task: t.folder,
-              name: t.name,
-              status: t.status,
-              taskId: backgroundRecord?.taskId || workerSession?.taskId || null,
-              description: backgroundRecord?.description || null,
-              startedAt: startedAtIso,
-              workerSession: workerSession || null,
-              sessionId: workerSession?.sessionId || null,
-              agent: workerSession?.agent || "inline",
-              mode: workerSession?.mode || "inline",
-              attempt: workerSession?.attempt || 1,
-              messageCount: workerSession?.messageCount || 0,
-              lastHeartbeatAt: workerSession?.lastHeartbeatAt || null,
-              workerId: workerSession?.workerId || null,
-              worktreePath: worktree?.path || null,
-              branch: worktree?.branch || null,
-              maybeStuck,
-              activity: {
-                elapsedMs,
-                elapsedFormatted: formatElapsed(elapsedMs),
-                messageCount,
-                lastActivityAgo,
-                lastMessagePreview,
-                maybeStuck
-              },
-              blocker: rawStatus?.blocker || null,
-              summary: t.summary || null
-            };
-          }));
-          const stuckWorkers = workers.filter((worker) => worker.activity?.maybeStuck).length;
-          const hint = workers.some((w) => w.status === "blocked") ? 'Use hive_exec_start(task, continueFrom: "blocked", decision: answer) to resume blocked workers' : workers.some((w) => w.maybeStuck) ? "Some workers may be stuck. Use hive_background_output({ task_id }) to check output, or abort with hive_exec_abort." : "Workers in progress. Wait for the completion notification (no polling required). Use hive_worker_status for spot checks; use hive_background_output only if interim output is explicitly needed.";
-          const guidance = stuckWorkers > 0 ? `
-
-⚠️ ${stuckWorkers} worker(s) may be stuck (no activity for 10+ minutes). Consider cancelling or investigating.` : "";
-          return JSON.stringify({
-            feature,
-            delegateMode,
-            omoSlimEnabled: isOmoSlimEnabled(),
-            backgroundTaskProvider: useHiveBackground ? "hive" : "task",
-            workers,
-            summary: {
-              stuckWorkers
-            },
-            hint: hint + guidance
-          }, null, 2);
-        }
-      }),
       hive_merge: tool({
         description: "Merge completed task branch into current branch (explicit integration)",
         args: {
@@ -24551,7 +23898,7 @@ Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "
           if (!taskInfo)
             return `Error: Task "${task}" not found`;
           if (taskInfo.status !== "done")
-            return "Error: Task must be completed before merging. Use hive_exec_complete first.";
+            return "Error: Task must be completed before merging. Use hive_worktree_commit first.";
           const result = await worktreeService.merge(feature, task, strategy);
           if (!result.success) {
             if (result.conflicts && result.conflicts.length > 0) {
@@ -24568,27 +23915,6 @@ Commit: ${result.sha}
 Files changed: ${result.filesChanged?.length || 0}`;
         }
       }),
-      hive_worktree_list: tool({
-        description: "List all worktrees for current feature",
-        args: {
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          const worktrees = await worktreeService.list(feature);
-          if (worktrees.length === 0)
-            return "No worktrees found for this feature.";
-          const lines = ["| Task | Branch | Has Changes |", "|------|--------|-------------|"];
-          for (const wt of worktrees) {
-            const hasChanges = await worktreeService.hasUncommittedChanges(wt.feature, wt.step);
-            lines.push(`| ${wt.step} | ${wt.branch} | ${hasChanges ? "Yes" : "No"} |`);
-          }
-          return lines.join(`
-`);
-        }
-      }),
       hive_context_write: tool({
         description: "Write a context file for the feature. Context files store persistent notes, decisions, and reference material.",
         args: {
@@ -24630,16 +23956,22 @@ Files changed: ${result.filesChanged?.length || 0}`;
           const plan = planService.read(feature);
           const tasks = taskService.list(feature);
           const contextFiles = contextService.list(feature);
-          const tasksSummary = tasks.map((t) => {
+          const tasksSummary = await Promise.all(tasks.map(async (t) => {
             const rawStatus = taskService.getRawStatus(feature, t.folder);
+            const worktree = await worktreeService.get(feature, t.folder);
+            const hasChanges = worktree ? await worktreeService.hasUncommittedChanges(worktree.feature, worktree.step) : null;
             return {
               folder: t.folder,
               name: t.name,
               status: t.status,
               origin: t.origin || "plan",
-              dependsOn: rawStatus?.dependsOn ?? null
+              dependsOn: rawStatus?.dependsOn ?? null,
+              worktree: worktree ? {
+                branch: worktree.branch,
+                hasChanges
+              } : null
             };
-          });
+          }));
           const contextSummary = contextFiles.map((c) => ({
             name: c.name,
             chars: c.content.length,
@@ -24677,7 +24009,7 @@ Files changed: ${result.filesChanged?.length || 0}`;
               return `${runnableTasks.length} tasks are ready to start in parallel: ${runnableTasks.join(", ")}`;
             }
             if (runnableTasks.length === 1) {
-              return `Start next task with hive_exec_start: ${runnableTasks[0]}`;
+              return `Start next task with hive_worktree_create: ${runnableTasks[0]}`;
             }
             const pending = tasks2.find((t) => t.status === "pending");
             if (pending) {
@@ -24715,79 +24047,45 @@ Files changed: ${result.filesChanged?.length || 0}`;
           });
         }
       }),
-      hive_request_review: tool({
-        description: "Request human review of completed task. BLOCKS until human approves or requests changes. Call after completing work, before merging.",
+      hive_agents_md: tool({
+        description: "Initialize or sync AGENTS.md. init: scan codebase and generate (preview only). sync: propose updates from feature contexts. apply: write approved content to disk.",
         args: {
-          task: tool.schema.string().describe("Task folder name"),
-          summary: tool.schema.string().describe("Summary of what you did for human to review"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
+          action: tool.schema.enum(["init", "sync", "apply"]).describe("Action to perform"),
+          feature: tool.schema.string().optional().describe("Feature name for sync action"),
+          content: tool.schema.string().optional().describe("Content to write (required for apply action)")
         },
-        async execute({ task, summary, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified.";
-          const taskDir = path7.join(directory, ".hive", "features", feature, "tasks", task);
-          if (!fs9.existsSync(taskDir)) {
-            return `Error: Task '${task}' not found in feature '${feature}'`;
-          }
-          const reportPath = path7.join(taskDir, "report.md");
-          const existingReport = fs9.existsSync(reportPath) ? fs9.readFileSync(reportPath, "utf-8") : `# Task Report
-`;
-          const attemptCount = (existingReport.match(/## Attempt \d+/g) || []).length + 1;
-          const timestamp = new Date().toISOString();
-          const newContent = existingReport + `
-## Attempt ${attemptCount}
-
-**Requested**: ${timestamp}
-
-### Summary
-
-${summary}
-
-`;
-          fs9.writeFileSync(reportPath, newContent);
-          const pendingPath = path7.join(taskDir, "PENDING_REVIEW");
-          fs9.writeFileSync(pendingPath, JSON.stringify({
-            attempt: attemptCount,
-            requestedAt: timestamp,
-            summary: summary.substring(0, 200) + (summary.length > 200 ? "..." : "")
-          }, null, 2));
-          const pollInterval = 2000;
-          const maxWait = 30 * 60 * 1000;
-          const startTime = Date.now();
-          while (fs9.existsSync(pendingPath)) {
-            if (Date.now() - startTime > maxWait) {
-              return "Review timed out after 30 minutes. Human did not respond.";
+        async execute({ action, feature, content }) {
+          if (action === "init") {
+            const result = await agentsMdService.init();
+            if (result.existed) {
+              return `AGENTS.md already exists (${result.content.length} chars). Use 'sync' to propose updates.`;
             }
-            await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-          }
-          const resultPath = path7.join(taskDir, "REVIEW_RESULT");
-          if (!fs9.existsSync(resultPath)) {
-            return "Review cancelled (PENDING_REVIEW removed but no REVIEW_RESULT).";
-          }
-          const result = fs9.readFileSync(resultPath, "utf-8").trim();
-          fs9.appendFileSync(reportPath, `### Review Result
-
-${result}
-
----
-
-`);
-          if (result.toUpperCase() === "APPROVED") {
-            return `✅ APPROVED
-
-Your work has been approved. You may now merge:
+            return `Generated AGENTS.md from codebase scan (${result.content.length} chars):
 
-  hive_merge(task="${task}")
+${result.content}
 
-After merging, proceed to the next task.`;
-          } else {
-            return `\uD83D\uDD04 Changes Requested
+⚠️ This has NOT been written to disk. Ask the user via question() whether to write it to AGENTS.md.`;
+          }
+          if (action === "sync") {
+            if (!feature)
+              return "Error: feature name required for sync action";
+            const result = await agentsMdService.sync(feature);
+            if (result.proposals.length === 0) {
+              return "No new findings to sync to AGENTS.md.";
+            }
+            return `Proposed AGENTS.md updates from feature "${feature}":
 
-${result}
+${result.diff}
 
-Make the requested changes, then call hive_request_review again.`;
+⚠️ These changes have NOT been applied. Ask the user via question() whether to apply them.`;
+          }
+          if (action === "apply") {
+            if (!content)
+              return "Error: content required for apply action. Use init or sync first to get content, then apply with the approved content.";
+            const result = agentsMdService.apply(content);
+            return `AGENTS.md ${result.isNew ? "created" : "updated"} (${result.chars} chars) at ${result.path}`;
           }
+          return "Error: unknown action";
         }
       })
     },
@@ -24802,27 +24100,13 @@ Make the requested changes, then call hive_request_review again.`;
         }
       }
     },
-    event: async ({ event }) => {
-      if (event.type === "session.idle") {
-        const sessionId = event.properties.sessionID;
-        if (sessionId) {
-          backgroundManager.handleSessionIdle(sessionId);
-        }
-      }
-      if (event.type === "message.updated") {
-        const info = event.properties.info;
-        const sessionId = info?.sessionID;
-        if (sessionId) {
-          backgroundManager.handleMessageEvent(sessionId);
-        }
-      }
-    },
     config: async (opencodeConfig) => {
       configService.init();
       const hiveUserConfig = configService.getAgentConfig("hive-master");
       const hiveAutoLoadedSkills = await buildAutoLoadedSkillsContent("hive-master", configService, directory);
       const hiveConfig = {
         model: hiveUserConfig.model,
+        variant: hiveUserConfig.variant,
         temperature: hiveUserConfig.temperature ?? 0.5,
         description: "Hive (Hybrid) - Plans + orchestrates. Detects phase, loads skills on-demand.",
         prompt: QUEEN_BEE_PROMPT + hiveAutoLoadedSkills,
@@ -24830,16 +24114,14 @@ Make the requested changes, then call hive_request_review again.`;
           question: "allow",
           skill: "allow",
           todowrite: "allow",
-          todoread: "allow",
-          hive_background_task: "allow",
-          hive_background_output: "allow",
-          hive_background_cancel: "allow"
+          todoread: "allow"
         }
       };
       const architectUserConfig = configService.getAgentConfig("architect-planner");
       const architectAutoLoadedSkills = await buildAutoLoadedSkillsContent("architect-planner", configService, directory);
       const architectConfig = {
         model: architectUserConfig.model,
+        variant: architectUserConfig.variant,
         temperature: architectUserConfig.temperature ?? 0.7,
         description: "Architect (Planner) - Plans features, interviews, writes plans. NEVER executes.",
         prompt: ARCHITECT_BEE_PROMPT + architectAutoLoadedSkills,
@@ -24850,16 +24132,14 @@ Make the requested changes, then call hive_request_review again.`;
           skill: "allow",
           todowrite: "allow",
           todoread: "allow",
-          webfetch: "allow",
-          hive_background_task: "allow",
-          hive_background_output: "allow",
-          hive_background_cancel: "allow"
+          webfetch: "allow"
         }
       };
       const swarmUserConfig = configService.getAgentConfig("swarm-orchestrator");
       const swarmAutoLoadedSkills = await buildAutoLoadedSkillsContent("swarm-orchestrator", configService, directory);
       const swarmConfig = {
         model: swarmUserConfig.model,
+        variant: swarmUserConfig.variant,
         temperature: swarmUserConfig.temperature ?? 0.5,
         description: "Swarm (Orchestrator) - Orchestrates execution. Delegates, spawns workers, verifies, merges.",
         prompt: SWARM_BEE_PROMPT + swarmAutoLoadedSkills,
@@ -24867,25 +24147,20 @@ Make the requested changes, then call hive_request_review again.`;
           question: "allow",
           skill: "allow",
           todowrite: "allow",
-          todoread: "allow",
-          hive_background_task: "allow",
-          hive_background_output: "allow",
-          hive_background_cancel: "allow"
+          todoread: "allow"
         }
       };
       const scoutUserConfig = configService.getAgentConfig("scout-researcher");
       const scoutAutoLoadedSkills = await buildAutoLoadedSkillsContent("scout-researcher", configService, directory);
       const scoutConfig = {
         model: scoutUserConfig.model,
+        variant: scoutUserConfig.variant,
         temperature: scoutUserConfig.temperature ?? 0.5,
         mode: "subagent",
         description: "Scout (Explorer/Researcher/Retrieval) - Researches codebase + external docs/data.",
         prompt: SCOUT_BEE_PROMPT + scoutAutoLoadedSkills,
         permission: {
           edit: "deny",
-          hive_background_task: "deny",
-          hive_background_output: "deny",
-          hive_background_cancel: "deny",
           task: "deny",
           delegate: "deny",
           skill: "allow",
@@ -24896,14 +24171,12 @@ Make the requested changes, then call hive_request_review again.`;
       const foragerAutoLoadedSkills = await buildAutoLoadedSkillsContent("forager-worker", configService, directory);
       const foragerConfig = {
         model: foragerUserConfig.model,
+        variant: foragerUserConfig.variant,
         temperature: foragerUserConfig.temperature ?? 0.3,
         mode: "subagent",
         description: "Forager (Worker/Coder) - Executes tasks directly in isolated worktrees. Never delegates.",
         prompt: FORAGER_BEE_PROMPT + foragerAutoLoadedSkills,
         permission: {
-          hive_background_task: "deny",
-          hive_background_output: "deny",
-          hive_background_cancel: "deny",
           task: "deny",
           delegate: "deny",
           skill: "allow"
@@ -24913,15 +24186,13 @@ Make the requested changes, then call hive_request_review again.`;
       const hygienicAutoLoadedSkills = await buildAutoLoadedSkillsContent("hygienic-reviewer", configService, directory);
       const hygienicConfig = {
         model: hygienicUserConfig.model,
+        variant: hygienicUserConfig.variant,
         temperature: hygienicUserConfig.temperature ?? 0.3,
         mode: "subagent",
         description: "Hygienic (Consultant/Reviewer/Debugger) - Reviews plan documentation quality. OKAY/REJECT verdict.",
         prompt: HYGIENIC_BEE_PROMPT + hygienicAutoLoadedSkills,
         permission: {
           edit: "deny",
-          hive_background_task: "deny",
-          hive_background_output: "deny",
-          hive_background_cancel: "deny",
           task: "deny",
           delegate: "deny",
           skill: "allow"