@wrongstack/sdd 0.296.4 → 0.297.0

package/dist/index.js

@@ -424,7 +424,7 @@ ${acLines}` : "") + blockedLine;
 // src/index.ts
 import {
   TaskTracker as TaskTracker3,
-  DefaultTaskStore as DefaultTaskStore3
+  DefaultTaskStore as DefaultTaskStore2
 } from "@wrongstack/core/tasking";
 
 // src/task-flow.ts
@@ -755,17 +755,24 @@ function graphFromJSON(raw) {
 var TaskGraphStore = class {
   baseDir;
   indexPath;
+  writeChain = Promise.resolve();
   constructor(opts) {
     this.baseDir = opts.baseDir;
     this.indexPath = path2.join(this.baseDir, "_index.json");
   }
   async save(graph) {
-    await ensureDir2(this.baseDir);
-    const filePath = this.filePath(graph.id);
-    await atomicWrite2(filePath, graphToJSON(graph), { mode: 384 });
-    await this.updateIndex(graph);
+    const snapshot = graphFromJSON(graphToJSON(graph));
+    const pending = this.writeChain.then(async () => {
+      await ensureDir2(this.baseDir);
+      const filePath = this.filePath(snapshot.id);
+      await atomicWrite2(filePath, graphToJSON(snapshot), { mode: 384 });
+      await this.updateIndex(snapshot);
+    });
+    this.writeChain = pending.catch(() => void 0);
+    await pending;
   }
   async load(id) {
+    await this.writeChain;
     try {
       const raw = await fsp2.readFile(this.filePath(id), "utf8");
       return graphFromJSON(raw);
@@ -774,10 +781,12 @@ var TaskGraphStore = class {
     }
   }
   async list() {
+    await this.writeChain;
     const index = await this.readIndex();
     return index.entries.sort((a, b) => b.updatedAt - a.updatedAt);
   }
   async delete(id) {
+    await this.writeChain;
     try {
       await fsp2.unlink(this.filePath(id));
       await this.removeFromIndex(id);
@@ -787,6 +796,7 @@ var TaskGraphStore = class {
     }
   }
   async exists(id) {
+    await this.writeChain;
     try {
       await fsp2.access(this.filePath(id));
       return true;
@@ -794,6 +804,18 @@ var TaskGraphStore = class {
       return false;
     }
   }
+  saveGraph(graph) {
+    return this.save(graph);
+  }
+  loadGraph(id) {
+    return this.load(id);
+  }
+  async listGraphs() {
+    return (await this.list()).map(({ id, title, updatedAt }) => ({ id, title, updatedAt }));
+  }
+  async deleteGraph(id) {
+    await this.delete(id);
+  }
   filePath(id) {
     return path2.join(this.baseDir, `${id}.json`);
   }
@@ -1007,7 +1029,7 @@ var SddBoardStore = class {
     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). */
+  /** Append a legacy control command. Production readers use Kanban IPC. */
   async appendControl(runId, command) {
     await this.ensureBaseDir();
     const filePath = this.controlPath(runId);
@@ -1017,7 +1039,7 @@ var SddBoardStore = class {
 `, { mode: 384 })
     );
   }
