opencode-hive 0.8.2 → 0.9.0

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -8,9 +9,11 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import * as path6 from "path";
+import * as path5 from "path";
+import * as fs6 from "fs";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -12332,8 +12335,339 @@ function tool(input) {
   return input;
 }
 tool.schema = exports_external;
+// src/skills/registry.generated.ts
+var BUILTIN_SKILL_NAMES = ["hive", "hive-execution"];
+var BUILTIN_SKILLS = [
+  {
+    name: "hive",
+    description: "Plan-first AI development with isolated git worktrees and human review. Use for any feature development.",
+    template: `# Hive Workflow
+
+You are working in a Hive-enabled repository. Follow this plan-first workflow.
+
+## Lifecycle
+
+\`\`\`
+Feature -> Plan -> Review -> Approve -> Execute -> Merge -> Complete
+\`\`\`
+
+---
+
+## Phase 1: Planning
+
+### Start Feature
+
+\`\`\`
+hive_feature_create({ name: "feature-name" })
+\`\`\`
+
+### Discovery Phase (Required)
+
+BEFORE writing a plan, you MUST:
+1. Ask clarifying questions about the feature
+2. Document Q&A in plan.md with a \`## Discovery\` section
+3. Research the codebase (grep, read existing code)
+4. Save findings with hive_context_write
+
+Your plan MUST include a \`## Discovery\` section or hive_plan_write will be BLOCKED.
+
+Example discovery section:
+\`\`\`markdown
+## Discovery
+
+**Q: What authentication system do we use?**
+A: JWT with refresh tokens, see src/auth/
+
+**Q: Should this work offline?**
+A: No, online-only is fine
+
+**Research:**
+- Found existing theme system in src/theme/
+- Uses CSS variables pattern
+\`\`\`
+
+### Research First
+
+Before writing anything:
+1. Search for relevant files (grep, explore)
+2. Read existing implementations
+3. Identify patterns and conventions
+
+Save all findings:
+\`\`\`
+hive_context_write({
+  name: "research",
+  content: \`# Research Findings
+
+## Existing Patterns
+- Theme system uses CSS variables in src/theme/
+- Components follow atomic design
+
+## Files to Modify
+- src/theme/colors.ts
+- src/components/ThemeProvider.tsx
+\`
+})
+\`\`\`
+
+### Write the Plan
+
+Your plan should include these sections:
+
+| Section | Required | Purpose |
+|---------|----------|---------|
+| \`## Discovery\` | Yes (gate enforced) | Q&A and research before planning |
+| \`## Problem\` | Yes | What we're solving |
+| \`## Non-Goals\` | Recommended | What we're NOT building (scope boundaries) |
+| \`## Tasks\` | Yes | Implementation steps with \`### N. Task Name\` format |
+| \`## Ghost Diffs\` | Recommended | Rejected alternatives (prevents re-proposing) |
+| \`## Success Criteria\` | Optional | How we know we're done |
+
+Format for task parsing:
+
+\`\`\`markdown
+# Feature Name
+
+## Overview
+One paragraph explaining what and why.
+
+## Tasks
+
+### 1. Task Name
+Description of what this task accomplishes.
+- Specific files to modify
+- Expected outcome
+
+### 2. Another Task
+Description...
+
+### 3. Final Task
+Description...
+\`\`\`
+
+Write with:
+\`\`\`
+hive_plan_write({ content: \`...\` })
+\`\`\`
+
+**STOP** and tell user: "Plan written. Please review."
+
+---
+
+## Phase 2: Review (Human)
+
+- User reviews plan.md in VS Code sidebar
+- User can add comments
+- Use \`hive_plan_read()\` to see user comments
+- Revise plan based on feedback
+- User clicks "Approve" or runs \`hive_plan_approve()\`
+
+---
+
+## Phase 3: Execution
+
+### Generate Tasks
+
+\`\`\`
+hive_tasks_sync()
+\`\`\`
+
+Parses \`### N. Task Name\` headers into task folders.
+
+### Execute Each Task
+
+For each task in order:
+
+#### 1. Start (creates worktree)
+\`\`\`
+hive_exec_start({ task: "01-task-name" })
+\`\`\`
+
+#### 2. Implement
+Work in the isolated worktree path. Read \`spec.md\` for context.
+
+#### 3. Complete (commits to branch)
+\`\`\`
+hive_exec_complete({ task: "01-task-name", summary: "What was done. Tests pass." })
+\`\`\`
+
+**Note**: Summary must mention verification (tests/build) or completion will be BLOCKED.
+
+#### 4. Merge (integrates to main)
+\`\`\`
+hive_merge({ task: "01-task-name", strategy: "squash" })
+\`\`\`
+
+---
+
+## Phase 4: Completion
+
+After all tasks merged:
+\`\`\`
+hive_feature_complete({ name: "feature-name" })
+\`\`\`
+
+---
+
+## Tool Quick Reference
+
+| Phase | Tool | Purpose |
+|-------|------|---------|
+| Plan | \`hive_feature_create\` | Start new feature |
+| Plan | \`hive_context_write\` | Save research findings |
+| Plan | \`hive_plan_write\` | Write the plan |
+| Plan | \`hive_plan_read\` | Check for user comments |
+| Plan | \`hive_plan_approve\` | Approve plan |
+| Execute | \`hive_tasks_sync\` | Generate tasks from plan |
+| Execute | \`hive_exec_start\` | Start task (creates worktree) |
+| Execute | \`hive_exec_complete\` | Finish task (commits changes) |
+| Execute | \`hive_merge\` | Integrate task to main |
+| Complete | \`hive_feature_complete\` | Mark feature done |
+
+---
+
+## Task Design Guidelines
+
+### Good Tasks
+
+| Characteristic | Example |
+|---------------|---------|
+| **Atomic** | "Add ThemeContext provider" not "Add theming" |
+| **Testable** | "Toggle switches between light/dark" |
+| **Independent** | Can be completed without other tasks (where possible) |
+| **Ordered** | Dependencies come first |
+
+### Task Sizing
+
+- **Too small**: "Add import statement" - combine with related work
+- **Too large**: "Implement entire feature" - break into logical units
+- **Just right**: "Create theme context with light/dark values"
+
+---
+
+## Rules
+
+1. **Never skip planning** - Always write plan first
+2. **Context is critical** - Save all research with \`hive_context_write\`
+3. **Wait for approval** - Don't execute until user approves
+4. **One task at a time** - Complete and merge before starting next
+5. **Squash merges** - Keep history clean with single commit per task
+
+---
+
+## Error Recovery
+
+### Task Failed
+\`\`\`
+hive_exec_abort(task="<task>")  # Discards changes
+hive_exec_start(task="<task>")  # Fresh start
+\`\`\`
+
+### Merge Conflicts
+1. Resolve conflicts in the worktree
+2. Commit the resolution
+3. Run \`hive_merge\` again
+
+---
+
+## Example
+
+User: "Add dark mode support"
+
+\`\`\`
+1. hive_feature_create({ name: "dark-mode" })
+2. Research: grep for theme, colors, CSS variables
+3. hive_context_write({ name: "research", content: "Found theme in src/theme/..." })
+4. hive_plan_write({ content: "# Dark Mode\\n\\n## Tasks\\n\\n### 1. Add theme context..." })
+5. Tell user: "Plan ready for review"
+6. [User reviews and approves]
+7. hive_tasks_sync()
+8. For each task: exec_start -> implement -> exec_complete -> merge
+9. hive_feature_complete({ name: "dark-mode" })
+\`\`\``
+  },
+  {
+    name: "hive-execution",
+    description: "Execute Hive feature tasks with worktree isolation, parallel orchestration, and clean git history. Use when running synced Hive tasks.",
+    template: `# Hive Execution
+
+Quick reference for executing Hive tasks.
+
+## Workflow Summary
+
+1. **Feature create** → Discovery guide injected
+2. **Discovery** → Q&A documented in plan.md
+3. **Plan write** → GATE: requires ## Discovery section
+4. **Approval** → User reviews in VS Code
+5. **Exec start** → Delegation guide (Master), TDD+debugging (Worker)
+6. **Complete** → GATE: requires verification mention
+7. **Merge** → Squash into feature branch
+
+## Gates
+
+| Tool | Gate | Error |
+|------|------|-------|
+| hive_plan_write | ## Discovery section | "BLOCKED: Discovery required" |
+| hive_exec_complete | Verification in summary | "BLOCKED: No verification" |
+
+## Task Lifecycle
+
+\`\`\`
+hive_exec_start(task)      # Creates worktree
+  ↓
+[implement in worktree]
+  ↓
+hive_exec_complete(task, summary)  # Commits to branch
+  ↓
+hive_merge(task, strategy: "squash")  # Integrates to main
+\`\`\`
+
+## Quick Reference
+
+| Tool | Purpose |
+|------|---------|
+| hive_status | Check overall progress |
+| hive_worker_status | Check delegated workers |
+| hive_exec_abort | Discard changes, restart |
+| hive_merge | Integrate completed task |
+| hive_worktree_list | See active worktrees |
+
+## Error Recovery
+
+### Task Failed
+\`\`\`
+hive_exec_abort(task)  # Discards changes
+hive_exec_start(task)  # Fresh start
+\`\`\`
+
+### Merge Conflicts
+1. Resolve conflicts in worktree
+2. Commit resolution
+3. Run hive_merge again`
+  }
+];
+
+// src/skills/builtin.ts
+function loadBuiltinSkill(name) {
+  const skill = BUILTIN_SKILLS.find((s) => s.name === name);
+  if (!skill) {
+    return {
+      found: false,
+      error: `Unknown builtin skill: ${name}. Available: ${BUILTIN_SKILL_NAMES.join(", ")}`
+    };
+  }
+  return {
+    found: true,
+    skill,
+    source: "builtin"
+  };
+}
+function getBuiltinSkills() {
+  return BUILTIN_SKILLS;
+}
+
 // ../hive-core/dist/index.js
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import * as path from "path";
 import * as fs from "fs";
 import * as path2 from "path";
