opencode-hive 0.8.3 → 0.9.0

package/dist/index.js

@@ -14,7 +14,6 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/index.ts
 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 = {};
@@ -12336,6 +12335,337 @@ 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 as createRequire2 } from "node:module";
 import * as path from "path";
@@ -12353,6 +12683,8 @@ import { normalize } from "node:path";
 import { EventEmitter } from "node:events";
 import * as fs8 from "fs";
 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;
@@ -13176,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";
@@ -13186,9 +13529,13 @@ 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);
 }
@@ -13318,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) {
@@ -13331,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",
@@ -18384,16 +18751,83 @@ ${f.content}`);
     return `${normalized}.md`;
   }
 }
+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");
+  }
+  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
+        }
+      };
+    } catch {
+      return { ...DEFAULT_HIVE_CONFIG };
+    }
+  }
+  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;
+  }
+  exists() {
+    return fs10.existsSync(this.configPath);
+  }
+  init() {
+    if (!this.exists()) {
+      return this.set(DEFAULT_HIVE_CONFIG);
+    }
+    return this.get();
+  }
+  isOmoSlimEnabled() {
+    return this.get().omoSlim?.enabled ?? false;
+  }
+  setOmoSlim(enabled) {
+    return this.set({ omoSlim: { enabled } });
+  }
+}
 
 // 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" }
+  { 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();
@@ -18402,7 +18836,7 @@ function selectAgent(taskName, spec) {
       return agent;
     }
   }
-  return "general";
+  return "fixer";
 }
 
 // src/utils/worker-prompt.ts
@@ -18493,6 +18927,7 @@ Instead, escalate via the blocker protocol:
 \`\`\`
 hive_exec_complete({
   task: "${task}",
+  feature: "${feature}",
   status: "blocked",
   summary: "What you accomplished so far",
   blocker: {
@@ -18504,6 +18939,8 @@ hive_exec_complete({
 })
 \`\`\`
 
+**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()
@@ -18520,16 +18957,22 @@ 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"
 })
@@ -18540,6 +18983,7 @@ 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"
 })
@@ -18547,6 +18991,26 @@ hive_exec_complete({
 
 ---
 
+## 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:**
@@ -18656,6 +19120,22 @@ When a worker returns status: 'blocked':
 
 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
@@ -18683,7 +19163,7 @@ Workers spawn in tmux panes with specialized agents:
 - **librarian** - External docs and library research
 - **oracle** - Architecture decisions and guidance
 - **designer** - UI/UX implementation
-- **general** - Default implementation
+- **fixer** - Default implementation (code changes)
 
 Agent is auto-selected based on task content.
 Watch workers in tmux panes for real-time progress.
@@ -18700,57 +19180,8 @@ function buildHiveAgentPrompt(featureContext, omoSlimDetected) {
 }
 
 // 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;
-    }
-  }
-  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;
-  }
-  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 {}
-  }
-  return skills;
-}
-function formatSkillsXml(skills) {
+function formatSkillsXml() {
+  const skills = getBuiltinSkills();
   if (skills.length === 0)
     return "";
   const skillsXml = skills.map((skill) => {
@@ -18770,49 +19201,29 @@ ${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);
-    }
-    return cachedDescription;
-  };
-  getDescription();
+  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({
-    get description() {
-      return cachedDescription ?? "Load a Hive skill to get detailed instructions for a specific workflow.";
-    },
+    description,
     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 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.body
+        skill.template
       ].join(`
 `);
     }
@@ -18897,29 +19308,18 @@ During execution, call \`hive_status\` periodically to:
 - 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 contextService = new ContextService(directory);
+  const configService = new ConfigService;
   const worktreeService = new WorktreeService({
     baseDir: directory,
     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 isOmoSlimEnabled = () => {
+    return configService.isOmoSlimEnabled();
   };
   const resolveFeature = (explicit) => {
     if (explicit)
@@ -18987,7 +19387,40 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
         },
         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({
@@ -19017,6 +19450,34 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
           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: {
@@ -19027,6 +19488,17 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
           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.`;
@@ -19192,8 +19664,7 @@ ${priorTasks.join(`
 `;
           }
           taskService.writeSpec(feature, task, specContent);
-          detectOmoSlim(toolContext);
-          if (omoSlimDetected) {
+          if (isOmoSlimEnabled()) {
             const contextFiles = [];
             const contextDir = path5.join(directory, ".hive", "features", feature, "context");
             if (fs6.existsSync(contextDir)) {
@@ -19221,33 +19692,39 @@ ${priorTasks.join(`
               } : 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 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}
@@ -19279,6 +19756,23 @@ Reminder: do all work inside this worktree and ensure any subagents do the same.
             return `Error: Task "${task}" not found`;
           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",
@@ -19385,9 +19879,10 @@ Use hive_merge to integrate changes. Worktree preserved at ${worktree?.path || "
               summary: t.summary || null
             };
           }));
+          const omoSlimEnabled = isOmoSlimEnabled();
           return JSON.stringify({
             feature,
-            omoSlimDetected,
+            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);
@@ -19673,8 +20168,8 @@ Make the requested changes, then call hive_request_review again.`;
           break;
         }
       }
-      if (featureContext || omoSlimDetected) {
-        return buildHiveAgentPrompt(featureContext, omoSlimDetected);
+      if (featureContext || isOmoSlimEnabled()) {
+        return buildHiveAgentPrompt(featureContext, isOmoSlimEnabled());
       }
       return existingPrompt;
     },