-  /** Read + truncate the control queue (the run drains it). Returns parsed commands. */
+  /** Read + truncate the legacy control queue for one-time migration. */
   async drainControl(runId) {
     const filePath = this.controlPath(runId);
     const active = this.controlDrains.get(filePath);
@@ -1612,11 +1634,20 @@ var SddRunRegistry = class {
 };
 
 // src/sdd-interview-driver.ts
-import { DefaultTaskStore as DefaultTaskStore2, TaskTracker as TaskTracker2 } from "@wrongstack/core/tasking";
+import { TaskTracker as TaskTracker2 } from "@wrongstack/core/tasking";
 
 // src/spec-builder.ts
 import { ERROR_CODES as ERROR_CODES2, SddError as SddError2 } from "@wrongstack/core/types";
 import { expectDefined as expectDefined2, toErrorMessage } from "@wrongstack/core/utils";
+
+// src/sdd-session-types.ts
+function isAISpecSession(value) {
+  if (!value || typeof value !== "object") return false;
+  const session = value;
+  return typeof session.id === "string" && typeof session.phase === "string" && typeof session.title === "string" && typeof session.userIntent === "string" && Array.isArray(session.answers) && typeof session.updatedAt === "number";
+}
+
+// src/spec-builder.ts
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -1813,11 +1844,13 @@ var AISpecBuilder = class {
   minQuestions;
   maxQuestions;
   sessionPath;
+  sessionPersistence;
   constructor(opts) {
     this.store = opts.store;
     this.minQuestions = opts.minQuestions ?? 2;
     this.maxQuestions = opts.maxQuestions ?? 10;
     this.sessionPath = opts.sessionPath;
+    this.sessionPersistence = opts.sessionPersistence;
     this.session = {
       id: crypto.randomUUID(),
       phase: "questioning",
@@ -1832,27 +1865,47 @@ var AISpecBuilder = class {
     };
   }
   // ── Session Persistence ──────────────────────────────────────────────────
-  /** Save session state to disk. */
+  /** Save session state to the configured durable owner. */
   async saveSession() {
-    if (!this.sessionPath) return;
+    if (!this.sessionPersistence && !this.sessionPath) return;
     try {
-      const fsp6 = await import("node:fs/promises");
+      if (this.sessionPersistence) {
+        await this.sessionPersistence.save(structuredClone(this.session));
+        return;
+      }
+      const fsp7 = await import("node:fs/promises");
       const path6 = await import("node:path");
       const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
-      await fsp6.mkdir(path6.dirname(this.sessionPath), { recursive: true });
-      await atomicWrite4(this.sessionPath, JSON.stringify(this.session, null, 2));
+      const sessionPath = expectDefined2(this.sessionPath);
+      await fsp7.mkdir(path6.dirname(sessionPath), { recursive: true });
+      await atomicWrite4(sessionPath, JSON.stringify(this.session, null, 2));
     } catch (error) {
-      console.warn(JSON.stringify({ level: "warn", event: "sdd.persist.failed", message: String(error), timestamp: Date.now() }));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "sdd.persist.failed",
+          message: String(error),
+          timestamp: Date.now()
+        })
+      );
     }
   }
