codex-orchestrator 2.0.10 → 2.0.12

package/dist/src/v2/runtime.js

@@ -1,45 +1,411 @@
 import { constants } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { access, lstat, mkdir, open, readFile, readdir, readlink, realpath, rm } from 'node:fs/promises';
+import { access, link, lstat, mkdir, mkdtemp, open, readFile, readdir, readlink, realpath, rm, unlink } from 'node:fs/promises';
 import { homedir, hostname } from 'node:os';
 import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { writeDurableAtomicFile } from './adapters/durable-atomic-file.js';
 import { GitWorktreeManager } from './adapters/worktree.js';
-import { ReviewFeedbackCoordinator } from './review-feedback-coordinator.js';
+import { ReviewFeedbackObserver } from './review-feedback-coordinator.js';
 import { defaultProcessExecutor } from './adapters/command.js';
 import { RunnerAndroidProofController } from './android-proof-runner.js';
-import { AcceptanceProof, ProofQuiescenceError } from './acceptance-proof.js';
+import { AcceptanceProof, CandidateProofInspectionError } from './acceptance-proof.js';
 import { createCheckedChangeCapabilities } from './checked-change.js';
 import { InjectedContainedReportOperation } from './contained-report-operation.js';
 import { ContainedImplementationReviewer } from './implementation-reviewer.js';
 import { parseAgentAutoConfig } from './config.js';
-import { WaitingHumanCoordinator } from './waiting-human-coordinator.js';
 import { canonicalJson, parseJsonWithoutDuplicateKeys, sha256, } from './containment.js';
-import { FileProofRecordWriter } from './proof-store.js';
 import { CheckProcessQuiescenceError, parseIssueCheckInvocation, resolveIssueCheckPolicy } from './issue-check-policy.js';
 import { acquireOwnerControlLock, OwnerControlLockBlockedError } from './owner-control-lock.js';
 import { decodeAgentReportForValidation } from './report-envelope.js';
 import { CodexProcess, ProcessQuiescenceError } from './codex-process.js';
 import { FileAndroidLeaseVerifier, FileIosLeaseVerifier } from './mobile-lease.js';
 import { publishRuntimeAssetSnapshot } from './runtime-assets.js';
-import { RouteCoordinator } from './route-coordinator.js';
-import { SpecCoordinator } from './spec-coordinator.js';
-import { createSpecRevision } from './spec-delivery.js';
-import { validateCodeReviewDefects } from './code-review-report.js';
-import { hashRouteDecision, validateRouteReceipt } from './route-decision.js';
-import { OwnerLockContentionError, OwnerLockSafetyError, RunIssue } from './run-issue.js';
+import { OwnerLockContentionError, OwnerLockSafetyError, RunIssue, } from './run-issue.js';
 import { FileRunRecordWriter } from './run-store.js';
+import { captureProcessStartIdentity, observeProcessGroup, observeProcessIdentity } from './process-identity.js';
 import { parseWorkflowExecutionProfile, verifyWorkflowGeneration, } from './workflow-assets.js';
