@wrongstack/sdd 1.0.33 → 1.0.36

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

@@ -0,0 +1,39 @@
+import type { DefaultMultiAgentCoordinator } from '@wrongstack/core/coordination';
+import type { WorktreeHandle } from '@wrongstack/core/worktree';
+import type { SddParallelRunOptions, SddSubtaskSpec } from './sdd-parallel-run-types.js';
+export interface SddParallelControlsHost {
+    isRunning(): boolean;
+    opts: SddParallelRunOptions;
+    taskWorktrees: Map<string, WorktreeHandle>;
+    forgetWorktree(taskId: string, opts?: {
+        keepBranchLabel?: boolean;
+    }): void;
+    baseBranch: string | undefined;
+    mergedCommits: Array<{
+        taskId: string;
+        sha: string;
+        title: string;
+    }>;
+    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;
+    taskSubagents: Map<string, string>;
+    coordinator: DefaultMultiAgentCoordinator | null;
+}
+export declare function cleanupWorktrees(host: SddParallelControlsHost): Promise<number>;
+export declare function rollback(host: SddParallelControlsHost): Promise<{
+    ok: boolean;
+    reverted: number;
+    reason?: string;
+}>;
+export declare function retryTask(host: SddParallelControlsHost, taskId: string): boolean;
+export declare function reassignTask(host: SddParallelControlsHost, taskId: string, agentName: string): boolean;
+export declare function setTaskModel(host: SddParallelControlsHost, taskId: string, model: string | undefined, provider?: string | undefined): boolean;
+export declare function setTaskFallbacks(host: SddParallelControlsHost, taskId: string, fallbackModels: string[] | undefined): boolean;
+export declare function setTaskVerification(host: SddParallelControlsHost, taskId: string, verificationCommand: string | undefined): boolean;
+export declare function cancelTask(host: SddParallelControlsHost, taskId: string): Promise<boolean>;
+export declare function deleteTask(host: SddParallelControlsHost, taskId: string): boolean;
+export declare function splitTask(host: SddParallelControlsHost, taskId: string, subtasks: SddSubtaskSpec[]): string[];
+//# sourceMappingURL=sdd-parallel-controls.d.ts.map

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

