@wrongstack/sdd 0.313.1 → 0.316.1

package/dist/conflict-resolver.d.ts

@@ -1,6 +1,6 @@
 import type { TaskNode } from '@wrongstack/core/types';
 export type ConflictSide = 'incoming' | 'base';
-export interface ConflictFileIO {
+interface ConflictFileIO {
     read(path: string): Promise<string>;
     write(path: string, content: string): Promise<void>;
 }
@@ -48,4 +48,5 @@ export declare function makeLlmConflictResolver(opts: LlmConflictResolverOptions
     conflictFiles: string[];
     cwd: string;
 }) => Promise<boolean>;
+export {};
 //# sourceMappingURL=conflict-resolver.d.ts.map

package/dist/index.js

@@ -2793,6 +2793,7 @@ import {
   makeAgentSubagentRunner,
   withDisabledToolFiltering
 } from "@wrongstack/core/coordination";
+import { requireSessionId } from "@wrongstack/primitives";
 
 // src/graph-split.ts
 function splitGraphNode(tracker, taskId, subtasks, options = {}) {
@@ -2825,6 +2826,112 @@ function splitGraphNode(tracker, taskId, subtasks, options = {}) {
   return leafIds;
 }
 
+// src/sdd-task-decomposer.ts
+var SddTaskDecomposer = class {
+  constructor(tracker, _graph, opts = {}) {
+    this.tracker = tracker;
+    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
+  }
+  tracker;
+  slots;
+  wave = 0;
+  // -------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------
+  /**
+   * Return the next batch of runnable tasks.
+   * Returns `allDone: true` when every node is completed.
+   * Returns `deadlocked: true` when no batch can be produced because
+   * all remaining tasks are blocked by failed nodes.
+   */
+  nextBatch() {
+    if (this.isDone()) {
+      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
+    }
+    const pending = this.pendingReadyNodes();
+    if (pending.length === 0) {
+      const hasBlockedTasks = this.hasAnyBlockedTasks();
+      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
+    }
+    const batch = pending.slice(0, this.slots);
+    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
+  }
+  /**
+   * Advance the wave counter after a batch completes.
+   * Call this once per `nextBatch()` result that was fan-out.
+   */
+  acknowledgeBatch(_completedTaskIds) {
+    this.wave++;
+  }
+  /**
+   * True when every node in the graph is completed.
+   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
+   */
+  isDone() {
+    const progress = this.tracker.getProgress();
+    return progress.total > 0 && progress.completed === progress.total;
+  }
+  /**
+   * Total waves produced so far.
+   */
+  getWaveCount() {
+    return this.wave;
+  }
+  /**
+   * All ready (dependency-satisfied) pending tasks, priority-sorted — UNSLICED.
+   * The continuous scheduler fills its own free slots from this list, so unlike
+   * `nextBatch()` it does not cap at `slots`.
+   */
+  readyNodes() {
+    return this.pendingReadyNodes();
+  }
+  /**
+   * True when every node has reached a terminal state (completed or failed).
+   * This — not `isDone()` (which requires ALL completed) — is the correct loop
+   * exit for the continuous scheduler: a terminally-failed task must not keep
+   * the run spinning to its backstop.
+   */
+  isSettled() {
+    const nodes = this.tracker.getAllNodes();
+    return nodes.length > 0 && nodes.every((n) => n.status === "completed" || n.status === "failed");
+  }
+  // -------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------
+  /**
+   * Return pending nodes whose blockers are all completed.
+   * Sorted by priority (critical first), then by creation time.
+   */
+  pendingReadyNodes() {
+    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
+    const ready = [];
+    for (const node of allPending) {
+      if (this.tracker.canStart(node.id)) {
+        ready.push(node);
+      }
+    }
+    const priorityRank = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    ready.sort((a, b) => {
+      const pr = priorityRank[a.priority] - priorityRank[b.priority];
+      if (pr !== 0) return pr;
+      return a.createdAt - b.createdAt;
+    });
+    return ready;
+  }
+  /** True when at least one non-completed, non-failed task is blocked. */
+  hasAnyBlockedTasks() {
+    const nodes = this.tracker.getAllNodes({
+      status: ["pending", "in_progress", "blocked"]
+    });
+    return nodes.some((n) => n.status === "blocked");
+  }
+};
+
 // src/sdd-task-execution.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
@@ -3009,112 +3116,6 @@ async function verifyTaskResult(params, result) {
   return verificationFailReason;
 }
 
-// src/sdd-task-decomposer.ts
-var SddTaskDecomposer = class {
-  constructor(tracker, _graph, opts = {}) {
-    this.tracker = tracker;
-    this.slots = Math.min(16, Math.max(1, opts.parallelSlots ?? 4));
-  }
-  tracker;
-  slots;
-  wave = 0;
-  // -------------------------------------------------------------------
-  // Public API
-  // -------------------------------------------------------------------
-  /**
-   * Return the next batch of runnable tasks.
-   * Returns `allDone: true` when every node is completed.
-   * Returns `deadlocked: true` when no batch can be produced because
-   * all remaining tasks are blocked by failed nodes.
-   */
-  nextBatch() {
-    if (this.isDone()) {
-      return { tasks: [], wave: this.wave, allDone: true, deadlocked: false };
-    }
-    const pending = this.pendingReadyNodes();
-    if (pending.length === 0) {
-      const hasBlockedTasks = this.hasAnyBlockedTasks();
-      return { tasks: [], wave: this.wave, allDone: false, deadlocked: hasBlockedTasks };
-    }
-    const batch = pending.slice(0, this.slots);
-    return { tasks: batch, wave: this.wave, allDone: false, deadlocked: false };
-  }
-  /**
-   * Advance the wave counter after a batch completes.
-   * Call this once per `nextBatch()` result that was fan-out.
-   */
-  acknowledgeBatch(_completedTaskIds) {
-    this.wave++;
-  }
-  /**
-   * True when every node in the graph is completed.
-   * Use this to exit the fan-out loop after `isDone() || deadlocked`.
-   */
-  isDone() {
-    const progress = this.tracker.getProgress();
-    return progress.total > 0 && progress.completed === progress.total;
-  }
-  /**
-   * Total waves produced so far.
-   */
-  getWaveCount() {
-    return this.wave;
-  }
-  /**
-   * All ready (dependency-satisfied) pending tasks, priority-sorted — UNSLICED.
-   * The continuous scheduler fills its own free slots from this list, so unlike
-   * `nextBatch()` it does not cap at `slots`.
-   */
-  readyNodes() {
-    return this.pendingReadyNodes();
-  }
-  /**
-   * True when every node has reached a terminal state (completed or failed).
-   * This — not `isDone()` (which requires ALL completed) — is the correct loop
-   * exit for the continuous scheduler: a terminally-failed task must not keep
-   * the run spinning to its backstop.
-   */
-  isSettled() {
-    const nodes = this.tracker.getAllNodes();
-    return nodes.length > 0 && nodes.every((n) => n.status === "completed" || n.status === "failed");
-  }
-  // -------------------------------------------------------------------
-  // Internal helpers
-  // -------------------------------------------------------------------
-  /**
-   * Return pending nodes whose blockers are all completed.
-   * Sorted by priority (critical first), then by creation time.
-   */
-  pendingReadyNodes() {
-    const allPending = this.tracker.getAllNodes({ status: ["pending"] });
-    const ready = [];
-    for (const node of allPending) {
-      if (this.tracker.canStart(node.id)) {
-        ready.push(node);
-      }
-    }
-    const priorityRank = {
-      critical: 0,
-      high: 1,
-      medium: 2,
-      low: 3
-    };
-    ready.sort((a, b) => {
-      const pr = priorityRank[a.priority] - priorityRank[b.priority];
-      if (pr !== 0) return pr;
-      return a.createdAt - b.createdAt;
-    });
-    return ready;
-  }
-  /** True when at least one non-completed, non-failed task is blocked. */
-  hasAnyBlockedTasks() {
-    const nodes = this.tracker.getAllNodes({
-      status: ["pending", "in_progress", "blocked"]
-    });
-    return nodes.some((n) => n.status === "blocked");
-  }
-};
-
 // src/sdd-worktree-integration.ts
 function forgetTaskWorktree(state, taskId, opts = {}) {
   state.taskWorktrees.delete(taskId);
@@ -3332,7 +3333,7 @@ var SddParallelRun = class {
   }
   currentSessionId() {
     const value = typeof this.sessionIdSource === "function" ? this.sessionIdSource() : this.sessionIdSource;
-    return typeof value === "string" && value.length > 0 ? value : void 0;
+    return requireSessionId(value, "SDD session operation");
   }
   // -------------------------------------------------------------------
   // Public API
@@ -3781,7 +3782,9 @@ var SddParallelRun = class {
         ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {}
       }
     };
-    this.coordinator = new DefaultMultiAgentCoordinator(config);
+    this.coordinator = new DefaultMultiAgentCoordinator(config, {
+      sessionId: () => this.currentSessionId()
+    });
     const baseFactory = this.opts.subagentFactory ?? this.defaultFactory();
     const filteredFactory = withDisabledToolFiltering(baseFactory);
     const runner = makeAgentSubagentRunner({

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

@@ -11,7 +11,7 @@ export interface SddBoardStoreOptions {
     /** Injectable control-queue file operations for fault testing. */
     controlFileIO?: SddBoardControlFileIO | undefined;
 }
-export interface SddBoardControlFileIO {
+interface SddBoardControlFileIO {
     stat(filePath: string): Promise<{
         size: number;
     }>;
@@ -27,7 +27,7 @@ export interface SddBoardIndexEntry {
     completed: number;
     updatedAt: number;
 }
-export interface IndexSignature {
+interface IndexSignature {
     size: number;
     mtimeMs: number;
     ctimeMs: number;
@@ -95,4 +95,5 @@ export declare class SddBoardStore {
     private indexSignature;
 }
 export declare function sameIndexSignature(a: IndexSignature | null, b: IndexSignature | null): boolean;
+export {};
 //# sourceMappingURL=sdd-board-store.d.ts.map

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

@@ -19,8 +19,8 @@
  */
 import type { TaskTracker } from '@wrongstack/core/tasking';
 import type { TaskNode } from '@wrongstack/core/types';
-import { type TaskBatch } from './sdd-task-decomposer.js';
 import type { RunResult, SddParallelRunOptions, SddSubtaskSpec, TaskOutcome, WaveResult } from './sdd-parallel-run-types.js';
+import { type TaskBatch } from './sdd-task-decomposer.js';
 export type { RunResult, SddParallelRunOptions, SddProgress, SddSubtaskSpec, SddSupervisorVerdict, WaveResult, } from './sdd-parallel-run-types.js';
 export declare class SddParallelRun {
     private readonly opts;

package/dist/sdd-worktree-integration.d.ts

@@ -1,7 +1,7 @@
 import type { TaskNode, TaskResult } from '@wrongstack/core/types';
 import type { WorktreeHandle } from '@wrongstack/core/worktree';
 import type { SddParallelRunOptions } from './sdd-parallel-run-types.js';
-export interface SddWorktreeState {
+interface SddWorktreeState {
     taskCwds: Map<string, string>;
     taskBranches: Map<string, string>;
     taskWorktrees: Map<string, WorktreeHandle>;
@@ -30,4 +30,5 @@ export declare function integrateTaskWorktree(params: {
     reason?: string;
     fatal?: boolean;
 }>;
+export {};
 //# sourceMappingURL=sdd-worktree-integration.d.ts.map

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

@@ -62,7 +62,7 @@ export interface SddRunHandle {
     /** Request a clean stop (idempotent). */
     stop(): void;
 }
-export interface SddControlCommand {
+interface SddControlCommand {
     type: string;
     payload?: unknown;
 }
@@ -74,4 +74,5 @@ export declare function applySddControlCommand(run: SddParallelRun, command: Sdd
  * Orphaned in_progress tasks are reset up-front so a crashed prior run re-executes.
  */
 export declare function startSddRun(opts: StartSddRunOptions): SddRunHandle;
+export {};
 //# sourceMappingURL=start-sdd-run.d.ts.map

package/dist/task-generator.d.ts

@@ -1,13 +1,6 @@
 import type { TaskStore, TaskTracker } from '@wrongstack/core/tasking';
 import type { Specification, TaskGraph, TaskNode, TaskPriority, TaskType } from '@wrongstack/core/types';
 import { type AtomicityRuleSetConfig } from '@wrongstack/kanban';
-/** Named estimate constants shared with the atomicity candidate mapping. */
-export declare const OVERVIEW_ESTIMATE_HOURS = 4;
-export declare const REQUIREMENT_ESTIMATE_HOURS: Record<string, number>;
-export declare const API_PARENT_ESTIMATE_HOURS = 0;
-export declare const API_BASE_ESTIMATE_HOURS = 2;
-export declare const TESTS_ESTIMATE_HOURS = 4;
-export declare const DOCS_ESTIMATE_HOURS = 2;
 export interface TaskGeneratorOptions {
     taskTracker: TaskTracker;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "0.313.1",
+  "version": "0.316.1",
   "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,9 +27,10 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/kanban": "0.313.1",
-    "@wrongstack/core": "0.313.1",
-    "@wrongstack/requirement-intake": "0.313.1"
+    "@wrongstack/core": "0.316.1",
+    "@wrongstack/primitives": "0.316.1",
+    "@wrongstack/kanban": "0.316.1",
+    "@wrongstack/requirement-intake": "0.316.1"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",