@wrongstack/sdd 0.295.0 → 0.296.2

package/dist/index.js

@@ -57,13 +57,13 @@ var SpecParser = class {
       if (h2) {
         if (currentSection && currentLines.length > 0) {
           sections.push({
-            type: this.mapSectionType(currentSection.title ?? "unknown"),
-            title: currentSection.title ?? "Unknown",
+            type: this.mapSectionType(currentSection.title),
+            title: currentSection.title,
             level: depth,
             content: currentLines.join("\n").trim()
           });
         }
-        currentSection = { title: h2[1] ?? "Unknown" };
+        currentSection = { title: h2[1] };
         currentLines = [];
         depth = 2;
         continue;
@@ -78,8 +78,8 @@ var SpecParser = class {
     }
     if (currentSection && currentLines.length > 0) {
       sections.push({
-        type: this.mapSectionType(currentSection.title ?? "unknown"),
-        title: currentSection.title ?? "Unknown",
+        type: this.mapSectionType(currentSection.title),
+        title: currentSection.title,
         level: depth,
         content: currentLines.join("\n").trim()
       });
@@ -227,6 +227,39 @@ var SpecParser = class {
 };
 
 // src/task-generator.ts
+import { assessAtomicity } from "@wrongstack/kanban";
+var OVERVIEW_ESTIMATE_HOURS = 4;
+var REQUIREMENT_ESTIMATE_HOURS = {
+  critical: 8,
+  high: 4,
+  medium: 2,
+  low: 1
+};
+var API_PARENT_ESTIMATE_HOURS = 0;
+var API_BASE_ESTIMATE_HOURS = 2;
+var TESTS_ESTIMATE_HOURS = 4;
+var DOCS_ESTIMATE_HOURS = 2;
+function assessGeneratedTaskAtomicity(task, config) {
+  const criteria = task.acceptanceCriteria ?? [];
+  const assessment = assessAtomicity(
+    {
+      title: task.title,
+      description: task.description,
+      estimatedHours: task.estimateHours,
+      // Graph edges are wired after generation; fan-in is unknown here.
+      dependencyCount: 0,
+      successCriteriaCount: criteria.length,
+      hasVerifiableOutput: extractVerificationCommand(criteria) !== void 0,
+      childCount: 0
+    },
+    config
+  );
+  return {
+    verdict: assessment.verdict,
+    score: assessment.score,
+    reasons: assessment.criteria.filter((c) => c.score < 1).map((c) => c.reason)
+  };
+}
 function extractVerificationCommand(criteria) {
   const marker = /^\s*(?:\$\s+|(?:run|verify|cmd)\s*:\s*)(.+\S)\s*$/i;
   for (const c of criteria) {
@@ -240,17 +273,29 @@ var TaskGenerator = class {
     this.opts = opts;
   }
   opts;
+  /** metadata.atomicity payload when the option is enabled, else undefined. */
+  atomicityMetadata(task) {
+    if (!this.opts.atomicity) return void 0;
+    return { atomicity: assessGeneratedTaskAtomicity(task, this.opts.atomicity.config) };
+  }
   async generateFromSpec(spec) {
     const graph = await this.opts.taskTracker.createGraph(spec.id, spec.title);
     const overviewSection = spec.sections?.find((s) => s.type === "overview");
     if (overviewSection?.content) {
-      this.opts.taskTracker.addNode({
+      const overview = {
         title: `Implement: ${spec.title}`,
         description: overviewSection.content,
+        estimateHours: OVERVIEW_ESTIMATE_HOURS
+      };
+      const metadata = this.atomicityMetadata(overview);
+      this.opts.taskTracker.addNode({
+        title: overview.title,
+        description: overview.description,
         type: "feature",
         priority: "high",
         status: "pending",
-        estimateHours: 4
+        estimateHours: overview.estimateHours,
+        ...metadata ? { metadata } : {}
       });
     }
     const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
@@ -258,7 +303,7 @@ var TaskGenerator = class {
       (a, b) => (priorityOrder[a.priority] ?? 9) - (priorityOrder[b.priority] ?? 9)
     );
     for (const req of sorted) {
-      const estimateHours = req.priority === "critical" ? 8 : req.priority === "high" ? 4 : req.priority === "medium" ? 2 : 1;
+      const estimateHours = REQUIREMENT_ESTIMATE_HOURS[req.priority] ?? 1;
       const tags = [req.type, req.priority];
       const acLines = (req.acceptanceCriteria ?? []).map((ac) => `- ${ac}`).join("\n");
       const blockedLine = req.blockedBy?.length ? `
@@ -270,7 +315,14 @@ var TaskGenerator = class {
 
 **Acceptance Criteria:**
 ${acLines}` : "") + blockedLine;
-      const metadata = {};
+      const metadata = {
+        ...this.atomicityMetadata({
+          title: req.description,
+          description,
+          estimateHours,
+          acceptanceCriteria: req.acceptanceCriteria ?? []
+        })
+      };
       if (this.opts.verificationFromAcceptance) {
         const cmd = extractVerificationCommand(req.acceptanceCriteria ?? []);
         if (cmd) metadata.verificationCommand = cmd;
@@ -294,38 +346,58 @@ ${acLines}` : "") + blockedLine;
         type: "feature",
         priority: "high",
         status: "pending",
-        estimateHours: 0
+        estimateHours: API_PARENT_ESTIMATE_HOURS
       });
       for (const ep of spec.apiEndpoints) {
-        const baseHours = 2;
         const authHours = ep.auth ? 1 : 0;
         const reqHours = ep.request ? 1 : 0;
-        this.opts.taskTracker.addNode({
+        const endpoint = {
           title: `${ep.method} ${ep.path} \u2014 ${ep.description}`,
           description: `${ep.method} ${ep.path}: ${ep.description}`,
+          estimateHours: API_BASE_ESTIMATE_HOURS + authHours + reqHours
+        };
+        const metadata = this.atomicityMetadata(endpoint);
+        this.opts.taskTracker.addNode({
+          title: endpoint.title,
+          description: endpoint.description,
           type: "feature",
           priority: "medium",
           status: "pending",
-          estimateHours: baseHours + authHours + reqHours,
-          parentId: apiParent.id
+          estimateHours: endpoint.estimateHours,
+          parentId: apiParent.id,
+          ...metadata ? { metadata } : {}
         });
       }
     }
-    this.opts.taskTracker.addNode({
+    const testsTask = {
       title: "Write Tests",
       description: "Write comprehensive tests for the implemented features.",
+      estimateHours: TESTS_ESTIMATE_HOURS
+    };
+    const testsMetadata = this.atomicityMetadata(testsTask);
+    this.opts.taskTracker.addNode({
+      title: testsTask.title,
+      description: testsTask.description,
       type: "test",
       priority: "high",
       status: "pending",
-      estimateHours: 4
+      estimateHours: testsTask.estimateHours,
+      ...testsMetadata ? { metadata: testsMetadata } : {}
     });
-    this.opts.taskTracker.addNode({
+    const docsTask = {
       title: "Update Documentation",
       description: "Update project documentation to reflect the changes.",
+      estimateHours: DOCS_ESTIMATE_HOURS
+    };
+    const docsMetadata = this.atomicityMetadata(docsTask);
+    this.opts.taskTracker.addNode({
+      title: docsTask.title,
+      description: docsTask.description,
       type: "docs",
       priority: "low",
       status: "pending",
-      estimateHours: 2
+      estimateHours: docsTask.estimateHours,
+      ...docsMetadata ? { metadata: docsMetadata } : {}
     });
     return graph;
   }
@@ -356,8 +428,9 @@ import {
 } from "@wrongstack/core/tasking";
 
 // src/task-flow.ts
-import { SddError, ERROR_CODES } from "@wrongstack/core/types";
 import { DefaultTaskStore, TaskTracker } from "@wrongstack/core/tasking";
+import { ERROR_CODES, SddError } from "@wrongstack/core/types";
+import { expectDefined } from "@wrongstack/core/utils";
 var TaskFlow = class {
   constructor(opts) {
     this.opts = opts;
@@ -397,11 +470,12 @@ var TaskFlow = class {
     return this.graph;
   }
   async execute(ctx) {
-    if (!this.graph) throw new SddError({
-      message: "No graph loaded. Call fromSpec first.",
-      code: ERROR_CODES.SDD_INVALID_STATE,
-      context: { phase: this.phase }
-    });
+    if (!this.graph)
+      throw new SddError({
+        message: "No graph loaded. Call fromSpec first.",
+        code: ERROR_CODES.SDD_INVALID_STATE,
+        context: { phase: this.phase }
+      });
     this.setPhase("executing");
     this.stopped = false;
     const pendingTasks = this.getExecutableTasks();
@@ -412,9 +486,8 @@ var TaskFlow = class {
         batch.map((task) => this.executeSingleTask(task, ctx))
       );
       for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        const task = batch[i];
-        if (!result || !task) continue;
+        const result = expectDefined(results[i]);
+        const task = expectDefined(batch[i]);
         if (result.status === "rejected") {
           const reason = result.reason;
           this.opts.tracker.updateNodeStatus(task.id, "failed", reason?.message);
@@ -441,11 +514,12 @@ var TaskFlow = class {
   }
   async reviewTask(taskId, approved, comment) {
     const task = this.opts.tracker.getNode(taskId);
-    if (!task) throw new SddError({
-      message: `Task ${taskId} not found`,
-      code: ERROR_CODES.SDD_NOT_READY,
-      context: { taskId }
-    });
+    if (!task)
+      throw new SddError({
+        message: `Task ${taskId} not found`,
+        code: ERROR_CODES.SDD_NOT_READY,
+        context: { taskId }
+      });
     if (approved) {
       this.opts.tracker.updateNodeStatus(taskId, "completed", comment);
       this.emit("task.completed", { taskId });
@@ -474,7 +548,7 @@ var TaskFlow = class {
   getExecutableTasks() {
     return this.opts.tracker.getAllNodes({ status: ["pending", "blocked"] }).filter((n) => n.status === "pending" && this.opts.tracker.canStart(n.id)).sort((a, b) => {
       const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-      return (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4);
+      return priorityOrder[a.priority] - priorityOrder[b.priority];
     });
   }
   async executeSingleTask(task, ctx) {
@@ -792,14 +866,14 @@ function buildBoardTasks(graph) {
     return d;
   };
   const toTask = (n) => {
-    const deps = blockers.get(n.id) ?? [];
+    const deps = blockers.get(n.id);
     const allDepsDone = deps.every((b) => statusOf(b) === "completed");
     const meta = n.metadata ?? {};
     const cancelled = Boolean(meta["cancelled"]);
     const displayStatus = cancelled ? "cancelled" : n.status === "pending" && deps.length > 0 && allDepsDone ? "queued" : n.status;
     return {
       id: n.id,
-      shortId: shortId.get(n.id) ?? n.id.slice(0, 6),
+      shortId: shortId.get(n.id),
       title: n.title,
       description: n.description,
       status: n.status,
@@ -815,7 +889,9 @@ function buildBoardTasks(graph) {
       model: typeof meta["model"] === "string" ? meta["model"] : void 0,
       provider: typeof meta["provider"] === "string" ? meta["provider"] : void 0,
       fallbackModels: Array.isArray(meta["fallbackModels"]) ? meta["fallbackModels"] : void 0,
-      verificationCommand: typeof meta["verificationCommand"] === "string" ? meta["verificationCommand"] : void 0
+      verificationCommand: typeof meta["verificationCommand"] === "string" ? meta["verificationCommand"] : void 0,
+      verificationState: meta["verificationState"] === "passed" || meta["verificationState"] === "failed" ? meta["verificationState"] : void 0,
+      verificationDetail: typeof meta["verificationDetail"] === "string" ? meta["verificationDetail"] : void 0
     };
   };
   const tasks = nodes.map(toTask);
@@ -823,9 +899,9 @@ function buildBoardTasks(graph) {
   for (const n of nodes) {
     const d = depthOf(n.id);
     if (!byDepth.has(d)) byDepth.set(d, []);
-    byDepth.get(d)?.push(shortId.get(n.id) ?? n.id.slice(0, 6));
+    byDepth.get(d).push(shortId.get(n.id));
   }
-  const columns = [...byDepth.keys()].sort((a, b) => a - b).map((d) => ({ label: d === 0 ? "Start" : `Phase ${d}`, taskIds: byDepth.get(d) ?? [] }));
+  const columns = [...byDepth.keys()].sort((a, b) => a - b).map((d) => ({ label: d === 0 ? "Start" : `Phase ${d}`, taskIds: byDepth.get(d) }));
   return { tasks, columns };
 }
 function buildBoardSnapshot(graph, run, now) {
@@ -864,6 +940,7 @@ var SddBoardStore = class {
   eventMaxBytes;
   eventKeepBytes;
   eventSizeCheckEvery;
+  controlFileIO;
   eventChains = /* @__PURE__ */ new Map();
   eventWritesSinceCheck = /* @__PURE__ */ new Map();
   controlDrains = /* @__PURE__ */ new Map();
@@ -882,6 +959,7 @@ var SddBoardStore = class {
       1,
       Math.floor(opts.eventSizeCheckEvery ?? DEFAULT_EVENT_SIZE_CHECK_EVERY)
     );
+    this.controlFileIO = opts.controlFileIO ?? fsp3;
   }
   snapshotPath(runId) {
     return path3.join(this.baseDir, `${this.safe(runId)}.json`);
@@ -952,12 +1030,12 @@ var SddBoardStore = class {
     try {
       return await drain;
     } finally {
-      if (this.controlDrains.get(filePath) === drain) this.controlDrains.delete(filePath);
+      this.controlDrains.delete(filePath);
     }
   }
   async delete(runId) {
     const eventPath = this.eventsPath(runId);
-    await this.eventChains.get(eventPath)?.catch(() => void 0);
+    await this.eventChains.get(eventPath);
     this.eventChains.delete(eventPath);
     await Promise.allSettled([
       fsp3.unlink(this.snapshotPath(runId)),
@@ -1005,13 +1083,10 @@ var SddBoardStore = class {
       const buffer = Buffer.allocUnsafe(length);
       const { bytesRead } = await handle.read(buffer, 0, length, start);
       retained = buffer.subarray(0, bytesRead);
-      if (start > 0 && retained.length > 0) {
-        const previous = Buffer.allocUnsafe(1);
-        const preceding = await handle.read(previous, 0, 1, start - 1);
-        if (preceding.bytesRead !== 1 || previous[0] !== 10) {
-          const firstNewline = retained.indexOf(10);
-          retained = firstNewline >= 0 ? retained.subarray(firstNewline + 1) : retained.subarray(0, 0);
-        }
+      const previous = Buffer.allocUnsafe(1);
+      await handle.read(previous, 0, 1, start - 1);
+      if (previous[0] !== 10) {
+        retained = retained.subarray(retained.indexOf(10) + 1);
       }
     } finally {
       await handle.close();
@@ -1020,7 +1095,7 @@ var SddBoardStore = class {
   }
   async drainControlInternal(filePath) {
     try {
-      const stat2 = await fsp3.stat(filePath);
+      const stat2 = await this.controlFileIO.stat(filePath);
       if (stat2.size === 0) return [];
     } catch {
       return [];
@@ -1028,14 +1103,14 @@ var SddBoardStore = class {
     return withFileLock(filePath, async () => {
       let raw;
       try {
-        const stat2 = await fsp3.stat(filePath);
+        const stat2 = await this.controlFileIO.stat(filePath);
         if (stat2.size === 0) return [];
-        raw = await fsp3.readFile(filePath, "utf8");
+        raw = await this.controlFileIO.readFile(filePath, "utf8");
       } catch {
         return [];
       }
       try {
-        await fsp3.truncate(filePath, 0);
+        await this.controlFileIO.truncate(filePath, 0);
       } catch {
         return [];
       }
@@ -1160,7 +1235,6 @@ var SddBoardProjector = class _SddBoardProjector {
   mergedCommits = [];
   /** Base branch reported by the run at start (overrides the constructor option). */
   runBaseBranch;
-  dirty = false;
   timer = null;
   unsubs = [];
   /** Latest snapshot waiting behind an in-flight disk write. */
@@ -1189,7 +1263,11 @@ var SddBoardProjector = class _SddBoardProjector {
     });
     this.onRun("sdd.wave", (e) => {
       this.wave = e.wave;
-      this.pushFeed({ ts: this.now(), kind: "wave", text: `Wave ${e.wave + 1} started \xB7 ${e.batchSize} task(s) in parallel` });
+      this.pushFeed({
+        ts: this.now(),
+        kind: "wave",
+        text: `Wave ${e.wave + 1} started \xB7 ${e.batchSize} task(s) in parallel`
+      });
       this.markDirty();
     });
     this.onRun("sdd.deadlock", (e) => {
@@ -1197,7 +1275,11 @@ var SddBoardProjector = class _SddBoardProjector {
         blocked: this.shortId.get(c.blocked) ?? c.blocked.slice(0, 6),
         blockedBy: c.blockedBy.map((b) => this.shortId.get(b) ?? b.slice(0, 6))
       }));
-      this.pushFeed({ ts: this.now(), kind: "deadlock", text: `Deadlock \u2014 ${e.chains.length} task(s) blocked by failed work` });
+      this.pushFeed({
+        ts: this.now(),
+        kind: "deadlock",
+        text: `Deadlock \u2014 ${e.chains.length} task(s) blocked by failed work`
+      });
       this.markDirty();
     });
     this.onRun("sdd.task.started", (e) => {
@@ -1377,7 +1459,8 @@ var SddBoardProjector = class _SddBoardProjector {
   }
   pushFeed(entry) {
     this.feed.unshift(entry);
-    if (this.feed.length > _SddBoardProjector.FEED_CAP) this.feed.length = _SddBoardProjector.FEED_CAP;
+    if (this.feed.length > _SddBoardProjector.FEED_CAP)
+      this.feed.length = _SddBoardProjector.FEED_CAP;
     if (entry.taskId) {
       const taskFeed = this.taskEvents.get(entry.taskId) ?? [];
       taskFeed.unshift(entry);
@@ -1402,12 +1485,7 @@ var SddBoardProjector = class _SddBoardProjector {
   }
   /** Resolve once all in-flight snapshot persistence has settled. */
   async drain() {
-    for (; ; ) {
-      const observed = this.saveLoop;
-      if (!observed) return;
-      await observed;
-      if (observed === this.saveLoop && !this.pendingSnapshot) return;
-    }
+    while (this.saveLoop) await this.saveLoop;
   }
   /** Stop projecting and release subscriptions. */
   dispose() {
@@ -1474,15 +1552,13 @@ var SddBoardProjector = class _SddBoardProjector {
     return snap;
   }
   markDirty() {
-    this.dirty = true;
     if (this.timer || this.finished) return;
     this.timer = setTimeout(() => {
       this.timer = null;
-      if (this.dirty) this.flush();
+      this.flush();
     }, this.throttleMs);
   }
   flush() {
-    this.dirty = false;
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = null;
@@ -1504,9 +1580,7 @@ var SddBoardProjector = class _SddBoardProjector {
     const loop = this.persistPendingSnapshots(store);
     this.saveLoop = loop;
     void loop.finally(() => {
-      if (this.saveLoop !== loop) return;
       this.saveLoop = void 0;
-      if (this.pendingSnapshot) this.startSaveLoop(store);
     });
   }
   async persistPendingSnapshots(store) {
@@ -1537,9 +1611,12 @@ var SddRunRegistry = class {
   }
 };
 
+// src/sdd-interview-driver.ts
+import { DefaultTaskStore as DefaultTaskStore2, TaskTracker as TaskTracker2 } from "@wrongstack/core/tasking";
+
 // src/spec-builder.ts
-import { expectDefined, toErrorMessage } from "@wrongstack/core/utils";
-import { SddError as SddError2, ERROR_CODES as ERROR_CODES2 } from "@wrongstack/core/types";
+import { ERROR_CODES as ERROR_CODES2, SddError as SddError2 } from "@wrongstack/core/types";
+import { expectDefined as expectDefined2, toErrorMessage } from "@wrongstack/core/utils";
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -1588,7 +1665,7 @@ function buildQuestioningPrompt(session, min, max) {
   if (answered > 0) {
     lines.push("", "**Conversation so far:**");
     for (let i = 0; i < answered; i++) {
-      const a = expectDefined(session.answers[i]);
+      const a = expectDefined2(session.answers[i]);
       lines.push(``, `Q${i + 1}: ${a.question}`, `A${i + 1}: ${a.answer}`);
     }
   }
@@ -1759,10 +1836,10 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp5 = await import("node:fs/promises");
-      const path4 = await import("node:path");
+      const fsp6 = await import("node:fs/promises");
+      const path6 = await import("node:path");
       const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
-      await fsp5.mkdir(path4.dirname(this.sessionPath), { recursive: true });
+      await fsp6.mkdir(path6.dirname(this.sessionPath), { recursive: true });
       await atomicWrite4(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -1771,8 +1848,8 @@ var AISpecBuilder = class {
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp5 = await import("node:fs/promises");
-      const raw = await fsp5.readFile(this.sessionPath, "utf8");
+      const fsp6 = await import("node:fs/promises");
+      const raw = await fsp6.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -1786,22 +1863,14 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp5 = await import("node:fs/promises");
-      await fsp5.unlink(this.sessionPath);
+      const fsp6 = await import("node:fs/promises");
+      await fsp6.unlink(this.sessionPath);
     } catch {
     }
   }
-  /** Auto-save helper — calls saveSession() but never throws.
-   *  Failures are surfaced via process.emitWarning so a persistent
-   *  ENOSPC / EACCES doesn't silently strand session edits in memory. */
+  /** Auto-save helper. saveSession() already handles best-effort persistence. */
   autoSave() {
-    this.saveSession().catch((err) => {
-      const detail = toErrorMessage(err);
-      process.emitWarning(
-        `SpecBuilder autoSave failed: ${detail}`,
-        "SpecBuilderWarning"
-      );
-    });
+    void this.saveSession();
   }
   // ── Session Lifecycle ─────────────────────────────────────────────────────
   /** Start a new session with a title and optional intent. */
@@ -1946,6 +2015,43 @@ var AISpecBuilder = class {
   getTaskGraphId() {
     return this.session.taskGraphId;
   }
+  /** Persist the last agent utterance so resume can rehydrate the UI + Q/A pairing. */
+  setLastAgentText(text) {
+    this.session.lastAgentText = text;
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  getLastAgentText() {
+    return this.session.lastAgentText;
+  }
+  /** Record a run kicked off from this interview (board deep-link after restart). */
+  setLastRunId(runId) {
+    this.session.lastRunId = runId;
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  getLastRunId() {
+    return this.session.lastRunId;
+  }
+  /**
+   * Hard-reset in-memory session fields while keeping the same session id /
+   * store binding. Used when the operator abandons a resumed interview and
+   * starts a brand-new goal (the next save overwrites the session file).
+   */
+  resetForNewInterview() {
+    this.session.phase = "questioning";
+    this.session.title = "";
+    this.session.userIntent = "";
+    this.session.answers = [];
+    this.session.questionCount = 0;
+    this.session.spec = void 0;
+    this.session.implementation = void 0;
+    this.session.taskGraphId = void 0;
+    this.session.lastAgentText = void 0;
+    this.session.lastRunId = void 0;
+    this.session.approved = false;
+    this.session.updatedAt = Date.now();
+  }
   // ── Spec Persistence ──────────────────────────────────────────────────────
   /**
    * Save the current spec to the store.
@@ -1975,7 +2081,7 @@ var AISpecBuilder = class {
         message: "Invalid JSON for spec",
         code: ERROR_CODES2.SDD_PARSE_FAILED,
         cause: e,
-        context: { detail: e instanceof Error ? e.message : "parse error" }
+        context: { detail: toErrorMessage(e) }
       });
     }
     if (!parsed || typeof parsed !== "object") {
@@ -1987,7 +2093,7 @@ var AISpecBuilder = class {
     }
     const raw = parsed;
     const now = Date.now();
-    const title = String(raw.title ?? this.session.title ?? "Untitled");
+    const title = String(raw.title ?? this.session.title);
     const overview = String(raw.overview ?? "");
     if (!overview || overview === "undefined") {
       throw new SddError2({
@@ -1998,7 +2104,15 @@ var AISpecBuilder = class {
     }
     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",
+      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
@@ -2006,7 +2120,9 @@ var AISpecBuilder = class {
     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",
+      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) : []
@@ -2095,7 +2211,6 @@ var AISpecBuilder = class {
 };
 
 // src/sdd-interview-driver.ts
-import { TaskTracker as TaskTracker2, DefaultTaskStore as DefaultTaskStore2 } from "@wrongstack/core/tasking";
 var SddInterviewDriver = class {
   builder;
   o;
@@ -2103,6 +2218,8 @@ var SddInterviewDriver = class {
   maxQuestions;
   tracker = null;
   graph = null;
+  /** Set when {@link loadExisting} successfully rehydrated a session from disk. */
+  resumedFromDisk = false;
   constructor(opts) {
     this.o = opts;
     this.minQuestions = opts.minQuestions ?? 2;
@@ -2117,9 +2234,11 @@ var SddInterviewDriver = class {
   }
   /** Begin a fresh interview. Returns the first AI prompt (a question kickoff). */
   start(title, intent) {
+    this.builder.resetForNewInterview();
     this.builder.startSession(title, intent);
     this.tracker = null;
     this.graph = null;
+    this.resumedFromDisk = false;
     return this.builder.getAIPrompt();
   }
   /**
@@ -2139,8 +2258,32 @@ var SddInterviewDriver = class {
         this.tracker = tracker;
       }
     }
+    this.resumedFromDisk = true;
     return true;
   }
+  /** Drop the on-disk session (if any) and clear in-memory interview state. */
+  async discard() {
+    await this.builder.deleteSession();
+    this.builder.resetForNewInterview();
+    this.tracker = null;
+    this.graph = null;
+    this.resumedFromDisk = false;
+  }
+  setLastAgentText(text) {
+    this.builder.setLastAgentText(text);
+  }
+  getLastAgentText() {
+    return this.builder.getLastAgentText();
+  }
+  setLastRunId(runId) {
+    this.builder.setLastRunId(runId);
+  }
+  getLastRunId() {
+    return this.builder.getLastRunId();
+  }
+  wasResumed() {
+    return this.resumedFromDisk;
+  }
   phase() {
     return this.builder.getPhase();
   }
@@ -2241,6 +2384,9 @@ var SddInterviewDriver = class {
       minQuestions: this.minQuestions,
       maxQuestions: this.maxQuestions,
       answers: s.answers.map((a) => ({ question: a.question, answer: a.answer })),
+      lastAgentText: s.lastAgentText,
+      lastRunId: s.lastRunId,
+      resumed: this.resumedFromDisk || void 0,
       spec: spec ? {
         id: spec.id,
         title: spec.title,
@@ -2308,16 +2454,17 @@ var SddInterviewDriver = class {
     );
     if (valid.length === 0) return void 0;
     const spec = this.builder.getSession().spec;
-    if (!spec) return void 0;
-    if (!this.tracker || !this.graph) {
-      const tracker = new TaskTracker2({ store: new DefaultTaskStore2() });
-      this.graph = await tracker.createGraph(spec.id, spec.title);
-      this.tracker = tracker;
+    if (!this.tracker) {
+      const tracker2 = new TaskTracker2({ store: new DefaultTaskStore2() });
+      this.graph = await tracker2.createGraph(spec.id, spec.title);
+      this.tracker = tracker2;
     }
+    const tracker = this.tracker;
+    const graph = this.graph;
     const refMap = /* @__PURE__ */ new Map();
     const created = [];
     valid.forEach((task, i) => {
-      const node = addTaskToTracker(this.tracker, task);
+      const node = addTaskToTracker(tracker, task);
       created.push({ nodeId: node.id, task });
       if (typeof task.id === "string" && task.id.trim()) {
         refMap.set(task.id.trim().toLowerCase(), node.id);
@@ -2330,13 +2477,13 @@ var SddInterviewDriver = class {
       const deps = Array.isArray(task.dependsOn) ? task.dependsOn : [];
       for (const ref of deps) {
         const depId = refMap.get(normalizeTaskRef(String(ref)));
-        if (depId && depId !== nodeId) this.tracker.addDependency(depId, nodeId);
+        if (depId && depId !== nodeId) tracker.addDependency(depId, nodeId);
       }
     }
-    await this.persistGraph(this.graph);
-    this.builder.setTaskGraphId(this.graph.id);
+    await this.persistGraph(graph);
+    this.builder.setTaskGraphId(graph.id);
     await this.builder.saveSession();
-    return this.graph.id;
+    return graph.id;
   }
 };
 var TASK_TYPES = ["feature", "bugfix", "refactor", "docs", "test", "chore"];
@@ -2364,10 +2511,219 @@ function isExplanatoryText(text) {
 import { TOKENS } from "@wrongstack/core/kernel";
 
 // src/sdd-parallel-run.ts
-import { expectDefined as expectDefined2 } from "@wrongstack/core/utils";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import {
+  DefaultMultiAgentCoordinator,
+  makeAgentSubagentRunner,
+  withDisabledToolFiltering
+} from "@wrongstack/core/coordination";
+
+// 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 verificationCommand = criterion ? extractVerificationCommand([criterion]) : void 0;
+    const description = criterion && !verificationCommand ? `${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,
+      ...verificationCommand ? { metadata: { verificationCommand } } : {}
+    }).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-task-execution.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { assignNickname, makeAgentSubagentRunner, withDisabledToolFiltering, DefaultMultiAgentCoordinator } from "@wrongstack/core/coordination";
-import { SddError as SddError3, ERROR_CODES as ERROR_CODES3 } from "@wrongstack/core/types";
+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");
+      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
+      });
+      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-decomposer.ts
 var SddTaskDecomposer = class {
@@ -2485,13 +2841,15 @@ var SddParallelRun = class {
     this.maxRetries = Math.max(0, opts.maxRetries ?? 3);
     this.maxSupervisorEscalations = Math.max(0, opts.maxSupervisorEscalations ?? 2);
     this.maxFailedSweeps = Math.max(0, opts.maxFailedRetrySweeps ?? 2);
-    this.runId = opts.runId ?? `sdd-${randomUUID2().slice(0, 8)}`;
+    this.runId = opts.runId ?? `sdd-${randomUUID3().slice(0, 8)}`;
     this.events = opts.events;
     this.sessionIdSource = opts.sessionId;
     this.maxTotalWaves = opts.maxTotalWaves ?? opts.graph.nodes.size * (this.maxRetries + 2) + 10;
     this.maxWallClockMs = opts.maxWallClockMs;
     this.maxRecoveryRounds = Math.max(0, opts.maxRecoveryRounds ?? 0);
-    this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, { parallelSlots: this.slots });
+    this.decomposer = new SddTaskDecomposer(opts.tracker, opts.graph, {
+      parallelSlots: this.slots
+    });
   }
   opts;
   slots;
@@ -2614,7 +2972,8 @@ 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" };
+    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" };
@@ -2647,7 +3006,10 @@ var SddParallelRun = class {
    */
   setTaskModel(taskId, model, provider) {
     if (!this.opts.tracker.getNode(taskId)) return false;
-    this.opts.tracker.patchMetadata(taskId, { model, ...provider !== void 0 ? { provider } : {} });
+    this.opts.tracker.patchMetadata(taskId, {
+      model,
+      ...provider !== void 0 ? { provider } : {}
+    });
     return true;
   }
   /** Set/override a task's fallback model chain (applied on its next dispatch). */
@@ -2679,7 +3041,12 @@ var SddParallelRun = class {
     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" });
+    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(() => {
@@ -2710,30 +3077,12 @@ var SddParallelRun = class {
    * The scheduler picks the new pending leaves up on its next dispatch pass.
    */
   splitTask(taskId, subtasks) {
-    const tracker = this.opts.tracker;
-    const node = tracker.getNode(taskId);
-    if (!node) return [];
-    if (node.status === "in_progress" || this.taskSubagents.has(taskId)) return [];
-    if (!subtasks.length) return [];
-    const blockers = tracker.getBlockers(taskId);
-    const dependents = tracker.getDependents(taskId);
-    const leafIds = subtasks.map(
-      (s) => tracker.addNode({
-        title: s.title,
-        description: s.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);
-    }
+    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);
-    tracker.updateNodeStatus(taskId, "completed", `split into ${leafIds.length} subtasks`);
     this.emit("sdd.task.split", { runId: this.runId, taskId, subtaskIds: leafIds });
     return leafIds;
   }
@@ -2781,7 +3130,12 @@ var SddParallelRun = class {
           return await this.executeOne(task);
         } catch (err) {
           this.opts.tracker.updateNodeStatus(task.id, "failed", `dispatch error: ${String(err)}`);
-          this.emit("sdd.task.failed", { runId: this.runId, taskId: task.id, subagentId: "", error: String(err) });
+          this.emit("sdd.task.failed", {
+            runId: this.runId,
+            taskId: task.id,
+            subagentId: "",
+            error: String(err)
+          });
           return { taskId: task.id, success: false };
         } finally {
           running.delete(task.id);
@@ -2795,16 +3149,18 @@ var SddParallelRun = class {
       await this.waitWhilePaused();
       if (this.stopRequested) break;
       let dispatchedThisRound = 0;
-      if (running.size < this.slots) {
-        const ready = this.decomposer.readyNodes().filter((t) => !running.has(t.id));
-        for (const task of ready) {
-          if (running.size >= this.slots) break;
-          dispatch(task);
-          dispatchedThisRound++;
-        }
+      const ready = this.decomposer.readyNodes().filter((t) => !running.has(t.id));
+      for (const task of ready) {
+        if (running.size >= this.slots) break;
+        dispatch(task);
+        dispatchedThisRound++;
       }
       if (dispatchedThisRound > 0) {
-        this.emit("sdd.wave", { runId: this.runId, wave: this.round, batchSize: dispatchedThisRound });
+        this.emit("sdd.wave", {
+          runId: this.runId,
+          wave: this.round,
+          batchSize: dispatchedThisRound
+        });
         this.round++;
       }
       if (running.size === 0) {
@@ -2835,7 +3191,6 @@ var SddParallelRun = class {
         this.opts.onProgress?.(this.buildProgress());
       }
     }
-    if (running.size > 0) await Promise.allSettled(running.values());
     if (this.stopRequested) await this.teardown();
     const finalProgress = this.opts.tracker.getProgress();
     this.emit("sdd.run.finished", {
@@ -2966,7 +3321,7 @@ var SddParallelRun = class {
   // -------------------------------------------------------------------
   buildCoordinator() {
     const config = {
-      coordinatorId: `sdd-parallel-${randomUUID2().slice(0, 8)}`,
+      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
@@ -3023,158 +3378,30 @@ var SddParallelRun = class {
    * missing coordinator or failed spawn so callers can enforce all-or-nothing.
    */
   async executeOne(task) {
-    const taskId = task.id;
-    let agentName = task.assignee;
-    if (!agentName) {
-      const nick = assignNickname("executor", this.usedNicknames);
-      this.usedNicknames.add(nick.key);
-      agentName = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
-      this.opts.tracker.updateNode(taskId, { assignee: agentName });
-    }
-    this.opts.tracker.updateNodeStatus(taskId, "in_progress");
-    await this.allocateWorktrees([task]);
-    if (!this.coordinator) throw new SddError3({
-      message: "SDD parallel runner requires a coordinator",
-      code: ERROR_CODES3.SDD_INVALID_STATE
-    });
-    const coordinator = this.coordinator;
-    const subagentId = `sdd-d${this.dispatchSeq++}`;
-    const correlationId = randomUUID2();
-    const meta = task.metadata ?? {};
-    const model = (typeof meta.model === "string" ? meta.model : void 0) ?? this.opts.defaultModel;
-    const provider = (typeof meta.provider === "string" ? meta.provider : void 0) ?? this.opts.defaultProvider;
-    const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : this.opts.fallbackModels;
-    const spawnResult = await coordinator.spawn({
-      id: subagentId,
-      name: agentName ?? subagentId,
-      role: "executor",
-      // Idle reaper is always on; the hard wall-clock cap only when opted in.
+    const outcome = await executeSddTask({
+      task,
+      opts: this.opts,
+      coordinator: this.coordinator,
+      usedNicknames: this.usedNicknames,
       idleTimeoutMs: this.idleTimeoutMs,
-      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {},
-      cwd: this.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
-      });
-    }
-    this.taskSubagents.set(taskId, subagentId);
-    this.emit("sdd.task.started", {
+      timeoutMs: this.timeoutMs,
       runId: this.runId,
-      taskId,
-      subagentId,
-      agentName: agentName ?? "",
-      worktreeBranch: this.taskBranches.get(taskId)
+      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)
     });
-    const directivePreamble = [
-      "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
-      "",
-      `Graph: ${this.opts.graph.title}`,
-      "",
-      "\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");
-    await coordinator.assign({
-      id: correlationId,
-      description: [
-        directivePreamble,
-        "",
-        `\u2500\u2500 TASK \u2500\u2500`,
-        `[${task.priority.toUpperCase()}] ${task.title}`,
-        "",
-        task.description
-      ].join("\n"),
-      subagentId,
-      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {},
-      context: {
-        telemetryTaskId: taskId,
-        telemetryRunId: this.runId,
-        telemetryBoardId: this.opts.graph.id
-      }
-    });
-    let result;
-    try {
-      const got = await coordinator.awaitTasks([correlationId]);
-      result = expectDefined2(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 (outcome.success) {
+      this.retryMap.delete(task.id);
+      this.persistRetries(task.id, 0);
     }
-    this.taskSubagents.delete(taskId);
-    if (this.cancelledTasks.has(taskId)) {
-      await this.resolveWorktrees([task]);
-      return { taskId, success: false, result };
-    }
-    let verificationFailReason;
-    if (result.status === "success" && this.opts.verifyTask) {
-      const cwd = this.taskCwds.get(taskId) ?? this.opts.projectRoot;
-      try {
-        const verdict = await this.opts.verifyTask({ task, result, cwd });
-        if (!verdict.ok) {
-          verificationFailReason = `verification failed: ${verdict.reason ?? "acceptance criteria not met"}`;
-        }
-      } catch (err) {
-        verificationFailReason = `verification error: ${String(err)}`;
-      }
-      if (verificationFailReason) {
-        this.emit("sdd.task.verification_failed", {
-          runId: this.runId,
-          taskId,
-          reason: verificationFailReason
-        });
-      }
-    }
-    let success = false;
-    if (result.status === "success" && !verificationFailReason) {
-      const merged = await this.integrateWorktree(task, result);
-      if (merged.ok) {
-        success = true;
-        this.opts.tracker.updateNodeStatus(taskId, "completed");
-        this.retryMap.delete(taskId);
-        this.persistRetries(taskId, 0);
-        this.emit("sdd.task.completed", {
-          runId: this.runId,
-          taskId,
-          subagentId,
-          durationMs: result.durationMs
-        });
-      } else if (merged.reason) {
-        this.emit("sdd.task.verification_failed", {
-          runId: this.runId,
-          taskId,
-          reason: merged.reason
-        });
-        await this.applyTaskFailure(taskId, subagentId, merged.reason);
-      } else {
-        this.emit("sdd.task.conflict", {
-          runId: this.runId,
-          taskId,
-          conflictFiles: merged.conflictFiles ?? []
-        });
-        const reason = `merge conflict${merged.conflictFiles?.length ? `: ${merged.conflictFiles.join(", ")}` : ""}`;
-        await this.applyTaskFailure(taskId, subagentId, reason);
-      }
-    } else {
-      const errMsg = verificationFailReason ?? (result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error");
-      await this.applyTaskFailure(taskId, subagentId, errMsg);
-      await this.resolveWorktrees([task]);
-    }
-    return { taskId, success, result };
+    return outcome;
   }
   /**
    * Apply a task failure: retry (→ pending, bump retry count) while attempts
@@ -3269,7 +3496,11 @@ var SddParallelRun = class {
       const res = await wt.merge(handle, {
         squash: true,
         ...this.opts.conflictResolver ? {
-          resolve: (info) => this.opts.conflictResolver({ task, conflictFiles: info.conflictFiles, cwd: info.cwd })
+          resolve: (info) => this.opts.conflictResolver({
+            task,
+            conflictFiles: info.conflictFiles,
+            cwd: info.cwd
+          })
         } : {}
       });
       if (res.ok) {
@@ -3281,7 +3512,8 @@ var SddParallelRun = class {
               result: result ?? {},
               cwd: this.opts.projectRoot
             });
-            if (!verdict.ok) regressed = verdict.reason ?? "verification failed after conflict resolution";
+            if (!verdict.ok)
+              regressed = verdict.reason ?? "verification failed after conflict resolution";
           } catch (err) {
             regressed = `verification error after conflict resolution: ${String(err)}`;
           }
@@ -3397,6 +3629,32 @@ var SddParallelRun = class {
 };
 
 // src/start-sdd-run.ts
+function applySddControlCommand(run, command) {
+  const payload = command.payload ?? {};
+  if (command.type === "pause") run.pause();
+  else if (command.type === "resume") run.resume();
+  else if (command.type === "stop") run.stop();
+  else if (command.type === "retry" && payload.taskId) run.retryTask(payload.taskId);
+  else if (command.type === "retry_all_failed") run.retryAllFailed();
+  else if (command.type === "reassign" && payload.taskId)
+    run.reassignTask(payload.taskId, payload.agentName ?? "");
+  else if (command.type === "set_task_model" && payload.taskId)
+    run.setTaskModel(payload.taskId, payload.model, payload.provider);
+  else if (command.type === "set_task_fallbacks" && payload.taskId)
+    run.setTaskFallbacks(payload.taskId, payload.fallbackModels);
+  else if (command.type === "set_task_verification" && payload.taskId)
+    run.setTaskVerification(payload.taskId, payload.verificationCommand);
+  else if (command.type === "cancel_task" && payload.taskId)
+    void run.cancelTask(payload.taskId).catch(() => {
+    });
+  else if (command.type === "delete_task" && payload.taskId) run.deleteTask(payload.taskId);
+  else if (command.type === "split_task" && payload.taskId && payload.subtasks?.length)
+    run.splitTask(payload.taskId, payload.subtasks);
+  else if (command.type === "cleanup_worktrees") void run.cleanupWorktrees().catch(() => {
+  });
+  else if (command.type === "rollback") void run.rollback().catch(() => {
+  });
+}
 function startSddRun(opts) {
   SddParallelRun.resetOrphans(opts.tracker);
   const run = new SddParallelRun({
@@ -3460,25 +3718,7 @@ function startSddRun(opts) {
   const controlTimer = setInterval(() => {
     void opts.boardStore.drainControl(run.runId).then((cmds) => {
       for (const c of cmds) {
-        const p = c.payload ?? {};
-        if (c.type === "pause") run.pause();
-        else if (c.type === "resume") run.resume();
-        else if (c.type === "stop") run.stop();
-        else if (c.type === "retry" && p.taskId) run.retryTask(p.taskId);
-        else if (c.type === "retry_all_failed") run.retryAllFailed();
-        else if (c.type === "reassign" && p.taskId) run.reassignTask(p.taskId, p.agentName ?? "");
-        else if (c.type === "set_task_model" && p.taskId) run.setTaskModel(p.taskId, p.model, p.provider);
-        else if (c.type === "set_task_fallbacks" && p.taskId) run.setTaskFallbacks(p.taskId, p.fallbackModels);
-        else if (c.type === "set_task_verification" && p.taskId)
-          run.setTaskVerification(p.taskId, p.verificationCommand);
-        else if (c.type === "cancel_task" && p.taskId) void run.cancelTask(p.taskId).catch(() => {
-        });
-        else if (c.type === "delete_task" && p.taskId) run.deleteTask(p.taskId);
-        else if (c.type === "split_task" && p.taskId && p.subtasks?.length) run.splitTask(p.taskId, p.subtasks);
-        else if (c.type === "cleanup_worktrees") void run.cleanupWorktrees().catch(() => {
-        });
-        else if (c.type === "rollback") void run.rollback().catch(() => {
-        });
+        applySddControlCommand(run, c);
       }
     }).catch(() => {
     });
@@ -3506,7 +3746,10 @@ function startSddRun(opts) {
 
 // src/sdd-lifecycle.ts
 import * as fsp4 from "node:fs/promises";
+import * as path4 from "node:path";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 import { WorktreeManager } from "@wrongstack/core/worktree";
+import { listBoards, removeBoard } from "@wrongstack/kanban";
 async function cleanupSddWorktrees(projectRoot) {
   const wt = new WorktreeManager({ projectRoot });
   return wt.cleanupAllManaged();
@@ -3517,19 +3760,21 @@ async function cleanupStaleWorktrees(projectRoot) {
 }
 async function cleanupStaleSddWorktrees(opts) {
   const now = opts.now?.() ?? Date.now();
-  try {
-    const store = new SddBoardStore({ baseDir: opts.boardsDir });
-    const latest = (await store.list())[0];
-    if (latest) {
-      const age = now - latest.updatedAt;
-      if (latest.status === "running" && age < (opts.runningLiveMs ?? 12e4)) {
-        return { swept: false, removed: 0, detected: 0, skippedReason: "a run appears live (running)" };
-      }
-      if (latest.status === "paused" && age < (opts.pausedLiveMs ?? 18e5)) {
-        return { swept: false, removed: 0, detected: 0, skippedReason: "a run is paused" };
-      }
+  const store = new SddBoardStore({ baseDir: opts.boardsDir });
+  const latest = (await store.list())[0];
+  if (latest) {
+    const age = now - latest.updatedAt;
+    if (latest.status === "running" && age < (opts.runningLiveMs ?? 12e4)) {
+      return {
+        swept: false,
+        removed: 0,
+        detected: 0,
+        skippedReason: "a run appears live (running)"
+      };
+    }
+    if (latest.status === "paused" && age < (opts.pausedLiveMs ?? 18e5)) {
+      return { swept: false, removed: 0, detected: 0, skippedReason: "a run is paused" };
     }
-  } catch {
   }
   try {
     const wt = new WorktreeManager({ projectRoot: opts.projectRoot });
@@ -3546,7 +3791,11 @@ async function rollbackSddRunFromDisk(opts) {
   const snap = await store.load(runId);
   if (!snap) return { ok: false, reverted: 0, reason: `board "${runId}" not found` };
   if (!snap.baseBranch) {
-    return { ok: false, reverted: 0, reason: "this run did not record a base branch (no worktree run)" };
+    return {
+      ok: false,
+      reverted: 0,
+      reason: "this run did not record a base branch (no worktree run)"
+    };
   }
   const shas = (snap.mergedCommits ?? []).map((c) => c.sha);
   if (shas.length === 0) {
@@ -3564,7 +3813,7 @@ async function destroySddProject(opts) {
       projectRoot: opts.projectRoot,
       boardsDir: opts.paths.projectSddBoards,
       runId: opts.runId
-    }).catch((err) => ({ ok: false, reverted: 0, reason: toReason(err) }));
+    }).catch((err) => ({ ok: false, reverted: 0, reason: toErrorMessage2(err) }));
     reverted = r.reverted;
     revertOk = r.ok;
     revertReason = r.reason;
@@ -3586,14 +3835,24 @@ async function destroySddProject(opts) {
     }
   };
   await rmFile(opts.paths.projectSddSession, "session");
+  await rmFile(
+    path4.join(path4.dirname(opts.paths.projectSddSession), "sdd-wizard-session.json"),
+    "wizard-session"
+  );
   await rmDir(opts.paths.projectSpecs, "specs");
   await rmDir(opts.paths.projectTaskGraphs, "task-graphs");
   await rmDir(opts.paths.projectSddBoards, "boards");
+  try {
+    const mirrors = (await listBoards(opts.projectRoot)).filter((b) => b.tags?.includes("sdd"));
+    let mirrorsRemoved = 0;
+    for (const b of mirrors) {
+      if (await removeBoard(opts.projectRoot, b.id)) mirrorsRemoved++;
+    }
+    if (mirrorsRemoved > 0) deleted.push(`kanban-mirrors(${mirrorsRemoved})`);
+  } catch {
+  }
   return { worktreesRemoved: removed, deleted, reverted, revertOk, revertReason };
 }
-function toReason(err) {
-  return err instanceof Error ? err.message : String(err);
-}
 async function applySddLifecycle(op, opts) {
   try {
     if (op === "cleanup_worktrees") {
@@ -3625,8 +3884,58 @@ async function applySddLifecycle(op, opts) {
       reason: r.revertOk === false ? r.revertReason : void 0
     };
   } catch (err) {
-    return { op, ok: false, reason: toReason(err) };
+    return { op, ok: false, reason: toErrorMessage2(err) };
+  }
+}
+
+// src/project-context.ts
+import * as fsp5 from "node:fs/promises";
+import * as path5 from "node:path";
+async function gatherProjectContext(projectRoot) {
+  const parts = [];
+  const root = projectRoot.trim() || process.cwd();
+  try {
+    const pkgPath = path5.join(root, "package.json");
+    const pkgRaw = await fsp5.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(pkgRaw);
+    parts.push(`Project: ${String(pkg.name ?? "unknown")}`);
+    parts.push(`Description: ${String(pkg.description ?? "none")}`);
+    if (pkg.dependencies && typeof pkg.dependencies === "object") {
+      const deps = Object.keys(pkg.dependencies);
+      parts.push(`Dependencies: ${deps.slice(0, 20).join(", ")}${deps.length > 20 ? "..." : ""}`);
+    }
+    if (pkg.devDependencies && typeof pkg.devDependencies === "object") {
+      const devDeps = Object.keys(pkg.devDependencies);
+      parts.push(
+        `Dev Dependencies: ${devDeps.slice(0, 15).join(", ")}${devDeps.length > 15 ? "..." : ""}`
+      );
+    }
+  } catch {
+  }
+  try {
+    await fsp5.access(path5.join(root, "tsconfig.json"));
+    parts.push("Language: TypeScript");
+  } catch {
+  }
+  try {
+    const srcDir = path5.join(root, "src");
+    const entries = await fsp5.readdir(srcDir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    if (dirs.length > 0) parts.push(`Source structure: src/${dirs.join(", src/")}`);
+  } catch {
   }
+  try {
+    const packagesDir = path5.join(root, "packages");
+    const entries = await fsp5.readdir(packagesDir, { withFileTypes: true });
+    const pkgs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    if (pkgs.length > 0) {
+      parts.push(
+        `Packages: ${pkgs.slice(0, 25).join(", ")}${pkgs.length > 25 ? "..." : ""}`
+      );
+    }
+  } catch {
+  }
+  return parts.join("\n");
 }
 
 // src/spec-templates.ts
@@ -3747,7 +4056,7 @@ function templateToMarkdown(template, title) {
 
 // src/task-visualizer.ts
 import { computeTaskProgress as computeTaskProgress2 } from "@wrongstack/core/tasking";
-import { truncate as truncate2 } from "@wrongstack/core/utils";
+import { expectDefined as expectDefined4, truncate } from "@wrongstack/core/utils";
 var STATUS_ICON = {
   pending: "\u25CB",
   in_progress: "\u25D0",
@@ -3774,7 +4083,9 @@ function renderTaskGraph(graph, opts) {
   const lines = [];
   const compact = opts?.compact ?? false;
   lines.push(`\u256D\u2500 Task Graph: ${graph.title} \u2500\u256E`);
-  lines.push(`\u2502 Spec: ${graph.specId.slice(0, 8)}... \u2502 Nodes: ${graph.nodes.size} \u2502 Edges: ${graph.edges.length} \u2502`);
+  lines.push(
+    `\u2502 Spec: ${graph.specId.slice(0, 8)}... \u2502 Nodes: ${graph.nodes.size} \u2502 Edges: ${graph.edges.length} \u2502`
+  );
   lines.push("\u2570" + "\u2500".repeat(Math.max(50, graph.title.length + 30)) + "\u256F");
   lines.push("");
   const progress = computeTaskProgress2(graph);
@@ -3809,19 +4120,18 @@ function renderTaskGraph(graph, opts) {
 function renderNode(graph, nodeId, lines, rendered, childrenMap, compact, prefix) {
   if (rendered.has(nodeId)) return;
   rendered.add(nodeId);
-  const node = graph.nodes.get(nodeId);
-  if (!node) return;
+  const node = expectDefined4(graph.nodes.get(nodeId));
   const icon = STATUS_ICON[node.status];
   const prioIcon = PRIORITY_ICON[node.priority];
   const typeIcon = TYPE_ICON[node.type];
-  const title = compact ? truncate2(node.title, 40) : node.title;
+  const title = compact ? truncate(node.title, 40) : node.title;
   const blockedBy = childrenMap.get(nodeId) ?? [];
   const depsStr = blockedBy.length > 0 ? ` \u2190 [${blockedBy.map((d) => graph.nodes.get(d)?.title?.slice(0, 12) ?? "?").join(", ")}]` : "";
   lines.push(`${prefix}${icon} ${typeIcon} ${prioIcon} ${title}${depsStr}`);
   if (!compact && node.description) {
     const descLines = node.description.split("\n").slice(0, 3);
     for (const dl of descLines) {
-      lines.push(`${prefix}  \u2514 ${truncate2(dl, 60)}`);
+      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));
@@ -3851,7 +4161,7 @@ function renderTaskList(graph) {
     completed: []
   };
   for (const node of nodes) {
-    groups[node.status]?.push(node);
+    groups[node.status].push(node);
   }
   for (const [status, group] of Object.entries(groups)) {
     if (group.length === 0) continue;
@@ -3899,8 +4209,8 @@ function renderSpecAnalysis(spec, analysis) {
 }
 
 // src/critical-path.ts
-import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
 import { topologicalSort } from "@wrongstack/core/tasking";
+import { expectDefined as expectDefined5 } from "@wrongstack/core/utils";
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -3954,8 +4264,7 @@ function analyzeCriticalPath(graph) {
   bottlenecks.sort((a, b) => b.severity - a.severity);
   const criticalPath = computeCriticalPath(graph, topoOrder, blockedByMap);
   const totalHours = criticalPath.reduce((sum, id) => {
-    const n = graph.nodes.get(id);
-    return sum + (n?.estimateHours ?? 0);
+    return sum + (graph.nodes.get(id).estimateHours ?? 0);
   }, 0);
   const parallelGroups = computeParallelGroups(graph, blockedByMap);
   const executionOrder = topoOrder.filter((id) => {
@@ -3976,7 +4285,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = expectDefined3(queue.shift());
+    const current = expectDefined5(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -4011,7 +4320,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       const blocked = blocksMap.get(id);
       if (!blocked) continue;
       for (const blockedId of blocked) {
-        const candidateDist = (dist.get(id) ?? 0) + (graph.nodes.get(blockedId)?.estimateHours ?? 1);
+        const candidateDist = dist.get(id) + (graph.nodes.get(blockedId)?.estimateHours ?? 1);
         if (candidateDist > (dist.get(blockedId) ?? 0)) {
           dist.set(blockedId, candidateDist);
           prev.set(blockedId, id);
@@ -4022,23 +4331,23 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = expectDefined3(allIds[0]);
+  let maxId = expectDefined5(allIds[0]);
   for (const id of allIds) {
-    const d = dist.get(id) ?? 0;
+    const d = dist.get(id);
     if (d > maxDist) {
       maxDist = d;
       maxId = id;
     }
   }
-  const path4 = [];
+  const path6 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path4.unshift(current);
+    path6.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path4;
+  return path6;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -4059,8 +4368,7 @@ function computeParallelGroups(graph, blockedByMap) {
       }
     }
     if (group.length === 0) {
-      const first = Array.from(remaining)[0];
-      if (first) group.push(first);
+      group.push(expectDefined5(Array.from(remaining)[0]));
     }
     for (const id of group) {
       assigned.add(id);
@@ -4274,7 +4582,6 @@ var AutoExecutor = class {
       for (let i = 0; i < results.length; i++) {
         const result = results[i];
         const task = batch[i];
-        if (!result || !task) continue;
         if (result.status === "fulfilled") {
           const { result: execResult, retries } = result.value;
           if (execResult.success) {
@@ -4324,14 +4631,14 @@ var AutoExecutor = class {
       }
     }
     const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
-    ready.sort((a, b) => (priorityOrder[a.priority] ?? 4) - (priorityOrder[b.priority] ?? 4));
+    ready.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
     return ready;
   }
   /** Execute a single task with retry logic. */
   async executeTaskWithRetry(task, graph, spec) {
     const maxRetries = this.opts.maxRetries ?? 2;
     let retryCount = this.retryMap.get(task.id) ?? 0;
-    while (retryCount <= maxRetries) {
+    while (true) {
       this.opts.tracker.updateNodeStatus(task.id, "in_progress");
       this.opts.onTaskStart?.(task);
       const dependencies = this.getTaskDependencies(task.id, graph);
@@ -4375,7 +4682,6 @@ var AutoExecutor = class {
         };
       }
     }
-    return { result: { success: false, error: "Max retries exceeded" }, retries: retryCount };
   }
   /** Get tasks that this task depends on. */
   getTaskDependencies(taskId, graph) {
@@ -4462,6 +4768,54 @@ Supervisor rescues already used: ${attempts}`,
 
 // src/verify-task.ts
 import { spawn } from "node:child_process";
+function verificationShell(platform) {
+  return platform === "win32" ? ["cmd", "/d", "/c"] : ["sh", "-c"];
+}
+function makeCompositeVerifier(parts) {
+  return async function verifyTask(info) {
+    for (const part of parts) {
+      const outcome = await part(info);
+      if (!outcome.ok) return outcome;
+    }
+    return { ok: true };
+  };
+}
+function makeAcceptanceCriteriaVerifier(options) {
+  const maxResultChars = options.maxResultChars ?? 4e3;
+  return async function verifyTask(info) {
+    const description = info.task.description ?? "";
+    const marker = description.indexOf("**Acceptance Criteria:**");
+    if (marker === -1) return { ok: true };
+    const criteria = description.slice(marker);
+    const resultText = typeof info.result.result === "string" ? info.result.result.slice(0, maxResultChars) : JSON.stringify(info.result.result ?? "").slice(0, maxResultChars);
+    let text;
+    try {
+      text = await options.run(
+        [
+          "You are a strict acceptance reviewer for one completed engineering task.",
+          `Task: ${info.task.title}`,
+          "",
+          criteria,
+          "",
+          "Worker's reported result:",
+          resultText || "(no result text)",
+          "",
+          "Does the reported result plausibly satisfy EVERY acceptance criterion?",
+          'Answer with exactly one line: "VERDICT: PASS" or "VERDICT: FAIL \u2014 <short reason>".'
+        ].join("\n")
+      );
+    } catch {
+      return { ok: true };
+    }
+    const match = text.match(/VERDICT:\s*(PASS|FAIL)(?:\s*[—-]\s*(.*))?/i);
+    if (!match) return { ok: true };
+    if (match[1].toUpperCase() === "PASS") return { ok: true };
+    return {
+      ok: false,
+      reason: `acceptance criteria not met: ${match[2]?.trim() || "judge rejected the result"}`
+    };
+  };
+}
 function makeCommandVerifier(options = {}) {
   const metadataKey = options.metadataKey ?? "verificationCommand";
   const timeoutMs = options.timeoutMs ?? 18e4;
@@ -4469,8 +4823,7 @@ function makeCommandVerifier(options = {}) {
     const cmd = info.task.metadata?.[metadataKey];
     if (typeof cmd !== "string" || !cmd.trim()) return { ok: true };
     return await new Promise((resolve) => {
-      const isWindows = process.platform === "win32";
-      const [shell, ...shellArgs] = isWindows ? ["cmd", "/d", "/c"] : ["sh", "-c"];
+      const [shell, ...shellArgs] = verificationShell(process.platform);
       const child = spawn(shell, [...shellArgs, cmd], {
         cwd: info.cwd,
         shell: false,
@@ -4492,7 +4845,6 @@ function makeCommandVerifier(options = {}) {
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        if (timedOut) return;
         resolve({ ok: false, reason: `verification spawn error: ${String(err)}` });
       });
     });
@@ -4500,10 +4852,7 @@ function makeCommandVerifier(options = {}) {
 }
 
 // src/decompose-task.ts
-import {
-  readBundledInstructionText,
-  renderInstructionTemplate
-} from "@wrongstack/core/utils";
+import { readBundledInstructionText, renderInstructionTemplate } from "@wrongstack/core/utils";
 var TASK_TYPES2 = /* @__PURE__ */ new Set(["feature", "bugfix", "refactor", "docs", "test", "chore"]);
 var PRIORITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low"]);
 function extractJsonArray(text) {
@@ -4527,48 +4876,144 @@ function buildPrompt(task, error, min, max) {
     error: error || "(none recorded)"
   });
 }
-function makeLlmSubtaskGenerator(opts) {
+function parseSubtaskSpecs(text, min, max, options = {}) {
+  const json = extractJsonArray(text ?? "");
+  if (!json) return [];
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    return [];
+  }
+  const items = raw;
+  const specs = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const r = item;
+    const title = typeof r["title"] === "string" ? r["title"].trim() : "";
+    const description = typeof r["description"] === "string" ? r["description"].trim() : "";
+    if (!title || !description) continue;
+    const type = TASK_TYPES2.has(r["type"]) ? r["type"] : void 0;
+    const priority = PRIORITIES.has(r["priority"]) ? r["priority"] : void 0;
+    const successCriterion = options.acceptSuccessCriterion && typeof r["successCriterion"] === "string" ? r["successCriterion"].trim() || void 0 : void 0;
+    specs.push({ title, description, type, priority, successCriterion });
+    if (specs.length >= max) break;
+  }
+  return specs.length >= min ? specs : [];
+}
+function makePlanningDecomposer(opts) {
   const min = Math.max(2, opts.minSubtasks ?? 2);
-  const max = Math.max(min, opts.maxSubtasks ?? 4);
-  return async function generateSubtasks(info) {
+  const max = Math.max(min, opts.maxSubtasks ?? 5);
+  return async function decompose(info) {
     let text;
     try {
-      text = await opts.run(buildPrompt(info.task, info.error, min, max));
+      text = await opts.run(
+        renderInstructionTemplate(readBundledInstructionText("sdd/decompose-task-planning.md"), {
+          minSubtasks: String(min),
+          maxSubtasks: String(max),
+          title: info.title,
+          description: info.description,
+          reasons: info.reasons.length ? info.reasons.map((r) => `- ${r}`).join("\n") : "- (unspecified)"
+        })
+      );
     } catch {
       return [];
     }
-    const json = extractJsonArray(text ?? "");
-    if (!json) return [];
-    let raw;
+    return parseSubtaskSpecs(text, min, max, { acceptSuccessCriterion: true });
+  };
+}
+function makeLlmSubtaskGenerator(opts) {
+  const min = Math.max(2, opts.minSubtasks ?? 2);
+  const max = Math.max(min, opts.maxSubtasks ?? 4);
+  return async function generateSubtasks(info) {
+    let text;
     try {
-      raw = JSON.parse(json);
+      text = await opts.run(buildPrompt(info.task, info.error, min, max));
     } catch {
       return [];
     }
-    if (!Array.isArray(raw)) return [];
-    const specs = [];
-    for (const item of raw) {
-      if (!item || typeof item !== "object") continue;
-      const r = item;
-      const title = typeof r["title"] === "string" ? r["title"].trim() : "";
-      const description = typeof r["description"] === "string" ? r["description"].trim() : "";
-      if (!title || !description) continue;
-      const type = TASK_TYPES2.has(r["type"]) ? r["type"] : void 0;
-      const priority = PRIORITIES.has(r["priority"]) ? r["priority"] : void 0;
-      specs.push({ title, description, type, priority });
-      if (specs.length >= max) break;
-    }
-    return specs.length >= min ? specs : [];
+    return parseSubtaskSpecs(text, min, max);
   };
 }
 
-// src/conflict-resolver.ts
-import { readFile as readFile4, writeFile } from "node:fs/promises";
-import { join as join4, isAbsolute } from "node:path";
+// src/plan-decompose.ts
 import {
-  readBundledInstructionText as readBundledInstructionText2,
-  renderInstructionTemplate as renderInstructionTemplate2
-} from "@wrongstack/core/utils";
+  assessAtomicity as assessAtomicity2
+} from "@wrongstack/kanban";
+function countAcceptanceCriteria(description) {
+  const marker = description.indexOf("**Acceptance Criteria:**");
+  if (marker === -1) return 0;
+  const tail = description.slice(marker);
+  return (tail.match(/^\s*-\s+\S/gm) ?? []).length;
+}
+function assessTaskNodeAtomicity(tracker, node, config) {
+  const criteriaCount = countAcceptanceCriteria(node.description ?? "");
+  const verificationCommand = node.metadata?.["verificationCommand"] ?? extractVerificationCommand([node.description ?? ""]);
+  return assessAtomicity2(
+    {
+      title: node.title,
+      description: node.description,
+      estimatedHours: node.estimateHours,
+      dependencyCount: tracker.getBlockers(node.id).length,
+      successCriteriaCount: criteriaCount,
+      hasVerifiableOutput: Boolean(verificationCommand),
+      childCount: tracker.getAllNodes().filter((n) => n.parentId === node.id).length
+    },
+    config
+  );
+}
+async function decomposeNonAtomicTasks(opts) {
+  const maxDecompositions = Math.max(1, opts.maxDecompositions ?? 10);
+  const result = { applied: [], proposals: [], flagged: [] };
+  const nodes = opts.tracker.getAllNodes();
+  const childCounts = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (node.parentId) childCounts.set(node.parentId, (childCounts.get(node.parentId) ?? 0) + 1);
+  }
+  const candidates = nodes.filter(
+    (node) => node.status === "pending" && !childCounts.get(node.id)
+  );
+  let spent = 0;
+  for (const node of candidates) {
+    if (spent >= maxDecompositions) break;
+    const assessment = assessTaskNodeAtomicity(opts.tracker, node, opts.config);
+    opts.tracker.patchMetadata(node.id, {
+      atomicity: {
+        verdict: assessment.verdict,
+        score: assessment.score,
+        reasons: assessment.criteria.filter((c) => c.score < 1).map((c) => c.reason)
+      }
+    });
+    if (assessment.verdict !== "needs_decomposition") continue;
+    result.flagged.push(node.id);
+    spent += 1;
+    const reasons = assessment.criteria.filter((c) => c.score < 1).map((c) => c.reason);
+    const subtasks = await opts.decompose({
+      title: node.title,
+      description: node.description ?? "",
+      reasons
+    });
+    if (!subtasks.length) continue;
+    if (opts.mode === "auto") {
+      const subtaskIds = splitGraphNode(opts.tracker, node.id, subtasks);
+      if (subtaskIds.length) result.applied.push({ nodeId: node.id, subtaskIds });
+    } else {
+      result.proposals.push({ nodeId: node.id, title: node.title, reasons, subtasks });
+    }
+  }
+  return result;
+}
+
+// src/conflict-resolver.ts
+import { readFile as readFile5, writeFile } from "node:fs/promises";
+import { isAbsolute, join as join6 } from "node:path";
+import { readBundledInstructionText as readBundledInstructionText2, renderInstructionTemplate as renderInstructionTemplate2 } from "@wrongstack/core/utils";
+var defaultFileIO = {
+  read: (path6) => readFile5(path6, "utf8"),
+  write: async (path6, content) => {
+    await writeFile(path6, content, "utf8");
+  }
+};
 var START = "<<<<<<<";
 var BASE = "|||||||";
 var SEP = "=======";
@@ -4606,21 +5051,21 @@ function hasConflictMarkers(text) {
     return m === START || m === SEP || m === END || m === BASE;
   });
 }
-function makePreferSideConflictResolver(side) {
+function makePreferSideConflictResolver(side, io = defaultFileIO) {
   return async function conflictResolver(info) {
     if (info.conflictFiles.length === 0) return false;
     for (const rel of info.conflictFiles) {
-      const abs = isAbsolute(rel) ? rel : join4(info.cwd, rel);
+      const abs = isAbsolute(rel) ? rel : join6(info.cwd, rel);
       let content;
       try {
-        content = await readFile4(abs, "utf8");
+        content = await io.read(abs);
       } catch {
         return false;
       }
       const resolved = resolveConflictText(content, side);
       if (hasConflictMarkers(resolved)) return false;
       try {
-        await writeFile(abs, resolved, "utf8");
+        await io.write(abs, resolved);
       } catch {
         return false;
       }
@@ -4640,13 +5085,14 @@ function nonMarkerLineCount(text) {
 }
 function makeLlmConflictResolver(opts) {
   const minFraction = opts.minRetainedFraction ?? 0.5;
+  const io = opts.io ?? defaultFileIO;
   return async function conflictResolver(info) {
     if (info.conflictFiles.length === 0) return false;
     for (const rel of info.conflictFiles) {
-      const abs = isAbsolute(rel) ? rel : join4(info.cwd, rel);
+      const abs = isAbsolute(rel) ? rel : join6(info.cwd, rel);
       let content;
       try {
-        content = await readFile4(abs, "utf8");
+        content = await io.read(abs);
       } catch {
         return false;
       }
@@ -4670,7 +5116,7 @@ function makeLlmConflictResolver(opts) {
         return false;
       }
       try {
-        await writeFile(abs, resolved, "utf8");
+        await io.write(abs, resolved);
       } catch {
         return false;
       }
@@ -4700,21 +5146,28 @@ export {
   TaskTracker3 as TaskTracker,
   analyzeCriticalPath,
   applySddLifecycle,
+  assessGeneratedTaskAtomicity,
+  assessTaskNodeAtomicity,
   buildBoardSnapshot,
   buildBoardTasks,
   cleanupSddWorktrees,
   cleanupStaleSddWorktrees,
   cleanupStaleWorktrees,
   createAutoExecutor,
+  decomposeNonAtomicTasks,
   destroySddProject,
   extractVerificationCommand,
+  gatherProjectContext,
   getTemplate,
   hasConflictMarkers,
   isExplanatoryText,
   listTemplates,
+  makeAcceptanceCriteriaVerifier,
   makeCommandVerifier,
+  makeCompositeVerifier,
   makeLlmConflictResolver,
   makeLlmSubtaskGenerator,
+  makePlanningDecomposer,
   makePreferSideConflictResolver,
   renderProgress,
   renderSpecAnalysis,
@@ -4723,6 +5176,7 @@ export {
   resolveConflictText,
   rollbackSddRunFromDisk,
   shortIdMap,
+  splitGraphNode,
   startSddRun,
   templateToMarkdown
 };