@wrongstack/sdd 1.0.19 → 1.0.26

package/dist/index.js

@@ -739,9 +739,9 @@ var SpecDrivenDev = class {
 };
 
 // src/spec-store.ts
+import { randomUUID } from "node:crypto";
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-import { randomUUID } from "node:crypto";
 import { atomicWrite, ensureDir } from "@wrongstack/core/utils";
 var SpecStore = class {
   baseDir;
@@ -833,7 +833,7 @@ var SpecStore = class {
     const dir = path.resolve(this.baseDir);
     const resolved = path.resolve(dir, `${id}.json`);
     const rel = path.relative(dir, resolved);
-    if (rel.startsWith("..") || path.isAbsolute(rel) || rel.includes(path.sep)) {
+    if (rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel) || rel.includes(path.sep)) {
       throw new Error(`Invalid spec id: ${JSON.stringify(id)}`);
     }
     return resolved;
@@ -970,7 +970,7 @@ var TaskGraphStore = class {
     const dir = path2.resolve(this.baseDir);
     const resolved = path2.resolve(dir, `${id}.json`);
     const rel = path2.relative(dir, resolved);
-    if (rel.startsWith("..") || path2.isAbsolute(rel) || rel.includes(path2.sep)) {
+    if (rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel) || rel.includes(path2.sep)) {
       throw new Error(`Invalid task-graph id: ${JSON.stringify(id)}`);
     }
     return resolved;
@@ -1358,14 +1358,16 @@ var SddBoardStore = class {
     });
   }
   async removeFromIndex(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();
+    await withFileLock(this.indexPath, async () => {
+      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 {
@@ -2011,6 +2013,7 @@ var AISpecBuilder = class {
   store;
   minQuestions;
   maxQuestions;
+  projectContext;
   sessionPath;
   sessionPersistence;
   pendingSessionWrite = Promise.resolve();
@@ -2018,6 +2021,7 @@ var AISpecBuilder = class {
     this.store = opts.store;
     this.minQuestions = opts.minQuestions ?? 2;
     this.maxQuestions = opts.maxQuestions ?? 10;
+    this.projectContext = opts.projectContext ?? "";
     this.sessionPath = opts.sessionPath;
     this.sessionPersistence = opts.sessionPersistence;
     this.session = {
@@ -2025,7 +2029,7 @@ var AISpecBuilder = class {
       phase: "questioning",
       title: "",
       userIntent: "",
-      projectContext: opts.projectContext ?? "",
+      projectContext: this.projectContext,
       answers: [],
       questionCount: 0,
       approved: false,
@@ -2105,10 +2109,11 @@ var AISpecBuilder = class {
     void this.saveSession();
   }
   // ── Session Lifecycle ─────────────────────────────────────────────────────
-  /** Start a new session with a title and optional intent. */
-  startSession(title, intent) {
+  /** Start a new session with a title, optional intent, and per-session context. */
+  startSession(title, intent, projectContext) {
     this.session.title = title;
     this.session.userIntent = intent ?? "";
+    this.session.projectContext = projectContext ?? this.projectContext;
     this.session.phase = "questioning";
     this.session.updatedAt = Date.now();
     this.autoSave();
@@ -2308,6 +2313,7 @@ var AISpecBuilder = class {
     this.session.phase = "questioning";
     this.session.title = "";
     this.session.userIntent = "";
+    this.session.projectContext = this.projectContext;
     this.session.answers = [];
     this.session.questionCount = 0;
     this.session.spec = void 0;
@@ -2500,9 +2506,9 @@ var SddInterviewDriver = class {
     });
   }
   /** Begin a fresh interview. Returns the first AI prompt (a question kickoff). */
-  start(title, intent) {
+  start(title, intent, projectContext) {
     this.builder.resetForNewInterview();
-    this.builder.startSession(title, intent);
+    this.builder.startSession(title, intent, projectContext);
     this.tracker = null;
     this.graph = null;
     this.resumedFromDisk = false;
@@ -2816,6 +2822,68 @@ import {
   writeKanbanWorkflowState
 } from "@wrongstack/kanban";
 
+// src/sdd-task-recovery.ts
+function computeDeadlockChains(host) {
+  const tracker = host.opts.tracker;
+  const chains = [];
+  for (const node of tracker.getAllNodes()) {
+    if (node.status === "completed" || node.status === "failed") continue;
+    const blockedBy = tracker.getBlockers(node.id).filter((id) => tracker.getNode(id)?.status !== "completed");
+    if (blockedBy.length > 0) chains.push({ blocked: node.id, blockedBy });
+  }
+  return chains;
+}
+function recoverFailedBlockers(host) {
+  const tracker = host.opts.tracker;
+  let recovered = false;
+  for (const node of tracker.getAllNodes({ status: ["failed"] })) {
+    const blocksIncomplete = tracker.getDependents(node.id).some((d) => {
+      const s = tracker.getNode(d)?.status;
+      return s !== "completed" && s !== "failed";
+    });
+    if (blocksIncomplete) {
+      host.retryMap.delete(node.id);
+      host.persistRetries(node.id, 0);
+      tracker.updateNodeStatus(node.id, "pending", "deadlock recovery");
+      recovered = true;
+    }
+  }
+  return recovered;
+}
+function requeueFailedTasks(host, reason = "retry failed sweep") {
+  const tracker = host.opts.tracker;
+  let n = 0;
+  for (const node of tracker.getAllNodes({ status: ["failed"] })) {
+    if (host.cancelledTasks.has(node.id) || node.metadata?.cancelled) continue;
+    host.retryMap.delete(node.id);
+    host.persistRetries(node.id, 0);
+    tracker.updateNodeStatus(node.id, "pending", reason);
+    host.emit("sdd.task.retrying", {
+      runId: host.runId,
+      taskId: node.id,
+      attempt: 0,
+      maxRetries: host.maxRetries
+    });
+    n++;
+  }
+  return n;
+}
+function restoreRetryMap(host) {
+  host.retryMap.clear();
+  for (const node of host.opts.tracker.getAllNodes()) {
+    const r = node.metadata?.retries;
+    if (typeof r === "number" && r > 0) host.retryMap.set(node.id, r);
+  }
+}
+function resetOrphans(tracker) {
+  let n = 0;
+  for (const node of tracker.getAllNodes({ status: ["in_progress"] })) {
+    tracker.updateNodeStatus(node.id, "pending", "resume: orphaned in_progress");
+    n++;
+  }
+  return n;
+}
+
 // src/sdd-parallel-run.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import {
@@ -3357,10 +3425,10 @@ var SddParallelRun = class {
   /** Type-safe emit on the optional EventBus (no-op when unwired). */
   emit(event, payload) {
     const sessionId = this.currentSessionId();
-    this.events?.emit(
-      event,
-      { ...payload, sessionId }
-    );
+    this.events?.emit(event, {
+      ...payload,
+      sessionId
+    });
   }
   currentSessionId() {
     const value = typeof this.sessionIdSource === "function" ? this.sessionIdSource() : this.sessionIdSource;
@@ -3686,32 +3754,11 @@ var SddParallelRun = class {
    * included since they're the usual deadlock cause once retries are exhausted.
    */
   computeDeadlockChains() {
-    const tracker = this.opts.tracker;
-    const chains = [];
-    for (const node of tracker.getAllNodes()) {
-      if (node.status === "completed" || node.status === "failed") continue;
-      const blockedBy = tracker.getBlockers(node.id).filter((id) => tracker.getNode(id)?.status !== "completed");
-      if (blockedBy.length > 0) chains.push({ blocked: node.id, blockedBy });
-    }
-    return chains;
+    return computeDeadlockChains(this.sddTaskRecoveryHost());
   }
   /** Requeue failed tasks that block an incomplete dependent. Returns true if any. */
   recoverFailedBlockers() {
-    const tracker = this.opts.tracker;
-    let recovered = false;
-    for (const node of tracker.getAllNodes({ status: ["failed"] })) {
-      const blocksIncomplete = tracker.getDependents(node.id).some((d) => {
-        const s = tracker.getNode(d)?.status;
-        return s !== "completed" && s !== "failed";
-      });
-      if (blocksIncomplete) {
-        this.retryMap.delete(node.id);
-        this.persistRetries(node.id, 0);
-        tracker.updateNodeStatus(node.id, "pending", "deadlock recovery");
-        recovered = true;
-      }
-    }
-    return recovered;
+    return recoverFailedBlockers(this.sddTaskRecoveryHost());
   }
   /**
    * Requeue every terminal-failed task that the user did NOT cancel, giving each
@@ -3719,22 +3766,7 @@ var SddParallelRun = class {
    * the manual "retry all failed" control. Returns the number requeued.
    */
   requeueFailedTasks(reason = "retry failed sweep") {
-    const tracker = this.opts.tracker;
-    let n = 0;
-    for (const node of tracker.getAllNodes({ status: ["failed"] })) {
-      if (this.cancelledTasks.has(node.id) || node.metadata?.cancelled) continue;
-      this.retryMap.delete(node.id);
-      this.persistRetries(node.id, 0);
-      tracker.updateNodeStatus(node.id, "pending", reason);
-      this.emit("sdd.task.retrying", {
-        runId: this.runId,
-        taskId: node.id,
-        attempt: 0,
-        maxRetries: this.maxRetries
-      });
-      n++;
-    }
-    return n;
+    return requeueFailedTasks(this.sddTaskRecoveryHost(), reason);
   }
   /**
    * Manually requeue all failed tasks to `pending` (board "Retry all failed").
@@ -3753,11 +3785,7 @@ var SddParallelRun = class {
   }
   /** Restore per-task retry counts persisted in node metadata (resume support). */
   restoreRetryMap() {
-    this.retryMap.clear();
-    for (const node of this.opts.tracker.getAllNodes()) {
-      const r = node.metadata?.retries;
-      if (typeof r === "number" && r > 0) this.retryMap.set(node.id, r);
-    }
+    restoreRetryMap(this.sddTaskRecoveryHost());
   }
   /**
    * Reset orphaned `in_progress` tasks (no agent runs them after a crash) back
@@ -3765,12 +3793,7 @@ var SddParallelRun = class {
    * from a reloaded graph. Static so callers don't need a run instance.
    */
   static resetOrphans(tracker) {
-    let n = 0;
-    for (const node of tracker.getAllNodes({ status: ["in_progress"] })) {
-      tracker.updateNodeStatus(node.id, "pending", "resume: orphaned in_progress");
-      n++;
-    }
-    return n;
+    return resetOrphans(tracker);
   }
   /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
   async teardown() {
@@ -4021,6 +4044,24 @@ var SddParallelRun = class {
       deadlocked: isDeadlocked
     };
   }
+  sddTaskRecoveryHost() {
+    const self = this;
+    return {
+      get opts() {
+        return self.opts;
+      },
+      get retryMap() {
+        return self.retryMap;
+      },
+      persistRetries: (...args) => this.persistRetries(...args),
+      get cancelledTasks() {
+        return self.cancelledTasks;
+      },
+      emit: (...args) => this.emit(...args),
+      runId: this.runId,
+      maxRetries: this.maxRetries
+    };
+  }
 };
 
 // src/start-sdd-run.ts
@@ -4493,10 +4534,13 @@ function createKanbanSddSessionPersistence(projectRoot, legacySessionPath) {
       await pending;
     },
     async delete() {
-      await writeChain;
-      await deleteKanbanWorkflowState2(projectRoot, SDD_SESSION_WORKFLOW_ID);
-      revision = 0;
-      if (legacySessionPath) await fsp5.unlink(legacySessionPath).catch(() => void 0);
+      const pending = writeChain.then(async () => {
+        await deleteKanbanWorkflowState2(projectRoot, SDD_SESSION_WORKFLOW_ID);
+        revision = 0;
+        if (legacySessionPath) await fsp5.unlink(legacySessionPath).catch(() => void 0);
+      });
+      writeChain = pending.catch(() => void 0);
+      await pending;
     }
   };
 }
@@ -4581,7 +4625,7 @@ function intakeToInterviewKickoff(record) {
 }
 function startInterviewFromIntake(driver, record) {
   const kickoff = intakeToInterviewKickoff(record);
-  return driver.start(kickoff.title, kickoff.intent);
+  return driver.start(kickoff.title, kickoff.intent, kickoff.projectContext);
 }
 
 // src/spec-templates.ts
@@ -5051,7 +5095,9 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
-  const assigned = /* @__PURE__ */ new Set();
+  const assigned = new Set(
+    Array.from(graph.nodes.values()).filter((n) => n.status === "completed").map((n) => n.id)
+  );
   const nodes = Array.from(graph.nodes.values()).filter((n) => n.status !== "completed");
   const remaining = new Set(nodes.map((n) => n.id));
   while (remaining.size > 0) {
@@ -5314,6 +5360,8 @@ var AutoExecutor = class {
             this.opts.onTaskComplete?.(task, execResult);
           } else if (execResult.retry) {
             retried++;
+            this.opts.tracker.updateNodeStatus(task.id, "failed", execResult.error);
+            failed++;
           } else {
             this.opts.tracker.updateNodeStatus(task.id, "failed", execResult.error);
             failed++;

package/dist/intake-kickoff.d.ts

@@ -25,9 +25,9 @@ export interface IntakeInterviewKickoff {
 export declare function intakeToInterviewKickoff(record: RequirementIntakeRecord): IntakeInterviewKickoff;
 /**
  * Start a spec-builder interview from an intake record. Returns the first AI
- * prompt (a question kickoff), ready to feed the agent loop. The driver should
- * be constructed with `projectContext: kickoff.projectContext` so the
- * questioning prompt already knows the collected facts.
+ * prompt (a question kickoff), ready to feed the agent loop. Collected intake
+ * facts are passed as this interview's project context so the questioning
+ * prompt already knows them.
  */
 export declare function startInterviewFromIntake(driver: Pick<SddInterviewDriver, 'start'>, record: RequirementIntakeRecord): string;
 //# sourceMappingURL=intake-kickoff.d.ts.map

package/dist/sdd-interview-driver.d.ts

@@ -78,7 +78,7 @@ export declare class SddInterviewDriver {
     private resumedFromDisk;
     constructor(opts: SddInterviewDriverOptions);
     /** Begin a fresh interview. Returns the first AI prompt (a question kickoff). */
-    start(title: string, intent?: string): string;
+    start(title: string, intent?: string, projectContext?: string): string;
     /**
      * Resume a previously-persisted interview. Re-hydrates the task
      * graph too when one was already produced. Returns true if a session loaded.

package/dist/sdd-parallel-run.d.ts

@@ -1,22 +1,3 @@
-/**
- * SddParallelRun
- *
- * Drives a TaskGraph through ParallelEternalEngine's infrastructure
- * (DefaultMultiAgentCoordinator + AgentSubagentRunner) but powered by
- * SddTaskDecomposer — producing dependency-aware waves instead of
- * goal-driven iterations.
- *
- * One-shot: completes when all tasks are done OR a deadlock is detected.
- * Does NOT loop — each run() call is a discrete execution.
- *
- * Usage:
- * ```
- * const run = new SddParallelRun({ tracker, graph, agent, projectRoot });
- * await run.run({ onWave });
- * // or with progress callback:
- * await run.run({ onProgress: (p) => console.log(renderProgress(p)) });
- * ```
- */
 import type { TaskTracker } from '@wrongstack/core/tasking';
 import type { TaskNode } from '@wrongstack/core/types';
 import type { RunResult, SddParallelRunOptions, SddSubtaskSpec, TaskOutcome, WaveResult } from './sdd-parallel-run-types.js';
@@ -270,5 +251,6 @@ export declare class SddParallelRun {
     /** Persist a task's retry count into node metadata (survives crash → resume). */
     private persistRetries;
     private buildProgress;
+    private sddTaskRecoveryHost;
 }
 //# sourceMappingURL=sdd-parallel-run.d.ts.map

package/dist/sdd-task-recovery.d.ts

@@ -0,0 +1,20 @@
+import type { TaskTracker } from '@wrongstack/core/tasking';
+import type { SddParallelRunOptions } from './sdd-parallel-run-types.js';
+export interface SddTaskRecoveryHost {
+    opts: SddParallelRunOptions;
+    retryMap: Map<string, number>;
+    persistRetries: (taskId: string, retries: number) => void;
+    cancelledTasks: Set<string>;
+    emit: <K extends keyof import('@wrongstack/core/kernel').EventMap>(event: K, payload: import('@wrongstack/core/kernel').EventMap[K]) => void;
+    runId: string;
+    maxRetries: number;
+}
+export declare function computeDeadlockChains(host: SddTaskRecoveryHost): Array<{
+    blocked: string;
+    blockedBy: string[];
+}>;
+export declare function recoverFailedBlockers(host: SddTaskRecoveryHost): boolean;
+export declare function requeueFailedTasks(host: SddTaskRecoveryHost, reason?: string): number;
+export declare function restoreRetryMap(host: SddTaskRecoveryHost): void;
+export declare function resetOrphans(tracker: TaskTracker): number;
+//# sourceMappingURL=sdd-task-recovery.d.ts.map

package/dist/spec-builder.d.ts

@@ -25,6 +25,7 @@ export declare class AISpecBuilder {
     private readonly store;
     private readonly minQuestions;
     private readonly maxQuestions;
+    private readonly projectContext;
     private readonly sessionPath?;
     private readonly sessionPersistence?;
     private pendingSessionWrite;
@@ -37,8 +38,8 @@ export declare class AISpecBuilder {
     deleteSession(): Promise<void>;
     /** Auto-save helper. saveSession() already handles best-effort persistence. */
     private autoSave;
-    /** Start a new session with a title and optional intent. */
-    startSession(title: string, intent?: string): void;
+    /** Start a new session with a title, optional intent, and per-session context. */
+    startSession(title: string, intent?: string, projectContext?: string): void;
     /** Get current session state (readonly). */
     getSession(): Readonly<AISpecSession>;
     /** Get the current phase. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "1.0.19",
+  "version": "1.0.26",
   "license": "MIT",
   "description": "WrongStack Spec-Driven Development engine — standalone package extracted from @wrongstack/core. Task graph generation, tracking, execution, lifecycle management, and AI-driven spec building for SDD workflows.",
   "repository": {
@@ -27,10 +27,10 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "1.0.19",
-    "@wrongstack/kanban": "1.0.19",
-    "@wrongstack/primitives": "1.0.19",
-    "@wrongstack/requirement-intake": "1.0.19"
+    "@wrongstack/core": "1.0.26",
+    "@wrongstack/kanban": "1.0.26",
+    "@wrongstack/primitives": "1.0.26",
+    "@wrongstack/requirement-intake": "1.0.26"
   },
   "devDependencies": {
     "@types/node": "^26.5.1",