@wrongstack/sdd 1.0.24 → 1.0.27

package/dist/index.js

@@ -2049,10 +2049,10 @@ var AISpecBuilder = class {
           return;
         }
         const fsp7 = await import("node:fs/promises");
-        const path6 = await import("node:path");
+        const path7 = await import("node:path");
         const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
         const sessionPath = expectDefined2(this.sessionPath);
-        await fsp7.mkdir(path6.dirname(sessionPath), { recursive: true });
+        await fsp7.mkdir(path7.dirname(sessionPath), { recursive: true });
         await atomicWrite4(sessionPath, JSON.stringify(snapshot, null, 2));
       } catch (error) {
         console.warn(
@@ -2822,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 {
@@ -3363,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;
@@ -3692,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
@@ -3725,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").
@@ -3759,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
@@ -3771,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() {
@@ -4027,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
@@ -5048,15 +5083,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path6 = [];
+  const path7 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path6.unshift(current);
+    path7.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path6;
+  return path7;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -5277,6 +5312,14 @@ var SpecVersioning = class {
 };
 
 // src/auto-executor.ts
+function asDependentFirstGraph(graph) {
+  return {
+    ...graph,
+    edges: graph.edges.map(
+      (edge) => edge.type === "depends_on" ? { ...edge, from: edge.to, to: edge.from } : edge
+    )
+  };
+}
 var AutoExecutor = class {
   opts;
   stopped = false;
@@ -5293,7 +5336,7 @@ var AutoExecutor = class {
     this.stopped = false;
     this.retryMap.clear();
     const startTime = Date.now();
-    const critical = analyzeCriticalPath(graph);
+    const critical = analyzeCriticalPath(asDependentFirstGraph(graph));
     let completed = 0;
     let failed = 0;
     const skipped = 0;
@@ -5325,6 +5368,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++;
@@ -5464,6 +5509,7 @@ var SddSupervisor = class {
     const canSplit = Boolean(this.opts.generateSubtasks);
     const decision = await this.opts.brain.decide({
       id: `sdd-supervisor-${task.id}-${attempts}`,
+      sessionId: this.opts.sessionId,
       source: "system",
       question: `SDD task "${task.title}" exhausted its retries. How should the run proceed?`,
       context: `Error: ${error}
@@ -5502,6 +5548,28 @@ Supervisor rescues already used: ${attempts}`,
 
 // src/verify-task.ts
 import { spawn } from "node:child_process";
+import { accessSync } from "node:fs";
+import * as path6 from "node:path";
+import { buildWin32CmdShimInvocation } from "@wrongstack/core/utils";
+function win32BatchTarget(executable) {
+  if (/\.(?:cmd|bat)$/i.test(executable)) return executable;
+  if (/[\\/]/.test(executable) || path6.extname(executable)) return void 0;
+  const exts = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").toLowerCase().split(";");
+  for (const dir of (process.env["PATH"] ?? "").split(path6.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      if (!ext) continue;
+      const full = path6.join(dir, `${executable}${ext}`);
+      try {
+        accessSync(full);
+      } catch {
+        continue;
+      }
+      return ext === ".cmd" || ext === ".bat" ? full : void 0;
+    }
+  }
+  return void 0;
+}
 function tokenizeCommand(command) {
   const trimmed = command.trim();
   if (!trimmed) return void 0;
@@ -5638,12 +5706,22 @@ function makeCommandVerifier(options = {}) {
       return { ok: false, reason: `verification command is malformed: ${rawCommand}` };
     }
     const [executable, ...args] = argv;
+    const batch = process.platform === "win32" ? win32BatchTarget(executable) : void 0;
+    let shim;
+    if (batch) {
+      try {
+        shim = buildWin32CmdShimInvocation(batch, args);
+      } catch (err) {
+        return { ok: false, reason: `verification command refused: ${String(err)}` };
+      }
+    }
     return await new Promise((resolve3) => {
-      const child = spawn(executable, args, {
+      const child = spawn(shim?.command ?? executable, shim?.args ?? args, {
         cwd: info.cwd,
         shell: false,
         windowsHide: true,
-        stdio: "ignore"
+        stdio: "ignore",
+        ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
       });
       let timedOut = false;
       const timer = setTimeout(() => {
@@ -5819,12 +5897,12 @@ async function decomposeNonAtomicTasks(opts) {
 
 // src/conflict-resolver.ts
 import { readFile as readFile6, writeFile } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join6 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join7 } from "node:path";
 import { readBundledInstructionText as readBundledInstructionText2, renderInstructionTemplate as renderInstructionTemplate2 } from "@wrongstack/core/utils";
 var defaultFileIO = {
-  read: (path6) => readFile6(path6, "utf8"),
-  write: async (path6, content) => {
-    await writeFile(path6, content, "utf8");
+  read: (path7) => readFile6(path7, "utf8"),
+  write: async (path7, content) => {
+    await writeFile(path7, content, "utf8");
   }
 };
 var START = "<<<<<<<";
@@ -5868,7 +5946,7 @@ 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 = isAbsolute3(rel) ? rel : join6(info.cwd, rel);
+      const abs = isAbsolute3(rel) ? rel : join7(info.cwd, rel);
       let content;
       try {
         content = await io.read(abs);
@@ -5902,7 +5980,7 @@ function makeLlmConflictResolver(opts) {
   return async function conflictResolver(info) {
     if (info.conflictFiles.length === 0) return false;
     for (const rel of info.conflictFiles) {
-      const abs = isAbsolute3(rel) ? rel : join6(info.cwd, rel);
+      const abs = isAbsolute3(rel) ? rel : join7(info.cwd, rel);
       let content;
       try {
         content = await io.read(abs);

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-supervisor.d.ts

@@ -4,6 +4,8 @@ import type { SddSubtaskSpec, SddSupervisorVerdict } from './sdd-parallel-run.js
 export interface SddSupervisorOptions {
     /** Decision authority (policy/LLM/human). Reuse the session's TOKENS.BrainArbiter. */
     brain: BrainArbiter;
+    /** Session that started this run, retained when another tab becomes foreground. */
+    sessionId?: string | undefined;
     /**
      * Models to rotate through on a `reassign` verdict (e.g. the run's fallback
      * chain). Omit to drop the reassign option entirely.

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "1.0.24",
+  "version": "1.0.27",
   "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.24",
-    "@wrongstack/kanban": "1.0.24",
-    "@wrongstack/primitives": "1.0.24",
-    "@wrongstack/requirement-intake": "1.0.24"
+    "@wrongstack/core": "1.0.27",
+    "@wrongstack/kanban": "1.0.27",
+    "@wrongstack/primitives": "1.0.27",
+    "@wrongstack/requirement-intake": "1.0.27"
   },
   "devDependencies": {
     "@types/node": "^26.5.1",