+import { candidateBindingId, candidateBindingSeed, candidateRef, } from './candidate.js';
 export class LocalGitRunIssueAdapter {
     executor;
+    repositoryRoot;
     worktrees;
-    constructor(executor = defaultProcessExecutor) {
+    candidateRepositories = new Map();
+    candidateV2;
+    constructor(executor = defaultProcessExecutor, repositoryRoot) {
         this.executor = executor;
+        this.repositoryRoot = repositoryRoot;
         this.worktrees = new GitWorktreeManager(executor);
+        this.candidateV2 = {
+            reconcileOrphans: (input) => this.reconcileCandidateOrphans(input),
+            captureAndPin: (input) => this.captureAndPinCandidate(input),
+            inspectPin: (binding) => this.inspectCandidatePin(binding),
+            normalizeSharedIndex: (input) => this.candidateOperation('candidate-io-failed', async () => {
+                if (await this.getHead(input.worktreePath) !== input.expectedHeadSha)
+                    throw new Error('candidate expected HEAD diverged');
+                await this.git(['-C', input.worktreePath, 'read-tree', input.expectedHeadSha]);
+            }),
+            prepareMaterialization: (input) => this.prepareCandidateMaterialization(input),
+            inspectMaterialization: (input) => this.inspectCandidateMaterialization(input),
+            removeMaterialization: (input) => this.removeCandidateMaterialization(input.materialization),
+            copyProofArtifacts: (input) => this.copyCandidateProofArtifacts(input),
+            createOrObserveCommit: (input) => this.createOrObserveCandidateCommit(input),
+            releasePin: (input) => this.releaseCandidatePin(input.binding, input.expectedPinnedCommitSha),
+        };
+    }
+    async reconcileCandidateOrphans(input) {
+        return this.candidateOperation('candidate-io-failed', async () => {
+            const root = (await this.git(['-C', input.repositoryRoot, 'rev-parse', '--show-toplevel'])).trim();
+            const activeRefs = new Set(input.activeCandidateRefs);
+            const adoptableRefs = new Set();
+            for (const pending of input.pendingCandidates) {
+                const first = await this.captureCandidateTree(pending.worktreePath, pending.expectedHeadSha, pending.artifactDir);
+                const second = await this.captureCandidateTree(pending.worktreePath, pending.expectedHeadSha, pending.artifactDir);
+                if (canonicalJson(first) !== canonicalJson(second))
+                    continue;
+                const bindingId = candidateBindingId({
+                    bindingSeed: candidateBindingSeed(pending.runId, pending.boundary),
+                    expectedHeadSha: pending.expectedHeadSha,
+                    candidateTreeSha: first.treeSha,
+                    canonicalChangedFiles: first.changedFiles,
+                    sourceWorktreeIdentity: first.worktreeIdentity,
+                });
+                const ref = candidateRef(pending.runId, bindingId);
+                const commit = await this.resolveOptionalRef(root, ref);
+                if (commit && await this.commitMatches(root, commit, pending.expectedHeadSha, first.treeSha))
+                    adoptableRefs.add(ref);
+            }
+            const refs = (await this.git(['-C', root, 'for-each-ref', '--format=%(refname) %(objectname)', 'refs/codex-orchestrator/candidates/']))
+                .split('\n').filter(Boolean);
+            for (const row of refs) {
+                const separator = row.indexOf(' ');
+                if (separator < 1)
+                    throw new Error('orphan candidate ref row is malformed');
+                const ref = row.slice(0, separator);
+                const sha = row.slice(separator + 1);
+                if (!activeRefs.has(ref) && !adoptableRefs.has(ref)) {
+                    const deleted = await this.executor('git', ['-C', root, 'update-ref', '-d', ref, sha]);
+                    if (deleted.exitCode !== 0)
+                        throw new Error('orphan candidate ref cleanup failed');
+                }
+            }
+            const materializationRoot = canonicalFilesystemPath(resolve(input.workspaceRoot, '.candidate-materializations'));
+            const activeMaterializations = new Map(input.activeMaterializations.map((materialization) => [
+                canonicalFilesystemPath(materialization.path), materialization.candidateCommitSha,
+            ]));
+            for (const worktree of await this.worktrees.listWorktrees(root)) {
+                const path = canonicalFilesystemPath(worktree.path);
+                const relativePath = relative(materializationRoot, path);
+                if (relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath))) {
+                    const expectedCommit = activeMaterializations.get(path);
+                    if (expectedCommit) {
+                        if (worktree.branch !== undefined || await this.getHead(path).catch(() => '') !== expectedCommit) {
+                            throw new Error('persisted candidate materialization diverged');
+                        }
+                    }
+                    else {
+                        if (worktree.branch !== undefined)
+                            throw new Error('orphan candidate materialization unexpectedly owns a branch');
+                        await this.git(['-C', root, 'worktree', 'remove', '--force', path]);
+                    }
+                }
+            }
+        });
+    }
+    async captureAndPinCandidate(input) {
+        try {
+            const first = await this.captureCandidateTree(input.worktreePath, input.expectedHeadSha, input.artifactDir);
+            const second = await this.captureCandidateTree(input.worktreePath, input.expectedHeadSha, input.artifactDir);
+            if (canonicalJson(first) !== canonicalJson(second)) {
+                return { kind: 'failed', code: 'candidate-unstable', detailSha256: sha256(canonicalJson({ first, second })) };
+            }
+            const bindingSeed = candidateBindingSeed(input.runId, input.boundary);
+            const bindingId = candidateBindingId({
+                bindingSeed,
+                expectedHeadSha: input.expectedHeadSha,
+                candidateTreeSha: first.treeSha,
+                canonicalChangedFiles: first.changedFiles,
+                sourceWorktreeIdentity: first.worktreeIdentity,
+            });
+            const ref = candidateRef(input.runId, bindingId);
+            const root = (await this.git(['-C', input.worktreePath, 'rev-parse', '--show-toplevel'])).trim();
+            this.candidateRepositories.set(ref, root);
+            let commitSha = await this.resolveOptionalRef(root, ref);
+            if (commitSha) {
+                if (!await this.commitMatches(root, commitSha, input.expectedHeadSha, first.treeSha))
+                    throw new Error('existing candidate ref diverged');
+            }
+            else {
+                commitSha = (await this.git([
+                    '-C', root, '-c', 'user.name=codex-orchestrator', '-c', 'user.email=codex-orchestrator@users.noreply.github.com',
+                    'commit-tree', first.treeSha, '-p', input.expectedHeadSha, '-m', `codex-orchestrator candidate ${bindingId}`,
+                ])).trim();
+                const update = await this.executor('git', ['-C', root, 'update-ref', ref, commitSha, '0'.repeat(commitSha.length)]);
+                if (update.exitCode !== 0) {
+                    const observed = await this.resolveOptionalRef(root, ref);
+                    if (!observed || !await this.commitMatches(root, observed, input.expectedHeadSha, first.treeSha)) {
+                        return { kind: 'failed', code: 'candidate-ref-update-unknown', detailSha256: sha256(update.stderr) };
+                    }
+                    commitSha = observed;
+                }
+            }
+            return { kind: 'ok', value: {
+                    version: 2, bindingId, expectedHeadSha: input.expectedHeadSha, candidateRef: ref,
+                    candidateCommitSha: commitSha, candidateTreeSha: first.treeSha,
+                    canonicalChangedFiles: first.changedFiles, sourceWorktreeIdentity: first.worktreeIdentity,
+                } };
+        }
+        catch (error) {
+            return candidateFailure('candidate-io-failed', error);
+        }
+    }
+    async captureCandidateTree(worktreePath, expectedHeadSha, artifactDir) {
+        validateRelativeRoot(artifactDir);
+        const [head, canonicalPath, gitDirectoryRaw] = await Promise.all([
+            this.getHead(worktreePath), realpath(worktreePath), this.git(['-C', worktreePath, 'rev-parse', '--absolute-git-dir']),
+        ]);
+        if (head !== expectedHeadSha)
+            throw new Error('candidate expected HEAD diverged');
+        const gitDirectory = gitDirectoryRaw.trim();
+        const temporaryRoot = await mkdtemp(join(gitDirectory, 'candidate-index-'));
+        const indexPath = join(temporaryRoot, 'index');
+        const options = { envOverlay: { GIT_INDEX_FILE: indexPath } };
+        try {
+            await this.git(['-C', worktreePath, 'read-tree', expectedHeadSha], options);
+            await this.git(['-C', worktreePath, 'add', '-u', '--'], options);
+            const untracked = (await this.git(['-C', worktreePath, 'ls-files', '--others', '--exclude-standard', '-z'], options)).split('\0')
+                .filter((path) => path && path !== artifactDir && !path.startsWith(`${artifactDir}/`)).sort();
+            if (untracked.length > 0) {
+                await this.git(['-C', worktreePath, 'add', '--pathspec-from-file=-', '--pathspec-file-nul'], {
+                    ...options, stdin: `${untracked.join('\0')}\0`,
+                });
+            }
+            const treeSha = (await this.git(['-C', worktreePath, 'write-tree'], options)).trim();
+            const changedFiles = (await this.git(['-C', worktreePath, 'diff-tree', '--no-commit-id', '--name-only', '-r', '-z', expectedHeadSha, treeSha]))
+                .split('\0').filter(Boolean).sort();
+            return {
+                expectedHeadSha,
+                treeSha,
+                changedFiles,
+                worktreeIdentity: sha256(canonicalJson({ canonicalPath, gitDirectory })),
+            };
+        }
+        finally {
+            await rm(temporaryRoot, { recursive: true, force: true });
+        }
+    }
+    async inspectCandidatePin(binding) {
+        return this.candidateOperation('candidate-io-failed', async () => {
+            const root = await this.candidateRepository(binding.candidateRef);
+            if (!root)
+                return 'missing';
+            const observed = await this.resolveOptionalRef(root, binding.candidateRef);
+            if (!observed)
+                return 'missing';
+            return observed === binding.candidateCommitSha
+                && await this.commitMatches(root, observed, binding.expectedHeadSha, binding.candidateTreeSha) ? 'matching' : 'diverged';
+        });
+    }
+    async prepareCandidateMaterialization(input) {
+        return this.candidateOperation('candidate-materialization-io-failed', async () => {
+            const root = await this.repositoryFromWorkspaceRoot(input.workspaceRoot);
+            this.candidateRepositories.set(input.binding.candidateRef, root);
+            const path = join(input.workspaceRoot, '.candidate-materializations', input.runId, input.binding.bindingId, input.materializationId);
+            const existing = (await this.worktrees.listWorktrees(root)).find((worktree) => sameFilesystemPath(worktree.path, path));
+            if (existing) {
+                const clean = await this.worktrees.isWorktreeClean(path);
+                const head = await this.getHead(path).catch(() => 'missing');
+                if (existing.branch !== undefined || head !== input.binding.candidateCommitSha || !clean)
+                    return { kind: 'path-diverged', path };
+            }
+            else {
+                await mkdir(dirname(path), { recursive: true });
+                await this.git(['-C', root, 'worktree', 'add', '--detach', path, input.binding.candidateCommitSha]);
+            }
+            return { kind: 'prepared', materialization: {
+                    version: 2, bindingId: input.binding.bindingId, candidateCommitSha: input.binding.candidateCommitSha,
+                    path,
+                } };
+        });
+    }
+    async inspectCandidateMaterialization(input) {
+        return this.candidateOperation('candidate-materialization-io-failed', async () => {
+            try {
+                const stat = await lstat(input.materialization.path);
+                if (stat.isSymbolicLink() || !stat.isDirectory())
+                    return 'mutated';
+            }
+            catch (error) {
+                if (isErrorCode(error, 'ENOENT'))
+                    return 'missing';
+                throw error;
+            }
+            const [head, tree, changed] = await Promise.all([
+                this.getHead(input.materialization.path),
+                this.git(['-C', input.materialization.path, 'rev-parse', 'HEAD^{tree}']).then((value) => value.trim()),
+                this.worktrees.listChangedFilesIgnoringUntrackedRoot(input.materialization.path, input.artifactDir),
+            ]);
+            return head === input.binding.candidateCommitSha && tree === input.binding.candidateTreeSha && changed.length === 0 ? 'matching' : 'mutated';
+        });
+    }
+    async removeCandidateMaterialization(materialization) {
+        return this.candidateOperation('candidate-materialization-io-failed', async () => {
+            const root = await this.repositoryFromWorkspaceRoot(materialization.path);
+            const registered = (await this.worktrees.listWorktrees(root)).find((worktree) => sameFilesystemPath(worktree.path, materialization.path));
+            if (!registered)
+                return;
+            if (registered.branch !== undefined || await this.getHead(materialization.path) !== materialization.candidateCommitSha)
+                throw new Error('candidate materialization diverged');
+            await this.git(['-C', root, 'worktree', 'remove', '--force', materialization.path]);
+        });
+    }
+    async copyCandidateProofArtifacts(input) {
+        return this.candidateOperation('candidate-materialization-io-failed', async () => {
+            const proofRoot = `${input.artifactDir}/${input.proofId}`;
+            const repositoryRoot = await this.repositoryFromWorkspaceRoot(input.materialization.path);
+            const registered = (await this.worktrees.listWorktrees(repositoryRoot))
+                .find((worktree) => sameFilesystemPath(worktree.path, input.materialization.path));
+            if (!registered || registered.branch !== undefined
+                || await this.getHead(input.materialization.path).catch(() => '') !== input.materialization.candidateCommitSha) {
+                return { kind: 'artifact-conflict', relativePath: proofRoot };
+            }
+            const sourceRoot = await inspectSafeArtifactRoot(input.materialization.path);
+            const destinationRoot = await inspectSafeArtifactRoot(input.issueWorktreePath);
+            for (const artifact of input.artifacts) {
+                if (artifact.relativePath !== proofRoot && !artifact.relativePath.startsWith(`${proofRoot}/`))
+                    return { kind: 'artifact-conflict', relativePath: artifact.relativePath };
+                try {
+                    const source = join(input.materialization.path, artifact.relativePath);
+                    const destination = join(input.issueWorktreePath, artifact.relativePath);
+                    const sourceBytes = await readRegularFileWithoutSymlinkAncestors(sourceRoot, source);
+                    if (sha256(sourceBytes) !== artifact.sha256)
+                        return { kind: 'artifact-conflict', relativePath: artifact.relativePath };
+                    await ensureSafeDirectoryPath(destinationRoot, dirname(destination));
+                    await publishArtifactCreateOnly(destinationRoot, destination, sourceBytes, artifact.sha256);
+                }
+                catch (error) {
+                    if (error instanceof CandidateArtifactConflictError)
+                        return { kind: 'artifact-conflict', relativePath: artifact.relativePath };
+                    throw error;
+                }
+            }
+            return { kind: 'copied-or-observed' };
+        });
+    }
+    async createOrObserveCandidateCommit(input) {
+        return this.candidateOperation('candidate-ref-update-unknown', async () => {
+            const root = (await this.git(['-C', input.worktreePath, 'rev-parse', '--show-toplevel'])).trim();
+            const ref = `refs/heads/${input.branchName}`;
+            const observedHead = (await this.git(['-C', root, 'rev-parse', '--verify', `${ref}^{commit}`])).trim();
+            if (observedHead !== input.parentSha) {
+                const observed = await this.inspectCommit(root, observedHead);
+                if (observed.parentSha === input.parentSha && observed.treeSha === input.treeSha && observed.message === input.message) {
+                    return { kind: 'created-or-observed', sha: observedHead, ...observed };
+                }
+                return { kind: 'branch-diverged', observedHeadSha: observedHead };
+            }
+            if (input.observeOnly)
+                return { kind: 'parent-unchanged' };
+            const pin = await this.resolveOptionalRef(root, input.candidateRef);
+            if (!pin || (await this.git(['-C', root, 'rev-parse', `${pin}^{tree}`])).trim() !== input.treeSha)
+                throw new Error('candidate pin does not authorize publication tree');
+            const sha = (await this.git([
+                '-C', root, '-c', 'user.name=codex-orchestrator', '-c', 'user.email=codex-orchestrator@users.noreply.github.com',
+                'commit-tree', input.treeSha, '-p', input.parentSha, '-m', input.message,
+            ])).trim();
+            const update = await this.executor('git', ['-C', root, 'update-ref', ref, sha, input.parentSha]);
+            if (update.exitCode !== 0) {
+                const after = (await this.git(['-C', root, 'rev-parse', '--verify', `${ref}^{commit}`])).trim();
+                if (after === input.parentSha)
+                    return { kind: 'parent-unchanged' };
+                const observed = await this.inspectCommit(root, after);
+                if (observed.parentSha === input.parentSha && observed.treeSha === input.treeSha && observed.message === input.message) {
+                    return { kind: 'created-or-observed', sha: after, ...observed };
+                }
+                return { kind: 'branch-diverged', observedHeadSha: after };
+            }
+            return { kind: 'created-or-observed', sha, parentSha: input.parentSha, treeSha: input.treeSha, message: input.message };
+        });
+    }
+    async releaseCandidatePin(binding, expected) {
+        return this.candidateOperation('candidate-ref-update-unknown', async () => {
+            const root = await this.candidateRepository(binding.candidateRef);
+            if (!root)
+                return;
+            const observed = await this.resolveOptionalRef(root, binding.candidateRef);
+            if (!observed)
+                return;
+            if (observed !== expected)
+                throw new Error('candidate pin diverged');
+            const result = await this.executor('git', ['-C', root, 'update-ref', '-d', binding.candidateRef, expected]);
+            if (result.exitCode !== 0 && await this.resolveOptionalRef(root, binding.candidateRef))
+                throw new Error('candidate pin deletion outcome is unknown');
+        });
+    }
+    async candidateOperation(code, operation) {
+        try {
+            return { kind: 'ok', value: await operation() };
+        }
+        catch (error) {
+            return candidateFailure(code, error);
+        }
+    }
+    async candidateRepository(ref) {
+        const known = this.candidateRepositories.get(ref);
+        if (known)
+            return known;
+        for (const candidateRoot of [this.repositoryRoot, process.cwd()]) {
+            if (!candidateRoot)
+                continue;
+            try {
+                const root = (await this.git(['-C', candidateRoot, 'rev-parse', '--show-toplevel'])).trim();
+                if (await this.resolveOptionalRef(root, ref)) {
+                    this.candidateRepositories.set(ref, root);
+                    return root;
+                }
+            }
+            catch { /* this location need not be in the target repository */ }
+        }
+        return undefined;
+    }
+    async repositoryFromWorkspaceRoot(path) {
+        let current = resolve(path);
+        while (true) {
+            try {
+                return (await this.git(['-C', current, 'rev-parse', '--show-toplevel'])).trim();
+            }
+            catch {
+                const parent = dirname(current);
+                if (parent === current)
+                    throw new Error('candidate workspace is not below a Git repository');
+                current = parent;
+            }
+        }
+    }
+    async resolveOptionalRef(root, ref) {
+        const result = await this.executor('git', ['-C', root, 'rev-parse', '--verify', `${ref}^{commit}`]);
+        if (result.exitCode === 1 || result.exitCode === 128)
+            return undefined;
+        if (result.exitCode !== 0)
+            throw new Error(`git ref inspection failed: ${result.stderr}`);
+        return result.stdout.trim();
+    }
+    async commitMatches(root, commit, parent, tree) {
+        const observed = await this.inspectCommit(root, commit);
+        return observed.parentSha === parent && observed.treeSha === tree;
+    }
+    async inspectCommit(root, commit) {
+        const output = await this.git(['-C', root, 'show', '-s', '--format=%P%n%T%n%B', commit]);
+        const [parentSha, treeSha, ...message] = output.split('\n');
+        if (!parentSha || parentSha.includes(' ') || !treeSha)
+            throw new Error('candidate commit is not single-parent');
+        return { parentSha, treeSha, message: message.join('\n').trimEnd() };
     }
     async getBaseSha(input) {
-        return (await this.git(['-C', input.targetRoot, 'rev-parse', input.baseBranch])).trim();
+        await this.git([
+            '-C', input.targetRoot, 'fetch', '--quiet', '--no-tags', 'origin', `refs/heads/${input.baseBranch}`,
+        ]);
+        return (await this.git(['-C', input.targetRoot, 'rev-parse', '--verify', 'FETCH_HEAD^{commit}'])).trim();
     }
     async createWorktree(input) {
         await this.worktrees.createIssueWorktree({
@@ -49,6 +415,9 @@ export class LocalGitRunIssueAdapter {
             baseBranch: input.baseBranch,
             requiredBaseSha: input.baseSha,
         });
+        if (await this.getHead(input.worktreePath) !== input.baseSha) {
+            throw new Error('created issue worktree does not match the pinned base SHA');
+        }
     }
     async ensureContinuationWorktree(input) {
         const localHead = (await this.git([
@@ -137,6 +506,13 @@ export class LocalGitRunIssueAdapter {
     listChangedFiles(worktreePath) {
         return this.worktrees.listChangedFiles(worktreePath);
     }
+    async diffTrees(worktreePath, previousTreeSha, candidateTreeSha) {
+        const [names, patch] = await Promise.all([
+            this.git(['-C', worktreePath, 'diff-tree', '--no-commit-id', '--name-only', '-r', '-z', previousTreeSha, candidateTreeSha], { maxOutputBytes: 1024 * 1024 }),
+            this.git(['-C', worktreePath, 'diff', '--binary', '--full-index', '--no-ext-diff', previousTreeSha, candidateTreeSha, '--'], { maxOutputBytes: 1024 * 1024 }),
+        ]);
+        return { changedFiles: names.split('\0').filter(Boolean).sort(), patch };
+    }
     listChangedFilesIgnoringUntrackedRoot(worktreePath, ignoredRoot) {
         return this.worktrees.listChangedFilesIgnoringUntrackedRoot(worktreePath, ignoredRoot);
     }
@@ -197,13 +573,204 @@ export class LocalGitRunIssueAdapter {
     push(input) {
         return this.worktrees.pushBranch(input);
     }
-    async git(args) {
-        const result = await this.executor('git', args);
+    async git(args, options) {
+        const result = await this.executor('git', args, options);
         if (result.exitCode !== 0)
             throw new Error(`git failed: ${result.stderr}`);
         return result.stdout;
     }
 }
+function candidateFailure(code, error) {
+    const detail = error instanceof Error ? `${error.name}:${error.message}` : String(error);
+    return { kind: 'failed', code, detailSha256: sha256(detail) };
+}
+function processGroupIsAlive(processGroupId) {
+    try {
+        process.kill(-processGroupId, 0);
+        return true;
+    }
+    catch (error) {
+        return !isErrorCode(error, 'ESRCH');
+    }
+}
+function sameFilesystemPath(left, right) {
+    return canonicalFilesystemPath(left) === canonicalFilesystemPath(right);
+}
+function canonicalFilesystemPath(value) {
+    const resolved = resolve(value);
+    return resolved.startsWith('/private/') ? resolved.slice('/private'.length) : resolved;
+}
+async function inspectSafeArtifactRoot(root) {
+    const path = resolve(root);
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink() || !stat.isDirectory())
+        throw new CandidateArtifactConflictError('candidate artifact root is unsafe');
+    const realPath = canonicalFilesystemPath(await realpath(path));
+    if (realPath !== canonicalFilesystemPath(path))
+        throw new CandidateArtifactConflictError('candidate artifact root has a symlinked ancestor');
+    const identity = { path, realPath, dev: stat.dev, ino: stat.ino };
+    await assertSafeArtifactRoot(identity);
+    return identity;
+}
+async function assertSafeArtifactRoot(root) {
+    const stat = await lstat(root.path);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || stat.dev !== root.dev || stat.ino !== root.ino
+        || canonicalFilesystemPath(await realpath(root.path)) !== root.realPath) {
+        throw new CandidateArtifactConflictError('candidate artifact root changed');
+    }
+}
+async function readRegularFileWithoutSymlinkAncestors(rootInput, path) {
+    const root = typeof rootInput === 'string' ? await inspectSafeArtifactRoot(rootInput) : rootInput;
+    await assertSafeArtifactRoot(root);
+    const relativePath = relative(root.path, resolve(path));
+    if (!relativePath || relativePath.startsWith('..') || isAbsolute(relativePath))
+        throw new CandidateArtifactConflictError('candidate artifact path escapes its root');
+    let current = root.path;
+    const rootStat = await lstat(current);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
+        throw new CandidateArtifactConflictError('candidate artifact root is unsafe');
+    const ancestorIdentity = [{ path: current, dev: rootStat.dev, ino: rootStat.ino }];
+    const segments = relativePath.split('/');
+    for (const segment of segments.slice(0, -1)) {
+        current = join(current, segment);
+        const stat = await lstat(current);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw new CandidateArtifactConflictError('candidate artifact ancestor is unsafe');
+        ancestorIdentity.push({ path: current, dev: stat.dev, ino: stat.ino });
+    }
+    const finalBeforeOpen = await lstat(path);
+    if (finalBeforeOpen.isSymbolicLink() || !finalBeforeOpen.isFile()) {
+        throw new CandidateArtifactConflictError('candidate artifact is not a regular file');
+    }
+    let handle;
+    try {
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    }
+    catch (error) {
+        if (isErrorCode(error, 'ELOOP'))
+            throw new CandidateArtifactConflictError('candidate artifact is not a regular file');
+        throw error;
+    }
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile())
+            throw new CandidateArtifactConflictError('candidate artifact is not a regular file');
+        const openedPath = await realpath(path);
+        const openedRelative = relative(root.realPath, canonicalFilesystemPath(openedPath));
+        if (!openedRelative || openedRelative.startsWith('..') || isAbsolute(openedRelative)) {
+            throw new CandidateArtifactConflictError('candidate artifact path escaped its root during read');
+        }
+        const finalStat = await lstat(path);
+        if (!finalStat.isFile() || finalStat.isSymbolicLink() || finalStat.dev !== stat.dev || finalStat.ino !== stat.ino) {
+            throw new CandidateArtifactConflictError('candidate artifact changed during read');
+        }
+        for (const identity of ancestorIdentity) {
+            const observed = await lstat(identity.path);
+            if (!observed.isDirectory() || observed.isSymbolicLink() || observed.dev !== identity.dev || observed.ino !== identity.ino) {
+                throw new CandidateArtifactConflictError('candidate artifact ancestor changed during read');
+            }
+        }
+        await assertSafeArtifactRoot(root);
+        return await handle.readFile();
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function ensureSafeDirectoryPath(root, directory) {
+    await assertSafeArtifactRoot(root);
+    const relativeDirectory = relative(root.path, resolve(directory));
+    if (relativeDirectory.startsWith('..') || isAbsolute(relativeDirectory))
+        throw new CandidateArtifactConflictError('candidate artifact directory escapes its root');
+    let current = root.path;
+    for (const segment of relativeDirectory.split('/').filter(Boolean)) {
+        current = join(current, segment);
+        try {
+            await mkdir(current);
+        }
+        catch (error) {
+            if (!isErrorCode(error, 'EEXIST'))
+                throw error;
+        }
+        const stat = await lstat(current);
+        if (stat.isSymbolicLink() || !stat.isDirectory())
+            throw new CandidateArtifactConflictError('candidate artifact directory is unsafe');
+    }
+    const parentRealPath = canonicalFilesystemPath(await realpath(directory));
+    const parentRelative = relative(root.realPath, parentRealPath);
+    if (parentRelative.startsWith('..') || isAbsolute(parentRelative))
+        throw new CandidateArtifactConflictError('candidate artifact directory escaped its root');
+    await assertSafeArtifactRoot(root);
+}
+class CandidateArtifactConflictError extends Error {
+}
+async function publishArtifactCreateOnly(root, destination, bytes, expectedSha256) {
+    await assertSafeArtifactRoot(root);
+    const temporary = join(dirname(destination), `.${basename(destination)}.${expectedSha256}.tmp`);
+    let handle;
+    try {
+        handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+    }
+    catch (error) {
+        if (!isErrorCode(error, 'EEXIST'))
+            throw error;
+        const stale = await readRegularFileWithoutSymlinkAncestors(root, temporary);
+        if (sha256(stale) !== expectedSha256) {
+            await unlink(temporary);
+            handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+        }
+    }
+    if (handle) {
+        try {
+            await handle.writeFile(bytes);
+            await handle.sync();
+            const stat = await handle.stat();
+            const observed = await lstat(temporary);
+            const temporaryRealPath = canonicalFilesystemPath(await realpath(temporary));
+            const temporaryRelative = relative(root.realPath, temporaryRealPath);
+            if (!observed.isFile() || observed.isSymbolicLink() || observed.dev !== stat.dev || observed.ino !== stat.ino
+                || temporaryRelative.startsWith('..') || isAbsolute(temporaryRelative)) {
+                throw new CandidateArtifactConflictError('candidate artifact temporary path changed');
+            }
+            await assertSafeArtifactRoot(root);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    try {
+        await link(temporary, destination);
+    }
+    catch (error) {
+        if (!isErrorCode(error, 'EEXIST'))
+            throw error;
+        const existing = await readRegularFileWithoutSymlinkAncestors(root, destination);
+        if (sha256(existing) !== expectedSha256)
+            throw new CandidateArtifactConflictError('candidate artifact destination conflicts');
+    }
+    const published = await readRegularFileWithoutSymlinkAncestors(root, destination);
+    if (sha256(published) !== expectedSha256)
+        throw new CandidateArtifactConflictError('candidate artifact destination conflicts');
+    const parent = await open(dirname(destination), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        const parentStat = await parent.stat();
+        const observedParent = await lstat(dirname(destination));
+        const parentRealPath = canonicalFilesystemPath(await realpath(dirname(destination)));
+        const parentRelative = relative(root.realPath, parentRealPath);
+        if (!observedParent.isDirectory() || observedParent.isSymbolicLink()
+            || observedParent.dev !== parentStat.dev || observedParent.ino !== parentStat.ino
+            || parentRelative.startsWith('..') || isAbsolute(parentRelative)) {
+            throw new CandidateArtifactConflictError('candidate artifact destination directory changed');
+        }
+        await parent.sync();
+        await assertSafeArtifactRoot(root);
+    }
+    finally {
+        await parent.close();
+    }
+    await unlink(temporary).catch((error) => { if (!isErrorCode(error, 'ENOENT'))
+        throw error; });
+}
 export class ContainedImplementationAgent {
     dependencies;
     constructor(dependencies) {
@@ -212,7 +779,7 @@ export class ContainedImplementationAgent {
     async run(input) {
         const config = this.dependencies.config();
         const canonicalRepository = `${config.github.owner.toLowerCase()}/${config.github.repo.toLowerCase()}`;
-        const attemptId = (this.dependencies.createAttemptId ?? randomUUID)();
+        const attemptId = input.attemptId;
         const attempt = await prepareContainedAttempt({
             orchestratorHome: this.dependencies.orchestratorHome,
             canonicalRepository,
@@ -230,6 +797,14 @@ export class ContainedImplementationAgent {
             baseline,
         });
         try {
+            try {
+                const recovered = await readRegularFile(attempt.reportPath);
+                return { kind: 'completed', attemptId, report: decodeAgentReportForValidation(recovered) };
+            }
+            catch (error) {
+                if (!isErrorCode(error, 'ENOENT'))
+                    return { kind: 'internal-error' };
+            }
             const result = await (this.dependencies.process ?? new CodexProcess()).run({
                 codexPath: config.codex.command,
                 cwd: input.worktreePath,
@@ -244,19 +819,12 @@ export class ContainedImplementationAgent {
                     `Package profile instructions: ${attempt.profile.developerInstructions}`,
                     `Follow the exact operation at ${attempt.operationPath}.`,
                     `The operation's immutable workflow root is ${attempt.workflowRoot}.`,
-                    ...(input.operation === 'qualification-repair'
-                        ? [
-                            `Pre-implementation qualification repair for issue #${input.issue.number}: ${input.issue.title}`,
-                            'Do not implement the issue acceptance criteria yet. Repair only the reported scoped-check failures so the existing worktree qualifies for implementation.',
-                            'You may modify the product files required by those failures. Return changedFiles as the complete cumulative worktree change set.',
-                        ]
-                        : [`Implement issue #${input.issue.number}: ${input.issue.title}`]),
+                    `Implement issue #${input.issue.number}: ${input.issue.title}`,
                     `Implementation cycle: ${input.cycle}.`,
                     ...(input.reviewFeedbackRound ? [`Pull-request feedback repair round: ${input.reviewFeedbackRound}.`] : []),
                     ...(input.reviewFeedback?.length ? [`Frozen trusted pull-request feedback: ${canonicalJson(input.reviewFeedback)}`] : []),
-                    ...(input.operation === 'implementation'
-                        ? [`Frozen acceptance criteria: ${canonicalJson(input.frozenCriteria)}`]
-                        : []),
+                    `Exact delivery authority: ${canonicalJson(input.deliveryAuthority)}`,
+                    `Frozen acceptance criteria: ${canonicalJson(input.frozenCriteria)}`,
                     ...(input.reworkFindings.length > 0 ? [`Repair these verified findings: ${canonicalJson(input.reworkFindings)}`] : []),
                     ...(input.repairOnly ? ['Report repair only: do not modify any worktree file; emit a schema-valid implementation report for the existing change.'] : []),
                     'Do not commit, push, publish, or print credentials or local auth paths.',
@@ -265,13 +833,13 @@ export class ContainedImplementationAgent {
                 idleTimeoutMs: config.codex.idleTimeoutMs,
                 operationPolicy: attempt.policy,
                 executionProfile: attempt.profile,
-                ...(input.onLaunched ? { onSpawned: ({ pid, processGroupId }) => input.onLaunched({
-                        attemptId, pid, processGroupId, launchedAt: (this.dependencies.now ?? (() => new Date().toISOString()))(),
-                    }) } : {}),
+                onSpawned: async ({ pid, processGroupId }) => input.onLaunched?.({
+                    attemptId, pid, processGroupId, launchedAt: (this.dependencies.now ?? (() => new Date().toISOString()))(),
+                }),
             }, input.signal);
             if (result.kind === 'cancelled')
                 return { kind: 'cancelled' };
-            if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout'].includes(result.kind)) {
+            if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout', 'launch-gate-failed'].includes(result.kind)) {
                 return { kind: 'transport-failed', resumable: true };
             }
             if (result.kind !== 'completed' || result.report.kind !== 'available')
@@ -285,38 +853,9 @@ export class ContainedImplementationAgent {
         catch (error) {
             if (!(error instanceof ProcessQuiescenceError))
                 return { kind: 'internal-error' };
-            return {
-                kind: 'safe-halt',
-                process: {
-                    pid: error.pid,
-                    processGroupId: error.processGroupId,
-                    startedAt: (this.dependencies.now ?? (() => new Date().toISOString()))(),
-                    baseline: { ...baseline },
-                },
-                waitForAbsence: () => waitForProcessGroupAbsent(error.processGroupId),
-            };
+            return { kind: 'safe-halt' };
         }
     }
-    async recover(input) {
-        const expected = join(resolve(this.dependencies.orchestratorHome), 'v2', sha256(input.canonicalRepository), 'runs', input.runId, 'attempts', input.invocation.attemptId, 'report.json');
-        if (resolve(input.invocation.reportPath) !== expected) {
-            throw new Error('review feedback implementation report path is not attempt-owned');
-        }
-        let bytes;
-        try {
-            bytes = await readRegularFile(expected);
-        }
-        catch (error) {
-            if (isErrorCode(error, 'ENOENT'))
-                return undefined;
-            throw error;
-        }
-        return {
-            kind: 'completed',
-            attemptId: input.invocation.attemptId,
-            report: decodeAgentReportForValidation(bytes),
-        };
-    }
 }
 export class ContainedProofAgent {
     dependencies;
@@ -328,12 +867,13 @@ export class ContainedProofAgent {
             throw new Error('proof workflow generation is required');
         const config = this.dependencies.config();
         const canonicalRepository = `${config.github.owner.toLowerCase()}/${config.github.repo.toLowerCase()}`;
-        const worktreePath = resolve(this.dependencies.targetRoot, config.runner.workspaceRoot, `issue-${input.issue.number}`);
+        const issueWorktreePath = resolve(this.dependencies.targetRoot, config.runner.workspaceRoot, `issue-${input.issue.number}`);
+        const worktreePath = input.worktreePath ? resolve(input.worktreePath) : issueWorktreePath;
         const attempt = await prepareContainedAttempt({
             orchestratorHome: this.dependencies.orchestratorHome,
             canonicalRepository,
             runId: input.runId,
-            attemptId: (this.dependencies.createAttemptId ?? randomUUID)(),
+            attemptId: input.attemptId ?? (this.dependencies.createAttemptId ?? randomUUID)(),
             operationId: 'acceptance-proof',
             workflowGeneration: input.workflowGeneration,
             bootId: this.dependencies.bootId,
@@ -345,6 +885,22 @@ export class ContainedProofAgent {
         const iosTooling = await discoverIosTooling(this.dependencies.processExecutor, this.dependencies.iosXcrunPath);
         const before = await artifactInventory(artifactRoot, config.proof.artifactDir);
         try {
+            try {
+                const recoveredReport = await readRegularFile(attempt.reportPath);
+                const recoveredInventory = await artifactInventory(artifactRoot, config.proof.artifactDir);
+                const runnerPrepared = new Set(input.runnerPreparedArtifactPaths);
+                return {
+                    kind: 'report',
+                    report: decodeAgentReportForValidation(recoveredReport, ['visualEvidence', 'blocker']),
+                    proofPhaseChangedFiles: [...recoveredInventory.keys()].filter((path) => !runnerPrepared.has(path)).sort(),
+                };
+            }
+            catch (error) {
+                if (!isErrorCode(error, 'ENOENT'))
+                    throw error;
+            }
+            if (input.recoverOnly)
+                return { kind: 'internal-error' };
             const result = await (this.dependencies.process ?? new CodexProcess()).run({
                 codexPath: config.codex.command,
                 cwd: worktreePath,
@@ -393,10 +949,13 @@ export class ContainedProofAgent {
                 idleTimeoutMs: config.codex.idleTimeoutMs,
                 operationPolicy: attempt.policy,
                 executionProfile: attempt.profile,
+                onSpawned: async ({ pid, processGroupId }) => input.onLaunched?.({
+                    pid, processGroupId, launchedAt: new Date().toISOString(),
+                }),
             }, input.signal);
             if (result.kind === 'cancelled')
                 return { kind: 'cancelled' };
-            if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout'].includes(result.kind)) {
+            if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout', 'launch-gate-failed'].includes(result.kind)) {
                 return { kind: 'transport-failed', resumable: true };
             }
             if (result.kind !== 'completed' || result.report.kind !== 'available')
@@ -409,13 +968,48 @@ export class ContainedProofAgent {
             };
         }
         catch (error) {
-            if (error instanceof ProcessQuiescenceError) {
-                throw new ProofQuiescenceError(error.pid, error.processGroupId, () => waitForProcessGroupAbsent(error.processGroupId));
-            }
-            return { kind: 'internal-error' };
+            return error instanceof ProcessQuiescenceError ? { kind: 'safe-halt' } : { kind: 'internal-error' };
         }
     }
 }
+export async function observeAttemptReadViewCleanup(input) {
+    const runtimeRoot = join(resolve(input.orchestratorHome), 'v2', sha256(input.canonicalRepository));
+    const attemptRoot = join(runtimeRoot, 'runs', input.identity.runId, 'attempts', input.identity.attemptId);
+    const expectedResultPath = join(attemptRoot, 'report.json');
+    if (input.identity.resultPath !== expectedResultPath)
+        return 'pending';
+    let canonicalRuntimeRoot;
+    let canonicalAttemptRoot;
+    try {
+        canonicalRuntimeRoot = await realpath(runtimeRoot);
+    }
+    catch (error) {
+        return isErrorCode(error, 'ENOENT') ? 'confirmed' : 'pending';
+    }
+    try {
+        canonicalAttemptRoot = await realpath(attemptRoot);
+    }
+    catch (error) {
+        return isErrorCode(error, 'ENOENT') ? 'confirmed' : 'pending';
+    }
+    const expectedRelative = relative(runtimeRoot, attemptRoot);
+    if (!isPathWithin(canonicalRuntimeRoot, canonicalAttemptRoot)
+        || relative(canonicalRuntimeRoot, canonicalAttemptRoot) !== expectedRelative)
+        return 'pending';
+    await rm(join(attemptRoot, 'read-view'), { recursive: true, force: true });
+    return 'confirmed';
+}
+export function selectedConfiguredCheckPolicySha256(selectedChecks, configuredAuthority) {
+    const selected = {};
+    for (const check of selectedChecks) {
+        if (Object.prototype.hasOwnProperty.call(selected, check.id)
+            || configuredAuthority[check.id] !== check.command) {
+            throw new CandidateProofInspectionError('selected check no longer matches current configured authority');
+        }
+        selected[check.id] = check.command;
+    }
+    return sha256(canonicalJson(selected));
+}
 export async function resolveCodexExecutable(command, safePath) {
     if (command.length === 0 || safePath.length === 0)
         throw new Error('Codex command and safe path must be non-empty');
@@ -453,7 +1047,7 @@ export function createV2Runtime(input) {
         codexExecutable = { command, path };
         return path;
     };
-    const git = input.git ?? new LocalGitRunIssueAdapter(commandExecutor);
+    const git = input.git ?? new LocalGitRunIssueAdapter(commandExecutor, targetRoot);
     const proofFreshnessGit = git;
     const controller = new AbortController();
     let currentConfig;
@@ -515,6 +1109,14 @@ export function createV2Runtime(input) {
                 || !attempt.profile || !attempt.operationPath || !attempt.workflowRoot) {
                 return { status: 'blocked', kind: 'safety', code: 'report-operation-attempt-incomplete' };
             }
+            try {
+                return { status: 'completed', reportBytes: await readRegularFile(attempt.reportPath) };
+            }
+            catch (error) {
+                if (!isErrorCode(error, 'ENOENT')) {
+                    return { status: 'blocked', kind: 'safety', code: 'report-operation-result-read-failed' };
+                }
+            }
             let readView;
             try {
                 readView = await materializeReportReadView({
@@ -544,6 +1146,7 @@ export function createV2Runtime(input) {
                         `Follow the exact operation at ${attempt.operationPath}.`,
                         `The operation's immutable workflow root is ${attempt.workflowRoot}.`,
                         `Runner-provided facts: ${canonicalJson(promptFacts)}`,
+                        `Available reviewer roles: ${canonicalJson(attempt.reviewers ?? [])}`,
                         'This is a read-only, report-only operation. Do not edit files or external state, use network or MCP tools, or request additional authority.',
                         'Do not read .env or any .env* file. The runner has removed repository credential paths from this read view.',
                     ].join('\n'),
@@ -551,7 +1154,8 @@ export function createV2Runtime(input) {
                     idleTimeoutMs: config.codex.idleTimeoutMs,
                     operationPolicy: attempt.policy,
                     executionProfile: attempt.profile,
-                    ...(onLaunched ? { onSpawned: onLaunched } : {}),
+                    agentProfilePaths: attempt.reviewerProfiles,
+                    onSpawned: async ({ pid, processGroupId }) => onLaunched?.({ pid, processGroupId }),
                 }, signal);
             }
             catch (error) {
@@ -562,10 +1166,6 @@ export function createV2Runtime(input) {
                         pid: error.pid,
                         processGroupId: error.processGroupId,
                         startedAt: now(),
-                        waitForAbsence: async () => {
-                            await waitForProcessGroupAbsent(error.processGroupId);
-                            await rm(readView, { recursive: true, force: true });
-                        },
                     };
                 }
                 throw error;
@@ -577,7 +1177,7 @@ export function createV2Runtime(input) {
             if (result.kind === 'cancelled')
                 return { status: 'cancelled' };
             if (result.kind === 'launch-gate-failed') {
-                return { status: 'blocked', kind: 'safety', code: 'review-operation-launch-persistence-failed' };
+                return { status: 'retryable', code: 'review-operation-launch-gate-failed' };
             }
             if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout'].includes(result.kind)) {
                 return { status: 'retryable', code: `report-operation-${result.kind}` };
@@ -590,196 +1190,7 @@ export function createV2Runtime(input) {
     });
     const implementationReviewer = new ContainedImplementationReviewer({
         operation: reportOperation,
-        createAttemptId: input.createAttemptId ?? randomUUID,
     });
-    const createAttemptId = input.createAttemptId ?? randomUUID;
-    const specOperation = {
-        author: async ({ context, state, mode, signal, onPrepared, onLaunched }) => {
-            const attemptId = createAttemptId();
-            const sessionId = state.authorSessionId ?? randomUUID();
-            let attempt;
-            try {
-                attempt = await prepareContainedAttempt({
-                    orchestratorHome, canonicalRepository: requireCanonicalRepository(currentConfig), runId: context.runId,
-                    attemptId, operationId: 'spec-author', workflowGeneration: context.workflowGeneration, bootId: input.bootId,
-                });
-                const revisionPath = join(dirname(attempt.reportPath), `revision-${state.revisions.length + 1}.md`);
-                await onPrepared({ attemptId, sessionId, reportPath: attempt.reportPath, revisionPath });
-                const config = requireConfig(currentConfig);
-                const result = await containedProcess.run({
-                    codexPath: config.codex.command, cwd: dirname(attempt.reportPath), schemaPath: attempt.schemaPath,
-                    reportPath: attempt.reportPath, toolHome: attempt.toolHome, tmpDir: attempt.tmpDir,
-                    safePath: requireRuntimeString(input.safePath, 'safePath'), parentCodexHome: requireRuntimeString(input.parentCodexHome, 'parentCodexHome'),
-                    parentEnv: process.env, timeoutMs: config.codex.timeoutMs, idleTimeoutMs: config.codex.idleTimeoutMs,
-                    operationPolicy: attempt.policy, executionProfile: attempt.profile,
-                    onSpawned: ({ pid, processGroupId }) => onLaunched({ attemptId, sessionId, pid, processGroupId }),
-                    prompt: [
-                        `Package profile instructions: ${attempt.profile.developerInstructions}`,
-                        `Follow the exact operation at ${attempt.operationPath}.`,
-                        `The immutable workflow root is ${attempt.workflowRoot}.`,
-                        `Author mode: ${mode}. Issue authority: ${canonicalJson(context.issue)}.`,
-                        `Frozen criteria: ${canonicalJson(context.frozenCriteria)}.`,
-                        `Prior revisions and review state: ${canonicalJson({ revisions: state.revisions, review: state.review })}.`,
-                        `Write the complete new immutable revision only to ${revisionPath}. Return that exact absolute path and its SHA-256 in the report.`,
-                        'Do not modify the product worktree, prior revisions, external state, or any .env file.',
-                    ].join('\n'),
-                }, signal);
-                if (result.kind === 'cancelled')
-                    return { status: 'cancelled' };
-                if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout'].includes(result.kind))
-                    return { status: 'retryable', code: `spec-author-${result.kind}` };
-                if (result.kind !== 'completed' || result.report.kind !== 'available')
-                    return { status: 'retryable', code: 'spec-author-report-invalid' };
-                const report = decodeAgentReportForValidation(result.report.bytes);
-                if (report.status !== 'ready' || report.specPath !== revisionPath || report.specSha256 === null)
-                    return { status: 'retryable', code: 'spec-author-report-invalid' };
-                const content = await readRegularFile(revisionPath);
-                if (report.specSha256 !== sha256(content))
-                    return { status: 'retryable', code: 'spec-author-report-invalid' };
-                const previous = state.revisions.at(-1) ?? null;
-                return { status: 'completed', value: createSpecRevision({
-                        revision: state.revisions.length + 1, path: revisionPath, content: content.toString('utf8'),
-                        evidence: [{ path: context.issue.url, sha256: sha256(canonicalJson(context.issue)), description: 'Frozen issue authority' }],
-                        author: { attemptId, sessionId }, previousRevision: previous,
-                    }) };
-            }
-            catch (error) {
-                if (error instanceof ProcessQuiescenceError) {
-                    try {
-                        await waitForProcessGroupAbsent(error.processGroupId);
-                        return { status: 'retryable', code: 'spec-author-process-quiescence' };
-                    }
-                    catch {
-                        return { status: 'blocked', kind: 'safety', code: 'spec-author-process-absence-unconfirmed' };
-                    }
-                }
-                return { status: 'retryable', code: 'spec-author-report-invalid' };
-            }
-        },
-        review: async ({ context, state, mode, signal, onPrepared, onLaunched }) => {
-            const attemptId = createAttemptId();
-            const sessionId = state.review.reviewer?.sessionId ?? randomUUID();
-            try {
-                const attempt = await prepareContainedAttempt({
-                    orchestratorHome, canonicalRepository: requireCanonicalRepository(currentConfig), runId: context.runId,
-                    attemptId, operationId: 'spec-review', workflowGeneration: context.workflowGeneration, bootId: input.bootId,
-                });
-                await onPrepared({ attemptId, sessionId, reportPath: attempt.reportPath });
-                const config = requireConfig(currentConfig);
-                const result = await containedProcess.run({
-                    codexPath: config.codex.command, cwd: context.worktreePath, schemaPath: attempt.schemaPath,
-                    reportPath: attempt.reportPath, toolHome: attempt.toolHome, tmpDir: attempt.tmpDir,
-                    safePath: requireRuntimeString(input.safePath, 'safePath'), parentCodexHome: requireRuntimeString(input.parentCodexHome, 'parentCodexHome'),
-                    parentEnv: process.env, timeoutMs: config.codex.timeoutMs, idleTimeoutMs: config.codex.idleTimeoutMs,
-                    operationPolicy: attempt.policy, executionProfile: attempt.profile,
-                    onSpawned: ({ pid, processGroupId }) => onLaunched({ attemptId, sessionId, pid, processGroupId }),
-                    prompt: [
-                        `Package profile instructions: ${attempt.profile.developerInstructions}`,
-                        `Follow the exact operation at ${attempt.operationPath}.`,
-                        `Reviewer session ID: ${sessionId}. Review mode: ${mode}.`,
-                        `Issue authority and frozen criteria: ${canonicalJson({ issue: context.issue, frozenCriteria: context.frozenCriteria })}.`,
-                        `Immutable spec delivery state: ${canonicalJson(state)}.`,
-                        'Return only the package spec-review report. Do not edit files or external state.',
-                    ].join('\n'),
-                }, signal);
-                if (result.kind === 'cancelled')
-                    return { status: 'cancelled' };
-                if (['spawn-failed', 'transport-failed', 'timeout', 'idle-timeout'].includes(result.kind))
-                    return { status: 'retryable', code: `spec-review-${result.kind}` };
-                if (result.kind !== 'completed' || result.report.kind !== 'available')
-                    return { status: 'retryable', code: 'spec-review-report-invalid' };
-                const raw = decodeAgentReportForValidation(result.report.bytes);
-                if (raw.mode !== mode || raw.reviewerSessionId !== sessionId || !Array.isArray(raw.coverage) || !Array.isArray(raw.defects)
-                    || !Array.isArray(raw.affectedDefectIds) || !Array.isArray(raw.affectedContracts) || !Array.isArray(raw.acceptedRisks)
-                    || typeof raw.coverageInvalidated !== 'boolean'
-                    || !['approved', 'needs-work', 'rejected'].includes(raw.verdict))
-                    return { status: 'retryable', code: 'spec-review-report-invalid' };
-                const target = state.revisions.at(-1);
-                const defects = validateCodeReviewDefects(raw.defects, target.revision);
-                const report = {
-                    version: 1, targetRevision: target.revision, targetSha256: target.revisionSha256, mode,
-                    verdict: raw.verdict, reviewer: { attemptId, sessionId },
-                    coverage: raw.coverage, defects,
-                    affectedDefectIds: raw.affectedDefectIds,
-                    affectedContracts: raw.affectedContracts,
-                    closureRequestSha256: mode === 'closure' ? state.review.closureRequestSha256 : null,
-                    acceptedRisks: [], coverageInvalidated: raw.coverageInvalidated,
-                };
-                return { status: 'completed', value: report, reportSha256: sha256(result.report.bytes) };
-            }
-            catch (error) {
-                if (error instanceof ProcessQuiescenceError) {
-                    try {
-                        await waitForProcessGroupAbsent(error.processGroupId);
-                        return { status: 'retryable', code: 'spec-review-process-quiescence' };
-                    }
-                    catch {
-                        return { status: 'blocked', kind: 'safety', code: 'spec-review-process-absence-unconfirmed' };
-                    }
-                }
-                return { status: 'retryable', code: 'spec-review-report-invalid' };
-            }
-        },
-        recover: async ({ context, state, signal }) => {
-            const invocation = state.invocation;
-            if (!invocation || signal.aborted)
-                return signal.aborted ? { status: 'cancelled' } : { status: 'blocked', kind: 'safety', code: 'spec-recovery-invocation-missing' };
-            if (invocation.status === 'launched') {
-                try {
-                    await waitForProcessGroupAbsent(invocation.processGroupId);
-                }
-                catch {
-                    return { status: 'blocked', kind: 'safety', code: 'spec-process-absence-unconfirmed' };
-                }
-            }
-            if (!invocation.reportPath)
-                return { status: 'retryable', code: `spec-${invocation.purpose}-transport-recovery` };
-            let reportBytes;
-            try {
-                reportBytes = await readRegularFile(invocation.reportPath);
-            }
-            catch {
-                return { status: 'retryable', code: `spec-${invocation.purpose}-transport-recovery` };
-            }
-            if (invocation.purpose === 'author') {
-                if (!invocation.revisionPath)
-                    return { status: 'retryable', code: 'spec-author-report-invalid' };
-                try {
-                    const raw = decodeAgentReportForValidation(reportBytes);
-                    const content = await readRegularFile(invocation.revisionPath);
-                    if (raw.status !== 'ready' || raw.specPath !== invocation.revisionPath || raw.specSha256 !== sha256(content))
-                        return { status: 'retryable', code: 'spec-author-report-invalid' };
-                    return { status: 'completed', value: createSpecRevision({
-                            revision: state.revisions.length + 1, path: invocation.revisionPath, content: content.toString('utf8'),
-                            evidence: [{ path: context.issue.url, sha256: sha256(canonicalJson(context.issue)), description: 'Frozen issue authority' }],
-                            author: { attemptId: invocation.attemptId, sessionId: invocation.sessionId }, previousRevision: state.revisions.at(-1) ?? null,
-                        }) };
-                }
-                catch {
-                    return { status: 'retryable', code: 'spec-author-report-invalid' };
-                }
-            }
-            try {
-                const raw = decodeAgentReportForValidation(reportBytes);
-                if (raw.mode !== invocation.mode || raw.reviewerSessionId !== invocation.sessionId || !Array.isArray(raw.coverage)
-                    || !Array.isArray(raw.defects) || !Array.isArray(raw.affectedDefectIds) || !Array.isArray(raw.affectedContracts)
-                    || typeof raw.coverageInvalidated !== 'boolean' || !['approved', 'needs-work', 'rejected'].includes(raw.verdict)) {
-                    return { status: 'retryable', code: 'spec-review-report-invalid' };
-                }
-                const defects = validateCodeReviewDefects(raw.defects, invocation.targetRevision);
-                return { status: 'completed', reportSha256: sha256(reportBytes), value: {
-                        version: 1, targetRevision: invocation.targetRevision, targetSha256: invocation.targetSha256,
-                        mode: invocation.mode, verdict: raw.verdict,
-                        reviewer: { attemptId: invocation.attemptId, sessionId: invocation.sessionId }, coverage: raw.coverage, defects,
-                        affectedDefectIds: raw.affectedDefectIds, affectedContracts: raw.affectedContracts,
-                        closureRequestSha256: invocation.closureRequestSha256, acceptedRisks: [], coverageInvalidated: raw.coverageInvalidated,
-                    } };
-            }
-            catch {
-                return { status: 'retryable', code: 'spec-review-report-invalid' };
-            }
-        },
-    };
     const readConfig = async (requestedRoot) => {
         if (resolve(requestedRoot) !== targetRoot)
             throw new Error('runtime target root mismatch');
@@ -796,6 +1207,11 @@ export function createV2Runtime(input) {
         return { bytes, config };
     };
     const records = {
+        inspect: async () => {
+            if (!runRecords)
+                throw new Error('run store used before config');
+            return runRecords.inspect();
+        },
         read: async () => {
             if (!runRecords)
                 throw new Error('run store used before config');
@@ -813,8 +1229,8 @@ export function createV2Runtime(input) {
             const config = requireConfig(currentConfig);
             const checked = capabilities.verifyAndRead(proofInput.checkedChange);
             const repoKey = sha256(checked.payload.canonicalRepository);
-            const proofRecords = new FileProofRecordWriter(join(orchestratorHome, 'v2', repoKey, 'proofs'));
-            const worktreePath = resolve(targetRoot, config.runner.workspaceRoot, `issue-${checked.payload.issueNumber}`);
+            const issueWorktreePath = resolve(targetRoot, config.runner.workspaceRoot, `issue-${checked.payload.issueNumber}`);
+            const worktreePath = proofInput.materialization?.path ?? issueWorktreePath;
             const androidLease = new FileAndroidLeaseVerifier({
                 leaseRoot: join(orchestratorHome, 'v2', repoKey, 'leases'),
                 worktreeRoot: worktreePath,
@@ -833,21 +1249,34 @@ export function createV2Runtime(input) {
             });
             const acceptanceProof = new AcceptanceProof({
                 checkedChangeReader: capabilities,
-                proofRecords,
                 proofAgent,
-                inspectFreshness: async (payload) => ({
-                    ...await (proofFreshnessGit.snapshotIgnoringUntrackedRoot
-                        ? proofFreshnessGit.snapshotIgnoringUntrackedRoot(worktreePath, config.proof.artifactDir)
-                        : git.snapshot(worktreePath)),
-                    checkPolicySha256: sha256(canonicalJson(resolveIssueCheckPolicy(proofInput.issue.body, config.checks).checks)),
-                }),
+                inspectFreshness: async (payload, materialization) => {
+                    const checkPolicySha256 = selectedConfiguredCheckPolicySha256(payload.checks, resolveIssueCheckPolicy(proofInput.issue.body, config.checks).checks);
+                    if (payload.version === 1)
+                        return {
+                            ...await (proofFreshnessGit.snapshotIgnoringUntrackedRoot
+                                ? proofFreshnessGit.snapshotIgnoringUntrackedRoot(worktreePath, config.proof.artifactDir)
+                                : git.snapshot(worktreePath)),
+                            checkPolicySha256,
+                        };
+                    if (!materialization || !git.candidateV2)
+                        throw new CandidateProofInspectionError('candidate-git-v2-required');
+                    const inspection = await git.candidateV2.inspectMaterialization({
+                        binding: payload.binding,
+                        materialization,
+                        artifactDir: config.proof.artifactDir,
+                    });
+                    if (inspection.kind === 'failed')
+                        throw new CandidateProofInspectionError(inspection.code);
+                    if (inspection.value !== 'matching')
+                        throw new CandidateProofInspectionError('candidate-materialization-mutated');
+                    return { bindingId: payload.binding.bindingId, candidateTreeSha: payload.binding.candidateTreeSha, checkPolicySha256 };
+                },
                 readArtifact: async (relativePath) => readRegularFile(resolve(worktreePath, relativePath)),
                 inspectArtifact: async (relativePath) => inspectRegularFile(resolve(worktreePath, relativePath)),
                 androidLease,
                 iosLease,
                 proofArtifactDir: config.proof.artifactDir,
-                createAttemptId: input.createAttemptId ?? randomUUID,
-                now,
                 signal: controller.signal,
             });
             const androidRelevant = !!config.proof.android && isAndroidProofRelevant(proofInput.issue, proofInput.frozenCriteria, checked.payload.changedFiles);
@@ -855,7 +1284,7 @@ export function createV2Runtime(input) {
             const runnerPreparedArtifactSha256 = {};
             const runnerPreparationWarnings = [];
             let preparationAttempted = false;
-            return acceptanceProof.proveChange({
+            const result = await acceptanceProof.proveChange({
                 ...proofInput,
                 runnerPreparedArtifactPaths,
                 runnerPreparedArtifactSha256,
@@ -885,6 +1314,21 @@ export function createV2Runtime(input) {
                     }
                 },
             });
+            if (checked.payload.version === 2 && proofInput.materialization && git.candidateV2 && result.status === 'passed') {
+                const artifacts = result.receipt.publishableEvidence.map((artifact) => ({ relativePath: artifact.ref, sha256: artifact.sha256 }));
+                const copied = await git.candidateV2.copyProofArtifacts({
+                    materialization: proofInput.materialization,
+                    issueWorktreePath,
+                    artifactDir: config.proof.artifactDir,
+                    proofId: proofInput.proofId,
+                    artifacts,
+                });
+                if (copied.kind === 'failed')
+                    throw new CandidateProofInspectionError(copied.code);
+                if (copied.value.kind === 'artifact-conflict')
+                    throw new CandidateProofInspectionError('candidate-artifact-conflict');
+            }
+            return result;
         },
     };
     const runner = new RunIssue({
@@ -918,6 +1362,8 @@ export function createV2Runtime(input) {
                         id: comment.id,
                         body: comment.body,
                         authorAssociation: comment.authorAssociation,
+                        author: comment.author.login,
+                        authorId: comment.author.id,
                         createdAt: comment.createdAt,
                         updatedAt: comment.updatedAt,
                     })),
@@ -930,9 +1376,10 @@ export function createV2Runtime(input) {
                     removeLabels: current.filter((label) => !labels.includes(label)),
                 });
             },
+            getRepositoryPermission: (login, expectedUserId) => input.issues.getRepositoryPermission(login, expectedUserId),
             transitionToBlocked: async (issueNumber, labels) => {
                 const current = await input.issues.getLabels(issueNumber);
-                if (current.includes(labels.review) || current.includes(labels.waitingHuman))
+                if (current.includes(labels.review))
                     return;
                 const hasRunnerStatus = current.some((label) => (label === labels.auto || label === labels.running || label === labels.blocked));
                 if (!hasRunnerStatus)
@@ -949,7 +1396,7 @@ export function createV2Runtime(input) {
                 const matches = (await input.pullRequests.listAllByHeadBranch(headBranch))
                     .filter((pullRequest) => pullRequest.state === 'OPEN' && pullRequest.baseRefName === baseBranch);
                 if (matches.length > 1)
-                    throw new Error('multiple open pull requests match publication intent');
+                    throw new Error('multiple open pull requests match publication pendingEffect');
                 const match = matches[0];
                 if (!match)
                     return undefined;
@@ -970,59 +1417,17 @@ export function createV2Runtime(input) {
                 return { id: comment.id, body: comment.body };
             },
         },
-        reviewFeedback: new ReviewFeedbackCoordinator({ pullRequests: input.pullRequests, issues: input.issues, now }),
+        reviewFeedback: new ReviewFeedbackObserver({ pullRequests: input.pullRequests, issues: input.issues, now }),
         git,
-        routeCoordinator: {
-            run: ({ state, ...routeInput }) => new RouteCoordinator({
-                state,
-                operation: reportOperation,
-                createAttemptId: input.createAttemptId ?? randomUUID,
-                now,
-                createReceipt: ({ artifact, triage, review, decidedAt }) => {
-                    if (artifact.status === 'blocked')
-                        throw new Error('blocked triage cannot create a route receipt');
-                    const receipt = {
-                        version: 1,
-                        route: artifact.status,
-                        triage,
-                        review,
-                        artifact,
-                        decisionSha256: '',
-                        decidedAt,
-                        assumptions: [...artifact.assumptions],
-                    };
-                    receipt.decisionSha256 = hashRouteDecision(receipt);
-                    return validateRouteReceipt(receipt, triage.generationHash);
-                },
-            }).run(routeInput),
-        },
-        routeContinuations: {
-            direct: async () => ({ status: 'completed' }),
-            specRequired: (context, state, signal) => new SpecCoordinator({ state, operation: specOperation }).run(context, signal),
-            awaitingUser: async (context, state, signal) => {
-                const config = requireConfig(currentConfig);
-                return new WaitingHumanCoordinator({
-                    issues: input.issues,
-                    labels: {
-                        auto: config.github.labels.auto.name,
-                        running: config.github.labels.running.name,
-                        blocked: config.github.labels.blocked.name,
-                        review: config.github.labels.review.name,
-                        waitingHuman: config.github.labels.waitingHuman.name,
-                    },
-                    now,
-                }).run(context, state, signal);
-            },
-        },
         implementationAgent,
         implementationReviewer,
-        waitForReviewProcessAbsence: waitForProcessGroupAbsent,
         checks: {
-            run: async ({ source, command, cwd, signal }) => {
+            supportsLaunchOwnership: true,
+            run: async ({ source, command, cwd, signal, onLaunched }) => {
                 const timeoutMs = requireConfig(currentConfig).codex.timeoutMs;
                 return source === 'issue'
-                    ? runProcessCheck(parseIssueCheckInvocation(command), cwd, signal, timeoutMs)
-                    : runShellCheck(command, cwd, signal, timeoutMs);
+                    ? runProcessCheck(parseIssueCheckInvocation(command), cwd, signal, timeoutMs, onLaunched)
+                    : runShellCheck(command, cwd, signal, timeoutMs, onLaunched);
             },
         },
         proof,
@@ -1034,12 +1439,56 @@ export function createV2Runtime(input) {
             await writeDurableAtomicFile(resolve(targetRoot, relativePath), `${canonicalJson({ version: 1, runId, code, summary, recordedAt: now() })}\n`);
             return { id: `evidence:${runId}:${code}`, path: relativePath };
         },
+        outcomeEvidencePath: (runId, code, summarySha256) => `${requireConfig(currentConfig).runner.stateDir}/v2/evidence/${runId}/${sha256(code)}-${summarySha256}.json`,
+        inspectOutcomeEvidence: async (path) => {
+            try {
+                return { sha256: sha256(await readRegularFile(resolve(targetRoot, path))) };
+            }
+            catch (error) {
+                if (isErrorCode(error, 'ENOENT'))
+                    return undefined;
+                throw error;
+            }
+        },
+        writeOutcomeEvidence: ({ path, bytes, sha256: expectedSha256 }) => writeExactDurableBytes(resolve(targetRoot, path), bytes, expectedSha256),
         packageVersion: input.packageVersion,
         createWorkflowGeneration: input.createWorkflowGeneration,
         verifyWorkflowGeneration,
         createRunId: input.createRunId ?? randomUUID,
         createProofId: input.createProofId ?? randomUUID,
         createReviewSessionId: input.createAttemptId ?? randomUUID,
+        processIdentity: {
+            host: hostname(),
+            bootId: input.bootId,
+            capture: async (pid, processGroupId) => {
+                const captured = await captureProcessStartIdentity({ platform: process.platform, pid, processGroupId });
+                return captured.status === 'available' ? captured.identity : undefined;
+            },
+            observe: async (identity) => ({
+                leader: await observeProcessIdentity({ platform: process.platform, ...identity }),
+                group: observeProcessGroup(identity.processGroupId),
+            }),
+        },
+        inspectAttemptResult: async (path) => {
+            try {
+                const bytes = await readRegularFile(path);
+                return { bytes, sha256: sha256(bytes) };
+            }
+            catch (error) {
+                if (isErrorCode(error, 'ENOENT'))
+                    return undefined;
+                throw error;
+            }
+        },
+        observeAttemptCleanup: async (attempt) => {
+            return observeAttemptReadViewCleanup({
+                orchestratorHome,
+                canonicalRepository: requireCanonicalRepository(currentConfig),
+                identity: attempt,
+            });
+        },
+        writeAttemptResult: ({ path, bytes, sha256: expectedSha256 }) => writeExactDurableBytes(path, bytes, expectedSha256),
+        attemptResultPath: ({ canonicalRepository, runId, attemptId }) => join(resolve(orchestratorHome), 'v2', sha256(canonicalRepository), 'runs', runId, 'attempts', attemptId, 'report.json'),
         now,
         signal: controller.signal,
     });
@@ -1078,7 +1527,10 @@ async function acquireOwnerLock(input) {
     }
 }
 async function readRegularFile(path) {
-    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const beforeOpen = await lstat(path);
+    if (beforeOpen.isSymbolicLink() || !beforeOpen.isFile())
+        throw new Error(`${path} is not a bounded regular file`);
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
     try {
         const stat = await handle.stat();
         if (!stat.isFile() || stat.size > 5 * 1024 * 1024)
@@ -1089,6 +1541,24 @@ async function readRegularFile(path) {
         await handle.close();
     }
 }
+async function writeExactDurableBytes(path, bytes, expectedSha256) {
+    if (sha256(bytes) !== expectedSha256)
+        throw new Error('durable result bytes do not match expected SHA-256');
+    try {
+        const existing = await readRegularFile(path);
+        if (sha256(existing) !== expectedSha256)
+            throw new Error('durable result path already contains different bytes');
+        return;
+    }
+    catch (error) {
+        if (!isErrorCode(error, 'ENOENT'))
+            throw error;
+    }
+    await writeDurableAtomicFile(path, bytes, 0o600);
+    const observed = await readRegularFile(path);
+    if (sha256(observed) !== expectedSha256)
+        throw new Error('durable result write postcondition failed');
+}
 async function inspectRegularFile(path) {
     const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
@@ -1101,15 +1571,20 @@ async function inspectRegularFile(path) {
         await handle.close();
     }
 }
-export async function runShellCheck(command, cwd, signal, timeoutMs) {
-    return runSpawnCheck('/bin/sh', ['-lc', command], cwd, signal, timeoutMs);
+export async function runShellCheck(command, cwd, signal, timeoutMs, onLaunched) {
+    return runSpawnCheck('/bin/sh', ['-lc', command], cwd, signal, timeoutMs, onLaunched);
 }
-async function runProcessCheck(invocation, cwd, signal, timeoutMs) {
-    return runSpawnCheck(invocation.file, invocation.args, cwd, signal, timeoutMs);
+async function runProcessCheck(invocation, cwd, signal, timeoutMs, onLaunched) {
+    return runSpawnCheck(invocation.file, invocation.args, cwd, signal, timeoutMs, onLaunched);
 }
-async function runSpawnCheck(file, args, cwd, signal, timeoutMs) {
+async function runSpawnCheck(file, args, cwd, signal, timeoutMs, onLaunched) {
     return new Promise((resolveCheck, rejectCheck) => {
-        const child = spawn(file, args, { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        const child = spawn('/bin/sh', [
+            '-c', 'IFS= read -r _ || exit 125; exec "$@"', 'codex-orchestrator-check-gate', file, ...args,
+        ], { cwd, detached: true, stdio: ['pipe', 'pipe', 'pipe'] });
+        const launchOwnership = child.pid && onLaunched
+            ? onLaunched({ pid: child.pid, processGroupId: child.pid })
+            : Promise.resolve();
         const chunks = [];
         let retained = 0;
         const outputHash = createHash('sha256');
@@ -1150,6 +1625,7 @@ async function runSpawnCheck(file, args, cwd, signal, timeoutMs) {
             }, 5_000);
             killTimer.unref();
         };
+        void launchOwnership.then(() => child.stdin.end('\n')).catch(() => terminate());
         signal.addEventListener('abort', terminate, { once: true });
         if (signal.aborted)
             terminate();
@@ -1189,10 +1665,15 @@ async function runSpawnCheck(file, args, cwd, signal, timeoutMs) {
                     rejectCheck(new Error(`Check exceeded ${timeoutMs}ms and was terminated.`));
                     return;
                 }
+                await launchOwnership;
                 resolveCheck({
                     status: code === 0 ? 'passed' : 'failed',
                     output: Buffer.concat(chunks),
                     outputSha256: outputHash.digest('hex'),
+                    observation: {
+                        leader: 'absent',
+                        group: child.pid ? observeProcessGroup(child.pid) : 'unknown',
+                    },
                 });
             })().catch(rejectCheck);
         });
@@ -1303,8 +1784,7 @@ async function prepareContainedAttempt(input) {
         operation: input.operationId,
         bootId: input.bootId,
     });
-    const reportOnly = input.operationId === 'triage' || input.operationId === 'ambiguity-review'
-        || input.operationId === 'code-review' || input.operationId === 'spec-review';
+    const reportOnly = input.operationId === 'code-review';
     if ((reportOnly
         ? snapshot.policy.sandboxMode !== 'read-only'
             || snapshot.policy.worktreeAccess !== 'read-only'
@@ -1340,6 +1820,8 @@ async function prepareContainedAttempt(input) {
         tmpDir,
         policy: structuredClone(snapshot.policy),
         profile,
+        reviewers: Object.keys(snapshot.reviewerProfiles).sort(),
+        reviewerProfiles: structuredClone(snapshot.reviewerProfiles),
     };
 }
 async function artifactInventory(root, logicalRoot) {
@@ -1355,7 +1837,9 @@ async function artifactInventory(root, logicalRoot) {
     }
     if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
         throw new Error('proof artifact root must be a direct directory');
+    const rootIdentity = await inspectSafeArtifactRoot(root);
     const visit = async (directory, relative) => {
+        await assertSafeArtifactRoot(rootIdentity);
         for (const entry of await readdir(directory, { withFileTypes: true })) {
             const childRelative = relative ? `${relative}/${entry.name}` : entry.name;
             const childPath = join(directory, entry.name);
@@ -1364,7 +1848,7 @@ async function artifactInventory(root, logicalRoot) {
             if (entry.isDirectory())
                 await visit(childPath, childRelative);
             else if (entry.isFile())
-                output.set(`${logicalRoot}/${childRelative}`, sha256(await readFile(childPath)));
+                output.set(`${logicalRoot}/${childRelative}`, sha256(await readRegularFileWithoutSymlinkAncestors(rootIdentity, childPath)));
             else
                 throw new Error('proof artifact tree contains a special file');
         }
@@ -1413,20 +1897,6 @@ async function fingerprintDeniedEntry(path, existingInfo) {
     }
     return { kind: 'directory', entries };
 }
-async function waitForProcessGroupAbsent(processGroupId) {
-    while (true) {
-        try {
-            process.kill(-processGroupId, 0);
-        }
-        catch (error) {
-            if (isErrorCode(error, 'ESRCH'))
-                return;
-            if (!isErrorCode(error, 'EPERM'))
-                throw error;
-        }
-        await new Promise((resolveWait) => setTimeout(resolveWait, 1_000));
-    }
-}
 export async function materializeReportReadView(input) {
     await assertDisjointReadViewPaths(input.worktreePath, input.destination);
     const deniedPaths = normalizeReadViewDeniedPaths(input.deniedPaths);