codex-orchestrator 2.0.4 → 2.0.6

package/dist/src/v2/runtime.js

@@ -1,12 +1,14 @@
 import { constants } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { lstat, mkdir, open, readFile, readdir, readlink, realpath, rm } from 'node:fs/promises';
+import { access, lstat, mkdir, open, readFile, readdir, readlink, realpath, rm } 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 { defaultProcessExecutor } from './adapters/command.js';
+import { RunnerAndroidProofController } from './android-proof-runner.js';
 import { AcceptanceProof, ProofQuiescenceError } from './acceptance-proof.js';
 import { createCheckedChangeCapabilities } from './checked-change.js';
 import { InjectedContainedReportOperation } from './contained-report-operation.js';
@@ -47,6 +49,30 @@ export class LocalGitRunIssueAdapter {
             requiredBaseSha: input.baseSha,
         });
     }
+    async ensureContinuationWorktree(input) {
+        const localHead = (await this.git([
+            '-C', input.targetRoot, 'rev-parse', '--verify', `refs/heads/${input.branchName}`,
+        ])).trim();
+        const remoteHead = await this.getRemoteBranchSha(input.targetRoot, input.branchName);
+        if (localHead !== input.publishedHeadSha || remoteHead !== input.publishedHeadSha) {
+            throw new Error('continuation branch refs do not exactly match the published head');
+        }
+        await this.worktrees.ensureIssueWorktree({
+            targetRoot: input.targetRoot,
+            workspacePath: input.worktreePath,
+            branchName: input.branchName,
+            baseBranch: input.baseBranch,
+            requiredBaseSha: input.publishedHeadSha,
+            allowResume: true,
+        });
+        const observed = await this.inspectWorktree({
+            worktreePath: input.worktreePath,
+            branchName: input.branchName,
+            baseSha: input.publishedHeadSha,
+        });
+        if (observed !== 'matching')
+            throw new Error('continuation worktree does not match the published head');
+    }
     async inspectWorktree(input) {
         try {
             const stat = await lstat(input.worktreePath);
@@ -110,6 +136,9 @@ export class LocalGitRunIssueAdapter {
     listChangedFiles(worktreePath) {
         return this.worktrees.listChangedFiles(worktreePath);
     }
+    listChangedFilesIgnoringUntrackedRoot(worktreePath, ignoredRoot) {
+        return this.worktrees.listChangedFilesIgnoringUntrackedRoot(worktreePath, ignoredRoot);
+    }
     async fingerprintChangedFiles(worktreePath, changedFiles) {
         const root = await realpath(worktreePath);
         const entries = [];
@@ -193,6 +222,12 @@ export class ContainedImplementationAgent {
             bootId: this.dependencies.bootId,
         });
         const baseline = await this.dependencies.git.snapshot(input.worktreePath);
+        await input.onPrepared?.({
+            attemptId,
+            reportPath: attempt.reportPath,
+            preparedAt: (this.dependencies.now ?? (() => new Date().toISOString()))(),
+            baseline,
+        });
         try {
             const result = await (this.dependencies.process ?? new CodexProcess()).run({
                 codexPath: config.codex.command,
@@ -210,6 +245,8 @@ export class ContainedImplementationAgent {
                     `The operation's immutable workflow root is ${attempt.workflowRoot}.`,
                     `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)}`] : []),
                     `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.'] : []),
@@ -219,6 +256,9 @@ 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()))(),
+                    }) } : {}),
             }, input.signal);
             if (result.kind === 'cancelled')
                 return { kind: 'cancelled' };
@@ -248,6 +288,26 @@ export class ContainedImplementationAgent {
             };
         }
     }
+    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;
@@ -271,8 +331,6 @@ export class ContainedProofAgent {
         });
         const artifactRoot = resolve(worktreePath, config.proof.artifactDir);
         const snapshotRoot = dirname(attempt.sourceSkillPath ?? attempt.operationPath);
-        const androidLeaseRoot = join(resolve(this.dependencies.orchestratorHome), 'v2', sha256(canonicalRepository), 'leases');
-        const androidLeaseArtifact = join(artifactRoot, input.proofId, 'android-lease.json');
         const iosLeaseRoot = join(resolve(this.dependencies.orchestratorHome), 'v2', sha256(canonicalRepository), 'leases');
         const iosLeaseArtifact = join(artifactRoot, input.proofId, 'ios-lease.json');
         const iosTooling = await discoverIosTooling(this.dependencies.processExecutor, this.dependencies.iosXcrunPath);
@@ -300,12 +358,14 @@ export class ContainedProofAgent {
                     `Write evidence only below ${config.proof.artifactDir}.`,
                     'When a frozen criterion has a browser surface, follow references/browser.md from the exact acceptance-proof skill snapshot.',
                     'When a frozen criterion has an Android surface, follow references/android.md from the exact acceptance-proof skill snapshot.',
-                    `Android lease helper: ${join(snapshotRoot, 'tools', 'android-lease.mjs')}.`,
-                    `Android lease root: ${androidLeaseRoot}.`,
-                    `Android lease artifact: ${androidLeaseArtifact}.`,
-                    `Android lease proof ID: ${input.proofId}.`,
-                    `Android lease owner PID: ${process.pid}.`,
-                    `Android adb path: ${this.dependencies.androidAdbPath}.`,
+                    ...(config.proof.android ? [
+                        `Runner-owned Android artifact paths: ${canonicalJson(input.runnerPreparedArtifactPaths)}.`,
+                        `Runner-owned Android preparation warnings: ${canonicalJson(input.runnerPreparationWarnings)}.`,
+                        'The trusted Runner owns emulator, build, adb, lease, capture, and cleanup actions. Do not invoke adb, emulator, Flutter run, or an Android lease helper.',
+                        'Inspect Runner artifacts when present. If preparation warnings are present, continue with all available non-visual evidence and preserve the warning as a residual risk; Android infrastructure failure alone must not block delivery.',
+                    ] : [
+                        'Runner-owned Android proof is not configured for this repository. Do not invoke adb, emulator, Flutter run, or an Android lease helper; return a typed tool blocker for Android criteria.',
+                    ]),
                     'When a frozen criterion has an iOS surface, follow references/ios.md from the exact acceptance-proof skill snapshot.',
                     `iOS lease helper: ${join(snapshotRoot, 'tools', 'ios-lease.mjs')}.`,
                     `iOS lease root: ${iosLeaseRoot}.`,
@@ -347,11 +407,43 @@ export class ContainedProofAgent {
         }
     }
 }
+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');
+    if (!isAbsolute(command) && command.includes('/'))
+        throw new Error('relative Codex command paths are not supported');
+    const candidates = isAbsolute(command)
+        ? [command]
+        : safePath.split(':').filter((entry) => entry.length > 0).map((entry) => join(entry, command));
+    for (const candidate of candidates) {
+        try {
+            const canonical = await realpath(candidate);
+            const stat = await lstat(canonical);
+            if (!stat.isFile())
+                continue;
+            await access(canonical, constants.X_OK);
+            return canonical;
+        }
+        catch {
+            // Try the next safe-path entry.
+        }
+    }
+    throw new Error('Codex executable is unavailable in the configured safe path');
+}
 export function createV2Runtime(input) {
     const targetRoot = resolve(input.targetRoot);
     const orchestratorHome = resolve(input.orchestratorHome);
     const now = input.now ?? (() => new Date().toISOString());
     const commandExecutor = input.processExecutor ?? defaultProcessExecutor;
+    const runtimeSafePath = requireRuntimeString(input.safePath, 'safePath');
+    let codexExecutable;
+    const resolveRuntimeCodex = async (command) => {
+        if (codexExecutable?.command === command)
+            return codexExecutable.path;
+        const path = await resolveCodexExecutable(command, runtimeSafePath);
+        codexExecutable = { command, path };
+        return path;
+    };
     const git = input.git ?? new LocalGitRunIssueAdapter(commandExecutor);
     const proofFreshnessGit = git;
     const controller = new AbortController();
@@ -364,12 +456,13 @@ export function createV2Runtime(input) {
         ?? (process.env.ANDROID_SDK_ROOT ? join(process.env.ANDROID_SDK_ROOT, 'platform-tools', 'adb') : undefined)
         ?? join(homedir(), 'Library', 'Android', 'sdk', 'platform-tools', 'adb');
     const androidAdbPath = resolve(configuredAndroidAdbPath);
+    const androidEmulatorPath = join(dirname(dirname(androidAdbPath)), 'emulator', 'emulator');
     const iosXcrunPath = resolve(input.iosXcrunPath ?? '/usr/bin/xcrun');
     const containedDependencies = () => ({
         config: () => requireConfig(currentConfig),
         orchestratorHome,
         parentCodexHome: requireRuntimeString(input.parentCodexHome, 'parentCodexHome'),
-        safePath: requireRuntimeString(input.safePath, 'safePath'),
+        safePath: runtimeSafePath,
         bootId: input.bootId,
         process: containedProcess,
         createAttemptId: input.createAttemptId,
@@ -386,6 +479,12 @@ export function createV2Runtime(input) {
         iosXcrunPath,
         processExecutor: commandExecutor,
     });
+    const androidProofController = new RunnerAndroidProofController({
+        adbPath: androidAdbPath,
+        emulatorPath: androidEmulatorPath,
+        execute: commandExecutor,
+        now: () => new Date(now()),
+    });
     const reportOperation = new InjectedContainedReportOperation({
         prepare: async ({ operation, attemptId, runId, workflowGeneration }) => ({
             operation,
@@ -676,7 +775,11 @@ export function createV2Runtime(input) {
         if (resolve(requestedRoot) !== targetRoot)
             throw new Error('runtime target root mismatch');
         const bytes = await readRegularFile(join(targetRoot, '.codex-orchestrator', 'config.json'));
-        const config = parseAgentAutoConfig(parseJsonWithoutDuplicateKeys(bytes.toString('utf8')));
+        const parsed = parseAgentAutoConfig(parseJsonWithoutDuplicateKeys(bytes.toString('utf8')));
+        const config = {
+            ...parsed,
+            codex: { ...parsed.codex, command: await resolveRuntimeCodex(parsed.codex.command) },
+        };
         const path = join(targetRoot, config.runner.stateDir, 'v2', 'run-state.json');
         if (!runRecords)
             runRecords = new FileRunRecordWriter(path);
@@ -708,6 +811,7 @@ export function createV2Runtime(input) {
                 worktreeRoot: worktreePath,
                 now: () => new Date(now()),
                 artifactRelativePathForProof: (proofId) => `${config.proof.artifactDir}/${proofId}/android-lease.json`,
+                targetController: androidProofController,
             });
             const iosLease = new FileIosLeaseVerifier({
                 leaseRoot: join(orchestratorHome, 'v2', repoKey, 'leases'),
@@ -737,18 +841,56 @@ export function createV2Runtime(input) {
                 now,
                 signal: controller.signal,
             });
-            return acceptanceProof.proveChange(proofInput);
+            const androidRelevant = !!config.proof.android && isAndroidProofRelevant(proofInput.issue, proofInput.frozenCriteria, checked.payload.changedFiles);
+            const runnerPreparedArtifactPaths = [];
+            const runnerPreparedArtifactSha256 = {};
+            const runnerPreparationWarnings = [];
+            let preparationAttempted = false;
+            return acceptanceProof.proveChange({
+                ...proofInput,
+                runnerPreparedArtifactPaths,
+                runnerPreparedArtifactSha256,
+                runnerPreparationWarnings,
+                beforeAgentLaunch: async () => {
+                    await proofInput.beforeAgentLaunch?.();
+                    if (!androidRelevant || preparationAttempted)
+                        return;
+                    preparationAttempted = true;
+                    const prepared = await androidProofController.prepare({
+                        proofId: proofInput.proofId,
+                        worktreePath,
+                        artifactDir: config.proof.artifactDir,
+                        leaseRoot: join(orchestratorHome, 'v2', repoKey, 'leases'),
+                        config: config.proof.android,
+                        checks: checked.payload.checks,
+                        checkedChangeSha256: checked.checkedChangeSha256,
+                        proofAgentBudgetMs: config.codex.timeoutMs * 3,
+                        signal: controller.signal,
+                    });
+                    if (prepared.status === 'prepared') {
+                        runnerPreparedArtifactPaths.splice(0, runnerPreparedArtifactPaths.length, ...prepared.runnerPreparedArtifactPaths);
+                        Object.assign(runnerPreparedArtifactSha256, prepared.runnerPreparedArtifactSha256);
+                    }
+                    else {
+                        runnerPreparationWarnings.push(`Android UI proof unfinished: ${prepared.summary}`);
+                    }
+                },
+            });
         },
     };
     const runner = new RunIssue({
         readConfig,
         validateContainment: async (config) => {
             const certificate = await readContainmentCertificate(containmentCertificatePath(orchestratorHome));
-            const version = await commandExecutor(config.codex.command, ['--version']);
+            const executablePath = await resolveRuntimeCodex(config.codex.command);
+            const version = await commandExecutor(executablePath, ['--version']);
             if (version.exitCode !== 0)
                 throw new Error('Codex version is unavailable');
             assertContainmentCertificateMatchesRuntime(certificate, {
                 codexVersion: version.stdout.trim(),
+                codexExecutablePath: executablePath,
+                codexExecutableSha256: sha256(await readFile(executablePath)),
+                packageVersion: input.packageVersion,
                 argvPolicySha256: containmentArgvPolicySha256(),
             });
         },
@@ -777,7 +919,13 @@ export function createV2Runtime(input) {
                     url: issue.url,
                     state: 'OPEN',
                     labels: issue.labels.map((label) => label.name).sort(),
-                    comments: comments.map((comment) => ({ body: comment.body, authorAssociation: comment.authorAssociation })),
+                    comments: comments.map((comment) => ({
+                        id: comment.id,
+                        body: comment.body,
+                        authorAssociation: comment.authorAssociation,
+                        createdAt: comment.createdAt,
+                        updatedAt: comment.updatedAt,
+                    })),
                 };
             },
             setLabels: async (issueNumber, labels) => {
@@ -796,10 +944,26 @@ export function createV2Runtime(input) {
                 if (matches.length > 1)
                     throw new Error('multiple open pull requests match publication intent');
                 const match = matches[0];
-                return match ? { url: match.url, body: match.body } : undefined;
+                if (!match)
+                    return undefined;
+                const reviewTarget = await input.pullRequests.getReviewTarget(match.number);
+                return {
+                    url: match.url,
+                    body: match.body,
+                    number: match.number,
+                    nodeId: match.nodeId,
+                    ...(reviewTarget ? { headSha: reviewTarget.headRefOid } : {}),
+                };
             },
             createDraft: async ({ title, body, headBranch, baseBranch }) => input.pullRequests.createDraftPullRequest({ title, body, headBranch, baseBranch }),
+            listConversationComments: async (number) => (await input.pullRequests.listConversationComments(number))
+                .map((comment) => ({ id: comment.id, body: comment.body })),
+            postConversationComment: async (number, body) => {
+                const comment = await input.pullRequests.postConversationComment(number, body);
+                return { id: comment.id, body: comment.body };
+            },
         },
+        reviewFeedback: new ReviewFeedbackCoordinator({ pullRequests: input.pullRequests, issues: input.issues, now }),
         git,
         routeCoordinator: {
             run: ({ state, ...routeInput }) => new RouteCoordinator({
@@ -1332,6 +1496,10 @@ async function scrubReportReadView(directory) {
         }
     }
 }
+function isAndroidProofRelevant(issue, criteria, changedFiles) {
+    return /\bandroid\b/iu.test([issue.title, issue.body, ...criteria.map((criterion) => criterion.text)].join('\n'))
+        || changedFiles.some((path) => /^(?:android\/|lib\/|assets\/|fonts\/|pubspec\.(?:yaml|lock)$)/u.test(path));
+}
 function isErrorCode(error, code) {
     return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
 }