@aviaratech/ai-delivery 0.3.22 → 0.3.24

package/dist/verification.js

@@ -1,18 +1,15 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
+import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
-import { closeSync, existsSync, fsyncSync, fstatSync, openSync, unlinkSync, lstatSync, mkdirSync, rmdirSync, renameSync, readFileSync, readSync, readlinkSync, readdirSync, realpathSync, statfsSync, } from 'node:fs';
-import { basename, dirname, join, resolve, sep } from 'node:path';
+import { closeSync, existsSync, fsyncSync, openSync, unlinkSync, lstatSync, mkdirSync, rmdirSync, renameSync, readFileSync, readlinkSync, readdirSync, realpathSync, statfsSync, } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
-import { loadDeliveryConfig } from './config/deliveryConfig.js';
 import { assertPrivateFile } from './delivery/common.js';
-import { classifyRepositoryExactRange, assertRepositoryClassificationCurrent, createRepositoryDeliveryEvidence, createRepositoryStageAggregate, createRepositoryStageInput, createRepositoryStageReceipt, digestBytes, digestValue, assertRepositoryStageProof, loadRepositoryStageCheckpoint, loadSelectedRepositoryPolicy, RepositoryClassificationReceiptSchema, RepositoryStageAggregateSchema, RepositoryStageReceiptSchema, writeRepositoryCommandOutput, writeRepositoryDeliveryEvidence, writeRepositoryStageAggregate, writeRepositoryStageCheckpoint, } from './delivery/index.js';
+import { readRepositoryCommandOutput } from './delivery/stage.js';
+import { createRepositoryStageAggregate, digestBytes, digestValue, RepositoryClassificationReceiptSchema, RepositoryStageAggregateSchema, RepositoryStageReceiptSchema, writeRepositoryCommandOutput, } from './delivery/legacy.js';
 import { DeliveryError } from './errors.js';
-import { createDeliveryGitHubClients } from './github/client.js';
-import { assertClean, changedPaths, coordinate, defaultBaseRef, git, gitCommonDir, gitRoot } from './git.js';
-import { assertAiDeliveryWorktreeOwner, getIssueWorktreeStrict } from './services/worktreeRegistry.js';
-import { assertDeliveryRuntimeAdmitted } from './services/deliveryAdmission.js';
+import { gitCommonDir, gitRoot } from './git.js';
 import { withLock } from './utils/lockfile.js';
 import { ensurePrivateDirectoryDurably, writePrivateJsonFileAtomically } from './utils/atomicJson.js';
 const ResourceSummarySchema = z
@@ -49,63 +46,6 @@ const ResourceSummarySchema = z
         (value.bounds.maxNewOutputBytes !== undefined) !== (value.outputBaselineId !== undefined))
         ctx.addIssue({ code: 'custom', message: 'Resource samples do not satisfy their declared bounds.' });
 });
-const ResourceStageCheckpointSchema = z.strictObject({
-    checkpointId: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
-    receipt: RepositoryStageReceiptSchema,
-    resources: ResourceSummarySchema,
-    schemaVersion: z.literal('ai-delivery.resource-stage@1'),
-});
-function resourceStagePath(common, stageInput) {
-    return join(common, 'ai-delivery', 'resource-stages@1', `${stageInput.inputId.slice(7)}.json`);
-}
-function loadResourceStageCheckpoint(common, repoRoot, stageInput, bounds, baselineId) {
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(resourceStagePath(common, stageInput), 'utf8'));
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return undefined;
-        throw new DeliveryError('Resource stage checkpoint is corrupt.');
-    }
-    const checkpoint = ResourceStageCheckpointSchema.parse(raw);
-    const { checkpointId, ...content } = checkpoint;
-    if (checkpointId !== digestValue(content) ||
-        checkpoint.receipt.input.inputId !== stageInput.inputId ||
-        digestValue(checkpoint.resources.bounds) !== digestValue(bounds) ||
-        checkpoint.resources.outputBaselineId !== baselineId ||
-        checkpoint.resources.sampleCount === 0)
-        throw new DeliveryError('Resource stage checkpoint is corrupt or belongs to another input.');
-    assertRepositoryStageProof({ gitCommonDir: common, receipt: checkpoint.receipt, repoRoot });
-    return checkpoint;
-}
-function writeResourceStageCheckpoint(common, receipt, resources) {
-    if (resources.sampleCount === 0)
-        throw new DeliveryError('Completed bounded stage lacks resource samples.');
-    const content = {
-        receipt,
-        resources: ResourceSummarySchema.parse(resources),
-        schemaVersion: 'ai-delivery.resource-stage@1',
-    };
-    writePrivateJsonFileAtomically(resourceStagePath(common, receipt.input), {
-        ...content,
-        checkpointId: digestValue(content),
-    });
-}
-function mergeResourceSummary(target, source) {
-    target.sampleCount += source.sampleCount;
-    if (!Number.isSafeInteger(target.sampleCount))
-        throw new DeliveryError('Resource sample count overflowed.');
-    if (source.maxSampledAggregateRssBytes !== null) {
-        target.maxSampledAggregateRssBytes = Math.max(target.maxSampledAggregateRssBytes ?? 0, source.maxSampledAggregateRssBytes);
-    }
-    if (source.maxSampledNewOutputBytes !== null) {
-        target.maxSampledNewOutputBytes = Math.max(target.maxSampledNewOutputBytes ?? 0, source.maxSampledNewOutputBytes);
-    }
-    if (source.minSampledFreeDiskBytes !== null) {
-        target.minSampledFreeDiskBytes = Math.min(target.minSampledFreeDiskBytes ?? source.minSampledFreeDiskBytes, source.minSampledFreeDiskBytes);
-    }
-}
 function assertResourceBounds(bounds) {
     const limits = [
         ['maxAggregateRssBytes', bounds.maxAggregateRssBytes],
@@ -375,23 +315,6 @@ async function withOutputObservationGate(root, enabled, operation) {
         retireOutputGate(gate);
     }
 }
-const OutputBaselineCheckpointSchema = z.strictObject({
-    baselineId: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
-    files: z.array(z.tuple([z.string().min(1), z.number().int().nonnegative().safe()])),
-    inputId: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
-    roots: z.array(z.string().min(1)).min(1),
-    schemaVersion: z.literal('ai-delivery.output-baseline@1'),
-});
-const OutputBaselineStateSchema = z.strictObject({
-    baselineId: z
-        .string()
-        .regex(/^sha256:[a-f0-9]{64}$/u)
-        .optional(),
-    inputId: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
-    schemaVersion: z.literal('ai-delivery.output-baseline-state@1'),
-    stateId: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
-    status: z.enum(['preparing', 'complete']),
-});
 class OutputObservationError extends DeliveryError {
     cause;
     code;
@@ -563,83 +486,6 @@ function scanOutputRoots(roots, links, commandRunning = false, onMissingTarget)
         links.set(path, link);
     return files;
 }
-async function outputBaseline(repoRoot, common, classificationReceiptId, bounds, gate, signal) {
-    if (bounds.outputRoots === undefined)
-        return undefined;
-    const roots = bounds.outputRoots.map((path) => resolve(repoRoot, path)).sort();
-    const links = new Map();
-    for (let i = 1; i < roots.length; i++) {
-        if (roots[i] === roots[i - 1] || roots[i].startsWith(`${roots[i - 1]}${sep}`)) {
-            throw new DeliveryError('Filesystem output roots must not overlap.');
-        }
-    }
-    const inputId = digestValue({
-        bounds: { ...bounds, outputRoots: roots },
-        classificationReceiptId,
-        resourceRunner: digestBytes(readFileSync(fileURLToPath(import.meta.url))),
-    });
-    const path = join(common, 'ai-delivery', 'output-baselines@1', `${inputId.slice(7)}.json`);
-    const statePath = join(common, 'ai-delivery', 'output-baselines@1', `${inputId.slice(7)}.state.json`);
-    const writeState = (status, baselineId) => {
-        const content = {
-            inputId,
-            schemaVersion: 'ai-delivery.output-baseline-state@1',
-            status,
-            ...(baselineId === undefined ? {} : { baselineId }),
-        };
-        writePrivateJsonFileAtomically(statePath, { ...content, stateId: digestValue(content) });
-    };
-    let state;
-    try {
-        state = OutputBaselineStateSchema.parse(JSON.parse(readFileSync(statePath, 'utf8')));
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT') {
-            throw new DeliveryError('Filesystem output baseline state is corrupt.');
-        }
-    }
-    if (state === undefined) {
-        if (existsSync(path))
-            throw new DeliveryError('Filesystem output baseline state is missing.');
-        writeState('preparing');
-    }
-    else {
-        const { stateId, ...content } = state;
-        if (stateId !== digestValue(content) ||
-            state.inputId !== inputId ||
-            (state.status === 'complete') !== (state.baselineId !== undefined))
-            throw new DeliveryError('Filesystem output baseline state is corrupt.');
-    }
-    let checkpoint;
-    if (state?.status !== 'complete') {
-        const content = {
-            files: [...(await withOutputGateLock(gate, 'scan', () => scanOutputRoots(roots, links), signal))].sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0)),
-            inputId,
-            roots,
-            schemaVersion: 'ai-delivery.output-baseline@1',
-        };
-        checkpoint = { ...content, baselineId: digestValue(content) };
-        writePrivateJsonFileAtomically(path, checkpoint);
-        writeState('complete', checkpoint.baselineId);
-    }
-    else {
-        try {
-            checkpoint = OutputBaselineCheckpointSchema.parse(JSON.parse(readFileSync(path, 'utf8')));
-        }
-        catch {
-            throw new DeliveryError('Filesystem output baseline checkpoint is missing or corrupt.');
-        }
-    }
-    const { baselineId, ...content } = checkpoint;
-    if (baselineId !== digestValue(content) ||
-        (state?.status === 'complete' && state.baselineId !== baselineId) ||
-        checkpoint.inputId !== inputId ||
-        digestValue(checkpoint.roots) !== digestValue(roots) ||
-        checkpoint.files.some(([file], index) => (index > 0 && file <= checkpoint.files[index - 1][0]) ||
-            !roots.some((root) => file === root || file.startsWith(`${root}${sep}`))))
-        throw new DeliveryError('Filesystem output baseline checkpoint is corrupt or belongs to another input.');
-    return { baselineId, roots, files: new Map(checkpoint.files), links, ...(gate === undefined ? {} : { gate }) };
-}
 async function positiveNewOutputBytes(baseline, signal, commandRunning = false, onUnavailable) {
     let files;
     let firstFailure;
@@ -711,7 +557,7 @@ function assertDiskHeadroom(repoRoot, bounds, baseline) {
         throw new DeliveryError(`Free disk fell below limit ${bounds.minFreeDiskBytes}.`);
     }
 }