@@ -0,0 +1,196 @@
+import type { AgentFactory } from '@wrongstack/core/coordination';
+import { DefaultMultiAgentCoordinator } from '@wrongstack/core/coordination';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { TaskNode, TaskResult } from '@wrongstack/core/types';
+import type { WorktreeHandle } from '@wrongstack/core/worktree';
+import type { SddParallelControlsHost } from './sdd-parallel-controls.js';
+import type { SddParallelRunOptions, SddProgress, SddSubtaskSpec, TaskOutcome } from './sdd-parallel-run-types.js';
+import { SddTaskDecomposer } from './sdd-task-decomposer.js';
+import { type SddTaskDispatchHost } from './sdd-task-dispatch.js';
+import { type SddTaskRecoveryHost } from './sdd-task-recovery.js';
+/**
+ * Run state and internal machinery behind `SddParallelRun`: limits and
+ * per-task bookkeeping, event emission, pause parking, recovery/requeue
+ * delegates, coordinator construction, failure handling, worktree
+ * integration and the host views the `sdd-task-*` / `sdd-parallel-controls`
+ * modules take. `SddParallelRun` (sdd-parallel-run.ts) extends this with the
+ * public control API and the scheduler loop; the members the host views need
+ * from it are declared abstract here.
+ */
+export declare abstract class SddParallelRunState {
+    protected readonly opts: SddParallelRunOptions;
+    protected readonly slots: number;
+    /** Opt-in hard wall-clock cap (undefined → no cap; idle reaper guards instead). */
+    protected readonly timeoutMs: number | undefined;
+    /** Idle reaper window (ms) — resets on activity; reaps only a genuine stall. */
+    protected readonly idleTimeoutMs: number;
+    protected readonly maxRetries: number;
+    /** Max supervisor rescues per task before it must terminal-fail (loop guard). */
+    protected readonly maxSupervisorEscalations: number;
+    /** Per-task count of supervisor rescues used (resets nothing — bounds the loop). */
+    protected supervisorEscalations: Map<string, number>;
+    /** Max end-of-run failed-task sweeps (see `maxFailedRetrySweeps`). */
+    protected readonly maxFailedSweeps: number;
+    /** How many failed-task sweeps have run this `run()` so far. */
+    protected failedSweeps: number;
+    /** Completed-count snapshot at the last sweep, to detect a no-progress sweep. */
+    protected lastSweepCompleted: number;
+    protected decomposer: SddTaskDecomposer;
+    protected coordinator: DefaultMultiAgentCoordinator | null;
+    protected stopRequested: boolean;
+    protected retryMap: Map<string, number>;
+    readonly runId: string;
+    protected readonly events?: EventBus | undefined;
+    protected readonly sessionIdSource: string | (() => string | undefined) | undefined;
+    protected readonly maxTotalWaves: number;
+    protected readonly maxWallClockMs?: number | undefined;
+    protected readonly maxRecoveryRounds: number;
+    protected recoveryRounds: number;
+    /** Per-run worker identities, so the board shows "who is on what". */
+    protected usedNicknames: Set<string>;
+    /** Per-task git worktree cwd (Layer 2 worktree isolation; empty otherwise). */
+    protected taskCwds: Map<string, string>;
+    /** Per-task git worktree branch, for board display. */
+    protected taskBranches: Map<string, string>;
+    /** Live worktree handles keyed by task id (for commit/merge/release). */
+    protected taskWorktrees: Map<string, WorktreeHandle>;
+    /** Live subagent id per running task — lets cancelTask() abort exactly one. */
+    protected taskSubagents: Map<string, string>;
+    /** Tasks the user cancelled mid-flight — skip retry, mark terminal-cancelled. */
+    protected cancelledTasks: Set<string>;
+    /**
+     * Base branch the run's squash commits land on (captured once at start when
+     * worktrees are enabled). Anchors a later `rollback()`.
+     */
+    protected baseBranch: string | undefined;
+    /**
+     * Squash-merge commits this run landed on the base branch, in landing order.
+     * `rollback()` reverts these (newest → oldest). Persisted via the board
+     * snapshot so a post-run rollback can read them off disk.
+     */
+    protected mergedCommits: Array<{
+        taskId: string;
+        sha: string;
+        title: string;
+    }>;
+    /**
+     * Fatal, non-recoverable run error — set together with `stopRequested` when
+     * the run hard-stops (e.g. a known-invalid merge that could not be rolled
+     * back). Surfaced on `run()`'s result so the caller can see WHY it stopped.
+     */
+    protected fatalError: string | undefined;
+    /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
+    protected dispatchSeq: number;
+    protected round: number;
+    /**
+     * 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.
+     */
+    protected runReturned: boolean;
+    constructor(opts: SddParallelRunOptions);
+    /** Type-safe emit on the optional EventBus (no-op when unwired). */
+    protected emit<K extends keyof import('@wrongstack/core/kernel').EventMap>(event: K, payload: import('@wrongstack/core/kernel').EventMap[K]): void;
+    protected currentSessionId(): string;
+    protected paused: boolean;
+    /** Resolvers for tasks parked in `waitWhilePaused`, woken on resume/stop. */
+    protected pausedWaiters: Set<() => void>;
+    protected notifyPausedWaiters(): void;
+    protected waitWhilePaused(): Promise<void>;
+    /**
+     * Compute the blocking chains for a deadlock: every still-incomplete task and
+     * the blockers (by node id) that are NOT completed. Failed blockers are
+     * included since they're the usual deadlock cause once retries are exhausted.
+     */
+    protected computeDeadlockChains(): Array<{
+        blocked: string;
+        blockedBy: string[];
+    }>;
+    /** Requeue failed tasks that block an incomplete dependent. Returns true if any. */
+    protected recoverFailedBlockers(): boolean;
+    /**
+     * Requeue every terminal-failed task that the user did NOT cancel, giving each
+     * a fresh `maxRetries` budget. Shared by the automatic end-of-run sweep and
+     * the manual "retry all failed" control. Returns the number requeued.
+     */
+    protected requeueFailedTasks(reason?: string): number;
+    /** Restore per-task retry counts persisted in node metadata (resume support). */
+    protected restoreRetryMap(): void;
+    /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
+    protected teardown(): Promise<void>;
+    /**
+     * Hard-stop the run after an unrecoverable error: the base branch is in a
+     * state no retry can fix (e.g. a known-invalid merge that could not be rolled
+     * back), so continuing would contaminate every task forked after this point.
+     * The reason is surfaced on `run()`'s result and the `sdd.run.finished` event.
+     */
+    protected abortRun(reason: string): void;
+    protected buildCoordinator(): void;
+    protected defaultFactory(): AgentFactory;
+    /**
+     * Apply a task failure: retry (→ pending, bump retry count) while attempts
+     * remain, else consult the optional supervisor (which can rescue via
+     * retry/reassign/split), else terminal-fail (→ failed). Shared by the
+     * worker-failure, verification-gate, and merge-conflict paths so all three
+     * negotiate the same retry budget and emit the same events.
+     */
+    protected applyTaskFailure(taskId: string, subagentId: string, errMsg: string): Promise<void>;
+    /**
+     * Consult `superviseFailure` for a task that has exhausted its retries.
+     * Applies the verdict (retry / reassign+retry / split) and returns true when
+     * the task was rescued (caller must NOT terminal-fail it). Bounded per task by
+     * `maxSupervisorEscalations` so an always-"retry" supervisor can't loop forever.
+     */
+    protected trySupervisorRescue(taskId: string, errMsg: string): Promise<boolean>;
+    /**
+     * Integrate a verified-successful task's worktree into the base branch.
+     * Commits, squash-merges (optionally running `conflictResolver` first), and on
+     * success releases the worktree. On an UNRESOLVED conflict it returns
+     * `{ok:false}` with the conflicting files so the caller routes the task into
+     * the failure path (a retry forks a fresh worktree off the now-advanced base,
+     * which usually clears the conflict). No-op `{ok:true}` when worktrees are
+     * disabled or none was allocated for this task. Never throws — a merge hiccup
+     * degrades to a (retryable) failure rather than wedging the run.
+     */
+    protected get worktreeState(): {
+        taskCwds: Map<string, string>;
+        taskBranches: Map<string, string>;
+        taskWorktrees: Map<string, WorktreeHandle>;
+        mergedCommits: {
+            taskId: string;
+            sha: string;
+            title: string;
+        }[];
+    };
+    protected integrateWorktree(task: TaskNode, result?: TaskResult): Promise<{
+        ok: boolean;
+        conflictFiles?: string[];
+        reason?: string;
+        fatal?: boolean;
+    }>;
+    /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
+    protected allocateWorktrees(tasks: TaskNode[]): Promise<void>;
+    /**
+     * Resolve each task's worktree after its result is known. Serialized merges
+     * (one at a time) keep the base branch consistent; the wave structure already
+     * guarantees dependency order (a task's blockers merged in an earlier wave).
+     */
+    protected resolveWorktrees(tasks: TaskNode[]): Promise<void>;
+    protected forgetWorktree(taskId: string, opts?: {
+        keepBranchLabel?: boolean;
+    }): void;
+    /** Persist a task's retry count into node metadata (survives crash → resume). */
+    protected persistRetries(taskId: string, retries: number): void;
+    protected buildProgress(): SddProgress;
+    protected sddTaskRecoveryHost(): SddTaskRecoveryHost;
+    protected sddTaskDispatchHost(): SddTaskDispatchHost;
+    protected sddParallelControlsHost(): SddParallelControlsHost;
+    abstract isRunning(): boolean;
+    abstract executeOne(task: TaskNode): Promise<TaskOutcome>;
+    abstract setTaskModel(taskId: string, model: string | undefined, provider?: string | undefined): boolean;
+    abstract splitTask(taskId: string, subtasks: SddSubtaskSpec[]): string[];
+}
+//# sourceMappingURL=sdd-parallel-run-state.d.ts.map

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

