opencode-hive 1.0.5 → 1.0.6

package/dist/index.js

@@ -12608,6 +12608,19 @@ When you have multiple unrelated failures (different test files, different subsy
 
 **Core principle:** Dispatch one agent per independent problem domain. Let them work concurrently.
 
+## Prerequisite: Check Runnable Tasks
+
+Before dispatching, use \`hive_status()\` to get the **runnable** list — tasks whose dependencies are all satisfied.
+
+**Only dispatch tasks that are runnable.** Never start tasks with unmet dependencies.
+
+Only \`done\` satisfies dependencies (not \`blocked\`, \`failed\`, \`partial\`, \`cancelled\`).
+
+**Ask the operator first:**
+- Use \`question()\`: "These tasks are runnable and independent: [list]. Execute in parallel?"
+- Record the decision with \`hive_context_write({ name: "execution-decisions", content: "..." })\`
+- Proceed only after operator approval
+
 ## When to Use
 
 \`\`\`dot
@@ -12668,6 +12681,13 @@ hive_exec_start({ task: "03-fix-race-condition-tests" })
 // All three run concurrently in isolated worktrees
 \`\`\`
 
+Parallelize by issuing multiple task() calls in the same assistant message.
+
+\`\`\`typescript
+task({ subagent_type: 'scout-researcher', prompt: 'Investigate failure A' })
+task({ subagent_type: 'scout-researcher', prompt: 'Investigate failure B' })
+\`\`\`
+
 ### 4. Review and Integrate
 
 When agents return:
@@ -12797,28 +12817,39 @@ Load plan, review critically, execute tasks in batches, report for review betwee
 3. If concerns: Raise them with your human partner before starting
 4. If no concerns: Create TodoWrite and proceed
 
-### Step 2: Execute Batch
-**Default: First 3 tasks**
+### Step 2: Identify Runnable Tasks
+
+Use \`hive_status()\` to get the **runnable** list — tasks with all dependencies satisfied.
+
+Only \`done\` satisfies dependencies (not \`blocked\`, \`failed\`, \`partial\`, \`cancelled\`).
+
+**When 2+ tasks are runnable:**
+- **Ask the operator** via \`question()\`: "Multiple tasks are runnable: [list]. Run in parallel, sequential, or a specific subset?"
+- Record the decision with \`hive_context_write({ name: "execution-decisions", content: "..." })\` for future reference
+
+**When 1 task is runnable:** Proceed directly.
+
+### Step 3: Execute Batch
 
-For each task:
-1. Mark as in_progress
+For each task in the batch:
+1. Mark as in_progress via \`hive_exec_start()\`
 2. Follow each step exactly (plan has bite-sized steps)
 3. Run verifications as specified
 4. Mark as completed
 
-### Step 3: Report
+### Step 4: Report
 When batch complete:
 - Show what was implemented
 - Show verification output
 - Say: "Ready for feedback."
 
-### Step 4: Continue
+### Step 5: Continue
 Based on feedback:
 - Apply changes if needed
 - Execute next batch
 - Repeat until complete
 
-### Step 5: Complete Development
+### Step 6: Complete Development
 
 After all tasks complete and verified:
 - Announce: "I'm using the finishing-a-development-branch skill to complete this work."
@@ -12913,19 +12944,23 @@ Ask one at a time, with the provided options. Store the answers in \`.hive/conte
   },
   {
     name: "parallel-exploration",
-    description: "Use when you need parallel, read-only exploration via hive_hive_background_task (Scout fan-out)",
-    template: `# Parallel Exploration (Background Scout Fan-Out)
+    description: "Use when you need parallel, read-only exploration with hive_background_* or task() (Scout fan-out)",
+    template: `# Parallel Exploration (Scout Fan-Out)
 
 ## Overview
 
 When you need to answer "where/how does X work?" across multiple domains (codebase, tests, docs, OSS), investigating sequentially wastes time. Each investigation is independent and can happen in parallel.
 
-**Core principle:** Decompose into independent sub-questions, spawn one \`hive_hive_background_task\` per sub-question, collect results asynchronously.
+**Core principle:** Decompose into independent sub-questions, spawn one task per sub-question, collect results asynchronously.
 
 **Safe in Planning mode:** This is read-only exploration. It is OK to use during exploratory research even when there is no feature, no plan, and no approved tasks.
 
 **This skill is for read-only research.** For parallel implementation work, use \`hive_skill("dispatching-parallel-agents")\` with \`hive_exec_start\`.
 
+**Two valid execution paths:**
+- **Path A (Hive background tools):** Use \`hive_background_task\`, \`hive_background_output\`, \`hive_background_cancel\` when available.
+- **Path B (Task mode):** Use native \`task()\` for delegation when background tools are not registered.
+
 ## When to Use
 
 **Default to this skill when:**
@@ -12968,6 +13003,7 @@ Split your investigation into 2-4 independent sub-questions. Good decomposition:
 Launch all tasks before waiting for any results:
 
 \`\`\`typescript
+// Path A: Hive background tools (when available)
 // Fan-out: spawn all tasks first
 hive_background_task({
   agent: "scout-researcher",
@@ -13000,6 +13036,37 @@ hive_background_task({
 })
 \`\`\`
 
+\`\`\`typescript
+// Path B: Task mode (native task tool)
+// Parallelize by issuing multiple task() calls in the same assistant message.
+task({
+  subagent_type: 'scout-researcher',
+  description: 'Find hive_background_task implementation',
+  prompt: \`Where is hive_background_task implemented and registered?
+    - Find the tool definition
+    - Find the plugin registration
+    - Return file paths with line numbers\`,
+});
+
+task({
+  subagent_type: 'scout-researcher',
+  description: 'Analyze background task concurrency',
+  prompt: \`How does background task concurrency/queueing work?
+    - Find the manager/scheduler code
+    - Document the concurrency model
+    - Return file paths with evidence\`,
+});
+
+task({
+  subagent_type: 'scout-researcher',
+  description: 'Find parent notification mechanism',
+  prompt: \`How does parent notification work for background tasks?
+    - Where is the notification built?
+    - How is it sent to the parent session?
+    - Return file paths with evidence\`,
+});
+\`\`\`
+
 **Key points:**
 - Use \`agent: "scout-researcher"\` for read-only exploration
 - Use \`sync: false\` to return immediately (non-blocking)
@@ -13020,6 +13087,7 @@ You'll receive a \`<system-reminder>\` notification when each task completes.
 When notified of completion, retrieve results:
 
 \`\`\`typescript
+// Path A: Hive background tools
 // Get output from completed task
 hive_background_output({
   task_id: "task-abc123",
@@ -13058,6 +13126,7 @@ Combine results from all tasks:
 Cancel tasks that are no longer needed:
 
 \`\`\`typescript
+// Path A: Hive background tools
 // Cancel specific task
 hive_background_cancel({ task_id: "task-abc123" })
 
@@ -13120,6 +13189,7 @@ Return:
 
 **Fan-out:**
 \`\`\`typescript
+// Path A: Hive background tools
 // Task 1: Implementation
 hive_background_task({
   agent: "scout-researcher",
@@ -13145,6 +13215,28 @@ hive_background_task({
 })
 \`\`\`
 
+\`\`\`typescript
+// Path B: Task mode (native task tool)
+// Parallelize by issuing multiple task() calls in the same assistant message.
+task({
+  subagent_type: 'scout-researcher',
+  description: 'Find hive_background_task implementation',
+  prompt: 'Where is hive_background_task implemented? Find tool definition and registration.',
+});
+
+task({
+  subagent_type: 'scout-researcher',
+  description: 'Analyze concurrency model',
+  prompt: 'How does background task concurrency work? Find the manager/scheduler.',
+});
+
+task({
+  subagent_type: 'scout-researcher',
+  description: 'Find notification mechanism',
+  prompt: 'How are parent sessions notified of task completion?',
+});
+\`\`\`
+
 **Results:**
 - Task 1: Found \`background-tools.ts\` (tool definition), \`index.ts\` (registration)
 - Task 2: Found \`manager.ts\` with concurrency=3 default, queue-based scheduling
@@ -13169,6 +13261,13 @@ hive_background_task({ ..., sync: false })  // Returns immediately
 // ... later, collect results with hive_background_output
 \`\`\`
 
+\`\`\`typescript
+// GOOD (task mode): Spawn all in the same assistant message
+task({ ... });
+task({ ... });
+task({ ... });
+\`\`\`
+
 **Too many tasks (diminishing returns):**
 - 2-4 tasks: Good parallelization
 - 5+ tasks: Overhead exceeds benefit, harder to synthesize
@@ -13192,8 +13291,9 @@ hive_background_task({ ..., sync: false })  // Returns immediately
 
 After using this pattern, verify:
 - [ ] All tasks spawned before collecting any results (true fan-out)
-- [ ] Received notifications for completed tasks
-- [ ] Successfully retrieved output with \`hive_background_output\`
+- [ ] Received notifications for completed tasks (Path A)
+- [ ] Successfully retrieved output with \`hive_background_output\` (Path A)
+- [ ] Verified \`task()\` fan-out pattern used when in task mode (Path B)
 - [ ] Synthesized findings into coherent answer`
   },
   {
@@ -14281,9 +14381,11 @@ Run \`hive_status()\` or \`hive_feature_list()\` to detect phase:
 ### Delegation
 
 - Single-scout research → \`hive_background_task(agent: "scout-researcher", sync: true, ...)\` (blocks until complete, simpler flow)
-- Parallel exploration → Load \`hive_skill("parallel-exploration")\` and use \`hive_background_task(agent: "scout-researcher", sync: false, ...)\`
+- Parallel exploration → Load \`hive_skill("parallel-exploration")\` and follow the task vs hive mode delegation guidance.
 - Implementation → \`hive_exec_start(task)\` (spawns Forager)
 
+In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
+
 During Planning, default to synchronous exploration (\`sync: true\`). If async/parallel exploration would help, ask the user via \`question()\`.
 
 ### Context Persistence
@@ -14306,7 +14408,7 @@ Load when detailed guidance needed:
 - \`hive_skill("brainstorming")\` - exploring ideas and requirements
 - \`hive_skill("writing-plans")\` - structuring implementation plans
 - \`hive_skill("dispatching-parallel-agents")\` - parallel task delegation
-- \`hive_skill("parallel-exploration")\` - parallel read-only research via hive_background_task (Scout fan-out)
+- \`hive_skill("parallel-exploration")\` - parallel read-only research via task() or hive_background_task (Scout fan-out)
 - \`hive_skill("executing-plans")\` - step-by-step plan execution
 
 Load ONE skill at a time. Only when you need guidance beyond this prompt.
@@ -14365,6 +14467,13 @@ If yes → \`task({ subagent_type: "hygienic", prompt: "Review plan..." })\`
 
 *Active when: plan approved, tasks exist*
 
+### Task Dependencies (Always Check)
+
+Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **blockedBy** info.
+- Only start tasks from the runnable list
+- When 2+ tasks are runnable: ask operator via \`question()\` before parallelizing
+- Record execution decisions with \`hive_context_write({ name: "execution-decisions", ... })\`
+
 ### When to Load Skills
 
 - Multiple independent tasks → \`hive_skill("dispatching-parallel-agents")\`
@@ -14500,7 +14609,9 @@ Plan MUST include:
 **Never:**
 - Execute code (you plan, not implement)
 - Spawn implementation/coding workers (Swarm (Orchestrator) does this); read-only research delegation to Scout is allowed
-- Use the task tool
+- You may use task() to delegate read-only research to Scout and plan review to Hygienic.
+- Never use task() to delegate implementation or coding work.
+- Tool availability depends on delegateMode.
 - Skip discovery for complex tasks
 - Assume when uncertain - ASK
 
@@ -14530,16 +14641,26 @@ Delegate by default. Work yourself only when trivial.
 |------|--------|--------|
 | Trivial | Single file, known location | Direct tools only |
 | Explicit | Specific file/line, clear command | Execute directly |
-| Exploratory | "How does X work?" | Delegate to Scout via hive_background_task(agent: "scout-researcher", sync: false, …). |
+| Exploratory | "How does X work?" | Delegate to Scout via the parallel-exploration playbook. |
 | Open-ended | "Improve", "Refactor" | Assess first, then delegate |
 | Ambiguous | Unclear scope | Ask ONE clarifying question |
 
 ## Delegation Check (Before Acting)
 
+### Task Dependencies (Always Check)
+
+Use \`hive_status()\` to see **runnable** tasks (dependencies satisfied) and **blockedBy** info.
+- Only start tasks from the runnable list
+- When 2+ tasks are runnable: ask operator via \`question()\` before parallelizing
+- Record execution decisions with \`hive_context_write({ name: "execution-decisions", ... })\`
+
+### Standard Checks
+
 1. Is there a specialized agent that matches?
 2. Can I do it myself FOR SURE? REALLY?
 3. Does this require external system data (DBs/APIs/3rd-party tools)?
 → If external data needed: Load \`hive_skill("parallel-exploration")\` for parallel Scout fan-out
+In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
 During Planning, default to synchronous exploration. If async exploration would help, ask the user via \`question()\` and follow the onboarding preferences.
 → Default: DELEGATE
 
@@ -14562,7 +14683,7 @@ hive_exec_start({ task: "01-task-name" })
 hive_background_task({ agent: "forager-worker", prompt: "...", sync: false })
 // If external system data is needed (parallel exploration):
 // Load hive_skill("parallel-exploration") for the full playbook, then:
-hive_background_task({ agent: "scout-researcher", prompt: "...", sync: false })
+// In task mode, use task() for research fan-out; in hive mode, use hive_background_task.
 \`\`\`
 
 **Sync Mode Guidance:**
@@ -15860,7 +15981,7 @@ var DEFAULT_HIVE_CONFIG = {
       model: DEFAULT_AGENT_MODELS["scout-researcher"],
       temperature: 0.5,
       skills: [],
-      autoLoadSkills: ["parallel-exploration"]
+      autoLoadSkills: []
     },
     "forager-worker": {
       model: DEFAULT_AGENT_MODELS["forager-worker"],
@@ -16356,6 +16477,7 @@ class TaskService {
       throw new Error(`No plan.md found for feature '${featureName}'`);
     }
     const planTasks = this.parseTasksFromPlan(planContent);
+    this.validateDependencyGraph(planTasks, featureName);
     const existingTasks = this.list(featureName);
     const result = {
       created: [],
@@ -16388,7 +16510,7 @@ class TaskService {
     }
     for (const planTask of planTasks) {
       if (!existingByName.has(planTask.folder)) {
-        this.createFromPlan(featureName, planTask, planTasks);
+        this.createFromPlan(featureName, planTask, planTasks, planContent);
         result.created.push(planTask.folder);
       }
     }
@@ -16409,49 +16531,156 @@ class TaskService {
     writeJson(getTaskStatusPath(this.projectRoot, featureName, folder), status);
     return folder;
   }
-  createFromPlan(featureName, task, allTasks) {
+  createFromPlan(featureName, task, allTasks, planContent) {
     const taskPath = getTaskPath(this.projectRoot, featureName, task.folder);
     ensureDir(taskPath);
+    const dependsOn = this.resolveDependencies(task, allTasks);
     const status = {
       status: "pending",
       origin: "plan",
-      planTitle: task.name
+      planTitle: task.name,
+      dependsOn
     };
     writeJson(getTaskStatusPath(this.projectRoot, featureName, task.folder), status);
+    const specContent = this.buildSpecContent({
+      featureName,
+      task,
+      dependsOn,
+      allTasks,
+      planContent
+    });
+    writeText(getTaskSpecPath(this.projectRoot, featureName, task.folder), specContent);
+  }
+  buildSpecContent(params) {
+    const { featureName, task, dependsOn, allTasks, planContent, contextFiles = [], completedTasks = [] } = params;
     const specLines = [
-      `# Task ${task.order}: ${task.name}`,
+      `# Task: ${task.folder}`,
       "",
-      `**Feature:** ${featureName}`,
-      `**Folder:** ${task.folder}`,
-      `**Status:** pending`,
+      `## Feature: ${featureName}`,
       "",
-      "---",
-      "",
-      "## Description",
-      "",
-      task.description || "_No description provided in plan_",
+      "## Dependencies",
       ""
     ];
