opencode-hive 0.8.2 → 0.8.3

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,12 @@ 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";
+import { fileURLToPath } from "url";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -12333,7 +12337,7 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // ../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 +12345,14 @@ 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";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -12368,7 +12370,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 +12819,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 +12916,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 +13096,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) {
@@ -13183,6 +13185,7 @@ var COMMENTS_FILE = "comments.json";
 var FEATURE_FILE = "feature.json";
 var STATUS_FILE = "status.json";
 var REPORT_FILE = "report.md";
+var APPROVED_FILE = "APPROVED";
 function getHivePath(projectRoot) {
   return path.join(projectRoot, HIVE_DIR);
 }
@@ -13219,6 +13222,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) {
@@ -13343,6 +13349,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 +13438,7 @@ class PlanService {
     const planPath = getPlanPath(this.projectRoot, featureName);
     writeText(planPath, content);
     this.clearComments(featureName);
+    this.revokeApproval(featureName);
     return planPath;
   }
   read(featureName) {
@@ -13429,25 +13446,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 +13666,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 +13811,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 +13871,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,170 +13882,6 @@ _Add detailed instructions here_
     return name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
   }
 }
-
-class SubtaskService {
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-  }
-  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);
@@ -18028,7 +17901,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 +17913,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 +17942,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 +17962,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 +18012,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 +18022,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 +18044,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 +18069,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 +18094,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 +18109,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 +18133,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 +18163,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 +18182,7 @@ class WorktreeService {
   }
   async checkConflictsFromSavedDiff(diffPath, reverse = false) {
     try {
-      await fs6.access(diffPath);
+      await fs7.access(diffPath);
     } catch {
       return [];
     }
@@ -18332,7 +18205,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 +18345,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 +18361,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;
@@ -18512,139 +18385,457 @@ ${f.content}`);
   }
 }
 
-class SessionService {
-  projectRoot;
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-  }
-  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
-      };
-      data.sessions.push(session);
-    }
-    if (!data.master) {
-      data.master = sessionId;
-    }
-    this.saveSessions(featureName, data);
-    return session;
-  }
-  setMaster(featureName, sessionId) {
-    const data = this.getSessions(featureName);
-    data.master = sessionId;
-    this.saveSessions(featureName, data);
+// src/utils/agent-selector.ts
+var AGENT_PATTERNS = [
+  { pattern: /\b(find|search|locate|where|grep|explore|scan)\b/i, agent: "explore" },
+  { pattern: /\b(research|investigate|learn|understand|docs?|documentation|library|api)\b/i, agent: "librarian" },
+  { pattern: /\b(ui|ux|component|frontend|react|vue|svelte|css|style|layout|design|button|form|modal)\b/i, agent: "frontend-ui-ux-engineer" },
+  { pattern: /\b(refactor|simplify|clean|reduce|complexity|review|optimize)\b/i, agent: "code-simplicity-reviewer" },
+  { pattern: /\b(readme|document|explain|write.*doc|comment|jsdoc|tsdoc)\b/i, agent: "document-writer" },
+  { pattern: /\b(image|screenshot|visual|diagram|mockup|pdf|picture|photo)\b/i, agent: "multimodal-looker" },
+  { pattern: /\b(architect|design.*decision|tradeoff|approach|strategy|choose|decide|compare)\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 "general";
+}
+
+// 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}",
+  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"
+  }
+})
+\`\`\`
+
+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}",
+  status: "completed",
+  summary: "Concise summary of what you accomplished"
+})
+\`\`\`
+
+If you encounter an **unrecoverable error**:
+
+\`\`\`
+hive_exec_complete({
+  task: "${task}",
+  status: "failed",
+  summary: "What went wrong and what was attempted"
+})
+\`\`\`
+
+If you made **partial progress** but can't continue:
+
+\`\`\`
+hive_exec_complete({
+  task: "${task}",
+  status: "partial",
+  summary: "What was completed and what remains"
+})
+\`\`\`
+
+---
+
+## 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.
+
+## 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
+- **general** - Default implementation
+
+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);
   }
-  getMaster(featureName) {
-    return this.getSessions(featureName).master;
+  if (omoSlimDetected) {
+    prompt += OOM_SLIM_SECTION;
   }
-  list(featureName) {
-    return this.getSessions(featureName).sessions;
+  return prompt;
+}
+
+// src/index.ts
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) {
+    return { meta: {}, body: content.trim() };
+  }
+  const meta = {};
+  const frontmatter = match[1];
+  const body = match[2];
+  for (const line of frontmatter.split(`
+`)) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx > 0) {
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      meta[key] = value;
+    }
   }
-  get(featureName, sessionId) {
-    return this.getSessions(featureName).sessions.find((s) => s.sessionId === sessionId);
+  return { meta, body: body.trim() };
+}
+function getSkillsDir() {
+  const filename = fileURLToPath(import.meta.url);
+  const dirname5 = path5.dirname(filename);
+  return path5.join(dirname5, "..", "skills");
+}
+function discoverHiveSkills() {
+  const skillsDir = getSkillsDir();
+  const skills = [];
+  if (!fs6.existsSync(skillsDir)) {
+    return skills;
   }
-  getByTask(featureName, taskFolder) {
-    return this.getSessions(featureName).sessions.find((s) => s.taskFolder === taskFolder);
+  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const skillPath = path5.join(skillsDir, entry.name, "SKILL.md");
+    if (!fs6.existsSync(skillPath))
+      continue;
+    try {
+      const content = fs6.readFileSync(skillPath, "utf-8");
+      const { meta, body } = parseFrontmatter(content);
+      skills.push({
+        name: meta.name || entry.name,
+        description: meta.description || "",
+        path: skillPath,
+        body
+      });
+    } catch {}
   }
-  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;
+  return skills;
+}
+function formatSkillsXml(skills) {
+  if (skills.length === 0)
+    return "";
+  const skillsXml = skills.map((skill) => {
+    return [
+      "  <skill>",
+      `    <name>${skill.name}</name>`,
+      `    <description>(hive - Skill) ${skill.description}</description>`,
+      "  </skill>"
+    ].join(`
+`);
+  }).join(`
+`);
+  return `
+
+<available_skills>
+${skillsXml}
+</available_skills>`;
+}
+function createHiveSkillTool() {
+  let cachedSkills = null;
+  let cachedDescription = null;
+  const getSkills = () => {
+    if (cachedSkills)
+      return cachedSkills;
+    cachedSkills = discoverHiveSkills();
+    return cachedSkills;
+  };
+  const getDescription = () => {
+    if (cachedDescription)
+      return cachedDescription;
+    const skills = getSkills();
+    const base = "Load a Hive skill to get detailed instructions for a specific workflow.";
+    if (skills.length === 0) {
+      cachedDescription = base + `
+
+No Hive skills available.`;
+    } else {
+      cachedDescription = base + formatSkillsXml(skills);
     }
-    this.saveSessions(featureName, data);
-    return true;
-  }
-  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 cachedDescription;
+  };
+  getDescription();
+  return tool({
+    get description() {
+      return cachedDescription ?? "Load a Hive skill to get detailed instructions for a specific workflow.";
+    },
+    args: {
+      name: tool.schema.string().describe("The skill name from available_skills")
+    },
+    async execute({ name }) {
+      const skills = getSkills();
+      const skill = skills.find((s) => s.name === name);
+      if (!skill) {
+        const available = skills.map((s) => s.name).join(", ");
+        throw new Error(`Skill "${name}" not found. Available Hive skills: ${available || "none"}`);
+      }
+      return [
+        `## Hive Skill: ${skill.name}`,
+        "",
+        `**Description**: ${skill.description}`,
+        "",
+        skill.body
+      ].join(`
+`);
     }