@@ -12341,16 +12675,16 @@ import * as fs2 from "fs";
 import * as fs3 from "fs";
 import * as fs4 from "fs";
 import * as fs5 from "fs";
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import * as path3 from "path";
 import { Buffer as Buffer2 } from "node:buffer";
 import { spawn } from "child_process";
 import { normalize } from "node:path";
 import { EventEmitter } from "node:events";
-import * as fs7 from "fs";
-import * as path4 from "path";
 import * as fs8 from "fs";
-import * as path5 from "path";
+import * as path4 from "path";
+import * as fs10 from "fs";
+import * as path6 from "path";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -12368,7 +12702,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
 var require_ms = __commonJS((exports, module) => {
   var s = 1000;
   var m = s * 60;
@@ -12817,8 +13151,8 @@ var require_has_flag = __commonJS((exports, module) => {
   };
 });
 var require_supports_color = __commonJS((exports, module) => {
-  var os = __require("os");
-  var tty = __require("tty");
+  var os = __require2("os");
+  var tty = __require2("tty");
   var hasFlag = require_has_flag();
   var { env } = process;
   var forceColor;
@@ -12914,8 +13248,8 @@ var require_supports_color = __commonJS((exports, module) => {
   };
 });
 var require_node = __commonJS((exports, module) => {
-  var tty = __require("tty");
-  var util = __require("util");
+  var tty = __require2("tty");
+  var util = __require2("util");
   exports.init = init;
   exports.log = log;
   exports.formatArgs = formatArgs;
@@ -13094,7 +13428,7 @@ var require_src2 = __commonJS((exports) => {
     return mod && mod.__esModule ? mod : { default: mod };
   };
   Object.defineProperty(exports, "__esModule", { value: true });
-  var fs_1 = __require("fs");
+  var fs_1 = __require2("fs");
   var debug_1 = __importDefault(require_src());
   var log = debug_1.default("@kwsites/file-exists");
   function check2(path32, isFile, isDirectory) {
@@ -13174,6 +13508,17 @@ var require_dist2 = __commonJS((exports) => {
   exports.createDeferred = deferred;
   exports.default = deferred;
 });
+var DEFAULT_HIVE_CONFIG = {
+  enableToolsFor: [],
+  agents: {
+    worker: {
+      visible: true
+    }
+  },
+  omoSlim: {
+    enabled: false
+  }
+};
 var HIVE_DIR = ".hive";
 var FEATURES_DIR = "features";
 var TASKS_DIR = "tasks";
@@ -13183,9 +13528,14 @@ var COMMENTS_FILE = "comments.json";
 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 getHivePath(projectRoot) {
   return path.join(projectRoot, HIVE_DIR);
 }
+function getJournalPath(projectRoot) {
+  return path.join(getHivePath(projectRoot), JOURNAL_FILE);
+}
 function getFeaturesPath(projectRoot) {
   return path.join(getHivePath(projectRoot), FEATURES_DIR);
 }
@@ -13219,6 +13569,9 @@ function getTaskReportPath(projectRoot, featureName, taskFolder) {
 function getTaskSpecPath(projectRoot, featureName, taskFolder) {
   return path.join(getTaskPath(projectRoot, featureName, taskFolder), "spec.md");
 }
+function getApprovedPath(projectRoot, featureName) {
+  return path.join(getFeaturePath(projectRoot, featureName), APPROVED_FILE);
+}
 var SUBTASKS_DIR = "subtasks";
 var SPEC_FILE = "spec.md";
 function getSubtasksPath(projectRoot, featureName, taskFolder) {
@@ -13312,6 +13665,22 @@ function listFeatures(projectRoot) {
     return [];
   return fs2.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) {
@@ -13325,6 +13694,10 @@ 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",
@@ -13343,6 +13716,16 @@ class FeatureService {
       return [];
     return fs3.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
+  getActive() {
+    const features = this.list();
+    for (const name of features) {
+      const feature = this.get(name);
+      if (feature && feature.status !== "completed") {
+        return feature;
+      }
+    }
+    return null;
+  }
   updateStatus(name, status) {
     const feature = this.get(name);
     if (!feature)
@@ -13422,6 +13805,7 @@ class PlanService {
     const planPath = getPlanPath(this.projectRoot, featureName);
     writeText(planPath, content);
     this.clearComments(featureName);
+    this.revokeApproval(featureName);
     return planPath;
   }
   read(featureName) {
@@ -13429,25 +13813,45 @@ class PlanService {
     const content = readText(planPath);
     if (content === null)
       return null;
-    const feature = readJson(getFeatureJsonPath(this.projectRoot, featureName));
     const comments = this.getComments(featureName);
+    const isApproved = this.isApproved(featureName);
     return {
       content,
-      status: feature?.status || "planning",
+      status: isApproved ? "approved" : "planning",
       comments
     };
   }
   approve(featureName) {
-    const featurePath = getFeatureJsonPath(this.projectRoot, featureName);
-    const feature = readJson(featurePath);
-    if (!feature)
-      throw new Error(`Feature '${featureName}' not found`);
     if (!fileExists(getPlanPath(this.projectRoot, featureName))) {
       throw new Error(`No plan.md found for feature '${featureName}'`);
     }
-    feature.status = "approved";
-    feature.approvedAt = new Date().toISOString();
-    writeJson(featurePath, feature);
+    const approvedPath = getApprovedPath(this.projectRoot, featureName);
+    const timestamp = new Date().toISOString();
+    fs4.writeFileSync(approvedPath, `Approved at ${timestamp}
+`);
+    const featurePath = getFeatureJsonPath(this.projectRoot, featureName);
+    const feature = readJson(featurePath);
+    if (feature) {
+      feature.status = "approved";
+      feature.approvedAt = timestamp;
+      writeJson(featurePath, feature);
+    }
+  }
+  isApproved(featureName) {
+    return fileExists(getApprovedPath(this.projectRoot, featureName));
+  }
+  revokeApproval(featureName) {
+    const approvedPath = getApprovedPath(this.projectRoot, featureName);
+    if (fileExists(approvedPath)) {
+      fs4.unlinkSync(approvedPath);
+    }
+    const featurePath = getFeatureJsonPath(this.projectRoot, featureName);
+    const feature = readJson(featurePath);
+    if (feature && feature.status === "approved") {
+      feature.status = "planning";
+      delete feature.approvedAt;
+      writeJson(featurePath, feature);
+    }
   }
   getComments(featureName) {
     const commentsPath = getCommentsPath(this.projectRoot, featureName);
@@ -13629,12 +14033,12 @@ class TaskService {
     const tasksPath = getTasksPath(this.projectRoot, featureName);
     if (!fileExists(tasksPath))
       return [];
-    return fs4.readdirSync(tasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    return fs5.readdirSync(tasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   }
   deleteTask(featureName, taskFolder) {
     const taskPath = getTaskPath(this.projectRoot, featureName, taskFolder);
     if (fileExists(taskPath)) {
-      fs4.rmSync(taskPath, { recursive: true });
+      fs5.rmSync(taskPath, { recursive: true });
     }
   }
   getNextOrder(existingFolders) {
@@ -13774,7 +14178,7 @@ _Add detailed instructions here_
     }
     const subtaskPath = getSubtaskPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
     if (fileExists(subtaskPath)) {
-      fs4.rmSync(subtaskPath, { recursive: true });
+      fs5.rmSync(subtaskPath, { recursive: true });
     }
   }
   getSubtask(featureName, taskFolder, subtaskId) {
@@ -13834,7 +14238,7 @@ _Add detailed instructions here_
     const subtasksPath = getSubtasksPath(this.projectRoot, featureName, taskFolder);
     if (!fileExists(subtasksPath))
       return [];
-    return fs4.readdirSync(subtasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+    return fs5.readdirSync(subtasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
   }
   findSubtaskFolder(featureName, taskFolder, subtaskId) {
     const folders = this.listSubtaskFolders(featureName, taskFolder);
@@ -13845,212 +14249,48 @@ _Add detailed instructions here_
     return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   }
 }
-
-class SubtaskService {
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
+var import_file_exists = __toESM(require_dist(), 1);
+var import_debug = __toESM(require_src(), 1);
+var import_promise_deferred = __toESM(require_dist2(), 1);
+var import_promise_deferred2 = __toESM(require_dist2(), 1);
+var __defProp22 = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
+};
+var __commonJS2 = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp22(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  create(featureName, taskFolder, name, type) {
-    const subtasksPath = getSubtasksPath(this.projectRoot, featureName, taskFolder);
-    ensureDir(subtasksPath);
-    const existingFolders = this.listFolders(featureName, taskFolder);
-    const taskOrder = parseInt(taskFolder.split("-")[0], 10);
-    const nextOrder = existingFolders.length + 1;
-    const subtaskId = `${taskOrder}.${nextOrder}`;
-    const folderName = `${nextOrder}-${this.slugify(name)}`;
-    const subtaskPath = getSubtaskPath(this.projectRoot, featureName, taskFolder, folderName);
-    ensureDir(subtaskPath);
-    const subtaskStatus = {
-      status: "pending",
-      type,
-      createdAt: new Date().toISOString()
-    };
-    writeJson(getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, folderName), subtaskStatus);
-    const specContent = `# Subtask: ${name}
-
-**Type:** ${type || "custom"}
-**ID:** ${subtaskId}
-
-## Instructions
-
-_Add detailed instructions here_
-`;
-    writeText(getSubtaskSpecPath(this.projectRoot, featureName, taskFolder, folderName), specContent);
-    return {
-      id: subtaskId,
-      name,
-      folder: folderName,
-      status: "pending",
-      type,
-      createdAt: subtaskStatus.createdAt
-    };
-  }
-  update(featureName, taskFolder, subtaskId, status) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder) {
-      throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-    }
-    const statusPath = getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    const current = readJson(statusPath);
-    if (!current) {
-      throw new Error(`Subtask status not found for '${subtaskId}'`);
-    }
-    const updated = { ...current, status };
-    if (status === "done" && !current.completedAt) {
-      updated.completedAt = new Date().toISOString();
-    }
-    writeJson(statusPath, updated);
-    const name = subtaskFolder.replace(/^\d+-/, "");
-    return {
-      id: subtaskId,
-      name,
-      folder: subtaskFolder,
-      status,
-      type: current.type,
-      createdAt: current.createdAt,
-      completedAt: updated.completedAt
-    };
-  }
-  list(featureName, taskFolder) {
-    const folders = this.listFolders(featureName, taskFolder);
-    const taskOrder = parseInt(taskFolder.split("-")[0], 10);
-    return folders.map((folder, index) => {
-      const statusPath = getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, folder);
-      const status = readJson(statusPath);
-      const name = folder.replace(/^\d+-/, "");
-      const subtaskOrder = parseInt(folder.split("-")[0], 10) || index + 1;
-      return {
-        id: `${taskOrder}.${subtaskOrder}`,
-        name,
-        folder,
-        status: status?.status || "pending",
-        type: status?.type,
-        createdAt: status?.createdAt,
-        completedAt: status?.completedAt
-      };
-    });
-  }
-  get(featureName, taskFolder, subtaskId) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder)
-      return null;
-    const statusPath = getSubtaskStatusPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    const status = readJson(statusPath);
-    if (!status)
-      return null;
-    const taskOrder = parseInt(taskFolder.split("-")[0], 10);
-    const subtaskOrder = parseInt(subtaskFolder.split("-")[0], 10);
-    const name = subtaskFolder.replace(/^\d+-/, "");
-    return {
-      id: `${taskOrder}.${subtaskOrder}`,
-      name,
-      folder: subtaskFolder,
-      status: status.status,
-      type: status.type,
-      createdAt: status.createdAt,
-      completedAt: status.completedAt
-    };
-  }
-  writeSpec(featureName, taskFolder, subtaskId, content) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder) {
-      throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-    }
-    const specPath = getSubtaskSpecPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    writeText(specPath, content);
-    return specPath;
-  }
-  writeReport(featureName, taskFolder, subtaskId, content) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder) {
-      throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-    }
-    const reportPath = getSubtaskReportPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    writeText(reportPath, content);
-    return reportPath;
-  }
-  readSpec(featureName, taskFolder, subtaskId) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder)
-      return null;
-    const specPath = getSubtaskSpecPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    return readText(specPath);
-  }
-  readReport(featureName, taskFolder, subtaskId) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder)
-      return null;
-    const reportPath = getSubtaskReportPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    return readText(reportPath);
-  }
-  delete(featureName, taskFolder, subtaskId) {
-    const subtaskFolder = this.findFolder(featureName, taskFolder, subtaskId);
-    if (!subtaskFolder) {
-      throw new Error(`Subtask '${subtaskId}' not found in task '${taskFolder}'`);
-    }
-    const subtaskPath = getSubtaskPath(this.projectRoot, featureName, taskFolder, subtaskFolder);
-    if (fileExists(subtaskPath)) {
-      fs5.rmSync(subtaskPath, { recursive: true });
-    }
-  }
-  listFolders(featureName, taskFolder) {
-    const subtasksPath = getSubtasksPath(this.projectRoot, featureName, taskFolder);
-    if (!fileExists(subtasksPath))
-      return [];
-    return fs5.readdirSync(subtasksPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
-  }
-  findFolder(featureName, taskFolder, subtaskId) {
-    const folders = this.listFolders(featureName, taskFolder);
-    const subtaskOrder = subtaskId.split(".")[1];
-    return folders.find((f) => f.startsWith(`${subtaskOrder}-`)) || null;
-  }
-  slugify(name) {
-    return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
-  }
-}
-var import_file_exists = __toESM(require_dist(), 1);
-var import_debug = __toESM(require_src(), 1);
-var import_promise_deferred = __toESM(require_dist2(), 1);
-var import_promise_deferred2 = __toESM(require_dist2(), 1);
-var __defProp22 = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames2(fn)[0]])(fn = 0)), res;
-};
-var __commonJS2 = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export2 = (target, all) => {
-  for (var name in all)
-    __defProp22(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames2(from))
-      if (!__hasOwnProp2.call(to, key) && key !== except)
-        __defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp22({}, "__esModule", { value: true }), mod);
-function pathspec(...paths) {
-  const key = new String(paths);
-  cache.set(key, paths);
-  return key;
-}
-function isPathSpec(path32) {
-  return path32 instanceof String && cache.has(path32);
-}
-function toPaths(pathSpec) {
-  return cache.get(pathSpec) || [];
-}
-var cache;
-var init_pathspec = __esm({
-  "src/lib/args/pathspec.ts"() {
-    cache = /* @__PURE__ */ new WeakMap;
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp22({}, "__esModule", { value: true }), mod);
+function pathspec(...paths) {
+  const key = new String(paths);
+  cache.set(key, paths);
+  return key;
+}
+function isPathSpec(path32) {
+  return path32 instanceof String && cache.has(path32);
+}
+function toPaths(pathSpec) {
+  return cache.get(pathSpec) || [];
+}
+var cache;
+var init_pathspec = __esm({
+  "src/lib/args/pathspec.ts"() {
+    cache = /* @__PURE__ */ new WeakMap;
   }
 });
 var GitError;
@@ -18028,7 +18268,7 @@ class WorktreeService {
     const featurePath = path3.join(this.config.hiveDir, "features", feature);
     const tasksPath = path3.join(featurePath, "tasks", step, "status.json");
     try {
-      await fs6.access(tasksPath);
+      await fs7.access(tasksPath);
       return tasksPath;
     } catch {}
     return path3.join(featurePath, "execution", step, "status.json");
@@ -18040,7 +18280,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
-    await fs6.mkdir(path3.dirname(worktreePath), { recursive: true });
+    await fs7.mkdir(path3.dirname(worktreePath), { recursive: true });
     const base = baseBranch || (await git.revparse(["HEAD"])).trim();
     const existing = await this.get(feature, step);
     if (existing) {
@@ -18069,7 +18309,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     try {
-      await fs6.access(worktreePath);
+      await fs7.access(worktreePath);
       const worktreeGit = this.getGit(worktreePath);
       const commit = (await worktreeGit.revparse(["HEAD"])).trim();
       return {
@@ -18089,7 +18329,7 @@ class WorktreeService {
     let base = baseCommit;
     if (!base) {
       try {
-        const status = JSON.parse(await fs6.readFile(statusPath, "utf-8"));
+        const status = JSON.parse(await fs7.readFile(statusPath, "utf-8"));
         base = status.baseCommit;
       } catch {}
     }
@@ -18139,7 +18379,7 @@ class WorktreeService {
     const base = baseBranch || "HEAD~1";
     const worktreeGit = this.getGit(worktreePath);
     const diff = await worktreeGit.diff([`${base}...HEAD`]);
-    await fs6.writeFile(patchPath, diff);
+    await fs7.writeFile(patchPath, diff);
     return patchPath;
   }
   async applyDiff(feature, step, baseBranch) {
@@ -18149,13 +18389,13 @@ class WorktreeService {
     }
     const patchPath = path3.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
-      await fs6.writeFile(patchPath, diffContent);
+      await fs7.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath);
-      await fs6.unlink(patchPath).catch(() => {});
+      await fs7.unlink(patchPath).catch(() => {});
       return { success: true, filesAffected: filesChanged };
     } catch (error45) {
-      await fs6.unlink(patchPath).catch(() => {});
+      await fs7.unlink(patchPath).catch(() => {});
       const err = error45;
       return {
         success: false,
@@ -18171,13 +18411,13 @@ class WorktreeService {
     }
     const patchPath = path3.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
-      await fs6.writeFile(patchPath, diffContent);
+      await fs7.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath, ["-R"]);
-      await fs6.unlink(patchPath).catch(() => {});
+      await fs7.unlink(patchPath).catch(() => {});
       return { success: true, filesAffected: filesChanged };
     } catch (error45) {
-      await fs6.unlink(patchPath).catch(() => {});
+      await fs7.unlink(patchPath).catch(() => {});
       const err = error45;
       return {
         success: false,
@@ -18196,7 +18436,7 @@ class WorktreeService {
     return [...new Set(files)];
   }
   async revertFromSavedDiff(diffPath) {
-    const diffContent = await fs6.readFile(diffPath, "utf-8");
+    const diffContent = await fs7.readFile(diffPath, "utf-8");
     if (!diffContent.trim()) {
       return { success: true, filesAffected: [] };
     }
@@ -18221,7 +18461,7 @@ class WorktreeService {
     try {
       await git.raw(["worktree", "remove", worktreePath, "--force"]);
     } catch {
-      await fs6.rm(worktreePath, { recursive: true, force: true });
+      await fs7.rm(worktreePath, { recursive: true, force: true });
     }
     try {
       await git.raw(["worktree", "prune"]);
@@ -18236,13 +18476,13 @@ class WorktreeService {
     const worktreesDir = this.getWorktreesDir();
     const results = [];
     try {
-      const features = feature ? [feature] : await fs6.readdir(worktreesDir);
+      const features = feature ? [feature] : await fs7.readdir(worktreesDir);
       for (const feat of features) {
         const featurePath = path3.join(worktreesDir, feat);
-        const stat2 = await fs6.stat(featurePath).catch(() => null);
+        const stat2 = await fs7.stat(featurePath).catch(() => null);
         if (!stat2?.isDirectory())
           continue;
-        const steps = await fs6.readdir(featurePath).catch(() => []);
+        const steps = await fs7.readdir(featurePath).catch(() => []);
         for (const step of steps) {
           const info = await this.get(feat, step);
           if (info) {
@@ -18260,16 +18500,16 @@ class WorktreeService {
       await git.raw(["worktree", "prune"]);
     } catch {}
     const worktreesDir = this.getWorktreesDir();
-    const features = feature ? [feature] : await fs6.readdir(worktreesDir).catch(() => []);
+    const features = feature ? [feature] : await fs7.readdir(worktreesDir).catch(() => []);
     for (const feat of features) {
       const featurePath = path3.join(worktreesDir, feat);
-      const stat2 = await fs6.stat(featurePath).catch(() => null);
+      const stat2 = await fs7.stat(featurePath).catch(() => null);
       if (!stat2?.isDirectory())
         continue;
-      const steps = await fs6.readdir(featurePath).catch(() => []);
+      const steps = await fs7.readdir(featurePath).catch(() => []);
       for (const step of steps) {
         const worktreePath = path3.join(featurePath, step);
-        const stepStat = await fs6.stat(worktreePath).catch(() => null);
+        const stepStat = await fs7.stat(worktreePath).catch(() => null);
         if (!stepStat?.isDirectory())
           continue;
         try {
@@ -18290,13 +18530,13 @@ class WorktreeService {
     }
     const patchPath = path3.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
     try {
-      await fs6.writeFile(patchPath, diffContent);
+      await fs7.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath, ["--check"]);
-      await fs6.unlink(patchPath).catch(() => {});
+      await fs7.unlink(patchPath).catch(() => {});
       return [];
     } catch (error45) {
-      await fs6.unlink(patchPath).catch(() => {});
+      await fs7.unlink(patchPath).catch(() => {});
       const err = error45;
       const stderr = err.message || "";
       const conflicts2 = stderr.split(`
@@ -18309,7 +18549,7 @@ class WorktreeService {
   }
   async checkConflictsFromSavedDiff(diffPath, reverse = false) {
     try {
-      await fs6.access(diffPath);
+      await fs7.access(diffPath);
     } catch {
       return [];
     }
@@ -18332,7 +18572,7 @@ class WorktreeService {
   async commitChanges(feature, step, message) {
     const worktreePath = this.getWorktreePath(feature, step);
     try {
-      await fs6.access(worktreePath);
+      await fs7.access(worktreePath);
     } catch {
       return { committed: false, sha: "", message: "Worktree not found" };
     }
@@ -18472,10 +18712,10 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     if (!fileExists(contextPath))
       return [];
-    const files = fs7.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
+    const files = fs8.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
     return files.map((name) => {
       const filePath = path4.join(contextPath, name);
-      const stat2 = fs7.statSync(filePath);
+      const stat2 = fs8.statSync(filePath);
       const content = readText(filePath) || "";
       return {
         name: name.replace(/\.md$/, ""),
@@ -18488,7 +18728,7 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     const filePath = path4.join(contextPath, this.normalizeFileName(fileName));
     if (fileExists(filePath)) {
-      fs7.unlinkSync(filePath);
+      fs8.unlinkSync(filePath);
       return true;
     }
     return false;
@@ -18511,140 +18751,502 @@ ${f.content}`);
     return `${normalized}.md`;
   }
 }
-
-class SessionService {
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
+class ConfigService {
+  configPath;
+  constructor() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    const configDir = path6.join(homeDir, ".config", "opencode");
+    this.configPath = path6.join(configDir, "agent_hive.json");
   }
-  getSessionsPath(featureName) {
-    return path5.join(getFeaturePath(this.projectRoot, featureName), "sessions.json");
-  }
-  getSessions(featureName) {
-    const sessionsPath = this.getSessionsPath(featureName);
-    return readJson(sessionsPath) || { sessions: [] };
-  }
-  saveSessions(featureName, data) {
-    const sessionsPath = this.getSessionsPath(featureName);
-    ensureDir(path5.dirname(sessionsPath));
-    writeJson(sessionsPath, data);
-  }
-  track(featureName, sessionId, taskFolder) {
-    const data = this.getSessions(featureName);
-    const now = new Date().toISOString();
-    let session = data.sessions.find((s) => s.sessionId === sessionId);
-    if (session) {
-      session.lastActiveAt = now;
-      if (taskFolder)
-        session.taskFolder = taskFolder;
-    } else {
-      session = {
-        sessionId,
-        taskFolder,
-        startedAt: now,
-        lastActiveAt: now
+  getPath() {
+    return this.configPath;
+  }
+  get() {
+    try {
+      if (!fs10.existsSync(this.configPath)) {
+        return { ...DEFAULT_HIVE_CONFIG };
+      }
+      const raw = fs10.readFileSync(this.configPath, "utf-8");
+      const stored = JSON.parse(raw);
+      return {
+        ...DEFAULT_HIVE_CONFIG,
+        ...stored,
+        agents: {
+          ...DEFAULT_HIVE_CONFIG.agents,
+          ...stored.agents
+        },
+        omoSlim: {
+          ...DEFAULT_HIVE_CONFIG.omoSlim,
+          ...stored.omoSlim
+        }
       };
-      data.sessions.push(session);
-    }
-    if (!data.master) {
-      data.master = sessionId;
+    } catch {
+      return { ...DEFAULT_HIVE_CONFIG };
     }
-    this.saveSessions(featureName, data);
-    return session;
-  }
-  setMaster(featureName, sessionId) {
-    const data = this.getSessions(featureName);
-    data.master = sessionId;
-    this.saveSessions(featureName, data);
   }
-  getMaster(featureName) {
-    return this.getSessions(featureName).master;
+  set(updates) {
+    const current = this.get();
+    const merged = {
+      ...current,
+      ...updates,
+      agents: updates.agents ? {
+        ...current.agents,
+        ...updates.agents
+      } : current.agents,
+      omoSlim: updates.omoSlim ? {
+        ...current.omoSlim,
+        ...updates.omoSlim
+      } : current.omoSlim
+    };
+    const configDir = path6.dirname(this.configPath);
+    if (!fs10.existsSync(configDir)) {
+      fs10.mkdirSync(configDir, { recursive: true });
+    }
+    fs10.writeFileSync(this.configPath, JSON.stringify(merged, null, 2));
+    return merged;
   }
-  list(featureName) {
-    return this.getSessions(featureName).sessions;
+  exists() {
+    return fs10.existsSync(this.configPath);
   }
-  get(featureName, sessionId) {
-    return this.getSessions(featureName).sessions.find((s) => s.sessionId === sessionId);
+  init() {
+    if (!this.exists()) {
+      return this.set(DEFAULT_HIVE_CONFIG);
+    }
+    return this.get();
   }
-  getByTask(featureName, taskFolder) {
-    return this.getSessions(featureName).sessions.find((s) => s.taskFolder === taskFolder);
+  isOmoSlimEnabled() {
+    return this.get().omoSlim?.enabled ?? false;
   }
-  remove(featureName, sessionId) {
-    const data = this.getSessions(featureName);
-    const index = data.sessions.findIndex((s) => s.sessionId === sessionId);
-    if (index === -1)
-      return false;
-    data.sessions.splice(index, 1);
-    if (data.master === sessionId) {
-      data.master = data.sessions[0]?.sessionId;
-    }
-    this.saveSessions(featureName, data);
-    return true;
+  setOmoSlim(enabled) {
+    return this.set({ omoSlim: { enabled } });
   }
-  findFeatureBySession(sessionId) {
-    const featuresPath = path5.join(this.projectRoot, ".hive", "features");
-    if (!fs8.existsSync(featuresPath))
-      return null;
-    const features = fs8.readdirSync(featuresPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-    for (const feature of features) {
-      const sessions = this.getSessions(feature);
-      if (sessions.sessions.some((s) => s.sessionId === sessionId)) {
-        return feature;
-      }
-      if (sessions.master === sessionId) {
-        return feature;
-      }
-    }
-    return null;
+}
+
+// src/utils/agent-selector.ts
+var AGENT_PATTERNS = [
+  { pattern: /\b(find|search|locate|where|grep|explore|scan|codebase)\b/i, agent: "explorer" },
+  { pattern: /\b(research|investigate|learn|docs?|documentation|library|api|external|github)\b/i, agent: "librarian" },
+  { pattern: /\b(ui|ux|component|frontend|react|vue|svelte|css|style|layout|design|button|form|modal|visual|responsive)\b/i, agent: "designer" },
+  { pattern: /\b(architect|decision|tradeoff|approach|strategy|choose|decide|compare|review|debug|complex)\b/i, agent: "oracle" }
+];
+function selectAgent(taskName, spec) {
+  const content = `${taskName} ${spec}`.toLowerCase();
+  for (const { pattern, agent } of AGENT_PATTERNS) {
+    if (pattern.test(content)) {
+      return agent;
+    }
+  }
+  return "fixer";
+}
+
+// src/utils/worker-prompt.ts
+function buildWorkerPrompt(params) {
+  const {
+    feature,
+    task,
+    taskOrder,
+    worktreePath,
+    branch,
+    plan,
+    contextFiles,
+    spec,
+    previousTasks,
+    continueFrom
+  } = params;
+  const contextSection = contextFiles.length > 0 ? contextFiles.map((f) => `### ${f.name}
+${f.content}`).join(`
+
+`) : "_No context files available._";
+  const previousSection = previousTasks?.length ? previousTasks.map((t) => `- **${t.name}**: ${t.summary}`).join(`
+`) : "_This is the first task._";
+  const continuationSection = continueFrom ? `
+## Continuation from Blocked State
+
+Previous worker was blocked and exited. Here's the context:
+
+**Previous Progress**: ${continueFrom.previousSummary}
+
+**User Decision**: ${continueFrom.decision}
+
+Continue from where the previous worker left off, incorporating the user's decision.
+The worktree already contains the previous worker's progress.
+` : "";
+  return `# Hive Worker Assignment
+
+You are a worker agent executing a task in an isolated git worktree.
+
+## Assignment Details
+
+| Field | Value |
+|-------|-------|
+| Feature | ${feature} |
+| Task | ${task} |
+| Task # | ${taskOrder} |
+| Branch | ${branch} |
+| Worktree | ${worktreePath} |
+
+**CRITICAL**: All file operations MUST be within this worktree path:
+\`${worktreePath}\`
+
+Do NOT modify files outside this directory.
+${continuationSection}
+---
+
+## Plan Context
+
+${plan}
+
+---
+
+## Context Files (Royal Jelly)
+
+${contextSection}
+
+---
+
+## Previous Tasks Completed
+
+${previousSection}
+
+---
+
+## Your Mission
+
+${spec}
+
+---
+
+## 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:
+
+\`\`\`
+hive_exec_complete({
+  task: "${task}",
+  feature: "${feature}",
+  status: "blocked",
+  summary: "What you accomplished so far",
+  blocker: {
+    reason: "Why you're blocked - be specific",
+    options: ["Option A", "Option B", "Option C"],
+    recommendation: "Your suggested choice with reasoning",
+    context: "Relevant background the user needs to decide"
+  }
+})
+\`\`\`
+
+**After calling hive_exec_complete with blocked status, STOP IMMEDIATELY.**
+
+The Hive Master will:
+1. Receive your blocker info
+2. Ask the user via question()
+3. Spawn a NEW worker to continue with the decision
+
+This keeps the user focused on ONE conversation (Hive Master) instead of multiple worker panes.
+
+---
+
+## Completion Protocol
+
+When your task is **fully complete**:
+
+\`\`\`
+hive_exec_complete({
+  task: "${task}",
+  feature: "${feature}",
+  status: "completed",
+  summary: "Concise summary of what you accomplished"
+})
+\`\`\`
+
+**CRITICAL: After calling hive_exec_complete, you MUST STOP IMMEDIATELY.**
+Do NOT continue working. Do NOT respond further. Your session is DONE.
+The Hive Master will take over from here.
+
+If you encounter an **unrecoverable error**:
+
+\`\`\`
+hive_exec_complete({
+  task: "${task}",
+  feature: "${feature}",
+  status: "failed",
+  summary: "What went wrong and what was attempted"
+})
+\`\`\`
+
+If you made **partial progress** but can't continue:
+
+\`\`\`
+hive_exec_complete({
+  task: "${task}",
+  feature: "${feature}",
+  status: "partial",
+  summary: "What was completed and what remains"
+})
+\`\`\`
+
+---
+
+## TDD Protocol (Required)
+
+1. **Red**: Write failing test first
+2. **Green**: Minimal code to pass
+3. **Refactor**: Clean up, keep tests green
+
+Never write implementation before test exists.
+Exception: Pure refactoring of existing tested code.
+
+## Debugging Protocol (When stuck)
+
+1. **Reproduce**: Get consistent failure
+2. **Isolate**: Binary search to find cause
+3. **Hypothesize**: Form theory, test it
+4. **Fix**: Minimal change that resolves
+
+After 3 failed attempts at same fix: STOP and report blocker.
+
+---
+
+## Tool Access
+
+**You have access to:**
+- 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_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_merge\` - Only Hive Master merges
+- \`background_task\` - No recursive delegation
+
+---
+
+## Guidelines
+
+1. **Work methodically** - Break down the mission into steps
+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
+
+---
+
+Begin your task now.
+`;
+}
+
+// src/agents/hive.ts
+var HIVE_AGENT_BASE = `# Hive Agent
+
+You are the Hive Master - a hybrid planner-orchestrator for structured feature development.
+
+## Your Role
+
+- **Plan** features via hive_plan_write (explicit, reviewable)
+- **Delegate** execution via hive_exec_start (workers in tmux panes)
+- **Ask questions** on behalf of blocked workers (single point of contact)
+- **Do simple work** directly if user explicitly asks
+
+## Core Workflow
+
+1. **Plan** - Create feature, write plan, get user approval
+2. **Execute** - Spawn workers for each task via hive_exec_start
+3. **Monitor** - Check progress with hive_worker_status
+4. **Handle blockers** - Workers exit with blocker info, you ask user and resume
+5. **Merge** - Integrate completed work via hive_merge
+
+## When No Feature is Active
+
+Work directly on user requests. You're a capable coding agent.
+Use hive_feature_create when the task is complex enough to benefit from structure.
+
+Signs you should create a feature:
+- Multiple files to change
+- Task requires planning
+- Work should be reviewed before merging
+- User mentions "feature", "implement", or describes multi-step work
+
+## When Feature is Active
+
+Follow Hive workflow strictly:
+1. Write plan via hive_plan_write
+2. Wait for user to review and add comments
+3. Read comments via hive_plan_read, revise if needed
+4. Get approval (explicit or via hive_plan_approve)
+5. Generate tasks via hive_tasks_sync
+6. Execute tasks via hive_exec_start (spawns workers)
+7. Monitor workers via hive_worker_status
+8. Handle any blocked workers
+9. Merge completed work via hive_merge
+
+## Blocker Handling Protocol
+
+When a worker returns status: 'blocked':
+
+1. **Read** the blocker info from hive_worker_status:
+   - reason: Why they're blocked
+   - options: Available choices
+   - recommendation: Worker's suggestion
+
+2. **Ask** the user via question():
+   \`\`\`
+   question({
+     questions: [{
+       header: "Decision Needed",
+       question: "Worker blocked: {reason}. {recommendation}",
+       options: [
+         { label: "Option A", description: "..." },
+         { label: "Option B", description: "..." }
+       ]
+     }]
+   })
+   \`\`\`
+
+3. **Resume** with the decision:
+   \`\`\`
+   hive_exec_start({
+     task: "the-task",
+     continueFrom: "blocked",
+     decision: "User chose Option A because..."
+   })
+   \`\`\`
+
+This keeps the user focused on ONE conversation (you) instead of multiple worker panes.
+
+## Iron Laws
+
+### Never
+- Plan without asking questions first (discovery required)
+- Code without failing test first
+- Complete without running verification
+- Assume when uncertain - ASK
+- Put raw data in Master context - DELEGATE
+- Attempt same fix more than 3 times
+
+### Always
+- One question at a time (discovery)
+- Test -> Code -> Verify (TDD)
+- Delegate data queries to subagents
+- Stop and ask when blocked
+
+## Communication Style
+
+- Be concise, no preamble
+- Start work immediately
+- Challenge wrong approaches professionally
+- Don't summarize unless asked
+- Use hive tools proactively when in feature context
+`;
+function buildFeatureContextSection(ctx) {
+  return `
+## Active Feature: ${ctx.name}
+
+**Plan Status:** ${ctx.planStatus}
+**Tasks:** ${ctx.tasksSummary}
+**Context Files:** ${ctx.contextList.length > 0 ? ctx.contextList.join(", ") : "none"}
+
+You are in feature context. Use Hive workflow.
+`;
+}
+var OOM_SLIM_SECTION = `
+## OMO-Slim Detected
+
+Workers spawn in tmux panes with specialized agents:
+- **explorer** - Codebase search and pattern matching
+- **librarian** - External docs and library research
+- **oracle** - Architecture decisions and guidance
+- **designer** - UI/UX implementation
+- **fixer** - Default implementation (code changes)
+
+Agent is auto-selected based on task content.
+Watch workers in tmux panes for real-time progress.
+`;
+function buildHiveAgentPrompt(featureContext, omoSlimDetected) {
+  let prompt = HIVE_AGENT_BASE;
+  if (featureContext) {
+    prompt += buildFeatureContextSection(featureContext);
   }
-  fork(featureName, fromSessionId) {
-    const data = this.getSessions(featureName);
-    const now = new Date().toISOString();
-    const sourceSession = fromSessionId ? data.sessions.find((s) => s.sessionId === fromSessionId) : data.sessions.find((s) => s.sessionId === data.master);
-    const newSessionId = `ses_fork_${Date.now()}`;
-    const newSession = {
-      sessionId: newSessionId,
-      taskFolder: sourceSession?.taskFolder,
-      startedAt: now,
-      lastActiveAt: now
-    };
-    data.sessions.push(newSession);
-    this.saveSessions(featureName, data);
-    return newSession;
-  }
-  fresh(featureName, title) {
-    const data = this.getSessions(featureName);
-    const now = new Date().toISOString();
-    const newSessionId = `ses_${title ? title.replace(/\s+/g, "_").toLowerCase() : Date.now()}`;
-    const newSession = {
-      sessionId: newSessionId,
-      startedAt: now,
-      lastActiveAt: now
-    };
-    data.sessions.push(newSession);
-    this.saveSessions(featureName, data);
-    return newSession;
+  if (omoSlimDetected) {
+    prompt += OOM_SLIM_SECTION;
   }
+  return prompt;
 }
 
 // src/index.ts
+function formatSkillsXml() {
+  const skills = getBuiltinSkills();
+  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>`;
+}
+function createHiveSkillTool() {
+  const base = "Load a Hive skill to get detailed instructions for a specific workflow.";
+  const skills = getBuiltinSkills();
+  const description = skills.length === 0 ? base + `
+
+No Hive skills available.` : base + formatSkillsXml();
+  return tool({
+    description,
+    args: {
+      name: tool.schema.string().describe("The skill name from available_skills")
+    },
+    async execute({ name }) {
+      const result = loadBuiltinSkill(name);
+      if (!result.found || !result.skill) {
+        const available = skills.map((s) => s.name).join(", ");
+        throw new Error(`Skill "${name}" not found. Available Hive skills: ${available || "none"}`);
+      }
+      const skill = result.skill;
+      return [
+        `## Hive Skill: ${skill.name}`,
+        "",
+        `**Description**: ${skill.description}`,
+        "",
+        skill.template
+      ].join(`
+`);
+    }
+  });
+}
 var HIVE_SYSTEM_PROMPT = `
 ## Hive - Feature Development System
 
 Plan-first development: Write plan → User reviews → Approve → Execute tasks
 
-### Tools (24 total)
+### Tools (19 total)
 
 | Domain | Tools |
 |--------|-------|
 | Feature | hive_feature_create, hive_feature_list, hive_feature_complete |
 | Plan | hive_plan_write, hive_plan_read, hive_plan_approve |
 | Task | hive_tasks_sync, hive_task_create, hive_task_update |
-| Subtask | hive_subtask_create, hive_subtask_update, hive_subtask_list, hive_subtask_spec_write, hive_subtask_report_write |
 | Exec | hive_exec_start, hive_exec_complete, hive_exec_abort |
+| Worker | hive_worker_status |
 | Merge | hive_merge, hive_worktree_list |
-| Context | hive_context_write, hive_context_read, hive_context_list |
-| Session | hive_session_open, hive_session_list |
+| Context | hive_context_write |
+| Status | hive_status |
+| Skill | hive_skill |
 
 ### Workflow
 
@@ -18659,37 +19261,31 @@ Plan-first development: Write plan → User reviews → Approve → Execute task
 **Important:** \`hive_exec_complete\` commits changes to task branch but does NOT merge.
 Use \`hive_merge\` to explicitly integrate changes. Worktrees persist until manually removed.
 
-### Subtasks & TDD
+### Delegated Execution (OMO-Slim Integration)
 
-For complex tasks, break work into subtasks:
-
-\`\`\`
-hive_subtask_create(task, "Write failing tests", "test")
-hive_subtask_create(task, "Implement until green", "implement")
-hive_subtask_create(task, "Run test suite", "verify")
-\`\`\`
-
-Subtask types: test, implement, review, verify, research, debug, custom
-
-**Test-Driven Development**: For implementation tasks, consider writing tests first.
-Tests define "done" and provide feedback loops that improve quality.
-
-### Plan Format
-
-\`\`\`markdown
-# Feature Name
+When OMO-Slim is installed, \`hive_exec_start\` spawns worker agents in tmux panes:
 
-## Overview
-What we're building and why.
+1. \`hive_exec_start(task)\` → Creates worktree + spawns worker via \`background_task\`
+2. Worker appears in tmux pane - watch it work in real-time
+3. Worker completes → calls \`hive_exec_complete(status: "completed")\`
+4. Worker blocked → calls \`hive_exec_complete(status: "blocked", blocker: {...})\`
 
-## Tasks
+**Handling blocked workers:**
+1. Check blockers with \`hive_worker_status()\`
+2. Read the blocker info (reason, options, recommendation)
+3. Ask user via \`question()\` tool
+4. Resume with \`hive_exec_start(task, continueFrom: "blocked", decision: answer)\`
 
-### 1. Task Name
-Description of what to do.
+**Agent auto-selection** based on task content:
+| Pattern | Agent |
+|---------|-------|
+| find, search, explore | explorer |
+| research, docs | librarian |
+| ui, component, react | designer |
+| architect, decision | oracle |
+| (default) | general |
 
-### 2. Another Task
-Description.
-\`\`\`
+Without OMO-Slim: \`hive_exec_start\` falls back to inline mode (work in same session).
 
 ### Planning Phase - Context Management REQUIRED
 
@@ -18702,22 +19298,29 @@ As you research and plan, CONTINUOUSLY save findings using \`hive_context_write\
 **Update existing context files** when new info emerges - dont create duplicates.
 Workers depend on context for background. Without it, they work blind.
 
-Save context BEFORE writing the plan, and UPDATE it as planning iterates.
-
 \`hive_tasks_sync\` parses \`### N. Task Name\` headers.
+
+### Execution Phase - Stay Aligned
+
+During execution, call \`hive_status\` periodically to:
+- Check current progress and pending work
+- See context files to read
+- Get reminded of next actions
 `;
 var plugin = async (ctx) => {
-  const { directory } = ctx;
+  const { directory, client } = ctx;
   const featureService = new FeatureService(directory);
   const planService = new PlanService(directory);
   const taskService = new TaskService(directory);
-  const subtaskService = new SubtaskService(directory);
   const contextService = new ContextService(directory);
-  const sessionService = new SessionService(directory);
+  const configService = new ConfigService;
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path6.join(directory, ".hive")
+    hiveDir: path5.join(directory, ".hive")
   });
+  const isOmoSlimEnabled = () => {
+    return configService.isOmoSlimEnabled();
+  };
   const resolveFeature = (explicit) => {
     if (explicit)
       return explicit;
@@ -18738,6 +19341,20 @@ var plugin = async (ctx) => {
       }
     }
   };
+  const checkBlocked = (feature) => {
+    const fs9 = __require("fs");
+    const blockedPath = path5.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)"}
+
+The human has blocked this feature. Wait for them to unblock it.
+To unblock: Remove .hive/features/${feature}/BLOCKED`;
+    }
+    return null;
+  };
   return {
     "experimental.chat.system.transform": async (_input, output) => {
       output.system.push(HIVE_SYSTEM_PROMPT);
@@ -18761,6 +19378,7 @@ var plugin = async (ctx) => {
       }
     },
     tool: {
+      hive_skill: createHiveSkillTool(),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
         args: {
@@ -18769,7 +19387,40 @@ var plugin = async (ctx) => {
         },
         async execute({ name, ticket }) {
           const feature = featureService.create(name, ticket);
-          return `Feature "${name}" created. Status: ${feature.status}. Write a plan with hive_plan_write.`;
+          return `Feature "${name}" created.
+
+## Discovery Phase Required
+
+Before writing a plan, you MUST:
+1. Ask clarifying questions about the feature
+2. Document Q&A in plan.md with a \`## Discovery\` section
+3. Research the codebase (grep, read existing code)
+4. Save findings with hive_context_write
+
+Example discovery section:
+\`\`\`markdown
+## Discovery
+
+**Q: What authentication system do we use?**
+A: JWT with refresh tokens, see src/auth/
+
+**Q: Should this work offline?**
+A: No, online-only is fine
+
+**Research:**
+- Found existing theme system in src/theme/
+- Uses CSS variables pattern
+\`\`\`
+
+## Planning Guidelines
+
+When writing your plan, include:
+- \`## Non-Goals\` - What we're explicitly NOT building (scope boundaries)
+- \`## Ghost Diffs\` - Alternatives you considered but rejected
+
+These prevent scope creep and re-proposing rejected solutions.
+
+NEXT: Ask your first clarifying question about this feature.`;
         }
       }),
       hive_feature_list: tool({
@@ -18799,6 +19450,34 @@ var plugin = async (ctx) => {
           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 = path5.join(directory, ".hive", "journal.md");
+          if (!fs6.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
+
+---
+`;
+          fs6.appendFileSync(journalPath, entry);
+          return `Journal entry added for ${feature}. ${constraint ? `Constraint: "${constraint}"` : ""}`;
+        }
+      }),
       hive_plan_write: tool({
         description: "Write plan.md (clears existing comments)",
         args: {
@@ -18809,6 +19488,17 @@ var plugin = async (ctx) => {
           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) {
+            return `BLOCKED: Discovery section required before planning.
+
+Your plan must include a \`## Discovery\` section documenting:
+- Questions you asked and answers received
+- Research findings from codebase exploration
+- Key decisions made
+
+Add this section to your plan content and try again.`;
+          }
           captureSession(feature, toolContext);
           const planPath = planService.write(feature, content);
           return `Plan written to ${planPath}. Comments cleared for fresh review.`;
@@ -18880,7 +19570,8 @@ var plugin = async (ctx) => {
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
           const folder = taskService.create(feature, name, order);
-          return `Manual task created: ${folder}`;
+          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.`;
         }
       }),
       hive_task_update: tool({
@@ -18903,21 +19594,36 @@ var plugin = async (ctx) => {
         }
       }),
       hive_exec_start: tool({
-        description: "Create worktree and begin work on task",
+        description: "Create worktree and begin work on task. When OMO-Slim is installed, spawns worker agent in tmux pane.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
+          feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)"),
+          continueFrom: tool.schema.enum(["blocked"]).optional().describe("Resume a blocked task"),
+          decision: tool.schema.string().optional().describe("Answer to blocker question when continuing")
         },
-        async execute({ task, feature: explicitFeature }) {
+        async execute({ task, feature: explicitFeature, continueFrom, decision }, toolContext) {
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
+          const blocked = checkBlocked(feature);
+          if (blocked)
+            return blocked;
           const taskInfo = taskService.get(feature, task);
           if (!taskInfo)
             return `Error: Task "${task}" not found`;
           if (taskInfo.status === "done")
             return "Error: Task already completed";
-          const worktree = await worktreeService.create(feature, task);
+          if (continueFrom === "blocked" && taskInfo.status !== "blocked") {
+            return "Error: Task is not in blocked state. Use without continueFrom.";
+          }
+          let worktree;
+          if (continueFrom === "blocked") {
+            worktree = await worktreeService.get(feature, task);
+            if (!worktree)
+              return "Error: No worktree found for blocked task";
+          } else {
+            worktree = await worktreeService.create(feature, task);
+          }
           taskService.update(feature, task, {
             status: "in_progress",
             baseCommit: worktree.commit
@@ -18933,7 +19639,7 @@ var plugin = async (ctx) => {
 
 `;
           if (planResult) {
-            const taskMatch = planResult.content.match(new RegExp(`###\\s*\\d+\\.\\s*${taskInfo.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?(?=###|$)`, "i"));
+            const taskMatch = planResult.content.match(new RegExp(`###\\s*\\d+\\.\\s*${taskInfo.name.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")}[\\s\\S]*?(?=###|$)`, "i"));
             if (taskMatch) {
               specContent += `## Plan Section
 
@@ -18958,36 +19664,140 @@ ${priorTasks.join(`
 `;
           }
           taskService.writeSpec(feature, task, specContent);
+          if (isOmoSlimEnabled()) {
+            const contextFiles = [];
+            const contextDir = path5.join(directory, ".hive", "features", feature, "context");
+            if (fs6.existsSync(contextDir)) {
+              const files = fs6.readdirSync(contextDir).filter((f) => f.endsWith(".md"));
+              for (const file2 of files) {
+                const content = fs6.readFileSync(path5.join(contextDir, file2), "utf-8");
+                contextFiles.push({ name: file2, content });
+              }
+            }
+            const previousTasks = allTasks.filter((t) => t.status === "done" && t.summary).map((t) => ({ name: t.folder, summary: t.summary }));
+            const workerPrompt = buildWorkerPrompt({
+              feature,
+              task,
+              taskOrder: parseInt(taskInfo.folder.match(/^(\d+)/)?.[1] || "0", 10),
+              worktreePath: worktree.path,
+              branch: worktree.branch,
+              plan: planResult?.content || "No plan available",
+              contextFiles,
+              spec: specContent,
+              previousTasks,
+              continueFrom: continueFrom === "blocked" ? {
+                status: "blocked",
+                previousSummary: taskInfo.summary || "No previous summary",
+                decision: decision || "No decision provided"
+              } : undefined
+            });
+            const agent = selectAgent(taskInfo.name, specContent);
+            return JSON.stringify({
+              worktreePath: worktree.path,
+              branch: worktree.branch,
+              mode: "delegate",
+              agent,
+              delegationRequired: true,
+              backgroundTaskCall: {
+                agent,
+                prompt: workerPrompt,
+                description: `Hive: ${task}`,
+                sync: false
+              },
+              instructions: `## Delegation Required
+
+You MUST now call background_task to spawn a worker:
+
+\`\`\`
+background_task({
+  agent: "${agent}",
+  prompt: <the workerPrompt below>,
+  description: "Hive: ${task}",
+  sync: false
+})
+\`\`\`
+
+After spawning:
+- Monitor with hive_worker_status
+- Handle blockers when worker exits
+- Merge completed work with hive_merge
+
+DO NOT do the work yourself. Delegate it.`,
+              workerPrompt
+            }, null, 2);
+          }
           return `Worktree created at ${worktree.path}
 Branch: ${worktree.branch}
 Base commit: ${worktree.commit}
-Spec: ${task}/spec.md generated`;
+Spec: ${task}/spec.md generated
+Reminder: do all work inside this worktree and ensure any subagents do the same.`;
         }
       }),
       hive_exec_complete: tool({
-        description: "Complete task: commit changes to branch, write report (does NOT merge or cleanup)",
+        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"),
           summary: tool.schema.string().describe("Summary of what was done"),
+          status: tool.schema.enum(["completed", "blocked", "failed", "partial"]).optional().default("completed").describe("Task completion status"),
+          blocker: tool.schema.object({
+            reason: tool.schema.string().describe("Why the task is blocked"),
+            options: tool.schema.array(tool.schema.string()).optional().describe("Available options for the user"),
+            recommendation: tool.schema.string().optional().describe("Your recommended choice"),
+            context: tool.schema.string().optional().describe("Additional context for the decision")
+          }).optional().describe("Blocker info when status is blocked"),
           feature: tool.schema.string().optional().describe("Feature name (defaults to detection or single feature)")
         },
-        async execute({ task, summary, feature: explicitFeature }) {
+        async execute({ task, summary, status = "completed", blocker, feature: explicitFeature }) {
           const feature = resolveFeature(explicitFeature);
           if (!feature)
             return "Error: No feature specified. Create a feature or provide feature param.";
           const taskInfo = taskService.get(feature, task);
           if (!taskInfo)
             return `Error: Task "${task}" not found`;
-          if (taskInfo.status !== "in_progress")
+          if (taskInfo.status !== "in_progress" && taskInfo.status !== "blocked")
             return "Error: Task not in progress";
+          if (status === "completed") {
+            const verificationKeywords = ["test", "build", "lint", "vitest", "jest", "npm run", "pnpm", "cargo", "pytest", "verified", "passes", "succeeds"];
+            const summaryLower = summary.toLowerCase();
+            const hasVerificationMention = verificationKeywords.some((kw) => summaryLower.includes(kw));
+            if (!hasVerificationMention) {
+              return `BLOCKED: No verification detected in summary.
+
+Before claiming completion, you must:
+1. Run tests (vitest, jest, pytest, etc.)
+2. Run build (npm run build, cargo build, etc.)
+3. Include verification results in summary
+
+Example summary: "Implemented auth flow. Tests pass (vitest). Build succeeds."
+
+Re-run with updated summary showing verification results.`;
+            }
+          }
+          if (status === "blocked") {
+            taskService.update(feature, task, {
+              status: "blocked",
+              summary,
+              blocker
+            });
+            const worktree2 = await worktreeService.get(feature, task);
+            return JSON.stringify({
+              status: "blocked",
+              task,
+              summary,
+              blocker,
+              worktreePath: worktree2?.path,
+              message: 'Task blocked. Hive Master will ask user and resume with hive_exec_start(continueFrom: "blocked", decision: answer)'
+            }, null, 2);
+          }
           const commitResult = await worktreeService.commitChanges(feature, task, `hive(${task}): ${summary.slice(0, 50)}`);
           const diff = await worktreeService.getDiff(feature, task);
+          const statusLabel = status === "completed" ? "success" : status;
           const reportLines = [
             `# Task Report: ${task}`,
             "",
             `**Feature:** ${feature}`,
             `**Completed:** ${new Date().toISOString()}`,
-            `**Status:** success`,
+            `**Status:** ${statusLabel}`,
             `**Commit:** ${commitResult.sha || "none"}`,
             "",
             "---",
@@ -19011,9 +19821,10 @@ Spec: ${task}/spec.md generated`;
           }
           taskService.writeReport(feature, task, reportLines.join(`
 `));
-          taskService.update(feature, task, { status: "done", summary });
+          const finalStatus = status === "completed" ? "done" : status;
+          taskService.update(feature, task, { status: finalStatus, summary });
           const worktree = await worktreeService.get(feature, task);
-          return `Task "${task}" completed. Changes committed to branch ${worktree?.branch || "unknown"}.
+          return `Task "${task}" ${status}. Changes committed to branch ${worktree?.branch || "unknown"}.
 Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "unknown"}.`;
         }
       }),
@@ -19032,6 +19843,51 @@ 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 now = Date.now();
+          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 taskData = t;
+            const startedAt = taskData.startedAt ? new Date(taskData.startedAt).getTime() : now;
+            const maybeStuck = now - startedAt > STUCK_THRESHOLD && t.status === "in_progress";
+            return {
+              task: t.folder,
+              name: t.name,
+              status: t.status,
+              agent: taskData.agent || "inline",
+              mode: taskData.mode || "inline",
+              workerId: taskData.workerId || null,
+              worktreePath: worktree?.path || null,
+              branch: worktree?.branch || null,
+              maybeStuck,
+              blocker: taskData.blocker || null,
+              summary: t.summary || null
+            };
+          }));
+          const omoSlimEnabled = isOmoSlimEnabled();
+          return JSON.stringify({
+            feature,
+            omoSlimEnabled,
+            workers,
+            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. Check tmux panes or abort with hive_exec_abort." : "Workers in progress. Watch tmux panes for live updates."
+          }, null, 2);
+        }
+      }),
       hive_merge: tool({
         description: "Merge completed task branch into current branch (explicit integration)",
         args: {
@@ -19100,218 +19956,166 @@ Files changed: ${result.filesChanged?.length || 0}`;
           return `Context file written: ${filePath}`;
         }
       }),
-      hive_context_read: tool({
-        description: "Read a specific context file or all context for the feature",
-        args: {
-          name: tool.schema.string().optional().describe("Context file name. If omitted, returns all context compiled."),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ name, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          if (name) {
-            const content = contextService.read(feature, name);
-            if (!content)
-              return `Error: Context file '${name}' not found`;
-            return content;
-          }
-          const compiled = contextService.compile(feature);
-          if (!compiled)
-            return "No context files found";
-          return compiled;
-        }
-      }),
-      hive_context_list: tool({
-        description: "List all context files for the feature",
+      hive_status: tool({
+        description: "Get comprehensive status of a feature including plan, tasks, and context. Returns JSON with all relevant state for resuming work.",
         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 files = contextService.list(feature);
-          if (files.length === 0)
-            return "No context files";
-          return files.map((f) => `${f.name} (${f.content.length} chars, updated ${f.updatedAt})`).join(`
-`);
-        }
-      }),
-      hive_session_open: tool({
-        description: "Open session, return full context for a feature",
-        args: {
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)"),
-          task: tool.schema.string().optional().describe("Task folder to focus on")
-        },
-        async execute({ feature: explicitFeature, task }, toolContext) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
+          if (!feature) {
+            return JSON.stringify({
+              error: "No feature specified and no active feature found",
+              hint: "Use hive_feature_create to create a new feature"
+            });
+          }
           const featureData = featureService.get(feature);
-          if (!featureData)
-            return `Error: Feature '${feature}' not found`;
-          const ctx2 = toolContext;
-          if (ctx2?.sessionID) {
-            sessionService.track(feature, ctx2.sessionID, task);
+          if (!featureData) {
+            return JSON.stringify({
+              error: `Feature '${feature}' not found`,
+              availableFeatures: featureService.list()
+            });
           }
-          const planResult = planService.read(feature);
+          const blocked = checkBlocked(feature);
+          if (blocked)
+            return blocked;
+          const plan = planService.read(feature);
           const tasks = taskService.list(feature);
-          const contextCompiled = contextService.compile(feature);
-          const sessions = sessionService.list(feature);
-          let output = `## Feature: ${feature} [${featureData.status}]
-
-`;
-          if (planResult) {
-            output += `### Plan
-${planResult.content.substring(0, 500)}...
-
-`;
-          }
-          output += `### Tasks (${tasks.length})
-`;
-          tasks.forEach((t) => {
-            output += `- ${t.folder}: ${t.name} [${t.status}]
-`;
-          });
-          if (contextCompiled) {
-            output += `
-### Context
-${contextCompiled.substring(0, 500)}...
-`;
-          }
-          output += `
-### Sessions (${sessions.length})
-`;
-          sessions.forEach((s) => {
-            output += `- ${s.sessionId} (${s.taskFolder || "no task"})
-`;
+          const contextFiles = contextService.list(feature);
+          const tasksSummary = tasks.map((t) => ({
+            folder: t.folder,
+            name: t.name,
+            status: t.status,
+            origin: t.origin || "plan"
+          }));
+          const contextSummary = contextFiles.map((c) => ({
+            name: c.name,
+            chars: c.content.length,
+            updatedAt: c.updatedAt
+          }));
+          const pendingTasks = tasksSummary.filter((t) => t.status === "pending");
+          const inProgressTasks = tasksSummary.filter((t) => t.status === "in_progress");
+          const doneTasks = tasksSummary.filter((t) => t.status === "done");
+          const getNextAction = (planStatus2, tasks2) => {
+            if (!planStatus2 || planStatus2 === "draft") {
+              return "Write or revise plan with hive_plan_write, then get approval";
+            }
+            if (planStatus2 === "review") {
+              return "Wait for plan approval or revise based on comments";
+            }
+            if (tasks2.length === 0) {
+              return "Generate tasks from plan with hive_tasks_sync";
+            }
+            const inProgress = tasks2.find((t) => t.status === "in_progress");
+            if (inProgress) {
+              return `Continue work on task: ${inProgress.folder}`;
+            }
+            const pending = tasks2.find((t) => t.status === "pending");
+            if (pending) {
+              return `Start next task with hive_exec_start: ${pending.folder}`;
+            }
+            return "All tasks complete. Review and merge or complete feature.";
+          };
+          const planStatus = featureData.status === "planning" ? "draft" : featureData.status === "approved" ? "approved" : featureData.status === "executing" ? "locked" : "none";
+          return JSON.stringify({
+            feature: {
+              name: feature,
+              status: featureData.status,
+              ticket: featureData.ticket || null,
+              createdAt: featureData.createdAt
+            },
+            plan: {
+              exists: !!plan,
+              status: planStatus,
+              approved: planStatus === "approved" || planStatus === "locked"
+            },
+            tasks: {
+              total: tasks.length,
+              pending: pendingTasks.length,
+              inProgress: inProgressTasks.length,
+              done: doneTasks.length,
+              list: tasksSummary
+            },
+            context: {
+              fileCount: contextFiles.length,
+              files: contextSummary
+            },
+            nextAction: getNextAction(planStatus, tasksSummary)
           });
-          return output;
-        }
-      }),
-      hive_session_list: tool({
-        description: "List all sessions for the 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 sessions = sessionService.list(feature);
-          const master = sessionService.getMaster(feature);
-          if (sessions.length === 0)
-            return "No sessions";
-          return sessions.map((s) => {
-            const masterMark = s.sessionId === master ? " (master)" : "";
-            return `${s.sessionId}${masterMark} - ${s.taskFolder || "no task"} - ${s.lastActiveAt}`;
-          }).join(`
-`);
-        }
-      }),
-      hive_subtask_create: tool({
-        description: "Create a subtask within a task. Use for TDD: create test/implement/verify subtasks.",
-        args: {
-          task: tool.schema.string().describe("Task folder name"),
-          name: tool.schema.string().describe("Subtask description"),
-          type: tool.schema.enum(["test", "implement", "review", "verify", "research", "debug", "custom"]).optional().describe("Subtask type"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task, name, type, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          try {
-            const subtask = subtaskService.create(feature, task, name, type);
-            return `Subtask created: ${subtask.id} - ${subtask.name} [${subtask.type || "custom"}]`;
-          } catch (e) {
-            return `Error: ${e.message}`;
-          }
         }
       }),
-      hive_subtask_update: tool({
-        description: "Update subtask status",
+      hive_request_review: tool({
+        description: "Request human review of completed task. BLOCKS until human approves or requests changes. Call after completing work, before merging.",
         args: {
           task: tool.schema.string().describe("Task folder name"),
-          subtask: tool.schema.string().describe('Subtask ID (e.g., "1.1")'),
-          status: tool.schema.enum(["pending", "in_progress", "done", "cancelled"]).describe("New status"),
+          summary: tool.schema.string().describe("Summary of what you did for human to review"),
           feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
         },
-        async execute({ task, subtask, status, feature: explicitFeature }) {
+        async execute({ task, summary, feature: explicitFeature }) {
           const feature = resolveFeature(explicitFeature);
           if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          try {
-            const updated = subtaskService.update(feature, task, subtask, status);
-            return `Subtask ${updated.id} updated: ${updated.status}`;
-          } catch (e) {
-            return `Error: ${e.message}`;
+            return "Error: No feature specified.";
+          const taskDir = path5.join(directory, ".hive", "features", feature, "tasks", task);
+          if (!fs6.existsSync(taskDir)) {
+            return `Error: Task '${task}' not found in feature '${feature}'`;
           }
-        }
-      }),
-      hive_subtask_list: tool({
-        description: "List all subtasks for a task",
-        args: {
-          task: tool.schema.string().describe("Task folder name"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          try {
-            const subtasks = subtaskService.list(feature, task);
-            if (subtasks.length === 0)
-              return "No subtasks for this task.";
-            return subtasks.map((s) => {
-              const typeTag = s.type ? ` [${s.type}]` : "";
-              const statusIcon = s.status === "done" ? "✓" : s.status === "in_progress" ? "→" : "○";
-              return `${statusIcon} ${s.id}: ${s.name}${typeTag}`;
-            }).join(`
-`);
-          } catch (e) {
-            return `Error: ${e.message}`;
+          const reportPath = path5.join(taskDir, "report.md");
+          const existingReport = fs6.existsSync(reportPath) ? fs6.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}
+
+`;
+          fs6.writeFileSync(reportPath, newContent);
+          const pendingPath = path5.join(taskDir, "PENDING_REVIEW");
+          fs6.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 (fs6.existsSync(pendingPath)) {
+            if (Date.now() - startTime > maxWait) {
+              return "Review timed out after 30 minutes. Human did not respond.";
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
           }
-        }
-      }),
-      hive_subtask_spec_write: tool({
-        description: "Write spec.md for a subtask (detailed instructions)",
-        args: {
-          task: tool.schema.string().describe("Task folder name"),
-          subtask: tool.schema.string().describe('Subtask ID (e.g., "1.1")'),
-          content: tool.schema.string().describe("Spec content (markdown)"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task, subtask, content, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          try {
-            const specPath = subtaskService.writeSpec(feature, task, subtask, content);
-            return `Subtask spec written: ${specPath}`;
-          } catch (e) {
-            return `Error: ${e.message}`;
+          const resultPath = path5.join(taskDir, "REVIEW_RESULT");
+          if (!fs6.existsSync(resultPath)) {
+            return "Review cancelled (PENDING_REVIEW removed but no REVIEW_RESULT).";
           }
-        }
-      }),
-      hive_subtask_report_write: tool({
-        description: "Write report.md for a subtask (what was done)",
-        args: {
-          task: tool.schema.string().describe("Task folder name"),
-          subtask: tool.schema.string().describe('Subtask ID (e.g., "1.1")'),
-          content: tool.schema.string().describe("Report content (markdown)"),
-          feature: tool.schema.string().optional().describe("Feature name (defaults to active)")
-        },
-        async execute({ task, subtask, content, feature: explicitFeature }) {
-          const feature = resolveFeature(explicitFeature);
-          if (!feature)
-            return "Error: No feature specified. Create a feature or provide feature param.";
-          try {
-            const reportPath = subtaskService.writeReport(feature, task, subtask, content);
-            return `Subtask report written: ${reportPath}`;
-          } catch (e) {
-            return `Error: ${e.message}`;
+          const result = fs6.readFileSync(resultPath, "utf-8").trim();
+          fs6.appendFileSync(reportPath, `### Review Result
+
+${result}
+
+---
+
+`);
+          if (result.toUpperCase() === "APPROVED") {
+            return `✅ APPROVED
+
+Your work has been approved. You may now merge:
+
+  hive_merge(task="${task}")
+
+After merging, proceed to the next task.`;
+          } else {
+            return `\uD83D\uDD04 Changes Requested
+
+${result}
+
+Make the requested changes, then call hive_request_review again.`;
           }
         }
       })
@@ -19326,6 +20130,62 @@ ${contextCompiled.substring(0, 500)}...
           return `Create feature "${name}" using hive_feature_create tool.`;
         }
       }
+    },
+    agent: {
+      hive: {
+        model: undefined,
+        temperature: 0.7,
+        description: "Hive Master - plan-first development with structured workflow and worker delegation",
+        prompt: buildHiveAgentPrompt(undefined, false)
+      }
+    },
+    systemPrompt: (existingPrompt) => {
+      if (!existingPrompt.includes("Hive Master")) {
+        return existingPrompt;
+      }
+      const featureNames = listFeatures(directory);
+      let featureContext;
+      for (const featureName of featureNames) {
+        const feature = featureService.get(featureName);
+        if (feature && ["planning", "executing"].includes(feature.status)) {
+          const tasks = taskService.list(featureName);
+          const pendingCount = tasks.filter((t) => t.status === "pending").length;
+          const inProgressCount = tasks.filter((t) => t.status === "in_progress").length;
+          const doneCount = tasks.filter((t) => t.status === "done").length;
+          const contextDir = path5.join(directory, ".hive", "features", featureName, "context");
+          const contextList = fs6.existsSync(contextDir) ? fs6.readdirSync(contextDir).filter((f) => f.endsWith(".md")) : [];
+          const planResult = planService.read(featureName);
+          let planStatus = "none";
+          if (planResult) {
+            planStatus = planResult.status === "approved" || planResult.status === "executing" ? "approved" : "draft";
+          }
+          featureContext = {
+            name: featureName,
+            planStatus,
+            tasksSummary: `${doneCount} done, ${inProgressCount} in progress, ${pendingCount} pending`,
+            contextList
+          };
+          break;
+        }
+      }
+      if (featureContext || isOmoSlimEnabled()) {
+        return buildHiveAgentPrompt(featureContext, isOmoSlimEnabled());
+      }
+      return existingPrompt;
+    },
+    config: async (opencodeConfig) => {
+      const hiveAgentConfig = {
+        model: undefined,
+        temperature: 0.7,
+        description: "Hive Master - plan-first development with structured workflow and worker delegation",
+        prompt: buildHiveAgentPrompt(undefined, false)
+      };
+      const configAgent = opencodeConfig.agent;
+      if (!configAgent) {
+        opencodeConfig.agent = { hive: hiveAgentConfig };
+      } else {
+        configAgent.hive = hiveAgentConfig;
+      }
     }
   };
 };