@miller-tech/uap 1.148.24 → 1.149.1

package/dist/delivery/plan-check.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Pre-execution plan validation (the ATG-style "thought experiment").
+ *
+ * Two layers, both run BEFORE any phase executes:
+ *
+ *  1. `validatePhaseGraph` — structural: duplicate ids, unknown/self deps,
+ *     dependency cycles, empty goals. Pure, no model.
+ *  2. `runPlanThoughtExperiment` — one evaluator call that mentally executes
+ *     the decomposition ("will these phases, in this dependency order, deliver
+ *     the mission?") and returns a pass/fail verdict with findings. The judge
+ *     did not author the plan — the same generator≠evaluator separation the
+ *     acceptance gate uses.
+ *
+ * `reviewPlanText` is the free-text sibling used by `uap plan validate` on
+ * markdown plan artifacts (the validate-plan-on-change gate's `validate the
+ * plan` step becomes a real review, not just a stamp).
+ *
+ * Everything is fail-soft: a validator or model error forfeits the check, it
+ * never blocks delivery — decomposition and the plan gate must never wedge.
+ *
+ * SECURITY NOTE: because of that fail-soft design (and because the judged text
+ * is authored by the same party the gate constrains), a PASS verdict is an
+ * anti-sloppiness signal, NOT an adversarial guarantee — never build
+ * enforcement that treats a PASS as proof of review.
+ */
+import type { LoopExecutor } from './convergence-loop.js';
+import type { DeliveryPhase } from './decompose.js';
+export interface PhaseGraphValidation {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/** Structural validation of a phase/epic DAG. Pure — safe to call anywhere. */
+export declare function validatePhaseGraph(phases: DeliveryPhase[]): PhaseGraphValidation;
+export interface PlanReviewVerdict {
+    verdict: 'pass' | 'fail';
+    findings: string[];
+}
+/** Extract a {verdict,findings} JSON verdict from model output. Anything
+ * unparseable is a PASS — a garbled judge must not block delivery. */
+export declare function parsePlanVerdict(text: string): PlanReviewVerdict;
+/**
+ * ATG thought experiment: ask the evaluator to mentally execute the phase plan
+ * before anything real runs, hunting for the defects that sink multi-phase
+ * missions (missing prerequisites, wrong dependency order, phases consuming
+ * artifacts no earlier phase produces, invented scope). One call; fail-soft.
+ */
+export declare function runPlanThoughtExperiment(mission: string, phases: DeliveryPhase[], executor: LoopExecutor): Promise<PlanReviewVerdict>;
+/**
+ * Free-text plan review for `uap plan validate` over a markdown plan artifact.
+ * Same verdict contract and fail-soft rules as the phase thought experiment.
+ */
+export declare function reviewPlanText(planText: string, executor: LoopExecutor): Promise<PlanReviewVerdict>;
+//# sourceMappingURL=plan-check.d.ts.map

package/dist/delivery/plan-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-check.d.ts","sourceRoot":"","sources":["../../src/delivery/plan-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,oBAAoB,CAsChF;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;sEACsE;AACtE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAiBhE;AAWD;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,aAAa,EAAE,EACvB,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,iBAAiB,CAAC,CA0B5B;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAyBzG"}

package/dist/delivery/plan-check.js

@@ -0,0 +1,165 @@
+/**
+ * Pre-execution plan validation (the ATG-style "thought experiment").
+ *
+ * Two layers, both run BEFORE any phase executes:
+ *
+ *  1. `validatePhaseGraph` — structural: duplicate ids, unknown/self deps,
+ *     dependency cycles, empty goals. Pure, no model.
+ *  2. `runPlanThoughtExperiment` — one evaluator call that mentally executes
+ *     the decomposition ("will these phases, in this dependency order, deliver
+ *     the mission?") and returns a pass/fail verdict with findings. The judge
+ *     did not author the plan — the same generator≠evaluator separation the
+ *     acceptance gate uses.
+ *
+ * `reviewPlanText` is the free-text sibling used by `uap plan validate` on
+ * markdown plan artifacts (the validate-plan-on-change gate's `validate the
+ * plan` step becomes a real review, not just a stamp).
+ *
+ * Everything is fail-soft: a validator or model error forfeits the check, it
+ * never blocks delivery — decomposition and the plan gate must never wedge.
+ *
+ * SECURITY NOTE: because of that fail-soft design (and because the judged text
+ * is authored by the same party the gate constrains), a PASS verdict is an
+ * anti-sloppiness signal, NOT an adversarial guarantee — never build
+ * enforcement that treats a PASS as proof of review.
+ */
+/** Structural validation of a phase/epic DAG. Pure — safe to call anywhere. */
+export function validatePhaseGraph(phases) {
+    const errors = [];
+    const warnings = [];
+    const ids = new Set();
+    for (const p of phases) {
+        if (ids.has(p.id))
+            errors.push(`duplicate phase id '${p.id}'`);
+        ids.add(p.id);
+        if (!p.goal || !p.goal.trim())
+            errors.push(`phase '${p.id}' has an empty goal`);
+    }
+    for (const p of phases) {
+        for (const d of p.deps ?? []) {
+            if (d === p.id)
+                errors.push(`phase '${p.id}' depends on itself`);
+            else if (!ids.has(d))
+                warnings.push(`phase '${p.id}' depends on unknown phase '${d}' (dropped at execution)`);
+        }
+    }
+    // Cycle detection (DFS with recursion stack) over known-id edges only —
+    // unknown and self deps are already reported above.
+    const visited = new Set();
+    const stack = new Set();
+    const byId = new Map(phases.map((p) => [p.id, p]));
+    const hasCycle = (id) => {
+        visited.add(id);
+        stack.add(id);
+        for (const d of byId.get(id)?.deps ?? []) {
+            if (!byId.has(d) || d === id)
+                continue;
+            if (!visited.has(d) && hasCycle(d))
+                return true;
+            if (stack.has(d))
+                return true;
+        }
+        stack.delete(id);
+        return false;
+    };
+    for (const p of phases) {
+        if (!visited.has(p.id) && hasCycle(p.id)) {
+            errors.push('dependency cycle detected — cycle members can never become ready and their subtree is skipped at execution');
+            break;
+        }
+    }
+    return { ok: errors.length === 0, errors, warnings };
+}
+/** Extract a {verdict,findings} JSON verdict from model output. Anything
+ * unparseable is a PASS — a garbled judge must not block delivery. */
+export function parsePlanVerdict(text) {
+    try {
+        const match = text.match(/\{[\s\S]*\}/);
+        if (!match)
+            return { verdict: 'pass', findings: [] };
+        const parsed = JSON.parse(match[0]);
+        const verdict = parsed.verdict === 'fail' ? 'fail' : 'pass';
+        const findings = Array.isArray(parsed.findings)
+            ? parsed.findings
+                .filter((f) => typeof f === 'string' && f.trim().length > 0)
+                // Model output reaches terminals and prompts — strip control/ANSI bytes.
+                .map((f) => f.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, ' ').trim().slice(0, 300))
+                .slice(0, 8)
+            : [];
+        return { verdict, findings };
+    }
+    catch {
+        return { verdict: 'pass', findings: [] };
+    }
+}
+function describePhases(phases) {
+    return phases
+        .map((p, i) => `${i + 1}. [${p.id}] ${p.title} — ${p.goal}${p.deps?.length ? ` (deps: ${p.deps.join(', ')})` : ''}`)
+        .join('\n');
+}
+/**
+ * ATG thought experiment: ask the evaluator to mentally execute the phase plan
+ * before anything real runs, hunting for the defects that sink multi-phase
+ * missions (missing prerequisites, wrong dependency order, phases consuming
+ * artifacts no earlier phase produces, invented scope). One call; fail-soft.
+ */
+export async function runPlanThoughtExperiment(mission, phases, executor) {
+    const prompt = [
+        'You are a plan validator. Mentally EXECUTE the phase plan below, in its',
+        'dependency order, before anything real runs. You did not author this plan;',
+        'judge it adversarially.',
+        '',
+        `MISSION: ${mission.slice(0, 4000)}`,
+        '',
+        'PHASE PLAN:',
+        describePhases(phases),
+        '',
+        'Check ONLY for defects that would make execution fail or deliver the wrong thing:',
+        '- a phase that needs an artifact/decision no earlier phase (per its deps) produces',
+        '- missing prerequisite phases (setup, shared contracts, migrations)',
+        '- dependency edges that are wrong or missing (a later phase silently assumes an independent one ran first)',
+        '- phases that invent scope the mission does not imply, or mission parts no phase covers',
+        'Do NOT fail a plan for style, granularity taste, or improvements that are merely nice.',
+        '',
+        'Respond with ONLY JSON: {"verdict": "pass" | "fail", "findings": ["<specific defect>", ...]}',
+        '"fail" requires at least one concrete, execution-breaking finding.',
+    ].join('\n');
+    try {
+        return parsePlanVerdict(await executor(prompt));
+    }
+    catch {
+        return { verdict: 'pass', findings: [] }; // model unavailable ⇒ check forfeited, never blocked
+    }
+}
+/**
+ * Free-text plan review for `uap plan validate` over a markdown plan artifact.
+ * Same verdict contract and fail-soft rules as the phase thought experiment.
+ */
+export async function reviewPlanText(planText, executor) {
+    const truncated = planText.length > 12000;
+    const prompt = [
+        'You are a plan validator. Review the implementation plan below as if you',
+        'had to execute it exactly as written. You did not author it; judge it',
+        'adversarially.',
+        '',
+        'PLAN:' + (truncated ? ' (truncated to the first 12,000 characters — judge only what you see)' : ''),
+        planText.slice(0, 12000),
+        '',
+        'Check ONLY for defects that would make executing the plan fail or produce the wrong result:',
+        '- steps in an impossible order (a step consumes what a later step produces)',
+        '- missing prerequisite or verification steps for risky/irreversible actions',
+        '- load-bearing assumptions stated nowhere and likely false',
+        '- internal contradictions between sections',
+        'Do NOT fail a plan for style, brevity, or missing nice-to-haves.',
+        '',
+        'Respond with ONLY JSON: {"verdict": "pass" | "fail", "findings": ["<specific defect>", ...]}',
+        '"fail" requires at least one concrete, execution-breaking finding.',
+    ].join('\n');
+    try {
+        return parsePlanVerdict(await executor(prompt));
+    }
+    catch {
+        return { verdict: 'pass', findings: [] };
+    }
+}
+//# sourceMappingURL=plan-check.js.map

package/dist/delivery/plan-check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-check.js","sourceRoot":"","sources":["../../src/delivery/plan-check.ts"],"names":[],"mappings":"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"}

package/dist/delivery/task-orchestrator.d.ts

@@ -86,13 +86,48 @@ export interface OrchestratorConfig {
     maxTasks?: number;
     /** Progress hook. */
     onTask?: (task: OrchestratorTask, outcome: TaskOutcome) => void;
+    /**
+     * Minimal node repair (ATG): extra fresh attempts for a FAILED task before
+     * its dependents are blocked. Each repair attempt re-executes ONLY the
+     * failed node, with the failure summary fed into its minimal context — the
+     * validated rest of the graph stays frozen. Default: UAP_ORCH_TASK_REPAIRS
+     * env (fallback 1, env hard-ceiling 5 — a full executor rerun per attempt
+     * must not be unboundable from the environment). 0 restores fail-fast.
+     */
+    maxRepairsPerTask?: number;
+    /**
+     * Re-plan repair (ATG minimal-subgraph repair): after retries are exhausted,
+     * re-plan the failed node as a replacement chain executed in place. The
+     * chain is interface-preserving — its first task inherits the failed node's
+     * deps, and when the whole chain succeeds the ORIGINAL task id is credited
+     * on the blackboard, so dependents unblock without any graph rewrite.
+     * Return null/[] to decline. Fail-soft: a throw declines.
+     */
+    repairTask?: (task: OrchestratorTask, lastFailure: TaskOutcome, attempts: number) => Promise<OrchestratorTask[] | null>;
+    /**
+     * Dependency-aware parallel dispatch: max independent READY tasks running
+     * concurrently (wave-barrier scheduling: each wave completes before the
+     * next dispatches — simple and deterministic over maximal utilization).
+     * Default 1 = sequential, the historical behavior. DELIBERATELY config-only,
+     * no env override: >1 requires a runTask that tolerates concurrent
+     * execution (isolated workspaces / per-task judge state), and the
+     * production deliver runTask is NOT concurrency-safe yet — an env knob
+     * would let one exported variable silently corrupt every deliver run.
+     * Clamped to [1, 16].
+     */
+    concurrency?: number;
 }
 export interface OrchestratorResult {
     success: boolean;
+    /** Succeeded ids — includes synthetic repair-chain link ids (`x.r0-…`)
+     * alongside the credited original id when a repair chain ran. */
     completed: string[];
     failed: string[];
-    /** Aggregate turns across all executed tasks. */
+    /** Aggregate turns across all executed tasks (incl. retries and repairs). */
     turns: number;
+    /** Full attempt trail: a repaired task appears MULTIPLE times (failed
+     * attempt(s), chain links, then the credited success under its original
+     * id). Consumers wanting "the" outcome for an id must take the LAST entry. */
     outcomes: TaskOutcome[];
 }
 /**
@@ -114,12 +149,19 @@ export declare function governContext(prompt: string, depLineCount: number, budg
 export declare function assembleTaskContext(task: OrchestratorTask, mission: string, blackboard: Map<string, TaskOutcome>, maxDepSummaryChars?: number, opts?: {
     designLines?: string[];
     budgetChars?: number;
+    lastFailure?: string;
 }): AssembledContext;
 /**
- * P1 — execute the task DAG on a blackboard. Topologically ordered; a task
- * runs only after every dependency has SUCCEEDED. A failed task blocks its
- * dependents (their deps aren't all green) and they are reported as skipped/
- * failed rather than run against incomplete state. Fail-soft on publish.
+ * P1 — execute the task DAG on a blackboard. Dependency-aware: a task runs
+ * only after every dependency has SUCCEEDED; independent READY tasks dispatch
+ * in parallel up to `concurrency` (default 1 — the historical sequential
+ * behavior). A task that fails gets ATG-style MINIMAL REPAIR before its
+ * dependents are blocked: bounded fresh re-execution of just that node with
+ * the failure fed back (`maxRepairsPerTask`), then an optional re-planned
+ * replacement chain (`repairTask`) credited under the original id — the
+ * validated rest of the graph stays frozen throughout. Only when repair is
+ * exhausted are dependents reported as skipped rather than run against
+ * incomplete state. Fail-soft on publish.
  */
 export declare function orchestrate(config: OrchestratorConfig): Promise<OrchestratorResult>;
 //# sourceMappingURL=task-orchestrator.d.ts.map

package/dist/delivery/task-orchestrator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-orchestrator.d.ts","sourceRoot":"","sources":["../../src/delivery/task-orchestrator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD,wEAAwE;AACxE,MAAM,WAAW,gBAAiB,SAAQ,aAAa;IACrD,+EAA+E;IAC/E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAC/B;AAED,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC;qEACiE;IACjE,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B;;;;OAIG;IACH,OAAO,EAAE,CAAC,GAAG,EAAE,gBAAgB,EAAE,IAAI,EAAE,gBAAgB,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IACjF;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,gBAAgB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjF,2EAA2E;IAC3E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1E,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qBAAqB;IACrB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;CACjE;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,WAAW,EAAE,CAAC;CACzB;AAQD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAgB3H;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,kBAAkB,SAA4B,EAC9C,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1D,gBAAgB,CA6ClB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA4EzF"}
+{"version":3,"file":"task-orchestrator.d.ts","sourceRoot":"","sources":["../../src/delivery/task-orchestrator.ts"],"names":[],"mappings":"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"}

package/dist/delivery/task-orchestrator.js

@@ -72,6 +72,12 @@ export function assembleTaskContext(task, mission, blackboard, maxDepSummaryChar
         sections.push('This task is done when:');
         task.criteria.forEach((c, i) => sections.push(`  ${i + 1}. ${c}`));
     }
+    // Minimal repair: the retry sees WHAT failed last time, not a fresh-amnesia
+    // rerun — the one new piece of information a repair attempt has.
+    if (opts.lastFailure && opts.lastFailure.trim()) {
+        sections.push('');
+        sections.push(`PREVIOUS ATTEMPT FAILED — fix this: ${opts.lastFailure.trim().slice(0, 400)}`);
+    }
     // P3 — relevant persisted design decisions (objective/architecture): a
     // small retrieval, not the full spec dump.
     if (opts.designLines && opts.designLines.length > 0) {
@@ -98,41 +104,42 @@ export function assembleTaskContext(task, mission, blackboard, maxDepSummaryChar
     const governed = governContext(raw, includedDeps.length, opts.budgetChars ?? DEFAULT_CONTEXT_BUDGET_CHARS);
     return { taskId: task.id, prompt: governed.prompt, includedDeps };
 }
+function envInt(name, fallback, max) {
+    const rawStr = process.env[name];
+    if (!rawStr || !rawStr.trim())
+        return fallback; // empty string = unset, not 0
+    const raw = Number(rawStr);
+    return Number.isFinite(raw) && raw >= 0 ? Math.min(Math.floor(raw), max) : fallback;
+}
 /**
- * P1 — execute the task DAG on a blackboard. Topologically ordered; a task
- * runs only after every dependency has SUCCEEDED. A failed task blocks its
- * dependents (their deps aren't all green) and they are reported as skipped/
- * failed rather than run against incomplete state. Fail-soft on publish.
+ * P1 — execute the task DAG on a blackboard. Dependency-aware: a task runs
+ * only after every dependency has SUCCEEDED; independent READY tasks dispatch
+ * in parallel up to `concurrency` (default 1 — the historical sequential
+ * behavior). A task that fails gets ATG-style MINIMAL REPAIR before its
+ * dependents are blocked: bounded fresh re-execution of just that node with
+ * the failure fed back (`maxRepairsPerTask`), then an optional re-planned
+ * replacement chain (`repairTask`) credited under the original id — the
+ * validated rest of the graph stays frozen throughout. Only when repair is
+ * exhausted are dependents reported as skipped rather than run against
+ * incomplete state. Fail-soft on publish.
  */
 export async function orchestrate(config) {
     const maxTasks = config.maxTasks ?? DEFAULT_MAX_TASKS;
     const budget = config.contextBudgetChars;
-    // Mutable queue so P5 re-planning can append discovered subtasks; re-sorted
-    // topologically each time the set grows.
-    let queue = topoOrder(config.tasks);
-    const known = new Set(queue.map((t) => t.id));
+    const concurrency = Math.min(Math.max(1, config.concurrency ?? 1), 16);
+    const maxRepairs = Math.max(0, config.maxRepairsPerTask ?? envInt('UAP_ORCH_TASK_REPAIRS', 1, 5));
+    // Pending is kept topo-ordered; P5 re-planning appends discovered subtasks
+    // and re-sorts. `scheduled` counts every task ever admitted (initial +
+    // re-planned + repair chains) against the maxTasks runaway guard.
+    let pending = topoOrder(config.tasks);
+    const known = new Set(pending.map((t) => t.id));
+    let scheduled = pending.length;
     const blackboard = new Map();
     const done = new Set();
     const failed = new Set();
     const outcomes = [];
     let turns = 0;
-    for (let qi = 0; qi < queue.length; qi++) {
-        const task = queue[qi];
-        const deps = task.deps ?? [];
-        // Skip a task whose dependency failed — never build against a broken base.
-        const blockedBy = deps.filter((d) => failed.has(d) || !done.has(d));
-        if (blockedBy.length > 0) {
-            const outcome = {
-                taskId: task.id,
-                success: false,
-                summary: `skipped — unmet dependency: ${blockedBy.join(', ')}`,
-                turns: 0,
-            };
-            failed.add(task.id);
-            outcomes.push(outcome);
-            config.onTask?.(task, outcome);
-            continue;
-        }
+    const runOne = async (task, lastFailure) => {
         let designLines = [];
         if (config.retrieveDesign) {
             try {
@@ -145,34 +152,192 @@ export async function orchestrate(config) {
         const ctx = assembleTaskContext(task, config.mission, blackboard, config.maxDepSummaryChars, {
             designLines,
             budgetChars: budget,
+            ...(lastFailure ? { lastFailure } : {}),
         });
-        const outcome = await config.runTask(ctx, task);
+        // A throwing runTask becomes a failed outcome, never an abandoned graph:
+        // under parallel dispatch one rejection must not orphan in-flight siblings.
+        let outcome;
+        try {
+            outcome = await config.runTask(ctx, task);
+        }
+        catch (err) {
+            outcome = {
+                taskId: task.id,
+                success: false,
+                summary: `task execution error: ${err instanceof Error ? err.message : String(err)}`.slice(0, 300),
+                turns: 0,
+            };
+        }
         turns += outcome.turns;
         outcomes.push(outcome);
-        if (outcome.success) {
-            done.add(task.id);
-            blackboard.set(task.id, outcome);
-            try {
-                await config.publish?.(outcome, task);
-            }
-            catch {
-                // publishing to durable memory is best-effort
+        return outcome;
+    };
+    const recordSuccess = async (id, task, outcome) => {
+        done.add(id);
+        blackboard.set(id, outcome);
+        try {
+            await config.publish?.(outcome, task);
+        }
+        catch {
+            // publishing to durable memory is best-effort
+        }
+    };
+    const markSkipped = (task, blockedBy) => {
+        const outcome = {
+            taskId: task.id,
+            success: false,
+            summary: `skipped — unmet dependency: ${blockedBy.join(', ')}`,
+            turns: 0,
+        };
+        failed.add(task.id);
+        outcomes.push(outcome);
+        config.onTask?.(task, outcome);
+    };
+    /**
+     * Re-plan repair: execute the replacement chain in place. Interface
+     * preserving — the first link inherits the failed node's deps, links chain
+     * sequentially, and full-chain success credits the ORIGINAL task id on the
+     * blackboard so dependents unblock unchanged. Returns the credited outcome,
+     * or null when the repair was declined or the chain broke.
+     */
+    const runRepairChain = async (task, lastFailure, attempts) => {
+        if (!config.repairTask)
+            return null;
+        let plan = null;
+        try {
+            plan = await config.repairTask(task, lastFailure, attempts);
+        }
+        catch {
+            plan = null; // fail-soft: an unplannable repair keeps the failure
+        }
+        if (!plan || plan.length === 0 || scheduled + plan.length > maxTasks)
+            return null;
+        let prevId;
+        let last = null;
+        for (let i = 0; i < plan.length; i++) {
+            // Namespace chain links under the failed node. The 64-char cut can eat
+            // the differentiator for very long task ids, so collisions against
+            // anything ever known get a numeric suffix instead of silently
+            // overwriting a blackboard entry.
+            let subId = `${task.id}.r${i}-${plan[i].id}`.slice(0, 64);
+            for (let bump = 2; known.has(subId); bump++)
+                subId = `${subId.slice(0, 60)}~${bump}`;
+            const sub = {
+                ...plan[i],
+                id: subId,
+                deps: i === 0 ? [...(task.deps ?? [])] : [prevId],
+            };
+            known.add(sub.id);
+            scheduled++;
+            // Chain links run to plan; their own newTasks are DELIBERATELY dropped —
+            // a repair must converge the failed node, not grow the graph.
+            const outcome = await runOne(sub, i === 0 ? lastFailure.summary : undefined);
+            config.onTask?.(sub, outcome);
+            if (!outcome.success) {
+                failed.add(sub.id);
+                return null;
             }
-            // P5 — adaptive re-planning: fold discovered subtasks into the queue.
-            const fresh = (outcome.newTasks ?? []).filter((t) => !known.has(t.id));
-            if (fresh.length > 0 && queue.length + fresh.length <= maxTasks) {
+            await recordSuccess(sub.id, sub, outcome);
+            prevId = sub.id;
+            last = outcome;
+        }
+        if (!last)
+            return null;
+        const credited = {
+            taskId: task.id,
+            success: true,
+            summary: `repaired via ${plan.length} replacement task(s): ${last.summary}`.slice(0, 400),
+            turns: 0,
+            ...(last.contract ? { contract: last.contract } : {}),
+        };
+        outcomes.push(credited);
+        await recordSuccess(task.id, task, credited);
+        return credited;
+    };
+    /** Full failure handling for one task: retries → re-plan chain → fail. */
+    const settleTask = async (task, first) => {
+        let final = first;
+        let attempts = 1;
+        // Minimal repair 1 — bounded re-execution of JUST this node, failure fed back.
+        while (!final.success && attempts <= maxRepairs) {
+            final = await runOne(task, final.summary);
+            attempts++;
+        }
+        // Minimal repair 2 — re-planned replacement chain, original id credited.
+        if (!final.success) {
+            const credited = await runRepairChain(task, final, attempts);
+            if (credited)
+                final = credited;
+        }
+        if (final.success) {
+            // Repair-chain success already recorded itself under the original id.
+            if (!done.has(task.id))
+                await recordSuccess(task.id, task, final);
+            // P5 — adaptive re-planning: fold discovered subtasks into the graph.
+            const fresh = (final.newTasks ?? []).filter((t) => !known.has(t.id));
+            if (fresh.length > 0 && scheduled + fresh.length <= maxTasks) {
                 for (const t of fresh)
                     known.add(t.id);
-                // Re-topo-sort the not-yet-run remainder plus the new tasks so deps hold.
-                const remainder = queue.slice(qi + 1).concat(fresh);
-                const resorted = topoOrder(remainder);
-                queue = queue.slice(0, qi + 1).concat(resorted);
+                scheduled += fresh.length;
+                const merged = pending.concat(fresh);
+                const sorted = topoOrder(merged);
+                // topoOrder cleans deps against ONLY the passed array — which would
+                // silently drop edges to already-done (harmless) and already-FAILED
+                // (dangerous: dependents would run on a broken base) tasks. Restore
+                // each task's true deps, filtered against everything ever known.
+                const byId = new Map(merged.map((t) => [t.id, t]));
+                pending = sorted.map((s) => {
+                    const orig = byId.get(s.id);
+                    const deps = (orig.deps ?? []).filter((d) => known.has(d) && d !== s.id);
+                    return { ...orig, deps };
+                });
             }
         }
         else {
             failed.add(task.id);
         }
-        config.onTask?.(task, outcome);
+        config.onTask?.(task, final);
+        return final;
+    };
+    while (pending.length > 0) {
+        // Skip cascade: drop every task whose dependency already failed — never
+        // build against a broken base. Loops because each skip can cascade.
+        let cascading = true;
+        while (cascading) {
+            cascading = false;
+            for (let i = 0; i < pending.length; i++) {
+                const blockedBy = (pending[i].deps ?? []).filter((d) => failed.has(d));
+                if (blockedBy.length > 0) {
+                    markSkipped(pending[i], blockedBy);
+                    pending.splice(i, 1);
+                    i--;
+                    cascading = true;
+                }
+            }
+        }
+        if (pending.length === 0)
+            break;
+        // Ready set: every dependency has SUCCEEDED. Nothing ready with work
+        // still pending means an unsatisfiable remainder (cycle degraded by
+        // topoOrder) — skip it rather than wedge.
+        const ready = pending.filter((t) => (t.deps ?? []).every((d) => done.has(d)));
+        if (ready.length === 0) {
+            for (const t of pending)
+                markSkipped(t, (t.deps ?? []).filter((d) => !done.has(d)));
+            pending = [];
+            break;
+        }
+        // Dependency-aware dispatch: up to `concurrency` independent ready tasks
+        // run at once (they are mutually independent by construction — none can
+        // depend on another still-pending task). Settlement (repair, re-planning,
+        // bookkeeping) is sequential for deterministic graph state.
+        const wave = ready.slice(0, concurrency);
+        const waveIds = new Set(wave.map((t) => t.id));
+        pending = pending.filter((t) => !waveIds.has(t.id));
+        const results = await Promise.all(wave.map(async (t) => ({ task: t, outcome: await runOne(t) })));
+        for (const { task, outcome } of results) {
+            await settleTask(task, outcome);
+        }
     }
     return {
         success: failed.size === 0,