@wrongstack/sdd 1.0.28 → 1.0.32

package/dist/index.js

@@ -90,15 +90,31 @@ var SpecParser = class {
     const requirements = [];
     let inRequirements = false;
     let idCounter = 0;
+    let fence;
     for (const line of lines) {
+      const marker = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+      const markerRun = marker?.[1];
+      if (fence) {
+        if (markerRun && markerRun[0] === fence[0] && markerRun.length >= fence.length && !marker?.[2]?.trim()) {
+          fence = void 0;
+        }
+        continue;
+      }
+      if (marker) {
+        fence = marker[1];
+        continue;
+      }
       if (/^##\s+Requirements/i.test(line.trim())) {
         inRequirements = true;
         continue;
       }
       if (inRequirements && /^##\s+/.test(line.trim())) break;
       if (inRequirements) {
-        const req = this.parseRequirementLine(line, `REQ-${++idCounter}`);
-        if (req) requirements.push(req);
+        const req = this.parseRequirementLine(line, `REQ-${idCounter + 1}`);
+        if (req) {
+          idCounter += 1;
+          requirements.push(req);
+        }
       }
     }
     return requirements;
@@ -119,18 +135,21 @@ var SpecParser = class {
       if (lower.includes(`[${t}]`)) type = t;
     }
     let priority = "medium";
-    if (trimmed.includes("[critical]") || trimmed.includes("[prio:high]")) {
+    if (lower.includes("[critical]") || lower.includes("[prio:high]")) {
       priority = "critical";
-    } else if (trimmed.includes("[high]")) {
+    } else if (lower.includes("[high]")) {
       priority = "high";
-    } else if (trimmed.includes("[low]")) {
+    } else if (lower.includes("[low]")) {
       priority = "low";
     }
     return {
       id,
       type,
       priority,
-      description: trimmed.replace(/\[[^\]]+\]/g, "").trim(),
+      description: trimmed.replace(
+        /\[(?:functional|non-functional|security|performance|ux|critical|high|medium|low|prio:high)\]/gi,
+        ""
+      ).trim(),
       acceptanceCriteria: []
     };
   }
@@ -522,12 +541,14 @@ function assertTaskGraphExecutionIntegrity(graph) {
   const outgoing = /* @__PURE__ */ new Map();
   for (const edge of dependencies) {
     indegree.set(edge.to, indegree.get(edge.to) + 1);
-    outgoing.set(edge.from, [...outgoing.get(edge.from) ?? [], edge.to]);
+    const dependents = outgoing.get(edge.from);
+    if (dependents) dependents.push(edge.to);
+    else outgoing.set(edge.from, [edge.to]);
   }
   const ready = Array.from(indegree.entries()).filter(([, degree]) => degree === 0).map(([id]) => id);
   let visited = 0;
-  while (ready.length > 0) {
-    const id = ready.shift();
+  for (let cursor = 0; cursor < ready.length; cursor++) {
+    const id = ready[cursor];
     visited += 1;
     for (const dependent of outgoing.get(id) ?? []) {
       const next = indegree.get(dependent) - 1;
@@ -643,7 +664,7 @@ var TaskFlow = class {
       this.opts.tracker.updateNodeStatus(taskId, "completed", comment);
       this.emit("task.completed", { taskId });
     } else {
-      this.opts.tracker.updateNodeStatus(taskId, "in_progress", comment ?? "Needs revision");
+      this.opts.tracker.updateNodeStatus(taskId, "pending", comment ?? "Needs revision");
       this.emit("task.review", { taskId });
     }
   }
@@ -742,21 +763,24 @@ var SpecDrivenDev = class {
 import { randomUUID } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-import { atomicWrite, ensureDir } from "@wrongstack/core/utils";
+import { atomicWrite, ensureDir, withFileLock } from "@wrongstack/core/utils";
 var SpecStore = class {
   baseDir;
   indexPath;
+  writeChain = Promise.resolve();
   constructor(opts) {
     this.baseDir = opts.baseDir;
     this.indexPath = path.join(this.baseDir, "_index.json");
   }
   async save(spec) {
-    await ensureDir(this.baseDir);
-    const filePath = this.filePath(spec.id);
-    await atomicWrite(filePath, JSON.stringify(spec, null, 2), { mode: 384 });
-    await this.updateIndex(spec);
+    const snapshot = structuredClone(spec);
+    await this.enqueueWrite(() => this.writeSnapshot(snapshot));
   }
   async load(id) {
+    await this.writeChain;
+    return this.loadFile(id);
+  }
+  async loadFile(id) {
     const filePath = this.filePath(id);
     try {
       const raw = await fsp.readFile(filePath, "utf8");
@@ -766,20 +790,26 @@ var SpecStore = class {
     }
   }
   async list() {
+    await this.writeChain;
     const index = await this.readIndex();
     return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
   }
   async delete(id) {
     const filePath = this.filePath(id);
-    try {
-      await fsp.unlink(filePath);
+    return this.enqueueWrite(async () => {
+      let removed = false;
+      try {
+        await fsp.unlink(filePath);
+        removed = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
       await this.removeFromIndex(id);
-      return true;
-    } catch {
-      return false;
-    }
+      return removed;
+    });
   }
   async exists(id) {
+    await this.writeChain;
     try {
       await fsp.access(this.filePath(id));
       return true;
@@ -806,17 +836,36 @@ var SpecStore = class {
   }
   /** Update spec fields and persist. */
   async update(id, patch) {
-    const spec = await this.load(id);
-    if (!spec) return null;
-    const updated = {
-      ...spec,
-      ...patch,
-      id: spec.id,
-      createdAt: spec.createdAt,
-      updatedAt: Date.now()
-    };
-    await this.save(updated);
-    return updated;
+    return this.enqueueWrite(async () => {
+      const spec = await this.loadFile(id);
+      if (!spec) return null;
+      const updated = {
+        ...spec,
+        ...patch,
+        id: spec.id,
+        createdAt: spec.createdAt,
+        updatedAt: Date.now()
+      };
+      await this.writeSnapshot(updated);
+      return updated;
+    });
+  }
+  /** Serialize every read-modify-write across this process and other store instances. */
+  enqueueWrite(work) {
+    const pending = this.writeChain.then(async () => {
+      await ensureDir(this.baseDir);
+      return withFileLock(this.indexPath, work);
+    });
+    this.writeChain = pending.then(
+      () => void 0,
+      () => void 0
+    );
+    return pending;
+  }
+  async writeSnapshot(snapshot) {
+    const filePath = this.filePath(snapshot.id);
+    await atomicWrite(filePath, JSON.stringify(snapshot, null, 2), { mode: 384 });
+    await this.updateIndex(snapshot);
   }
   /**
    * Resolve a spec id to its file, refusing anything that escapes `baseDir`.
@@ -827,6 +876,9 @@ var SpecStore = class {
    * the same containment `task-graph-store.ts:134-145` applies to its ids.
    */
   filePath(id) {
+    if (typeof id === "string" && id.toLowerCase() === "_index") {
+      throw new Error(`Invalid spec id: ${JSON.stringify(id)}`);
+    }
     if (typeof id !== "string" || id.length === 0 || id.length > 200 || /[\0/\\]/.test(id)) {
       throw new Error(`Invalid spec id: ${JSON.stringify(id)}`);
     }
@@ -839,13 +891,47 @@ var SpecStore = class {
     return resolved;
   }
   async readIndex() {
+    let raw;
+    try {
+      raw = await fsp.readFile(this.indexPath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return this.rebuildIndex();
+      throw error;
+    }
     try {
-      const raw = await fsp.readFile(this.indexPath, "utf8");
       const parsed = JSON.parse(raw);
-      if (parsed?.version === 1) return parsed;
+      if (parsed?.version === 1 && Array.isArray(parsed.entries) && parsed.entries.every(
+        (entry) => entry && typeof entry.id === "string" && typeof entry.title === "string" && typeof entry.version === "string" && typeof entry.status === "string" && Number.isFinite(entry.updatedAt) && typeof entry.filePath === "string"
+      ))
+        return parsed;
     } catch {
     }
-    return { version: 1, entries: [] };
+    return this.rebuildIndex();
+  }
+  async rebuildIndex() {
+    let files;
+    try {
+      files = await fsp.readdir(this.baseDir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, entries: [] };
+      throw error;
+    }
+    const entries = [];
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".json") || file.name === "_index.json") continue;
+      const id = file.name.slice(0, -".json".length);
+      const spec = await this.loadFile(id);
+      if (!spec || spec.id !== id) continue;
+      entries.push({
+        id,
+        title: spec.title,
+        version: spec.version,
+        status: spec.status,
+        updatedAt: spec.updatedAt,
+        filePath: this.filePath(id)
+      });
+    }
+    return { version: 1, entries };
   }
   async updateIndex(spec) {
     const index = await this.readIndex();
@@ -875,7 +961,7 @@ var SpecStore = class {
 // src/task-graph-store.ts
 import * as fsp2 from "node:fs/promises";
 import * as path2 from "node:path";
-import { atomicWrite as atomicWrite2, ensureDir as ensureDir2 } from "@wrongstack/core/utils";
+import { atomicWrite as atomicWrite2, ensureDir as ensureDir2, withFileLock as withFileLock2 } from "@wrongstack/core/utils";
 function graphToJSON(graph) {
   const serialisable = {
     ...graph,
@@ -900,17 +986,17 @@ var TaskGraphStore = class {
   }
   async save(graph) {
     const snapshot = graphFromJSON(graphToJSON(graph));
-    const pending = this.writeChain.then(async () => {
-      await ensureDir2(this.baseDir);
+    await this.enqueueWrite(async () => {
       const filePath = this.filePath(snapshot.id);
       await atomicWrite2(filePath, graphToJSON(snapshot), { mode: 384 });
       await this.updateIndex(snapshot);
     });
-    this.writeChain = pending.catch(() => void 0);
-    await pending;
   }
   async load(id) {
     await this.writeChain;
+    return this.loadFile(id);
+  }
+  async loadFile(id) {
     try {
       const raw = await fsp2.readFile(this.filePath(id), "utf8");
       return graphFromJSON(raw);
@@ -924,14 +1010,23 @@ var TaskGraphStore = class {
     return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
   }
   async delete(id) {
-    await this.writeChain;
+    let filePath;
     try {
-      await fsp2.unlink(this.filePath(id));
-      await this.removeFromIndex(id);
-      return true;
+      filePath = this.filePath(id);
     } catch {
       return false;
     }
+    return this.enqueueWrite(async () => {
+      let removed = false;
+      try {
+        await fsp2.unlink(filePath);
+        removed = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      await this.removeFromIndex(id);
+      return removed;
+    });
   }
   async exists(id) {
     await this.writeChain;
@@ -964,6 +1059,9 @@ var TaskGraphStore = class {
    * already applies to board ids.
    */
   filePath(id) {
+    if (typeof id === "string" && id.toLowerCase() === "_index") {
+      throw new Error(`Invalid task-graph id: ${JSON.stringify(id)}`);
+    }
     if (typeof id !== "string" || id.length === 0 || id.length > 200 || /[\0]/.test(id)) {
       throw new Error(`Invalid task-graph id: ${JSON.stringify(id)}`);
     }
@@ -976,28 +1074,67 @@ var TaskGraphStore = class {
     return resolved;
   }
   async readIndex() {
+    let raw;
+    try {
+      raw = await fsp2.readFile(this.indexPath, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return this.rebuildIndex();
+      throw error;
+    }
     try {
-      const raw = await fsp2.readFile(this.indexPath, "utf8");
       const parsed = JSON.parse(raw);
-      if (parsed?.version === 1) return parsed;
+      if (parsed?.version === 1 && Array.isArray(parsed.entries) && parsed.entries.every(
+        (entry) => entry && typeof entry.id === "string" && typeof entry.specId === "string" && typeof entry.title === "string" && Number.isSafeInteger(entry.nodeCount) && Number.isSafeInteger(entry.completedCount) && Number.isFinite(entry.updatedAt) && typeof entry.filePath === "string"
+      ))
+        return parsed;
     } catch {
     }
-    return { version: 1, entries: [] };
+    return this.rebuildIndex();
   }
-  async updateIndex(graph) {
-    const index = await this.readIndex();
-    const completedCount = Array.from(graph.nodes.values()).filter(
-      (n) => n.status === "completed"
-    ).length;
-    const entry = {
+  async rebuildIndex() {
+    let files;
+    try {
+      files = await fsp2.readdir(this.baseDir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, entries: [] };
+      throw error;
+    }
+    const entries = [];
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".json") || file.name === "_index.json") continue;
+      const id = file.name.slice(0, -".json".length);
+      const graph = await this.loadFile(id);
+      if (!graph || graph.id !== id) continue;
+      entries.push(this.indexEntry(graph));
+    }
+    return { version: 1, entries };
+  }
+  /** Serialize graph and index mutations across this process and other store instances. */
+  enqueueWrite(work) {
+    const pending = this.writeChain.then(async () => {
+      await ensureDir2(this.baseDir);
+      return withFileLock2(this.indexPath, work);
+    });
+    this.writeChain = pending.then(
+      () => void 0,
+      () => void 0
+    );
+    return pending;
+  }
+  indexEntry(graph) {
+    return {
       id: graph.id,
       specId: graph.specId,
       title: graph.title,
       nodeCount: graph.nodes.size,
-      completedCount,
+      completedCount: Array.from(graph.nodes.values()).filter((n) => n.status === "completed").length,
       updatedAt: graph.updatedAt,
       filePath: this.filePath(graph.id)
     };
+  }
+  async updateIndex(graph) {
+    const index = await this.readIndex();
+    const entry = this.indexEntry(graph);
     const idx = index.entries.findIndex((e) => e.id === graph.id);
     if (idx >= 0) {
       index.entries[idx] = entry;
@@ -1108,7 +1245,7 @@ function buildBoardSnapshot(graph, run, now) {
 // src/sdd-board-store.ts
 import * as fsp3 from "node:fs/promises";
 import * as path3 from "node:path";
-import { atomicWrite as atomicWrite3, ensureDir as ensureDir3, withFileLock } from "@wrongstack/core/utils";
+import { atomicWrite as atomicWrite3, ensureDir as ensureDir3, withFileLock as withFileLock3 } from "@wrongstack/core/utils";
 var DEFAULT_EVENT_MAX_BYTES = 16 * 1024 * 1024;
 var DEFAULT_EVENT_KEEP_BYTES = 8 * 1024 * 1024;
 var DEFAULT_EVENT_SIZE_CHECK_EVERY = 100;
@@ -1125,6 +1262,7 @@ var SddBoardStore = class {
   baseDirReady;
   cachedIndex;
   cachedIndexSignature = null;
+  indexNeedsRebuild = false;
   constructor(opts) {
     this.baseDir = opts.baseDir;
     this.indexPath = path3.join(this.baseDir, "_index.json");
@@ -1193,7 +1331,7 @@ var SddBoardStore = class {
   async appendControl(runId, command) {
     await this.ensureBaseDir();
     const filePath = this.controlPath(runId);
-    await withFileLock(
+    await withFileLock3(
       filePath,
       () => fsp3.appendFile(filePath, `${JSON.stringify(command)}
 `, { mode: 384 })
@@ -1282,7 +1420,7 @@ var SddBoardStore = class {
     } catch {
       return [];
     }
-    return withFileLock(filePath, async () => {
+    return withFileLock3(filePath, async () => {
       let raw;
       try {
         const stat2 = await this.controlFileIO.stat(filePath);
@@ -1320,24 +1458,53 @@ var SddBoardStore = class {
     try {
       const raw = await fsp3.readFile(this.indexPath, "utf8");
       const parsed = JSON.parse(raw);
-      if (parsed?.version === 1) {
+      if (parsed?.version === 1 && Array.isArray(parsed.entries)) {
         parsed.entries.sort((a, b) => b.updatedAt - a.updatedAt);
         this.cachedIndex = parsed;
         this.cachedIndexSignature = signature;
+        this.indexNeedsRebuild = false;
         return parsed;
       }
     } catch {
     }
     this.cachedIndex = { version: 1, entries: [] };
     this.cachedIndexSignature = signature;
+    this.indexNeedsRebuild = true;
     return this.cachedIndex;
   }
+  async rebuildIndexEntries() {
+    let files;
+    try {
+      files = await fsp3.readdir(this.baseDir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return [];
+      throw error;
+    }
+    const entries = [];
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".json") || file.name === "_index.json") continue;
+      const runId = file.name.slice(0, -".json".length);
+      const snapshot = await this.load(runId);
+      if (!snapshot || snapshot.runId !== runId || typeof snapshot.title !== "string" || typeof snapshot.status !== "string" || !Number.isFinite(snapshot.updatedAt) || !snapshot.progress || !Number.isFinite(snapshot.progress.total) || !Number.isFinite(snapshot.progress.completed))
+        continue;
+      entries.push({
+        runId,
+        specId: snapshot.specId,
+        title: snapshot.title,
+        status: snapshot.status,
+        total: snapshot.progress.total,
+        completed: snapshot.progress.completed,
+        updatedAt: snapshot.updatedAt
+      });
+    }
+    return entries.sort((a, b) => b.updatedAt - a.updatedAt);
+  }
   async updateIndex(snapshot) {
-    await withFileLock(this.indexPath, async () => {
+    await withFileLock3(this.indexPath, async () => {
       const current = await this.readIndex();
       const index = {
         version: 1,
-        entries: current.entries.map((entry2) => ({ ...entry2 }))
+        entries: this.indexNeedsRebuild ? await this.rebuildIndexEntries() : current.entries.map((entry2) => ({ ...entry2 }))
       };
       const entry = {
         runId: snapshot.runId,
@@ -1355,18 +1522,20 @@ var SddBoardStore = class {
       await atomicWrite3(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
       this.cachedIndex = index;
       this.cachedIndexSignature = await this.indexSignature();
+      this.indexNeedsRebuild = false;
     });
   }
   async removeFromIndex(runId) {
-    await withFileLock(this.indexPath, async () => {
+    await withFileLock3(this.indexPath, async () => {
       const current = await this.readIndex();
       const index = {
         version: 1,
-        entries: current.entries.filter((entry) => entry.runId !== runId).map((entry) => ({ ...entry }))
+        entries: (this.indexNeedsRebuild ? await this.rebuildIndexEntries() : current.entries).filter((entry) => entry.runId !== runId).map((entry) => ({ ...entry }))
       };
       await atomicWrite3(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
       this.cachedIndex = index;
       this.cachedIndexSignature = await this.indexSignature();
+      this.indexNeedsRebuild = false;
     });
   }
   async indexSignature() {
@@ -2822,90 +2991,378 @@ import {
   writeKanbanWorkflowState
 } from "@wrongstack/kanban";
 
-// src/sdd-task-recovery.ts
-function computeDeadlockChains(host) {
-  const tracker = host.opts.tracker;
-  const chains = [];
-  for (const node of tracker.getAllNodes()) {
-    if (node.status === "completed" || node.status === "failed") continue;
-    const blockedBy = tracker.getBlockers(node.id).filter((id) => tracker.getNode(id)?.status !== "completed");
-    if (blockedBy.length > 0) chains.push({ blocked: node.id, blockedBy });
+// src/sdd-task-execution.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
+import { assignNickname } from "@wrongstack/core/coordination";
+import { ERROR_CODES as ERROR_CODES3, SddError as SddError3 } from "@wrongstack/core/types";
+async function executeSddTask(params) {
+  const { task, opts } = params;
+  const taskId = task.id;
+  let agentName = task.assignee;
+  if (!agentName) {
+    const nick = assignNickname("executor", params.usedNicknames);
+    params.usedNicknames.add(nick.key);
+    agentName = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
+    opts.tracker.updateNode(taskId, { assignee: agentName });
   }
-  return chains;
-}
-function recoverFailedBlockers(host) {
-  const tracker = host.opts.tracker;
-  let recovered = false;
-  for (const node of tracker.getAllNodes({ status: ["failed"] })) {
-    const blocksIncomplete = tracker.getDependents(node.id).some((d) => {
-      const s = tracker.getNode(d)?.status;
-      return s !== "completed" && s !== "failed";
+  opts.tracker.updateNodeStatus(taskId, "in_progress");
+  await params.allocateWorktrees([task]);
+  if (!params.coordinator)
+    throw new SddError3({
+      message: "SDD parallel runner requires a coordinator",
+      code: ERROR_CODES3.SDD_INVALID_STATE
     });
-    if (blocksIncomplete) {
-      host.retryMap.delete(node.id);
-      host.persistRetries(node.id, 0);
-      tracker.updateNodeStatus(node.id, "pending", "deadlock recovery");
-      recovered = true;
-    }
-  }
-  return recovered;
-}
-function requeueFailedTasks(host, reason = "retry failed sweep") {
-  const tracker = host.opts.tracker;
-  let n = 0;
-  for (const node of tracker.getAllNodes({ status: ["failed"] })) {
-    if (host.cancelledTasks.has(node.id) || node.metadata?.cancelled) continue;
-    host.retryMap.delete(node.id);
-    host.persistRetries(node.id, 0);
-    tracker.updateNodeStatus(node.id, "pending", reason);
-    host.emit("sdd.task.retrying", {
-      runId: host.runId,
-      taskId: node.id,
-      attempt: 0,
-      maxRetries: host.maxRetries
+  const coordinator = params.coordinator;
+  const subagentId = params.nextSubagentId();
+  const correlationId = randomUUID2();
+  const meta = task.metadata ?? {};
+  const model = (typeof meta.model === "string" ? meta.model : void 0) ?? opts.defaultModel;
+  const provider = (typeof meta.provider === "string" ? meta.provider : void 0) ?? opts.defaultProvider;
+  const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : opts.fallbackModels;
+  const spawnResult = await coordinator.spawn({
+    id: subagentId,
+    name: agentName,
+    role: "executor",
+    idleTimeoutMs: params.idleTimeoutMs,
+    ...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+    cwd: params.taskCwds.get(taskId),
+    disabledTools: ["delegate"],
+    ...model ? { model } : {},
+    ...provider ? { provider } : {},
+    ...fallbackModels?.length ? { fallbackModels } : {}
+  });
+  if (!spawnResult.subagentId) {
+    throw new SddError3({
+      message: "One or more subagent spawns failed",
+      code: ERROR_CODES3.SDD_INVALID_STATE
     });
-    n++;
   }
-  return n;
-}
-function restoreRetryMap(host) {
-  host.retryMap.clear();
-  for (const node of host.opts.tracker.getAllNodes()) {
-    const r = node.metadata?.retries;
-    if (typeof r === "number" && r > 0) host.retryMap.set(node.id, r);
+  params.taskSubagents.set(taskId, subagentId);
+  params.emit("sdd.task.started", {
+    runId: params.runId,
+    taskId,
+    subagentId,
+    agentName,
+    worktreeBranch: params.taskBranches.get(taskId)
+  });
+  await coordinator.assign({
+    id: correlationId,
+    description: buildTaskDirective(opts.graph.title, task),
+    subagentId,
+    ...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+    context: {
+      telemetryTaskId: taskId,
+      telemetryRunId: params.runId,
+      telemetryBoardId: opts.graph.id
+    }
+  });
+  let result;
+  try {
+    const got = await coordinator.awaitTasks([correlationId]);
+    result = expectDefined3(got[0]);
+  } catch (err) {
+    result = {
+      subagentId,
+      taskId: correlationId,
+      status: "failed",
+      error: { kind: "unknown", message: String(err), retryable: false },
+      iterations: 0,
+      toolCalls: 0,
+      durationMs: 0
+    };
   }
-}
-function resetOrphans(tracker) {
-  let n = 0;
-  for (const node of tracker.getAllNodes({ status: ["in_progress"] })) {
-    tracker.updateNodeStatus(node.id, "pending", "resume: orphaned in_progress");
-    n++;
+  params.taskSubagents.delete(taskId);
+  if (params.cancelledTasks.has(taskId)) {
+    await params.resolveWorktrees([task]);
+    return { taskId, success: false, result };
   }
-  return n;
-}
-
-// src/sdd-parallel-run.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import {
-  DefaultMultiAgentCoordinator,
-  makeAgentSubagentRunner,
-  withDisabledToolFiltering
-} from "@wrongstack/core/coordination";
-import { requireSessionId } from "@wrongstack/primitives";
-
-// src/graph-split.ts
-function splitGraphNode(tracker, taskId, subtasks, options = {}) {
-  const node = tracker.getNode(taskId);
-  if (!node) return [];
-  if (node.status === "in_progress" || options.isRunning?.(taskId)) return [];
-  if (!subtasks.length) return [];
-  const blockers = tracker.getBlockers(taskId);
-  const dependents = tracker.getDependents(taskId);
-  const leafIds = subtasks.map((s) => {
-    const criterion = s.successCriterion?.trim();
-    const description = criterion ? `${s.description}
-
-**Acceptance Criteria:**
+  const verificationFailReason = await verifyTaskResult(params, result);
+  let success = false;
+  if (result.status === "success" && !verificationFailReason) {
+    const merged = await params.integrateWorktree(task, result);
+    if (merged.ok) {
+      success = true;
+      opts.tracker.updateNodeStatus(taskId, "completed");
+      await params.resolveWorktrees([task]);
+      params.emit("sdd.task.completed", {
+        runId: params.runId,
+        taskId,
+        subagentId,
+        durationMs: result.durationMs
+      });
+    } else if (merged.reason) {
+      params.emit("sdd.task.verification_failed", {
+        runId: params.runId,
+        taskId,
+        reason: merged.reason
+      });
+      if (merged.fatal) {
+        opts.tracker.updateNodeStatus(taskId, "failed", merged.reason);
+        params.emit("sdd.task.failed", {
+          runId: params.runId,
+          taskId,
+          subagentId,
+          error: merged.reason
+        });
+      } else {
+        await params.applyTaskFailure(taskId, subagentId, merged.reason);
+      }
+    } else {
+      const conflictFiles = merged.conflictFiles ?? [];
+      params.emit("sdd.task.conflict", { runId: params.runId, taskId, conflictFiles });
+      const reason = `merge conflict${conflictFiles.length ? `: ${conflictFiles.join(", ")}` : ""}`;
+      await params.applyTaskFailure(taskId, subagentId, reason);
+    }
+  } else {
+    const errMsg = verificationFailReason ?? (result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error");
+    await params.applyTaskFailure(taskId, subagentId, errMsg);
+    await params.resolveWorktrees([task]);
+  }
+  return { taskId, success, result };
+}
+function buildTaskDirective(graphTitle, task) {
+  const directivePreamble = [
+    "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
+    "",
+    `Graph: ${graphTitle}`,
+    "",
+    "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+    "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
+    "\u2022 Mark the task [done] in the tracker when complete.",
+    "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
+    "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
+  ].join("\n");
+  return [
+    directivePreamble,
+    "",
+    `\u2500\u2500 TASK \u2500\u2500`,
+    `[${task.priority.toUpperCase()}] ${task.title}`,
+    "",
+    task.description
+  ].join("\n");
+}
+async function verifyTaskResult(params, result) {
+  const { task, opts, taskCwds } = params;
+  if (result.status !== "success" || !opts.verifyTask) return void 0;
+  const taskId = task.id;
+  const cwd = taskCwds.get(taskId) ?? opts.projectRoot;
+  let verificationFailReason;
+  try {
+    const verdict = await opts.verifyTask({ task, result, cwd });
+    if (!verdict.ok) {
+      verificationFailReason = `verification failed: ${verdict.reason ?? "acceptance criteria not met"}`;
+    }
+  } catch (err) {
+    verificationFailReason = `verification error: ${String(err)}`;
+  }
+  const hadVerifiable = typeof task.metadata?.["verificationCommand"] === "string" || task.description.includes("**Acceptance Criteria:**");
+  if (verificationFailReason) {
+    opts.tracker.patchMetadata(taskId, {
+      verificationState: "failed",
+      verificationDetail: verificationFailReason
+    });
+    params.emit("sdd.task.verification_failed", {
+      runId: params.runId,
+      taskId,
+      reason: verificationFailReason
+    });
+  } else if (hadVerifiable) {
+    opts.tracker.patchMetadata(taskId, {
+      verificationState: "passed",
+      verificationDetail: void 0
+    });
+  }
+  return verificationFailReason;
+}
+
+// src/sdd-task-dispatch.ts
+async function executeWave(batch) {
+  const waveStart = Date.now();
+  const outcomes = await Promise.all(batch.tasks.map((task) => this.executeOne(task)));
+  const results = outcomes.map((o) => o.result).filter((r) => Boolean(r));
+  const successCount = outcomes.filter((o) => o.success).length;
+  const failCount = outcomes.length - successCount;
+  return {
+    wave: batch.wave,
+    batch,
+    results,
+    successCount,
+    failCount,
+    durationMs: Date.now() - waveStart,
+    stopRequested: this.stopRequested
+  };
+}
+async function executeOne(task) {
+  const outcome = await executeSddTask({
+    task,
+    opts: this.opts,
+    coordinator: this.coordinator,
+    usedNicknames: this.usedNicknames,
+    idleTimeoutMs: this.idleTimeoutMs,
+    timeoutMs: this.timeoutMs,
+    runId: this.runId,
+    nextSubagentId: () => `sdd-d${this.dispatchSeq++}`,
+    emit: (event, payload) => this.emit(event, payload),
+    taskCwds: this.taskCwds,
+    taskBranches: this.taskBranches,
+    taskSubagents: this.taskSubagents,
+    cancelledTasks: this.cancelledTasks,
+    allocateWorktrees: (tasks) => this.allocateWorktrees(tasks),
+    resolveWorktrees: (tasks) => this.resolveWorktrees(tasks),
+    integrateWorktree: (taskNode, result) => this.integrateWorktree(taskNode, result),
+    applyTaskFailure: (taskId, subagentId, errMsg) => this.applyTaskFailure(taskId, subagentId, errMsg)
+  });
+  if (outcome.success) {
+    this.retryMap.delete(task.id);
+    this.persistRetries(task.id, 0);
+  }
+  return outcome;
+}
+async function applyTaskFailure(taskId, subagentId, errMsg) {
+  const currentRetries = this.retryMap.get(taskId) ?? 0;
+  if (currentRetries < this.maxRetries) {
+    this.retryMap.set(taskId, currentRetries + 1);
+    this.persistRetries(taskId, currentRetries + 1);
+    this.opts.tracker.updateNodeStatus(
+      taskId,
+      "pending",
+      `Retry ${currentRetries + 1}/${this.maxRetries}: ${errMsg}`
+    );
+    this.emit("sdd.task.retrying", {
+      runId: this.runId,
+      taskId,
+      attempt: currentRetries + 1,
+      maxRetries: this.maxRetries
+    });
+    return;
+  }
+  if (await this.trySupervisorRescue(taskId, errMsg)) return;
+  this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
+  this.emit("sdd.task.failed", { runId: this.runId, taskId, subagentId, error: errMsg });
+}
+async function trySupervisorRescue(taskId, errMsg) {
+  const supervise = this.opts.superviseFailure;
+  if (!supervise) return false;
+  const used = this.supervisorEscalations.get(taskId) ?? 0;
+  if (used >= this.maxSupervisorEscalations) return false;
+  const node = this.opts.tracker.getNode(taskId);
+  if (!node) return false;
+  let verdict;
+  try {
+    verdict = await supervise({ task: node, error: errMsg, attempts: used });
+  } catch {
+    return false;
+  }
+  if (!verdict || verdict.action === "fail") return false;
+  this.supervisorEscalations.set(taskId, used + 1);
+  const requeue = (reason) => {
+    this.retryMap.delete(taskId);
+    this.persistRetries(taskId, 0);
+    this.opts.tracker.updateNodeStatus(taskId, "pending", reason);
+  };
+  if (verdict.action === "reassign") {
+    this.setTaskModel(taskId, verdict.model, verdict.provider);
+    requeue(`supervisor reassign: ${verdict.model ?? "default"}`);
+    this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "reassign" });
+    return true;
+  }
+  if (verdict.action === "split") {
+    const ids = this.splitTask(taskId, verdict.subtasks);
+    if (ids.length === 0) return false;
+    this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "split" });
+    return true;
+  }
+  requeue("supervisor retry");
+  this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "retry" });
+  return true;
+}
+
+// src/sdd-task-recovery.ts
+function computeDeadlockChains(host) {
+  const tracker = host.opts.tracker;
+  const chains = [];
+  for (const node of tracker.getAllNodes()) {
+    if (node.status === "completed" || node.status === "failed") continue;
+    const blockedBy = tracker.getBlockers(node.id).filter((id) => tracker.getNode(id)?.status !== "completed");
+    if (blockedBy.length > 0) chains.push({ blocked: node.id, blockedBy });
+  }
+  return chains;
+}
+function recoverFailedBlockers(host) {
+  const tracker = host.opts.tracker;
+  let recovered = false;
+  for (const node of tracker.getAllNodes({ status: ["failed"] })) {
+    if (host.cancelledTasks.has(node.id) || node.metadata?.cancelled) continue;
+    const blocksIncomplete = tracker.getDependents(node.id).some((d) => {
+      const s = tracker.getNode(d)?.status;
+      return s !== "completed" && s !== "failed";
+    });
+    if (blocksIncomplete) {
+      host.retryMap.delete(node.id);
+      host.persistRetries(node.id, 0);
+      tracker.updateNodeStatus(node.id, "pending", "deadlock recovery");
+      recovered = true;
+    }
+  }
+  return recovered;
+}
+function requeueFailedTasks(host, reason = "retry failed sweep") {
+  const tracker = host.opts.tracker;
+  let n = 0;
+  for (const node of tracker.getAllNodes({ status: ["failed"] })) {
+    if (host.cancelledTasks.has(node.id) || node.metadata?.cancelled) continue;
+    host.retryMap.delete(node.id);
+    host.persistRetries(node.id, 0);
+    tracker.updateNodeStatus(node.id, "pending", reason);
+    host.emit("sdd.task.retrying", {
+      runId: host.runId,
+      taskId: node.id,
+      attempt: 0,
+      maxRetries: host.maxRetries
+    });
+    n++;
+  }
+  return n;
+}
+function restoreRetryMap(host) {
+  host.retryMap.clear();
+  for (const node of host.opts.tracker.getAllNodes()) {
+    const r = node.metadata?.retries;
+    if (typeof r === "number" && r > 0) host.retryMap.set(node.id, r);
+  }
+}
+function resetOrphans(tracker) {
+  let n = 0;
+  for (const node of tracker.getAllNodes({ status: ["in_progress"] })) {
+    tracker.updateNodeStatus(node.id, "pending", "resume: orphaned in_progress");
+    n++;
+  }
+  return n;
+}
+
+// src/sdd-parallel-run.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import {
+  DefaultMultiAgentCoordinator,
+  makeAgentSubagentRunner,
+  withDisabledToolFiltering
+} from "@wrongstack/core/coordination";
+import { requireSessionId } from "@wrongstack/primitives";
+
+// src/graph-split.ts
+function splitGraphNode(tracker, taskId, subtasks, options = {}) {
+  const node = tracker.getNode(taskId);
+  if (!node) return [];
+  if (node.status === "in_progress" || options.isRunning?.(taskId)) return [];
+  if (!subtasks.length) return [];
+  const blockers = tracker.getBlockers(taskId);
+  const dependents = tracker.getDependents(taskId);
+  const leafIds = subtasks.map((s) => {
+    const criterion = s.successCriterion?.trim();
+    const description = criterion ? `${s.description}
+
+**Acceptance Criteria:**
 - ${criterion}` : s.description;
     return tracker.addNode({
       title: s.title,
@@ -3021,199 +3478,17 @@ var SddTaskDecomposer = class {
     });
     return ready;
   }
-  /** True when at least one non-completed, non-failed task is blocked. */
+  /** True when non-completed, non-failed tasks remain blocked and cannot make progress. */
   hasAnyBlockedTasks() {
     const nodes = this.tracker.getAllNodes({
       status: ["pending", "in_progress", "blocked"]
     });
-    return nodes.some((n) => n.status === "blocked");
-  }
-};
-
-// src/sdd-task-execution.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
-import { assignNickname } from "@wrongstack/core/coordination";
-import { ERROR_CODES as ERROR_CODES3, SddError as SddError3 } from "@wrongstack/core/types";
-async function executeSddTask(params) {
-  const { task, opts } = params;
-  const taskId = task.id;
-  let agentName = task.assignee;
-  if (!agentName) {
-    const nick = assignNickname("executor", params.usedNicknames);
-    params.usedNicknames.add(nick.key);
-    agentName = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
-    opts.tracker.updateNode(taskId, { assignee: agentName });
-  }
-  opts.tracker.updateNodeStatus(taskId, "in_progress");
-  await params.allocateWorktrees([task]);
-  if (!params.coordinator)
-    throw new SddError3({
-      message: "SDD parallel runner requires a coordinator",
-      code: ERROR_CODES3.SDD_INVALID_STATE
-    });
-  const coordinator = params.coordinator;
-  const subagentId = params.nextSubagentId();
-  const correlationId = randomUUID2();
-  const meta = task.metadata ?? {};
-  const model = (typeof meta.model === "string" ? meta.model : void 0) ?? opts.defaultModel;
-  const provider = (typeof meta.provider === "string" ? meta.provider : void 0) ?? opts.defaultProvider;
-  const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : opts.fallbackModels;
-  const spawnResult = await coordinator.spawn({
-    id: subagentId,
-    name: agentName,
-    role: "executor",
-    idleTimeoutMs: params.idleTimeoutMs,
-    ...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
-    cwd: params.taskCwds.get(taskId),
-    disabledTools: ["delegate"],
-    ...model ? { model } : {},
-    ...provider ? { provider } : {},
-    ...fallbackModels?.length ? { fallbackModels } : {}
-  });
-  if (!spawnResult.subagentId) {
-    throw new SddError3({
-      message: "One or more subagent spawns failed",
-      code: ERROR_CODES3.SDD_INVALID_STATE
-    });
-  }
-  params.taskSubagents.set(taskId, subagentId);
-  params.emit("sdd.task.started", {
-    runId: params.runId,
-    taskId,
-    subagentId,
-    agentName,
-    worktreeBranch: params.taskBranches.get(taskId)
-  });
-  await coordinator.assign({
-    id: correlationId,
-    description: buildTaskDirective(opts.graph.title, task),
-    subagentId,
-    ...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
-    context: {
-      telemetryTaskId: taskId,
-      telemetryRunId: params.runId,
-      telemetryBoardId: opts.graph.id
-    }
-  });
-  let result;
-  try {
-    const got = await coordinator.awaitTasks([correlationId]);
-    result = expectDefined3(got[0]);
-  } catch (err) {
-    result = {
-      subagentId,
-      taskId: correlationId,
-      status: "failed",
-      error: { kind: "unknown", message: String(err), retryable: false },
-      iterations: 0,
-      toolCalls: 0,
-      durationMs: 0
-    };
-  }
-  params.taskSubagents.delete(taskId);
-  if (params.cancelledTasks.has(taskId)) {
-    await params.resolveWorktrees([task]);
-    return { taskId, success: false, result };
-  }
-  const verificationFailReason = await verifyTaskResult(params, result);
-  let success = false;
-  if (result.status === "success" && !verificationFailReason) {
-    const merged = await params.integrateWorktree(task, result);
-    if (merged.ok) {
-      success = true;
-      opts.tracker.updateNodeStatus(taskId, "completed");
-      await params.resolveWorktrees([task]);
-      params.emit("sdd.task.completed", {
-        runId: params.runId,
-        taskId,
-        subagentId,
-        durationMs: result.durationMs
-      });
-    } else if (merged.reason) {
-      params.emit("sdd.task.verification_failed", {
-        runId: params.runId,
-        taskId,
-        reason: merged.reason
-      });
-      if (merged.fatal) {
-        opts.tracker.updateNodeStatus(taskId, "failed", merged.reason);
-        params.emit("sdd.task.failed", {
-          runId: params.runId,
-          taskId,
-          subagentId,
-          error: merged.reason
-        });
-      } else {
-        await params.applyTaskFailure(taskId, subagentId, merged.reason);
-      }
-    } else {
-      const conflictFiles = merged.conflictFiles ?? [];
-      params.emit("sdd.task.conflict", { runId: params.runId, taskId, conflictFiles });
-      const reason = `merge conflict${conflictFiles.length ? `: ${conflictFiles.join(", ")}` : ""}`;
-      await params.applyTaskFailure(taskId, subagentId, reason);
-    }
-  } else {
-    const errMsg = verificationFailReason ?? (result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error");
-    await params.applyTaskFailure(taskId, subagentId, errMsg);
-    await params.resolveWorktrees([task]);
-  }
-  return { taskId, success, result };
-}
-function buildTaskDirective(graphTitle, task) {
-  const directivePreamble = [
-    "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
-    "",
-    `Graph: ${graphTitle}`,
-    "",
-    "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
-    "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
-    "\u2022 Mark the task [done] in the tracker when complete.",
-    "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
-    "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
-  ].join("\n");
-  return [
-    directivePreamble,
-    "",
-    `\u2500\u2500 TASK \u2500\u2500`,
-    `[${task.priority.toUpperCase()}] ${task.title}`,
-    "",
-    task.description
-  ].join("\n");
-}
-async function verifyTaskResult(params, result) {
-  const { task, opts, taskCwds } = params;
-  if (result.status !== "success" || !opts.verifyTask) return void 0;
-  const taskId = task.id;
-  const cwd = taskCwds.get(taskId) ?? opts.projectRoot;
-  let verificationFailReason;
-  try {
-    const verdict = await opts.verifyTask({ task, result, cwd });
-    if (!verdict.ok) {
-      verificationFailReason = `verification failed: ${verdict.reason ?? "acceptance criteria not met"}`;
+    if (nodes.some((n) => n.status === "in_progress")) {
+      return false;
     }
-  } catch (err) {
-    verificationFailReason = `verification error: ${String(err)}`;
+    return nodes.some((n) => n.status === "blocked" || n.status === "pending");
   }
-  const hadVerifiable = typeof task.metadata?.["verificationCommand"] === "string" || task.description.includes("**Acceptance Criteria:**");
-  if (verificationFailReason) {
-    opts.tracker.patchMetadata(taskId, {
-      verificationState: "failed",
-      verificationDetail: verificationFailReason
-    });
-    params.emit("sdd.task.verification_failed", {
-      runId: params.runId,
-      taskId,
-      reason: verificationFailReason
-    });
-  } else if (hadVerifiable) {
-    opts.tracker.patchMetadata(taskId, {
-      verificationState: "passed",
-      verificationDetail: void 0
-    });
-  }
-  return verificationFailReason;
-}
+};
 
 // src/sdd-worktree-integration.ts
 function forgetTaskWorktree(state, taskId, opts = {}) {
@@ -3677,14 +3952,20 @@ var SddParallelRun = class {
       running.set(task.id, tracked);
     };
     while (!this.stopRequested) {
-      if (totalDispatched >= this.maxTotalWaves) break;
-      if (this.maxWallClockMs && Date.now() - startTime >= this.maxWallClockMs) break;
+      if (totalDispatched >= this.maxTotalWaves) {
+        await Promise.allSettled(running.values());
+        break;
+      }
+      if (this.maxWallClockMs && Date.now() - startTime >= this.maxWallClockMs) {
+        this.stop();
+        break;
+      }
       await this.waitWhilePaused();
       if (this.stopRequested) break;
       let dispatchedThisRound = 0;
       const ready = this.decomposer.readyNodes().filter((t) => !running.has(t.id));
       for (const task of ready) {
-        if (running.size >= this.slots) break;
+        if (running.size >= this.slots || totalDispatched >= this.maxTotalWaves) break;
         dispatch(task);
         dispatchedThisRound++;
       }
@@ -3861,20 +4142,7 @@ var SddParallelRun = class {
    * (surfaced from `executeOne`), preserving the original all-or-nothing contract.
    */
   async executeWave(batch) {
-    const waveStart = Date.now();
-    const outcomes = await Promise.all(batch.tasks.map((task) => this.executeOne(task)));
-    const results = outcomes.map((o) => o.result).filter((r) => Boolean(r));
-    const successCount = outcomes.filter((o) => o.success).length;
-    const failCount = outcomes.length - successCount;
-    return {
-      wave: batch.wave,
-      batch,
-      results,
-      successCount,
-      failCount,
-      durationMs: Date.now() - waveStart,
-      stopRequested: this.stopRequested
-    };
+    return executeWave.call(this.sddTaskDispatchHost(), batch);
   }
   /**
    * Execute one task end-to-end: assign a worker identity, allocate its worktree,
@@ -3884,30 +4152,7 @@ var SddParallelRun = class {
    * missing coordinator or failed spawn so callers can enforce all-or-nothing.
    */
   async executeOne(task) {
-    const outcome = await executeSddTask({
-      task,
-      opts: this.opts,
-      coordinator: this.coordinator,
-      usedNicknames: this.usedNicknames,
-      idleTimeoutMs: this.idleTimeoutMs,
-      timeoutMs: this.timeoutMs,
-      runId: this.runId,
-      nextSubagentId: () => `sdd-d${this.dispatchSeq++}`,
-      emit: (event, payload) => this.emit(event, payload),
-      taskCwds: this.taskCwds,
-      taskBranches: this.taskBranches,
-      taskSubagents: this.taskSubagents,
-      cancelledTasks: this.cancelledTasks,
-      allocateWorktrees: (tasks) => this.allocateWorktrees(tasks),
-      resolveWorktrees: (tasks) => this.resolveWorktrees(tasks),
-      integrateWorktree: (taskNode, result) => this.integrateWorktree(taskNode, result),
-      applyTaskFailure: (taskId, subagentId, errMsg) => this.applyTaskFailure(taskId, subagentId, errMsg)
-    });
-    if (outcome.success) {
-      this.retryMap.delete(task.id);
-      this.persistRetries(task.id, 0);
-    }
-    return outcome;
+    return executeOne.call(this.sddTaskDispatchHost(), task);
   }
   /**
    * Apply a task failure: retry (→ pending, bump retry count) while attempts
@@ -3917,26 +4162,7 @@ var SddParallelRun = class {
    * negotiate the same retry budget and emit the same events.
    */
   async applyTaskFailure(taskId, subagentId, errMsg) {
-    const currentRetries = this.retryMap.get(taskId) ?? 0;
-    if (currentRetries < this.maxRetries) {
-      this.retryMap.set(taskId, currentRetries + 1);
-      this.persistRetries(taskId, currentRetries + 1);
-      this.opts.tracker.updateNodeStatus(
-        taskId,
-        "pending",
-        `Retry ${currentRetries + 1}/${this.maxRetries}: ${errMsg}`
-      );
-      this.emit("sdd.task.retrying", {
-        runId: this.runId,
-        taskId,
-        attempt: currentRetries + 1,
-        maxRetries: this.maxRetries
-      });
-      return;
-    }
-    if (await this.trySupervisorRescue(taskId, errMsg)) return;
-    this.opts.tracker.updateNodeStatus(taskId, "failed", errMsg);
-    this.emit("sdd.task.failed", { runId: this.runId, taskId, subagentId, error: errMsg });
+    return applyTaskFailure.call(this.sddTaskDispatchHost(), taskId, subagentId, errMsg);
   }
   /**
    * Consult `superviseFailure` for a task that has exhausted its retries.
@@ -3945,40 +4171,7 @@ var SddParallelRun = class {
    * `maxSupervisorEscalations` so an always-"retry" supervisor can't loop forever.
    */
   async trySupervisorRescue(taskId, errMsg) {
-    const supervise = this.opts.superviseFailure;
-    if (!supervise) return false;
-    const used = this.supervisorEscalations.get(taskId) ?? 0;
-    if (used >= this.maxSupervisorEscalations) return false;
-    const node = this.opts.tracker.getNode(taskId);
-    if (!node) return false;
-    let verdict;
-    try {
-      verdict = await supervise({ task: node, error: errMsg, attempts: used });
-    } catch {
-      return false;
-    }
-    if (!verdict || verdict.action === "fail") return false;
-    this.supervisorEscalations.set(taskId, used + 1);
-    const requeue = (reason) => {
-      this.retryMap.delete(taskId);
-      this.persistRetries(taskId, 0);
-      this.opts.tracker.updateNodeStatus(taskId, "pending", reason);
-    };
-    if (verdict.action === "reassign") {
-      this.setTaskModel(taskId, verdict.model, verdict.provider);
-      requeue(`supervisor reassign: ${verdict.model ?? "default"}`);
-      this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "reassign" });
-      return true;
-    }
-    if (verdict.action === "split") {
-      const ids = this.splitTask(taskId, verdict.subtasks);
-      if (ids.length === 0) return false;
-      this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "split" });
-      return true;
-    }
-    requeue("supervisor retry");
-    this.emit("sdd.supervisor.decision", { runId: this.runId, taskId, action: "retry" });
-    return true;
+    return trySupervisorRescue.call(this.sddTaskDispatchHost(), taskId, errMsg);
   }
   /**
    * Integrate a verified-successful task's worktree into the base branch.
@@ -4062,6 +4255,35 @@ var SddParallelRun = class {
       maxRetries: this.maxRetries
     };
   }
+  sddTaskDispatchHost() {
+    void this.executeOne;
+    void this.stopRequested;
+    void this.opts;
+    void this.coordinator;
+    void this.usedNicknames;
+    void this.idleTimeoutMs;
+    void this.timeoutMs;
+    void this.runId;
+    void this.dispatchSeq;
+    void this.emit;
+    void this.taskCwds;
+    void this.taskBranches;
+    void this.taskSubagents;
+    void this.cancelledTasks;
+    void this.allocateWorktrees;
+    void this.resolveWorktrees;
+    void this.integrateWorktree;
+    void this.applyTaskFailure;
+    void this.retryMap;
+    void this.persistRetries;
+    void this.maxRetries;
+    void this.trySupervisorRescue;
+    void this.supervisorEscalations;
+    void this.maxSupervisorEscalations;
+    void this.setTaskModel;
+    void this.splitTask;
+    return this;
+  }
 };
 
 // src/start-sdd-run.ts
@@ -4836,11 +5058,17 @@ function renderTaskGraph(graph, opts) {
   lines.push(renderProgress(progress));
   lines.push("");
   const childrenMap = /* @__PURE__ */ new Map();
+  const dependentsMap = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
     if (edge.type === "depends_on") {
       const deps = childrenMap.get(edge.from) ?? [];
       deps.push(edge.to);
       childrenMap.set(edge.from, deps);
+      if (graph.nodes.has(edge.from)) {
+        const dependents = dependentsMap.get(edge.to) ?? [];
+        dependents.push(edge.from);
+        dependentsMap.set(edge.to, dependents);
+      }
     }
   }
   const rendered = /* @__PURE__ */ new Set();
@@ -4850,18 +5078,18 @@ function renderTaskGraph(graph, opts) {
     return !deps || deps.length === 0;
   });
   for (const rootId of startNodes) {
-    renderNode(graph, rootId, lines, rendered, childrenMap, compact, "");
+    renderNode(graph, rootId, lines, rendered, childrenMap, dependentsMap, compact, "");
   }
   for (const [id] of graph.nodes) {
     if (!rendered.has(id)) {
-      renderNode(graph, id, lines, rendered, childrenMap, compact, "");
+      renderNode(graph, id, lines, rendered, childrenMap, dependentsMap, compact, "");
     }
   }
   lines.push("");
   lines.push("Legend: \u25CF done \u25D0 in-progress \u25CB pending \u2297 blocked \u2717 failed \u25D2 review");
   return lines.join("\n");
 }
-function renderNode(graph, nodeId, lines, rendered, childrenMap, compact, prefix) {
+function renderNode(graph, nodeId, lines, rendered, childrenMap, dependentsMap, compact, prefix) {
   if (rendered.has(nodeId)) return;
   rendered.add(nodeId);
   const node = expectDefined4(graph.nodes.get(nodeId));
@@ -4878,9 +5106,9 @@ function renderNode(graph, nodeId, lines, rendered, childrenMap, compact, prefix
       lines.push(`${prefix}  \u2514 ${truncate(dl, 60)}`);
     }
   }
-  const dependents = graph.edges.filter((e) => e.type === "depends_on" && e.to === nodeId).map((e) => e.from).filter((id) => graph.nodes.has(id));
+  const dependents = dependentsMap.get(nodeId) ?? [];
   for (const depId of dependents) {
-    renderNode(graph, depId, lines, rendered, childrenMap, compact, prefix + "  ");
+    renderNode(graph, depId, lines, rendered, childrenMap, dependentsMap, compact, prefix + "  ");
   }
 }
 function renderProgress(progress) {
@@ -4991,24 +5219,28 @@ function analyzeCriticalPath(graph) {
   for (const node of nodes) {
     if (node.status === "completed") continue;
     const downstream = getTransitiveBlocked(graph, node.id, blocksMap);
-    if (downstream.size > 0) {
-      const blockedHours = Array.from(downstream).reduce((sum, id) => {
-        const n = graph.nodes.get(id);
-        return sum + (n?.estimateHours ?? 0);
-      }, 0);
+    const activeDownstream = Array.from(downstream).filter((id) => {
+      const downstreamNode = graph.nodes.get(id);
+      return downstreamNode?.status !== "completed";
+    });
+    if (activeDownstream.length > 0) {
+      const blockedHours = activeDownstream.reduce(
+        (sum, id) => sum + taskEstimateHours(graph, id, 0),
+        0
+      );
       bottlenecks.push({
         taskId: node.id,
         title: node.title,
-        blockedCount: downstream.size,
+        blockedCount: activeDownstream.length,
         blockedHours,
-        severity: Math.min(100, Math.round(downstream.size / nodes.length * 100))
+        severity: Math.min(100, Math.round(activeDownstream.length / nodes.length * 100))
       });
     }
   }
   bottlenecks.sort((a, b) => b.severity - a.severity);
   const criticalPath = computeCriticalPath(graph, topoOrder, blockedByMap);
   const totalHours = criticalPath.reduce((sum, id) => {
-    return sum + (graph.nodes.get(id).estimateHours ?? 0);
+    return sum + taskEstimateHours(graph, id, 0);
   }, 0);
   const parallelGroups = computeParallelGroups(graph, blockedByMap);
   const executionOrder = topoOrder.filter((id) => {
@@ -5047,7 +5279,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   const dist = /* @__PURE__ */ new Map();
   const prev = /* @__PURE__ */ new Map();
   for (const id of allIds) {
-    dist.set(id, graph.nodes.get(id)?.estimateHours ?? 1);
+    dist.set(id, taskEstimateHours(graph, id, 1));
     prev.set(id, null);
   }
   const blocksMap = /* @__PURE__ */ new Map();
@@ -5064,7 +5296,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       const blocked = blocksMap.get(id);
       if (!blocked) continue;
       for (const blockedId of blocked) {
-        const candidateDist = dist.get(id) + (graph.nodes.get(blockedId)?.estimateHours ?? 1);
+        const candidateDist = dist.get(id) + taskEstimateHours(graph, blockedId, 1);
         if (candidateDist > (dist.get(blockedId) ?? 0)) {
           dist.set(blockedId, candidateDist);
           prev.set(blockedId, id);
@@ -5093,6 +5325,10 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   }
   return path7;
 }
+function taskEstimateHours(graph, taskId, fallback) {
+  const value = graph.nodes.get(taskId)?.estimateHours;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
   const assigned = new Set(
@@ -5143,21 +5379,23 @@ var SpecVersioning = class {
     const history = this.versions.get(spec.id) ?? [];
     history.push(version);
     this.versions.set(spec.id, history);
-    return version;
+    return structuredClone(version);
   }
   /** Get version history for a spec. */
   getHistory(specId) {
-    return this.versions.get(specId) ?? [];
+    return structuredClone(this.versions.get(specId) ?? []);
   }
   /** Get a specific version of a spec. */
   getVersion(specId, version) {
     const history = this.versions.get(specId) ?? [];
-    return history.find((v) => v.version === version);
+    const found = history.find((v) => v.version === version);
+    return found ? structuredClone(found) : void 0;
   }
   /** Get the latest version of a spec. */
   getLatest(specId) {
     const history = this.versions.get(specId) ?? [];
-    return history[history.length - 1];
+    const latest = history[history.length - 1];
+    return latest ? structuredClone(latest) : void 0;
   }
   /** Compute diff between two versions of a spec. */
   diff(oldSpec, newSpec) {
@@ -5245,6 +5483,17 @@ var SpecVersioning = class {
         task.title = mod.requirement.description;
         task.description = this.buildTaskDescription(mod.requirement);
         task.priority = mod.requirement.priority;
+        const metadataTags = /* @__PURE__ */ new Set([
+          mod.previousVersion.type,
+          mod.previousVersion.priority,
+          mod.requirement.type,
+          mod.requirement.priority
+        ]);
+        task.tags = [
+          ...(task.tags ?? []).filter((tag) => !metadataTags.has(tag)),
+          mod.requirement.type,
+          mod.requirement.priority
+        ];
         task.updatedAt = Date.now();
         changes.push(`Updated task: ${task.title} (${mod.changes.join(", ")})`);
       }
@@ -5267,6 +5516,9 @@ var SpecVersioning = class {
       graph.rootNodes.push(newTask.id);
       changes.push(`Added task: ${newTask.title}`);
     }
+    graph.requiredRequirementIds = Array.from(
+      new Set(newSpec.requirements.map((requirement) => requirement.id))
+    );
     graph.updatedAt = Date.now();
     return { graph, changes };
   }
@@ -5930,8 +6182,10 @@ function resolveConflictText(text, side) {
     }
     if (isMarker(line, "|", size)) state = "base";
     else if (isMarker(line, "=", size)) state = "theirs";
-    else if (isMarker(line, ">", size)) state = "normal";
-    else if (state === "ours" && side === "base") out.push(line);
+    else if (isMarker(line, ">", size)) {
+      if (state !== "theirs") return text;
+      state = "normal";
+    } else if (state === "ours" && side === "base") out.push(line);
     else if (state === "theirs" && side === "incoming") out.push(line);
   }
   if (state !== "normal") return text;