codex-orchestrator 2.0.10 → 2.0.11

package/dist/src/v2/contained-report-operation.js

@@ -1,9 +1,4 @@
-import { canonicalJson, containsCredentialEvidence, sha256 } from './containment.js';
-import { decodeAgentReportForValidation } from './report-envelope.js';
-import { hashCodeReviewReport, validateCodeReviewReport, } from './code-review-report.js';
-import { hashAmbiguityReviewArtifact, hashTriageArtifact, validateAmbiguityReviewArtifact, } from './route-decision.js';
-import { validateTriageRoute } from './triage-route.js';
-const MAX_STRING_LENGTH = 16 * 1024;
+import { canonicalJson, sha256 } from './containment.js';
 const POLICY_KEYS = [
     'sandboxMode', 'cwdClass', 'worktreeAccess', 'writableRootClasses', 'runnerPostcondition',
     'network', 'networkHosts', 'mcpTools', 'approvalCeiling', 'externalWrite',
@@ -14,171 +9,494 @@ export class InjectedContainedReportOperation {
         this.dependencies = dependencies;
     }
     async run(input) {
-        let before;
+        const existing = await input.invocationState.read();
+        if (existing)
+            return this.recover(input, validateDurableReportInvocation(existing));
+        return this.launch(input);
+    }
+    async launch(input) {
+        let baseline;
         try {
-            before = requireReportSnapshot(await this.dependencies.snapshot(input.worktreePath));
+            baseline = requireReportSnapshot(await this.dependencies.snapshot(input.worktreePath, input.operation));
         }
         catch {
-            return { status: 'blocked', kind: 'safety', code: 'report-operation-snapshot-failed' };
+            return blocked('safety', 'report-operation-snapshot-failed');
         }
+        const attemptId = this.dependencies.createAttemptId();
+        if (!attemptId || input.forbiddenAttemptIds?.includes(attemptId))
+            return blocked('safety', 'report-operation-attempt-identity-invalid');
         let attempt;
         try {
-            attempt = await this.dependencies.prepare({
-                operation: input.operation,
-                attemptId: input.attemptId,
-                runId: input.runId,
-                workflowGeneration: input.workflowGeneration,
+            attempt = await this.prepare(input, attemptId);
+        }
+        catch (error) {
+            return error instanceof ReportAuthorityError
+                ? blocked('safety', 'report-operation-authority-drift')
+                : blocked('external', 'report-operation-prepare-failed');
+        }
+        const prepared = {
+            version: 1, operation: input.operation, attemptId, generationHash: input.workflowGeneration.generationHash,
+            promptFactsSha256: promptFactsSha256(input.promptFacts),
+            reportPath: attempt.reportPath, phase: 'prepared', host: this.dependencies.host, bootId: this.dependencies.bootId,
+            preparedAt: this.dependencies.now(), launchedAt: null, pid: null, processStartIdentity: null,
+            processGroupId: null, baseline,
+        };
+        if (!await input.invocationState.compareAndSwap(undefined, prepared))
+            return blocked('safety', 'report-operation-state-conflict');
+        let current = prepared;
+        let result;
+        try {
+            await input.beforeLaunch?.();
+        }
+        catch (error) {
+            const abandoned = await this.abandon(input, current, attempt);
+            if (abandoned)
+                return abandoned;
+            throw error;
+        }
+        try {
+            result = await this.dependencies.launch({
+                ...input,
+                attempt,
+                onSpawned: async ({ pid, processGroupId }) => {
+                    const processStartIdentity = await this.dependencies.processStartIdentity(pid);
+                    if (!processStartIdentity)
+                        throw new Error('report process identity unavailable');
+                    const launched = {
+                        ...prepared, phase: 'launched', launchedAt: this.dependencies.now(), pid, processStartIdentity, processGroupId,
+                    };
+                    if (!await input.invocationState.compareAndSwap(prepared, launched))
+                        throw new Error('report launch state conflict');
+                    current = launched;
+                },
             });
         }
         catch {
-            return this.finishWithSnapshot(input.worktreePath, before, {
-                status: 'blocked', kind: 'external', code: 'report-operation-prepare-failed',
-            });
+            result = { status: 'retryable', code: 'report-operation-launch-failed' };
         }
-        let launchResult;
-        if (!hasExactReadOnlyAuthority(attempt, input)) {
-            launchResult = { status: 'blocked', kind: 'safety', code: 'report-operation-authority-drift' };
-        }
-        else {
-            if (isImplementationReview(input.operation)) {
-                if (!input.reviewContext || !input.onPrepared || !input.onLaunched) {
-                    return this.finishWithSnapshot(input.worktreePath, before, {
-                        status: 'blocked', kind: 'safety', code: 'review-operation-launch-gate-missing',
-                    });
-                }
-                try {
-                    await input.onPrepared();
-                }
-                catch {
-                    return this.finishWithSnapshot(input.worktreePath, before, {
-                        status: 'blocked', kind: 'safety', code: 'review-operation-prepare-persistence-failed',
-                    });
-                }
-            }
-            try {
-                launchResult = await this.dependencies.launch({ ...input, attempt });
-            }
-            catch {
-                launchResult = { status: 'blocked', kind: 'external', code: 'report-operation-launch-failed' };
+        if (result.status === 'completed')
+            return this.finish(input, current, attempt, result.reportBytes);
+        if (result.status === 'safe-halt')
+            return { status: 'safe-halt', code: 'report-operation-process-unresolved' };
+        if (result.status === 'cancelled' || result.status === 'blocked') {
+            const abandoned = await this.abandon(input, current, attempt);
+            if (abandoned)
+                return abandoned;
+            return result;
+        }
+        const recovered = await this.observeReport(current.reportPath);
+        if (recovered.status === 'unknown')
+            return { status: 'safe-halt', code: 'report-operation-report-observation-unknown' };
+        if (recovered.status === 'available')
+            return this.finish(input, current, attempt, recovered.bytes);
+        const abandoned = await this.abandon(input, current, attempt);
+        if (abandoned)
+            return abandoned;
+        return result;
+    }
+    async recover(input, invocation) {
+        if (invocation.operation !== input.operation || invocation.generationHash !== input.workflowGeneration.generationHash
+            || invocation.host !== this.dependencies.host || invocation.bootId !== this.dependencies.bootId) {
+            return { status: 'safe-halt', code: 'report-operation-owner-identity-unresolved' };
+        }
+        if (invocation.promptFactsSha256 !== promptFactsSha256(input.promptFacts)) {
+            return { status: 'safe-halt', code: 'report-operation-prompt-facts-drift' };
+        }
+        let attempt;
+        try {
+            attempt = await this.prepare(input, invocation.attemptId);
+        }
+        catch (error) {
+            return error instanceof ReportAuthorityError
+                ? blocked('safety', 'report-operation-authority-drift')
+                : blocked('external', 'report-operation-prepare-failed');
+        }
+        if (attempt.reportPath !== invocation.reportPath)
+            return blocked('safety', 'report-operation-report-path-drift');
+        const report = await this.observeReport(invocation.reportPath);
+        if (report.status === 'unknown')
+            return { status: 'safe-halt', code: 'report-operation-report-observation-unknown' };
+        if (invocation.phase === 'prepared') {
+            if (report.status === 'available')
+                return this.finish(input, invocation, attempt, report.bytes);
+            if (!await this.settleAttempt(attempt))
+                return { status: 'safe-halt', code: 'report-operation-attempt-cleanup-failed' };
+            if (!await input.invocationState.compareAndSwap(invocation, undefined))
+                return blocked('safety', 'report-operation-state-conflict');
+            return { status: 'retryable', code: 'report-operation-prepared-attempt-abandoned' };
+        }
+        const unresolved = await this.unresolvedProcess(invocation);
+        if (unresolved)
+            return unresolved;
+        if (report.status === 'available')
+            return this.finish(input, invocation, attempt, report.bytes);
+        if (!await this.settleAttempt(attempt))
+            return { status: 'safe-halt', code: 'report-operation-attempt-cleanup-failed' };
+        if (!await input.invocationState.compareAndSwap(invocation, undefined))
+            return blocked('safety', 'report-operation-state-conflict');
+        return { status: 'retryable', code: 'report-operation-output-unavailable' };
+    }
+    async abandon(input, invocation, attempt) {
+        if (invocation.phase === 'launched') {
+            const unresolved = await this.unresolvedProcess(invocation);
+            if (unresolved)
+                return unresolved;
+        }
+        if (!await this.settleAttempt(attempt))
+            return { status: 'safe-halt', code: 'report-operation-attempt-cleanup-failed' };
+        if (!await input.invocationState.compareAndSwap(invocation, undefined))
+            return blocked('safety', 'report-operation-state-conflict');
+        return undefined;
+    }
+    async observeReport(path) {
+        try {
+            return await this.dependencies.readReport(path);
+        }
+        catch {
+            return { status: 'unknown' };
+        }
+    }
+    async unresolvedProcess(invocation) {
+        const observed = await this.dependencies.inspectProcess(invocation).catch(() => ({ status: 'unknown' }));
+        if (observed.status === 'unknown')
+            return { status: 'safe-halt', code: 'report-operation-process-observation-unknown' };
+        if (observed.status === 'present' && (observed.processStartIdentity === invocation.processStartIdentity || observed.processGroupAlive !== false)) {
+            return { status: 'safe-halt', code: 'report-operation-process-active-or-uncertain' };
+        }
+        return observed.status === 'absent' && observed.processGroupAlive !== false
+            ? { status: 'safe-halt', code: 'report-operation-process-group-unresolved' } : undefined;
+    }
+    async settleAttempt(attempt) {
+        try {
+            await this.dependencies.settleAttempt(attempt);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async prepare(input, attemptId) {
+        const attempt = await this.dependencies.prepare({
+            operation: input.operation, attemptId, runId: input.runId, workflowGeneration: input.workflowGeneration,
+        });
+        if (!hasExactReportAuthority(attempt, input) || !attempt.reportPath)
+            throw new ReportAuthorityError();
+        return attempt;
+    }
+    async finish(input, invocation, attempt, reportBytes) {
+        let after;
+        try {
+            after = requireReportSnapshot(await this.dependencies.snapshot(input.worktreePath, input.operation));
+        }
+        catch {
+            return blocked('safety', 'report-operation-snapshot-failed');
+        }
+        if (canonicalJson(invocation.baseline) !== canonicalJson(after))
+            return blocked('safety', 'report-operation-worktree-mutated');
+        if (!await this.settleAttempt(attempt))
+            return { status: 'safe-halt', code: 'report-operation-attempt-cleanup-failed' };
+        return { status: 'completed', attemptId: invocation.attemptId, reportBytes: Buffer.from(reportBytes), reportSha256: sha256(reportBytes) };
+    }
+}
+export class InjectedContainedMutableOperation {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async run(input) {
+        const existing = await input.invocationState.read();
+        return existing ? this.recover(input, validateDurableMutableInvocation(existing)) : this.launch(input);
+    }
+    async settle(input) {
+        const existing = await input.invocationState.read();
+        if (!existing)
+            return { status: 'settled' };
+        const recovered = await this.recover(input, validateDurableMutableInvocation(existing));
+        if (recovered.status === 'retryable') {
+            return await input.invocationState.read() === undefined
+                ? { status: 'settled' }
+                : { status: 'safe-halt', code: 'mutable-operation-state-conflict' };
+        }
+        if (recovered.status === 'completed') {
+            const adopted = await input.invocationState.read();
+            if (!adopted || adopted.attemptId !== recovered.attemptId || adopted.phase !== 'adopted') {
+                return { status: 'safe-halt', code: 'mutable-operation-state-conflict' };
             }
+            return await input.invocationState.compareAndSwap(adopted, undefined)
+                ? { status: 'settled' }
+                : { status: 'safe-halt', code: 'mutable-operation-state-conflict' };
         }
-        if (launchResult.status === 'safe-halt') {
-            return {
-                status: 'safe-halt',
-                process: {
-                    pid: launchResult.pid,
-                    processGroupId: launchResult.processGroupId,
-                    startedAt: launchResult.startedAt,
-                    baseline: structuredClone(before),
+        return { status: 'safe-halt', code: recovered.status === 'cancelled'
+                ? 'mutable-operation-settlement-cancelled' : recovered.code };
+    }
+    async launch(input) {
+        let baseline;
+        try {
+            baseline = requireReportSnapshot(await this.dependencies.snapshot(input.worktreePath));
+        }
+        catch {
+            return blocked('safety', 'mutable-operation-snapshot-failed');
+        }
+        const attemptId = this.dependencies.createAttemptId();
+        if (!attemptId)
+            return blocked('safety', 'mutable-operation-attempt-identity-invalid');
+        let attempt;
+        try {
+            attempt = await this.prepare(input, attemptId);
+        }
+        catch (error) {
+            return error instanceof ReportAuthorityError
+                ? blocked('safety', 'mutable-operation-authority-drift') : blocked('external', 'mutable-operation-prepare-failed');
+        }
+        const prepared = {
+            version: 1, operation: input.operation, attemptId, generationHash: input.workflowGeneration.generationHash,
+            promptFactsSha256: promptFactsSha256(input.promptFacts), worktreePath: input.worktreePath, reportPath: attempt.reportPath,
+            context: structuredClone(input.context),
+            phase: 'prepared', host: this.dependencies.host, bootId: this.dependencies.bootId, preparedAt: this.dependencies.now(),
+            launchedAt: null, pid: null, processStartIdentity: null, processGroupId: null, baseline, reportSha256: null, resultSnapshot: null,
+        };
+        if (!await input.invocationState.compareAndSwap(undefined, prepared))
+            return blocked('safety', 'mutable-operation-state-conflict');
+        let current = prepared;
+        let result;
+        try {
+            await input.beforeLaunch?.();
+            result = await this.dependencies.launch({
+                ...input, attempt,
+                onSpawned: async ({ pid, processGroupId }) => {
+                    const processStartIdentity = await this.dependencies.processStartIdentity(pid);
+                    if (!processStartIdentity)
+                        throw new Error('mutable process identity unavailable');
+                    const launched = { ...prepared, phase: 'launched', launchedAt: this.dependencies.now(),
+                        pid, processStartIdentity, processGroupId };
+                    if (!await input.invocationState.compareAndSwap(prepared, launched))
+                        throw new Error('mutable launch state conflict');
+                    current = launched;
                 },
-                waitForAbsence: launchResult.waitForAbsence,
-            };
+            });
+        }
+        catch {
+            return { status: 'retryable', code: 'mutable-operation-launch-failed' };
         }
-        return this.finishWithSnapshot(input.worktreePath, before, launchResult, input);
+        if (result.status === 'completed')
+            return current.phase === 'launched'
+                ? this.adopt(input, current, result.reportBytes)
+                : { status: 'safe-halt', code: 'mutable-operation-launch-unfenced' };
+        if (result.status === 'safe-halt')
+            return { status: 'safe-halt', code: 'mutable-operation-process-unresolved' };
+        if (result.status === 'cancelled' || result.status === 'blocked') {
+            const unresolved = current.phase === 'launched' ? await this.unresolvedProcess(current) : undefined;
+            if (unresolved)
+                return unresolved;
+            const snapshot = await this.stableSnapshot(input.worktreePath);
+            if (!snapshot || canonicalJson(snapshot) !== canonicalJson(current.baseline))
+                return { status: 'safe-halt', code: 'mutable-operation-abandonment-ambiguous' };
+            if (!await input.invocationState.compareAndSwap(current, undefined))
+                return blocked('safety', 'mutable-operation-state-conflict');
+        }
+        return result;
     }
-    async finishWithSnapshot(worktreePath, before, launchResult, input) {
-        let after;
+    async recover(input, invocation) {
+        if (invocation.operation !== input.operation
+            || invocation.generationHash !== input.workflowGeneration.generationHash || invocation.promptFactsSha256 !== promptFactsSha256(input.promptFacts)
+            || canonicalJson(invocation.context) !== canonicalJson(input.context)
+            || invocation.worktreePath !== input.worktreePath || invocation.host !== this.dependencies.host || invocation.bootId !== this.dependencies.bootId)
+            return { status: 'safe-halt', code: 'mutable-operation-correlation-drift' };
+        let attempt;
         try {
-            after = requireReportSnapshot(await this.dependencies.snapshot(worktreePath));
+            attempt = await this.prepare(input, invocation.attemptId);
         }
         catch {
-            return { status: 'blocked', kind: 'safety', code: 'report-operation-snapshot-failed' };
+            return { status: 'safe-halt', code: 'mutable-operation-prepare-recovery-failed' };
+        }
+        if (attempt.reportPath !== invocation.reportPath)
+            return { status: 'safe-halt', code: 'mutable-operation-report-path-drift' };
+        const report = await this.observeReport(invocation.reportPath);
+        if (report.status === 'unknown')
+            return { status: 'safe-halt', code: 'mutable-operation-report-observation-unknown' };
+        if (invocation.phase === 'adopted') {
+            if (report.status !== 'available' || sha256(report.bytes) !== invocation.reportSha256)
+                return { status: 'safe-halt', code: 'mutable-operation-adopted-report-drift' };
+            const snapshot = await this.stableSnapshot(input.worktreePath);
+            if (!snapshot || canonicalJson(snapshot) !== canonicalJson(invocation.resultSnapshot))
+                return { status: 'safe-halt', code: 'mutable-operation-adopted-worktree-drift' };
+            return this.completeAdopted(input, invocation, report.bytes);
         }
-        if (!sameSnapshot(before, after)) {
-            return { status: 'blocked', kind: 'safety', code: 'report-operation-worktree-mutated' };
+        if (invocation.phase === 'prepared') {
+            if (report.status === 'available')
+                return { status: 'safe-halt', code: 'mutable-operation-prepared-report-ambiguous' };
+            const snapshot = await this.stableSnapshot(input.worktreePath);
+            if (!snapshot || canonicalJson(snapshot) !== canonicalJson(invocation.baseline))
+                return { status: 'safe-halt', code: 'mutable-operation-prepared-worktree-ambiguous' };
+            if (!await input.invocationState.compareAndSwap(invocation, undefined))
+                return blocked('safety', 'mutable-operation-state-conflict');
+            return { status: 'retryable', code: 'mutable-operation-prepared-attempt-abandoned' };
+        }
+        const unresolved = await this.unresolvedProcess(invocation);
+        if (unresolved)
+            return unresolved;
+        if (report.status === 'available')
+            return this.adopt(input, invocation, report.bytes);
+        const snapshot = await this.stableSnapshot(input.worktreePath);
+        if (!snapshot || canonicalJson(snapshot) !== canonicalJson(invocation.baseline))
+            return { status: 'safe-halt', code: 'mutable-operation-worktree-without-report' };
+        if (!await input.invocationState.compareAndSwap(invocation, undefined))
+            return blocked('safety', 'mutable-operation-state-conflict');
+        return { status: 'retryable', code: 'mutable-operation-output-unavailable' };
+    }
+    async adopt(input, invocation, reportBytes) {
+        const resultSnapshot = await this.stableSnapshot(input.worktreePath);
+        if (!resultSnapshot || resultSnapshot.worktreeIdentity !== invocation.baseline.worktreeIdentity || resultSnapshot.headSha !== invocation.baseline.headSha)
+            return { status: 'safe-halt', code: 'mutable-operation-result-worktree-mismatch' };
+        const adopted = { ...invocation, phase: 'adopted', reportSha256: sha256(reportBytes), resultSnapshot };
+        if (!await input.invocationState.compareAndSwap(invocation, adopted))
+            return blocked('safety', 'mutable-operation-state-conflict');
+        return this.completeAdopted(input, adopted, reportBytes);
+    }
+    async completeAdopted(input, invocation, reportBytes) {
+        if (invocation.context.repairOnly && canonicalJson(invocation.baseline) !== canonicalJson(invocation.resultSnapshot)) {
+            if (!await input.invocationState.compareAndSwap(invocation, undefined))
+                return blocked('safety', 'mutable-operation-state-conflict');
+            return blocked('safety', 'report-repair-modified-worktree');
+        }
+        return completedMutable(invocation, reportBytes);
+    }
+    async prepare(input, attemptId) {
+        const operation = workerOperation(input.operation);
+        const attempt = await this.dependencies.prepare({ operation, attemptId, runId: input.runId, workflowGeneration: input.workflowGeneration });
+        if (attempt.operation !== operation || attempt.generationHash !== input.workflowGeneration.generationHash || !hasExactMutableAuthority(attempt.policy)
+            || !attempt.reportPath)
+            throw new ReportAuthorityError();
+        return attempt;
+    }
+    async observeReport(path) {
+        try {
+            return await this.dependencies.readReport(path);
+        }
+        catch {
+            return { status: 'unknown' };
         }
-        if (launchResult.status !== 'completed')
-            return launchResult;
-        if (!input)
-            return { status: 'blocked', kind: 'external', code: 'report-operation-prepare-failed' };
-        return validateCompletedReport(input.operation, input.attemptId, launchResult.reportBytes, input.reviewContext);
+    }
+    async stableSnapshot(worktreePath) {
+        try {
+            const first = requireReportSnapshot(await this.dependencies.snapshot(worktreePath));
+            const second = requireReportSnapshot(await this.dependencies.snapshot(worktreePath));
+            return canonicalJson(first) === canonicalJson(second) ? first : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async unresolvedProcess(invocation) {
+        const observed = await this.dependencies.inspectProcess(invocation).catch(() => ({ status: 'unknown' }));
+        if (observed.status === 'unknown')
+            return { status: 'safe-halt', code: 'mutable-operation-process-observation-unknown' };
+        if (observed.status === 'present' && (observed.processStartIdentity === invocation.processStartIdentity || observed.processGroupAlive !== false))
+            return { status: 'safe-halt', code: 'mutable-operation-process-active-or-uncertain' };
+        return observed.status === 'absent' && observed.processGroupAlive !== false
+            ? { status: 'safe-halt', code: 'mutable-operation-process-group-unresolved' } : undefined;
     }
 }
-function hasExactReadOnlyAuthority(attempt, input) {
-    const policy = attempt.policy;
-    return attempt.operation === input.operation
-        && attempt.generationHash === input.workflowGeneration.generationHash
-        && hasExactKeys(policy, POLICY_KEYS)
-        && policy.sandboxMode === 'read-only'
-        && policy.cwdClass === 'worktree'
-        && policy.worktreeAccess === 'read-only'
-        && Array.isArray(policy.writableRootClasses)
-        && policy.writableRootClasses.length === 0
-        && policy.runnerPostcondition === 'report-only'
-        && policy.network === 'deny'
-        && Array.isArray(policy.networkHosts)
-        && policy.networkHosts.length === 0
-        && Array.isArray(policy.mcpTools)
-        && policy.mcpTools.length === 0
-        && policy.approvalCeiling === 'never'
-        && policy.externalWrite === false;
+export function validateDurableMutableInvocation(value) {
+    const keys = [
+        'version', 'operation', 'attemptId', 'generationHash', 'promptFactsSha256', 'worktreePath', 'reportPath',
+        'context', 'phase', 'host', 'bootId', 'preparedAt', 'launchedAt', 'pid', 'processStartIdentity', 'processGroupId', 'baseline',
+        'reportSha256', 'resultSnapshot',
+    ];
+    if (!hasExactKeys(value, keys))
+        throw new Error('durable mutable invocation is invalid');
+    const record = value;
+    if (record.version !== 1 || !['qualification-repair', 'implementation', 'review-feedback-implementation'].includes(record.operation)
+        || !nonEmpty(record.attemptId) || !/^[0-9a-f]{64}$/u.test(record.generationHash)
+        || !/^[0-9a-f]{64}$/u.test(record.promptFactsSha256) || !nonEmpty(record.worktreePath) || !nonEmpty(record.reportPath)
+        || !nonEmpty(record.host) || !nonEmpty(record.bootId) || !timestamp(record.preparedAt)
+        || !['prepared', 'launched', 'adopted'].includes(record.phase))
+        throw new Error('durable mutable invocation fields are invalid');
+    const context = record.context;
+    if (!hasExactKeys(context, ['repairOnly', 'reworkFindings']) || typeof context.repairOnly !== 'boolean'
+        || !Array.isArray(context.reworkFindings) || !context.reworkFindings.every(nonEmpty)) {
+        throw new Error('durable mutable invocation context is invalid');
+    }
+    const launched = record.phase === 'launched' || record.phase === 'adopted';
+    if (launched !== (positive(record.pid) && positive(record.processGroupId) && nonEmpty(record.processStartIdentity) && timestamp(record.launchedAt)))
+        throw new Error('durable mutable invocation process identity is invalid');
+    if (!launched && (record.pid !== null || record.processGroupId !== null || record.processStartIdentity !== null || record.launchedAt !== null))
+        throw new Error('prepared mutable invocation has process identity');
+    const adopted = record.phase === 'adopted';
+    if (adopted !== (typeof record.reportSha256 === 'string'
+        && /^[0-9a-f]{64}$/u.test(record.reportSha256) && record.resultSnapshot !== null))
+        throw new Error('durable mutable invocation adoption is invalid');
+    if (!adopted && (record.reportSha256 !== null || record.resultSnapshot !== null))
+        throw new Error('unfinished mutable invocation has adoption evidence');
+    requireReportSnapshot(record.baseline);
+    if (adopted)
+        requireReportSnapshot(record.resultSnapshot);
+    return structuredClone(value);
 }
-function validateCompletedReport(operation, attemptId, reportBytes, reviewContext) {
-    const rawText = reportBytes.toString('utf8');
-    const repairable = Buffer.from(rawText, 'utf8').equals(reportBytes)
-        && !containsCredentialEvidence(rawText)
-        && reportBytes.length <= 1024 * 1024;
-    try {
-        if (!Buffer.from(rawText, 'utf8').equals(reportBytes) || containsCredentialEvidence(rawText)) {
-            throw new Error('report payload contains forbidden credential material');
-        }
-        const decoded = decodeAgentReportForValidation(reportBytes);
-        let validatedPayload;
-        let artifactSha256;
-        if (operation === 'triage') {
-            validatedPayload = validateTriageRoute(decoded);
-            artifactSha256 = hashTriageArtifact(validatedPayload);
-        }
-        else if (operation === 'ambiguity-review') {
-            validatedPayload = validateAmbiguityReviewArtifact(decoded);
-            artifactSha256 = hashAmbiguityReviewArtifact(validatedPayload);
-        }
-        else {
-            const reviewReport = inputReview(operation, inputReviewContext(reviewContext), decoded);
-            validatedPayload = reviewReport;
-            artifactSha256 = hashCodeReviewReport(reviewReport);
-        }
-        return {
-            status: 'completed',
-            attemptId,
-            validatedPayload,
-            artifactSha256,
-        };
+export function validateDurableReportInvocation(value) {
+    const keys = [
+        'version', 'operation', 'attemptId', 'generationHash', 'promptFactsSha256', 'reportPath', 'phase', 'host', 'bootId', 'preparedAt',
+        'launchedAt', 'pid', 'processStartIdentity', 'processGroupId', 'baseline',
+    ];
+    if (!hasExactKeys(value, keys))
+        throw new Error('durable report invocation is invalid');
+    const record = value;
+    if (record.version !== 1 || !['triage', 'ambiguity-review', 'code-review', 'spec-author', 'spec-review', 'acceptance-proof'].includes(record.operation)
+        || !nonEmpty(record.attemptId) || !/^[0-9a-f]{64}$/u.test(record.generationHash)
+        || !nonEmpty(record.reportPath) || !nonEmpty(record.host) || !nonEmpty(record.bootId)
+        || !/^[0-9a-f]{64}$/u.test(record.promptFactsSha256)
+        || !timestamp(record.preparedAt) || !['prepared', 'launched'].includes(record.phase))
+        throw new Error('durable report invocation fields are invalid');
+    const launched = record.phase === 'launched';
+    if (launched !== (positive(record.pid) && positive(record.processGroupId) && nonEmpty(record.processStartIdentity)
+        && timestamp(record.launchedAt)))
+        throw new Error('durable report invocation process identity is invalid');
+    if (!launched && (record.pid !== null || record.processGroupId !== null || record.processStartIdentity !== null || record.launchedAt !== null)) {
+        throw new Error('prepared report invocation has process identity');
     }
-    catch (error) {
-        return {
-            status: 'invalid',
-            attemptId,
-            findings: [safeFinding(error)],
-            ...(repairable ? { repairInput: { originalReportSha256: sha256(reportBytes), originalReportBytes: Buffer.from(reportBytes) } } : {}),
-        };
+    requireReportSnapshot(record.baseline);
+    return structuredClone(value);
+}
+function hasExactReportAuthority(attempt, input) {
+    const policy = attempt.policy;
+    if (attempt.operation !== input.operation || attempt.generationHash !== input.workflowGeneration.generationHash
+        || !hasExactKeys(policy, POLICY_KEYS) || policy.network !== 'deny' || policy.networkHosts.length !== 0
+        || policy.mcpTools.length !== 0 || policy.approvalCeiling !== 'never' || policy.externalWrite !== false)
+        return false;
+    if (input.operation === 'spec-author') {
+        return policy.sandboxMode === 'workspace-write' && policy.cwdClass === 'target-state'
+            && policy.worktreeAccess === 'write' && canonicalJson(policy.writableRootClasses) === canonicalJson(['target-state'])
+            && policy.runnerPostcondition === 'spec-only';
+    }
+    if (input.operation === 'acceptance-proof') {
+        return policy.sandboxMode === 'workspace-write' && policy.cwdClass === 'worktree'
+            && policy.worktreeAccess === 'write' && canonicalJson(policy.writableRootClasses) === canonicalJson(['worktree'])
+            && policy.runnerPostcondition === 'proof-only';
     }
+    return policy.sandboxMode === 'read-only' && policy.cwdClass === 'worktree'
+        && policy.worktreeAccess === 'read-only' && Array.isArray(policy.writableRootClasses) && policy.writableRootClasses.length === 0
+        && policy.runnerPostcondition === 'report-only';
 }
-function isImplementationReview(operation) {
-    return operation === 'code-review';
+function hasExactMutableAuthority(policy) {
+    return hasExactKeys(policy, POLICY_KEYS) && policy.sandboxMode === 'workspace-write' && policy.cwdClass === 'worktree'
+        && policy.worktreeAccess === 'write' && canonicalJson(policy.writableRootClasses) === canonicalJson(['worktree'])
+        && policy.runnerPostcondition === 'change-set' && policy.network === 'deny' && policy.networkHosts.length === 0
+        && policy.mcpTools.length === 0 && policy.approvalCeiling === 'never' && policy.externalWrite === false;
 }
-function inputReviewContext(context) {
-    if (!context)
-        throw new Error('implementation review validation context is missing');
-    return context;
+function workerOperation(operation) {
+    return operation === 'qualification-repair' ? operation : 'implementation';
 }
-function inputReview(operation, context, decoded) {
-    if (context.operation !== operation)
-        throw new Error('implementation review operation context mismatch');
-    return validateCodeReviewReport(decoded, context);
+function completedMutable(invocation, reportBytes) {
+    return { status: 'completed', attemptId: invocation.attemptId, reportBytes: Buffer.from(reportBytes) };
 }
-function safeFinding(error) {
-    return error instanceof Error && error.message.length > 0
-        ? error.message.slice(0, MAX_STRING_LENGTH)
-        : 'report payload validation failed';
+function requireReportSnapshot(value) {
+    const keys = ['headSha', 'indexTreeSha', 'trackedContentSha256', 'untrackedContentSha256', 'worktreeIdentity'];
+    if (!hasExactKeys(value, keys) || !keys.every((key) => nonEmpty(value[key])))
+        throw new Error('report snapshot is invalid');
+    return structuredClone(value);
 }
-function sameSnapshot(left, right) {
-    try {
-        return canonicalJson(left) === canonicalJson(right);
-    }
-    catch {
-        return false;
-    }
+function blocked(kind, code) {
+    return { status: 'blocked', kind, code };
 }
 function hasExactKeys(value, keys) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
@@ -187,14 +505,10 @@ function hasExactKeys(value, keys) {
     const expected = [...keys].sort();
     return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
 }
-function requireReportSnapshot(value) {
-    const keys = ['headSha', 'indexTreeSha', 'trackedContentSha256', 'untrackedContentSha256', 'worktreeIdentity'];
-    if (!hasExactKeys(value, keys))
-        throw new Error('report-operation snapshot is invalid');
-    for (const key of keys) {
-        if (typeof value[key] !== 'string')
-            throw new Error('report-operation snapshot is invalid');
-    }
-    return value;
+function nonEmpty(value) { return typeof value === 'string' && value.length > 0; }
+function positive(value) { return Number.isSafeInteger(value) && value > 0; }
+function timestamp(value) { return typeof value === 'string' && !Number.isNaN(Date.parse(value)) && new Date(value).toISOString() === value; }
+function promptFactsSha256(promptFacts) { return sha256(canonicalJson(promptFacts)); }
+class ReportAuthorityError extends Error {
 }
 //# sourceMappingURL=contained-report-operation.js.map