-    return null;
-  }
-  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;
-  }
+  });
 }
-
-// src/index.ts
 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 +18850,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
-
-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
+### Delegated Execution (OMO-Slim Integration)
 
-**Test-Driven Development**: For implementation tasks, consider writing tests first.
-Tests define "done" and provide feedback loops that improve quality.
+When OMO-Slim is installed, \`hive_exec_start\` spawns worker agents in tmux panes:
 
-### Plan Format
+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: {...})\`
 
-\`\`\`markdown
-# Feature Name
+**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)\`
 
-## Overview
-What we're building and why.
+**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 |
 
-## Tasks
-
-### 1. Task Name
-Description of what to do.
-
-### 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 +18887,40 @@ 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 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 worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path6.join(directory, ".hive")
+    hiveDir: path5.join(directory, ".hive")
   });
+  let omoSlimDetected = false;
+  let detectionDone = false;
+  const detectOmoSlim = (toolContext) => {
+    if (detectionDone)
+      return omoSlimDetected;
+    const ctx2 = toolContext;
+    if (ctx2?.tools?.includes?.("background_task") || ctx2?.background_task || typeof ctx2?.callTool === "function") {
+      omoSlimDetected = true;
+    }
+    detectionDone = true;
+    if (omoSlimDetected) {
+      console.log("[Hive] OMO-Slim detected: delegated execution with tmux panes enabled");
+    }
+    return omoSlimDetected;
+  };
   const resolveFeature = (explicit) => {
     if (explicit)
       return explicit;
@@ -18738,6 +18941,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 +18978,7 @@ var plugin = async (ctx) => {
       }
     },
     tool: {
+      hive_skill: createHiveSkillTool(),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",
         args: {
@@ -18880,7 +19098,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 +19122,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 +19167,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 +19192,118 @@ ${priorTasks.join(`
 `;
           }
           taskService.writeSpec(feature, task, specContent);
+          detectOmoSlim(toolContext);
+          if (omoSlimDetected) {
+            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);
+            try {
+              const ctx2 = toolContext;
+              if (ctx2.callTool) {
+                const result = await ctx2.callTool("background_task", {
+                  agent,
+                  prompt: workerPrompt,
+                  description: `Hive: ${task}`,
+                  sync: false
+                });
+                taskService.update(feature, task, {
+                  status: "in_progress",
+                  workerId: result?.task_id,
+                  agent,
+                  mode: "omo-slim"
+                });
+                return JSON.stringify({
+                  worktreePath: worktree.path,
+                  branch: worktree.branch,
+                  mode: "delegated",
+                  agent,
+                  taskId: result?.task_id,
+                  message: `Worker spawned via OMO-Slim (${agent} agent). Watch in tmux pane. Use hive_worker_status to check progress.`
+                }, null, 2);
+              }
+            } catch (e) {
+              console.log("[Hive] OMO-Slim delegation failed, falling back to inline:", e.message);
+            }
+          }
           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 === "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 +19327,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 +19349,50 @@ 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
+            };
+          }));
+          return JSON.stringify({
+            feature,
+            omoSlimDetected,
+            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 +19461,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.",
+      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"),
-          name: tool.schema.string().describe("Subtask description"),
-          type: tool.schema.enum(["test", "implement", "review", "verify", "research", "debug", "custom"]).optional().describe("Subtask type"),
+          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, 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",
-        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"),
-          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 +19635,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 || omoSlimDetected) {
+        return buildHiveAgentPrompt(featureContext, omoSlimDetected);
+      }
+      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;
+      }
     }
   };
 };