@miller-tech/uap 1.149.5 → 1.150.1

package/dist/cli/deliver.js

@@ -19,6 +19,7 @@ import { planAutoOptimization } from '../delivery/auto-optimizer.js';
 import { RoutingPresets, resolvePresetModel } from '../models/types.js';
 import { measureQueryComplexity } from '../utils/query-complexity.js';
 import { authorAcceptanceGate } from '../delivery/self-gate.js';
+import { applyPendingIntents } from '../delivery/pending-intents.js';
 import { runAcceptanceGate, formatAcceptanceReport, createAcceptanceChurnBreaker } from '../delivery/acceptance-judge.js';
 import { runExecutionGate } from '../delivery/execution-gate.js';
 import { runVisualGate, visualRuntimeNote } from '../delivery/visual-gate.js';
@@ -41,7 +42,9 @@ import { runVisualGate, visualRuntimeNote } from '../delivery/visual-gate.js';
  */
 export function decideGateStrategy(opts) {
     const acceptancePrimary = opts.hasAcceptance && opts.noRealGates && !opts.forceSelfGate;
-    const needsSelfGate = opts.selfGateAllowed && !acceptancePrimary && (opts.noRealGates || opts.forceSelfGate);
+    const needsSelfGate = opts.selfGateAllowed &&
+        !acceptancePrimary &&
+        (opts.noRealGates || opts.forceSelfGate || opts.baselineAllGreen === true);
     const noGatesError = opts.noRealGates && !needsSelfGate && !acceptancePrimary;
     return { acceptancePrimary, needsSelfGate, noGatesError };
 }
@@ -118,6 +121,7 @@ import { extractContract } from '../delivery/contract-extractor.js';
 import { completeDeliveryTask, openDeliveryTask, recordDeliveryOutcome, recordOrchestratorTaskOutcome, reopenDeliveryTask } from '../delivery/task-sync.js';
 import { autoMineHaloTraces, summarizeWeaknesses, weaknessGuidance, loadPersistedWeaknesses } from '../delivery/auto-mine.js';
 import { createGitWorktreeProvider } from '../delivery/candidate-workspace.js';
+import { createTaskWorkspaceManager, resolveParallelTasks } from '../delivery/task-workspace.js';
 import { createHaloDeliveryTracer } from '../delivery/halo-trace.js';
 import { haloTracePath, isHaloTracingEnabled } from '../observability/halo-exporter.js';
 import { createRunCoordinator } from '../delivery/run-coordinator.js';
@@ -401,6 +405,34 @@ export async function deliverCommand(instruction, options) {
 }
 async function runDeliver(instruction, options) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
+    // P1 (plan D1): --pending replays gate-recorded edit intents exactly, then
+    // verifies with the required gates — the sanctioned path for a blocked
+    // direct edit, with zero model improvisation. Runs BEFORE preflight: it
+    // never creates a worktree, so the git-repo requirement does not apply.
+    if (options.pending !== undefined && options.pending !== false) {
+        const pendingFile = typeof options.pending === 'string' ? options.pending : undefined;
+        const res = applyPendingIntents(projectRoot, pendingFile);
+        for (const a of res.applied)
+            console.log(chalk.green(`  ✓ applied ${a.kind}: ${a.file}`));
+        for (const s of res.skipped)
+            console.log(chalk.yellow(`  ⚠ skipped ${s.file}: ${s.reason}`));
+        if (res.applied.length === 0) {
+            fail(`No pending intents applied${pendingFile ? ` for ${pendingFile}` : ''} (${res.skipped.length} skipped).`);
+        }
+        const rungs = detectRungs(projectRoot).filter((r) => r.required && tierOf(r) === 'fast');
+        if (rungs.length > 0) {
+            console.log(chalk.cyan(`⚖ verifying ${res.applied.length} applied intent(s) against ${rungs.length} required fast gate(s)…`));
+            const ladder = runLadder(rungs, projectRoot);
+            if (!ladder.passed) {
+                fail(`Applied intents but the required gates FAIL:\n${ladder.feedback}`);
+            }
+            console.log(chalk.green('  ✓ gates pass'));
+        }
+        else {
+            console.log(chalk.yellow('  (no required fast gates detected — applied without verification)'));
+        }
+        return;
+    }
     // Preflight: refuse to start in a project that structurally cannot deliver
     // (chiefly: not a git repo — the candidate workspace is worktree-based, so
     // deliver/epics/orchestration are all dead and the mission would burn its
