@wrongstack/sdd 1.0.29 → 1.0.33

package/dist/sdd-board-store.d.ts

@@ -59,6 +59,7 @@ export declare class SddBoardStore {
     private baseDirReady;
     private cachedIndex;
     private cachedIndexSignature;
+    private indexNeedsRebuild;
     constructor(opts: SddBoardStoreOptions);
     snapshotPath(runId: string): string;
     eventsPath(runId: string): string;
@@ -90,6 +91,7 @@ export declare class SddBoardStore {
     private compactEventTail;
     private drainControlInternal;
     private readIndex;
+    private rebuildIndexEntries;
     private updateIndex;
     private removeFromIndex;
     private indexSignature;

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

@@ -64,6 +64,15 @@ export declare class SddParallelRun {
     /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
     private dispatchSeq;
     private round;
+    /**
+     * True once `run()` has returned. A FINISHED run is not "running" even when
+     * the graph is left unsettled (deadlock exit): `isRunning()` gates
+     * `cleanupWorktrees()` / `rollback()` / the Ctrl+C ladders, and a returned
+     * run kept reporting live, silently no-oping cleanup and refusing rollback
+     * with "run still active" until the user called `stop()` on a run that had
+     * already ended. Cleared again at the top of `run()` so a re-run re-arms.
+     */
+    private runReturned;
     constructor(opts: SddParallelRunOptions);
     /** Type-safe emit on the optional EventBus (no-op when unwired). */
     private emit;
@@ -252,5 +261,6 @@ export declare class SddParallelRun {
     private persistRetries;
     private buildProgress;
     private sddTaskRecoveryHost;
+    private sddTaskDispatchHost;
 }
 //# sourceMappingURL=sdd-parallel-run.d.ts.map

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

@@ -83,7 +83,7 @@ export declare class SddTaskDecomposer {
      * Sorted by priority (critical first), then by creation time.
      */
     private pendingReadyNodes;
-    /** True when at least one non-completed, non-failed task is blocked. */
+    /** True when non-completed, non-failed tasks remain blocked and cannot make progress. */
     private hasAnyBlockedTasks;
 }
 //# sourceMappingURL=sdd-task-decomposer.d.ts.map

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

@@ -0,0 +1,41 @@
+import type { TaskNode } from '@wrongstack/core/types';
+import type { TaskOutcome, WaveResult } from './sdd-parallel-run-types.js';
+import type { TaskBatch } from './sdd-task-decomposer.js';
+export interface SddTaskDispatchHost {
+    executeOne: (task: import('@wrongstack/core/types').TaskNode) => Promise<import('./sdd-parallel-run-types.js').TaskOutcome>;
+    stopRequested: boolean;
+    opts: import('./sdd-parallel-run-types.js').SddParallelRunOptions;
+    coordinator: import('@wrongstack/core/coordination').DefaultMultiAgentCoordinator | null;
+    usedNicknames: Set<string>;
+    idleTimeoutMs: number;
+    timeoutMs: number | undefined;
+    runId: string;
+    dispatchSeq: number;
+    emit: <K extends keyof import('@wrongstack/core/kernel').EventMap>(event: K, payload: import('@wrongstack/core/kernel').EventMap[K]) => void;
+    taskCwds: Map<string, string>;
+    taskBranches: Map<string, string>;
+    taskSubagents: Map<string, string>;
+    cancelledTasks: Set<string>;
+    allocateWorktrees: (tasks: import('@wrongstack/core/types').TaskNode[]) => Promise<void>;
+    resolveWorktrees: (tasks: import('@wrongstack/core/types').TaskNode[]) => Promise<void>;
+    integrateWorktree: (task: import('@wrongstack/core/types').TaskNode, result?: import('@wrongstack/core/types').TaskResult<unknown> | undefined) => Promise<{
+        ok: boolean;
+        conflictFiles?: string[];
+        reason?: string;
+        fatal?: boolean;
+    }>;
+    applyTaskFailure: (taskId: string, subagentId: string, errMsg: string) => Promise<void>;
+    retryMap: Map<string, number>;
+    persistRetries: (taskId: string, retries: number) => void;
+    maxRetries: number;
+    trySupervisorRescue: (taskId: string, errMsg: string) => Promise<boolean>;
+    supervisorEscalations: Map<string, number>;
+    maxSupervisorEscalations: number;
+    setTaskModel: (taskId: string, model: string | undefined, provider?: string | undefined) => boolean;
+    splitTask: (taskId: string, subtasks: import('./sdd-parallel-run-types.js').SddSubtaskSpec[]) => string[];
+}
+export declare function executeWave(this: SddTaskDispatchHost, batch: TaskBatch): Promise<WaveResult>;
+export declare function executeOne(this: SddTaskDispatchHost, task: TaskNode): Promise<TaskOutcome>;
+export declare function applyTaskFailure(this: SddTaskDispatchHost, taskId: string, subagentId: string, errMsg: string): Promise<void>;
+export declare function trySupervisorRescue(this: SddTaskDispatchHost, taskId: string, errMsg: string): Promise<boolean>;
+//# sourceMappingURL=sdd-task-dispatch.d.ts.map

package/dist/spec-store.d.ts

@@ -18,9 +18,11 @@ export interface SpecIndexEntry {
 export declare class SpecStore {
     private readonly baseDir;
     private readonly indexPath;
+    private writeChain;
     constructor(opts: SpecStoreOptions);
     save(spec: Specification): Promise<void>;
     load(id: string): Promise<Specification | null>;
+    private loadFile;
     list(): Promise<SpecIndexEntry[]>;
     delete(id: string): Promise<boolean>;
     exists(id: string): Promise<boolean>;
@@ -28,6 +30,9 @@ export declare class SpecStore {
     createDraft(title: string, overview?: string): Promise<Specification>;
     /** Update spec fields and persist. */
     update(id: string, patch: Partial<Omit<Specification, 'id' | 'createdAt'>>): Promise<Specification | null>;
+    /** Serialize every read-modify-write across this process and other store instances. */
+    private enqueueWrite;
+    private writeSnapshot;
     /**
      * Resolve a spec id to its file, refusing anything that escapes `baseDir`.
      * `id` arrives from a WebSocket frame (`specs-ws-handler.ts:96-97,152`,
@@ -38,6 +43,7 @@ export declare class SpecStore {
      */
     private filePath;
     private readIndex;
+    private rebuildIndex;
     private updateIndex;
     private removeFromIndex;
 }

package/dist/task-graph-store.d.ts

@@ -24,6 +24,7 @@ export declare class TaskGraphStore implements TaskStore {
     constructor(opts: TaskGraphStoreOptions);
     save(graph: TaskGraph): Promise<void>;
     load(id: string): Promise<TaskGraph | null>;
+    private loadFile;
     list(): Promise<TaskGraphIndexEntry[]>;
     delete(id: string): Promise<boolean>;
     exists(id: string): Promise<boolean>;
@@ -46,6 +47,10 @@ export declare class TaskGraphStore implements TaskStore {
      */
     private filePath;
     private readIndex;
+    private rebuildIndex;
+    /** Serialize graph and index mutations across this process and other store instances. */
+    private enqueueWrite;
+    private indexEntry;
     private updateIndex;
     private removeFromIndex;
 }

package/package.json

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