@wrongstack/sdd 1.0.32 → 1.0.35

package/dist/index.js

@@ -1975,8 +1975,8 @@ var SddRunRegistry = class {
 import { TaskTracker as TaskTracker2 } from "@wrongstack/core/tasking";
 
 // src/spec-builder.ts
-import { ERROR_CODES as ERROR_CODES2, SddError as SddError2 } from "@wrongstack/core/types";
-import { expectDefined as expectDefined2, toErrorMessage } from "@wrongstack/core/utils";
+import { ERROR_CODES as ERROR_CODES3, SddError as SddError3 } from "@wrongstack/core/types";
+import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
 
 // src/sdd-session-types.ts
 function isAISpecSession(value) {
@@ -1985,7 +1985,122 @@ function isAISpecSession(value) {
   return typeof session.id === "string" && typeof session.phase === "string" && typeof session.title === "string" && typeof session.userIntent === "string" && Array.isArray(session.answers) && typeof session.updatedAt === "number";
 }
 
-// src/spec-builder.ts
+// src/spec-builder-parsing.ts
+import { ERROR_CODES as ERROR_CODES2, SddError as SddError2 } from "@wrongstack/core/types";
+import { toErrorMessage } from "@wrongstack/core/utils";
+function parseSpecificationJSON(jsonStr, fallbackTitle, sessionId) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch (e) {
+    throw new SddError2({
+      message: "Invalid JSON for spec",
+      code: ERROR_CODES2.SDD_PARSE_FAILED,
+      cause: e,
+      context: { detail: toErrorMessage(e) }
+    });
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new SddError2({
+      message: "Spec JSON must be an object",
+      code: ERROR_CODES2.SDD_VALIDATION_FAILED,
+      context: { actualType: typeof parsed }
+    });
+  }
+  const raw = parsed;
+  const now = Date.now();
+  const title = String(raw.title ?? fallbackTitle);
+  const overview = String(raw.overview ?? "");
+  if (!overview || overview === "undefined") {
+    throw new SddError2({
+      message: "Spec must have an overview",
+      code: ERROR_CODES2.SDD_VALIDATION_FAILED,
+      context: { field: "overview", title }
+    });
+  }
+  const rawSections = Array.isArray(raw.sections) ? raw.sections : [];
+  const sections = rawSections.filter((s) => s && typeof s === "object").map((s) => ({
+    type: [
+      "overview",
+      "requirements",
+      "architecture",
+      "api",
+      "data",
+      "security",
+      "acceptance"
+    ].includes(String(s.type)) ? String(s.type) : "overview",
+    title: String(s.title ?? ""),
+    content: String(s.content ?? ""),
+    level: Number(s.level) || 1
+  }));
+  const rawReqs = Array.isArray(raw.requirements) ? raw.requirements : [];
+  const requirements = rawReqs.filter((r) => r && typeof r === "object").map((r, i) => ({
+    id: String(r.id ?? `REQ-${i + 1}`),
+    type: ["functional", "non-functional", "security", "performance", "ux"].includes(
+      String(r.type)
+    ) ? String(r.type) : "functional",
+    priority: ["critical", "high", "medium", "low"].includes(String(r.priority)) ? String(r.priority) : "medium",
+    description: String(r.description ?? ""),
+    acceptanceCriteria: Array.isArray(r.acceptanceCriteria) ? r.acceptanceCriteria.map(String) : []
+  }));
+  const spec = {
+    id: crypto.randomUUID(),
+    title,
+    version: "0.1.0",
+    status: "draft",
+    overview,
+    sections,
+    requirements,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      generatedBy: "AISpecBuilder",
+      sessionId
+    }
+  };
+  return spec;
+}
+function extractJSONFromText(text) {
+  const codeBlockMatch = text.match(/```json\s*([\s\S]*?)```/);
+  if (codeBlockMatch?.[1]) {
+    return codeBlockMatch[1].trim();
+  }
+  const genericBlockMatch = text.match(/```\s*([\s\S]*?)```/);
+  if (genericBlockMatch?.[1]) {
+    const trimmed = genericBlockMatch[1].trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return trimmed;
+    }
+  }
+  const jsonMatch = text.match(/(\{[\s\S]*\})/);
+  if (jsonMatch?.[1]) {
+    try {
+      JSON.parse(jsonMatch[1]);
+      return jsonMatch[1];
+    } catch {
+    }
+  }
+  return null;
+}
+function extractJSONArrayFromText(text) {
+  const codeBlockMatch = text.match(/```json\s*([\s\S]*?)```/);
+  if (codeBlockMatch?.[1]) {
+    const trimmed = codeBlockMatch[1].trim();
+    if (trimmed.startsWith("[")) return trimmed;
+  }
+  const arrayMatch = text.match(/(\[[\s\S]*\])/);
+  if (arrayMatch?.[1]) {
+    try {
+      const parsed = JSON.parse(arrayMatch[1]);
+      if (Array.isArray(parsed)) return arrayMatch[1];
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/spec-builder-prompts.ts
+import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -2177,6 +2292,34 @@ function buildExecutingPrompt(session) {
     "Start executing the first pending task now."
   ].join("\n");
 }
+
+// src/spec-builder-session-file.ts
+async function writeAISpecSessionFile(sessionPath, snapshot) {
+  const fsp7 = await import("node:fs/promises");
+  const path7 = await import("node:path");
+  const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
+  await fsp7.mkdir(path7.dirname(sessionPath), { recursive: true });
+  await atomicWrite4(sessionPath, JSON.stringify(snapshot, null, 2));
+}
+async function readAISpecSessionFile(sessionPath) {
+  try {
+    const fsp7 = await import("node:fs/promises");
+    const raw = await fsp7.readFile(sessionPath, "utf8");
+    const loaded = JSON.parse(raw);
+    if (isAISpecSession(loaded)) return loaded;
+  } catch {
+  }
+  return void 0;
+}
+async function deleteAISpecSessionFile(sessionPath) {
+  try {
+    const fsp7 = await import("node:fs/promises");
+    await fsp7.unlink(sessionPath);
+  } catch {
+  }
+}
+
+// src/spec-builder.ts
 var AISpecBuilder = class {
   session;
   store;
@@ -2217,12 +2360,7 @@ var AISpecBuilder = class {
           await this.sessionPersistence.save(snapshot);
           return;
         }
-        const fsp7 = await import("node:fs/promises");
-        const path7 = await import("node:path");
-        const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
-        const sessionPath = expectDefined2(this.sessionPath);
-        await fsp7.mkdir(path7.dirname(sessionPath), { recursive: true });
-        await atomicWrite4(sessionPath, JSON.stringify(snapshot, null, 2));
+        await writeAISpecSessionFile(expectDefined3(this.sessionPath), snapshot);
       } catch (error) {
         console.warn(
           JSON.stringify({
@@ -2239,23 +2377,18 @@ var AISpecBuilder = class {
   /** Load session state from the configured durable owner. */
   async loadSession() {
     if (this.sessionPersistence) {
-      const loaded = await this.sessionPersistence.load();
-      if (isAISpecSession(loaded)) {
-        this.session = loaded;
+      const loaded2 = await this.sessionPersistence.load();
+      if (isAISpecSession(loaded2)) {
+        this.session = loaded2;
         return true;
       }
       return false;
     }
     if (!this.sessionPath) return false;
-    try {
-      const fsp7 = await import("node:fs/promises");
-      const raw = await fsp7.readFile(this.sessionPath, "utf8");
-      const loaded = JSON.parse(raw);
-      if (isAISpecSession(loaded)) {
-        this.session = loaded;
-        return true;
-      }
-    } catch {
+    const loaded = await readAISpecSessionFile(this.sessionPath);
+    if (loaded) {
+      this.session = loaded;
+      return true;
     }
     return false;
   }
@@ -2267,11 +2400,7 @@ var AISpecBuilder = class {
       return;
     }
     if (!this.sessionPath) return;
-    try {
-      const fsp7 = await import("node:fs/promises");
-      await fsp7.unlink(this.sessionPath);
-    } catch {
-    }
+    await deleteAISpecSessionFile(this.sessionPath);
   }
   /** Auto-save helper. saveSession() already handles best-effort persistence. */
   autoSave() {
@@ -2363,9 +2492,9 @@ var AISpecBuilder = class {
     switch (this.session.phase) {
       case "questioning":
         if (!this.session.spec) {
-          throw new SddError2({
+          throw new SddError3({
             message: "Cannot approve: no spec generated yet.",
-            code: ERROR_CODES2.SDD_INVALID_STATE,
+            code: ERROR_CODES3.SDD_INVALID_STATE,
             context: { phase: "questioning", sessionId: this.session.id }
           });
         }
@@ -2499,9 +2628,9 @@ var AISpecBuilder = class {
    */
   async saveSpec() {
     if (!this.session.spec) {
-      throw new SddError2({
+      throw new SddError3({
         message: "No spec to save.",
-        code: ERROR_CODES2.SDD_NOT_READY,
+        code: ERROR_CODES3.SDD_NOT_READY,
         context: { sessionId: this.session.id }
       });
     }
@@ -2514,101 +2643,13 @@ var AISpecBuilder = class {
    * Validates and normalizes the structure.
    */
   parseSpecFromJSON(jsonStr) {
-    let parsed;
-    try {
-      parsed = JSON.parse(jsonStr);
-    } catch (e) {
-      throw new SddError2({
-        message: "Invalid JSON for spec",
-        code: ERROR_CODES2.SDD_PARSE_FAILED,
-        cause: e,
-        context: { detail: toErrorMessage(e) }
-      });
-    }
-    if (!parsed || typeof parsed !== "object") {
-      throw new SddError2({
-        message: "Spec JSON must be an object",
-        code: ERROR_CODES2.SDD_VALIDATION_FAILED,
-        context: { actualType: typeof parsed }
-      });
-    }
-    const raw = parsed;
-    const now = Date.now();
-    const title = String(raw.title ?? this.session.title);
-    const overview = String(raw.overview ?? "");
-    if (!overview || overview === "undefined") {
-      throw new SddError2({
-        message: "Spec must have an overview",
-        code: ERROR_CODES2.SDD_VALIDATION_FAILED,
-        context: { field: "overview", title }
-      });
-    }
-    const rawSections = Array.isArray(raw.sections) ? raw.sections : [];
-    const sections = rawSections.filter((s) => s && typeof s === "object").map((s) => ({
-      type: [
-        "overview",
-        "requirements",
-        "architecture",
-        "api",
-        "data",
-        "security",
-        "acceptance"
-      ].includes(String(s.type)) ? String(s.type) : "overview",
-      title: String(s.title ?? ""),
-      content: String(s.content ?? ""),
-      level: Number(s.level) || 1
-    }));
-    const rawReqs = Array.isArray(raw.requirements) ? raw.requirements : [];
-    const requirements = rawReqs.filter((r) => r && typeof r === "object").map((r, i) => ({
-      id: String(r.id ?? `REQ-${i + 1}`),
-      type: ["functional", "non-functional", "security", "performance", "ux"].includes(
-        String(r.type)
-      ) ? String(r.type) : "functional",
-      priority: ["critical", "high", "medium", "low"].includes(String(r.priority)) ? String(r.priority) : "medium",
-      description: String(r.description ?? ""),
-      acceptanceCriteria: Array.isArray(r.acceptanceCriteria) ? r.acceptanceCriteria.map(String) : []
-    }));
-    const spec = {
-      id: crypto.randomUUID(),
-      title,
-      version: "0.1.0",
-      status: "draft",
-      overview,
-      sections,
-      requirements,
-      createdAt: now,
-      updatedAt: now,
-      metadata: {
-        generatedBy: "AISpecBuilder",
-        sessionId: this.session.id
-      }
-    };
-    return spec;
+    return parseSpecificationJSON(jsonStr, this.session.title, this.session.id);
   }
   /**
    * Extract JSON from AI output (handles ```json blocks and raw JSON).
    */
   extractJSON(text) {
-    const codeBlockMatch = text.match(/```json\s*([\s\S]*?)```/);
-    if (codeBlockMatch?.[1]) {
-      return codeBlockMatch[1].trim();
-    }
-    const genericBlockMatch = text.match(/```\s*([\s\S]*?)```/);
-    if (genericBlockMatch?.[1]) {
-      const trimmed = genericBlockMatch[1].trim();
-      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-        return trimmed;
-      }
-    }
-    const jsonMatch = text.match(/(\{[\s\S]*\})/);
-    if (jsonMatch?.[1]) {
-      try {
-        JSON.parse(jsonMatch[1]);
-        return jsonMatch[1];
-      } catch {
-      }
-    }
-    return null;
+    return extractJSONFromText(text);
   }
   /**
    * Detect if AI output contains a spec (JSON block).
@@ -2634,20 +2675,7 @@ var AISpecBuilder = class {
    * Extract a JSON array from AI output (for task lists).
    */
   extractJSONArray(text) {
-    const codeBlockMatch = text.match(/```json\s*([\s\S]*?)```/);
-    if (codeBlockMatch?.[1]) {
-      const trimmed = codeBlockMatch[1].trim();
-      if (trimmed.startsWith("[")) return trimmed;
-    }
-    const arrayMatch = text.match(/(\[[\s\S]*\])/);
-    if (arrayMatch?.[1]) {
-      try {
-        const parsed = JSON.parse(arrayMatch[1]);
-        if (Array.isArray(parsed)) return arrayMatch[1];
-      } catch {
-      }
-    }
-    return null;
+    return extractJSONArrayFromText(text);
   }
 };
 
@@ -2991,95 +3019,341 @@ import {
   writeKanbanWorkflowState
 } from "@wrongstack/kanban";
 
-// 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 } : {}
+// 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,
+      description,
+      type: s.type ?? node.type,
+      priority: s.priority ?? node.priority,
+      status: "pending",
+      parentId: taskId
+    }).id;
   });
-  if (!spawnResult.subagentId) {
-    throw new SddError3({
-      message: "One or more subagent spawns failed",
-      code: ERROR_CODES3.SDD_INVALID_STATE
+  for (const leaf of leafIds) {
+    for (const b of blockers) tracker.addDependency(b, leaf);
+    for (const dep of dependents) tracker.addDependency(leaf, dep);
+  }
+  tracker.updateNodeStatus(taskId, "completed", `split into ${leafIds.length} subtasks`);
+  return leafIds;
+}
+
+// src/sdd-parallel-controls.ts
+async function cleanupWorktrees(host) {
+  if (host.isRunning()) return 0;
+  const wt = host.opts.worktrees;
+  if (!wt) return 0;
+  for (const [taskId, handle] of [...host.taskWorktrees]) {
+    await wt.release(handle, { keep: false }).catch(() => {
     });
+    host.forgetWorktree(taskId);
   }
-  params.taskSubagents.set(taskId, subagentId);
-  params.emit("sdd.task.started", {
-    runId: params.runId,
+  const { removed } = await wt.cleanupAllManaged();
+  return removed;
+}
+async function rollback(host) {
+  if (host.isRunning())
+    return { ok: false, reverted: 0, reason: "run still active \u2014 stop it first" };
+  const wt = host.opts.worktrees;
+  if (!wt || !host.baseBranch) {
+    return { ok: false, reverted: 0, reason: "no worktree run to roll back" };
+  }
+  return wt.revertCommits(
+    host.baseBranch,
+    host.mergedCommits.map((c) => c.sha)
+  );
+}
+function retryTask(host, taskId) {
+  if (!host.opts.tracker.getNode(taskId)) return false;
+  host.retryMap.delete(taskId);
+  host.persistRetries(taskId, 0);
+  host.cancelledTasks.delete(taskId);
+  host.opts.tracker.patchMetadata(taskId, { cancelled: void 0 });
+  host.opts.tracker.updateNodeStatus(taskId, "pending", "manual retry");
+  return true;
+}
+function reassignTask(host, taskId, agentName) {
+  if (!host.opts.tracker.getNode(taskId)) return false;
+  host.opts.tracker.updateNode(taskId, { assignee: agentName });
+  return true;
+}
+function setTaskModel(host, taskId, model, provider) {
+  if (!host.opts.tracker.getNode(taskId)) return false;
+  host.opts.tracker.patchMetadata(taskId, {
+    model,
+    ...provider !== void 0 ? { provider } : {}
+  });
+  return true;
+}
+function setTaskFallbacks(host, taskId, fallbackModels) {
+  if (!host.opts.tracker.getNode(taskId)) return false;
+  host.opts.tracker.patchMetadata(taskId, { fallbackModels });
+  return true;
+}
+function setTaskVerification(host, taskId, verificationCommand) {
+  if (!host.opts.tracker.getNode(taskId)) return false;
+  const cmd = verificationCommand?.trim();
+  host.opts.tracker.patchMetadata(taskId, { verificationCommand: cmd ? cmd : void 0 });
+  return true;
+}
+async function cancelTask(host, taskId) {
+  const node = host.opts.tracker.getNode(taskId);
+  if (!node) return false;
+  if (node.status === "completed") return false;
+  host.cancelledTasks.add(taskId);
+  host.opts.tracker.patchMetadata(taskId, { cancelled: true });
+  host.opts.tracker.updateNodeStatus(taskId, "failed", "cancelled by user");
+  host.emit("sdd.task.failed", {
+    runId: host.runId,
     taskId,
-    subagentId,
-    agentName,
-    worktreeBranch: params.taskBranches.get(taskId)
+    subagentId: "",
+    error: "cancelled by user"
   });
-  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
-    }
+  const subagentId = host.taskSubagents.get(taskId);
+  if (subagentId && host.coordinator) {
+    await host.coordinator.stop(subagentId).catch(() => {
+    });
+  }
+  return true;
+}
+function deleteTask(host, taskId) {
+  const node = host.opts.tracker.getNode(taskId);
+  if (!node) return false;
+  if (node.status === "in_progress" || host.taskSubagents.has(taskId)) return false;
+  host.cancelledTasks.delete(taskId);
+  host.retryMap.delete(taskId);
+  return host.opts.tracker.removeNode(taskId);
+}
+function splitTask(host, taskId, subtasks) {
+  const leafIds = splitGraphNode(host.opts.tracker, taskId, subtasks, {
+    isRunning: (id) => host.taskSubagents.has(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
-    };
+  if (!leafIds.length) return [];
+  host.retryMap.delete(taskId);
+  host.persistRetries(taskId, 0);
+  host.emit("sdd.task.split", { runId: host.runId, taskId, subtaskIds: leafIds });
+  return leafIds;
+}
+
+// src/sdd-parallel-run-state.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import {
+  DefaultMultiAgentCoordinator,
+  makeAgentSubagentRunner,
+  withDisabledToolFiltering
+} from "@wrongstack/core/coordination";
+import { requireSessionId } from "@wrongstack/primitives";
+
+// src/sdd-task-decomposer.ts
+var SddTaskDecomposer = class {
+  constructor(tracker, _graph, opts = {}) {
+    this.tracker = tracker;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
   }
-  params.taskSubagents.delete(taskId);
-  if (params.cancelledTasks.has(taskId)) {
-    await params.resolveWorktrees([task]);
-    return { taskId, success: false, result };
+  tracker;
+  slots;
+  wave = 0;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /**
+   * Return the next batch of runnable tasks.
+   * Returns `allDone: true` when every node is completed.
+   * Returns `deadlocked: true` when no batch can be produced because
+   * all remaining tasks are blocked by failed nodes.
+   */
+  nextBatch() {
+    if (this.isDone()) {
+      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
+    }
+    const pending = this.pendingReadyNodes();
+    if (pending.length === 0) {
+      const hasBlockedTasks = this.hasAnyBlockedTasks();
+      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
+    }
+    const batch = pending.slice(0, this.slots);
+    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
   }
-  const verificationFailReason = await verifyTaskResult(params, result);
-  let success = false;
-  if (result.status === "success" && !verificationFailReason) {
+  /**
+   * Advance the wave counter after a batch completes.
+   * Call this once per `nextBatch()` result that was fan-out.
+   */
+  acknowledgeBatch(_completedTaskIds) {
+    this.wave++;
+  }
+  /**
+   * True when every node in the graph is completed.
+   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
+   */
+  isDone() {
+    const progress = this.tracker.getProgress();
+    return progress.total > 0 && progress.completed === progress.total;
+  }
+  /**
+   * Total waves produced so far.
+   */
+  getWaveCount() {
+    return this.wave;
+  }
+  /**
+   * All ready (dependency-satisfied) pending tasks, priority-sorted — UNSLICED.
+   * The continuous scheduler fills its own free slots from this list, so unlike
+   * `nextBatch()` it does not cap at `slots`.
+   */
+  readyNodes() {
+    return this.pendingReadyNodes();
+  }
+  /**
+   * True when every node has reached a terminal state (completed or failed).
+   * This — not `isDone()` (which requires ALL completed) — is the correct loop
+   * exit for the continuous scheduler: a terminally-failed task must not keep
+   * the run spinning to its backstop.
+   */
+  isSettled() {
+    const nodes = this.tracker.getAllNodes();
+    return nodes.length > 0 && nodes.every((n) => n.status === "completed" || n.status === "failed");
+  }
+  // -------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------
+  /**
+   * Return pending nodes whose blockers are all completed.
+   * Sorted by priority (critical first), then by creation time.
+   */
+  pendingReadyNodes() {
+    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
+    const ready = [];
+    for (const node of allPending) {
+      if (this.tracker.canStart(node.id)) {
+        ready.push(node);
+      }
+    }
+    const priorityRank = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    ready.sort((a, b) => {
+      const pr = priorityRank[a.priority] - priorityRank[b.priority];
+      if (pr !== 0) return pr;
+      return a.createdAt - b.createdAt;
+    });
+    return ready;
+  }
+  /** True when non-completed, non-failed tasks remain blocked and cannot make progress. */
+  hasAnyBlockedTasks() {
+    const nodes = this.tracker.getAllNodes({
+      status: ["pending", "in_progress", "blocked"]
+    });
+    if (nodes.some((n) => n.status === "in_progress")) {
+      return false;
+    }
+    return nodes.some((n) => n.status === "blocked" || n.status === "pending");
+  }
+};
+
+// src/sdd-task-execution.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { expectDefined as expectDefined4 } from "@wrongstack/core/utils";
+import { assignNickname } from "@wrongstack/core/coordination";
+import { ERROR_CODES as ERROR_CODES4, SddError as SddError4 } 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 SddError4({
+      message: "SDD parallel runner requires a coordinator",
+      code: ERROR_CODES4.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 SddError4({
+      message: "One or more subagent spawns failed",
+      code: ERROR_CODES4.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 = expectDefined4(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;
@@ -3268,6 +3542,9 @@ async function trySupervisorRescue(taskId, errMsg) {
     return true;
   }
   if (verdict.action === "split") {
+    if (this.opts.tracker.getNode(taskId)?.status === "in_progress") {
+      this.opts.tracker.updateNodeStatus(taskId, "pending", "supervisor 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" });
@@ -3341,179 +3618,30 @@ function resetOrphans(tracker) {
   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,
-      description,
-      type: s.type ?? node.type,
-      priority: s.priority ?? node.priority,
-      status: "pending",
-      parentId: taskId
-    }).id;
-  });
-  for (const leaf of leafIds) {
-    for (const b of blockers) tracker.addDependency(b, leaf);
-    for (const dep of dependents) tracker.addDependency(leaf, dep);
-  }
-  tracker.updateNodeStatus(taskId, "completed", `split into ${leafIds.length} subtasks`);
-  return leafIds;
+// src/sdd-worktree-integration.ts
+function forgetTaskWorktree(state, taskId, opts = {}) {
+  state.taskWorktrees.delete(taskId);
+  state.taskCwds.delete(taskId);
+  if (!opts.keepBranchLabel) state.taskBranches.delete(taskId);
 }
-
-// src/sdd-task-decomposer.ts
-var SddTaskDecomposer = class {
-  constructor(tracker, _graph, opts = {}) {
-    this.tracker = tracker;
-    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
-  }
-  tracker;
-  slots;
-  wave = 0;
-  // -------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------
-  /**
-   * Return the next batch of runnable tasks.
-   * Returns `allDone: true` when every node is completed.
-   * Returns `deadlocked: true` when no batch can be produced because
-   * all remaining tasks are blocked by failed nodes.
-   */
-  nextBatch() {
-    if (this.isDone()) {
-      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
-    }
-    const pending = this.pendingReadyNodes();
-    if (pending.length === 0) {
-      const hasBlockedTasks = this.hasAnyBlockedTasks();
-      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
-    }
-    const batch = pending.slice(0, this.slots);
-    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
-  }
-  /**
-   * Advance the wave counter after a batch completes.
-   * Call this once per `nextBatch()` result that was fan-out.
-   */
-  acknowledgeBatch(_completedTaskIds) {
-    this.wave++;
-  }
-  /**
-   * True when every node in the graph is completed.
-   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
-   */
-  isDone() {
-    const progress = this.tracker.getProgress();
-    return progress.total > 0 && progress.completed === progress.total;
-  }
-  /**
-   * Total waves produced so far.
-   */
-  getWaveCount() {
-    return this.wave;
-  }
-  /**
-   * All ready (dependency-satisfied) pending tasks, priority-sorted — UNSLICED.
-   * The continuous scheduler fills its own free slots from this list, so unlike
-   * `nextBatch()` it does not cap at `slots`.
-   */
-  readyNodes() {
-    return this.pendingReadyNodes();
-  }
-  /**
-   * True when every node has reached a terminal state (completed or failed).
-   * This — not `isDone()` (which requires ALL completed) — is the correct loop
-   * exit for the continuous scheduler: a terminally-failed task must not keep
-   * the run spinning to its backstop.
-   */
-  isSettled() {
-    const nodes = this.tracker.getAllNodes();
-    return nodes.length > 0 && nodes.every((n) => n.status === "completed" || n.status === "failed");
-  }
-  // -------------------------------------------------------------------
-  // Internal helpers
-  // -------------------------------------------------------------------
-  /**
-   * Return pending nodes whose blockers are all completed.
-   * Sorted by priority (critical first), then by creation time.
-   */
-  pendingReadyNodes() {
-    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
-    const ready = [];
-    for (const node of allPending) {
-      if (this.tracker.canStart(node.id)) {
-        ready.push(node);
-      }
-    }
-    const priorityRank = {
-      critical: 0,
-      high: 1,
-      medium: 2,
-      low: 3
-    };
-    ready.sort((a, b) => {
-      const pr = priorityRank[a.priority] - priorityRank[b.priority];
-      if (pr !== 0) return pr;
-      return a.createdAt - b.createdAt;
-    });
-    return ready;
-  }
-  /** True when non-completed, non-failed tasks remain blocked and cannot make progress. */
-  hasAnyBlockedTasks() {
-    const nodes = this.tracker.getAllNodes({
-      status: ["pending", "in_progress", "blocked"]
-    });
-    if (nodes.some((n) => n.status === "in_progress")) {
-      return false;
-    }
-    return nodes.some((n) => n.status === "blocked" || n.status === "pending");
-  }
-};
-
-// src/sdd-worktree-integration.ts
-function forgetTaskWorktree(state, taskId, opts = {}) {
-  state.taskWorktrees.delete(taskId);
-  state.taskCwds.delete(taskId);
-  if (!opts.keepBranchLabel) state.taskBranches.delete(taskId);
-}
-async function allocateTaskWorktrees(opts, state, tasks) {
-  const wt = opts.worktrees;
-  if (!wt) return;
-  for (const task of tasks) {
-    if (state.taskWorktrees.has(task.id)) continue;
-    try {
-      const handle = await wt.allocate(`sdd-${task.id}`, {
-        slugHint: task.title,
-        ownerLabel: task.title
-      });
-      if (handle.status === "active") {
-        state.taskWorktrees.set(task.id, handle);
-        state.taskCwds.set(task.id, handle.dir);
-        state.taskBranches.set(task.id, handle.branch);
-        const node = opts.tracker.getNode(task.id);
-        if (node) node.metadata = { ...node.metadata, worktreeBranch: handle.branch };
-      }
-    } catch {
+async function allocateTaskWorktrees(opts, state, tasks) {
+  const wt = opts.worktrees;
+  if (!wt) return;
+  for (const task of tasks) {
+    if (state.taskWorktrees.has(task.id)) continue;
+    try {
+      const handle = await wt.allocate(`sdd-${task.id}`, {
+        slugHint: task.title,
+        ownerLabel: task.title
+      });
+      if (handle.status === "active") {
+        state.taskWorktrees.set(task.id, handle);
+        state.taskCwds.set(task.id, handle.dir);
+        state.taskBranches.set(task.id, handle.branch);
+        const node = opts.tracker.getNode(task.id);
+        if (node) node.metadata = { ...node.metadata, worktreeBranch: handle.branch };
+      }
+    } catch {
     }
   }
 }
@@ -3610,15 +3738,19 @@ async function integrateTaskWorktree(params) {
     await wt.release(handle, { keep: false }).catch(() => {
     });
     forgetTaskWorktree(state, task.id, { keepBranchLabel: true });
-    return { ok: false, conflictFiles: res.conflictFiles ?? [] };
+    return {
+      ok: false,
+      conflictFiles: res.conflictFiles ?? [],
+      ...res.conflict ? {} : { reason: res.stderr?.trim() || "worktree merge failed" }
+    };
   } catch {
     forgetTaskWorktree(state, task.id);
     return { ok: false, conflictFiles: [] };
   }
 }
 
-// src/sdd-parallel-run.ts
-var SddParallelRun = class {
+// src/sdd-parallel-run-state.ts
+var SddParallelRunState = class {
   constructor(opts) {
     this.opts = opts;
     this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 2));
@@ -3697,6 +3829,15 @@ var SddParallelRun = class {
   /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
   dispatchSeq = 0;
   round = 0;
+  /**
+   * True once `run()` has returned. A FINISHED run is not "running" even when
+   * the graph is left unsettled (deadlock exit): `isRunning()` gates
+   * `cleanupWorktrees()` / `rollback()` / the Ctrl+C ladders, and a returned
+   * run kept reporting live, silently no-oping cleanup and refusing rollback
+   * with "run still active" until the user called `stop()` on a run that had
+   * already ended. Cleared again at the top of `run()` so a re-run re-arms.
+   */
+  runReturned = false;
   /** Type-safe emit on the optional EventBus (no-op when unwired). */
   emit(event, payload) {
     const sessionId = this.currentSessionId();
@@ -3709,16 +3850,259 @@ var SddParallelRun = class {
     const value = typeof this.sessionIdSource === "function" ? this.sessionIdSource() : this.sessionIdSource;
     return requireSessionId(value, "SDD session operation");
   }
+  paused = false;
+  /** Resolvers for tasks parked in `waitWhilePaused`, woken on resume/stop. */
+  pausedWaiters = /* @__PURE__ */ new Set();
+  notifyPausedWaiters() {
+    for (const resolve3 of this.pausedWaiters) resolve3();
+    this.pausedWaiters.clear();
+  }
+  async waitWhilePaused() {
+    while (this.paused && !this.stopRequested) {
+      await new Promise((resolve3) => {
+        this.pausedWaiters.add(resolve3);
+        const safety = setTimeout(() => {
+          if (this.pausedWaiters.delete(resolve3)) resolve3();
+        }, 1e3);
+        safety.unref?.();
+      });
+    }
+  }
+  /**
+   * Compute the blocking chains for a deadlock: every still-incomplete task and
+   * the blockers (by node id) that are NOT completed. Failed blockers are
+   * included since they're the usual deadlock cause once retries are exhausted.
+   */
+  computeDeadlockChains() {
+    return computeDeadlockChains(this.sddTaskRecoveryHost());
+  }
+  /** Requeue failed tasks that block an incomplete dependent. Returns true if any. */
+  recoverFailedBlockers() {
+    return recoverFailedBlockers(this.sddTaskRecoveryHost());
+  }
+  /**
+   * Requeue every terminal-failed task that the user did NOT cancel, giving each
+   * a fresh `maxRetries` budget. Shared by the automatic end-of-run sweep and
+   * the manual "retry all failed" control. Returns the number requeued.
+   */
+  requeueFailedTasks(reason = "retry failed sweep") {
+    return requeueFailedTasks(this.sddTaskRecoveryHost(), reason);
+  }
+  /** Restore per-task retry counts persisted in node metadata (resume support). */
+  restoreRetryMap() {
+    restoreRetryMap(this.sddTaskRecoveryHost());
+  }
+  /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
+  async teardown() {
+    for (const node of this.opts.tracker.getAllNodes({ status: ["in_progress"] })) {
+      this.opts.tracker.updateNodeStatus(node.id, "pending", "run stopped");
+    }
+    const wt = this.opts.worktrees;
+    if (wt) {
+      for (const [taskId, handle] of [...this.taskWorktrees]) {
+        await wt.release(handle, { keep: true }).catch(() => {
+        });
+        this.forgetWorktree(taskId);
+      }
+    }
+  }
+  /**
+   * Hard-stop the run after an unrecoverable error: the base branch is in a
+   * state no retry can fix (e.g. a known-invalid merge that could not be rolled
+   * back), so continuing would contaminate every task forked after this point.
+   * The reason is surfaced on `run()`'s result and the `sdd.run.finished` event.
+   */
+  abortRun(reason) {
+    this.fatalError = reason;
+    this.stopRequested = true;
+    this.coordinator?.stopAll();
+  }
+  // -------------------------------------------------------------------
+  // Internal
+  // -------------------------------------------------------------------
+  buildCoordinator() {
+    const config = {
+      coordinatorId: `sdd-parallel-${randomUUID3().slice(0, 8)}`,
+      maxConcurrent: this.slots,
+      doneCondition: { type: "all_tasks_done" },
+      // Default budget guard for every spawned worker: idle reaper (resets on
+      // activity) plus the opt-in wall-clock cap when one was configured. This
+      // ensures the reaper applies even if a per-spawn config path is bypassed.
+      defaultBudget: {
+        idleTimeoutMs: this.idleTimeoutMs,
+        ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
+      }
+    };
+    this.coordinator = new DefaultMultiAgentCoordinator(config, {
+      sessionId: () => this.currentSessionId()
+    });
+    const baseFactory = this.opts.subagentFactory ?? this.defaultFactory();
+    const filteredFactory = withDisabledToolFiltering(baseFactory);
+    const runner = makeAgentSubagentRunner({
+      factory: filteredFactory,
+      hostEvents: this.events
+    });
+    this.coordinator.setRunner?.(runner);
+  }
+  defaultFactory() {
+    return async (_config) => ({
+      agent: this.opts.agent,
+      events: this.opts.agent.events
+    });
+  }
+  /**
+   * Apply a task failure: retry (→ pending, bump retry count) while attempts
+   * remain, else consult the optional supervisor (which can rescue via
+   * retry/reassign/split), else terminal-fail (→ failed). Shared by the
+   * worker-failure, verification-gate, and merge-conflict paths so all three
+   * negotiate the same retry budget and emit the same events.
+   */
+  async applyTaskFailure(taskId, subagentId, errMsg) {
+    return applyTaskFailure.call(this.sddTaskDispatchHost(), taskId, subagentId, errMsg);
+  }
+  /**
+   * Consult `superviseFailure` for a task that has exhausted its retries.
+   * Applies the verdict (retry / reassign+retry / split) and returns true when
+   * the task was rescued (caller must NOT terminal-fail it). Bounded per task by
+   * `maxSupervisorEscalations` so an always-"retry" supervisor can't loop forever.
+   */
+  async trySupervisorRescue(taskId, errMsg) {
+    return trySupervisorRescue.call(this.sddTaskDispatchHost(), taskId, errMsg);
+  }
+  /**
+   * Integrate a verified-successful task's worktree into the base branch.
+   * Commits, squash-merges (optionally running `conflictResolver` first), and on
+   * success releases the worktree. On an UNRESOLVED conflict it returns
+   * `{ok:false}` with the conflicting files so the caller routes the task into
+   * the failure path (a retry forks a fresh worktree off the now-advanced base,
+   * which usually clears the conflict). No-op `{ok:true}` when worktrees are
+   * disabled or none was allocated for this task. Never throws — a merge hiccup
+   * degrades to a (retryable) failure rather than wedging the run.
+   */
+  get worktreeState() {
+    return {
+      taskCwds: this.taskCwds,
+      taskBranches: this.taskBranches,
+      taskWorktrees: this.taskWorktrees,
+      mergedCommits: this.mergedCommits
+    };
+  }
+  async integrateWorktree(task, result) {
+    return integrateTaskWorktree({
+      opts: this.opts,
+      state: this.worktreeState,
+      task,
+      result,
+      runId: this.runId,
+      emit: this.emit.bind(this),
+      abortRun: this.abortRun.bind(this)
+    });
+  }
+  /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
+  async allocateWorktrees(tasks) {
+    await allocateTaskWorktrees(this.opts, this.worktreeState, tasks);
+  }
+  /**
+   * Resolve each task's worktree after its result is known. Serialized merges
+   * (one at a time) keep the base branch consistent; the wave structure already
+   * guarantees dependency order (a task's blockers merged in an earlier wave).
+   */
+  async resolveWorktrees(tasks) {
+    await resolveTaskWorktrees(this.opts, this.worktreeState, tasks);
+  }
+  forgetWorktree(taskId, opts = {}) {
+    forgetTaskWorktree(this.worktreeState, taskId, opts);
+  }
+  /** Persist a task's retry count into node metadata (survives crash → resume). */
+  persistRetries(taskId, retries) {
+    const node = this.opts.tracker.getNode(taskId);
+    if (node) node.metadata = { ...node.metadata, retries };
+  }
+  buildProgress() {
+    const gp = this.opts.tracker.getProgress();
+    const isDeadlocked = !this.decomposer.isDone() && this.decomposer.nextBatch().deadlocked;
+    return {
+      wave: this.decomposer.getWaveCount(),
+      total: gp.total,
+      completed: gp.completed,
+      inProgress: gp.inProgress,
+      failed: gp.failed,
+      blocked: gp.blocked,
+      pending: gp.pending,
+      percent: gp.percentComplete,
+      deadlocked: isDeadlocked
+    };
+  }
+  sddTaskRecoveryHost() {
+    const self = this;
+    return {
+      opts: self.opts,
+      get retryMap() {
+        return self.retryMap;
+      },
+      persistRetries: (...args) => this.persistRetries(...args),
+      get cancelledTasks() {
+        return self.cancelledTasks;
+      },
+      emit: (...args) => this.emit(...args),
+      runId: this.runId,
+      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;
+  }
+  sddParallelControlsHost() {
+    void {
+      isRunning: this.isRunning,
+      opts: this.opts,
+      taskWorktrees: this.taskWorktrees,
+      forgetWorktree: this.forgetWorktree,
+      baseBranch: this.baseBranch,
+      mergedCommits: this.mergedCommits,
+      retryMap: this.retryMap,
+      persistRetries: this.persistRetries,
+      cancelledTasks: this.cancelledTasks,
+      emit: this.emit,
+      runId: this.runId,
+      taskSubagents: this.taskSubagents,
+      coordinator: this.coordinator
+    };
+    return this;
+  }
+};
+
+// src/sdd-parallel-run.ts
+var SddParallelRun = class extends SddParallelRunState {
   // -------------------------------------------------------------------
   // Public API
   // -------------------------------------------------------------------
-  paused = false;
-  /** Resolvers for tasks parked in `waitWhilePaused`, woken on resume/stop. */
-  pausedWaiters = /* @__PURE__ */ new Set();
-  notifyPausedWaiters() {
-    for (const resolve3 of this.pausedWaiters) resolve3();
-    this.pausedWaiters.clear();
-  }
   /** Trigger stop — causes run() to abort after the current wave. */
   stop() {
     this.stopRequested = true;
@@ -3738,7 +4122,7 @@ var SddParallelRun = class {
     return this.paused;
   }
   isRunning() {
-    return !this.stopRequested && !this.decomposer.isSettled();
+    return !this.stopRequested && !this.runReturned && !this.decomposer.isSettled();
   }
   /** Base branch the run's squash commits land on (undefined when worktrees off). */
   getBaseBranch() {
@@ -3755,16 +4139,7 @@ var SddParallelRun = class {
    * (0 when worktrees are disabled). Idempotent.
    */
   async cleanupWorktrees() {
-    if (this.isRunning()) return 0;
-    const wt = this.opts.worktrees;
-    if (!wt) return 0;
-    for (const [taskId, handle] of [...this.taskWorktrees]) {
-      await wt.release(handle, { keep: false }).catch(() => {
-      });
-      this.forgetWorktree(taskId);
-    }
-    const { removed } = await wt.cleanupAllManaged();
-    return removed;
+    return cleanupWorktrees(this.sddParallelControlsHost());
   }
   /**
    * Undo the run's merged commits by reverting each on the base branch (history
@@ -3772,32 +4147,15 @@ var SddParallelRun = class {
    * revert outcome; a dirty tree or revert conflict surfaces as `ok:false`.
    */
   async rollback() {
-    if (this.isRunning())
-      return { ok: false, reverted: 0, reason: "run still active \u2014 stop it first" };
-    const wt = this.opts.worktrees;
-    if (!wt || !this.baseBranch) {
-      return { ok: false, reverted: 0, reason: "no worktree run to roll back" };
-    }
-    return wt.revertCommits(
-      this.baseBranch,
-      this.mergedCommits.map((c) => c.sha)
-    );
+    return rollback(this.sddParallelControlsHost());
   }
   /** Requeue a task to `pending` so the scheduler re-runs it (clears retries + cancel marker). */
   retryTask(taskId) {
-    if (!this.opts.tracker.getNode(taskId)) return false;
-    this.retryMap.delete(taskId);
-    this.persistRetries(taskId, 0);
-    this.cancelledTasks.delete(taskId);
-    this.opts.tracker.patchMetadata(taskId, { cancelled: void 0 });
-    this.opts.tracker.updateNodeStatus(taskId, "pending", "manual retry");
-    return true;
+    return retryTask(this.sddParallelControlsHost(), taskId);
   }
   /** Reassign a task to a specific agent name (reflected on the board). */
   reassignTask(taskId, agentName) {
-    if (!this.opts.tracker.getNode(taskId)) return false;
-    this.opts.tracker.updateNode(taskId, { assignee: agentName });
-    return true;
+    return reassignTask(this.sddParallelControlsHost(), taskId, agentName);
   }
   /**
    * Set/override a task's worker model (and optionally provider) — applied on its
@@ -3805,18 +4163,11 @@ var SddParallelRun = class {
    * assignment lives on node metadata so it survives crash → resume.
    */
   setTaskModel(taskId, model, provider) {
-    if (!this.opts.tracker.getNode(taskId)) return false;
-    this.opts.tracker.patchMetadata(taskId, {
-      model,
-      ...provider !== void 0 ? { provider } : {}
-    });
-    return true;
+    return setTaskModel(this.sddParallelControlsHost(), taskId, model, provider);
   }
   /** Set/override a task's fallback model chain (applied on its next dispatch). */
   setTaskFallbacks(taskId, fallbackModels) {
-    if (!this.opts.tracker.getNode(taskId)) return false;
-    this.opts.tracker.patchMetadata(taskId, { fallbackModels });
-    return true;
+    return setTaskFallbacks(this.sddParallelControlsHost(), taskId, fallbackModels);
   }
   /**
    * Set/override a task's verification command (the completion gate runs it in
@@ -3824,10 +4175,7 @@ var SddParallelRun = class {
    * clears it. Applied on the task's next verification — i.e. its next dispatch.
    */
   setTaskVerification(taskId, verificationCommand) {
-    if (!this.opts.tracker.getNode(taskId)) return false;
-    const cmd = verificationCommand?.trim();
-    this.opts.tracker.patchMetadata(taskId, { verificationCommand: cmd ? cmd : void 0 });
-    return true;
+    return setTaskVerification(this.sddParallelControlsHost(), taskId, verificationCommand);
   }
   /**
    * Cancel a task. If it is currently running, abort its subagent and mark the
@@ -3836,24 +4184,7 @@ var SddParallelRun = class {
    * `retryTask` to bring a cancelled task back. Returns false for an unknown task.
    */
   async cancelTask(taskId) {
-    const node = this.opts.tracker.getNode(taskId);
-    if (!node) return false;
-    if (node.status === "completed") return false;
-    this.cancelledTasks.add(taskId);
-    this.opts.tracker.patchMetadata(taskId, { cancelled: true });
-    this.opts.tracker.updateNodeStatus(taskId, "failed", "cancelled by user");
-    this.emit("sdd.task.failed", {
-      runId: this.runId,
-      taskId,
-      subagentId: "",
-      error: "cancelled by user"
-    });
-    const subagentId = this.taskSubagents.get(taskId);
-    if (subagentId && this.coordinator) {
-      await this.coordinator.stop(subagentId).catch(() => {
-      });
-    }
-    return true;
+    return cancelTask(this.sddParallelControlsHost(), taskId);
   }
   /**
    * Delete a not-yet-started task from the graph (pending/blocked/failed only —
@@ -3861,12 +4192,7 @@ var SddParallelRun = class {
    * touching it; dependents lose this blocker. Returns false if missing or running.
    */
   deleteTask(taskId) {
-    const node = this.opts.tracker.getNode(taskId);
-    if (!node) return false;
-    if (node.status === "in_progress" || this.taskSubagents.has(taskId)) return false;
-    this.cancelledTasks.delete(taskId);
-    this.retryMap.delete(taskId);
-    return this.opts.tracker.removeNode(taskId);
+    return deleteTask(this.sddParallelControlsHost(), taskId);
   }
   /**
    * Split a task into sub-tasks and delegate them to separate workers. The new
@@ -3878,25 +4204,7 @@ var SddParallelRun = class {
    * The scheduler picks the new pending leaves up on its next dispatch pass.
    */
   splitTask(taskId, subtasks) {
-    const leafIds = splitGraphNode(this.opts.tracker, taskId, subtasks, {
-      isRunning: (id) => this.taskSubagents.has(id)
-    });
-    if (!leafIds.length) return [];
-    this.retryMap.delete(taskId);
-    this.persistRetries(taskId, 0);
-    this.emit("sdd.task.split", { runId: this.runId, taskId, subtaskIds: leafIds });
-    return leafIds;
-  }
-  async waitWhilePaused() {
-    while (this.paused && !this.stopRequested) {
-      await new Promise((resolve3) => {
-        this.pausedWaiters.add(resolve3);
-        const safety = setTimeout(() => {
-          if (this.pausedWaiters.delete(resolve3)) resolve3();
-        }, 1e3);
-        safety.unref?.();
-      });
-    }
+    return splitTask(this.sddParallelControlsHost(), taskId, subtasks);
   }
   /**
    * Continuous dependency-driven execution. Unlike a wave-barrier loop (where a
@@ -3913,6 +4221,7 @@ var SddParallelRun = class {
     const startTime = Date.now();
     this.round = 0;
     this.dispatchSeq = 0;
+    this.runReturned = false;
     let totalDispatched = 0;
     this.buildCoordinator();
     if (this.opts.worktrees && !this.baseBranch) {
@@ -4018,6 +4327,7 @@ var SddParallelRun = class {
       stopped: this.stopRequested,
       ...this.fatalError ? { fatalError: this.fatalError } : {}
     });
+    this.runReturned = true;
     return {
       totalWaves: this.round,
       totalCompleted: finalProgress.completed,
@@ -4029,26 +4339,6 @@ var SddParallelRun = class {
       finalProgress
     };
   }
-  /**
-   * Compute the blocking chains for a deadlock: every still-incomplete task and
-   * the blockers (by node id) that are NOT completed. Failed blockers are
-   * included since they're the usual deadlock cause once retries are exhausted.
-   */
-  computeDeadlockChains() {
-    return computeDeadlockChains(this.sddTaskRecoveryHost());
-  }
-  /** Requeue failed tasks that block an incomplete dependent. Returns true if any. */
-  recoverFailedBlockers() {
-    return recoverFailedBlockers(this.sddTaskRecoveryHost());
-  }
-  /**
-   * Requeue every terminal-failed task that the user did NOT cancel, giving each
-   * a fresh `maxRetries` budget. Shared by the automatic end-of-run sweep and
-   * the manual "retry all failed" control. Returns the number requeued.
-   */
-  requeueFailedTasks(reason = "retry failed sweep") {
-    return requeueFailedTasks(this.sddTaskRecoveryHost(), reason);
-  }
   /**
    * Manually requeue all failed tasks to `pending` (board "Retry all failed").
    * Unlike the automatic sweep this also clears any `cancelled` marker, so a
@@ -4064,10 +4354,6 @@ var SddParallelRun = class {
     }
     return this.requeueFailedTasks("manual retry all");
   }
-  /** Restore per-task retry counts persisted in node metadata (resume support). */
-  restoreRetryMap() {
-    restoreRetryMap(this.sddTaskRecoveryHost());
-  }
   /**
    * Reset orphaned `in_progress` tasks (no agent runs them after a crash) back
    * to `pending` so a fresh run re-executes them. Call before constructing a run
@@ -4076,64 +4362,6 @@ var SddParallelRun = class {
   static resetOrphans(tracker) {
     return resetOrphans(tracker);
   }
-  /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
-  async teardown() {
-    for (const node of this.opts.tracker.getAllNodes({ status: ["in_progress"] })) {
-      this.opts.tracker.updateNodeStatus(node.id, "pending", "run stopped");
-    }
-    const wt = this.opts.worktrees;
-    if (wt) {
-      for (const [taskId, handle] of [...this.taskWorktrees]) {
-        await wt.release(handle, { keep: true }).catch(() => {
-        });
-        this.forgetWorktree(taskId);
-      }
-    }
-  }
-  /**
-   * Hard-stop the run after an unrecoverable error: the base branch is in a
-   * state no retry can fix (e.g. a known-invalid merge that could not be rolled
-   * back), so continuing would contaminate every task forked after this point.
-   * The reason is surfaced on `run()`'s result and the `sdd.run.finished` event.
-   */
-  abortRun(reason) {
-    this.fatalError = reason;
-    this.stopRequested = true;
-    this.coordinator?.stopAll();
-  }
-  // -------------------------------------------------------------------
-  // Internal
-  // -------------------------------------------------------------------
-  buildCoordinator() {
-    const config = {
-      coordinatorId: `sdd-parallel-${randomUUID3().slice(0, 8)}`,
-      maxConcurrent: this.slots,
-      doneCondition: { type: "all_tasks_done" },
-      // Default budget guard for every spawned worker: idle reaper (resets on
-      // activity) plus the opt-in wall-clock cap when one was configured. This
-      // ensures the reaper applies even if a per-spawn config path is bypassed.
-      defaultBudget: {
-        idleTimeoutMs: this.idleTimeoutMs,
-        ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
-      }
-    };
-    this.coordinator = new DefaultMultiAgentCoordinator(config, {
-      sessionId: () => this.currentSessionId()
-    });
-    const baseFactory = this.opts.subagentFactory ?? this.defaultFactory();
-    const filteredFactory = withDisabledToolFiltering(baseFactory);
-    const runner = makeAgentSubagentRunner({
-      factory: filteredFactory,
-      hostEvents: this.events
-    });
-    this.coordinator.setRunner?.(runner);
-  }
-  defaultFactory() {
-    return async (_config) => ({
-      agent: this.opts.agent,
-      events: this.opts.agent.events
-    });
-  }
   /**
    * Execute a batch of tasks together. Retained as a thin wrapper over the
    * single-task primitive `executeOne` so the wave-oriented tests and any
@@ -4154,136 +4382,6 @@ var SddParallelRun = class {
   async executeOne(task) {
     return executeOne.call(this.sddTaskDispatchHost(), task);
   }
-  /**
-   * Apply a task failure: retry (→ pending, bump retry count) while attempts
-   * remain, else consult the optional supervisor (which can rescue via
-   * retry/reassign/split), else terminal-fail (→ failed). Shared by the
-   * worker-failure, verification-gate, and merge-conflict paths so all three
-   * negotiate the same retry budget and emit the same events.
-   */
-  async applyTaskFailure(taskId, subagentId, errMsg) {
-    return applyTaskFailure.call(this.sddTaskDispatchHost(), taskId, subagentId, errMsg);
-  }
-  /**
-   * Consult `superviseFailure` for a task that has exhausted its retries.
-   * Applies the verdict (retry / reassign+retry / split) and returns true when
-   * the task was rescued (caller must NOT terminal-fail it). Bounded per task by
-   * `maxSupervisorEscalations` so an always-"retry" supervisor can't loop forever.
-   */
-  async trySupervisorRescue(taskId, errMsg) {
-    return trySupervisorRescue.call(this.sddTaskDispatchHost(), taskId, errMsg);
-  }
-  /**
-   * Integrate a verified-successful task's worktree into the base branch.
-   * Commits, squash-merges (optionally running `conflictResolver` first), and on
-   * success releases the worktree. On an UNRESOLVED conflict it returns
-   * `{ok:false}` with the conflicting files so the caller routes the task into
-   * the failure path (a retry forks a fresh worktree off the now-advanced base,
-   * which usually clears the conflict). No-op `{ok:true}` when worktrees are
-   * disabled or none was allocated for this task. Never throws — a merge hiccup
-   * degrades to a (retryable) failure rather than wedging the run.
-   */
-  get worktreeState() {
-    return {
-      taskCwds: this.taskCwds,
-      taskBranches: this.taskBranches,
-      taskWorktrees: this.taskWorktrees,
-      mergedCommits: this.mergedCommits
-    };
-  }
-  async integrateWorktree(task, result) {
-    return integrateTaskWorktree({
-      opts: this.opts,
-      state: this.worktreeState,
-      task,
-      result,
-      runId: this.runId,
-      emit: this.emit.bind(this),
-      abortRun: this.abortRun.bind(this)
-    });
-  }
-  /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
-  async allocateWorktrees(tasks) {
-    await allocateTaskWorktrees(this.opts, this.worktreeState, tasks);
-  }
-  /**
-   * Resolve each task's worktree after its result is known. Serialized merges
-   * (one at a time) keep the base branch consistent; the wave structure already
-   * guarantees dependency order (a task's blockers merged in an earlier wave).
-   */
-  async resolveWorktrees(tasks) {
-    await resolveTaskWorktrees(this.opts, this.worktreeState, tasks);
-  }
-  forgetWorktree(taskId, opts = {}) {
-    forgetTaskWorktree(this.worktreeState, taskId, opts);
-  }
-  /** Persist a task's retry count into node metadata (survives crash → resume). */
-  persistRetries(taskId, retries) {
-    const node = this.opts.tracker.getNode(taskId);
-    if (node) node.metadata = { ...node.metadata, retries };
-  }
-  buildProgress() {
-    const gp = this.opts.tracker.getProgress();
-    const isDeadlocked = !this.decomposer.isDone() && this.decomposer.nextBatch().deadlocked;
-    return {
-      wave: this.decomposer.getWaveCount(),
-      total: gp.total,
-      completed: gp.completed,
-      inProgress: gp.inProgress,
-      failed: gp.failed,
-      blocked: gp.blocked,
-      pending: gp.pending,
-      percent: gp.percentComplete,
-      deadlocked: isDeadlocked
-    };
-  }
-  sddTaskRecoveryHost() {
-    const self = this;
-    return {
-      get opts() {
-        return self.opts;
-      },
-      get retryMap() {
-        return self.retryMap;
-      },
-      persistRetries: (...args) => this.persistRetries(...args),
-      get cancelledTasks() {
-        return self.cancelledTasks;
-      },
-      emit: (...args) => this.emit(...args),
-      runId: this.runId,
-      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
@@ -5022,7 +5120,7 @@ function templateToMarkdown(template, title) {
 
 // src/task-visualizer.ts
 import { computeTaskProgress as computeTaskProgress2 } from "@wrongstack/core/tasking";
-import { expectDefined as expectDefined4, truncate } from "@wrongstack/core/utils";
+import { expectDefined as expectDefined5, truncate } from "@wrongstack/core/utils";
 var STATUS_ICON = {
   pending: "\u25CB",
   in_progress: "\u25D0",
@@ -5092,7 +5190,7 @@ function renderTaskGraph(graph, opts) {
 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));
+  const node = expectDefined5(graph.nodes.get(nodeId));
   const icon = STATUS_ICON[node.status];
   const prioIcon = PRIORITY_ICON[node.priority];
   const typeIcon = TYPE_ICON[node.type];
@@ -5182,7 +5280,7 @@ function renderSpecAnalysis(spec, analysis) {
 
 // src/critical-path.ts
 import { topologicalSort } from "@wrongstack/core/tasking";
-import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
+import { expectDefined as expectDefined6 } from "@wrongstack/core/utils";
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -5261,7 +5359,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = expectDefined5(queue.shift());
+    const current = expectDefined6(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -5307,7 +5405,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = expectDefined5(allIds[0]);
+  let maxId = expectDefined6(allIds[0]);
   for (const id of allIds) {
     const d = dist.get(id);
     if (d > maxDist) {
@@ -5350,7 +5448,7 @@ function computeParallelGroups(graph, blockedByMap) {
       }
     }
     if (group.length === 0) {
-      group.push(expectDefined5(Array.from(remaining)[0]));
+      group.push(expectDefined6(Array.from(remaining)[0]));
     }
     for (const id of group) {
       assigned.add(id);