@wrongstack/sdd 0.284.1 → 0.285.0

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

@@ -0,0 +1,427 @@
+import type { Agent } from '@wrongstack/core';
+import type { TaskResult } from '@wrongstack/core/types';
+import type { AgentFactory } from '@wrongstack/core';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { WorktreeManager } from '@wrongstack/core';
+import type { TaskGraph, TaskNode, TaskProgress } from '@wrongstack/core/types';
+import type { TaskTracker } from '@wrongstack/core/tasking';
+import { type TaskBatch } from './sdd-task-decomposer.js';
+/** A sub-task produced by splitting a parent task (see `splitTask`). */
+export 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.
+ */
+export type SddSupervisorVerdict = {
+    action: 'retry';
+} | {
+    action: 'reassign';
+    model?: string | undefined;
+    provider?: string | undefined;
+} | {
+    action: 'split';
+    subtasks: SddSubtaskSpec[];
+} | {
+    action: 'fail';
+};
+export 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;
+}
+export interface SddProgress {
+    wave: number;
+    total: number;
+    completed: number;
+    inProgress: number;
+    failed: number;
+    blocked: number;
+    pending: number;
+    percent: number;
+    deadlocked: boolean;
+}
+export 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;
+}
+export interface RunResult {
+    totalWaves: number;
+    totalCompleted: number;
+    totalFailed: number;
+    totalDurationMs: number;
+    deadlocked: boolean;
+    stopRequested: boolean;
+    finalProgress: TaskProgress;
+}
+export declare class SddParallelRun {
+    private readonly opts;
+    private readonly slots;
+    /** Opt-in hard wall-clock cap (undefined → no cap; idle reaper guards instead). */
+    private readonly timeoutMs;
+    /** Idle reaper window (ms) — resets on activity; reaps only a genuine stall. */
+    private readonly idleTimeoutMs;
+    private readonly maxRetries;
+    /** Max supervisor rescues per task before it must terminal-fail (loop guard). */
+    private readonly maxSupervisorEscalations;
+    /** Per-task count of supervisor rescues used (resets nothing — bounds the loop). */
+    private supervisorEscalations;
+    /** Max end-of-run failed-task sweeps (see `maxFailedRetrySweeps`). */
+    private readonly maxFailedSweeps;
+    /** How many failed-task sweeps have run this `run()` so far. */
+    private failedSweeps;
+    /** Completed-count snapshot at the last sweep, to detect a no-progress sweep. */
+    private lastSweepCompleted;
+    private decomposer;
+    private coordinator;
+    private stopRequested;
+    private retryMap;
+    readonly runId: string;
+    private readonly events?;
+    private readonly sessionIdSource;
+    private readonly maxTotalWaves;
+    private readonly maxWallClockMs?;
+    private readonly maxRecoveryRounds;
+    private recoveryRounds;
+    /** Per-run worker identities, so the board shows "who is on what". */
+    private usedNicknames;
+    /** Per-task git worktree cwd (Layer 2 worktree isolation; empty otherwise). */
+    private taskCwds;
+    /** Per-task git worktree branch, for board display. */
+    private taskBranches;
+    /** Live worktree handles keyed by task id (for commit/merge/release). */
+    private taskWorktrees;
+    /** Live subagent id per running task — lets cancelTask() abort exactly one. */
+    private taskSubagents;
+    /** Tasks the user cancelled mid-flight — skip retry, mark terminal-cancelled. */
+    private cancelledTasks;
+    /**
+     * Base branch the run's squash commits land on (captured once at start when
+     * worktrees are enabled). Anchors a later `rollback()`.
+     */
+    private baseBranch;
+    /**
+     * Squash-merge commits this run landed on the base branch, in landing order.
+     * `rollback()` reverts these (newest → oldest). Persisted via the board
+     * snapshot so a post-run rollback can read them off disk.
+     */
+    private mergedCommits;
+    /** 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;
+}
+export {};
+//# sourceMappingURL=sdd-parallel-run.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sdd-parallel-run.d.ts","sourceRoot":"","sources":["../src/sdd-parallel-run.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,68 @@
+import type { SddBoardSnapshot } from './board-types.js';
+import type { SddSubtaskSpec } from './sdd-parallel-run.js';
+/**
+ * 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.
+ */
+export 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.
+ */
+export declare class SddRunRegistry {
+    private current;
+    register(control: SddRunControl): void;
+    clear(runId: string): void;
+    getActive(): SddRunControl | null;
+}
+//# sourceMappingURL=sdd-run-registry.d.ts.map

package/dist/sdd-run-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdd-run-registry.d.ts","sourceRoot":"","sources":["../src/sdd-run-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,IAAI,IAAI,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;IACf,IAAI,IAAI,IAAI,CAAC;IACb,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,0FAA0F;IAC1F,cAAc,IAAI,MAAM,CAAC;IACzB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IACzD,+EAA+E;IAC/E,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IAChG,iEAAiE;IACjE,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAAC;IAChF,iFAAiF;IACjF,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IACtF,mEAAmE;IACnE,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACvD,wEAAwE;IACxE,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,qFAAqF;IACrF,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAAC;IAChE;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC;;;OAGG;IACH,QAAQ,IAAI,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,yEAAyE;IACzE,aAAa,IAAI,MAAM,GAAG,SAAS,CAAC;IACpC,0EAA0E;IAC1E,gBAAgB,IAAI,aAAa,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClF,+CAA+C;IAC/C,QAAQ,IAAI,gBAAgB,CAAC;IAC7B,SAAS,IAAI,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAA8B;IAE7C,QAAQ,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAErC;IAED,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEzB;IAED,SAAS,IAAI,aAAa,GAAG,IAAI,CAEhC;CACF"}

package/dist/sdd-supervisor.d.ts

@@ -0,0 +1,52 @@
+import type { BrainArbiter } from '@wrongstack/core';
+import type { TaskNode } from '@wrongstack/core/types';
+import type { SddSubtaskSpec, SddSupervisorVerdict } from './sdd-parallel-run.js';
+export 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;
+}
+export 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>;
+}
+//# sourceMappingURL=sdd-supervisor.d.ts.map

