@wrongstack/sdd 0.292.1 → 0.295.0

package/dist/index.js

@@ -356,7 +356,7 @@ import {
 } from "@wrongstack/core/tasking";
 
 // src/task-flow.ts
-import { SddError, ERROR_CODES } from "@wrongstack/core";
+import { SddError, ERROR_CODES } from "@wrongstack/core/types";
 import { DefaultTaskStore, TaskTracker } from "@wrongstack/core/tasking";
 var TaskFlow = class {
   constructor(opts) {
@@ -549,7 +549,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 +663,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 +762,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();
@@ -854,13 +854,34 @@ 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;
+  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)
+    );
   }
   snapshotPath(runId) {
     return path3.join(this.baseDir, `${this.safe(runId)}.json`);
@@ -872,7 +893,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 +909,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 +922,160 @@ 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 {
+      if (this.controlDrains.get(filePath) === drain) 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)?.catch(() => void 0);
+    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);
+      if (start > 0 && retained.length > 0) {
+        const previous = Buffer.allocUnsafe(1);
+        const preceding = await handle.read(previous, 0, 1, start - 1);
+        if (preceding.bytesRead !== 1 || previous[0] !== 10) {
+          const firstNewline = retained.indexOf(10);
+          retained = firstNewline >= 0 ? retained.subarray(firstNewline + 1) : retained.subarray(0, 0);
+        }
+      }
+    } finally {
+      await handle.close();
+    }
+    await atomicWrite3(filePath, retained, { mode: 384 });
+  }
+  async drainControlInternal(filePath) {
+    try {
+      const stat2 = await fsp3.stat(filePath);
+      if (stat2.size === 0) return [];
+    } catch {
+      return [];
+    }
+    return withFileLock(filePath, async () => {
+      let raw;
+      try {
+        const stat2 = await fsp3.stat(filePath);
+        if (stat2.size === 0) return [];
+        raw = await fsp3.readFile(filePath, "utf8");
+      } catch {
+        return [];
+      }
+      try {
+        await fsp3.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 +1088,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;
@@ -1020,8 +1163,10 @@ var SddBoardProjector = class _SddBoardProjector {
   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;
@@ -1257,7 +1402,12 @@ var SddBoardProjector = class _SddBoardProjector {
   }
   /** Resolve once all in-flight snapshot persistence has settled. */
   async drain() {
-    await this.lastSave;
+    for (; ; ) {
+      const observed = this.saveLoop;
+      if (!observed) return;
+      await observed;
+      if (observed === this.saveLoop && !this.pendingSnapshot) return;
+    }
   }
   /** Stop projecting and release subscriptions. */
   dispose() {
@@ -1345,8 +1495,25 @@ 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(() => {
+      if (this.saveLoop !== loop) return;
+      this.saveLoop = void 0;
+      if (this.pendingSnapshot) this.startSaveLoop(store);
+    });
+  }
+  async persistPendingSnapshots(store) {
+    while (this.pendingSnapshot) {
+      const snapshot = this.pendingSnapshot;
+      this.pendingSnapshot = void 0;
+      await store.saveSnapshot(snapshot).catch(() => {
       });
     }
   }
@@ -1371,9 +1538,8 @@ var SddRunRegistry = class {
 };
 
 // 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 { expectDefined, toErrorMessage } from "@wrongstack/core/utils";
+import { SddError as SddError2, ERROR_CODES as ERROR_CODES2 } from "@wrongstack/core/types";
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -1595,7 +1761,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 {
@@ -2195,14 +2361,13 @@ 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 expectDefined2 } 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, makeAgentSubagentRunner, withDisabledToolFiltering, DefaultMultiAgentCoordinator } from "@wrongstack/core/coordination";
+import { SddError as SddError3, ERROR_CODES as ERROR_CODES3 } from "@wrongstack/core/types";
 
 // src/sdd-task-decomposer.ts
 var SddTaskDecomposer = class {
@@ -3341,7 +3506,7 @@ function startSddRun(opts) {
 
 // src/sdd-lifecycle.ts
 import * as fsp4 from "node:fs/promises";
-import { WorktreeManager } from "@wrongstack/core";
+import { WorktreeManager } from "@wrongstack/core/worktree";
 async function cleanupSddWorktrees(projectRoot) {
   const wt = new WorktreeManager({ projectRoot });
   return wt.cleanupAllManaged();
@@ -3581,8 +3746,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 { truncate as truncate2 } from "@wrongstack/core/utils";
 var STATUS_ICON = {
   pending: "\u25CB",
   in_progress: "\u25D0",
@@ -3649,14 +3814,14 @@ function renderNode(graph, nodeId, lines, rendered, childrenMap, compact, prefix
   const icon = STATUS_ICON[node.status];
   const prioIcon = PRIORITY_ICON[node.priority];
   const typeIcon = TYPE_ICON[node.type];
-  const title = compact ? truncate(node.title, 40) : node.title;
+  const title = compact ? truncate2(node.title, 40) : node.title;
   const blockedBy = childrenMap.get(nodeId) ?? [];
   const depsStr = blockedBy.length > 0 ? ` \u2190 [${blockedBy.map((d) => graph.nodes.get(d)?.title?.slice(0, 12) ?? "?").join(", ")}]` : "";
   lines.push(`${prefix}${icon} ${typeIcon} ${prioIcon} ${title}${depsStr}`);
   if (!compact && node.description) {
     const descLines = node.description.split("\n").slice(0, 3);
     for (const dl of descLines) {
-      lines.push(`${prefix}  \u2514 ${truncate(dl, 60)}`);
+      lines.push(`${prefix}  \u2514 ${truncate2(dl, 60)}`);
     }
   }
   const dependents = graph.edges.filter((e) => e.type === "depends_on" && e.to === nodeId).map((e) => e.from).filter((id) => graph.nodes.has(id));
@@ -3734,8 +3899,8 @@ function renderSpecAnalysis(spec, analysis) {
 }
 
 // src/critical-path.ts
-import { expectDefined as expectDefined3 } from "@wrongstack/core";
-import { topologicalSort } from "@wrongstack/core/types";
+import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
+import { topologicalSort } from "@wrongstack/core/tasking";
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -3907,7 +4072,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. */
@@ -4243,7 +4408,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;
@@ -4338,7 +4503,7 @@ function makeCommandVerifier(options = {}) {
 import {
   readBundledInstructionText,
   renderInstructionTemplate
-} from "@wrongstack/core";
+} 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) {
@@ -4398,12 +4563,12 @@ function makeLlmSubtaskGenerator(opts) {
 }
 
 // src/conflict-resolver.ts
-import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { readFile as readFile4, writeFile } from "node:fs/promises";
 import { join as join4, isAbsolute } from "node:path";
 import {
   readBundledInstructionText as readBundledInstructionText2,
   renderInstructionTemplate as renderInstructionTemplate2
-} from "@wrongstack/core";
+} from "@wrongstack/core/utils";
 var START = "<<<<<<<";
 var BASE = "|||||||";
 var SEP = "=======";
@@ -4455,7 +4620,7 @@ function makePreferSideConflictResolver(side) {
       const resolved = resolveConflictText(content, side);
       if (hasConflictMarkers(resolved)) return false;
       try {
-        await writeFile2(abs, resolved, "utf8");
+        await writeFile(abs, resolved, "utf8");
       } catch {
         return false;
       }
@@ -4505,7 +4670,7 @@ function makeLlmConflictResolver(opts) {
         return false;
       }
       try {
-        await writeFile2(abs, resolved, "utf8");
+        await writeFile(abs, resolved, "utf8");
       } catch {
         return false;
       }