@@ -1,86 +1,29 @@
+/**
+ * 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';
-import { type TaskBatch } from './sdd-task-decomposer.js';
+import { SddParallelRunState } from './sdd-parallel-run-state.js';
+import type { RunResult, 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;
-    private readonly slots;
-    /** Opt-in hard wall-clock cap (undefined → no cap; idle reaper guards instead). */
-    private readonly timeoutMs;
-    /** Idle reaper window (ms) — resets on activity; reaps only a genuine stall. */
-    private readonly idleTimeoutMs;
-    private readonly maxRetries;
-    /** Max supervisor rescues per task before it must terminal-fail (loop guard). */
-    private readonly maxSupervisorEscalations;
-    /** Per-task count of supervisor rescues used (resets nothing — bounds the loop). */
-    private supervisorEscalations;
-    /** Max end-of-run failed-task sweeps (see `maxFailedRetrySweeps`). */
-    private readonly maxFailedSweeps;
-    /** How many failed-task sweeps have run this `run()` so far. */
-    private failedSweeps;
-    /** Completed-count snapshot at the last sweep, to detect a no-progress sweep. */
-    private lastSweepCompleted;
-    private decomposer;
-    private coordinator;
-    private stopRequested;
-    private retryMap;
-    readonly runId: string;
-    private readonly events?;
-    private readonly sessionIdSource;
-    private readonly maxTotalWaves;
-    private readonly maxWallClockMs?;
-    private readonly maxRecoveryRounds;
-    private recoveryRounds;
-    /** Per-run worker identities, so the board shows "who is on what". */
-    private usedNicknames;
-    /** Per-task git worktree cwd (Layer 2 worktree isolation; empty otherwise). */
-    private taskCwds;
-    /** Per-task git worktree branch, for board display. */
-    private taskBranches;
-    /** Live worktree handles keyed by task id (for commit/merge/release). */
-    private taskWorktrees;
-    /** Live subagent id per running task — lets cancelTask() abort exactly one. */
-    private taskSubagents;
-    /** Tasks the user cancelled mid-flight — skip retry, mark terminal-cancelled. */
-    private cancelledTasks;
-    /**
-     * Base branch the run's squash commits land on (captured once at start when
-     * worktrees are enabled). Anchors a later `rollback()`.
-     */
-    private baseBranch;
-    /**
-     * Squash-merge commits this run landed on the base branch, in landing order.
-     * `rollback()` reverts these (newest → oldest). Persisted via the board
-     * snapshot so a post-run rollback can read them off disk.
-     */
-    private mergedCommits;
-    /**
-     * Fatal, non-recoverable run error — set together with `stopRequested` when
-     * the run hard-stops (e.g. a known-invalid merge that could not be rolled
-     * back). Surfaced on `run()`'s result so the caller can see WHY it stopped.
-     */
-    private fatalError;
-    /** 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;
-    private currentSessionId;
-    private paused;
-    /** Resolvers for tasks parked in `waitWhilePaused`, woken on resume/stop. */
-    private pausedWaiters;
-    private notifyPausedWaiters;
+export declare class SddParallelRun extends SddParallelRunState {
     /** Trigger stop — causes run() to abort after the current wave. */
     stop(): void;
     /** Pause: no new wave starts until resume() (the current wave finishes). */
@@ -154,7 +97,6 @@ export declare class SddParallelRun {
      * The scheduler picks the new pending leaves up on its next dispatch pass.
      */
     splitTask(taskId: string, subtasks: SddSubtaskSpec[]): string[];
-    private waitWhilePaused;
     /**
      * Continuous dependency-driven execution. Unlike a wave-barrier loop (where a
      * whole batch must finish before the next starts), this fills free worker
@@ -164,20 +106,6 @@ export declare class SddParallelRun {
      * the final summary when the graph settles, deadlocks, stops, or hits a backstop.
      */
     run(): Promise<RunResult>;
-    /**
-     * Compute the blocking chains for a deadlock: every still-incomplete task and
-     * the blockers (by node id) that are NOT completed. Failed blockers are
-     * included since they're the usual deadlock cause once retries are exhausted.
-     */
-    private computeDeadlockChains;
-    /** Requeue failed tasks that block an incomplete dependent. Returns true if any. */
-    private recoverFailedBlockers;
-    /**
-     * Requeue every terminal-failed task that the user did NOT cancel, giving each
-     * a fresh `maxRetries` budget. Shared by the automatic end-of-run sweep and
-     * the manual "retry all failed" control. Returns the number requeued.
-     */
-    private requeueFailedTasks;
     /**
      * Manually requeue all failed tasks to `pending` (board "Retry all failed").
      * Unlike the automatic sweep this also clears any `cancelled` marker, so a
@@ -186,25 +114,12 @@ export declare class SddParallelRun {
      * Returns the number of tasks requeued.
      */
     retryAllFailed(): number;
-    /** Restore per-task retry counts persisted in node metadata (resume support). */
-    private restoreRetryMap;
     /**
      * Reset orphaned `in_progress` tasks (no agent runs them after a crash) back
      * to `pending` so a fresh run re-executes them. Call before constructing a run
      * from a reloaded graph. Static so callers don't need a run instance.
      */
     static resetOrphans(tracker: TaskTracker): number;
-    /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
-    private teardown;
-    /**
-     * Hard-stop the run after an unrecoverable error: the base branch is in a
-     * state no retry can fix (e.g. a known-invalid merge that could not be rolled
-     * back), so continuing would contaminate every task forked after this point.
-     * The reason is surfaced on `run()`'s result and the `sdd.run.finished` event.
-     */
-    private abortRun;
-    private buildCoordinator;
-    private defaultFactory;
     /**
      * Execute a batch of tasks together. Retained as a thin wrapper over the
      * single-task primitive `executeOne` so the wave-oriented tests and any
@@ -221,46 +136,5 @@ export declare class SddParallelRun {
      * missing coordinator or failed spawn so callers can enforce all-or-nothing.
      */
     executeOne(task: TaskNode): Promise<TaskOutcome>;
-    /**
-     * Apply a task failure: retry (→ pending, bump retry count) while attempts
-     * remain, else consult the optional supervisor (which can rescue via
-     * retry/reassign/split), else terminal-fail (→ failed). Shared by the
-     * worker-failure, verification-gate, and merge-conflict paths so all three
-     * negotiate the same retry budget and emit the same events.
-     */
-    private applyTaskFailure;
-    /**
-     * Consult `superviseFailure` for a task that has exhausted its retries.
-     * Applies the verdict (retry / reassign+retry / split) and returns true when
-     * the task was rescued (caller must NOT terminal-fail it). Bounded per task by
-     * `maxSupervisorEscalations` so an always-"retry" supervisor can't loop forever.
-     */
-    private trySupervisorRescue;
-    /**
-     * Integrate a verified-successful task's worktree into the base branch.
-     * Commits, squash-merges (optionally running `conflictResolver` first), and on
-     * success releases the worktree. On an UNRESOLVED conflict it returns
-     * `{ok:false}` with the conflicting files so the caller routes the task into
-     * the failure path (a retry forks a fresh worktree off the now-advanced base,
-     * which usually clears the conflict). No-op `{ok:true}` when worktrees are
-     * disabled or none was allocated for this task. Never throws — a merge hiccup
-     * degrades to a (retryable) failure rather than wedging the run.
-     */
-    private get worktreeState();
-    private integrateWorktree;
-    /** Allocate a fresh git worktree per task in the batch (no-op without a manager). */
-    private allocateWorktrees;
-    /**
-     * Resolve each task's worktree after its result is known. Serialized merges
-     * (one at a time) keep the base branch consistent; the wave structure already
-     * guarantees dependency order (a task's blockers merged in an earlier wave).
-     */
-    private resolveWorktrees;
-    private forgetWorktree;
-    /** Persist a task's retry count into node metadata (survives crash → resume). */
-    private persistRetries;
-    private buildProgress;
-    private sddTaskRecoveryHost;
-    private sddTaskDispatchHost;
 }
 //# sourceMappingURL=sdd-parallel-run.d.ts.map

package/dist/spec-builder-parsing.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parsing of AI output for `AISpecBuilder`: locating a JSON object / array in
+ * free text and validating + normalizing a specification object.
+ */
+import type { Specification } from '@wrongstack/core/types';
+/**
+ * Parse a spec from a JSON string (from AI output). Validates and normalizes
+ * the structure; `fallbackTitle` applies when the JSON has none, `sessionId`
+ * is recorded in the spec metadata.
+ */
+export declare function parseSpecificationJSON(jsonStr: string, fallbackTitle: string, sessionId: string): Specification;
+/** Extract JSON from AI output (handles ```json blocks and raw JSON). */
+export declare function extractJSONFromText(text: string): string | null;
+/** Extract a JSON array from AI output (for task lists). */
+export declare function extractJSONArrayFromText(text: string): string | null;
+//# sourceMappingURL=spec-builder-parsing.d.ts.map

package/dist/spec-builder-prompts.d.ts

@@ -0,0 +1,7 @@
+import type { AISpecSession } from './sdd-session-types.js';
+export declare function buildQuestioningPrompt(session: AISpecSession, min: number, max: number): string;
+export declare function buildSpecReviewPrompt(session: AISpecSession): string;
+export declare function buildImplementationPrompt(session: AISpecSession): string;
+export declare function buildTaskReviewPrompt(session: AISpecSession): string;
+export declare function buildExecutingPrompt(session: AISpecSession): string;
+//# sourceMappingURL=spec-builder-prompts.d.ts.map

package/dist/spec-builder-session-file.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Legacy file persistence for `AISpecBuilder` sessions (`sessionPath`), used
+ * when no durable `sessionPersistence` owner is configured. Modules load
+ * lazily, as before.
+ */
+import { type AISpecSession } from './sdd-session-types.js';
+export declare function writeAISpecSessionFile(sessionPath: string, snapshot: AISpecSession): Promise<void>;
+/** The saved session, or undefined when missing, unreadable or invalid. */
+export declare function readAISpecSessionFile(sessionPath: string): Promise<AISpecSession | undefined>;
+export declare function deleteAISpecSessionFile(sessionPath: string): Promise<void>;
+//# sourceMappingURL=spec-builder-session-file.d.ts.map

package/dist/task-generator.d.ts

@@ -1,4 +1,4 @@
-import type { TaskStore, TaskTracker } from '@wrongstack/core/tasking';
+import type { TaskTracker } from '@wrongstack/core/tasking';
 import type { Specification, TaskGraph, TaskNode, TaskPriority, TaskType } from '@wrongstack/core/types';
 import { type AtomicityRuleSetConfig } from '@wrongstack/kanban';
 export interface TaskGeneratorOptions {
@@ -64,5 +64,4 @@ export declare class TaskGenerator {
     private addRequirementTask;
     generateSubtasks(parentTaskId: string, spec: Specification): Promise<void>;
 }
-export type { TaskStore };
 //# sourceMappingURL=task-generator.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "1.0.33",
+  "version": "1.0.36",
   "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.33",
-    "@wrongstack/kanban": "1.0.33",
-    "@wrongstack/primitives": "1.0.33",
-    "@wrongstack/requirement-intake": "1.0.33"
+    "@wrongstack/core": "1.0.36",
+    "@wrongstack/kanban": "1.0.36",
+    "@wrongstack/primitives": "1.0.36",
+    "@wrongstack/requirement-intake": "1.0.36"
   },
   "devDependencies": {
     "@types/node": "^26.5.1",
@@ -41,7 +41,7 @@
   },
   "scripts": {
     "build": "node ../../scripts/build-package.mjs",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "node ../../scripts/bun-typecheck.mjs --noEmit",
     "test": "vitest run",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   }