package/dist/sdd-supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdd-supervisor.d.ts","sourceRoot":"","sources":["../src/sdd-supervisor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElF,MAAM,WAAW,oBAAoB;IACnC,sFAAsF;IACtF,KAAK,EAAE,YAAY,CAAC;IACpB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACtC;;;;OAIG;IACH,gBAAgB,CAAC,EACb,CAAC,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC,GACxE,SAAS,CAAC;IACd;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC;AAED,qBAAa,aAAa;IACZ,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAjC,YAA6B,IAAI,EAAE,oBAAoB,EAAI;IAE3D;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,SAAgB;QACvC,IAAI,EAAE,QAAQ,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAoD3C;CACH"}

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

@@ -0,0 +1,89 @@
+/**
+ * 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));
+ * }
+ * ```
+ */
+import type { TaskNode, TaskGraph } from '@wrongstack/core/types';
+import type { TaskTracker } from '@wrongstack/core/tasking';
+export interface SddTaskDecomposerOptions {
+    /** Max tasks per batch. Default: 4. Range 1–16. */
+    parallelSlots?: number | undefined;
+}
+export 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;
+}
+export 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;
+}
+//# sourceMappingURL=sdd-task-decomposer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sdd-task-decomposer.d.ts","sourceRoot":"","sources":["../src/sdd-task-decomposer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,MAAM,WAAW,wBAAwB;IACvC,mDAAmD;IACnD,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,SAAS;IACxB,2CAA2C;IAC3C,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,+FAA+F;IAC/F,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,iBAAiB;IAK1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,IAAI,CAAK;IAEjB,YACmB,OAAO,EAAE,WAAW,EACrC,MAAM,EAAE,SAAS,EACjB,IAAI,GAAE,wBAA6B,EAGpC;IAMD;;;;;OAKG;IACH,SAAS,IAAI,SAAS,CAerB;IAED;;;OAGG;IACH,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,EAAE,GAAG,IAAI,CAElD;IAED;;;OAGG;IACH,MAAM,IAAI,OAAO,CAGhB;IAED;;OAEG;IACH,YAAY,IAAI,MAAM,CAErB;IAED;;;;OAIG;IACH,UAAU,IAAI,QAAQ,EAAE,CAEvB;IAED;;;;;OAKG;IACH,SAAS,IAAI,OAAO,CAGnB;IAMD;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA2BzB,wEAAwE;IACxE,OAAO,CAAC,kBAAkB;CAM3B"}