@@ -471,6 +503,18 @@ async function runDeliver(instruction, options) {
             console.log(chalk.cyan(`⚙ auto-optimize: ${autoPlan.summary}`));
         }
     }
+    // Verification RAILS are independent of the optimization AIDS (P0,
+    // 2026-07-13): --no-auto / explicit aid flags stand down exploration,
+    // critic and ideation, but must not silently drop the acceptance judge —
+    // without it, a gates-green no-op run reads as delivered. When the
+    // auto-planner did not run, acceptance defaults ON; opt out explicitly
+    // with UAP_DELIVER_ACCEPTANCE=0.
+    if (!autoPlan && options.acceptance === undefined && process.env.UAP_DELIVER_ACCEPTANCE !== '0') {
+        options.acceptance = true;
+        if (!options.dryRun) {
+            console.log(chalk.cyan('⚖ acceptance judge on (verification rail; UAP_DELIVER_ACCEPTANCE=0 to disable)'));
+        }
+    }
     // `--optimize` turns on every convergence aid at once. Deploy queueing is
     // deliberately excluded — committing applied files is a side effect the
     // user must opt into explicitly.
@@ -657,11 +701,35 @@ async function runDeliver(instruction, options) {
             console.log(chalk.cyan('⚖ thin gate set (≤1 required rung) — acceptance judge enabled to thicken the target'));
         }
     }
