@wrongstack/sdd 0.293.0 → 0.295.1

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";
 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) {
@@ -549,7 +623,7 @@ var SpecDrivenDev = class {
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
-import { atomicWrite, ensureDir } from "@wrongstack/core";
+import { atomicWrite, ensureDir } from "@wrongstack/core/utils";
 var SpecStore = class {
   baseDir;
   indexPath;
@@ -663,7 +737,7 @@ var SpecStore = class {
 // src/task-graph-store.ts
 import * as fsp2 from "node:fs/promises";
 import * as path2 from "node:path";
-import { atomicWrite as atomicWrite2, ensureDir as ensureDir2 } from "@wrongstack/core";
+import { atomicWrite as atomicWrite2, ensureDir as ensureDir2 } from "@wrongstack/core/utils";
 function graphToJSON(graph) {
   const serialisable = {
     ...graph,
@@ -762,7 +836,7 @@ var TaskGraphStore = class {
 };
 
 // src/board-types.ts
-import { computeTaskProgress } from "@wrongstack/core/types";
+import { computeTaskProgress } from "@wrongstack/core/tasking";
 function shortIdMap(graph) {
   const nodes = Array.from(graph.nodes.values()).sort((a, b) => a.createdAt - b.createdAt);
   const m = /* @__PURE__ */ new Map();
@@ -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) {
@@ -854,13 +930,36 @@ function buildBoardSnapshot(graph, run, now) {
 // src/sdd-board-store.ts
 import * as fsp3 from "node:fs/promises";
 import * as path3 from "node:path";
-import { atomicWrite as atomicWrite3, ensureDir as ensureDir3 } from "@wrongstack/core";
+import { atomicWrite as atomicWrite3, ensureDir as ensureDir3, withFileLock } from "@wrongstack/core/utils";
+var DEFAULT_EVENT_MAX_BYTES = 16 * 1024 * 1024;
+var DEFAULT_EVENT_KEEP_BYTES = 8 * 1024 * 1024;
+var DEFAULT_EVENT_SIZE_CHECK_EVERY = 100;
 var SddBoardStore = class {
   baseDir;
   indexPath;
+  eventMaxBytes;
+  eventKeepBytes;
+  eventSizeCheckEvery;
+  controlFileIO;
+  eventChains = /* @__PURE__ */ new Map();
+  eventWritesSinceCheck = /* @__PURE__ */ new Map();
+  controlDrains = /* @__PURE__ */ new Map();
+  baseDirReady;
+  cachedIndex;
+  cachedIndexSignature = null;
   constructor(opts) {
     this.baseDir = opts.baseDir;
     this.indexPath = path3.join(this.baseDir, "_index.json");
+    this.eventMaxBytes = Math.max(1024, Math.floor(opts.eventMaxBytes ?? DEFAULT_EVENT_MAX_BYTES));
+    this.eventKeepBytes = Math.min(
+      this.eventMaxBytes,
+      Math.max(0, Math.floor(opts.eventKeepBytes ?? DEFAULT_EVENT_KEEP_BYTES))
+    );
+    this.eventSizeCheckEvery = Math.max(
+      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`);
@@ -872,7 +971,7 @@ var SddBoardStore = class {
     return path3.join(this.baseDir, `${this.safe(runId)}.control.jsonl`);
   }
   async saveSnapshot(snapshot) {
-    await ensureDir3(this.baseDir);
+    await this.ensureBaseDir();
     await atomicWrite3(this.snapshotPath(snapshot.runId), JSON.stringify(snapshot, null, 2), {
       mode: 384
     });
@@ -888,7 +987,12 @@ var SddBoardStore = class {
   }
   async list() {
     const index = await this.readIndex();
-    return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
+    return index.entries.map((entry) => ({ ...entry }));
+  }
+  /** Latest board metadata without cloning/sorting the complete index. */
+  async latest() {
+    const entry = (await this.readIndex()).entries[0];
+    return entry ? { ...entry } : void 0;
   }
   async loadLatestForSpec(specId) {
     const entry = (await this.list()).find((e) => e.specId === specId);
@@ -896,63 +1000,157 @@ var SddBoardStore = class {
   }
   /** Append one line to the board's JSONL event log (best-effort, never throws). */
   async appendEvent(runId, event) {
-    try {
-      await ensureDir3(this.baseDir);
-      await fsp3.appendFile(this.eventsPath(runId), `${JSON.stringify(event)}
-`, { mode: 384 });
-    } catch {
-    }
+    const filePath = this.eventsPath(runId);
+    const previous = this.eventChains.get(filePath) ?? Promise.resolve();
+    const write = previous.then(() => this.appendEventInternal(filePath, event)).catch(() => void 0);
+    this.eventChains.set(filePath, write);
+    await write;
+    if (this.eventChains.get(filePath) === write) this.eventChains.delete(filePath);
   }
   /** Append a control command (used by readers to steer a CLI-owned run). */
   async appendControl(runId, command) {
-    await ensureDir3(this.baseDir);
-    await fsp3.appendFile(this.controlPath(runId), `${JSON.stringify(command)}
-`, { mode: 384 });
+    await this.ensureBaseDir();
+    const filePath = this.controlPath(runId);
+    await withFileLock(
+      filePath,
+      () => fsp3.appendFile(filePath, `${JSON.stringify(command)}
+`, { mode: 384 })
+    );
   }
   /** Read + truncate the control queue (the run drains it). Returns parsed commands. */
   async drainControl(runId) {
-    const p = this.controlPath(runId);
-    let raw;
-    try {
-      raw = await fsp3.readFile(p, "utf8");
-    } catch {
+    const filePath = this.controlPath(runId);
+    const active = this.controlDrains.get(filePath);
+    if (active) {
+      await active;
       return [];
     }
+    const drain = this.drainControlInternal(filePath);
+    this.controlDrains.set(filePath, drain);
     try {
-      await fsp3.writeFile(p, "", { mode: 384 });
-    } catch {
+      return await drain;
+    } finally {
+      this.controlDrains.delete(filePath);
     }
-    return raw.split("\n").filter((l) => l.trim()).map((l) => {
-      try {
-        return JSON.parse(l);
-      } catch {
-        return null;
-      }
-    }).filter((c) => c !== null);
   }
   async delete(runId) {
+    const eventPath = this.eventsPath(runId);
+    await this.eventChains.get(eventPath);
+    this.eventChains.delete(eventPath);
     await Promise.allSettled([
       fsp3.unlink(this.snapshotPath(runId)),
-      fsp3.unlink(this.eventsPath(runId)),
+      fsp3.unlink(eventPath),
       fsp3.unlink(this.controlPath(runId))
     ]);
+    this.eventWritesSinceCheck.delete(eventPath);
     await this.removeFromIndex(runId);
   }
   // ── internal ────────────────────────────────────────────────────────────
   safe(runId) {
     return runId.replace(/[^a-zA-Z0-9._-]/g, "_");
   }
+  async ensureBaseDir() {
+    this.baseDirReady ??= ensureDir3(this.baseDir).catch((error) => {
+      this.baseDirReady = void 0;
+      throw error;
+    });
+    await this.baseDirReady;
+  }
+  async appendEventInternal(filePath, event) {
+    await this.ensureBaseDir();
+    await fsp3.appendFile(filePath, `${JSON.stringify(event)}
+`, { mode: 384 });
+    const writes = (this.eventWritesSinceCheck.get(filePath) ?? 0) + 1;
+    if (writes < this.eventSizeCheckEvery) {
+      this.eventWritesSinceCheck.set(filePath, writes);
+      return;
+    }
+    this.eventWritesSinceCheck.set(filePath, 0);
+    const stat2 = await fsp3.stat(filePath);
+    if (stat2.size <= this.eventMaxBytes) return;
+    await this.compactEventTail(filePath, stat2.size);
+  }
+  async compactEventTail(filePath, size) {
+    if (this.eventKeepBytes === 0) {
+      await atomicWrite3(filePath, "", { mode: 384 });
+      return;
+    }
+    const handle = await fsp3.open(filePath, "r");
+    let retained;
+    try {
+      const length = Math.min(size, this.eventKeepBytes);
+      const start = size - length;
+      const buffer = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(buffer, 0, length, start);
+      retained = buffer.subarray(0, bytesRead);
+      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();
+    }
+    await atomicWrite3(filePath, retained, { mode: 384 });
+  }
+  async drainControlInternal(filePath) {
+    try {
+      const stat2 = await this.controlFileIO.stat(filePath);
+      if (stat2.size === 0) return [];
+    } catch {
+      return [];
+    }
+    return withFileLock(filePath, async () => {
+      let raw;
+      try {
+        const stat2 = await this.controlFileIO.stat(filePath);
+        if (stat2.size === 0) return [];
+        raw = await this.controlFileIO.readFile(filePath, "utf8");
+      } catch {
+        return [];
+      }
+      try {
+        await this.controlFileIO.truncate(filePath, 0);
+      } catch {
+        return [];
+      }
+      return raw.split("\n").filter((line) => line.trim()).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(
+        (command) => command !== null
+      );
+    });
+  }
   async readIndex() {
+    const signature = await this.indexSignature();
+    if (this.cachedIndex && sameIndexSignature(signature, this.cachedIndexSignature)) {
+      return this.cachedIndex;
+    }
     try {
       const raw = await fsp3.readFile(this.indexPath, "utf8");
       const parsed = JSON.parse(raw);
-      if (parsed?.version === 1) return parsed;
+      if (parsed?.version === 1) {
+        parsed.entries.sort((a, b) => b.updatedAt - a.updatedAt);
+        this.cachedIndex = parsed;
+        this.cachedIndexSignature = signature;
+        return parsed;
+      }
     } catch {
     }
-    return { version: 1, entries: [] };
+    this.cachedIndex = { version: 1, entries: [] };
+    this.cachedIndexSignature = signature;
+    return this.cachedIndex;
   }
   async updateIndex(snapshot) {
-    const index = await this.readIndex();
+    const current = await this.readIndex();
+    const index = {
+      version: 1,
+      entries: current.entries.map((entry2) => ({ ...entry2 }))
+    };
     const entry = {
       runId: snapshot.runId,
       specId: snapshot.specId,
@@ -965,17 +1163,37 @@ var SddBoardStore = class {
     const idx = index.entries.findIndex((e) => e.runId === snapshot.runId);
     if (idx >= 0) index.entries[idx] = entry;
     else index.entries.push(entry);
+    index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
     await atomicWrite3(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+    this.cachedIndex = index;
+    this.cachedIndexSignature = await this.indexSignature();
   }
   async removeFromIndex(runId) {
-    const index = await this.readIndex();
-    index.entries = index.entries.filter((e) => e.runId !== runId);
+    const current = await this.readIndex();
+    const index = {
+      version: 1,
+      entries: current.entries.filter((entry) => entry.runId !== runId).map((entry) => ({ ...entry }))
+    };
     await atomicWrite3(this.indexPath, JSON.stringify(index, null, 2), { mode: 384 });
+    this.cachedIndex = index;
+    this.cachedIndexSignature = await this.indexSignature();
+  }
+  async indexSignature() {
+    try {
+      const stat2 = await fsp3.stat(this.indexPath);
+      return { size: stat2.size, mtimeMs: stat2.mtimeMs, ctimeMs: stat2.ctimeMs };
+    } catch {
+      return null;
+    }
   }
 };
+function sameIndexSignature(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+}
 
 // src/sdd-board-projector.ts
-import { DefaultSecretScrubber } from "@wrongstack/core";
+import { DefaultSecretScrubber } from "@wrongstack/core/security";
 function summarizeToolInput(input, scrubber) {
   if (!input || typeof input !== "object" || Array.isArray(input)) return void 0;
   const record = input;
@@ -1017,11 +1235,12 @@ var SddBoardProjector = class _SddBoardProjector {
   mergedCommits = [];
   /** Base branch reported by the run at start (overrides the constructor option). */
   runBaseBranch;
-  dirty = false;
   timer = null;
   unsubs = [];
-  /** Tail of in-flight persistence, so callers can await a settled state. */
-  lastSave = Promise.resolve();
+  /** Latest snapshot waiting behind an in-flight disk write. */
+  pendingSnapshot;
+  /** At most one persistence loop runs; intermediate snapshots are coalesced. */
+  saveLoop;
   constructor(opts) {
     this.o = opts;
     this.now = opts.now ?? Date.now;
@@ -1044,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) => {
@@ -1052,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) => {
@@ -1232,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);
@@ -1257,7 +1485,7 @@ var SddBoardProjector = class _SddBoardProjector {
   }
   /** Resolve once all in-flight snapshot persistence has settled. */
   async drain() {
-    await this.lastSave;
+    while (this.saveLoop) await this.saveLoop;
   }
   /** Stop projecting and release subscriptions. */
   dispose() {
@@ -1324,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;
@@ -1345,8 +1571,23 @@ var SddBoardProjector = class _SddBoardProjector {
       snapshot: snap
     });
     if (this.o.store) {
-      const store = this.o.store;
-      this.lastSave = this.lastSave.then(() => store.saveSnapshot(snap)).catch(() => {
+      this.pendingSnapshot = snap;
+      this.startSaveLoop(this.o.store);
+    }
+  }
+  startSaveLoop(store) {
+    if (this.saveLoop) return;
+    const loop = this.persistPendingSnapshots(store);
+    this.saveLoop = loop;
+    void loop.finally(() => {
+      this.saveLoop = void 0;
+    });
+  }
+  async persistPendingSnapshots(store) {
+    while (this.pendingSnapshot) {
+      const snapshot = this.pendingSnapshot;
+      this.pendingSnapshot = void 0;
+      await store.saveSnapshot(snapshot).catch(() => {
       });
     }
   }
@@ -1370,10 +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 } from "@wrongstack/core";
-import { toErrorMessage } from "@wrongstack/core";
-import { SddError as SddError2, ERROR_CODES as ERROR_CODES2 } from "@wrongstack/core";
+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);
@@ -1422,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}`);
     }
   }
@@ -1595,7 +1838,7 @@ var AISpecBuilder = class {
     try {
       const fsp5 = await import("node:fs/promises");
       const path4 = await import("node:path");
-      const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core");
+      const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
       await fsp5.mkdir(path4.dirname(this.sessionPath), { recursive: true });
       await atomicWrite4(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
@@ -1625,17 +1868,9 @@ var AISpecBuilder = class {
     } 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. */
@@ -1809,7 +2044,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") {
@@ -1821,7 +2056,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({
@@ -1832,7 +2067,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
@@ -1840,7 +2083,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) : []
@@ -1929,7 +2174,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;
@@ -2142,16 +2386,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);
@@ -2164,13 +2409,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"];
@@ -2195,14 +2440,51 @@ function isExplanatoryText(text) {
 }
 
 // src/start-sdd-run.ts
-import { TOKENS } from "@wrongstack/core";
+import { TOKENS } from "@wrongstack/core/kernel";
 
 // src/sdd-parallel-run.ts
-import { expectDefined as expectDefined2 } from "@wrongstack/core";
+import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { makeAgentSubagentRunner, withDisabledToolFiltering, DefaultMultiAgentCoordinator } from "@wrongstack/core/coordination";
-import { assignNickname } from "@wrongstack/core";
-import { SddError as SddError3, ERROR_CODES as ERROR_CODES3 } from "@wrongstack/core";
+import {
+  assignNickname,
+  DefaultMultiAgentCoordinator,
+  makeAgentSubagentRunner,
+  withDisabledToolFiltering
+} from "@wrongstack/core/coordination";
+import { ERROR_CODES as ERROR_CODES3, SddError as SddError3 } from "@wrongstack/core/types";
+
+// 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-decomposer.ts
 var SddTaskDecomposer = class {
@@ -2326,7 +2608,9 @@ var SddParallelRun = class {
     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;
@@ -2449,7 +2733,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" };
@@ -2482,7 +2767,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). */
@@ -2514,7 +2802,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(() => {
@@ -2545,30 +2838,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;
   }
@@ -2616,7 +2891,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);
@@ -2630,16 +2910,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) {
@@ -2670,7 +2952,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", {
@@ -2868,10 +3149,11 @@ var SddParallelRun = class {
     }
     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
-    });
+    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();
@@ -2881,7 +3163,7 @@ var SddParallelRun = class {
     const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : this.opts.fallbackModels;
     const spawnResult = await coordinator.spawn({
       id: subagentId,
-      name: agentName ?? subagentId,
+      name: agentName,
       role: "executor",
       // Idle reaper is always on; the hard wall-clock cap only when opted in.
       idleTimeoutMs: this.idleTimeoutMs,
@@ -2903,7 +3185,7 @@ var SddParallelRun = class {
       runId: this.runId,
       taskId,
       subagentId,
-      agentName: agentName ?? "",
+      agentName,
       worktreeBranch: this.taskBranches.get(taskId)
     });
     const directivePreamble = [
@@ -2938,7 +3220,7 @@ var SddParallelRun = class {
     let result;
     try {
       const got = await coordinator.awaitTasks([correlationId]);
-      result = expectDefined2(got[0]);
+      result = expectDefined3(got[0]);
     } catch (err) {
       result = {
         subagentId,
@@ -2966,12 +3248,22 @@ var SddParallelRun = class {
       } catch (err) {
         verificationFailReason = `verification error: ${String(err)}`;
       }
+      const hadVerifiable = typeof task.metadata?.["verificationCommand"] === "string" || task.description.includes("**Acceptance Criteria:**");
       if (verificationFailReason) {
+        this.opts.tracker.patchMetadata(taskId, {
+          verificationState: "failed",
+          verificationDetail: verificationFailReason
+        });
         this.emit("sdd.task.verification_failed", {
           runId: this.runId,
           taskId,
           reason: verificationFailReason
         });
+      } else if (hadVerifiable) {
+        this.opts.tracker.patchMetadata(taskId, {
+          verificationState: "passed",
+          verificationDetail: void 0
+        });
       }
     }
     let success = false;
@@ -2996,12 +3288,13 @@ var SddParallelRun = class {
         });
         await this.applyTaskFailure(taskId, subagentId, merged.reason);
       } else {
+        const conflictFiles = merged.conflictFiles ?? [];
         this.emit("sdd.task.conflict", {
           runId: this.runId,
           taskId,
-          conflictFiles: merged.conflictFiles ?? []
+          conflictFiles
         });
-        const reason = `merge conflict${merged.conflictFiles?.length ? `: ${merged.conflictFiles.join(", ")}` : ""}`;
+        const reason = `merge conflict${conflictFiles.length ? `: ${conflictFiles.join(", ")}` : ""}`;
         await this.applyTaskFailure(taskId, subagentId, reason);
       }
     } else {
@@ -3104,7 +3397,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) {
@@ -3116,7 +3413,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)}`;
           }
@@ -3232,6 +3530,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({
@@ -3295,25 +3619,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(() => {
     });
@@ -3341,7 +3647,8 @@ function startSddRun(opts) {
 
 // src/sdd-lifecycle.ts
 import * as fsp4 from "node:fs/promises";
-import { WorktreeManager } from "@wrongstack/core";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+import { WorktreeManager } from "@wrongstack/core/worktree";
 async function cleanupSddWorktrees(projectRoot) {
   const wt = new WorktreeManager({ projectRoot });
   return wt.cleanupAllManaged();
@@ -3352,19 +3659,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 });
@@ -3381,7 +3690,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) {
@@ -3399,7 +3712,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;
@@ -3426,9 +3739,6 @@ async function destroySddProject(opts) {
   await rmDir(opts.paths.projectSddBoards, "boards");
   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") {
@@ -3460,7 +3770,7 @@ 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) };
   }
 }
 
@@ -3581,8 +3891,8 @@ function templateToMarkdown(template, title) {
 }
 
 // src/task-visualizer.ts
-import { computeTaskProgress as computeTaskProgress2 } from "@wrongstack/core/types";
-import { truncate } from "@wrongstack/core";
+import { computeTaskProgress as computeTaskProgress2 } from "@wrongstack/core/tasking";
+import { expectDefined as expectDefined4, truncate } from "@wrongstack/core/utils";
 var STATUS_ICON = {
   pending: "\u25CB",
   in_progress: "\u25D0",
@@ -3609,7 +3919,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);
@@ -3644,8 +3956,7 @@ 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];
@@ -3686,7 +3997,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;
@@ -3734,8 +4045,8 @@ function renderSpecAnalysis(spec, analysis) {
 }
 
 // src/critical-path.ts
-import { expectDefined as expectDefined3 } from "@wrongstack/core";
-import { topologicalSort } from "@wrongstack/core/types";
+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);
@@ -3789,8 +4100,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) => {
@@ -3811,7 +4121,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) {
@@ -3846,7 +4156,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);
@@ -3857,9 +4167,9 @@ 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;
@@ -3894,8 +4204,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);
@@ -3907,7 +4216,7 @@ function computeParallelGroups(graph, blockedByMap) {
 }
 
 // src/spec-versioning.ts
-import { assertNever } from "@wrongstack/core";
+import { assertNever } from "@wrongstack/core/utils";
 var SpecVersioning = class {
   versions = /* @__PURE__ */ new Map();
   /** Record a new version of a spec. */
@@ -4109,7 +4418,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) {
@@ -4159,14 +4467,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);
@@ -4210,7 +4518,6 @@ var AutoExecutor = class {
         };
       }
     }
-    return { result: { success: false, error: "Max retries exceeded" }, retries: retryCount };
   }
   /** Get tasks that this task depends on. */
   getTaskDependencies(taskId, graph) {
@@ -4243,7 +4550,7 @@ function createAutoExecutor(opts) {
 }
 
 // src/sdd-supervisor.ts
-import { parseModelRef } from "@wrongstack/core";
+import { parseModelRef } from "@wrongstack/core/agent";
 var SddSupervisor = class {
   constructor(opts) {
     this.opts = opts;
@@ -4297,6 +4604,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;
@@ -4304,8 +4659,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,
@@ -4327,7 +4681,6 @@ function makeCommandVerifier(options = {}) {
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        if (timedOut) return;
         resolve({ ok: false, reason: `verification spawn error: ${String(err)}` });
       });
     });
@@ -4335,10 +4688,7 @@ function makeCommandVerifier(options = {}) {
 }
 
 // src/decompose-task.ts
-import {
-  readBundledInstructionText,
-  renderInstructionTemplate
-} from "@wrongstack/core";
+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) {
@@ -4362,48 +4712,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 as writeFile2 } 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";
+  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 readFile4, writeFile } from "node:fs/promises";
+import { isAbsolute, join as join4 } from "node:path";
+import { readBundledInstructionText as readBundledInstructionText2, renderInstructionTemplate as renderInstructionTemplate2 } from "@wrongstack/core/utils";
+var defaultFileIO = {
+  read: (path4) => readFile4(path4, "utf8"),
+  write: async (path4, content) => {
+    await writeFile(path4, content, "utf8");
+  }
+};
 var START = "<<<<<<<";
 var BASE = "|||||||";
 var SEP = "=======";
@@ -4441,21 +4887,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);
       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 writeFile2(abs, resolved, "utf8");
+        await io.write(abs, resolved);
       } catch {
         return false;
       }
@@ -4475,13 +4921,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);
       let content;
       try {
-        content = await readFile4(abs, "utf8");
+        content = await io.read(abs);
       } catch {
         return false;
       }
@@ -4505,7 +4952,7 @@ function makeLlmConflictResolver(opts) {
         return false;
       }
       try {
-        await writeFile2(abs, resolved, "utf8");
+        await io.write(abs, resolved);
       } catch {
         return false;
       }
@@ -4535,21 +4982,27 @@ export {
   TaskTracker3 as TaskTracker,
   analyzeCriticalPath,
   applySddLifecycle,
+  assessGeneratedTaskAtomicity,
+  assessTaskNodeAtomicity,
   buildBoardSnapshot,
   buildBoardTasks,
   cleanupSddWorktrees,
   cleanupStaleSddWorktrees,
   cleanupStaleWorktrees,
   createAutoExecutor,
+  decomposeNonAtomicTasks,
   destroySddProject,
   extractVerificationCommand,
   getTemplate,
   hasConflictMarkers,
   isExplanatoryText,
   listTemplates,
+  makeAcceptanceCriteriaVerifier,
   makeCommandVerifier,
+  makeCompositeVerifier,
   makeLlmConflictResolver,
   makeLlmSubtaskGenerator,
+  makePlanningDecomposer,
   makePreferSideConflictResolver,
   renderProgress,
   renderSpecAnalysis,
@@ -4558,6 +5011,7 @@ export {
   resolveConflictText,
   rollbackSddRunFromDisk,
   shortIdMap,
+  splitGraphNode,
   startSddRun,
   templateToMarkdown
 };