-function processSnapshot() {
+export function processSnapshot() {
     const psPath = existsSync('/usr/bin/ps') ? '/usr/bin/ps' : '/bin/ps';
     const result = spawnSync(psPath, ['-A', '-o', 'pid=,ppid=,pgid=,rss=,stat=,lstart='], {
         encoding: 'utf8',
@@ -840,7 +686,7 @@ function controllerTreeRssBytes(snapshot = processSnapshot(), excluded = new Set
         throw new DeliveryError('Controller aggregate RSS observation overflowed.');
     return bytes;
 }
-async function confirmOwnedCleanup(state) {
+export async function confirmOwnedCleanup(state) {
     if (!state.sampled || state.rootIdentity === undefined) {
         throw new DeliveryError('Owned process cleanup cannot be verified without a root identity.');
     }
@@ -868,7 +714,7 @@ async function confirmOwnedCleanup(state) {
     }
 }
 /** Signal only birth identities established by this command, including observed detached children. */
-function terminateOwnedProcesses(state) {
+export function terminateOwnedProcesses(state) {
     if (!state.sampled || state.rootIdentity === undefined)
         throw new DeliveryError('Owned process identity is unknown.');
     const snapshot = processSnapshot();
@@ -1150,21 +996,6 @@ export async function withWorktreeTransitionWriterLease(input, operation) {
         return result;
     }, input, gitCommonDir(repository));
 }
-function primaryRoot(worktreeRoot) {
-    const common = gitCommonDir(worktreeRoot);
-    if (basename(common) !== '.git')
-        throw new DeliveryError('Expected a conventional non-bare Git repository.');
-    return dirname(common);
-}
-function assertRegisteredIssue(worktreeRoot, issueNumber, allowMerged = false) {
-    const row = getIssueWorktreeStrict(issueNumber, primaryRoot(worktreeRoot));
-    if (row.path !== worktreeRoot ||
-        row.branch !== `issue/${issueNumber}` ||
-        (row.status !== 'active' && row.status !== 'pr-published' && !(allowMerged && row.status === 'merged'))) {
-        throw new DeliveryError('Verification requires the exact registered issue worktree.');
-    }
-    assertClean(worktreeRoot);
-}
 function worktreeDigest(root) {
     return digestValue(resolve(root));
 }
@@ -1233,11 +1064,6 @@ export function retainedWorktreeTransitionDependencyManifests(distDirectory) {
 export function readWorktreeTransitionRun(bytes) {
     return parseRun(JSON.parse(bytes.toString('utf8')));
 }
-function manifestPath(common, headSha, root) {
-    return root === undefined
-        ? join(common, 'ai-delivery', 'runs', `${headSha}.json`)
-        : join(common, 'ai-delivery', 'runs@2', worktreeDigest(root).slice(7), `${headSha}.json`);
-}
 function parseRun(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         throw new DeliveryError('Invalid run manifest.');
@@ -1275,54 +1101,10 @@ function parseRun(value) {
         throw new DeliveryError('Run manifest identity or aggregate is invalid.');
     return { ...content, completedAt: input.completedAt, manifestId: input.manifestId };
 }
-function loadRun(common, headSha, root, historical = false) {
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(manifestPath(common, headSha, root), 'utf8'));
-    }
-    catch (error) {
-        if (!historical || error.code !== 'ENOENT')
-            throw new DeliveryError('Exact-head worktree verification run is missing or corrupt; verify with the current producer.');
-        raw = JSON.parse(readFileSync(manifestPath(common, headSha), 'utf8'));
-    }
-    const run = parseRun(raw);
-    if (run.classification.head.sha !== headSha ||
-        (run.writer !== undefined &&
-            (run.writer.worktreeDigest !== worktreeDigest(root) ||
-                (!historical && run.writer.producerDigest !== producerDigest()))) ||
-        (!historical && run.writer === undefined))
-        throw new DeliveryError('Verification run belongs to another writer or producer.');
-    const expectedEnvironment = historical ? undefined : verificationEnvironmentDigest(root, run.resources);
-    if (expectedEnvironment !== undefined &&
-        run.stageReceipts.some((receipt) => receipt.input.environmentDigest !== expectedEnvironment))
-        throw new DeliveryError('Verification stage environment belongs to a foreign worktree or producer.');
-    return run;
-}
-function stageEnvironmentDigest(root, producer = producerDigest()) {
-    return digestValue({
-        arch: process.arch,
-        node: process.version,
-        path: process.env.PATH ?? '',
-        platform: process.platform,
-        worktreeDigest: worktreeDigest(root),
-        producerDigest: producer,
-    });
-}
-function verificationEnvironmentDigest(root, resources, producer = producerDigest()) {
-    const environment = stageEnvironmentDigest(root, producer);
-    return resources === undefined
-        ? environment
-        : digestValue({
-            environment,
-            ...(resources.outputBaselineId === undefined ? {} : { outputBaselineId: resources.outputBaselineId }),
-            resourceBounds: resources.bounds,
-            resourceRunner: digestBytes(readFileSync(fileURLToPath(import.meta.url))),
-        });
-}
 function reportVerificationProgress(input) {
     process.stderr.write(`ai-delivery.verify ${JSON.stringify(input)}\n`);
 }
-function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds, baseline, onResourceSample, writer, execution) {
+export function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds, baseline, onResourceSample, writer, execution) {
     const [executable, ...args] = argv;
     if (!executable)
         throw new DeliveryError('Policy selected an empty stage command.');
@@ -1375,6 +1157,8 @@ function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds,
                 : ` First filesystem observation: ${firstOutputObservationFailure} Last filesystem observation: ${lastOutputObservationFailure}`;
             try {
                 const bytes = Buffer.concat([...stdout, ...stderr]);
+                if (execution?.failedOutput)
+                    return execution.failedOutput(bytes);
                 return ` Command output ${writeRepositoryCommandOutput({ bytes, gitCommonDir: gitCommonDir(repoRoot) })}.${observation}`;
             }
             catch (error) {
@@ -1607,7 +1391,7 @@ function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds,
             }
             writer?.idle();
             settled = true;
-            resolve(Buffer.concat([...stdout, ...stderr], outputBytes));
+            resolve(execution?.stdoutOnly ? Buffer.concat(stdout) : Buffer.concat([...stdout, ...stderr], outputBytes));
         };
         child.once('close', (code, signal) => {
             void handleClose(code, signal)
@@ -1619,359 +1403,6 @@ function runStageCommand(repoRoot, argv, abortSignal, onRunning, resourceBounds,
         });
     });
 }
-export async function verifyIssue(input) {
-    const root = gitRoot(input.repoRoot);
-    return withVerificationWriter(root, (writer) => withOutputObservationGate(root, input.resourceBounds?.outputRoots !== undefined, (gate) => verifyIssueOwned(input, writer, gate)));
-}
-async function verifyIssueOwned(input, writer, gate) {
-    const assertNotCancelled = () => {
-        if (input.signal?.aborted)
-            throw new DeliveryError('Verification cancelled.');
-    };
-    assertNotCancelled();
-    const root = gitRoot(input.repoRoot);
-    if (input.resourceBounds !== undefined)
-        assertResourceBounds(input.resourceBounds);
-    assertRegisteredIssue(root, input.issueNumber);
-    const common = gitCommonDir(root);
-    if (existsSync(join(common, 'ai-delivery', 'merges', String(input.issueNumber), `${coordinate(root).sha}.json`))) {
-        throw new DeliveryError('Commit continuation work before verifying an already-merged issue head; retain its receipts.');
-    }
-    const loaded = await loadDeliveryConfig(root, input.personalAuth === undefined ? {} : { personalAuth: input.personalAuth });
-    const selected = await loadSelectedRepositoryPolicy({
-        repoRoot: root,
-        policySourcePath: loaded.config.policy.module,
-    });
-    const base = coordinate(root, defaultBaseRef(root, loaded.remote));
-    const head = coordinate(root);
-    const classification = classifyRepositoryExactRange({
-        base,
-        changedPaths: changedPaths(root, base.sha, head.sha),
-        configDigest: loaded.configDigest,
-        head,
-        policy: selected.policy,
-        policySourcePath: loaded.config.policy.module,
-        repoRoot: root,
-        repository: loaded.config.repository,
-    });
-    const baseline = input.resourceBounds === undefined
-        ? undefined
-        : await outputBaseline(root, common, classification.receiptId, input.resourceBounds, gate, input.signal);
-    if (input.resourceBounds !== undefined)
-        assertDiskHeadroom(root, input.resourceBounds, baseline);
-    const receipts = [];
-    const admitted = new Set(input.admittedResourceClasses ?? ['source_only']);
-    const startedAtMs = Date.now();
-    let reusedStages = 0;
-    let completedCommands = 0;
-    let reusedCommands = 0;
-    let lastCompletedAtMs = startedAtMs;
-    const totalCommands = classification.requiredStages.reduce((total, stage) => total + stage.commands.length, 0);
-    const report = (progress) => {
-        const elapsedMs = Date.now() - startedAtMs;
-        reportVerificationProgress({
-            ...progress,
-            completedCommands,
-            remainingCommands: totalCommands - completedCommands,
-            reusedCommands,
-            executedCommandsPerSecond: elapsedMs === 0 ? 0 : ((completedCommands - reusedCommands) * 1000) / elapsedMs,
-            lastCompletedWorkAgeMs: Date.now() - lastCompletedAtMs,
-        });
-    };
-    const normalizedBounds = input.resourceBounds === undefined
-        ? undefined
-        : {
-            maxAggregateRssBytes: input.resourceBounds.maxAggregateRssBytes,
-            minFreeDiskBytes: input.resourceBounds.minFreeDiskBytes,
-            ...(input.resourceBounds.maxNewOutputBytes === undefined
-                ? {}
-                : { maxNewOutputBytes: input.resourceBounds.maxNewOutputBytes }),
-            ...(baseline === undefined ? {} : { outputRoots: baseline.roots }),
-        };
-    const emptyResources = () => ({
-        bounds: normalizedBounds,
-        maxSampledAggregateRssBytes: null,
-        maxSampledNewOutputBytes: null,
-        minSampledFreeDiskBytes: null,
-        observation: 'sampled',
-        ...(baseline === undefined ? {} : { outputBaselineId: baseline.baselineId }),
-        processCoverage: 'observed-processes-only',
-        sampleCount: 0,
-    });
-    const resources = normalizedBounds === undefined ? undefined : emptyResources();
-    const producer = producerDigest();
-    const environmentDigest = verificationEnvironmentDigest(root, resources, producer);
-    let stageResources;
-    const recordResourceSample = (sample) => {
-        if (resources === undefined)
-            return;
-        const measured = {
-            ...emptyResources(),
-            sampleCount: 1,
-            maxSampledAggregateRssBytes: sample.aggregateRssBytes,
-            maxSampledNewOutputBytes: sample.newOutputBytes ?? null,
-            minSampledFreeDiskBytes: sample.freeDiskBytes,
-        };
-        mergeResourceSummary(resources, measured);
-        if (stageResources !== undefined)
-            mergeResourceSummary(stageResources, measured);
-    };
-    for (const stage of classification.requiredStages) {
-        assertNotCancelled();
-        const stageInput = createRepositoryStageInput({
-            classification,
-            environmentDigest,
-            semanticInputs: stage.semanticInputs ??
-                stage.semanticInputKeys.map((key) => ({
-                    digest: digestValue({ key, evidenceId: classification.policyEvidence.evidenceId }),
-                    key,
-                })),
-            stageId: stage.id,
-            upstream: stage.dependsOn.map((stageId) => {
-                const receipt = receipts.find((value) => value.input.stageId === stageId);
-                if (!receipt)
-                    throw new DeliveryError(`Missing upstream stage '${stageId}'.`);
-                return { receiptId: receipt.receiptId, stageId };
-            }),
-        });
-        let cached = loadRepositoryStageCheckpoint({
-            classification,
-            configDigest: loaded.configDigest,
-            gitCommonDir: common,
-            policySourcePath: loaded.config.policy.module,
-            repoRoot: root,
-            stageInput,
-        });
-        if (normalizedBounds !== undefined) {
-            const measured = loadResourceStageCheckpoint(common, root, stageInput, normalizedBounds, baseline?.baselineId);
-            if (measured !== undefined) {
-                if (cached === undefined) {
-                    writeRepositoryStageCheckpoint({ gitCommonDir: common, receipt: measured.receipt, repoRoot: root });
-                    cached = loadRepositoryStageCheckpoint({
-                        classification,
-                        configDigest: loaded.configDigest,
-                        gitCommonDir: common,
-                        policySourcePath: loaded.config.policy.module,
-                        repoRoot: root,
-                        stageInput,
-                    });
-                }
-                if (cached?.receiptId !== measured.receipt.receiptId) {
-                    throw new DeliveryError('Resource stage checkpoint disagrees with its stage receipt.');
-                }
-                mergeResourceSummary(resources, measured.resources);
-            }
-            else if (cached !== undefined) {
-                throw new DeliveryError('Bounded stage receipt lacks its resource checkpoint.');
-            }
-        }
-        if (cached) {
-            receipts.push(cached);
-            reusedStages += 1;
-            completedCommands += cached.commands.length;
-            reusedCommands += cached.commands.length;
-            lastCompletedAtMs = Date.now();
-            report({
-                state: 'reused',
-                stageId: stage.id,
-                completedStages: receipts.length,
-                remainingStages: classification.requiredStages.length - receipts.length,
-                reusedStages,
-                elapsedMs: Date.now() - startedAtMs,
-            });
-            continue;
-        }
-        assertNotCancelled();
-        if (!admitted.has(stage.resourceClass)) {
-            throw new DeliveryError(`Stage '${stage.id}' requires explicit ${stage.resourceClass} admission.`);
-        }
-        stageResources = normalizedBounds === undefined ? undefined : emptyResources();
-        const startedAt = new Date().toISOString();
-        const commands = [];
-        for (const command of stage.commands) {
-            const commandStartedAtMs = Date.now();
-            if (input.resourceBounds !== undefined)
-                assertDiskHeadroom(root, input.resourceBounds, baseline);
-            const progress = (capturedOutputBytes, sample, reason) => report({
-                state: 'running',
-                stageId: stage.id,
-                commandLabel: command.label,
-                completedStages: receipts.length,
-                remainingStages: classification.requiredStages.length - receipts.length,
-                reusedStages,
-                elapsedMs: Date.now() - startedAtMs,
-                capturedOutputBytes,
-                ...(reason === undefined ? {} : { reason }),
-                commandElapsedMs: Date.now() - commandStartedAtMs,
-                ...(sample === undefined
-                    ? {}
-                    : {
-                        sampledAggregateRssBytes: sample.aggregateRssBytes,
-                        sampledFreeDiskBytes: sample.freeDiskBytes,
-                        ...(sample.newOutputBytes === undefined ? {} : { sampledNewOutputBytes: sample.newOutputBytes }),
-                        ownedProcessCount: sample.ownedProcessCount,
-                        ...(baseline !== undefined && sample.newOutputBytes === undefined
-                            ? { reason: 'waiting for strict filesystem output scan' }
-                            : {}),
-                    }),
-            });
-            progress(0);
-            let bytes;
-            try {
-                bytes = await runStageCommand(root, command.argv, input.signal, progress, input.resourceBounds, baseline, recordResourceSample, writer);
-            }
-            catch (error) {
-                report({
-                    state: 'failed',
-                    stageId: stage.id,
-                    commandLabel: command.label,
-                    completedStages: receipts.length,
-                    remainingStages: classification.requiredStages.length - receipts.length,
-                    reusedStages,
-                    elapsedMs: Date.now() - startedAtMs,
-                    reason: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-            assertNotCancelled();
-            completedCommands += 1;
-            lastCompletedAtMs = Date.now();
-            commands.push({
-                exitCode: 0,
-                label: command.label,
-                outputDigest: writeRepositoryCommandOutput({ bytes, gitCommonDir: common }),
-            });
-        }
-        const artifacts = stage.attestationKey === undefined
-            ? []
-            : classification.policyEvidence.artifacts
-                .filter((artifact) => artifact.path === stage.attestationKey)
-                .map((artifact) => ({ digest: artifact.digest, path: artifact.path }));
-        if (stage.attestationKey !== undefined && artifacts.length === 0) {
-            throw new DeliveryError(`Selected attestation '${stage.attestationKey}' lacks a bound artifact.`);
-        }
-        const receipt = createRepositoryStageReceipt({
-            artifacts,
-            classification,
-            commands,
-            completedAt: new Date().toISOString(),
-            stageInput,
-            startedAt,
-        });
-        assertNotCancelled();
-        if (stageResources !== undefined)
-            writeResourceStageCheckpoint(common, receipt, stageResources);
-        writeRepositoryStageCheckpoint({ gitCommonDir: common, receipt, repoRoot: root });
-        stageResources = undefined;
-        receipts.push(receipt);
-        lastCompletedAtMs = Date.now();
-        report({
-            state: 'completed',
-            stageId: stage.id,
-            completedStages: receipts.length,
-            remainingStages: classification.requiredStages.length - receipts.length,
-            reusedStages,
-            elapsedMs: Date.now() - startedAtMs,
-        });
-    }
-    assertNotCancelled();
-    if (baseline !== undefined && input.resourceBounds !== undefined) {
-        const bytes = await positiveNewOutputBytes(baseline, input.signal);
-        if (bytes > input.resourceBounds.maxNewOutputBytes)
-            throw new DeliveryError('Positive new filesystem output ' + bytes + ' exceeded limit ' + input.resourceBounds.maxNewOutputBytes + '.');
-        assertDiskHeadroom(root, input.resourceBounds, baseline);
-        recordResourceSample({
-            aggregateRssBytes: 0,
-            freeDiskBytes: freeDiskBytes(root, baseline),
-            newOutputBytes: bytes,
-            ownedProcessCount: 0,
-        });
-    }
-    assertNotCancelled();
-    assertRepositoryClassificationCurrent({
-        classification,
-        configDigest: loaded.configDigest,
-        policySourcePath: loaded.config.policy.module,
-        repoRoot: root,
-    });
-    if (coordinate(root).sha !== head.sha || coordinate(root, defaultBaseRef(root, loaded.remote)).sha !== base.sha)
-        throw new DeliveryError('Verification source changed during execution; classify and resume the current source.');
-    if (producerDigest() !== producer)
-        throw new DeliveryError('Verification producer changed during execution.');
-    const aggregate = createRepositoryStageAggregate({ classification, receipts });
-    writeRepositoryStageAggregate({ gitCommonDir: common, aggregate });
-    const content = {
-        aggregate,
-        classification,
-        completedAt: new Date().toISOString(),
-        ...(resources === undefined ? {} : { resources: ResourceSummarySchema.parse(resources) }),
-        schemaVersion: 'ai-delivery.run@3',
-        writer: { worktreeDigest: worktreeDigest(root), producerDigest: producer },
-        stageReceipts: receipts,
-    };
-    const run = { ...content, manifestId: digestValue(content) };
-    writePrivateJsonFileAtomically(manifestPath(common, head.sha, root), run);
-    return run;
-}
-export async function createIssuePhaseEvidence(input) {
-    const root = gitRoot(input.repoRoot);
-    assertRegisteredIssue(root, input.issueNumber);
-    const loaded = await loadDeliveryConfig(root, input.personalAuth === undefined ? {} : { personalAuth: input.personalAuth });
-    const selected = await loadSelectedRepositoryPolicy({
-        repoRoot: root,
-        policySourcePath: loaded.config.policy.module,
-    });
-    const run = loadRun(gitCommonDir(root), coordinate(root).sha, root);
-    const evidence = createRepositoryDeliveryEvidence({
-        aggregate: run.aggregate,
-        ...(input.approval === undefined ? {} : { approval: input.approval }),
-        approvalRoles: {
-            authorIdentity: loaded.config.roles.author.identity,
-            reviewerIdentity: loaded.config.roles.reviewer.identity,
-        },
-        classification: run.classification,
-        configDigest: loaded.configDigest,
-        currentBase: coordinate(root, run.classification.base.sha),
-        currentHead: coordinate(root),
-        gitCommonDir: gitCommonDir(root),
-        ...(input.mergeReadback === undefined ? {} : { mergeReadback: input.mergeReadback }),
-        phase: input.phase,
-        policy: selected.policy,
-        policySourcePath: loaded.config.policy.module,
-        repoRoot: root,
-        stageReceipts: run.stageReceipts,
-    });
-    writeRepositoryDeliveryEvidence({ evidence, gitCommonDir: gitCommonDir(root) });
-    return evidence;
-}
-export function loadVerifiedRun(repoRoot, issueNumber) {
-    const root = gitRoot(repoRoot);
-    assertRegisteredIssue(root, issueNumber, true);
-    const historical = getIssueWorktreeStrict(issueNumber, primaryRoot(root)).status === 'merged';
-    return loadRun(gitCommonDir(root), coordinate(root).sha, root, historical);
-}
-/** @internal Preservation-only read; the continuation owner validates custody and terminal lineage. */
-export function loadHistoricalMergedRun(repoRoot, headSha) {
-    const root = gitRoot(repoRoot);
-    const common = gitCommonDir(root);
-    const run = loadRun(common, headSha, root, true);
-    const current = manifestPath(common, headSha, root);
-    return { run, path: existsSync(current) ? current : manifestPath(common, headSha) };
-}
-/** Recover an exact merged run after worktree removal interrupted terminal recording. */
-export function loadRemovedMergedRun(primaryRepoRoot, issueNumber) {
-    const root = gitRoot(primaryRepoRoot);
-    const row = getIssueWorktreeStrict(issueNumber, root);
-    if (row.status !== 'merged' || row.path !== join(root, '.worktrees', `issue-${issueNumber}`)) {
-        throw new DeliveryError('Removed-run recovery requires the exact registered merged issue.');
-    }
-    const headSha = git(root, 'rev-parse', `refs/heads/${row.branch}`);
-    const run = loadRun(gitCommonDir(root), headSha, row.path, true);
-    if (run.classification.head.sha !== headSha) {
-        throw new DeliveryError('Recovered merged run disagrees with the registered branch.');
-    }
-    return run;
-}
 const SourceDigest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
 const SourceSha = z.string().regex(/^[a-f0-9]{40}$/u);
 const SourceArtifactSchema = z.strictObject({ path: z.string().min(1), digest: SourceDigest });
@@ -2170,761 +1601,42 @@ const IssueSourcePhaseReceiptSchema = z.strictObject({
     source: SourceSnapshotSchema,
     commands: z.array(SourcePhaseCommandResultSchema),
 });
-function sourceFile(path) {
-    const stat = lstatSync(path);
-    if (!stat.isFile() || realpathSync(path) !== path)
-        throw new DeliveryError('Source-phase artifact must be a canonical regular file.');
-    const descriptor = openSync(path, 'r');
-    const hash = createHash('sha256');
-    try {
-        const buffer = Buffer.alloc(64 * 1024);
-        let bytes;
-        while ((bytes = readSync(descriptor, buffer, 0, buffer.length, null)) > 0)
-            hash.update(buffer.subarray(0, bytes));
-        const current = fstatSync(descriptor);
-        const named = lstatSync(path);
-        if (current.dev !== stat.dev ||
-            current.ino !== stat.ino ||
-            current.size !== stat.size ||
-            current.mode !== stat.mode ||
-            current.uid !== stat.uid ||
-            current.mtimeMs !== stat.mtimeMs ||
-            current.ctimeMs !== stat.ctimeMs ||
-            named.dev !== current.dev ||
-            named.ino !== current.ino ||
-            realpathSync(path) !== path)
-            throw new DeliveryError('Source-phase artifact changed during identity-bound hashing.');
-    }
-    finally {
-        closeSync(descriptor);
-    }
-    return {
-        path,
-        digest: `sha256:${hash.digest('hex')}`,
-        device: stat.dev,
-        inode: stat.ino,
-        uid: stat.uid,
-        mode: stat.mode,
-    };
-}
-function sourceDirty(root) {
-    const paths = [
-        ...new Set([
-            ...git(root, 'diff', '--cached', '--name-only', '-z').split('\0'),
-            ...git(root, 'ls-files', '-m', '-o', '--exclude-standard', '-z').split('\0'),
-        ].filter(Boolean)),
-    ].sort();
-    return paths.map((path) => {
-        const absolute = resolve(root, path);
-        if (!absolute.startsWith(`${root}${sep}`))
-            throw new DeliveryError('Source-phase dirty path escapes the worktree.');
-        try {
-            lstatSync(absolute);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return { path, digest: null };
-            throw error;
-        }
-        return { path, digest: sourceFile(absolute).digest };
-    });
-}
-function sourceReceipt(record) {
-    if (record.status !== 'complete' || record.result === undefined)
-        throw new DeliveryError('Source phase is not complete.');
-    return IssueSourcePhaseReceiptSchema.parse({
-        status: 'complete',
-        phaseId: record.phaseId,
-        recordId: record.recordId,
-        source: record.result.source,
-        commands: record.commands,
-    });
-}
-/** Run an authorized, frozen source graph under the registered issue's existing writer fence. */
-export async function withIssueSourcePhase(supplied, operation) {
-    const { signal, ...values } = supplied;
-    const input = IssueSourcePhaseInputSchema.parse(values);
-    assertResourceBounds(input.bounds);
-    if (signal?.aborted)
-        throw new DeliveryError('Source phase cancelled before preparation.');
-    const root = gitRoot(input.repoRoot);
-    if (root !== input.repoRoot ||
-        root !== primaryRoot(root) ||
-        realpathSync(input.source.path) !== input.source.path ||
-        gitCommonDir(root) !== gitCommonDir(input.source.path))
-        throw new DeliveryError('Source phase requires canonical primary controller and issue worktree roots.');
-    const row = getIssueWorktreeStrict(input.issueNumber, root);
-    assertAiDeliveryWorktreeOwner(row, root);
-    if (!row.identity ||
-        row.path !== input.source.path ||
-        row.branch !== input.source.branch ||
-        !['active', 'pr-published'].includes(row.status) ||
-        digestValue(row) !== input.rowDigest)
-        throw new DeliveryError('Source phase disagrees with the exact registered issue owner.');
-    const environment = { ...process.env };
-    delete environment[OUTPUT_GATE_ENV];
-    for (const [name, value] of Object.entries(input.environment.overrides)) {
-        if (name === OUTPUT_GATE_ENV)
-            throw new DeliveryError('Source phase cannot supply an output observer capability.');
-        if (value === null)
-            delete environment[name];
-        else
-            environment[name] = value;
-    }
-    Object.freeze(environment);
-    const { environment: _environment, ...bound } = input;
-    const binding = SourceBindingSchema.parse({ ...bound, environmentDigest: input.environment.digest });
-    const phaseId = digestValue(binding);
-    const subject = worktreeDigest(row.path);
-    const common = gitCommonDir(root);
-    const directory = join(common, 'ai-delivery', 'receipts', 'source-phase@1', subject.slice(7));
-    const path = join(directory, `${phaseId.slice(7)}.json`);
-    const writerPath = join(common, 'ai-delivery', 'writers@1', `${subject.slice(7)}.json`);
-    const roots = input.bounds.outputRoots.map((value) => resolve(root, value)).sort();
-    if (roots.some((value, index) => index > 0 && (value === roots[index - 1] || value.startsWith(`${roots[index - 1]}${sep}`))))
-        throw new DeliveryError('Source-phase output roots must not overlap.');
-    for (const required of [
-        directory,
-        writerPath,
-        join(common, 'ai-delivery', 'receipts'),
-        join(common, 'ai-delivery', 'output-observation', subject.slice(7)),
-    ]) {
-        if (!roots.some((value) => required === value || required.startsWith(`${value}${sep}`)))
-            throw new DeliveryError('Source-phase roots must account for writer, observer and SDK receipt metadata.');
-    }
-    const cancelled = new AbortController();
-    const combined = signal === undefined ? cancelled.signal : AbortSignal.any([signal, cancelled.signal]);
-    let record;
-    let baseline;
-    let reused = false;
-    let created = false;
-    let entered = false;
-    let startedCommand = false;
-    let validated = false;
-    let writerReleased = false;
-    let lockFailure;
-    let releaseFailure;
-    let operationFailure;
-    let accountingFailure;
-    let cleanupFailure;
-    let active;
-    let expired = false;
-    let captured = 0;
-    let bootstrapCharge = 0;
-    let previousBootstrap = 0;
-    let writerBootstrap = 0;
-    let predecessorChain = [];
-    let accountingBounds = input.bounds;
-    let protocolFailure;
-    let commandFailure;
-    const attempted = new Set();
-    let finalSource;
-    let artifacts = [];
-    let newBytes = 0;
-    const writerId = randomUUID();
-    const started = Date.now();
-    const message = (error) => (error instanceof Error ? error.message : String(error));
-    const persist = () => {
-        if (record === undefined)
-            throw new DeliveryError('Source-phase intent is unavailable.');
-        const { recordId: _recordId, ...content } = record;
-        record = SourcePhaseRecordSchema.parse({ ...content, recordId: digestValue(content) });
-        writePrivateJsonFileAtomically(path, record);
-    };
-    const readRecord = (file) => {
-        const value = SourcePhaseRecordSchema.parse(JSON.parse(assertPrivateFile(file).toString('utf8')));
-        if (value.worktreeDigest !== subject || basename(file) !== `${value.phaseId.slice(7)}.json`)
-            throw new DeliveryError('Source-phase record belongs to another input or worktree.');
-        return value;
-    };
-    const assertArtifact = (artifact) => {
-        if (sourceFile(artifact.path).digest !== artifact.digest)
-            throw new DeliveryError('Frozen source-phase input artifact changed.');
-    };
-    const sourceState = async (allowFinal = false) => {
-        const head = git(row.path, 'rev-parse', 'HEAD');
-        const branch = git(row.path, 'branch', '--show-current');
-        const dirty = sourceDirty(row.path);
-        const candidate = await loadDeliveryConfig(row.path);
-        const configDigest = head === input.source.head || input.source.effect.kind !== 'commitOnce'
-            ? input.source.configDigest
-            : (input.source.effect.configDigest ?? input.source.configDigest);
-        if (branch !== input.source.branch || candidate.configDigest !== configDigest)
-            throw new DeliveryError('Source-phase candidate branch or configuration changed.');
-        if (head === input.source.head) {
-            if (git(row.path, 'diff', '--cached', '--name-only', input.source.indexTree) !== '' ||
-                digestValue(dirty) !== digestValue(input.source.dirty))
-                throw new DeliveryError('Source-phase frozen index or dirty source changed.');
-            return { head, branch, indexTree: input.source.indexTree, configDigest: candidate.configDigest, dirty };
-        }
-        if (!allowFinal)
-            throw new DeliveryError('Source phase requires its exact initial source before new work.');
-        if (input.source.effect.kind !== 'commitOnce' ||
-            input.source.effect.parent !== input.source.head ||
-            git(row.path, 'rev-list', '--parents', '-n', '1', head) !== `${head} ${input.source.effect.parent}` ||
-            git(row.path, 'rev-parse', 'HEAD^{tree}') !== input.source.effect.tree ||
-            git(row.path, 'diff', '--cached', '--name-only', head) !== '' ||
-            dirty.length !== 0)
-            throw new DeliveryError('Source-phase commit does not match its exact parent, tree and clean postconditions.');
-        return { head, branch, indexTree: input.source.effect.tree, configDigest: candidate.configDigest, dirty };
-    };
-    let actor;
-    const validate = async (allowFinal = false) => {
-        const currentRow = getIssueWorktreeStrict(input.issueNumber, root);
-        assertAiDeliveryWorktreeOwner(currentRow, root);
-        const configuration = await loadDeliveryConfig(root);
-        const admission = await assertDeliveryRuntimeAdmitted({
-            repoRoot: root,
-            runtimeEntryPath: input.controller.runtimeEntryPath,
-            configuration,
-        });
-        if (dirname(realpathSync(input.controller.runtimeEntryPath)) !== dirname(realpathSync(fileURLToPath(import.meta.url))))
-            throw new DeliveryError('Source-phase executing SDK installation is not the selected admitted runtime.');
-        if (digestValue(currentRow) !== input.rowDigest ||
-            currentRow.identity !== row.identity ||
-            configuration.config.roles.author.identity !== input.identity ||
-            git(root, 'rev-parse', 'HEAD') !== input.controller.head ||
-            configuration.configDigest !== input.controller.configDigest ||
-            admission.admissionId !== input.controller.admissionId ||
-            admission.sourceArchiveSha256 !== input.controller.archiveDigest ||
-            admission.packageVersion !== input.controller.packageVersion ||
-            digestValue(environment) !== input.environment.digest ||
-            digestValue(input.commands) !== input.commandGraphDigest)
-            throw new DeliveryError('Source-phase controller, selected runtime, actor or command environment binding changed.');
-        const clients = await createDeliveryGitHubClients({
-            config: configuration.config,
-            identity: input.identity,
-            role: 'author',
-            env: environment,
+const RuntimeOutputLedgerSchema = z
+    .strictObject({
+    schemaVersion: z.literal('ai-delivery.runtime-output@1'),
+    stageId: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    worktreeDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    producerDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .safe()
+        .max(8 * 1024 ** 2),
+    outputs: z
+        .array(z.strictObject({
+        digest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+        bytes: z
+            .number()
+            .int()
+            .nonnegative()
+            .safe()
+            .max(8 * 1024 ** 2),
+        status: z.enum(['reserved', 'complete']),
+    }))
+        .max(4096),
+    contentDigest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+})
+    .superRefine((value, context) => {
+    const { contentDigest, ...content } = value;
+    if (contentDigest !== digestValue(content) ||
+        new Set(value.outputs.map((output) => output.digest)).size !== value.outputs.length ||
+        value.outputs.reduce((total, output) => total + output.bytes, 0) > value.limit)
+        context.addIssue({
+            code: 'custom',
+            message: 'Runtime retained-output ledger is corrupt.',
         });
-        if (clients.role !== 'author' || clients.authenticatedAuthor === undefined)
-            throw new DeliveryError('Source-phase configured author authentication is unavailable.');
-        const authenticated = await clients.authenticatedAuthor();
-        if (!authenticated.actorLogin || !authenticated.credentialIdentity)
-            throw new DeliveryError('Source-phase configured author identity readback is incomplete.');
-        const currentActor = { identity: input.identity, ...authenticated };
-        if (actor !== undefined && digestValue(actor) !== digestValue(currentActor))
-            throw new DeliveryError('Source-phase authenticated author changed.');
-        actor = currentActor;
-        for (const artifact of [input.caller, input.authorization, ...input.inputs])
-            assertArtifact(artifact);
-        for (const command of input.commands) {
-            if (command.cwd !== row.path ||
-                command.argv[0] !== command.executable.path ||
-                digestValue(sourceFile(command.executable.path)) !== digestValue(command.executable))
-                throw new DeliveryError('Source-phase command or executable identity changed.');
-        }
-        await sourceState(allowFinal);
-    };
-    const observe = async (finishing = false) => {
-        if (baseline === undefined)
-            throw new DeliveryError('Source-phase output baseline is unavailable.');
-        assertDiskHeadroom(row.path, accountingBounds, baseline);
-        newBytes = bootstrapCharge + captured + (await positiveNewOutputBytes(baseline, finishing ? undefined : combined));
-        if (newBytes > accountingBounds.maxNewOutputBytes)
-            throw new DeliveryError('Source-phase cumulative output exceeded its original allowance.');
-        if (process.memoryUsage().rss > accountingBounds.maxAggregateRssBytes)
-            throw new DeliveryError('Source-phase controller RSS exceeded its bound.');
-    };
-    try {
-        await withVerificationWriter(row.path, async (writer) => {
-            try {
-                ensurePrivateDirectoryDurably(directory);
-                if (created && record !== undefined) {
-                    record.binding = binding;
-                    record.allocation = input.bounds;
-                }
-                const names = readdirSync(directory);
-                if (names.length > 100_000)
-                    throw new DeliveryError('Source-phase record observation exceeded its entry bound.');
-                const history = names
-                    .map((name) => readRecord(join(directory, name)))
-                    .filter((value) => value.phaseId !== phaseId);
-                if (history.some((value) => ['preparing', 'intent', 'unresolved'].includes(value.status)))
-                    throw new DeliveryError('Unresolved source phase requires owning reconciliation before another attempt.');
-                const previous = input.reconciliation === undefined
-                    ? undefined
-                    : history.find((value) => value.phaseId === input.reconciliation?.phaseId && value.recordId === input.reconciliation.recordId);
-                const failed = history.filter((value) => ['failed-quiescent', 'rejected-before-work'].includes(value.status) &&
-                    !history.some((later) => later.retainedPredecessors.some((retained) => retained.phaseId === value.phaseId && retained.recordId === value.recordId)));
-                predecessorChain = [];
-                const visiting = new Set();
-                const retained = new Set();
-                const retain = (value) => {
-                    if (visiting.has(value))
-                        throw new DeliveryError('Source-phase predecessor cycle is invalid.');
-                    if (retained.has(value))
-                        return;
-                    visiting.add(value);
-                    predecessorChain.push(value);
-                    for (const link of value.retainedPredecessors) {
-                        const predecessor = history.find((candidate) => candidate.phaseId === link.phaseId && candidate.recordId === link.recordId);
-                        if (predecessor === undefined)
-                            throw new DeliveryError('Source-phase retained predecessor is unavailable.');
-                        retain(predecessor);
-                    }
-                    visiting.delete(value);
-                    retained.add(value);
-                };
-                for (const value of failed)
-                    retain(value);
-                if (record !== undefined && created)
-                    record.retainedPredecessors = failed.map(({ phaseId: retainedPhaseId, recordId }) => ({
-                        phaseId: retainedPhaseId,
-                        recordId,
-                    }));
-                previousBootstrap = predecessorChain.reduce((sum, value) => sum + value.bootstrapBytes, 0);
-                captured = predecessorChain.reduce((sum, value) => sum + value.capturedBytes, 0);
-                const allocations = predecessorChain.map((value) => {
-                    if (value.allocation === undefined)
-                        throw new DeliveryError('Source-phase retained predecessor lacks its original allocation.');
-                    return value.allocation;
-                });
-                const allocation = { ...(allocations[0] ?? input.bounds) };
-                for (const value of allocations) {
-                    allocation.maxAggregateRssBytes = Math.min(allocation.maxAggregateRssBytes, value.maxAggregateRssBytes);
-                    allocation.maxNewOutputBytes = Math.min(allocation.maxNewOutputBytes, value.maxNewOutputBytes);
-                    allocation.minFreeDiskBytes = Math.max(allocation.minFreeDiskBytes, value.minFreeDiskBytes);
-                }
-                accountingBounds = {
-                    ...allocation,
-                    maxAggregateRssBytes: Math.min(allocation.maxAggregateRssBytes, input.bounds.maxAggregateRssBytes),
-                    maxNewOutputBytes: Math.min(allocation.maxNewOutputBytes, input.bounds.maxNewOutputBytes),
-                    minFreeDiskBytes: Math.max(allocation.minFreeDiskBytes, input.bounds.minFreeDiskBytes),
-                };
-                const priorBaselines = predecessorChain.flatMap((value) => value.baseline === undefined ? [] : [value.baseline]);
-                const prior = priorBaselines[0];
-                if (created && record !== undefined) {
-                    record.allocation = allocation;
-                    if (prior !== undefined) {
-                        record.baseline = prior;
-                        baseline = {
-                            roots: prior.roots,
-                            files: new Map(prior.files),
-                            links: new Map(prior.links),
-                            baselineId: prior.baselineId,
-                        };
-                        for (const retained of [...predecessorChain, record])
-                            for (const [file, size] of retained.bootstrapFiles)
-                                baseline.files.set(file, Math.max(baseline.files.get(file) ?? 0, size));
-                    }
-                    bootstrapCharge = previousBootstrap + record.bootstrapBytes;
-                }
-                if (allocations.some((value) => digestValue(value.outputRoots) !== digestValue(allocation.outputRoots))) {
-                    accountingFailure = 'Source-phase retained original output roots disagree.';
-                    throw new DeliveryError(accountingFailure);
-                }
-                if (input.bounds.maxNewOutputBytes > allocation.maxNewOutputBytes ||
-                    input.bounds.maxAggregateRssBytes > allocation.maxAggregateRssBytes ||
-                    input.bounds.minFreeDiskBytes < allocation.minFreeDiskBytes ||
-                    digestValue(input.bounds.outputRoots) !== digestValue(allocation.outputRoots))
-                    throw new DeliveryError('Source-phase reconciliation cannot increase its original resource allowance.');
-                if (failed.length > 0 &&
-                    (previous === undefined ||
-                        !predecessorChain.includes(previous) ||
-                        input.reconciliation?.authorizationDigest !== input.authorization.digest))
-                    throw new DeliveryError('A failed source phase requires exact authorized retained-output reconciliation.');
-                if (input.reconciliation !== undefined && (previous === undefined || !predecessorChain.includes(previous)))
-                    throw new DeliveryError('Source-phase reconciliation does not name its exact terminal predecessor.');
-                if (prior !== undefined &&
-                    (priorBaselines.some((value) => value.baselineId !== prior.baselineId) ||
-                        input.reconciliation?.baselineId !== prior.baselineId ||
-                        digestValue(prior.roots) !== digestValue(roots)))
-                    throw new DeliveryError('Source-phase reconciliation cannot replace its original output baseline.');
-                for (const retained of predecessorChain.filter((value) => value.status === 'failed-quiescent')) {
-                    const old = retained.binding;
-                    if (old === undefined ||
-                        digestValue(old.controller) !== digestValue(input.controller) ||
-                        digestValue(old.source) !== digestValue(input.source) ||
-                        old.repoRoot !== root ||
-                        old.issueNumber !== input.issueNumber ||
-                        old.rowDigest !== input.rowDigest ||
-                        old.identity !== input.identity ||
-                        old.inputs.some((artifact) => !input.inputs.some((current) => digestValue(current) === digestValue(artifact))))
-                        throw new DeliveryError('Source-phase reconciliation requires compatible source/runtime and retained frozen inputs.');
-                    for (const artifact of [old.caller, old.authorization, ...old.inputs])
-                        assertArtifact(artifact);
-                }
-                if (predecessorChain.some((retained) => retained.retainedArtifacts?.some((artifact) => digestValue(sourceFile(artifact.path)) !== digestValue(artifact))))
-                    throw new DeliveryError('Source-phase retained output artifact identity changed before reconciliation.');
-                await validate(!created);
-                const executionProducer = producerDigest();
-                if (predecessorChain.some((value) => value.status === 'failed-quiescent' &&
-                    (value.producerDigest !== executionProducer || digestValue(value.actor) !== digestValue(actor))))
-                    throw new DeliveryError('Source-phase reconciliation requires its original authenticated actor and producer.');
-                if (!created) {
-                    record = readRecord(path);
-                    if (record.status !== 'complete' ||
-                        record.bindingDigest !== phaseId ||
-                        record.producerDigest !== executionProducer ||
-                        record.baseline === undefined ||
-                        record.result === undefined)
-                        throw new DeliveryError('Existing source phase is incomplete or belongs to another producer.');
-                    if (digestValue(actor) !== digestValue(record.actor) ||
-                        digestValue(await sourceState(true)) !== digestValue(record.result.source) ||
-                        record.result.artifacts.some((artifact) => digestValue(sourceFile(artifact.path)) !== digestValue(artifact)))
-                        throw new DeliveryError('Completed source-phase source or artifacts changed.');
-                    reused = true;
-                    return;
-                }
-                validated = true;
-                if (record === undefined)
-                    throw new DeliveryError('Source phase lacks preparation intent.');
-                record.binding = binding;
-                record.producerDigest = executionProducer;
-                record.actor = actor;
-                await withOutputObservationGate(row.path, true, async (gate) => {
-                    const gatePath = gate === undefined ? undefined : join(gate.directory, 'gate.json');
-                    if (gatePath !== undefined) {
-                        const gateBytes = lstatSync(gatePath).size;
-                        record.bootstrapBytes += gateBytes;
-                        record.bootstrapFiles.push([gatePath, gateBytes]);
-                    }
-                    bootstrapCharge = previousBootstrap + record.bootstrapBytes;
-                    const links = new Map();
-                    const files = prior === undefined
-                        ? await withOutputGateLock(gate, 'scan', () => scanOutputRoots(roots, links), combined)
-                        : new Map(prior.files);
-                    if (prior !== undefined)
-                        for (const [name, alias] of prior.links)
-                            links.set(name, alias);
-                    const content = { roots, files: [...files], links: [...links] };
-                    const persistedBaseline = prior ?? { ...content, baselineId: digestValue(content) };
-                    baseline = {
-                        roots,
-                        files,
-                        links,
-                        baselineId: persistedBaseline.baselineId,
-                        ...(gate === undefined ? {} : { gate }),
-                    };
-                    record.baseline = persistedBaseline;
-                    for (const retained of [...predecessorChain, record])
-                        for (const [file, size] of retained.bootstrapFiles)
-                            baseline.files.set(file, Math.max(baseline.files.get(file) ?? 0, size));
-                    record.status = 'intent';
-                    persist();
-                    await observe();
-                    let callbackFailure;
-                    let callbackRejected = false;
-                    const run = (index) => {
-                        if (expired)
-                            return Promise.reject(new DeliveryError('Source-phase command capability has expired.'));
-                        if (!Number.isSafeInteger(index) ||
-                            index !== record.nextCommandIndex ||
-                            attempted.has(index) ||
-                            active !== undefined ||
-                            index >= input.commands.length) {
-                            protocolFailure = 'Source-phase commands must be ordered, single-use and awaited.';
-                            cancelled.abort(new DeliveryError(protocolFailure));
-                            return Promise.reject(new DeliveryError(protocolFailure));
-                        }
-                        attempted.add(index);
-                        const command = input.commands[index];
-                        active = (async () => {
-                            let commandCaptured = 0;
-                            try {
-                                await validate(true);
-                                await observe();
-                                writer.assertQuiescent();
-                                startedCommand = true;
-                                const output = await runStageCommand(command.cwd, command.argv, combined, (bytes, sample, reason) => reportVerificationProgress({
-                                    state: 'running',
-                                    stageId: 'source-phase',
-                                    completedStages: index,
-                                    remainingStages: input.commands.length - index,
-                                    reusedStages: 0,
-                                    elapsedMs: Date.now() - started,
-                                    capturedOutputBytes: bytes,
-                                    ...(sample === undefined ? {} : { sampledNewOutputBytes: sample.newOutputBytes }),
-                                    ...(reason === undefined ? {} : { reason }),
-                                }), { ...input.bounds, maxNewOutputBytes: input.bounds.maxNewOutputBytes - bootstrapCharge - captured }, baseline, undefined, writer, {
-                                    environment,
-                                    onCaptured: (bytes) => {
-                                        commandCaptured = bytes;
-                                    },
-                                    onCleanupFailure: (reason) => {
-                                        cleanupFailure = reason;
-                                    },
-                                });
-                                record.commands.push({
-                                    index,
-                                    outputDigest: digestBytes(output),
-                                    outputBytes: output.length,
-                                    status: 'complete',
-                                });
-                                record.nextCommandIndex += 1;
-                                return output;
-                            }
-                            catch (error) {
-                                commandFailure = message(error);
-                                record.commands.push({ index, outputDigest: null, outputBytes: commandCaptured, status: 'failed' });
-                                throw error;
-                            }
-                            finally {
-                                captured += commandCaptured;
-                                record.capturedBytes += commandCaptured;
-                                active = undefined;
-                                persist();
-                            }
-                        })();
-                        return active;
-                    };
-                    entered = true;
-                    try {
-                        if (actor === undefined)
-                            throw new DeliveryError('Source-phase authenticated author is unavailable.');
-                        const source = await sourceState();
-                        await operation(Object.freeze({
-                            phaseId,
-                            signal: combined,
-                            source: Object.freeze({
-                                ...source,
-                                dirty: Object.freeze(source.dirty.map((entry) => Object.freeze(entry))),
-                            }),
-                            controller: Object.freeze({ ...input.controller }),
-                            actor: Object.freeze({ ...actor }),
-                            inputs: Object.freeze([input.caller, input.authorization, ...input.inputs].map((artifact) => Object.freeze({ ...artifact }))),
-                            run,
-                        }));
-                    }
-                    catch (error) {
-                        callbackRejected = true;
-                        callbackFailure = error;
-                    }
-                    expired = true;
-                    if (active !== undefined) {
-                        protocolFailure = 'Source-phase callback settled with an unawaited command.';
-                        cancelled.abort(new DeliveryError(protocolFailure));
-                        await active.catch(() => undefined);
-                    }
-                    if (callbackRejected)
-                        throw callbackFailure;
-                    if (protocolFailure !== undefined)
-                        throw new DeliveryError(protocolFailure);
-                    if (commandFailure !== undefined)
-                        throw new DeliveryError(commandFailure);
-                    if (combined.aborted)
-                        throw new DeliveryError('Source phase cancelled.');
-                    if (record.nextCommandIndex !== input.commands.length)
-                        throw new DeliveryError('Source-phase callback did not complete its frozen graph.');
-                    await validate(true);
-                    finalSource = await sourceState(true);
-                    if (input.source.effect.kind === 'commitOnce' && finalSource.head === input.source.head)
-                        throw new DeliveryError('Source phase did not publish its required commit.');
-                    artifacts = input.completionArtifacts.map(sourceFile);
-                    writer.assertQuiescent();
-                    await observe();
-                }).finally(() => {
-                    if (baseline !== undefined)
-                        delete baseline.gate;
-                });
-            }
-            catch (error) {
-                operationFailure = message(error);
-            }
-            finally {
-                expired = true;
-                if (active !== undefined) {
-                    cancelled.abort(new DeliveryError('Source phase is releasing its command capability.'));
-                    await active.catch((error) => {
-                        operationFailure ??= message(error);
-                    });
-                }
-                if (created && baseline !== undefined) {
-                    try {
-                        await observe(true);
-                    }
-                    catch (error) {
-                        accountingFailure = message(error);
-                    }
-                }
-            }
-        }, {
-            repoRoot: root,
-            worktreePath: row.path,
-            writerId,
-            beforeClaim: ({ previousBytes }) => {
-                if (previousBytes !== undefined)
-                    throw new DeliveryError('Source phase requires an absent writer; it never recovers a prior command.');
-            },
-            recordClaim: (bytes) => {
-                ensurePrivateDirectoryDurably(directory);
-                if (existsSync(path))
-                    return;
-                created = true;
-                writerBootstrap = bytes.length;
-                const content = {
-                    schemaVersion: 'ai-delivery.source-phase@1',
-                    phaseId,
-                    bindingDigest: phaseId,
-                    authorizationDigest: input.authorization.digest,
-                    worktreeDigest: subject,
-                    status: 'preparing',
-                    writerId,
-                    bootstrapBytes: bytes.length,
-                    allocation: input.bounds,
-                    capturedBytes: 0,
-                    nextCommandIndex: 0,
-                    owner: JSON.parse(bytes.toString('utf8')).owner,
-                    bootstrapFiles: [],
-                    commands: [],
-                    retainedPredecessors: [],
-                    claimDigest: digestBytes(bytes),
-                    ...(input.reconciliation === undefined ? {} : { reconciliation: input.reconciliation }),
-                };
-                record = { ...content, recordId: digestValue(content) };
-                persist();
-                record.preparationArtifact = sourceFile(path);
-                record.bootstrapFiles.push([path, lstatSync(path).size]);
-                for (let index = 0; index < 4; index++) {
-                    const size = Buffer.byteLength(`${JSON.stringify(record, null, 2)}\n`);
-                    record.bootstrapFiles[0] = [path, size];
-                    record.bootstrapBytes = writerBootstrap + size;
-                }
-                persist();
-            },
-            afterClaim: () => {
-                if (record !== undefined && created)
-                    record.writerArtifact = sourceFile(writerPath);
-            },
-            recordRelease: (bytes) => {
-                if (record !== undefined && !reused)
-                    record.releaseDigest = digestBytes(bytes);
-            },
-            afterRelease: () => {
-                writerReleased = true;
-            },
-            onLockReleaseError: (error) => {
-                lockFailure = message(error);
-            },
-            onLockCompromised: (error) => {
-                lockFailure = message(error);
-                cancelled.abort(error);
-            },
-        }, common, true);
-    }
-    catch (error) {
-        releaseFailure = message(error);
-    }
-    if (reused &&
-        record !== undefined &&
-        writerReleased &&
-        lockFailure === undefined &&
-        releaseFailure === undefined &&
-        operationFailure === undefined)
-        return sourceReceipt(record);
-    if (record === undefined || !created)
-        throw new DeliveryError(operationFailure ?? releaseFailure ?? 'Source-phase ownership could not be established.');
-    const failures = {
-        ...(operationFailure === undefined ? {} : { operation: operationFailure }),
-        ...(accountingFailure === undefined ? {} : { accounting: accountingFailure }),
-        ...(cleanupFailure === undefined ? {} : { cleanup: cleanupFailure }),
-        ...(writerReleased && releaseFailure === undefined
-            ? {}
-            : { writerRelease: releaseFailure ?? 'Writer absence was not confirmed.' }),
-        ...(lockFailure === undefined ? {} : { lockRelease: lockFailure }),
-    };
-    const quiescent = writerReleased && releaseFailure === undefined && lockFailure === undefined && cleanupFailure === undefined;
-    let unchanged = false;
-    if (validated) {
-        try {
-            await validate(finalSource !== undefined);
-            unchanged = (await sourceState(finalSource !== undefined)).head === input.source.head;
-            if (finalSource !== undefined &&
-                (existsSync(writerPath) ||
-                    artifacts.some((artifact) => digestValue(sourceFile(artifact.path)) !== digestValue(artifact))))
-                throw new DeliveryError('Source-phase writer absence or completion artifact changed before sealing.');
-        }
-        catch (error) {
-            unchanged = false;
-            if (finalSource !== undefined)
-                failures.operation ??= message(error);
-        }
-    }
-    const successful = Object.keys(failures).length === 0 && finalSource !== undefined;
-    record.status = successful
-        ? 'complete'
-        : !entered && !startedCommand && quiescent && accountingFailure === undefined
-            ? 'rejected-before-work'
-            : quiescent && unchanged && accountingFailure === undefined && baseline !== undefined
-                ? 'failed-quiescent'
-                : 'unresolved';
-    if (successful && finalSource !== undefined)
-        record.result = {
-            source: finalSource,
-            artifacts,
-            newOutputBytes: newBytes,
-            writerReleased: true,
-            lockReleased: true,
-        };
-    else
-        record.failure = failures;
-    if (record.status === 'failed-quiescent' && baseline !== undefined) {
-        try {
-            const files = scanOutputRoots(baseline.roots, new Map());
-            record.retainedArtifacts = [...files]
-                .filter(([file, bytes]) => file !== path && bytes > (baseline.files.get(file) ?? 0))
-                .map(([file]) => sourceFile(file));
-        }
-        catch (error) {
-            record.status = 'unresolved';
-            record.failure = { ...failures, accounting: message(error) };
-        }
-    }
-    if (baseline !== undefined) {
-        try {
-            await observe(true);
-            const originalSize = baseline.files.get(path) ?? 0;
-            const currentGrowth = Math.max(0, lstatSync(path).size - originalSize);
-            const observed = newBytes;
-            let projected = observed;
-            for (let index = 0; index < 4; index++) {
-                if (record.result !== undefined)
-                    record.result.newOutputBytes = projected;
-                const { recordId: _recordId, ...content } = record;
-                record.recordId = digestValue(content);
-                projected =
-                    observed -
-                        currentGrowth +
-                        Math.max(0, Buffer.byteLength(`${JSON.stringify(record, null, 2)}\n`) - originalSize);
-            }
-            if (projected > accountingBounds.maxNewOutputBytes)
-                throw new DeliveryError('Source-phase final receipt exceeds its original output allowance.');
-            if (record.result !== undefined)
-                record.result.newOutputBytes = projected;
-        }
-        catch (error) {
-            record.status = 'unresolved';
-            delete record.result;
-            record.failure = { ...failures, accounting: message(error) };
-        }
-    }
-    else {
-        for (let index = 0; index < 4; index++) {
-            const size = Buffer.byteLength(`${JSON.stringify(record, null, 2)}\n`);
-            record.bootstrapFiles[0] = [path, size];
-            record.bootstrapBytes =
-                writerBootstrap + size + record.bootstrapFiles.slice(1).reduce((sum, [, bytes]) => sum + bytes, 0);
-        }
-        if (previousBootstrap + record.bootstrapBytes + captured > accountingBounds.maxNewOutputBytes) {
-            record.status = 'unresolved';
-            record.failure = {
-                ...failures,
-                accounting: 'Retained rejected bootstrap exceeded the original output allowance.',
-            };
-            for (let index = 0; index < 4; index++) {
-                const size = Buffer.byteLength(`${JSON.stringify(record, null, 2)}\n`);
-                record.bootstrapFiles[0] = [path, size];
-                record.bootstrapBytes =
-                    writerBootstrap + size + record.bootstrapFiles.slice(1).reduce((sum, [, bytes]) => sum + bytes, 0);
-            }
-        }
-    }
-    persist();
-    if (record.status !== 'complete')
-        throw new DeliveryError(`Source phase ${record.status}: ${operationFailure ?? accountingFailure ?? releaseFailure ?? lockFailure ?? failures.operation ?? 'postconditions failed'}.`, path);
-    return sourceReceipt(record);
-}
+});
 /** @internal Runtime setup shares the existing writer, ownership handshake and bounded command runner. */
 export async function withRuntimeSetupWriter(root, operation, scope) {
     const cancellation = new AbortController();
@@ -2956,6 +1668,121 @@ export async function withRuntimeSetupWriter(root, operation, scope) {
     }
     root = gitRoot(root);
     return withVerificationWriter(root, async (writer) => withOutputObservationGate(root, scope !== undefined, async (scopeGate) => {
+        let ledger;
+        let ledgerPath;
+        const common = gitCommonDir(root);
+        const saveLedger = () => {
+            if (ledger === undefined || ledgerPath === undefined)
+                throw new DeliveryError('Runtime output allowance is unbound.');
+            const { contentDigest: _previous, ...content } = ledger;
+            ledger = RuntimeOutputLedgerSchema.parse({
+                ...content,
+                contentDigest: digestValue(content),
+            });
+            if (Buffer.byteLength(JSON.stringify(ledger, null, 2)) > 1024 ** 2)
+                throw new DeliveryError('Runtime retained-output ledger exceeds its evidence bound.');
+            writePrivateJsonFileAtomically(ledgerPath, ledger);
+        };
+        const assertOutput = (output) => {
+            try {
+                const bytes = readRepositoryCommandOutput({
+                    gitCommonDir: common,
+                    digest: output.digest,
+                    expectedBytes: output.bytes,
+                });
+                if (bytes.length !== output.bytes)
+                    throw new DeliveryError('Runtime retained-output evidence size changed.');
+                return true;
+            }
+            catch (error) {
+                if (output.status === 'reserved' && error.code === 'ENOENT')
+                    return false;
+                throw error;
+            }
+        };
+        const bindCapturedOutput = (stageId) => {
+            if (scope === undefined)
+                return;
+            if (ledger !== undefined)
+                throw new DeliveryError('Runtime output allowance is already bound.');
+            const identity = {
+                stageId,
+                worktreeDigest: worktreeDigest(root),
+                producerDigest: producerDigest(),
+                limit: scope.maxCapturedOutputBytes,
+            };
+            ledgerPath = join(common, 'ai-delivery', 'verification@1', 'runtime-output', identity.worktreeDigest.slice(7), `${stageId.slice(7)}.json`);
+            let retained;
+            try {
+                retained = assertPrivateFile(ledgerPath, { maxBytes: 1024 ** 2 });
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            if (retained !== undefined) {
+                ledger = RuntimeOutputLedgerSchema.parse(JSON.parse(retained.toString('utf8')));
+                if (ledger.stageId !== identity.stageId ||
+                    ledger.worktreeDigest !== identity.worktreeDigest ||
+                    ledger.producerDigest !== identity.producerDigest ||
+                    ledger.limit !== identity.limit)
+                    throw new DeliveryError('Runtime retained-output ledger belongs to an incompatible stage or controller.');
+                let recovered = false;
+                for (const output of ledger.outputs) {
+                    if (assertOutput(output) && output.status === 'reserved') {
+                        output.status = 'complete';
+                        recovered = true;
+                    }
+                }
+                if (recovered)
+                    saveLedger();
+            }
+            else {
+                const content = {
+                    schemaVersion: 'ai-delivery.runtime-output@1',
+                    ...identity,
+                    outputs: [],
+                };
+                ledger = RuntimeOutputLedgerSchema.parse({
+                    ...content,
+                    contentDigest: digestValue(content),
+                });
+                saveLedger();
+            }
+        };
+        const remainingOutput = () => {
+            if (scope === undefined)
+                return 8 * 1024 ** 2;
+            if (ledger === undefined)
+                throw new DeliveryError('Runtime output allowance is unbound.');
+            return ledger.limit - ledger.outputs.reduce((total, output) => total + output.bytes, 0);
+        };
+        const persistFailedOutput = (bytes) => {
+            if (ledger === undefined)
+                throw new DeliveryError('Runtime output allowance is unbound.');
+            const digest = digestBytes(bytes);
+            const prior = ledger.outputs.find((output) => output.digest === digest);
+            if (prior !== undefined) {
+                if (prior.bytes !== bytes.length || !assertOutput(prior))
+                    throw new DeliveryError('Runtime retained-output reservation is unresolved; identical output cannot be rewritten.');
+                return ` Command output ${digest}.`;
+            }
+            if (bytes.length > remainingOutput())
+                throw new DeliveryError('Runtime retained-output allowance exceeded.');
+            const output = {
+                digest,
+                bytes: bytes.length,
+                status: 'reserved',
+            };
+            ledger.outputs.push(output);
+            saveLedger();
+            writeRepositoryCommandOutput({ bytes, gitCommonDir: common });
+            if (!assertOutput(output))
+                throw new DeliveryError('Runtime retained-output publication is unresolved.');
+            ledger.outputs[ledger.outputs.length - 1].status = 'complete';
+            saveLedger();
+            return ` Command output ${digest}.`;
+        };
         if (scope !== undefined) {
             const paths = [...(scope.bounds.outputRoots ?? []), join(gitCommonDir(root), 'ai-delivery')]
                 .map((path) => resolve(root, path))
@@ -3008,6 +1835,7 @@ export async function withRuntimeSetupWriter(root, operation, scope) {
         try {
             const result = await operation({
                 assertQuiescent: () => writer.assertQuiescent(),
+                bindCapturedOutput,
                 checkResources,
                 signal,
                 run: async (argv, bounds, commandSignal, environment, cwd) => {
@@ -3020,6 +1848,9 @@ export async function withRuntimeSetupWriter(root, operation, scope) {
                                 throw new DeliveryError('Filesystem output roots must not overlap.');
                     }
                     const run = async (gate) => {
+                        const remaining = remainingOutput();
+                        if (remaining <= 0)
+                            throw new DeliveryError('Runtime retained-output allowance is exhausted; installer was not started.');
                         const links = new Map();
                         const files = roots === undefined
                             ? undefined
@@ -3058,7 +1889,11 @@ export async function withRuntimeSetupWriter(root, operation, scope) {
                                 ...(cwd === undefined ? {} : { cwd }),
                                 ...(scope === undefined
                                     ? {}
-                                    : { maxCapturedOutputBytes: scope.maxCapturedOutputBytes, includeControllerTree: true }),
+                                    : {
+                                        maxCapturedOutputBytes: remaining,
+                                        includeControllerTree: true,
+                                        failedOutput: persistFailedOutput,
+                                    }),
                                 onCaptured: (bytes) => {
                                     captured += bytes - commandCaptured;
                                     commandCaptured = bytes;