+    // Anti-vacuous floor (P0, 2026-07-13 incident): probe the REQUIRED rungs
+    // once before choosing the convergence target. If everything is already
+    // green, gate-satisfaction cannot measure this mission — a run on a
+    // gates-green repo would false-green as a no-op (observed live: a 6-file
+    // C++ mission "delivered" after writing nothing, because the only detected
+    // gates were unrelated npm web gates). UAP_DELIVER_VACUOUS_FLOOR=0 opts out.
+    let baselineAllGreen = false;
+    if (!noRealGates &&
+        options.forceSelfGate !== true &&
+        selfGateAllowed &&
+        process.env.UAP_DELIVER_VACUOUS_FLOOR !== '0' &&
+        !options.dryRun) {
+        try {
+            const requiredRungs = rungs.filter((r) => r.required);
+            baselineAllGreen = requiredRungs.length > 0 && runLadder(requiredRungs, projectRoot).passed;
+        }
+        catch {
+            baselineAllGreen = false; // probe is best-effort; never blocks a run
+        }
+        if (baselineAllGreen) {
+            console.log(chalk.cyan('⚖ anti-vacuous floor: all required project gates are ALREADY green — authoring a mission self-gate so success requires real, verified change'));
+        }
+    }
     const { acceptancePrimary, needsSelfGate, noGatesError } = decideGateStrategy({
         hasAcceptance: Boolean(options.acceptance),
         noRealGates,
         forceSelfGate: options.forceSelfGate === true,
         selfGateAllowed,
+        baselineAllGreen,
     });
     if (noGatesError) {
         fail(`No verifiable gates detected in ${projectRoot} (need package.json scripts, or drop --no-self-gate to author one).`);
@@ -975,7 +1043,12 @@ async function runDeliver(instruction, options) {
         }
         rungs.push(sg.rung);
         if (sg.vacuous) {
-            console.log(chalk.yellow('  ⚠ acceptance gate may be weak (could not force an initially-failing check); running multi-turn anyway.'));
+            // P0 hard-fail: a REQUIRED self-gate that passes on the unsolved repo
+            // re-opens the false-green door — "delivered" would be meaningless.
+            if (process.env.UAP_DELIVER_ALLOW_WEAK_SELF_GATE !== '1') {
+                fail('The self-gate is REQUIRED for this run (anti-vacuous floor) but stayed vacuous after retries — it passes on the unsolved repo. Add concrete, checkable ACCEPTANCE CRITERIA to the instruction, or set UAP_DELIVER_ALLOW_WEAK_SELF_GATE=1 to accept the risk.');
+            }
+            console.log(chalk.yellow('  ⚠ acceptance gate may be weak (could not force an initially-failing check); UAP_DELIVER_ALLOW_WEAK_SELF_GATE=1 — running multi-turn anyway.'));
         }
         else {
             console.log(chalk.green('  ✓ acceptance gate authored — fails on the unsolved repo, a real convergence target.'));
@@ -1195,14 +1268,45 @@ async function runDeliver(instruction, options) {
     // Phased missions re-point the judge at the current phase's goal — judging
     // phase 1 against the FULL mission would fail every phase by construction.
     let acceptanceSpec = instruction;
+    // Parallel orchestrated tasks run in ISOLATED worktree roots; each loop's
+    // judge must grade against ITS task's spec, not a shared mutable. The
+    // acceptance gate resolves by the root it is invoked with; the phased and
+    // epic paths (single loop at a time) keep using the shared variable.
+    const acceptanceSpecByRoot = new Map();
     // Secondary-judge churn breaker: bounds consecutive judge rejections of
     // objectively-green turns per spec (env UAP_DELIVER_ACCEPTANCE_FLIP_LIMIT,
     // default 2), after which the objective gates win. Primary mode is exempt.
     // Change-evidence for the breaker's zero-diff guard: files applied since the
     // current acceptance spec (epic) began. Incremented by the iteration hook,
     // reset wherever acceptanceSpec is re-pointed.
-    const specChangeEvidence = { writes: 0 };
-    const acceptanceChurnBreaker = createAcceptanceChurnBreaker(Number(process.env.UAP_DELIVER_ACCEPTANCE_FLIP_LIMIT ?? 2), () => specChangeEvidence.writes > 0);
+    // Per-ROOT under parallel dispatch: concurrent loops must not zero or
+    // inflate each other's evidence (an inflated count could let the breaker
+    // accept a task with zero writes of its own). projectRoot's entry is the
+    // historic shared counter the phased/epic paths keep using.
+    const writesByRoot = new Map();
+    const evidenceFor = (root) => {
+        let e = writesByRoot.get(root);
+        if (!e) {
+            e = { writes: 0 };
+            writesByRoot.set(root, e);
+        }
+        return e;
+    };
+    const specChangeEvidence = evidenceFor(projectRoot);
+    // Breaker state is per SPEC: one shared instance thrashes its current-spec
+    // slot under parallel dispatch and can then never trip.
+    const acceptanceFlipLimit = Number(process.env.UAP_DELIVER_ACCEPTANCE_FLIP_LIMIT ?? 2);
+    const acceptanceBreakers = new Map();
+    const breakerFor = (spec, root) => {
+        let b = acceptanceBreakers.get(spec);
+        if (!b) {
+            if (acceptanceBreakers.size > 100)
+                acceptanceBreakers.clear(); // runaway guard
+            b = createAcceptanceChurnBreaker(acceptanceFlipLimit, () => evidenceFor(root).writes > 0);
+            acceptanceBreakers.set(spec, b);
+        }
+        return b;
+    };
     const acceptanceGate = options.acceptance && !skipJudgeForSimple
         ? async (root) => {
             // Primary mode: the only objective rung is the trivial bootstrap, and the
@@ -1234,13 +1338,14 @@ async function runDeliver(instruction, options) {
             // gates all passed — hand the judge that fact as evidence, so
             // requirements like "make the tests pass" are graded on the gate
             // result instead of speculated about from static code.
+            const resolvedSpec = acceptanceSpecByRoot.get(root) ?? acceptanceSpec;
             const uvNote = buildUserPathsNote(root);
             const baseNote = acceptancePrimary
                 ? visualNote
                 : 'Objective project gates (build/test suite) ALL PASSED on this turn — treat test/build-related requirements as objectively verified.';
             const runtimeNote = [baseNote, uvNote?.note].filter(Boolean).join(' ');
             const r = await runAcceptanceGate({
-                spec: acceptanceSpec,
+                spec: resolvedSpec,
                 projectRoot: root,
                 executor: verdictExecutor,
                 ...(runtimeNote ? { runtimeNote } : {}),
@@ -1250,7 +1355,7 @@ async function runDeliver(instruction, options) {
             // objective gates ALL passed, so a bounded number of consecutive judge
             // rejections hands the verdict back to the gates instead of wedging.
             if (!acceptancePrimary) {
-                const checked = acceptanceChurnBreaker.check(acceptanceSpec, verdict);
+                const checked = breakerFor(resolvedSpec, root).check(resolvedSpec, verdict);
                 if (checked.overridden) {
                     console.log(chalk.yellow('  ⚖ acceptance: judge rejected consecutive objectively-green turns — accepting on gates (raise UAP_DELIVER_ACCEPTANCE_FLIP_LIMIT to let the judge argue longer)'));
                 }
@@ -1267,7 +1372,7 @@ async function runDeliver(instruction, options) {
         ...(acceptanceGate ? { acceptanceGate } : {}),
     };
     /** Compose the per-turn hooks with a FRESH escalation controller. */
-    const makeIterationHook = () => {
+    const makeIterationHook = (evidenceRoot = projectRoot) => {
         const escalation = makeEscalation();
         const repair = repairAgent && process.env.UAP_DELIVER_REPAIR_ESCALATION !== '0'
             ? createRepairEscalation({
@@ -1284,7 +1389,7 @@ async function runDeliver(instruction, options) {
         return composeIterationHooks((record) => printProgress(record), (record) => {
             // Feed the acceptance breaker's zero-diff guard.
             if (record.filesApplied.length > 0)
-                specChangeEvidence.writes += record.filesApplied.length;
+                evidenceFor(evidenceRoot).writes += record.filesApplied.length;
             return undefined;
         }, (record) => haloTracer.onIteration(record), repair ? (record) => repair.onIteration(record) : undefined, coordinator ? (record) => coordinator.onIteration(record) : undefined, escalation ? (record) => escalation.onIteration(record) : undefined);
     };
@@ -1295,6 +1400,9 @@ async function runDeliver(instruction, options) {
         // The agentic executor mutates the repo directly (no-op applier), so
         // gates must run every turn regardless of applier file count.
         alwaysVerify: agentic ? true : undefined,
+        // Anti-no-op acceptance rail (P0): success requires an actual tree
+        // change unless the caller explicitly allows a no-op mission.
+        requireDiffForAcceptance: options.allowNoop === true ? false : undefined,
         // From-scratch builds have no artifact at t0, so the runtime execution gate
         // (and build/test/lint) aren't detectable yet. Re-detect each turn so they
         // engage once the model writes files, rather than relying only on the t0
@@ -1517,47 +1625,61 @@ async function runDeliver(instruction, options) {
         const tasks = phases.map((ph) => ({
             id: ph.id, title: ph.title, goal: ph.goal, ...(ph.deps ? { deps: ph.deps } : {}),
         }));
-        const orchResult = await orchestrate({
-            mission: instruction,
-            tasks,
-            contextBudgetChars: Number(process.env.UAP_DELIVER_CONTEXT_BUDGET ?? 6000),
-            maxTasks: Number(process.env.UAP_DELIVER_MAX_TASKS ?? 40),
-            // P3 — per-task memory retrieval: pull the few most relevant established
-            // decisions/patterns/gotchas for THIS task's goal (a small semantic
-            // query, not the full spec), so a fresh-context task reconstructs "what
-            // am I building and why" from memory. Fail-soft → no design lines.
-            retrieveDesign: async (task) => {
-                try {
-                    const { retrieveDynamicMemoryContext } = await import('../memory/dynamic-retrieval.js');
-                    const mem = await retrieveDynamicMemoryContext(task.goal, projectRoot, { maxTokens: 400 });
-                    const lines = [];
-                    for (const m of mem.relevantMemories.slice(0, 4))
-                        lines.push(m.content.slice(0, 160));
-                    for (const g of mem.gotchas.slice(0, 2))
-                        lines.push(`gotcha: ${g.slice(0, 140)}`);
-                    for (const pat of mem.patterns.slice(0, 2))
-                        lines.push(`pattern: ${pat.slice(0, 140)}`);
-                    return lines;
-                }
-                catch {
-                    return [];
-                }
-            },
-            // P3/P4 — durable publish: a completed task's verified contract lands in
-            // short-term memory so later tasks (and future fresh sessions) retrieve
-            // the interface from memory instead of re-reading source.
-            publish: async (outcome, task) => {
-                if (!outcome.success)
-                    return;
-                await recordOrchestratorTaskOutcome(task.id, task.title, outcome.contract ?? outcome.summary, projectRoot);
-            },
-            runTask: async (ctx, task) => {
-                console.log(chalk.bold(`\u25b6 task ${task.id}: ${task.title}`) +
-                    chalk.dim(` (ctx ${ctx.prompt.length} chars, deps: ${ctx.includedDeps.join(',') || 'none'})`));
-                const taskRecord = await openDeliveryTask(`${task.title} — ${task.goal.slice(0, 120)}`, projectRoot, missionTask?.id);
+        // -- Worktree-isolated parallel dispatch --
+        // `.uap.json` deliver.parallelTasks (config-only BY DESIGN - no env; see
+        // the concurrency notes in task-orchestrator.ts) dispatches independent
+        // READY tasks concurrently, EACH in its own detached git worktree seeded
+        // with the main tree's current uncommitted state and judged against its
+        // own spec. Merge-backs are SERIALIZED under a lock; a conflicting merge
+        // fails the task, and the orchestrator's minimal repair retries it in a
+        // fresh workspace seeded with the updated baseline - conflicts resolve
+        // through the ATG repair path instead of corrupting the tree.
+        const parallelTasks = resolveParallelTasks(cfgRaw.deliver?.parallelTasks);
+        const wsManager = parallelTasks > 1 ? createTaskWorkspaceManager(projectRoot) : null;
+        if (parallelTasks > 1 && !wsManager) {
+            console.log(chalk.yellow('  ⇉ parallel tasks: worktree isolation unavailable (not a git repo?) - running sequentially'));
+        }
+        else if (wsManager) {
+            console.log(chalk.cyan(`  ⇉ parallel tasks: up to ${parallelTasks} independent tasks in isolated worktrees`));
+        }
+        // Merge-boundary defense-in-depth: refuse a delta touching protected
+        // tests/gate configs at the boundary, instead of trusting the in-worktree
+        // layers transitively (mode-only changes and capture-skipped files would
+        // otherwise ride the patch back).
+        const mergeProtected = new Set(options.protectTests !== false
+            ? [...snapshotProtection(projectRoot).protectedFiles, ...listGateConfigFiles(projectRoot)].map((f) => f.toLowerCase())
+            : []);
+        let mergeChain = Promise.resolve();
+        const withMergeLock = (fn) => {
+            const next = mergeChain.then(fn, fn);
+            mergeChain = next.then(() => undefined, () => undefined);
+            return next;
+        };
+        // Regexes built from strings so policy hooks never mistake a literal for a path.
+        const SOURCE_FILE_RE = new RegExp('[.](js|mjs|cjs|ts|tsx|jsx|py)$');
+        const NEW_TASKS_RE = new RegExp('NEW_TASKS:\\s*(\\[[\\s\\S]*?\\])');
+        /** Run one task's convergence loop against `root` with executor `exec` -
+         * the historic in-tree body, parameterized so isolated workspaces reuse it
+         * verbatim. Turns/history flow into the mission aggregate as before. */
+        const runTaskAt = async (ctx, task, root, exec) => {
+            const taskRecord = await openDeliveryTask(`${task.title} — ${task.goal.slice(0, 120)}`, projectRoot, missionTask?.id);
+            acceptanceSpecByRoot.set(root, ctx.prompt);
+            if (root === projectRoot)
                 acceptanceSpec = ctx.prompt;
-                specChangeEvidence.writes = 0;
-                const loop = new ConvergenceLoop({ ...loopConfig, baselineCheck: false, resumeFrom: undefined, onIteration: makeIterationHook() }, executor, seams);
+            evidenceFor(root).writes = 0;
+            try {
+                const loop = new ConvergenceLoop({
+                    ...loopConfig,
+                    projectRoot: root,
+                    baselineCheck: false,
+                    resumeFrom: undefined,
+                    // Checkpoints describe THE mission tree; isolated roots must not
+                    // clobber the durable run state.
+                    // The inherited explorer's workspaceProvider is bound to the MAIN
+                    // projectRoot; inside an isolated task it must not run at all.
+                    ...(root !== projectRoot ? { onCheckpoint: undefined, explorer: undefined } : {}),
+                    onIteration: makeIterationHook(root),
+                }, exec, seams);
                 const r = await loop.deliver(ctx.prompt);
                 all.turns += r.turns;
                 all.history.push(...r.history);
@@ -1570,7 +1692,7 @@ async function runDeliver(instruction, options) {
                 all.finalOutput = r.finalOutput;
                 completeDeliveryTask(taskRecord, r);
                 const files = [...new Set(r.history.flatMap((h) => h.filesApplied ?? []))];
-                // P4 — extract the VERIFIED public contract of what this task built so
+                // P4 - extract the VERIFIED public contract of what this task built so
                 // dependents load the interface (a few hundred chars), not the source.
                 let contract;
                 if (r.success && files.length > 0) {
@@ -1578,10 +1700,10 @@ async function runDeliver(instruction, options) {
                         const { readFileSync } = await import('fs');
                         const { join } = await import('path');
                         const srcs = files
-                            .filter((f) => /\.(js|mjs|cjs|ts|tsx|jsx|py)$/.test(f))
+                            .filter((f) => SOURCE_FILE_RE.test(f))
                             .map((f) => {
                             try {
-                                return { path: f, content: readFileSync(join(projectRoot, f), 'utf-8') };
+                                return { path: f, content: readFileSync(join(root, f), 'utf-8') };
                             }
                             catch {
                                 return null;
@@ -1594,16 +1716,16 @@ async function runDeliver(instruction, options) {
                         contract = undefined;
                     }
                 }
-                // P5 — adaptive re-planning feed: a task may surface work the initial
+                // P5 - adaptive re-planning feed: a task may surface work the initial
                 // plan missed by emitting a `NEW_TASKS: [ {id,title,goal,deps} ]` JSON
                 // array in its output. Parsed through the same validator as the planner
                 // (well-formed only), then folded into the DAG by orchestrate() (which
                 // dedupes, topo-resorts, and caps at maxTasks). Only structural fields
-                // are used — never free-form model text as durable memory.
+                // are used - never free-form model text as durable memory.
                 let newTasks;
                 if (r.success) {
                     try {
-                        const marker = /NEW_TASKS:\s*(\[[\s\S]*?\])/.exec(r.finalOutput || r.finalFeedback || '');
+                        const marker = NEW_TASKS_RE.exec(r.finalOutput || r.finalFeedback || '');
                         if (marker) {
                             const parsed = parsePhaseArray(marker[1]).filter((t) => t.id !== task.id);
                             if (parsed.length > 0) {
@@ -1631,8 +1753,121 @@ async function runDeliver(instruction, options) {
                     ...(contract ? { contract } : {}),
                     ...(newTasks && newTasks.length > 0 ? { newTasks } : {}),
                 };
+            }
+            finally {
+                acceptanceSpecByRoot.delete(root);
+            }
+        };
+        const orchResult = await orchestrate({
+            mission: instruction,
+            tasks,
+            contextBudgetChars: Number(process.env.UAP_DELIVER_CONTEXT_BUDGET ?? 6000),
+            maxTasks: Number(process.env.UAP_DELIVER_MAX_TASKS ?? 40),
+            // Dependency-aware parallel dispatch — only with worktree isolation.
+            concurrency: wsManager ? parallelTasks : 1,
+            // P3 — per-task memory retrieval: pull the few most relevant established
+            // decisions/patterns/gotchas for THIS task's goal (a small semantic
+            // query, not the full spec), so a fresh-context task reconstructs "what
+            // am I building and why" from memory. Fail-soft → no design lines.
+            retrieveDesign: async (task) => {
+                try {
+                    const { retrieveDynamicMemoryContext } = await import('../memory/dynamic-retrieval.js');
+                    const mem = await retrieveDynamicMemoryContext(task.goal, projectRoot, { maxTokens: 400 });
+                    const lines = [];
+                    for (const m of mem.relevantMemories.slice(0, 4))
+                        lines.push(m.content.slice(0, 160));
+                    for (const g of mem.gotchas.slice(0, 2))
+                        lines.push(`gotcha: ${g.slice(0, 140)}`);
+                    for (const pat of mem.patterns.slice(0, 2))
+                        lines.push(`pattern: ${pat.slice(0, 140)}`);
+                    return lines;
+                }
+                catch {
+                    return [];
+                }
+            },
+            // P3/P4 — durable publish: a completed task's verified contract lands in
+            // short-term memory so later tasks (and future fresh sessions) retrieve
+            // the interface from memory instead of re-reading source.
+            publish: async (outcome, task) => {
+                if (!outcome.success)
+                    return;
+                await recordOrchestratorTaskOutcome(task.id, task.title, outcome.contract ?? outcome.summary, projectRoot);
+            },
+            runTask: async (ctx, task) => {
+                console.log(chalk.bold(`▶ task ${task.id}: ${task.title}`) +
+                    chalk.dim(` (ctx ${ctx.prompt.length} chars, deps: ${ctx.includedDeps.join(',') || 'none'})`));
+                // Workspace acquisition mutates git state (worktree add) - serialize
+                // it behind the same lock the merges use.
+                const ws = wsManager ? await withMergeLock(() => wsManager.acquire(task.id)) : null;
+                if (!ws) {
+                    if (wsManager) {
+                        console.log(chalk.yellow(`  ⇉ task ${task.id}: workspace unavailable - running in-tree (serialized)`));
+                        // In-tree execution mutates the shared tree; hold the lock for the
+                        // WHOLE run so it never races an isolated task's merge-back.
+                        return withMergeLock(() => runTaskAt(ctx, task, projectRoot, executor));
+                    }
+                    return runTaskAt(ctx, task, projectRoot, executor);
+                }
+                try {
+                    // The agentic executor binds tools to a root at construction - give
+                    // the isolated task its own, with the same protections re-derived
+                    // for its tree. The blind executor is root-free (the per-task loop's
+                    // projectRoot directs the applier and gates).
+                    const taskExecutor = agentic
+                        ? createAgenticExecutor(model, {
+                            projectRoot: ws.root,
+                            endpoint: agenticEndpoint,
+                            temperature,
+                            contextTokenBudget: sessionBudget,
+                            contractFiles: contractLock,
+                            protectedFiles: options.protectTests !== false ? snapshotProtection(ws.root).protectedFiles : new Set(),
+                            protectGateConfigs: options.protectTests !== false,
+                            allowBash: options.allowBash === true || process.env.UAP_DELIVER_ALLOW_BASH === '1',
+                            onEvent: (e) => console.log(chalk.dim(`    [${task.id} r${e.round} ${e.kind}${e.tool ? `:${e.tool}` : ''}] ${e.detail ?? ''}`)),
+                        })
+                        : executor;
+                    const outcome = await runTaskAt(ctx, task, ws.root, taskExecutor);
+                    if (!outcome.success)
+                        return outcome;
+                    const merged = await withMergeLock(() => ws.mergeBack((f) => mergeProtected.has(f.toLowerCase())));
+                    if (!merged.ok) {
+                        console.log(chalk.yellow(`  ⇉ task ${task.id}: merge-back conflicted (${merged.reason ?? 'apply failed'}) - minimal repair retries on the updated tree`));
+                        return {
+                            taskId: task.id,
+                            success: false,
+                            turns: 0,
+                            summary: `${task.goal.slice(0, 120)} — FAILED: the tree changed underneath this task (parallel merge conflict) — rebuild it against the CURRENT state of the repository. Detail: ${(merged.reason ?? 'could not apply the task delta').slice(0, 200)}`,
+                        };
+                    }
+                    if (merged.files.length > 0) {
+                        console.log(chalk.dim(`  ⇉ task ${task.id}: merged ${merged.files.length} file(s) into the main tree`));
+                    }
+                    return outcome;
+                }
+                finally {
+                    ws.cleanup();
+                }
             },
         });
+        // Post-merge verification: every gate passed in SOME tree, but 3-way
+        // resolution can produce a combined main tree no gate ever saw. One
+        // ladder run on the merged result closes that. Fail-soft on runner
+        // errors; hard on gate failures.
+        if (wsManager && orchResult.success) {
+            try {
+                console.log(chalk.cyan('  ⇉ post-merge verification: gate ladder on the merged main tree…'));
+                const combined = await tieredRunner(rungs, projectRoot, {});
+                if (!combined.passed) {
+                    orchResult.success = false;
+                    orchResult.failed.push('post-merge-verification');
+                    all.finalFeedback = `post-merge verification FAILED on the combined tree:\n${combined.feedback}`.slice(0, 4000);
+                }
+            }
+            catch {
+                // verification unavailable — keep the per-task verdicts
+            }
+        }
         all.success = orchResult.success;
         if (!orchResult.success) {
             all.finalFeedback = `orchestration incomplete — failed tasks: ${orchResult.failed.join(', ')}\n${all.finalFeedback}`;