@wrongstack/core 0.272.1 → 0.273.0

package/dist/sdd/index.d.ts

@@ -1,13 +1,14 @@
 import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../spec-TBi3Jr6T.js';
 import { d as TaskGraph, e as TaskNode, i as TaskFilter, j as TaskSort, c as TaskProgress, T as TaskType, a as TaskPriority } from '../task-graph-u1q9Jkyk.js';
-import { E as EventBus } from '../brain-etbcbRwV.js';
-import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-BZa_IEcd.js';
+import { E as EventBus, B as BrainArbiter } from '../brain-BxN2k2HP.js';
+import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-ehb4xGvd.js';
+import { W as WorktreeManager } from '../worktree-manager-BDuXTaWL.js';
 import '../context-Dw55zZ_Q.js';
-import '../index-DWm_PE9L.js';
+import '../index-B7fHDt0B.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-Ckkn3AOA.js';
+import '../pipeline-CNVKuQDQ.js';
 import '../mailbox-types-Ct2hJq0P.js';
-import '../config-rRS8yorV.js';
+import '../config-C8IYxlO8.js';
 import '../observability-D-HZN_mF.js';
 import '../permission-CC7XFYWG.js';
 import '../retry-policy-BV7nzeAd.js';
@@ -51,11 +52,28 @@ interface TaskTransition {
     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).
@@ -65,8 +83,31 @@ declare class TaskTracker {
     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'>>): 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[];
@@ -88,7 +129,23 @@ declare class TaskTracker {
 
 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;
@@ -699,6 +756,19 @@ declare class SddTaskDecomposer {
      * 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.
@@ -708,6 +778,31 @@ declare class SddTaskDecomposer {
     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;
@@ -717,18 +812,119 @@ interface SddParallelRunOptions {
     agent: Agent;
     /** Project root (used for coordinator id). */
     projectRoot: string;
-    /** Override default parallel slots (1–16). Default: 4. */
+    /**
+     * 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;
-    /** Per-task timeout in ms. Default: 300_000 (5 min). */
+    /**
+     * 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;
-    /** Maximum retry attempts for failed tasks. Default: 2. */
+    /**
+     * 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;
+    /** 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;
@@ -750,6 +946,12 @@ interface WaveResult {
     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;
@@ -762,21 +964,919 @@ interface RunResult {
 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 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 paused;
     /** Trigger stop — causes run() to abort after the current wave. */
     stop(): void;
-    /** Execute all waves until completion or deadlock. Returns final summary. */
+    /** 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;
 }
 
-export { AISpecBuilder, type AISpecBuilderOptions, type AISpecPhase, type AISpecSession, AutoExecutor, type AutoExecutorOptions, type BottleneckTask, type CollectedAnswer, type CriticalPathAnalysis, DefaultTaskStore, type ExecutionSummary, type GeneratedTask, type RunResult, SPEC_TEMPLATES, SddParallelRun, type SddParallelRunOptions, type SddProgress, SddTaskDecomposer, type SddTaskDecomposerOptions, type SpecDiff, SpecDrivenDev, type SpecDrivenDevOptions, type SpecIndexEntry, SpecParser, SpecStore, type SpecStoreOptions, type SpecVersion, SpecVersioning, 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 TaskTrackerOptions, type TaskTransition, type WaveResult, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown };
+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>;
+}
+
+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;
+}>;
+
+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[]>;
+
+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>;
+
+/**
+ * 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' | '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;
+
+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;
+    /** 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;
+}
+
+/**
+ * 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 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;
+    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;
+
+interface StartSddRunOptions {
+    tracker: TaskTracker;
+    graph: TaskGraph;
+    /** Leader agent — seeds the default factory and the run's project context. */
+    agent: Agent;
+    projectRoot: string;
+    events: EventBus;
+    /** 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;
+
+/** Force-remove every git worktree + branch a previous run left behind. */
+declare function cleanupSddWorktrees(projectRoot: string): Promise<{
+    removed: number;
+}>;
+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;
+    };
+}
+interface DestroySddProjectResult {
+    worktreesRemoved: number;
+    /** Human labels of the artifacts that were deleted. */
+    deleted: string[];
+}
+/**
+ * Destroy an SDD project: clean every worktree + branch, then delete the on-disk
+ * artifacts (specs, task-graphs, session, boards). Does NOT roll back git commits
+ * — that is the separate, explicit `rollbackSddRunFromDisk`. 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>;
+
+export { AISpecBuilder, type AISpecBuilderOptions, type AISpecPhase, type AISpecSession, AutoExecutor, type AutoExecutorOptions, type BottleneckTask, 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, 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, buildBoardSnapshot, buildBoardTasks, cleanupSddWorktrees, createAutoExecutor, destroySddProject, extractVerificationCommand, getTemplate, hasConflictMarkers, isExplanatoryText, listTemplates, makeCommandVerifier, makeLlmConflictResolver, makeLlmSubtaskGenerator, makePreferSideConflictResolver, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, resolveConflictText, rollbackSddRunFromDisk, shortIdMap, startSddRun, templateToMarkdown };