codex-orchestrator 2.0.11 → 2.0.12

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

@@ -1,4 +1,7 @@
-import { canonicalJson, sha256 } from './containment.js';
+import { canonicalJson, containsCredentialEvidence, sha256 } from './containment.js';
+import { decodeAgentReportForValidation } from './report-envelope.js';
+import { hashCodeReviewReport, validateCodeReviewReport, } from './code-review-report.js';
+const MAX_STRING_LENGTH = 16 * 1024;
 const POLICY_KEYS = [
     'sandboxMode', 'cwdClass', 'worktreeAccess', 'writableRootClasses', 'runnerPostcondition',
     'network', 'networkHosts', 'mcpTools', 'approvalCeiling', 'externalWrite',
@@ -9,494 +12,160 @@ export class InjectedContainedReportOperation {
         this.dependencies = dependencies;
     }
     async run(input) {
-        const existing = await input.invocationState.read();
-        if (existing)
-            return this.recover(input, validateDurableReportInvocation(existing));
-        return this.launch(input);
-    }
-    async launch(input) {
-        let baseline;
+        let before;
         try {
-            baseline = requireReportSnapshot(await this.dependencies.snapshot(input.worktreePath, input.operation));
+            before = requireReportSnapshot(await this.dependencies.snapshot(input.worktreePath));
         }
         catch {
-            return blocked('safety', 'report-operation-snapshot-failed');
+            return { status: 'blocked', kind: 'safety', code: '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.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;
-                },
+            attempt = await this.dependencies.prepare({
+                operation: input.operation,
+                attemptId: input.attemptId,
+                runId: input.runId,
+                workflowGeneration: input.workflowGeneration,
             });
         }
         catch {
-            result = { status: 'retryable', 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' };
+            return this.finishWithSnapshot(input.worktreePath, before, {
+                status: 'blocked', kind: 'external', code: 'report-operation-prepare-failed',
+            });
         }
-        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' };
+        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' };
             }
-            return await input.invocationState.compareAndSwap(adopted, undefined)
-                ? { status: 'settled' }
-                : { status: 'safe-halt', code: 'mutable-operation-state-conflict' };
-        }
-        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;
+        if (launchResult.status === 'safe-halt') {
+            return {
+                status: 'safe-halt',
+                process: {
+                    pid: launchResult.pid,
+                    processGroupId: launchResult.processGroupId,
+                    startedAt: launchResult.startedAt,
+                    baseline: structuredClone(before),
                 },
-            });
+            };
         }
-        catch {
-            return { status: 'retryable', code: 'mutable-operation-launch-failed' };
-        }
-        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;
+        return this.finishWithSnapshot(input.worktreePath, before, launchResult, input, attempt);
     }
-    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 {
-            attempt = await this.prepare(input, invocation.attemptId);
-        }
-        catch {
-            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 (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' };
-        }
-    }
-    async stableSnapshot(worktreePath) {
+    async finishWithSnapshot(worktreePath, before, launchResult, input, attempt) {
+        let after;
         try {
-            const first = requireReportSnapshot(await this.dependencies.snapshot(worktreePath));
-            const second = requireReportSnapshot(await this.dependencies.snapshot(worktreePath));
-            return canonicalJson(first) === canonicalJson(second) ? first : undefined;
+            after = requireReportSnapshot(await this.dependencies.snapshot(worktreePath));
         }
         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;
-    }
-}
-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);
-}
-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');
+            return { status: 'blocked', kind: 'safety', code: 'report-operation-snapshot-failed' };
+        }
+        if (!sameSnapshot(before, after)) {
+            return { status: 'blocked', kind: 'safety', code: 'report-operation-worktree-mutated' };
+        }
+        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,
+            availableReviewers: [...(attempt?.reviewers ?? [])],
+        });
     }
-    requireReportSnapshot(record.baseline);
-    return structuredClone(value);
 }
-function hasExactReportAuthority(attempt, input) {
+function hasExactReadOnlyAuthority(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';
+    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 validateCompletedReport(operation, attemptId, reportBytes, reviewContext) {
+    const rawText = reportBytes.toString('utf8');
+    const repairable = Buffer.from(rawText, 'utf8').equals(reportBytes)
+        && !containsCredentialEvidence(rawText);
+    try {
+        if (!Buffer.from(rawText, 'utf8').equals(reportBytes) || containsCredentialEvidence(rawText)) {
+            throw new Error('report payload contains forbidden credential material');
+        }
+        const decoded = decodeAgentReportForValidation(reportBytes);
+        const reviewReport = inputReview(operation, inputReviewContext(reviewContext), decoded);
+        const validatedPayload = reviewReport;
+        const artifactSha256 = hashCodeReviewReport(reviewReport);
+        return {
+            status: 'completed',
+            attemptId,
+            validatedPayload,
+            artifactSha256,
+        };
     }
-    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';
+    catch (error) {
+        return {
+            status: 'invalid',
+            attemptId,
+            findings: [safeFinding(error)],
+            ...(repairable ? { repairInput: { originalReportSha256: sha256(reportBytes), originalReportBytes: Buffer.from(reportBytes) } } : {}),
+        };
     }
-    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 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 isImplementationReview(operation) {
+    return operation === 'code-review';
 }
-function workerOperation(operation) {
-    return operation === 'qualification-repair' ? operation : 'implementation';
+function inputReviewContext(context) {
+    if (!context)
+        throw new Error('implementation review validation context is missing');
+    return context;
 }
-function completedMutable(invocation, reportBytes) {
-    return { status: 'completed', attemptId: invocation.attemptId, reportBytes: Buffer.from(reportBytes) };
+function inputReview(operation, context, decoded) {
+    if (context.operation !== operation)
+        throw new Error('implementation review operation context mismatch');
+    return validateCodeReviewReport(decoded, context);
 }
-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 safeFinding(error) {
+    return error instanceof Error && error.message.length > 0
+        ? error.message.slice(0, MAX_STRING_LENGTH)
+        : 'report payload validation failed';
 }
-function blocked(kind, code) {
-    return { status: 'blocked', kind, code };
+function sameSnapshot(left, right) {
+    try {
+        return canonicalJson(left) === canonicalJson(right);
+    }
+    catch {
+        return false;
+    }
 }
 function hasExactKeys(value, keys) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
@@ -505,10 +174,14 @@ function hasExactKeys(value, keys) {
     const expected = [...keys].sort();
     return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
 }
-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 {
+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;
 }
 //# sourceMappingURL=contained-report-operation.js.map