-    if (task.order > 1) {
-      const priorTasks = allTasks.filter((t) => t.order < task.order);
-      if (priorTasks.length > 0) {
-        specLines.push("---", "", "## Prior Tasks", "");
-        for (const prior of priorTasks) {
-          specLines.push(`- **${prior.order}. ${prior.name}** (${prior.folder})`);
+    if (dependsOn.length > 0) {
+      for (const dep of dependsOn) {
+        const depTask = allTasks.find((t) => t.folder === dep);
+        if (depTask) {
+          specLines.push(`- **${depTask.order}. ${depTask.name}** (${dep})`);
+        } else {
+          specLines.push(`- ${dep}`);
         }
-        specLines.push("");
       }
+    } else {
+      specLines.push("_None_");
+    }
+    specLines.push("", "## Plan Section", "");
+    const planSection = this.extractPlanSection(planContent ?? null, task);
+    if (planSection) {
+      specLines.push(planSection.trim());
+    } else {
+      specLines.push("_No plan section available._");
+    }
+    specLines.push("");
+    if (contextFiles.length > 0) {
+      const contextCompiled = contextFiles.map((f) => `## ${f.name}
+
+${f.content}`).join(`
+
+---
+
+`);
+      specLines.push("## Context", "", contextCompiled, "");
+    }
+    if (completedTasks.length > 0) {
+      const completedLines = completedTasks.map((t) => `- ${t.name}: ${t.summary}`);
+      specLines.push("## Completed Tasks", "", ...completedLines, "");
+    }
+    return specLines.join(`
+`);
+  }
+  extractPlanSection(planContent, task) {
+    if (!planContent)
+      return null;
+    const escapedTitle = task.name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const titleRegex = new RegExp(`###\\s*\\d+\\.\\s*${escapedTitle}[\\s\\S]*?(?=###|$)`, "i");
+    let taskMatch = planContent.match(titleRegex);
+    if (!taskMatch && task.order > 0) {
+      const orderRegex = new RegExp(`###\\s*${task.order}\\.\\s*[^\\n]+[\\s\\S]*?(?=###|$)`, "i");
+      taskMatch = planContent.match(orderRegex);
+    }
+    return taskMatch ? taskMatch[0].trim() : null;
+  }
+  resolveDependencies(task, allTasks) {
+    if (task.dependsOnNumbers !== null && task.dependsOnNumbers.length === 0) {
+      return [];
     }
-    const nextTasks = allTasks.filter((t) => t.order > task.order);
-    if (nextTasks.length > 0) {
-      specLines.push("---", "", "## Upcoming Tasks", "");
-      for (const next of nextTasks) {
-        specLines.push(`- **${next.order}. ${next.name}** (${next.folder})`);
+    if (task.dependsOnNumbers !== null) {
+      return task.dependsOnNumbers.map((num) => allTasks.find((t) => t.order === num)?.folder).filter((folder) => folder !== undefined);
+    }
+    if (task.order === 1) {
+      return [];
+    }
+    const previousTask = allTasks.find((t) => t.order === task.order - 1);
+    return previousTask ? [previousTask.folder] : [];
+  }
+  validateDependencyGraph(tasks, featureName) {
+    const taskNumbers = new Set(tasks.map((t) => t.order));
+    for (const task of tasks) {
+      if (task.dependsOnNumbers === null) {
+        continue;
+      }
+      for (const depNum of task.dependsOnNumbers) {
+        if (depNum === task.order) {
+          throw new Error(`Invalid dependency graph in plan.md: Self-dependency detected for task ${task.order} ("${task.name}"). ` + `A task cannot depend on itself. Please fix the "Depends on:" line in plan.md.`);
+        }
+        if (!taskNumbers.has(depNum)) {
+          throw new Error(`Invalid dependency graph in plan.md: Unknown task number ${depNum} referenced in dependencies for task ${task.order} ("${task.name}"). ` + `Available task numbers are: ${Array.from(taskNumbers).sort((a, b) => a - b).join(", ")}. ` + `Please fix the "Depends on:" line in plan.md.`);
+        }
+      }
+    }
+    this.detectCycles(tasks);
+  }
+  detectCycles(tasks) {
+    const taskByOrder = new Map(tasks.map((t) => [t.order, t]));
+    const getDependencies = (task) => {
+      if (task.dependsOnNumbers !== null) {
+        return task.dependsOnNumbers;
+      }
+      if (task.order === 1) {
+        return [];
+      }
+      return [task.order - 1];
+    };
+    const visited = new Map;
+    const path32 = [];
+    const dfs = (taskOrder) => {
+      const state = visited.get(taskOrder);
+      if (state === 2) {
+        return;
+      }
+      if (state === 1) {
+        const cycleStart = path32.indexOf(taskOrder);
+        const cyclePath = [...path32.slice(cycleStart), taskOrder];
+        const cycleDesc = cyclePath.join(" -> ");
+        throw new Error(`Invalid dependency graph in plan.md: Cycle detected in task dependencies: ${cycleDesc}. ` + `Tasks cannot have circular dependencies. Please fix the "Depends on:" lines in plan.md.`);
+      }
+      visited.set(taskOrder, 1);
+      path32.push(taskOrder);
+      const task = taskByOrder.get(taskOrder);
+      if (task) {
+        const deps = getDependencies(task);
+        for (const depOrder of deps) {
+          dfs(depOrder);
+        }
+      }
+      path32.pop();
+      visited.set(taskOrder, 2);
+    };
+    for (const task of tasks) {
+      if (!visited.has(task.order)) {
+        dfs(task.order);
       }
-      specLines.push("");
     }
-    writeText(getTaskSpecPath(this.projectRoot, featureName, task.folder), specLines.join(`
-`));
   }
   writeSpec(featureName, taskFolder, content) {
     const specPath = getTaskSpecPath(this.projectRoot, featureName, taskFolder);
@@ -16542,6 +16771,7 @@ class TaskService {
 `);
     let currentTask = null;
     let descriptionLines = [];
+    const dependsOnRegex = /^\s*\*{0,2}Depends\s+on\*{0,2}\s*:\s*(.+)$/i;
     for (const line of lines) {
       const taskMatch = line.match(/^###\s+(\d+)\.\s+(.+)$/);
       if (taskMatch) {
@@ -16558,7 +16788,8 @@ class TaskService {
           folder,
           order,
           name: rawName,
-          description: ""
+          description: "",
+          dependsOnNumbers: null
         };
         descriptionLines = [];
       } else if (currentTask) {
@@ -16569,6 +16800,16 @@ class TaskService {
           currentTask = null;
           descriptionLines = [];
         } else {
+          const dependsMatch = line.match(dependsOnRegex);
+          if (dependsMatch) {
+            const value = dependsMatch[1].trim().toLowerCase();
+            if (value === "none") {
+              currentTask.dependsOnNumbers = [];
+            } else {
+              const numbers = value.split(/[,\s]+/).map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n));
+              currentTask.dependsOnNumbers = numbers;
+            }
+          }
           descriptionLines.push(line);
         }
       }
@@ -21356,6 +21597,62 @@ class ConfigService {
     return this.getDelegateMode() === "hive";
   }
 }
+function computeRunnableAndBlocked(tasks) {
+  const statusByFolder = new Map;
+  for (const task of tasks) {
+    statusByFolder.set(task.folder, task.status);
+  }
+  const runnable = [];
+  const blocked = {};
+  const effectiveDepsByFolder = buildEffectiveDependencies(tasks);
+  for (const task of tasks) {
+    if (task.status !== "pending") {
+      continue;
+    }
+    const deps = effectiveDepsByFolder.get(task.folder) ?? [];
+    const unmetDeps = deps.filter((dep) => {
+      const depStatus = statusByFolder.get(dep);
+      return depStatus !== "done";
+    });
+    if (unmetDeps.length === 0) {
+      runnable.push(task.folder);
+    } else {
+      blocked[task.folder] = unmetDeps;
+    }
+  }
+  return { runnable, blocked };
+}
+function buildEffectiveDependencies(tasks) {
+  const orderByFolder = new Map;
+  const folderByOrder = new Map;
+  for (const task of tasks) {
+    const match = task.folder.match(/^(\d+)-/);
+    if (!match) {
+      orderByFolder.set(task.folder, null);
+      continue;
+    }
+    const order = parseInt(match[1], 10);
+    orderByFolder.set(task.folder, order);
+    if (!folderByOrder.has(order)) {
+      folderByOrder.set(order, task.folder);
+    }
+  }
+  const effectiveDeps = new Map;
+  for (const task of tasks) {
+    if (task.dependsOn !== undefined) {
+      effectiveDeps.set(task.folder, task.dependsOn);
+      continue;
+    }
+    const order = orderByFolder.get(task.folder);
+    if (!order || order <= 1) {
+      effectiveDeps.set(task.folder, []);
+      continue;
+    }
+    const previousFolder = folderByOrder.get(order - 1);
+    effectiveDeps.set(task.folder, previousFolder ? [previousFolder] : []);
+  }
+  return effectiveDeps;
+}
 
 // src/utils/worker-prompt.ts
 function buildWorkerPrompt(params) {
@@ -22634,7 +22931,11 @@ class BackgroundManager {
         parts: [{ type: "text", text: options.prompt }],
         tools: {
           background_task: false,
-          delegate: false
+          delegate: false,
+          hive_background_task: false,
+          hive_background_output: false,
+          hive_background_cancel: false,
+          task: false
         },
         ...normalizedVariant !== undefined && { variant: normalizedVariant }
       }
@@ -22649,6 +22950,36 @@ class BackgroundManager {
     };
   }
   checkHiveTaskOrdering(feature, taskFolder) {
+    const taskStatus = this.taskService.getRawStatus(feature, taskFolder);
+    if (taskStatus?.dependsOn !== undefined) {
+      return this.checkDependencies(feature, taskFolder, taskStatus.dependsOn);
+    }
+    return this.checkNumericOrdering(feature, taskFolder);
+  }
+  checkDependencies(feature, taskFolder, dependsOn) {
+    if (dependsOn.length === 0) {
+      return { allowed: true };
+    }
+    const unmetDeps = [];
+    for (const depFolder of dependsOn) {
+      const depStatus = this.taskService.getRawStatus(feature, depFolder);
+      if (!depStatus || depStatus.status !== "done") {
+        unmetDeps.push({
+          folder: depFolder,
+          status: depStatus?.status ?? "unknown"
+        });
+      }
+    }
+    if (unmetDeps.length > 0) {
+      const depList = unmetDeps.map((d) => `"${d.folder}" (${d.status})`).join(", ");
+      return {
+        allowed: false,
+        error: `Dependency constraint: Task "${taskFolder}" cannot start - dependencies not done: ${depList}. ` + `Only tasks with status 'done' satisfy dependencies.`
+      };
+    }
+    return { allowed: true };
+  }
+  checkNumericOrdering(feature, taskFolder) {
     const orderMatch = taskFolder.match(/^(\d+)-/);
     if (!orderMatch) {
       return { allowed: true };
@@ -22716,7 +23047,7 @@ class BackgroundManager {
 **Description:** ${task.description}
 **Agent:** ${task.agent}${errorLine}
 
-Use \`background_output({ task_id: "${task.taskId}" })\` to retrieve the result.
+ Use \`hive_background_output({ task_id: "${task.taskId}" })\` to retrieve the result.
 </system-reminder>`;
     try {
       await this.client.session.prompt({
@@ -22913,6 +23244,22 @@ function createBackgroundTools(manager, client, configService) {
         attempt
       }, toolContext) {
         const ctx = toolContext;
+        const ALLOWED_CALLERS = new Set([
+          "hive-master",
+          "architect-planner",
+          "swarm-orchestrator"
+        ]);
+        const callerAgent = ctx?.agent;
+        if (!callerAgent || !ALLOWED_CALLERS.has(callerAgent)) {
+          const output = {
+            provider: "hive",
+            task_id: "",
+            session_id: "",
+            status: "error",
+            error: `Agent "${callerAgent ?? "unknown"}" is not allowed to spawn background tasks. Only orchestrator agents (${[...ALLOWED_CALLERS].join(", ")}) can delegate.`
+          };
+          return JSON.stringify(output, null, 2);
+        }
         let resolvedPrompt = prompt;
         if (promptFile) {
           const baseDir = workdir || process.cwd();
@@ -23424,6 +23771,43 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
     }
     return null;
   };
+  const checkDependencies = (feature, taskFolder) => {
+    const taskStatus = taskService.getRawStatus(feature, taskFolder);
+    if (!taskStatus) {
+      return { allowed: true };
+    }
+    const tasks = taskService.list(feature).map((task) => {
+      const status = taskService.getRawStatus(feature, task.folder);
+      return {
+        folder: task.folder,
+        status: task.status,
+        dependsOn: status?.dependsOn
+      };
+    });
+    const effectiveDeps = buildEffectiveDependencies(tasks);
+    const deps = effectiveDeps.get(taskFolder) ?? [];
+    if (deps.length === 0) {
+      return { allowed: true };
+    }
+    const unmetDeps = [];
+    for (const depFolder of deps) {
+      const depStatus = taskService.getRawStatus(feature, depFolder);
+      if (!depStatus || depStatus.status !== "done") {
+        unmetDeps.push({
+          folder: depFolder,
+          status: depStatus?.status ?? "unknown"
+        });
+      }
+    }
+    if (unmetDeps.length > 0) {
+      const depList = unmetDeps.map((d) => `"${d.folder}" (${d.status})`).join(", ");
+      return {
+        allowed: false,
+        error: `Dependency constraint: Task "${taskFolder}" cannot start - dependencies not done: ${depList}. ` + `Only tasks with status 'done' satisfy dependencies.`
+      };
+    }
+    return { allowed: true };
+  };
   return {
     "experimental.chat.system.transform": async (input, output) => {
       output.system.push(HIVE_SYSTEM_PROMPT);
@@ -23694,9 +24078,9 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
           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 blockedMessage = checkBlocked(feature);
+          if (blockedMessage)
+            return blockedMessage;
           const taskInfo = taskService.get(feature, task);
           if (!taskInfo)
             return `Error: Task "${task}" not found`;
@@ -23705,6 +24089,19 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
           if (continueFrom === "blocked" && taskInfo.status !== "blocked") {
             return "Error: Task is not in blocked state. Use without continueFrom.";
           }
+          if (continueFrom !== "blocked") {
+            const depCheck = checkDependencies(feature, task);
+            if (!depCheck.allowed) {
+              return JSON.stringify({
+                success: false,
+                error: depCheck.error,
+                hints: [
+                  "Complete the required dependencies before starting this task.",
+                  "Use hive_status to see current task states."
+                ]
+              });
+            }
+          }
           let worktree;
           if (continueFrom === "blocked") {
             worktree = await worktreeService.get(feature, task);
@@ -23738,56 +24135,28 @@ Reminder: start work with hive_exec_start to use its worktree, and ensure any su
             ...taskBudgetResult.truncationEvents,
             ...contextBudgetResult.truncationEvents
           ];
-          const priorTasksFormatted = previousTasks.map((t) => `- ${t.name}: ${t.summary}`).join(`
-`);
           const droppedTasksHint = taskBudgetResult.droppedTasksHint;
-          let specContent = `# Task: ${task}
-
-`;
-          specContent += `## Feature: ${feature}
-
-`;
-          if (planResult) {
-            const planTitle = taskInfo.planTitle ?? taskInfo.name;
-            const escapedTitle = planTitle.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const titleRegex = new RegExp(`###\\s*\\d+\\.\\s*${escapedTitle}[\\s\\S]*?(?=###|$)`, "i");
-            let taskMatch = planResult.content.match(titleRegex);
-            if (!taskMatch) {
-              const orderMatch = taskInfo.folder.match(/^(\d+)-/);
-              if (orderMatch) {
-                const orderRegex = new RegExp(`###\\s*${orderMatch[1]}\\.\\s*[^\\n]+[\\s\\S]*?(?=###|$)`, "i");
-                taskMatch = planResult.content.match(orderRegex);
-              }
-            }
-            if (taskMatch) {
-              specContent += `## Plan Section
-
-${taskMatch[0].trim()}
-
-`;
-            }
-          }
-          if (contextFiles.length > 0) {
-            const contextCompiled = contextFiles.map((f) => `## ${f.name}
-
-${f.content}`).join(`
-
----
-
-`);
-            specContent += `## Context
-
-${contextCompiled}
-
-`;
-          }
-          if (priorTasksFormatted) {
-            specContent += `## Completed Tasks
-
-${priorTasksFormatted}
-
-`;
-          }
+          const taskOrder = parseInt(taskInfo.folder.match(/^(\d+)/)?.[1] || "0", 10);
+          const status = taskService.getRawStatus(feature, task);
+          const dependsOn = status?.dependsOn ?? [];
+          const specContent = taskService.buildSpecContent({
+            featureName: feature,
+            task: {
+              folder: task,
+              name: taskInfo.planTitle ?? taskInfo.name,
+              order: taskOrder,
+              description: undefined
+            },
+            dependsOn,
+            allTasks: allTasks.map((t) => ({
+              folder: t.folder,
+              name: t.name,
+              order: parseInt(t.folder.match(/^(\d+)/)?.[1] || "0", 10)
+            })),
+            planContent: planResult?.content ?? null,
+            contextFiles,
+            completedTasks: previousTasks
+          });
           taskService.writeSpec(feature, task, specContent);
           const workerPrompt = buildWorkerPrompt({
             feature,
@@ -24214,12 +24583,16 @@ Files changed: ${result.filesChanged?.length || 0}`;
           const plan = planService.read(feature);
           const tasks = taskService.list(feature);
           const contextFiles = contextService.list(feature);
-          const tasksSummary = tasks.map((t) => ({
-            folder: t.folder,
-            name: t.name,
-            status: t.status,
-            origin: t.origin || "plan"
-          }));
+          const tasksSummary = tasks.map((t) => {
+            const rawStatus = taskService.getRawStatus(feature, t.folder);
+            return {
+              folder: t.folder,
+              name: t.name,
+              status: t.status,
+              origin: t.origin || "plan",
+              dependsOn: rawStatus?.dependsOn ?? null
+            };
+          });
           const contextSummary = contextFiles.map((c) => ({
             name: c.name,
             chars: c.content.length,
@@ -24228,7 +24601,18 @@ Files changed: ${result.filesChanged?.length || 0}`;
           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) => {
+          const tasksWithDeps = tasksSummary.map((t) => ({
+            folder: t.folder,
+            status: t.status,
+            dependsOn: t.dependsOn ?? undefined
+          }));
+          const effectiveDeps = buildEffectiveDependencies(tasksWithDeps);
+          const normalizedTasks = tasksWithDeps.map((task) => ({
+            ...task,
+            dependsOn: effectiveDeps.get(task.folder)
+          }));
+          const { runnable, blocked: blockedBy } = computeRunnableAndBlocked(normalizedTasks);
+          const getNextAction = (planStatus2, tasks2, runnableTasks) => {
             if (!planStatus2 || planStatus2 === "draft") {
               return "Write or revise plan with hive_plan_write, then get approval";
             }
@@ -24242,9 +24626,15 @@ Files changed: ${result.filesChanged?.length || 0}`;
             if (inProgress) {
               return `Continue work on task: ${inProgress.folder}`;
             }
+            if (runnableTasks.length > 1) {
+              return `${runnableTasks.length} tasks are ready to start in parallel: ${runnableTasks.join(", ")}`;
+            }
+            if (runnableTasks.length === 1) {
+              return `Start next task with hive_exec_start: ${runnableTasks[0]}`;
+            }
             const pending = tasks2.find((t) => t.status === "pending");
             if (pending) {
-              return `Start next task with hive_exec_start: ${pending.folder}`;
+              return `Pending tasks exist but are blocked by dependencies. Check blockedBy for details.`;
             }
             return "All tasks complete. Review and merge or complete feature.";
           };
@@ -24266,13 +24656,15 @@ Files changed: ${result.filesChanged?.length || 0}`;
               pending: pendingTasks.length,
               inProgress: inProgressTasks.length,
               done: doneTasks.length,
-              list: tasksSummary
+              list: tasksSummary,
+              runnable,
+              blockedBy
             },
             context: {
               fileCount: contextFiles.length,
               files: contextSummary
             },
-            nextAction: getNextAction(planStatus, tasksSummary)
+            nextAction: getNextAction(planStatus, tasksSummary, runnable)
           });
         }
       }),
@@ -24406,7 +24798,7 @@ Make the requested changes, then call hive_request_review again.`;
         prompt: ARCHITECT_BEE_PROMPT + architectAutoLoadedSkills,
         permission: {
           edit: "deny",
-          task: "deny",
+          task: "allow",
           question: "allow",
           skill: "allow",
           todowrite: "allow",
@@ -24444,6 +24836,11 @@ Make the requested changes, then call hive_request_review again.`;
         prompt: SCOUT_BEE_PROMPT + scoutAutoLoadedSkills,
         permission: {
           edit: "deny",
+          hive_background_task: "deny",
+          hive_background_output: "deny",
+          hive_background_cancel: "deny",
+          task: "deny",
+          delegate: "deny",
           skill: "allow",
           webfetch: "allow"
         }
@@ -24457,6 +24854,11 @@ Make the requested changes, then call hive_request_review again.`;
         description: "Forager (Worker/Coder) - Executes tasks directly in isolated worktrees. Never delegates.",
         prompt: FORAGER_BEE_PROMPT + foragerAutoLoadedSkills,
         permission: {
+          hive_background_task: "deny",
+          hive_background_output: "deny",
+          hive_background_cancel: "deny",
+          task: "deny",
+          delegate: "deny",
           skill: "allow"
         }
       };
@@ -24470,6 +24872,11 @@ Make the requested changes, then call hive_request_review again.`;
         prompt: HYGIENIC_BEE_PROMPT + hygienicAutoLoadedSkills,
         permission: {
           edit: "deny",
+          hive_background_task: "deny",
+          hive_background_output: "deny",
+          hive_background_cancel: "deny",
+          task: "deny",
+          delegate: "deny",
           skill: "allow"
         }
       };