-  /** Load session state from disk. Returns true if a session was loaded. */
+  /** Load session state from the configured durable owner. */
   async loadSession() {
+    if (this.sessionPersistence) {
+      const loaded = await this.sessionPersistence.load();
+      if (isAISpecSession(loaded)) {
+        this.session = loaded;
+        return true;
+      }
+      return false;
+    }
     if (!this.sessionPath) return false;
     try {
-      const fsp6 = await import("node:fs/promises");
-      const raw = await fsp6.readFile(this.sessionPath, "utf8");
+      const fsp7 = await import("node:fs/promises");
+      const raw = await fsp7.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
-      if (loaded?.id && loaded?.phase && loaded?.title) {
+      if (isAISpecSession(loaded)) {
         this.session = loaded;
         return true;
       }
@@ -1860,12 +1913,16 @@ var AISpecBuilder = class {
     }
     return false;
   }
-  /** Delete saved session from disk. */
+  /** Delete the saved session from the configured durable owner. */
   async deleteSession() {
+    if (this.sessionPersistence) {
+      await this.sessionPersistence.delete();
+      return;
+    }
     if (!this.sessionPath) return;
     try {
-      const fsp6 = await import("node:fs/promises");
-      await fsp6.unlink(this.sessionPath);
+      const fsp7 = await import("node:fs/promises");
+      await fsp7.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -2230,7 +2287,7 @@ var SddInterviewDriver = class {
   maxQuestions;
   tracker = null;
   graph = null;
-  /** Set when {@link loadExisting} successfully rehydrated a session from disk. */
+  /** Set when {@link loadExisting} successfully rehydrated a durable session. */
   resumedFromDisk = false;
   constructor(opts) {
     this.o = opts;
@@ -2239,6 +2296,7 @@ var SddInterviewDriver = class {
     this.builder = new AISpecBuilder({
       store: opts.specStore,
       sessionPath: opts.sessionPath,
+      sessionPersistence: opts.sessionPersistence,
       projectContext: opts.projectContext,
       minQuestions: this.minQuestions,
       maxQuestions: this.maxQuestions
@@ -2254,7 +2312,7 @@ var SddInterviewDriver = class {
     return this.builder.getAIPrompt();
   }
   /**
-   * Resume a previously-persisted interview from disk. Re-hydrates the task
+   * Resume a previously-persisted interview. Re-hydrates the task
    * graph too when one was already produced. Returns true if a session loaded.
    */
   async loadExisting() {
@@ -2265,7 +2323,7 @@ var SddInterviewDriver = class {
       const graph = await this.o.graphStore.load(graphId);
       if (graph) {
         this.graph = graph;
-        const tracker = new TaskTracker2({ store: new DefaultTaskStore2() });
+        const tracker = new TaskTracker2({ store: this.o.graphStore });
         tracker.setGraph(graph);
         this.tracker = tracker;
       }
@@ -2273,7 +2331,7 @@ var SddInterviewDriver = class {
     this.resumedFromDisk = true;
     return true;
   }
-  /** Drop the on-disk session (if any) and clear in-memory interview state. */
+  /** Drop the durable session (if any) and clear in-memory interview state. */
   async discard() {
     await this.builder.deleteSession();
     this.builder.resetForNewInterview();
@@ -2371,7 +2429,7 @@ var SddInterviewDriver = class {
     if (this.graph) return this.graph;
     const spec = this.builder.getSession().spec;
     if (!spec) return null;
-    const tracker = new TaskTracker2({ store: new DefaultTaskStore2() });
+    const tracker = new TaskTracker2({ store: this.o.graphStore });
     const generator = new TaskGenerator({
       taskTracker: tracker,
       verificationFromAcceptance: process.env["WRONGSTACK_SDD_VERIFY_FROM_ACCEPTANCE"] === "1"
@@ -2467,7 +2525,7 @@ var SddInterviewDriver = class {
     if (valid.length === 0) return void 0;
     const spec = this.builder.getSession().spec;
     if (!this.tracker) {
-      const tracker2 = new TaskTracker2({ store: new DefaultTaskStore2() });
+      const tracker2 = new TaskTracker2({ store: this.o.graphStore });
       this.graph = await tracker2.createGraph(spec.id, spec.title);
       this.tracker = tracker2;
     }
@@ -2521,6 +2579,12 @@ function isExplanatoryText(text) {
 
 // src/start-sdd-run.ts
 import { TOKENS } from "@wrongstack/core/kernel";
+import {
+  drainKanbanWorkflowCommands,
+  kanbanWorkflowId,
+  subscribeKanbanWorkflowCommands,
+  writeKanbanWorkflowState
+} from "@wrongstack/kanban";
 
 // src/sdd-parallel-run.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -3689,12 +3753,23 @@ function startSddRun(opts) {
     defaultProvider: opts.defaultProvider,
     fallbackModels: opts.fallbackModels
   });
+  const workflowId = kanbanWorkflowId("sdd", run.runId);
+  const legacyControl = opts.controlTransport === "legacy-file";
+  const legacyBoardState = opts.boardStateTransport === "legacy-file" || opts.boardStateTransport === void 0 && legacyControl;
+  const boardPersistence = legacyBoardState ? opts.boardStore : {
+    saveSnapshot: async (snapshot) => {
+      await writeKanbanWorkflowState(opts.projectRoot, workflowId, snapshot);
+    },
+    // Detailed events remain append-only audit artifacts; they are not read
+    // back as workflow authority.
+    appendEvent: (runId, event) => opts.boardStore.appendEvent(runId, event)
+  };
   const projector = new SddBoardProjector({
     runId: run.runId,
     graph: opts.graph,
     tracker: opts.tracker,
     events: opts.events,
-    store: opts.boardStore,
+    store: boardPersistence,
     sessionId: opts.sessionId,
     specId: opts.graph.specId,
     defaultModel: opts.defaultModel,
@@ -3724,21 +3799,82 @@ function startSddRun(opts) {
     snapshot: () => projector.snapshot(),
     isRunning: () => run.isRunning()
   });
-  const drainMs = opts.controlDrainMs ?? 500;
-  const controlTimer = setInterval(() => {
-    void opts.boardStore.drainControl(run.runId).then((cmds) => {
-      for (const c of cmds) {
-        applySddControlCommand(run, c);
+  let controlDrainInFlight = false;
+  let controlDisposed = false;
+  let unsubscribeControl;
+  const drainControl = async () => {
+    if (controlDrainInFlight || controlDisposed) return;
+    controlDrainInFlight = true;
+    try {
+      const commands = legacyControl ? await opts.boardStore.drainControl(run.runId) : await drainKanbanWorkflowCommands(opts.projectRoot, workflowId);
+      for (const command of commands) applySddControlCommand(run, command);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "sdd.control_drain_failed",
+          runId: run.runId,
+          workflowId,
+          transport: legacyControl ? "legacy-file" : "kanban",
+          message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    } finally {
+      controlDrainInFlight = false;
+    }
+  };
+  if (!legacyControl) {
+    void subscribeKanbanWorkflowCommands(opts.projectRoot, workflowId, () => {
+      void drainControl().catch(() => void 0);
+    }).then((unsubscribe) => {
+      if (controlDisposed) unsubscribe();
+      else {
+        unsubscribeControl = unsubscribe;
+        void drainControl().catch(() => void 0);
       }
-    }).catch(() => {
+    }).catch((error) => {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "sdd.control_subscribe_failed",
+          runId: run.runId,
+          workflowId,
+          message: error instanceof Error ? error.message : String(error),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    });
+  } else {
+    void opts.boardStore.drainControl(run.runId).then((commands) => {
+      for (const command of commands) applySddControlCommand(run, command);
+    }).catch((error) => {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "sdd.control_drain_failed",
+          runId: run.runId,
+          workflowId,
+          transport: "legacy-file",
+          message: error instanceof Error ? error.message : String(error),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     });
+  }
+  const drainMs = opts.controlDrainMs ?? 500;
+  const controlTimer = setInterval(() => {
+    void drainControl().catch(() => void 0);
   }, drainMs);
   controlTimer.unref?.();
   const completion = (async () => {
     try {
       return await run.run();
     } finally {
+      controlDisposed = true;
       clearInterval(controlTimer);
+      unsubscribeControl?.();
       await projector.drain().catch(() => {
       });
       projector.dispose();
@@ -3759,7 +3895,57 @@ 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";
+import {
+  deleteKanbanWorkflowState,
+  kanbanWorkflowId as kanbanWorkflowId2,
+  listBoards,
+  listKanbanWorkflowStates,
+  readKanbanWorkflowState,
+  removeBoard,
+  writeKanbanWorkflowState as writeKanbanWorkflowState2
+} from "@wrongstack/kanban";
+async function listSddSnapshots(projectRoot, boardsDir, transport) {
+  const legacyStore = new SddBoardStore({ baseDir: boardsDir });
+  if (transport === "kanban") {
+    const states = await listKanbanWorkflowStates(projectRoot, "sdd:");
+    const snapshots = states.map((state) => state.value).filter(isSddBoardSnapshot).sort((a, b) => b.updatedAt - a.updatedAt);
+    if (snapshots.length > 0) return snapshots;
+    const legacy = await loadLegacySnapshots(legacyStore);
+    for (const snapshot of legacy) {
+      await writeKanbanWorkflowState2(
+        projectRoot,
+        kanbanWorkflowId2("sdd", snapshot.runId),
+        snapshot
+      );
+    }
+    return legacy;
+  }
+  return loadLegacySnapshots(legacyStore);
+}
+async function loadSddSnapshot(projectRoot, boardsDir, runId, transport) {
+  const legacyStore = new SddBoardStore({ baseDir: boardsDir });
+  if (transport !== "kanban") return legacyStore.load(runId);
+  const state = await readKanbanWorkflowState(projectRoot, kanbanWorkflowId2("sdd", runId));
+  if (isSddBoardSnapshot(state?.value)) return state.value;
+  const legacy = await legacyStore.load(runId);
+  if (legacy) {
+    await writeKanbanWorkflowState2(projectRoot, kanbanWorkflowId2("sdd", runId), legacy);
+  }
+  return legacy;
+}
+async function loadLegacySnapshots(store) {
+  const snapshots = [];
+  for (const entry of await store.list()) {
+    const snapshot = await store.load(entry.runId);
+    if (snapshot) snapshots.push(snapshot);
+  }
+  return snapshots.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function isSddBoardSnapshot(value) {
+  if (!value || typeof value !== "object") return false;
+  const snapshot = value;
+  return typeof snapshot.runId === "string" && typeof snapshot.updatedAt === "number" && typeof snapshot.status === "string" && Array.isArray(snapshot.tasks);
+}
 async function cleanupSddWorktrees(projectRoot) {
   const wt = new WorktreeManager({ projectRoot });
   return wt.cleanupAllManaged();
@@ -3770,8 +3956,17 @@ async function cleanupStaleWorktrees(projectRoot) {
 }
 async function cleanupStaleSddWorktrees(opts) {
   const now = opts.now?.() ?? Date.now();
-  const store = new SddBoardStore({ baseDir: opts.boardsDir });
-  const latest = (await store.list())[0];
+  let latest;
+  try {
+    latest = (await listSddSnapshots(opts.projectRoot, opts.boardsDir, opts.stateTransport))[0];
+  } catch {
+    return {
+      swept: false,
+      removed: 0,
+      detected: 0,
+      skippedReason: "SDD workflow state is unavailable"
+    };
+  }
   if (latest) {
     const age = now - latest.updatedAt;
     if (latest.status === "running" && age < (opts.runningLiveMs ?? 12e4)) {
@@ -3795,10 +3990,10 @@ async function cleanupStaleSddWorktrees(opts) {
   }
 }
 async function rollbackSddRunFromDisk(opts) {
-  const store = new SddBoardStore({ baseDir: opts.boardsDir });
-  const runId = opts.runId ?? (await store.list())[0]?.runId;
+  const snapshots = await listSddSnapshots(opts.projectRoot, opts.boardsDir, opts.stateTransport);
+  const runId = opts.runId ?? snapshots[0]?.runId;
   if (!runId) return { ok: false, reverted: 0, reason: "no SDD board found to roll back" };
-  const snap = await store.load(runId);
+  const snap = snapshots.find((snapshot) => snapshot.runId === runId) ?? await loadSddSnapshot(opts.projectRoot, opts.boardsDir, runId, opts.stateTransport);
   if (!snap) return { ok: false, reverted: 0, reason: `board "${runId}" not found` };
   if (!snap.baseBranch) {
     return {
@@ -3822,7 +4017,8 @@ async function destroySddProject(opts) {
     const r = await rollbackSddRunFromDisk({
       projectRoot: opts.projectRoot,
       boardsDir: opts.paths.projectSddBoards,
-      runId: opts.runId
+      runId: opts.runId,
+      stateTransport: opts.stateTransport
     }).catch((err) => ({ ok: false, reverted: 0, reason: toErrorMessage2(err) }));
     reverted = r.reverted;
     revertOk = r.ok;
@@ -3852,6 +4048,16 @@ async function destroySddProject(opts) {
   await rmDir(opts.paths.projectSpecs, "specs");
   await rmDir(opts.paths.projectTaskGraphs, "task-graphs");
   await rmDir(opts.paths.projectSddBoards, "boards");
+  if (opts.stateTransport === "kanban") {
+    const states = await listKanbanWorkflowStates(opts.projectRoot, "sdd:").catch(() => []);
+    let removedStates = 0;
+    for (const state of states) {
+      if (await deleteKanbanWorkflowState(opts.projectRoot, state.workflowId).catch(() => false)) {
+        removedStates++;
+      }
+    }
+    if (removedStates > 0) deleted.push(`workflow-states(${removedStates})`);
+  }
   try {
     const mirrors = (await listBoards(opts.projectRoot)).filter((b) => b.tags?.includes("sdd"));
     let mirrorsRemoved = 0;
@@ -3873,7 +4079,8 @@ async function applySddLifecycle(op, opts) {
       const r2 = await rollbackSddRunFromDisk({
         projectRoot: opts.projectRoot,
         boardsDir: opts.paths.projectSddBoards,
-        runId: opts.runId
+        runId: opts.runId,
+        stateTransport: opts.stateTransport
       });
       return { op, ok: r2.ok, reverted: r2.reverted, reason: r2.reason };
     }
@@ -3881,7 +4088,8 @@ async function applySddLifecycle(op, opts) {
       projectRoot: opts.projectRoot,
       paths: opts.paths,
       revertMerged: opts.revertMerged,
-      runId: opts.runId
+      runId: opts.runId,
+      stateTransport: opts.stateTransport
     });
     return {
       op,
@@ -3898,15 +4106,85 @@ async function applySddLifecycle(op, opts) {
   }
 }
 
-// src/project-context.ts
+// src/kanban-sdd-session.ts
 import * as fsp5 from "node:fs/promises";
+import {
+  deleteKanbanWorkflowState as deleteKanbanWorkflowState2,
+  kanbanWorkflowId as kanbanWorkflowId3,
+  readKanbanWorkflowState as readKanbanWorkflowState2,
+  writeKanbanWorkflowState as writeKanbanWorkflowState3
+} from "@wrongstack/kanban";
+var SDD_SESSION_WORKFLOW_ID = kanbanWorkflowId3("sdd", "session");
+function createKanbanSddSessionPersistence(projectRoot, legacySessionPath) {
+  let revision;
+  let writeChain = Promise.resolve();
+  return {
+    async load() {
+      await writeChain;
+      const state = await readKanbanWorkflowState2(projectRoot, SDD_SESSION_WORKFLOW_ID);
+      if (state) {
+        revision = state.revision;
+        return isAISpecSession(state.value) ? structuredClone(state.value) : null;
+      }
+      const legacy = await readLegacySession(legacySessionPath);
+      if (!legacy) {
+        revision = 0;
+        return null;
+      }
+      const imported = await writeKanbanWorkflowState3(
+        projectRoot,
+        SDD_SESSION_WORKFLOW_ID,
+        legacy,
+        0
+      );
+      revision = imported.revision;
+      if (legacySessionPath) await fsp5.unlink(legacySessionPath).catch(() => void 0);
+      return structuredClone(legacy);
+    },
+    async save(session) {
+      const pending = writeChain.then(async () => {
+        if (revision === void 0) {
+          const current = await readKanbanWorkflowState2(projectRoot, SDD_SESSION_WORKFLOW_ID);
+          revision = current?.revision ?? 0;
+        }
+        const saved = await writeKanbanWorkflowState3(
+          projectRoot,
+          SDD_SESSION_WORKFLOW_ID,
+          session,
+          revision
+        );
+        revision = saved.revision;
+      });
+      writeChain = pending.catch(() => void 0);
+      await pending;
+    },
+    async delete() {
+      await writeChain;
+      await deleteKanbanWorkflowState2(projectRoot, SDD_SESSION_WORKFLOW_ID);
+      revision = 0;
+      if (legacySessionPath) await fsp5.unlink(legacySessionPath).catch(() => void 0);
+    }
+  };
+}
+async function readLegacySession(sessionPath) {
+  if (!sessionPath) return null;
+  try {
+    const value = JSON.parse(await fsp5.readFile(sessionPath, "utf8"));
+    return isAISpecSession(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/project-context.ts
+import * as fsp6 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 pkgRaw = await fsp6.readFile(pkgPath, "utf8");
     const pkg = JSON.parse(pkgRaw);
     parts.push(`Project: ${String(pkg.name ?? "unknown")}`);
     parts.push(`Description: ${String(pkg.description ?? "none")}`);
@@ -3923,20 +4201,20 @@ async function gatherProjectContext(projectRoot) {
   } catch {
   }
   try {
-    await fsp5.access(path5.join(root, "tsconfig.json"));
+    await fsp6.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 entries = await fsp6.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 entries = await fsp6.readdir(packagesDir, { withFileTypes: true });
     const pkgs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     if (pkgs.length > 0) {
       parts.push(
@@ -5081,11 +5359,11 @@ async function decomposeNonAtomicTasks(opts) {
 }
 
 // src/conflict-resolver.ts
-import { readFile as readFile5, writeFile } from "node:fs/promises";
+import { readFile as readFile6, 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"),
+  read: (path6) => readFile6(path6, "utf8"),
   write: async (path6, content) => {
     await writeFile(path6, content, "utf8");
   }
@@ -5203,7 +5481,7 @@ function makeLlmConflictResolver(opts) {
 export {
   AISpecBuilder,
   AutoExecutor,
-  DefaultTaskStore3 as DefaultTaskStore,
+  DefaultTaskStore2 as DefaultTaskStore,
   SPEC_TEMPLATES,
   SddBoardProjector,
   SddBoardStore,
@@ -5230,12 +5508,14 @@ export {
   cleanupStaleSddWorktrees,
   cleanupStaleWorktrees,
   createAutoExecutor,
+  createKanbanSddSessionPersistence,
   decomposeNonAtomicTasks,
   destroySddProject,
   extractVerificationCommand,
   gatherProjectContext,
   getTemplate,
   hasConflictMarkers,
+  isAISpecSession,
   isExplanatoryText,
   listTemplates,
   makeAcceptanceCriteriaVerifier,