@wrongstack/core 0.283.1 → 0.284.0

package/dist/sdd/index.d.ts

@@ -1,1993 +0,0 @@
-import { h as Specification, e as SpecStatus, S as SpecAnalysis, g as SpecValidationResult, f as SpecTemplate, b as SpecRequirement } from '../spec-TBi3Jr6T.js';
-import { d as TaskGraph, e as TaskNode, k as TaskFilter, l as TaskSort, c as TaskProgress, T as TaskType, a as TaskPriority } from '../task-graph-CH3acNQ7.js';
-import { E as EventBus, B as BrainArbiter } from '../events-KmxSmvho.js';
-import { A as Agent, a as AgentFactory, g as TaskResult, D as DoneCondition } from '../agent-subagent-runner-BsuWhB28.js';
-import { W as WorktreeManager } from '../worktree-manager-BjyAW30D.js';
-import '../tool-LVSLiE1s.js';
-import '../permission-B6YAtNFz.js';
-import '../index-BhCteHAF.js';
-import '../logger-B63L5bTg.js';
-import '../pipeline-ixSFe5jg.js';
-import '../mailbox-types-BGZWrYTJ.js';
-import '../config-DkCbA3Bw.js';
-import '../observability-D-HZN_mF.js';
-import '../secret-scrubber-3MHDDAtm.js';
-import '../retry-policy-V67lBOJz.js';
-
-interface TaskStore {
-    saveGraph(graph: TaskGraph): Promise<void>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    listGraphs(): Promise<{
-        id: string;
-        title: string;
-        updatedAt: number;
-    }[]>;
-    deleteGraph(id: string): Promise<void>;
-}
-interface TaskTrackerOptions {
-    store: TaskStore;
-    /**
-     * Called when an in-the-background persistence (`saveGraph`) rejects.
-     * The synchronous TaskTracker methods (addNode/addEdge/updateNodeStatus)
-     * fire-and-forget their writes; without this, a failing store silently
-     * loses graph mutations. Defaults to a console.warn.
-     */
-    onPersistError?: (((err: unknown) => void)) | undefined;
-}
-interface TaskTransition {
-    from: TaskNode['status'];
-    to: TaskNode['status'];
-    timestamp: number;
-    reason?: string | undefined;
-}
-/** A change notification emitted to `TaskTracker.subscribe` listeners. */
-interface TaskTrackerChange {
-    type: 'node_added' | 'node_updated' | 'status_changed' | 'node_removed';
-    nodeId: string;
-    /** For `node_removed` this is the node as it was just before deletion. */
-    node: TaskNode;
-    transition?: TaskTransition | undefined;
-}
-type TaskTrackerListener = (change: TaskTrackerChange) => void;
-declare class TaskTracker {
-    private readonly opts;
-    private graph;
-    private transitions;
-    private listeners;
-    constructor(opts: TaskTrackerOptions);
-    /**
-     * Subscribe to live task mutations (add / update / status change). Returns an
-     * unsubscribe fn. This is the hook the board projector uses to stream a live
-     * snapshot — the tracker was previously fire-and-forget with no observability.
-     */
-    subscribe(listener: TaskTrackerListener): () => void;
-    private notifyChange;
-    /**
-     * Attach an existing graph (used by PhaseOrchestrator to associate a tracker
-     * with a phase's pre-built task graph without re-creating it).
-     */
-    setGraph(graph: TaskGraph): void;
-    createGraph(specId: string, title: string): Promise<TaskGraph>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    addNode(node: Omit<TaskNode, 'id' | 'createdAt' | 'updatedAt'>): TaskNode;
-    addEdge(from: string, to: string, type?: TaskGraph['edges'][0]['type']): void;
-    /**
-     * Declare that `taskId` depends on `depId` (a `depends_on` edge `depId → taskId`),
-     * guarding against self-loops, duplicates, missing nodes, and cycles. Returns
-     * true if the dependency now holds (added or already present), false if it was
-     * rejected (would create a cycle / unknown node). This is the safe entry point
-     * for wiring agent-declared `dependsOn` references into the graph.
-     */
-    addDependency(depId: string, taskId: string): boolean;
-    /** True when `taskId` transitively depends on `targetId` (follows depends_on blockers). */
-    private dependsOnTransitively;
-    /**
-     * Merge `patch` into a node's `metadata` (used for per-task model/provider/
-     * fallback assignment and the cancel marker). Persists + notifies as a node
-     * update. No-op if the node is missing.
-     */
-    patchMetadata(id: string, patch: Record<string, unknown>): void;
-    /**
-     * Remove a node and every edge touching it. Intended for deleting a task that
-     * has not started yet — callers must gate on status (do not remove a running
-     * task). Dependents simply lose this blocker (re-evaluated by `canStart`).
-     * Returns true if a node was removed.
-     */
-    removeNode(id: string): boolean;
-    updateNodeStatus(id: string, status: TaskNode['status'], reason?: string): void;
-    updateNode(id: string, patch: Partial<Pick<TaskNode, 'title' | 'description' | 'priority' | 'estimateHours' | 'tags' | 'assignee'>>): void;
-    getNode(id: string): TaskNode | undefined;
-    getAllNodes(filter?: TaskFilter, sort?: TaskSort): TaskNode[];
-    getChildren(parentId: string): TaskNode[];
-    getDependents(taskId: string): string[];
-    getBlockers(taskId: string): string[];
-    canStart(taskId: string): boolean;
-    getProgress(): TaskProgress;
-    getTransitions(_taskId?: string): TaskTransition[];
-    private unblockDependents;
-    private checkAndBlockIfNeeded;
-    /**
-     * Fire-and-forget persistence with attached error handler.
-     * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
-     * avoid forcing an async cascade through every caller; if the store
-     * is missing or throwing, the error is surfaced via onPersistError.
-     */
-    private persist;
-}
-
-interface AutoExecutorOptions {
-    tracker: TaskTracker;
-    events: EventBus;
-    /** Maximum concurrent tasks. Defaults to 1 (sequential). */
-    maxConcurrent?: number | undefined;
-    /** Maximum retry attempts for failed tasks. */
-    maxRetries?: number | undefined;
-    /** Custom task executor function. */
-    executeTask: (task: TaskNode, context: TaskExecutionContext) => Promise<TaskExecutionResult>;
-    /** Called before each task starts. */
-    onTaskStart?: (((task: TaskNode) => void)) | undefined;
-    /** Called after each task completes. */
-    onTaskComplete?: (task: TaskNode, result: TaskExecutionResult) => void;
-    /** Called when a task fails. */
-    onTaskFail?: (task: TaskNode, error: Error, retryCount: number) => void;
-    /** Called when all tasks are done or no more can execute. */
-    onDone?: (((summary: ExecutionSummary) => void)) | undefined;
-}
-interface TaskExecutionContext {
-    /** The spec being implemented. */
-    spec: Specification;
-    /** The full task graph. */
-    graph: TaskGraph;
-    /** The current task being executed. */
-    task: TaskNode;
-    /** Tasks that this task depends on. */
-    dependencies: TaskNode[];
-    /** Tasks that depend on this task. */
-    dependents: TaskNode[];
-    /** Retry count for this task (0 = first attempt). */
-    retryCount: number;
-}
-interface TaskExecutionResult {
-    success: boolean;
-    output?: string | undefined;
-    error?: string | undefined;
-    /** If true, the task will be retried. */
-    retry?: boolean | undefined;
-}
-interface ExecutionSummary {
-    total: number;
-    completed: number;
-    failed: number;
-    skipped: number;
-    retried: number;
-    duration: number;
-    criticalPath: string[];
-}
-/**
- * Auto-executor that drives task execution with dependency resolution,
- * retry logic, and critical path awareness.
- */
-declare class AutoExecutor {
-    private readonly opts;
-    private stopped;
-    private retryMap;
-    constructor(opts: AutoExecutorOptions);
-    /**
-     * Execute all tasks in the graph, respecting dependencies.
-     */
-    execute(graph: TaskGraph, spec: Specification): Promise<ExecutionSummary>;
-    /** Stop execution. */
-    stop(): void;
-    /** Get tasks that are ready to execute (all dependencies completed). */
-    private getReadyTasks;
-    /** Execute a single task with retry logic. */
-    private executeTaskWithRetry;
-    /** Get tasks that this task depends on. */
-    private getTaskDependencies;
-    /** Get tasks that depend on this task. */
-    private getTaskDependents;
-    /** Detect deadlock: all remaining tasks are blocked by failed tasks. */
-    private detectDeadlock;
-}
-/**
- * Create an auto-executor that works with TaskFlow.
- */
-declare function createAutoExecutor(opts: {
-    tracker: TaskTracker;
-    events: EventBus;
-    executeTask: AutoExecutorOptions['executeTask'];
-    maxConcurrent?: number | undefined;
-    maxRetries?: number | undefined;
-}): AutoExecutor;
-
-/**
- * SDD live board model.
- *
- * A board snapshot is the canonical, surface-agnostic projection of a running
- * (or persisted) SDD TaskGraph: tasks laid into topological dependency columns,
- * each carrying its short id, status, blockers and the agent currently on it.
- * The projector (sdd-board-projector.ts) emits these over the EventBus and
- * persists them (sdd-board-store.ts); every surface (WebUI/TUI) renders the
- * same shape.
- */
-
-type SddBoardStatus = 'idle' | 'running' | 'paused' | 'stopped' | 'completed' | 'failed' | 'deadlocked';
-/**
- * FORGE-style display status: `queued` = pending with all blockers done;
- * `cancelled` = a task the user stopped (stored as a terminal `failed` node
- * carrying `metadata.cancelled`, surfaced distinctly so it doesn't read as an
- * error). Display-only — not a core `TaskStatus`.
- */
-type SddTaskDisplayStatus = TaskNode['status'] | 'queued' | 'cancelled';
-interface SddBoardTask {
-    id: string;
-    /** Stable short id (t01, t02, …) in creation order. */
-    shortId: string;
-    title: string;
-    description: string;
-    status: TaskNode['status'];
-    displayStatus: SddTaskDisplayStatus;
-    priority: TaskNode['priority'];
-    type: TaskNode['type'];
-    /** Short ids of the tasks that block this one (depends_on edges). */
-    deps: string[];
-    /** Worker on the task right now (scientist nickname), if any. */
-    agentName?: string | undefined;
-    /** Git worktree branch this task runs in, when isolated. */
-    worktreeBranch?: string | undefined;
-    startedAt?: number | undefined;
-    completedAt?: number | undefined;
-    retries: number;
-    /** Per-task model assignment (overrides the run default), if set. */
-    model?: string | undefined;
-    /** Per-task provider assignment (overrides the run default), if set. */
-    provider?: string | undefined;
-    /** Per-task fallback model chain (overrides the run default), if set. */
-    fallbackModels?: string[] | undefined;
-    /** Per-task completion-gate verification command, if set. */
-    verificationCommand?: string | undefined;
-}
-/** A topological column: tasks whose deepest dependency chain is `depth`. */
-interface SddBoardColumn {
-    label: string;
-    /** Short ids of the tasks in this column (join against `tasks`). */
-    taskIds: string[];
-}
-interface SddDeadlockChain {
-    /** Short id of the blocked task. */
-    blocked: string;
-    /** Short ids of the failed/incomplete blockers holding it. */
-    blockedBy: string[];
-}
-/** One entry in the live activity feed (the board's "what just happened" ticker). */
-interface SddBoardFeedEntry {
-    ts: number;
-    kind: 'started' | 'completed' | 'failed' | 'retrying' | 'wave' | 'deadlock' | 'verification_failed' | 'conflict' | 'split' | 'supervisor';
-    /** Short id of the task this entry concerns, when applicable. */
-    taskShortId?: string | undefined;
-    /** Worker involved, when applicable. */
-    agentName?: string | undefined;
-    /** Human-readable one-line summary. */
-    text: string;
-}
-interface SddBoardSnapshot {
-    runId: string;
-    specId?: string | undefined;
-    graphId: string;
-    title: string;
-    status: SddBoardStatus;
-    startedAt: number;
-    updatedAt: number;
-    progress: TaskProgress;
-    /** Current wave index (0-based) of the parallel run. */
-    wave: number;
-    tasks: SddBoardTask[];
-    columns: SddBoardColumn[];
-    diagnostics?: {
-        deadlockChains?: SddDeadlockChain[];
-    } | undefined;
-    /** Live activity feed — most recent first (capped). */
-    feed?: SddBoardFeedEntry[] | undefined;
-    /** Run-level default worker model (task overrides take precedence). */
-    defaultModel?: string | undefined;
-    /** Run-level default worker provider. */
-    defaultProvider?: string | undefined;
-    /** Run-level default fallback model chain. */
-    fallbackModels?: string[] | undefined;
-    /** Base branch the run's squash commits land on (worktree runs only). */
-    baseBranch?: string | undefined;
-    /**
-     * Squash commits the run landed on the base branch, in landing order. Lets a
-     * post-run `/sdd rollback` revert them from disk after the live run is gone.
-     */
-    mergedCommits?: Array<{
-        taskId: string;
-        sha: string;
-        title: string;
-    }> | undefined;
-}
-/**
- * Lay a TaskGraph's nodes into topological dependency columns with stable short
- * ids and per-task blocker refs. Shared by the projector (live) and any static
- * board browser. Pure; no run state — `agentName`/`worktreeBranch`/`retries`
- * are read from the node's `assignee`/`metadata` so a reload reflects the last
- * persisted run.
- */
-/**
- * Stable short-id map (t01, t02, …) for a graph's nodes in creation order.
- * Shared by the board renderer and the projector (deadlock-chain labelling).
- */
-declare function shortIdMap(graph: TaskGraph): Map<string, string>;
-declare function buildBoardTasks(graph: TaskGraph): {
-    tasks: SddBoardTask[];
-    columns: SddBoardColumn[];
-};
-/**
- * Build a full board snapshot from a graph + run state. The projector calls
- * this on every (throttled) change.
- */
-declare function buildBoardSnapshot(graph: TaskGraph, run: {
-    runId: string;
-    specId?: string | undefined;
-    status: SddBoardStatus;
-    startedAt: number;
-    wave: number;
-    deadlockChains?: SddDeadlockChain[] | undefined;
-    defaultModel?: string | undefined;
-    defaultProvider?: string | undefined;
-    fallbackModels?: string[] | undefined;
-    baseBranch?: string | undefined;
-    mergedCommits?: Array<{
-        taskId: string;
-        sha: string;
-        title: string;
-    }> | undefined;
-}, now: number): SddBoardSnapshot;
-
-type ConflictSide = 'incoming' | 'base';
-/**
- * Resolve every standard git conflict hunk in `text` by keeping `side`. Handles
- * both 2-way (`<<<<<<< / ======= / >>>>>>>`) and diff3 (`||||||| base`) markers.
- * Returns the rewritten text (markers removed).
- */
-declare function resolveConflictText(text: string, side: ConflictSide): string;
-/** True when `text` still contains a git conflict marker line. */
-declare function hasConflictMarkers(text: string): boolean;
-/**
- * Build a `conflictResolver` that keeps `side` of every hunk in each conflicted
- * file. Returns false (abort → conservative fail) if any file can't be read,
- * written, or still has markers after the rewrite.
- */
-declare function makePreferSideConflictResolver(side: ConflictSide): (info: {
-    task: TaskNode;
-    conflictFiles: string[];
-    cwd: string;
-}) => Promise<boolean>;
-interface LlmConflictResolverOptions {
-    /** Runs one self-contained, isolated LLM turn and resolves its final text. */
-    run: (prompt: string) => Promise<string>;
-    /**
-     * Reject a resolution that shrinks the file below this fraction of its original
-     * non-marker line count — a crude guard against the model dropping content.
-     * Default 0.5.
-     */
-    minRetainedFraction?: number;
-}
-/**
- * Build an LLM-backed `conflictResolver`: for each conflicted file it asks the
- * model (via one isolated `run` turn) to produce the fully resolved file and
- * writes it back. Heavily guarded — returns false (→ conservative abort/retry)
- * if the model leaves a marker, returns junk, or drops too much content. The
- * WorktreeManager STILL rejects any surviving marker, and (when a `verifyTask`
- * is configured) the run re-verifies the integrated base and reverts a
- * regression — so a bad LLM merge can never silently stick. OFF by default.
- */
-declare function makeLlmConflictResolver(opts: LlmConflictResolverOptions): (info: {
-    task: TaskNode;
-    conflictFiles: string[];
-    cwd: string;
-}) => Promise<boolean>;
-
-/**
- * Enhanced critical path analysis with bottleneck detection,
- * parallel execution groups, and time estimation.
- */
-interface CriticalPathAnalysis {
-    /** Ordered list of critical path task IDs. */
-    criticalPath: string[];
-    /** Total estimated hours for the critical path. */
-    totalHours: number;
-    /** Tasks that block the most downstream work. */
-    bottlenecks: BottleneckTask[];
-    /** Groups of tasks that can run in parallel. */
-    parallelGroups: string[][];
-    /** Recommended execution order respecting dependencies. */
-    executionOrder: string[];
-    /** Tasks with no blockers (can start immediately). */
-    readyTasks: string[];
-    /** Tasks that are blocked and cannot start. */
-    blockedTasks: string[];
-}
-interface BottleneckTask {
-    taskId: string;
-    title: string;
-    /** Number of tasks directly or transitively blocked by this task. */
-    blockedCount: number;
-    /** Total estimated hours of blocked downstream work. */
-    blockedHours: number;
-    /** Severity score (0-100). */
-    severity: number;
-}
-/**
- * Analyze a task graph and return critical path analysis.
- */
-declare function analyzeCriticalPath(graph: TaskGraph): CriticalPathAnalysis;
-
-/**
- * SddTaskDecomposer
- *
- * Converts a TaskGraph (from SDD's TaskGenerator) into a dependency-aware
- * sequence of batches for ParallelEternalEngine.
- *
- * Key behaviour:
- * - Each `nextBatch()` call returns up to `parallelSlots` ready tasks
- *   (all blockers completed, sorted by priority).
- * - Tasks that are blocked by an in-progress task are NOT included
- *   in the batch — they wait for the blocker to complete.
- * - When `isDone()` returns true the whole graph is either completed
- *   or deadlocked (all remaining tasks are blocked by failed tasks).
- *
- * Usage:
- * ```
- * const decomposer = new SddTaskDecomposer(tracker, graph, { parallelSlots: 4 });
- * while (!decomposer.isDone()) {
- *   const batch = decomposer.nextBatch();
- *   if (batch.length === 0) break; // deadlock
- *   await fanOut(batch);
- *   decomposer.acknowledgeBatch(batch.map(t => t.id));
- * }
- * ```
- */
-
-interface SddTaskDecomposerOptions {
-    /** Max tasks per batch. Default: 4. Range 1–16. */
-    parallelSlots?: number | undefined;
-}
-interface TaskBatch {
-    /** Tasks ready to execute in this wave. */
-    tasks: TaskNode[];
-    /** 0-based wave number since the decomposer was constructed. */
-    wave: number;
-    /** True when every node in the graph is either completed or failed. */
-    allDone: boolean;
-    /** True when no batch was produced because remaining tasks are all blocked by failed nodes. */
-    deadlocked: boolean;
-}
-declare class SddTaskDecomposer {
-    private readonly tracker;
-    private readonly slots;
-    private wave;
-    constructor(tracker: TaskTracker, _graph: TaskGraph, opts?: SddTaskDecomposerOptions);
-    /**
-     * 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(): TaskBatch;
-    /**
-     * Advance the wave counter after a batch completes.
-     * Call this once per `nextBatch()` result that was fan-out.
-     */
-    acknowledgeBatch(_completedTaskIds: string[]): void;
-    /**
-     * True when every node in the graph is completed.
-     * Use this to exit the fan-out loop after `isDone() || deadlocked`.
-     */
-    isDone(): boolean;
-    /**
-     * Total waves produced so far.
-     */
-    getWaveCount(): number;
-    /**
-     * 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(): TaskNode[];
-    /**
-     * 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(): boolean;
-    /**
-     * Return pending nodes whose blockers are all completed.
-     * Sorted by priority (critical first), then by creation time.
-     */
-    private pendingReadyNodes;
-    /** True when at least one non-completed, non-failed task is blocked. */
-    private hasAnyBlockedTasks;
-}
-
-/** A sub-task produced by splitting a parent task (see `splitTask`). */
-interface SddSubtaskSpec {
-    title: string;
-    description: string;
-    type?: TaskNode['type'] | undefined;
-    priority?: TaskNode['priority'] | undefined;
-}
-/**
- * Verdict returned by the optional failure supervisor when a task is about to go
- * terminal. `retry` re-queues with a fresh attempt budget; `reassign` swaps the
- * worker model (+ optional provider) then re-queues; `split` breaks the task
- * into sub-tasks; `fail` (or `undefined`) lets it terminal-fail.
- */
-type SddSupervisorVerdict = {
-    action: 'retry';
-} | {
-    action: 'reassign';
-    model?: string | undefined;
-    provider?: string | undefined;
-} | {
-    action: 'split';
-    subtasks: SddSubtaskSpec[];
-} | {
-    action: 'fail';
-};
-interface SddParallelRunOptions {
-    /** Pre-constructed TaskTracker (must already hold the graph's initial state). */
-    tracker: TaskTracker;
-    /** The TaskGraph produced by TaskGenerator from an approved spec. */
-    graph: TaskGraph;
-    /** The main agent — used as the subagent factory. */
-    agent: Agent;
-    /** Project root (used for coordinator id). */
-    projectRoot: string;
-    /**
-     * Override default parallel slots (1–16). Default: 2 — deliberately low so a
-     * run never juggles more git worktrees than a human can review. Independent
-     * tasks still run concurrently up to this cap; dependency chains run in order.
-     */
-    parallelSlots?: number | undefined;
-    /**
-     * Hard wall-clock cap per task in ms. OPT-IN — `undefined` by default so a
-     * long-but-productive task is never killed merely for running long (the old
-     * 5-min default hard-killed real coding tasks with `budget_timeout`). When
-     * set, the coordinator watchdog enforces it. Prefer `taskIdleTimeoutMs`.
-     */
-    taskTimeoutMs?: number | undefined;
-    /**
-     * Idle reaper per task in ms: reap a task only after this long with NO
-     * activity (iteration / tool call / streamed token / tool progress). Resets
-     * on every sign of forward motion, so an actively-working agent runs until
-     * its task naturally ends. Default: 600_000 (10 min of silence = genuinely
-     * stuck). This is the default guard — wall-clock (`taskTimeoutMs`) is opt-in.
-     */
-    taskIdleTimeoutMs?: number | undefined;
-    /** Maximum in-run retry attempts for a failed task before it goes terminal. Default: 3. */
-    maxRetries?: number | undefined;
-    /**
-     * After the graph settles with terminal-failed tasks, requeue ALL failed
-     * (non-cancelled) tasks to `pending` and run them again — up to this many
-     * sweeps. Each sweep gives every failed task a fresh `maxRetries` budget. The
-     * loop stops early once a sweep produces no new completions (no progress).
-     * 0 = off. Default: 2.
-     */
-    maxFailedRetrySweeps?: number | undefined;
-    /** Override the default agent factory. */
-    subagentFactory?: AgentFactory | undefined;
-    /**
-     * Run-level default model for worker subagents. A task's own
-     * `metadata.model` (set per-task in the WebUI) takes precedence; this is the
-     * fallback for every task that has no explicit assignment. Undefined → the
-     * factory's own default (the leader's model).
-     */
-    defaultModel?: string | undefined;
-    /** Run-level default provider id (same precedence rules as defaultModel). */
-    defaultProvider?: string | undefined;
-    /**
-     * Run-level fallback model chain (entries: `model` / `provider/model`). A
-     * task's `metadata.fallbackModels` overrides this. The subagent factory wires
-     * these into a fallback extension so a 429/stream-hang rotates to the next.
-     */
-    fallbackModels?: string[] | undefined;
-    /**
-     * Post-task verification gate. When set, a task whose worker reported success
-     * is NOT marked `completed` (and NOT merged) until this resolves `{ok:true}`.
-     * Runs in the task's worktree cwd (or the project root when no worktree). Core
-     * stays shell-agnostic — the caller injects a verifier that, e.g., runs the
-     * task's `metadata.verificationCommand` (tests / typecheck). A task with no
-     * command should return `{ok:true}`. An `{ok:false}` routes the task into the
-     * normal failure path (retry while attempts remain, else terminal-fail).
-     */
-    verifyTask?: ((info: {
-        task: TaskNode;
-        result: TaskResult;
-        cwd: string;
-    }) => Promise<{
-        ok: boolean;
-        reason?: string;
-    }>) | undefined;
-    /**
-     * Optional merge-conflict resolver, forwarded to `WorktreeManager.merge`. Given
-     * the conflicted files + the base checkout cwd, return `true` once resolved (no
-     * markers left). When omitted or it returns `false`, the task is requeued (a
-     * re-run forks a fresh worktree off the advanced base) and, if retries are
-     * exhausted, terminally failed with its worktree kept for review.
-     */
-    conflictResolver?: ((info: {
-        task: TaskNode;
-        conflictFiles: string[];
-        cwd: string;
-    }) => Promise<boolean>) | undefined;
-    /**
-     * Failure supervisor: consulted ONLY when a task has exhausted its retries and
-     * is about to go terminal-failed. Returning a verdict lets a decision agent
-     * keep the run moving — `retry` / `reassign` (swap model) / `split` — instead
-     * of dead-ending. Returning `{action:'fail'}` / `undefined` lets it fail. Each
-     * task can be rescued at most `maxSupervisorEscalations` times (loop guard).
-     */
-    superviseFailure?: ((info: {
-        task: TaskNode;
-        error: string;
-        attempts: number;
-    }) => Promise<SddSupervisorVerdict | undefined>) | undefined;
-    /** Max times the supervisor may rescue a single task before it must fail. Default 2. */
-    maxSupervisorEscalations?: number | undefined;
-    /** Called after each wave completes. */
-    onWave?: ((wave: WaveResult) => void) | undefined;
-    /** Called with progress stats every ~2s during execution. */
-    onProgress?: ((progress: SddProgress) => void) | undefined;
-    /** Shared EventBus — when set, the run emits `sdd.*` live-board events. */
-    events?: EventBus | undefined;
-    /** Parent session id for every emitted `sdd.*` event. */
-    sessionId?: string | (() => string | undefined) | undefined;
-    /** Stable id correlating all events of this run (default: random). */
-    runId?: string | undefined;
-    /**
-     * Optional git-worktree manager. When set (and the project is a git repo),
-     * each task runs in its own isolated worktree and merges back into the base
-     * branch after success — so parallel agents never collide on the same files.
-     */
-    worktrees?: WorktreeManager | undefined;
-    /** Run-level backstops (prevent an autonomous run from looping forever). */
-    maxTotalWaves?: number | undefined;
-    maxWallClockMs?: number | undefined;
-    /**
-     * Deadlock auto-recovery rounds: when the graph deadlocks on failed blockers,
-     * requeue those failed blockers `pending` and try again, up to N times. 0 = off.
-     */
-    maxRecoveryRounds?: number | undefined;
-}
-interface SddProgress {
-    wave: number;
-    total: number;
-    completed: number;
-    inProgress: number;
-    failed: number;
-    blocked: number;
-    pending: number;
-    percent: number;
-    deadlocked: boolean;
-}
-interface WaveResult {
-    wave: number;
-    batch: TaskBatch;
-    results: TaskResult[];
-    successCount: number;
-    failCount: number;
-    durationMs: number;
-    stopRequested: boolean;
-}
-/** Result of a single task's execution in the continuous scheduler. */
-interface TaskOutcome {
-    taskId: string;
-    success: boolean;
-    result?: TaskResult | undefined;
-}
-interface RunResult {
-    totalWaves: number;
-    totalCompleted: number;
-    totalFailed: number;
-    totalDurationMs: number;
-    deadlocked: boolean;
-    stopRequested: boolean;
-    finalProgress: TaskProgress;
-}
-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;
-    /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
-    private dispatchSeq;
-    private round;
-    constructor(opts: SddParallelRunOptions);
-    /** Type-safe emit on the optional EventBus (no-op when unwired). */
-    private emit;
-    private currentSessionId;
-    private paused;
-    /** Trigger stop — causes run() to abort after the current wave. */
-    stop(): void;
-    /** Pause: no new wave starts until resume() (the current wave finishes). */
-    pause(): void;
-    resume(): void;
-    isPaused(): boolean;
-    isRunning(): boolean;
-    /** Base branch the run's squash commits land on (undefined when worktrees off). */
-    getBaseBranch(): string | undefined;
-    /** Squash commits this run landed on the base branch, in landing order. */
-    getMergedCommits(): ReadonlyArray<{
-        taskId: string;
-        sha: string;
-        title: string;
-    }>;
-    /**
-     * Remove every git worktree + branch this run (and any prior run) created.
-     * Refuses while the run is still live — cleaning a checkout under an active
-     * worker would corrupt it. Stop first. Returns the number of worktrees removed
-     * (0 when worktrees are disabled). Idempotent.
-     */
-    cleanupWorktrees(): Promise<number>;
-    /**
-     * Undo the run's merged commits by reverting each on the base branch (history
-     * preserving). Refuses while the run is still live (stop first). Returns the
-     * revert outcome; a dirty tree or revert conflict surfaces as `ok:false`.
-     */
-    rollback(): Promise<{
-        ok: boolean;
-        reverted: number;
-        reason?: string;
-    }>;
-    /** Requeue a task to `pending` so the scheduler re-runs it (clears retries + cancel marker). */
-    retryTask(taskId: string): boolean;
-    /** Reassign a task to a specific agent name (reflected on the board). */
-    reassignTask(taskId: string, agentName: string): boolean;
-    /**
-     * Set/override a task's worker model (and optionally provider) — applied on its
-     * NEXT dispatch (a running task must be cancelled + retried to take effect). The
-     * assignment lives on node metadata so it survives crash → resume.
-     */
-    setTaskModel(taskId: string, model: string | undefined, provider?: string | undefined): boolean;
-    /** Set/override a task's fallback model chain (applied on its next dispatch). */
-    setTaskFallbacks(taskId: string, fallbackModels: string[] | undefined): boolean;
-    /**
-     * Set/override a task's verification command (the completion gate runs it in
-     * the task's cwd and only lets the task complete on exit 0). Empty/undefined
-     * clears it. Applied on the task's next verification — i.e. its next dispatch.
-     */
-    setTaskVerification(taskId: string, verificationCommand: string | undefined): boolean;
-    /**
-     * Cancel a task. If it is currently running, abort its subagent and mark the
-     * node terminally failed+cancelled (so the scheduler frees the slot and does
-     * NOT retry it). If it has not started, it is simply marked cancelled. Use
-     * `retryTask` to bring a cancelled task back. Returns false for an unknown task.
-     */
-    cancelTask(taskId: string): Promise<boolean>;
-    /**
-     * Delete a not-yet-started task from the graph (pending/blocked/failed only —
-     * never a running task; cancel it first). Removes the node and every edge
-     * touching it; dependents lose this blocker. Returns false if missing or running.
-     */
-    deleteTask(taskId: string): boolean;
-    /**
-     * Split a task into sub-tasks and delegate them to separate workers. The new
-     * leaves inherit the parent's blockers (so they don't start before the
-     * parent's dependencies are met), every existing dependent is rewired to
-     * depend on ALL leaves (so downstream work waits for the whole split), and the
-     * parent becomes a `completed` container. Refuses a running task (cancel it
-     * first) or empty subtask list. Returns the new leaf ids (empty on refusal).
-     * 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
-     * slots the instant a task's dependencies are satisfied: a fast task's
-     * dependent starts immediately rather than waiting for a slow sibling. Truly
-     * independent tasks run in parallel; dependency chains run in order. Returns
-     * 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
-     * user can bring cancelled tasks back in the same action — mirroring
-     * `retryTask`. Picked up by the running scheduler on its next dispatch pass.
-     * 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;
-    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
-     * batch callers keep working; the continuous scheduler in `run()` calls
-     * `executeOne` directly. Throws if no coordinator is wired or a spawn fails
-     * (surfaced from `executeOne`), preserving the original all-or-nothing contract.
-     */
-    executeWave(batch: TaskBatch): Promise<WaveResult>;
-    /**
-     * Execute one task end-to-end: assign a worker identity, allocate its worktree,
-     * spawn + assign the subagent, await its result, then update tracker status
-     * (success / retry / terminal-fail / cancelled) and resolve the worktree. This
-     * is the unit the continuous scheduler dispatches into a free slot. Throws on a
-     * 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 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;
-}
-
-interface SubtaskGeneratorOptions {
-    /** Runs one self-contained, isolated LLM turn and resolves its final text. */
-    run: (prompt: string) => Promise<string>;
-    /** Minimum well-formed sub-tasks required to accept a split. Default 2. */
-    minSubtasks?: number;
-    /** Maximum sub-tasks kept (excess is dropped). Default 4. */
-    maxSubtasks?: number;
-}
-/**
- * Build a `SddSupervisorOptions.generateSubtasks` closure backed by an LLM turn.
- * Returns [] on any failure (parse error, too few valid items, runner throw), so
- * the supervisor safely degrades a `split` verdict into a retry.
- */
-declare function makeLlmSubtaskGenerator(opts: SubtaskGeneratorOptions): (info: {
-    task: TaskNode;
-    error: string;
-}) => Promise<SddSubtaskSpec[]>;
-
-interface SddBoardStoreOptions {
-    /** Directory for board snapshots + event logs (wpaths.projectSddBoards). */
-    baseDir: string;
-}
-interface SddBoardIndexEntry {
-    runId: string;
-    specId?: string | undefined;
-    title: string;
-    status: string;
-    total: number;
-    completed: number;
-    updatedAt: number;
-}
-/** One appended line in a board's JSONL event log. */
-interface SddBoardEvent {
-    ts: number;
-    type: string;
-    payload?: unknown;
-}
-/**
- * File-backed SDD board storage. Each board (= one parallel run) has:
- *   - `<runId>.json`        — latest full snapshot (atomic; resume + standalone-webui mirror)
- *   - `<runId>.events.jsonl`— append-only event log (audit / replay)
- *   - `<runId>.control.jsonl` — append-only command queue (cross-process control, written by readers)
- * plus `_index.json` for fast listing. JSON for state, JSONL for streams.
- */
-declare class SddBoardStore {
-    private readonly baseDir;
-    private readonly indexPath;
-    constructor(opts: SddBoardStoreOptions);
-    snapshotPath(runId: string): string;
-    eventsPath(runId: string): string;
-    controlPath(runId: string): string;
-    saveSnapshot(snapshot: SddBoardSnapshot): Promise<void>;
-    load(runId: string): Promise<SddBoardSnapshot | null>;
-    list(): Promise<SddBoardIndexEntry[]>;
-    loadLatestForSpec(specId: string): Promise<SddBoardSnapshot | null>;
-    /** Append one line to the board's JSONL event log (best-effort, never throws). */
-    appendEvent(runId: string, event: SddBoardEvent): Promise<void>;
-    /** Append a control command (used by readers to steer a CLI-owned run). */
-    appendControl(runId: string, command: {
-        ts: number;
-        type: string;
-        payload?: unknown;
-    }): Promise<void>;
-    /** Read + truncate the control queue (the run drains it). Returns parsed commands. */
-    drainControl(runId: string): Promise<Array<{
-        ts: number;
-        type: string;
-        payload?: unknown;
-    }>>;
-    delete(runId: string): Promise<void>;
-    private safe;
-    private readIndex;
-    private updateIndex;
-    private removeFromIndex;
-}
-
-interface SddBoardProjectorOptions {
-    runId: string;
-    graph: TaskGraph;
-    tracker: TaskTracker;
-    events: EventBus;
-    /** Parent session id for emitted `sdd.board.snapshot` events. */
-    sessionId?: string | (() => string | undefined) | undefined;
-    /** Persist snapshots + JSONL events (optional — omit for in-memory only). */
-    store?: SddBoardStore | undefined;
-    specId?: string | undefined;
-    /** Run-level default worker model/provider/fallbacks (shown in the board header). */
-    defaultModel?: string | undefined;
-    defaultProvider?: string | undefined;
-    fallbackModels?: string[] | undefined;
-    /** Base branch the run's squash commits land on (for the board + rollback). */
-    baseBranch?: string | undefined;
-    /** Snapshot coalescing window in ms (default 250). */
-    throttleMs?: number | undefined;
-    /** Clock injection for tests; defaults to Date.now. */
-    now?: (() => number) | undefined;
-}
-declare class SddBoardProjector {
-    private readonly o;
-    private readonly now;
-    private readonly throttleMs;
-    private readonly shortId;
-    private status;
-    private wave;
-    private startedAt;
-    private deadlockChains;
-    /** Live activity feed, most recent first (capped). */
-    private feed;
-    private static readonly FEED_CAP;
-    private finished;
-    private runDeadlocked;
-    private runStopped;
-    /** Squash commits the run landed on the base branch (for post-run rollback). */
-    private mergedCommits;
-    /** Base branch reported by the run at start (overrides the constructor option). */
-    private runBaseBranch;
-    private dirty;
-    private timer;
-    private readonly unsubs;
-    /** Tail of in-flight persistence, so callers can await a settled state. */
-    private lastSave;
-    constructor(opts: SddBoardProjectorOptions);
-    private pushFeed;
-    /** ` (title…)` suffix for a feed line, or '' when the node/title is missing. */
-    private titleOf;
-    private assigneeOf;
-    /** Latest snapshot, built on demand (e.g. for a late-joining client). */
-    snapshot(): SddBoardSnapshot;
-    /** Resolve once all in-flight snapshot persistence has settled. */
-    drain(): Promise<void>;
-    /** Stop projecting and release subscriptions. */
-    dispose(): void;
-    /** Subscribe to a run event scoped to this run id; also append to JSONL. */
-    private onRun;
-    private resolveStatus;
-    private build;
-    private markDirty;
-    private flush;
-    private currentSessionId;
-}
-
-interface SpecStoreOptions {
-    /** Directory where spec files are stored. Defaults to `.wrongstack/specs`. */
-    baseDir: string;
-}
-interface SpecIndexEntry {
-    id: string;
-    title: string;
-    version: string;
-    status: SpecStatus;
-    updatedAt: number;
-    filePath: string;
-}
-/**
- * File-backed spec storage. Each spec is a JSON file under `baseDir/`.
- * An index file (`_index.json`) tracks all specs for fast listing.
- */
-declare class SpecStore {
-    private readonly baseDir;
-    private readonly indexPath;
-    constructor(opts: SpecStoreOptions);
-    save(spec: Specification): Promise<void>;
-    load(id: string): Promise<Specification | null>;
-    list(): Promise<SpecIndexEntry[]>;
-    delete(id: string): Promise<boolean>;
-    exists(id: string): Promise<boolean>;
-    /** Create a new spec with defaults, assign ID, and persist. */
-    createDraft(title: string, overview?: string): Promise<Specification>;
-    /** Update spec fields and persist. */
-    update(id: string, patch: Partial<Omit<Specification, 'id' | 'createdAt'>>): Promise<Specification | null>;
-    private filePath;
-    private readIndex;
-    private updateIndex;
-    private removeFromIndex;
-}
-
-type AISpecPhase = 'questioning' | 'spec_review' | 'implementation' | 'task_review' | 'executing' | 'done';
-interface CollectedAnswer {
-    question: string;
-    answer: string;
-    timestamp: number;
-}
-interface AISpecSession {
-    id: string;
-    phase: AISpecPhase;
-    title: string;
-    userIntent: string;
-    projectContext: string;
-    answers: CollectedAnswer[];
-    questionCount: number;
-    spec?: Specification | undefined;
-    implementation?: string | undefined;
-    taskGraphId?: string | undefined;
-    approved: boolean;
-    createdAt: number;
-    updatedAt: number;
-}
-interface AISpecBuilderOptions {
-    store: SpecStore;
-    /** Minimum questions the AI should ask. Default: 2 */
-    minQuestions?: number | undefined;
-    /** Maximum questions before forcing spec generation. Default: 10 */
-    maxQuestions?: number | undefined;
-    /** Project context string (package.json, file structure, etc.) */
-    projectContext?: string | undefined;
-    /** Path to persist session state. If set, session survives process restarts. */
-    sessionPath?: string | undefined;
-}
-/**
- * AI-driven specification builder. Instead of static questions, this builder
- * tracks conversation state and generates prompts that instruct the AI agent
- * to ask contextual questions and build specifications interactively.
- */
-declare class AISpecBuilder {
-    private session;
-    private readonly store;
-    private readonly minQuestions;
-    private readonly maxQuestions;
-    private readonly sessionPath?;
-    constructor(opts: AISpecBuilderOptions);
-    /** Save session state to disk. */
-    saveSession(): Promise<void>;
-    /** Load session state from disk. Returns true if a session was loaded. */
-    loadSession(): Promise<boolean>;
-    /** Delete saved session from disk. */
-    deleteSession(): Promise<void>;
-    /** Auto-save helper — calls saveSession() but never throws.
-     *  Failures are surfaced via process.emitWarning so a persistent
-     *  ENOSPC / EACCES doesn't silently strand session edits in memory. */
-    private autoSave;
-    /** Start a new session with a title and optional intent. */
-    startSession(title: string, intent?: string): void;
-    /** Get current session state (readonly). */
-    getSession(): Readonly<AISpecSession>;
-    /** Get the current phase. */
-    getPhase(): AISpecPhase;
-    /**
-     * Get the AI prompt for the current phase.
-     * This prompt is injected into the conversation so the AI agent knows
-     * what to do next (ask a question, generate a spec, etc.).
-     */
-    getAIPrompt(): string;
-    /**
-     * Record a question/answer pair from the AI conversation.
-     * Call this when the AI asks a question and the user responds.
-     */
-    addAnswer(question: string, answer: string): void;
-    /**
-     * Check if more questions should be asked.
-     * Returns false if max reached or if the AI has signaled it has enough info.
-     */
-    shouldContinueQuestioning(): boolean;
-    /**
-     * Check if minimum questions have been asked.
-     */
-    hasMetMinimumQuestions(): boolean;
-    /**
-     * Set the generated specification and move to spec_review phase.
-     */
-    setSpec(spec: Specification): void;
-    /**
-     * Approve the current phase and advance to the next.
-     * questioning → spec_review (requires spec to be set)
-     * spec_review → implementation
-     * implementation → task_review (requires implementation to be set)
-     * task_review → executing
-     * executing → done
-     */
-    approve(): AISpecPhase;
-    /**
-     * Set the implementation plan text.
-     */
-    setImplementation(plan: string): void;
-    /**
-     * Mark session as done.
-     */
-    markDone(): void;
-    /**
-     * Set the task graph ID for this session.
-     */
-    setTaskGraphId(graphId: string): void;
-    /**
-     * Get the task graph ID for this session.
-     */
-    getTaskGraphId(): string | undefined;
-    /**
-     * Save the current spec to the store.
-     */
-    saveSpec(): Promise<Specification>;
-    /**
-     * Parse a spec from a JSON string (from AI output).
-     * Validates and normalizes the structure.
-     */
-    parseSpecFromJSON(jsonStr: string): Specification;
-    /**
-     * Extract JSON from AI output (handles ```json blocks and raw JSON).
-     */
-    extractJSON(text: string): string | null;
-    /**
-     * Detect if AI output contains a spec (JSON block).
-     */
-    hasSpecInOutput(text: string): boolean;
-    /**
-     * Try to parse a spec from AI output text.
-     * Returns null if no valid spec found.
-     */
-    tryParseSpecFromOutput(text: string): Specification | null;
-    /**
-     * Extract a JSON array from AI output (for task lists).
-     */
-    extractJSONArray(text: string): string | null;
-}
-
-interface TaskGraphStoreOptions {
-    /** Directory where task graph files are stored. Defaults to `.wrongstack/task-graphs`. */
-    baseDir: string;
-}
-interface TaskGraphIndexEntry {
-    id: string;
-    specId: string;
-    title: string;
-    nodeCount: number;
-    completedCount: number;
-    updatedAt: number;
-    filePath: string;
-}
-/**
- * File-backed task graph storage. Each graph is a JSON file under `baseDir/`.
- * An index file (`_index.json`) tracks all graphs for fast listing.
- */
-declare class TaskGraphStore {
-    private readonly baseDir;
-    private readonly indexPath;
-    constructor(opts: TaskGraphStoreOptions);
-    save(graph: TaskGraph): Promise<void>;
-    load(id: string): Promise<TaskGraph | null>;
-    list(): Promise<TaskGraphIndexEntry[]>;
-    delete(id: string): Promise<boolean>;
-    exists(id: string): Promise<boolean>;
-    private filePath;
-    private readIndex;
-    private updateIndex;
-    private removeFromIndex;
-}
-
-interface SddInterviewDriverOptions {
-    /** Disk-backed spec store (`wpaths.projectSpecs`). */
-    specStore: SpecStore;
-    /** Disk-backed task-graph store (`wpaths.projectTaskGraphs`). */
-    graphStore: TaskGraphStore;
-    /** Persist the interview session here so a reconnect can resume it. */
-    sessionPath?: string | undefined;
-    /** Project context string injected into the questioning prompt. */
-    projectContext?: string | undefined;
-    minQuestions?: number | undefined;
-    maxQuestions?: number | undefined;
-}
-/** A serialisable view of the interview, streamed to observing surfaces. */
-interface SddInterviewSnapshot {
-    sessionId: string;
-    phase: AISpecPhase;
-    title: string;
-    /** The operator's original goal prompt (verbatim). `title` is a short heading. */
-    goal: string;
-    questionCount: number;
-    minQuestions: number;
-    maxQuestions: number;
-    answers: Array<{
-        question: string;
-        answer: string;
-    }>;
-    spec?: {
-        id: string;
-        title: string;
-        overview: string;
-        requirements: Array<{
-            priority: string;
-            description: string;
-        }>;
-    } | undefined;
-    graphId?: string | undefined;
-    taskCount: number;
-    /**
-     * Topologically-laid-out task graph (once decomposed) — lets the wizard
-     * render the same animated DAG as the live board ("decomposition reveal").
-     */
-    board?: {
-        tasks: SddBoardTask[];
-        columns: SddBoardColumn[];
-    } | undefined;
-    /** The current AI prompt for this phase (what to send the agent next). */
-    prompt: string;
-}
-/** What `ingestAgentOutput` detected and acted on. */
-interface SddIngestResult {
-    specDetected: boolean;
-    implementationDetected: boolean;
-    tasksDetected: boolean;
-    graphId?: string | undefined;
-}
-declare class SddInterviewDriver {
-    readonly builder: AISpecBuilder;
-    private readonly o;
-    private readonly minQuestions;
-    private readonly maxQuestions;
-    private tracker;
-    private graph;
-    constructor(opts: SddInterviewDriverOptions);
-    /** Begin a fresh interview. Returns the first AI prompt (a question kickoff). */
-    start(title: string, intent?: string): string;
-    /**
-     * Resume a previously-persisted interview from disk. Re-hydrates the task
-     * graph too when one was already produced. Returns true if a session loaded.
-     */
-    loadExisting(): Promise<boolean>;
-    phase(): AISpecPhase;
-    currentPrompt(): string;
-    getTracker(): TaskTracker | null;
-    getGraph(): TaskGraph | null;
-    /** Record a Q/A pair (the agent asked `question`, the user replied `answer`). */
-    submitAnswer(question: string, answer: string): void;
-    /**
-     * Feed the agent's text output back into the interview. Detects, in order:
-     *  1. a Specification JSON  → setSpec (phase → spec_review) + persist to SpecStore
-     *  2. an implementation plan (implementation phase) → setImplementation
-     *  3. a task JSON array      → build + persist a TaskGraph
-     * Each step is independent and best-effort; a malformed payload is ignored
-     * rather than thrown, so a chatty agent turn never breaks the interview.
-     */
-    ingestAgentOutput(text: string): Promise<SddIngestResult>;
-    /**
-     * Advance to the next phase (mirrors `/sdd approve`). When moving into the
-     * executing phase, guarantees a task graph exists — deterministically
-     * generating one from the approved spec if the agent never emitted a valid
-     * task array. Returns the new phase and its AI prompt.
-     */
-    approve(): Promise<{
-        phase: AISpecPhase;
-        prompt: string;
-    }>;
-    /**
-     * Ensure a TaskGraph exists for the approved spec. If the agent already
-     * produced one (via `ingestAgentOutput`), returns it; otherwise builds a
-     * deterministic graph from the spec's requirements via TaskGenerator. This is
-     * the robustness backstop: a run can always start, even if the model never
-     * emitted a parseable task array.
-     */
-    ensureTaskGraph(): Promise<TaskGraph | null>;
-    snapshot(): SddInterviewSnapshot;
-    private persistSpec;
-    private persistGraph;
-    /**
-     * Port of the CLI `trySaveImplementationPlan` operating on this driver's
-     * builder. Captures the prose plan that precedes the task JSON block.
-     */
-    private trySaveImplementationPlan;
-    /**
-     * Port of the CLI `trySaveTasksFromAIOutput`: parse a task JSON array from the
-     * agent output, build (or extend) the tracker + graph, persist to disk, and
-     * link the graphId to the session. Returns the graphId on success.
-     */
-    private tryBuildTasksFromOutput;
-}
-/**
- * True when the text reads like conversational filler rather than a structured
- * implementation plan. Ported verbatim from the CLI detection so behaviour is
- * identical across surfaces.
- */
-declare function isExplanatoryText(text: string): boolean;
-
-/** Force-remove every git worktree + branch a previous run left behind. */
-declare function cleanupSddWorktrees(projectRoot: string): Promise<{
-    removed: number;
-}>;
-/**
- * Detect and clean up stale worktrees from a crashed previous run.
- * No-op when the project is clean. Called on SDD/Director boot to
- * prevent orphaned worktrees from conflicting with the next run's
- * `allocate()`.
- *
- * P2 #B6 (sprint2 audit).
- */
-declare function cleanupStaleWorktrees(projectRoot: string): Promise<{
-    removed: number;
-    detected: number;
-}>;
-interface CleanupStaleSddOptions {
-    projectRoot: string;
-    /** Board snapshot dir (`wpaths.projectSddBoards`) — read for the liveness guard. */
-    boardsDir: string;
-    /** A `running` board updated within this window is treated as live → skip. Default 120_000 (2 min). */
-    runningLiveMs?: number | undefined;
-    /** A `paused` board updated within this window is treated as live → skip. Default 1_800_000 (30 min). */
-    pausedLiveMs?: number | undefined;
-    /** Injectable clock for tests. */
-    now?: (() => number) | undefined;
-}
-interface CleanupStaleSddResult {
-    /** True when a sweep ran (orphans were found and removed). */
-    swept: boolean;
-    removed: number;
-    detected: number;
-    /** Set when the sweep was skipped because a run appears live. */
-    skippedReason?: string | undefined;
-}
-/**
- * Liveness-guarded stale-worktree sweep for boot + run-start. Worktrees live
- * under `<projectRoot>/.wrongstack/worktrees` and a sweep force-removes ALL of
- * them — so it must NEVER run under a genuinely live run (possibly in another
- * process). The guard reads the latest board: a `running` board updated within
- * `runningLiveMs`, or a `paused` one within `pausedLiveMs`, is treated as live
- * and the sweep is skipped. A crashed run leaves its board frozen as `running`
- * → once it ages past the window it is correctly swept. Any other status
- * (completed / failed / stopped / deadlocked / idle) is always sweepable.
- * Never throws — best-effort cleanup.
- */
-declare function cleanupStaleSddWorktrees(opts: CleanupStaleSddOptions): Promise<CleanupStaleSddResult>;
-interface RollbackFromDiskOptions {
-    projectRoot: string;
-    /** Directory holding persisted board snapshots (`wpaths.projectSddBoards`). */
-    boardsDir: string;
-    /** Specific run to roll back. Omit → the most recently updated board. */
-    runId?: string | undefined;
-}
-/**
- * Roll back a finished run's merged commits by reading its persisted board
- * snapshot (base branch + commit SHAs) and reverting each. History-preserving;
- * refuses on a dirty tree or revert conflict (surfaced in `reason`). Returns
- * `ok:false` with a reason when there is no board, no base branch, or nothing to
- * revert.
- */
-declare function rollbackSddRunFromDisk(opts: RollbackFromDiskOptions): Promise<{
-    ok: boolean;
-    reverted: number;
-    reason?: string;
-}>;
-interface DestroySddProjectOptions {
-    projectRoot: string;
-    /** Resolved wstack paths to delete. */
-    paths: {
-        projectSpecs: string;
-        projectTaskGraphs: string;
-        projectSddSession: string;
-        projectSddBoards: string;
-    };
-    /**
-     * Also revert this run's already-merged squash commits (history-preserving
-     * `git revert`) BEFORE deleting the board that records them. Off by default —
-     * a plain destroy wipes worktrees + artifacts but leaves merged commits on the
-     * base branch (un-merged worktree work is destroyed regardless, since its
-     * branch is force-removed). When on and the working tree is dirty, the revert
-     * is refused and surfaced in `revertReason` (the destroy still proceeds).
-     */
-    revertMerged?: boolean | undefined;
-    /** Which run's merged commits to revert. Omit → the most recently updated board. */
-    runId?: string | undefined;
-}
-interface DestroySddProjectResult {
-    worktreesRemoved: number;
-    /** Human labels of the artifacts that were deleted. */
-    deleted: string[];
-    /** Number of merged commits reverted (only when `revertMerged` was set). */
-    reverted: number;
-    /** Whether the optional merged-commit revert succeeded (undefined → not requested). */
-    revertOk?: boolean | undefined;
-    /** Why the revert did not fully apply (dirty tree, conflict, nothing to revert). */
-    revertReason?: string | undefined;
-}
-/**
- * Destroy an SDD project: optionally revert its merged commits, then clean every
- * worktree + branch, then delete the on-disk artifacts (specs, task-graphs,
- * session, boards). The revert is opt-in (`revertMerged`) and runs FIRST — it
- * reads the board snapshot that the artifact deletion removes. Best-effort: a
- * missing path is simply skipped. The caller is responsible for stopping any
- * active run first.
- */
-declare function destroySddProject(opts: DestroySddProjectOptions): Promise<DestroySddProjectResult>;
-/** Lifecycle operation kinds shared by every surface (WebUI / TUI / CLI). */
-type SddLifecycleOp = 'cleanup_worktrees' | 'rollback' | 'destroy';
-interface SddLifecycleOptions {
-    projectRoot: string;
-    /** Resolved wstack paths (required for `destroy`; boards dir is enough for `rollback`). */
-    paths: {
-        projectSpecs: string;
-        projectTaskGraphs: string;
-        projectSddSession: string;
-        projectSddBoards: string;
-    };
-    /** Target a specific run (rollback / destroy). Omit → most recently updated board. */
-    runId?: string | undefined;
-    /** `destroy` only: also revert merged commits before wiping. */
-    revertMerged?: boolean | undefined;
-}
-/** Uniform result for any lifecycle op — drives identical UI wording everywhere. */
-interface SddLifecycleResult {
-    op: SddLifecycleOp;
-    ok: boolean;
-    /** Worktrees removed (cleanup_worktrees / destroy). */
-    removed?: number | undefined;
-    /** Merged commits reverted (rollback / destroy with revertMerged). */
-    reverted?: number | undefined;
-    /** Artifact labels deleted (destroy). */
-    deleted?: string[] | undefined;
-    /** Failure / partial reason, surfaced verbatim in the UI. */
-    reason?: string | undefined;
-}
-/**
- * Apply a post-run SDD lifecycle operation from disk and return a uniform result.
- * The single entry point shared by the WebUI board handler, the TUI overlay, and
- * the CLI `/sdd` host so every surface reports the same thing. The caller must
- * ensure no run is active (these operate on git + on-disk state, not the live
- * run) — `cleanup`/`destroy` force-remove worktrees, `rollback` refuses on a
- * dirty tree. Never throws.
- */
-declare function applySddLifecycle(op: SddLifecycleOp, opts: SddLifecycleOptions): Promise<SddLifecycleResult>;
-
-/**
- * Control surface over a live SDD run, exposed to every steering surface
- * (TUI, CLI-hosted WebUI in-process; standalone WebUI via a control file the
- * run drains). The run itself stays CLI-owned — this is the only sanctioned
- * way to pause / retry / reassign from outside the run loop.
- */
-interface SddRunControl {
-    runId: string;
-    specId?: string | undefined;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    retryTask(taskId: string): boolean;
-    /** Requeue every failed task to pending (board "Retry all failed"). Returns the count. */
-    retryAllFailed(): number;
-    reassignTask(taskId: string, agentName: string): boolean;
-    /** Set/override a task's worker model (+ optional provider). Next dispatch. */
-    setTaskModel(taskId: string, model: string | undefined, provider?: string | undefined): boolean;
-    /** Set/override a task's fallback model chain. Next dispatch. */
-    setTaskFallbacks(taskId: string, fallbackModels: string[] | undefined): boolean;
-    /** Set/override a task's completion-gate verification command. Next dispatch. */
-    setTaskVerification(taskId: string, verificationCommand: string | undefined): boolean;
-    /** Cancel a task — abort it if running, else mark it cancelled. */
-    cancelTask(taskId: string): Promise<boolean> | boolean;
-    /** Delete a not-started task from the graph (refused while running). */
-    deleteTask(taskId: string): boolean;
-    /** Split a task into sub-tasks (refused while running). Returns the new leaf ids. */
-    splitTask(taskId: string, subtasks: SddSubtaskSpec[]): string[];
-    /**
-     * Remove every git worktree + branch the run created (refused while running —
-     * stop first). Returns the number removed.
-     */
-    cleanupWorktrees(): Promise<number>;
-    /**
-     * Undo the run's merged commits by reverting each on the base branch (refused
-     * while running). History-preserving; refuses on a dirty tree / revert conflict.
-     */
-    rollback(): Promise<{
-        ok: boolean;
-        reverted: number;
-        reason?: string;
-    }>;
-    /** Base branch the run's squash commits land on (worktree runs only). */
-    getBaseBranch(): string | undefined;
-    /** Squash commits the run landed on the base branch, in landing order. */
-    getMergedCommits(): ReadonlyArray<{
-        taskId: string;
-        sha: string;
-        title: string;
-    }>;
-    /** Latest board snapshot (built on demand). */
-    snapshot(): SddBoardSnapshot;
-    isRunning(): boolean;
-}
-/**
- * In-process registry of the active SDD run. One run is active at a time (a
- * single fleet drives it); a new run replaces the previous. Lives in the CLI
- * process where the fleet runs.
- */
-declare class SddRunRegistry {
-    private current;
-    register(control: SddRunControl): void;
-    clear(runId: string): void;
-    getActive(): SddRunControl | null;
-}
-
-interface SddSupervisorOptions {
-    /** Decision authority (policy/LLM/human). Reuse the session's TOKENS.BrainArbiter. */
-    brain: BrainArbiter;
-    /**
-     * Models to rotate through on a `reassign` verdict (e.g. the run's fallback
-     * chain). Omit to drop the reassign option entirely.
-     */
-    reassignModels?: string[] | undefined;
-    /**
-     * Optional sub-task generator for a `split` verdict — typically an LLM call
-     * that decomposes the failing task into smaller pieces. Omit to drop the split
-     * option. Returning an empty array degrades the split into a retry.
-     */
-    generateSubtasks?: ((info: {
-        task: TaskNode;
-        error: string;
-    }) => Promise<SddSubtaskSpec[]>) | undefined;
-    /**
-     * Let the tiered brain's LLM layer actually pick the verdict.
-     *
-     * Default (false) requests `fallback: 'continue'`, which the policy layer
-     * answers immediately (a bounded retry) — the LLM never runs, so `reassign`/
-     * `split` can't be chosen. Set true to request `fallback: 'ask_human'`, which
-     * makes the policy escalate so the autonomous (LLM) layer decides.
-     *
-     * ONLY enable this when the supplied `brain` will NOT block on a human prompt
-     * for an unresolved decision (i.e. it has an autonomous layer and is NOT
-     * wrapped in `HumanEscalatingBrainArbiter`). When the LLM can't decide (no
-     * autonomous layer / over the risk ceiling / LLM down) the brain returns
-     * `ask_human`, which the supervisor degrades to a **bounded retry** (never a
-     * block, never a dead-end). A human-escalating brain would instead block
-     * inside `decide()` and wedge the run — keep this false there.
-     */
-    requestLlmVerdict?: boolean | undefined;
-}
-declare class SddSupervisor {
-    private readonly opts;
-    constructor(opts: SddSupervisorOptions);
-    /**
-     * Bind this as `SddParallelRunOptions.superviseFailure`. Returns a verdict the
-     * run applies, or `undefined`/`{action:'fail'}` to let the task terminal-fail.
-     */
-    readonly superviseFailure: (info: {
-        task: TaskNode;
-        error: string;
-        attempts: number;
-    }) => Promise<SddSupervisorVerdict | undefined>;
-}
-
-declare class SpecParser {
-    parse(content: string): Specification;
-    private extractTitle;
-    private extractVersion;
-    private extractOverview;
-    private extractSections;
-    private extractRequirements;
-    private parseRequirementLine;
-    private mapSectionType;
-    analyze(spec: Specification): SpecAnalysis;
-    validate(spec: Specification): SpecValidationResult;
-}
-
-/**
- * Built-in spec templates for common development scenarios.
- */
-declare const SPEC_TEMPLATES: SpecTemplate[];
-/**
- * Get a template by ID.
- */
-declare function getTemplate(id: string): SpecTemplate | undefined;
-/**
- * List all available templates.
- */
-declare function listTemplates(): Array<{
-    id: string;
-    name: string;
-    description: string;
-}>;
-/**
- * Generate a markdown skeleton from a template.
- */
-declare function templateToMarkdown(template: SpecTemplate, title?: string): string;
-
-interface SpecVersion {
-    version: string;
-    spec: Specification;
-    timestamp: number;
-    changeDescription?: string | undefined;
-}
-interface SpecDiff {
-    added: SpecRequirement[];
-    removed: SpecRequirement[];
-    modified: Array<{
-        requirement: SpecRequirement;
-        previousVersion: SpecRequirement;
-        changes: string[];
-    }>;
-    summary: string;
-}
-/**
- * Track spec versions and compute diffs between versions.
- */
-declare class SpecVersioning {
-    private versions;
-    /** Record a new version of a spec. */
-    recordVersion(spec: Specification, changeDescription?: string): SpecVersion;
-    /** Get version history for a spec. */
-    getHistory(specId: string): SpecVersion[];
-    /** Get a specific version of a spec. */
-    getVersion(specId: string, version: string): SpecVersion | undefined;
-    /** Get the latest version of a spec. */
-    getLatest(specId: string): SpecVersion | undefined;
-    /** Compute diff between two versions of a spec. */
-    diff(oldSpec: Specification, newSpec: Specification): SpecDiff;
-    /**
-     * Update a task graph incrementally based on spec changes.
-     * - Added requirements → new tasks
-     * - Removed requirements → remove tasks
-     * - Modified requirements → update task descriptions
-     * Returns the updated graph and list of changes made.
-     */
-    updateTaskGraph(graph: TaskGraph, oldSpec: Specification, newSpec: Specification): {
-        graph: TaskGraph;
-        changes: string[];
-    };
-    private compareRequirements;
-    private buildTaskDescription;
-    private mapReqType;
-}
-
-interface StartSddRunOptions {
-    tracker: TaskTracker;
-    graph: TaskGraph;
-    /** Leader agent — seeds the default factory and the run's project context. */
-    agent: Agent;
-    projectRoot: string;
-    events: EventBus;
-    /** Parent session id for all SDD EventBus emissions. */
-    sessionId?: string | (() => string | undefined) | undefined;
-    /** Per-task agent factory. Omit to run every task on the leader agent. */
-    subagentFactory?: AgentFactory | undefined;
-    /** Board snapshot/event persistence (also drained for cross-process control). */
-    boardStore: SddBoardStore;
-    /** Registry the run is registered with for in-process control. */
-    registry?: SddRunRegistry | undefined;
-    parallelSlots?: number | undefined;
-    /** Opt-in hard wall-clock cap per task (ms). Omit → no cap (idle reaper guards). */
-    taskTimeoutMs?: number | undefined;
-    /** Idle reaper per task (ms); resets on activity. Default 600_000 (10 min). */
-    taskIdleTimeoutMs?: number | undefined;
-    /** End-of-run failed-task auto-retry sweeps (bounded). Default 2. */
-    maxFailedRetrySweeps?: number | undefined;
-    /** Post-task verification gate (forwarded to SddParallelRun). Omit → no gate. */
-    verifyTask?: SddParallelRunOptions['verifyTask'];
-    /** Merge-conflict resolver (forwarded to SddParallelRun). Omit → retry-on-fresh-base then fail. */
-    conflictResolver?: SddParallelRunOptions['conflictResolver'];
-    /** Failure supervisor (forwarded to SddParallelRun). Omit → no rescue, plain terminal-fail. */
-    superviseFailure?: SddParallelRunOptions['superviseFailure'];
-    /** Run-level default worker model / provider / fallback chain (task overrides win). */
-    defaultModel?: string | undefined;
-    defaultProvider?: string | undefined;
-    fallbackModels?: string[] | undefined;
-    /** Per-task git worktree isolation. Omit → tasks share the working tree. */
-    worktrees?: WorktreeManager | undefined;
-    /** Bounded deadlock recovery rounds (default 1). */
-    maxRecoveryRounds?: number | undefined;
-    /** Progress callback (e.g. CLI renderer line). */
-    onProgress?: ((p: SddProgress) => void) | undefined;
-    /** Control-file drain interval in ms (default 500). */
-    controlDrainMs?: number | undefined;
-}
-interface SddRunHandle {
-    run: SddParallelRun;
-    runId: string;
-    projector: SddBoardProjector;
-    /** Resolves when the run finishes AND all teardown (drain/dispose/clear) is done. */
-    completion: Promise<RunResult>;
-    /** Request a clean stop (idempotent). */
-    stop(): void;
-}
-/**
- * Wire up and start an SDD parallel run. Returns immediately with a handle whose
- * `completion` promise resolves once the run finishes and teardown is complete.
- * Orphaned in_progress tasks are reset up-front so a crashed prior run re-executes.
- */
-declare function startSddRun(opts: StartSddRunOptions): SddRunHandle;
-
-/**
- * Extended event map used internally by TaskFlow and multi-agent components.
- * These events are emitted on the injected EventBus and are a subset of
- * the full EventMap — they do not require a separate registration.
- */
-interface TaskFlowEventMap {
-    'phase.change': {
-        from: TaskFlowPhase;
-        to: TaskFlowPhase;
-    };
-    'task.started': {
-        taskId: string;
-    };
-    'task.completed': {
-        taskId: string;
-        result?: unknown | undefined;
-    };
-    'task.failed': {
-        taskId: string;
-        error: string;
-    };
-    'task.review': {
-        taskId: string;
-    };
-    'spec.analyzed': {
-        analysis: SpecAnalysis;
-    };
-    progress: {
-        percent: number;
-        message: string;
-    };
-    done: {
-        graph: TaskGraph;
-    };
-    error: {
-        phase: TaskFlowPhase;
-        error: Error;
-    };
-}
-type TaskFlowPhase = 'idle' | 'parsing' | 'analyzing' | 'generating' | 'executing' | 'reviewing' | 'completing' | 'done' | 'failed';
-type TaskFlowEventName = keyof TaskFlowEventMap;
-interface TaskFlowOptions {
-    tracker: TaskTracker;
-    events: EventBus;
-    doneCondition?: DoneCondition | undefined;
-    maxConcurrent?: number | undefined;
-}
-interface TaskFlowExecutionContext {
-    executeTask: (task: TaskNode) => Promise<unknown>;
-    onTaskComplete?: (task: TaskNode | undefined, result: unknown) => void;
-    onTaskFail?: (task: TaskNode | undefined, error: Error) => void;
-}
-declare class TaskFlow {
-    private readonly opts;
-    private phase;
-    private spec;
-    private graph;
-    private stopped;
-    constructor(opts: TaskFlowOptions);
-    private emit;
-    fromSpec(specContent: string): Promise<TaskGraph>;
-    execute(ctx: TaskFlowExecutionContext): Promise<TaskGraph>;
-    reviewTask(taskId: string, approved: boolean, comment?: string): Promise<void>;
-    stop(): void;
-    getPhase(): TaskFlowPhase;
-    getGraph(): TaskGraph | null;
-    getSpec(): Specification | null;
-    private setPhase;
-    private getExecutableTasks;
-    private executeSingleTask;
-    private checkDoneCondition;
-    private emitProgress;
-}
-interface SpecDrivenDevOptions {
-    workingDirectory: string;
-    events: EventBus;
-    doneCondition?: DoneCondition | undefined;
-}
-declare class SpecDrivenDev {
-    private store;
-    private tracker;
-    private readonly events;
-    private flows;
-    constructor(opts: SpecDrivenDevOptions);
-    createFlow(specContent: string, options?: Partial<TaskFlowOptions>): Promise<TaskFlow>;
-    getTracker(): TaskTracker;
-    getFlow(graphId: string): TaskFlow | undefined;
-    listFlows(): {
-        id: string;
-        title: string;
-        phase: TaskFlowPhase;
-    }[];
-}
-
-interface TaskGeneratorOptions {
-    taskTracker: TaskTracker;
-    /**
-     * Opt-in (default off): derive each task's completion-gate
-     * `metadata.verificationCommand` from an acceptance criterion that carries a
-     * runnable-command marker (`$ <cmd>`, or `run:`/`verify:`/`cmd:` prefix). Off
-     * by default so the common case stays fast — auto-running a check per task is
-     * exactly the slowness the robustness initiative set out to avoid; enable it
-     * explicitly (the CLI gates it behind WRONGSTACK_SDD_VERIFY_FROM_ACCEPTANCE).
-     */
-    verificationFromAcceptance?: boolean | undefined;
-}
-/**
- * Pull a runnable verification command out of a requirement's acceptance
- * criteria. A criterion qualifies only when it carries an explicit marker —
- * `$ <cmd>` (shell-prompt style) or a `run:` / `verify:` / `cmd:` prefix — so
- * free-text criteria are never mistaken for commands. Returns the first match.
- */
-declare function extractVerificationCommand(criteria: readonly string[]): string | undefined;
-interface GeneratedTask {
-    specRequirementId?: string | undefined;
-    title: string;
-    description: string;
-    type: TaskType;
-    priority: TaskPriority;
-    estimateHours?: number | undefined;
-    tags?: string[] | undefined;
-}
-declare class TaskGenerator {
-    private readonly opts;
-    constructor(opts: TaskGeneratorOptions);
-    generateFromSpec(spec: Specification): Promise<TaskGraph>;
-    private createTaskFromRequirement;
-    private createTaskFromEndpoint;
-    private buildDescription;
-    private mapRequirementType;
-    private estimateHours;
-    private estimateForEndpoint;
-    generateSubtasks(parentTaskId: string, spec: Specification): Promise<void>;
-}
-declare class DefaultTaskStore implements TaskStore {
-    private graphs;
-    saveGraph(graph: TaskGraph): Promise<void>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    listGraphs(): Promise<{
-        id: string;
-        title: string;
-        updatedAt: number;
-    }[]>;
-    deleteGraph(id: string): Promise<void>;
-    private cloneGraph;
-}
-
-/**
- * Render a task graph as ASCII art for terminal display.
- */
-declare function renderTaskGraph(graph: TaskGraph, opts?: {
-    compact?: boolean | undefined;
-}): string;
-/**
- * Render a progress bar.
- */
-declare function renderProgress(progress: TaskProgress): string;
-/**
- * Render a compact task list (for quick status checks).
- */
-declare function renderTaskList(graph: TaskGraph): string;
-/**
- * Render spec analysis summary.
- */
-declare function renderSpecAnalysis(spec: Specification, analysis: {
-    completeness: number;
-    gaps: string[];
-    risks: string[];
-    suggestions: string[];
-}): string;
-
-interface CommandVerifierOptions {
-    /** Metadata key holding the shell command to run. Default 'verificationCommand'. */
-    metadataKey?: string;
-    /** Kill + fail the verification after this many ms. Default 180_000 (3 min). */
-    timeoutMs?: number;
-}
-/**
- * Build a `verifyTask` closure (shape matches {@link SddParallelRunOptions.verifyTask}).
- * Returns `{ ok: true }` immediately when the task carries no verification command,
- * otherwise spawns the command in `cwd` (shell, output discarded) and resolves
- * `{ ok: false, reason }` on non-zero exit, spawn error, or timeout.
- */
-declare function makeCommandVerifier(options?: CommandVerifierOptions): (info: {
-    task: TaskNode;
-    result: TaskResult;
-    cwd: string;
-}) => Promise<{
-    ok: boolean;
-    reason?: string;
-}>;
-
-export { AISpecBuilder, type AISpecBuilderOptions, type AISpecPhase, type AISpecSession, AutoExecutor, type AutoExecutorOptions, type BottleneckTask, type CleanupStaleSddOptions, type CleanupStaleSddResult, type CollectedAnswer, type CommandVerifierOptions, type ConflictSide, type CriticalPathAnalysis, DefaultTaskStore, type DestroySddProjectOptions, type DestroySddProjectResult, type ExecutionSummary, type GeneratedTask, type LlmConflictResolverOptions, type RollbackFromDiskOptions, type RunResult, SPEC_TEMPLATES, type SddBoardColumn, type SddBoardEvent, type SddBoardFeedEntry, type SddBoardIndexEntry, SddBoardProjector, type SddBoardProjectorOptions, type SddBoardSnapshot, type SddBoardStatus, SddBoardStore, type SddBoardStoreOptions, type SddBoardTask, type SddDeadlockChain, type SddIngestResult, SddInterviewDriver, type SddInterviewDriverOptions, type SddInterviewSnapshot, type SddLifecycleOp, type SddLifecycleOptions, type SddLifecycleResult, SddParallelRun, type SddParallelRunOptions, type SddProgress, type SddRunControl, type SddRunHandle, SddRunRegistry, type SddSubtaskSpec, SddSupervisor, type SddSupervisorOptions, type SddSupervisorVerdict, SddTaskDecomposer, type SddTaskDecomposerOptions, type SddTaskDisplayStatus, type SpecDiff, SpecDrivenDev, type SpecDrivenDevOptions, type SpecIndexEntry, SpecParser, SpecStore, type SpecStoreOptions, type SpecVersion, SpecVersioning, type StartSddRunOptions, type SubtaskGeneratorOptions, type TaskBatch, type TaskExecutionContext, type TaskExecutionResult, TaskFlow, type TaskFlowEventMap, type TaskFlowEventName, type TaskFlowExecutionContext, type TaskFlowOptions, type TaskFlowPhase, TaskGenerator, type TaskGeneratorOptions, type TaskGraphIndexEntry, TaskGraphStore, type TaskGraphStoreOptions, type TaskStore, TaskTracker, type TaskTrackerChange, type TaskTrackerListener, type TaskTrackerOptions, type TaskTransition, type WaveResult, analyzeCriticalPath, applySddLifecycle, buildBoardSnapshot, buildBoardTasks, cleanupSddWorktrees, cleanupStaleSddWorktrees, cleanupStaleWorktrees, createAutoExecutor, destroySddProject, extractVerificationCommand, getTemplate, hasConflictMarkers, isExplanatoryText, listTemplates, makeCommandVerifier, makeLlmConflictResolver, makeLlmSubtaskGenerator, makePreferSideConflictResolver, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, resolveConflictText, rollbackSddRunFromDisk, shortIdMap, startSddRun, templateToMarkdown };