@kontourai/flow-agents 3.2.0 → 3.4.0

package/src/cli/builder-flow-runtime.test.mjs

@@ -0,0 +1,213 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { FLOW_RUN_EVIDENCE_MANIFEST_PATH, runDir } from "@kontourai/flow";
+import {
+  startBuilderFlowSession,
+  syncBuilderFlowSession,
+} from "../../build/src/builder-flow-runtime.js";
+
+const SUBJECT = "local:work-item/runtime-projection";
+const NOW = "2026-07-09T20:00:00.000Z";
+
+function makeSession(slug = "runtime-projection") {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "flow-agents-builder-runtime-"));
+  const artifactRoot = path.join(projectRoot, ".kontourai", "flow-agents");
+  const sessionDir = path.join(artifactRoot, slug);
+  writeJson(path.join(sessionDir, "state.json"), {
+    schema_version: "1.0",
+    task_slug: slug,
+    status: "planned",
+    phase: "planning",
+    updated_at: NOW,
+    work_item_refs: [SUBJECT],
+    next_action: { status: "continue", summary: "Start Builder." },
+  });
+  writeJson(path.join(artifactRoot, "current.json"), {
+    active_slug: slug,
+    artifact_dir: `.kontourai/flow-agents/${slug}`,
+    updated_at: NOW,
+  });
+  return { projectRoot, artifactRoot, sessionDir, slug };
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function bundleClaim({ expectation, claimType, subjectType, status = "pass", routeReason, subject = SUBJECT }) {
+  const claimId = `claim.${expectation}`;
+  return {
+    claim: {
+      id: claimId,
+      subjectType,
+      subjectId: `runtime-projection/gate-claim-${expectation}`,
+      claimType,
+      fieldOrBehavior: `${expectation} fixture`,
+      value: status,
+      metadata: {
+        workflow_subject_ref: subject,
+        gate_claim: {
+          expectation_id: expectation,
+          claim_type: claimType,
+          subject_type: subjectType,
+          ...(routeReason ? { route_reason: routeReason } : {}),
+        },
+      },
+      createdAt: NOW,
+      updatedAt: NOW,
+    },
+    evidence: {
+      id: `evidence.${expectation}`,
+      claimId,
+      evidenceType: "human_attestation",
+      method: "attestation",
+      sourceRef: "src/cli/builder-flow-runtime.test.mjs",
+      excerptOrSummary: `${expectation} fixture`,
+      observedAt: NOW,
+      collectedBy: "flow-agents-test",
+    },
+    event: {
+      id: `event.${expectation}`,
+      claimId,
+      status: status === "pass" ? "verified" : "disputed",
+      actor: "flow-agents-test",
+      method: "attestation",
+      evidenceIds: [`evidence.${expectation}`],
+      createdAt: NOW,
+      verifiedAt: NOW,
+    },
+  };
+}
+
+function writeBundle(sessionDir, entries) {
+  writeJson(path.join(sessionDir, "trust.bundle"), {
+    schemaVersion: 5,
+    source: "flow-agents-builder-runtime-test",
+    claims: entries.map((entry) => entry.claim),
+    evidence: entries.map((entry) => entry.evidence),
+    policies: [],
+    events: entries.map((entry) => entry.event),
+  });
+}
+
+async function writeAndSync(session, entries) {
+  writeBundle(session.sessionDir, entries);
+  return syncBuilderFlowSession({ sessionDir: session.sessionDir });
+}
+
+test("small-model client can start and advance from projected actions without choosing Flow steps", async () => {
+  const session = makeSession();
+  const started = await startBuilderFlowSession({ sessionDir: session.sessionDir });
+
+  assert.equal(started.run.state.current_step, "pull-work");
+  assert.deepEqual(started.projection.next_action.skills, ["pull-work"]);
+  assert.deepEqual(started.projection.next_action.operations, []);
+  assert.equal(started.projection.next_action.command, `flow-agents builder-run sync --session-dir .kontourai/flow-agents/${session.slug}`);
+  assert.ok(fs.existsSync(runDir(session.slug, session.projectRoot)));
+  assert.ok(!fs.existsSync(path.join(session.projectRoot, ".flow", "runs")), "retired runtime path must not be created");
+
+  const advanced = await writeAndSync(session, [bundleClaim({
+    expectation: "selected-work",
+    claimType: "builder.pull-work.selected",
+    subjectType: "work-item",
+  })]);
+
+  assert.equal(advanced.attached, true);
+  assert.equal(advanced.run.state.current_step, "design-probe");
+  assert.deepEqual(advanced.projection.next_action.skills, ["pickup-probe"]);
+  assert.equal(readJson(path.join(session.artifactRoot, "current.json")).active_step_id, "design-probe");
+
+  const duplicate = await syncBuilderFlowSession({ sessionDir: session.sessionDir });
+  assert.equal(duplicate.attached, false);
+  assert.equal(duplicate.run.manifest.evidence.length, advanced.run.manifest.evidence.length);
+});
+
+test("wrong workflow subject is rejected before canonical Flow mutation", async () => {
+  const session = makeSession("wrong-subject");
+  await startBuilderFlowSession({ sessionDir: session.sessionDir });
+  const beforeState = readJson(path.join(runDir(session.slug, session.projectRoot), "state.json"));
+  const beforeManifest = readJson(path.join(runDir(session.slug, session.projectRoot), FLOW_RUN_EVIDENCE_MANIFEST_PATH));
+  writeBundle(session.sessionDir, [bundleClaim({
+    expectation: "selected-work",
+    claimType: "builder.pull-work.selected",
+    subjectType: "work-item",
+    subject: "local:work-item/other",
+  })]);
+
+  await assert.rejects(
+    () => syncBuilderFlowSession({ sessionDir: session.sessionDir }),
+    /workflow_subject_ref.*persisted run subject/,
+  );
+  assert.deepEqual(readJson(path.join(runDir(session.slug, session.projectRoot), "state.json")), beforeState);
+  assert.deepEqual(readJson(path.join(runDir(session.slug, session.projectRoot), FLOW_RUN_EVIDENCE_MANIFEST_PATH)), beforeManifest);
+});
+
+test("failed verification projects Flow-owned route-back attempt and budget", async () => {
+  const session = makeSession("route-back-projection");
+  await startBuilderFlowSession({ sessionDir: session.sessionDir });
+  await writeAndSync(session, [bundleClaim({ expectation: "selected-work", claimType: "builder.pull-work.selected", subjectType: "work-item" })]);
+  await writeAndSync(session, [
+    bundleClaim({ expectation: "pickup-probe-readiness", claimType: "builder.design-probe.pickup-readiness", subjectType: "work-item" }),
+    bundleClaim({ expectation: "probe-decisions-or-accepted-gaps", claimType: "builder.design-probe.decisions", subjectType: "decision" }),
+  ]);
+  await writeAndSync(session, [bundleClaim({ expectation: "implementation-plan", claimType: "builder.plan.implementation", subjectType: "artifact" })]);
+  const verify = await writeAndSync(session, [bundleClaim({ expectation: "implementation-scope", claimType: "builder.execute.scope", subjectType: "change" })]);
+  assert.equal(verify.run.state.current_step, "verify");
+
+  const routed = await writeAndSync(session, [bundleClaim({
+    expectation: "tests-evidence",
+    claimType: "builder.verify.tests",
+    subjectType: "flow-step",
+    status: "fail",
+    routeReason: "implementation_defect",
+  })]);
+
+  assert.equal(routed.run.state.current_step, "execute");
+  assert.equal(routed.projection.flow_run.route_back_attempt, 1);
+  assert.equal(routed.projection.flow_run.route_back_max_attempts, 3);
+  assert.match(routed.projection.next_action.summary, /Route-back history: attempt 1\/3 returned to `execute` for `implementation_defect`/);
+  assert.deepEqual(routed.projection.next_action.skills, ["execute-plan"]);
+});
+
+test("verified sidecar claims drive the composed publish and learning prefix to completion", async () => {
+  const session = makeSession("composed-completion");
+  await startBuilderFlowSession({ sessionDir: session.sessionDir });
+  const steps = [
+    [bundleClaim({ expectation: "selected-work", claimType: "builder.pull-work.selected", subjectType: "work-item" })],
+    [
+      bundleClaim({ expectation: "pickup-probe-readiness", claimType: "builder.design-probe.pickup-readiness", subjectType: "work-item" }),
+      bundleClaim({ expectation: "probe-decisions-or-accepted-gaps", claimType: "builder.design-probe.decisions", subjectType: "decision" }),
+    ],
+    [bundleClaim({ expectation: "implementation-plan", claimType: "builder.plan.implementation", subjectType: "artifact" })],
+    [bundleClaim({ expectation: "implementation-scope", claimType: "builder.execute.scope", subjectType: "change" })],
+    [bundleClaim({ expectation: "tests-evidence", claimType: "builder.verify.tests", subjectType: "flow-step" })],
+    [bundleClaim({ expectation: "merge-readiness", claimType: "builder.merge-ready.readiness", subjectType: "change" })],
+  ];
+  for (const entries of steps) await writeAndSync(session, entries);
+
+  const prOpen = readJson(path.join(session.sessionDir, "state.json"));
+  assert.equal(prOpen.flow_run.current_step, "pr-open");
+  assert.deepEqual(prOpen.next_action.skills, []);
+  assert.deepEqual(prOpen.next_action.operations, ["publish-change"]);
+
+  await writeAndSync(session, [bundleClaim({ expectation: "pull-request-opened", claimType: "builder.pr-open.pull-request", subjectType: "pull-request" })]);
+  await writeAndSync(session, [bundleClaim({ expectation: "ci-merge-readiness", claimType: "builder.merge-ready-ci.readiness", subjectType: "pull-request" })]);
+  const completed = await writeAndSync(session, [
+    bundleClaim({ expectation: "decision-evidence", claimType: "builder.learn.decisions", subjectType: "decision" }),
+    bundleClaim({ expectation: "learning-evidence", claimType: "builder.learn.evidence", subjectType: "release" }),
+  ]);
+
+  assert.equal(completed.run.state.current_step, "learn", JSON.stringify(completed.run.state.gate_outcomes, null, 2));
+  assert.equal(completed.run.state.status, "completed");
+  assert.equal(completed.projection.status, "delivered");
+  assert.deepEqual(completed.projection.next_action, { status: "done", summary: "Canonical Flow run is complete." });
+});

package/src/cli/builder-run.ts

@@ -0,0 +1,28 @@
+import { flagString, parseArgs } from "../lib/args.js";
+import { startBuilderFlowSession, syncBuilderFlowSession } from "../builder-flow-runtime.js";
+
+export async function main(argv: string[]): Promise<number> {
+  const parsed = parseArgs(argv);
+  const action = parsed.positionals[0];
+  const sessionDir = flagString(parsed.flags, "session-dir");
+  if (!sessionDir) {
+    console.error("builder-run requires --session-dir .kontourai/flow-agents/<slug>");
+    return 64;
+  }
+  if (action !== "start" && action !== "sync") {
+    console.error("Usage: flow-agents builder-run <start|sync> --session-dir <path>");
+    return 64;
+  }
+  const result = action === "start"
+    ? await startBuilderFlowSession({ sessionDir })
+    : await syncBuilderFlowSession({ sessionDir });
+  console.log(JSON.stringify({
+    run_id: result.run.runId,
+    definition_id: result.run.definitionId,
+    current_step: result.run.state.current_step,
+    status: result.run.state.status,
+    attached: result.attached,
+    next_action: result.projection.next_action,
+  }));
+  return 0;
+}

package/src/cli/codex-agent-routing.test.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { codexAgentRoutingErrors } from "../../build/src/tools/codex-agent-routing.js";
+
+const agents = ["tool-planner", "tool-worker"];
+const valid = {
+  codex: { allowed_agent_models: ["gpt-5.5", "gpt-5.6-sol", "gpt-5.6-terra"] },
+  codex_model_map: { default: "gpt-5.5" },
+  codex_reasoning_map: { default: "medium" },
+  codex_agent_map: {
+    "tool-planner": { model: "gpt-5.6-sol", reasoning_effort: "high" },
+    "tool-worker": { model: "gpt-5.6-terra", reasoning_effort: "high" },
+  },
+};
+
+test("accepts complete role-specific Codex routing", () => {
+  assert.deepEqual(codexAgentRoutingErrors(valid, agents), []);
+});
+
+test("rejects unknown agents, unsupported fields, models, and reasoning efforts", () => {
+  const malformed = structuredClone(valid);
+  malformed.codex_agent_map["tool-missing"] = {
+    model: "gpt-unknown",
+    reasoning_effort: "extreme",
+    extra: true,
+  };
+  const errors = codexAgentRoutingErrors(malformed, agents).join("\n");
+  assert.match(errors, /agent 'tool-missing' does not exist/);
+  assert.match(errors, /must contain exactly model and reasoning_effort/);
+  assert.match(errors, /uses unsupported model 'gpt-unknown'/);
+  assert.match(errors, /reasoning_effort is invalid: 'extreme'/);
+});
+
+test("rejects partial overrides and invalid family fallbacks", () => {
+  const malformed = structuredClone(valid);
+  malformed.codex_agent_map["tool-planner"] = { model: "gpt-5.6-sol" };
+  malformed.codex_model_map.default = "gpt-unknown";
+  malformed.codex_reasoning_map.default = "extreme";
+  const errors = codexAgentRoutingErrors(malformed, agents).join("\n");
+  assert.match(errors, /tool-planner must contain exactly model and reasoning_effort/);
+  assert.match(errors, /tool-planner.reasoning_effort is invalid: 'undefined'/);
+  assert.match(errors, /codex_model_map.default uses unsupported model 'gpt-unknown'/);
+  assert.match(errors, /codex_reasoning_map.default uses invalid reasoning effort 'extreme'/);
+});

package/src/cli/codex-exit-code.test.mjs

@@ -0,0 +1,207 @@
+// Unit tests for scripts/hooks/lib/codex-exit-code.js (#470 iteration 2).
+//
+// Loaded via createRequire (mirrors src/cli/public-api.test.mjs:35-36) since
+// the module under test is a plain CJS shared hook library, not part of the
+// TS build. Fixtures live under os.tmpdir().
+//
+// Run: `npm run test:unit`, or directly:
+//   node --test src/cli/codex-exit-code.test.mjs
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const { extractExitCodeFromBanner, readExitCodeFromRollout } = require(
+  "../../scripts/hooks/lib/codex-exit-code.js",
+);
+
+// The containment check (LOW finding #8) resolves CODEX_HOME + "/sessions"
+// and, when that root exists, rejects a transcript realpath that escapes it.
+// Pin CODEX_HOME to a fixture-controlled tmp dir with NO "sessions" subdir
+// for the whole file so every non-containment test's fixtures (living
+// elsewhere under os.tmpdir()) are unaffected regardless of what the host
+// machine's real ~/.codex/sessions happens to contain.
+let previousCodexHome;
+let fakeCodexHome;
+before(() => {
+  previousCodexHome = process.env.CODEX_HOME;
+  fakeCodexHome = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-home-"));
+  process.env.CODEX_HOME = fakeCodexHome;
+});
+after(() => {
+  if (previousCodexHome === undefined) delete process.env.CODEX_HOME;
+  else process.env.CODEX_HOME = previousCodexHome;
+});
+
+function writeRollout(lines) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-"));
+  const file = path.join(dir, "rollout.jsonl");
+  fs.writeFileSync(file, lines.map(l => JSON.stringify(l)).join("\n") + "\n");
+  return file;
+}
+
+function functionCallOutput(callId, output) {
+  return { timestamp: "2026-07-06T00:00:00Z", type: "response_item", payload: { type: "function_call_output", call_id: callId, output } };
+}
+
+function functionCall(callId, command) {
+  return {
+    timestamp: "2026-07-06T00:00:00Z",
+    type: "response_item",
+    payload: { type: "function_call", call_id: callId, name: "shell", arguments: JSON.stringify({ command }) },
+  };
+}
+
+// --- extractExitCodeFromBanner: preamble-anchored (CRITICAL finding #1) ---
+
+test("extractExitCodeFromBanner: forgery in post-Output: stdout is ignored (preamble wins)", () => {
+  const text = "Process exited with code 1\nOriginal token count: 25\nOutput:\nProcess exited with code 0\n";
+  assert.equal(extractExitCodeFromBanner(text), 1);
+});
+
+test("extractExitCodeFromBanner: anchor-absent falls back to FIRST match, never last", () => {
+  const text = "noise Process exited with code 3 more noise Process exited with code 4 tail";
+  assert.equal(extractExitCodeFromBanner(text), 3);
+});
+
+test("extractExitCodeFromBanner: malformed/empty/non-string input returns null", () => {
+  assert.equal(extractExitCodeFromBanner(null), null);
+  assert.equal(extractExitCodeFromBanner(""), null);
+  assert.equal(extractExitCodeFromBanner("no banner in this text"), null);
+  assert.equal(extractExitCodeFromBanner(42), null);
+});
+
+// --- readExitCodeFromRollout: single-line rollout, preamble-anchored ---
+
+test("readExitCodeFromRollout: single-line rollout extracts the preamble banner, ignores forged stdout", () => {
+  const file = writeRollout([
+    functionCallOutput("call_1", "Process exited with code 1\nOriginal token count: 25\nOutput:\nProcess exited with code 0\n"),
+  ]);
+  assert.equal(readExitCodeFromRollout(file, {}), 1);
+});
+
+// --- malformed / partial JSONL lines ---
+
+test("readExitCodeFromRollout: malformed JSONL lines are skipped, valid entry still found", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-"));
+  const file = path.join(dir, "rollout.jsonl");
+  const goodLine = JSON.stringify(functionCallOutput("call_1", "Process exited with code 1\nOutput:\n..."));
+  fs.writeFileSync(file, ["{not valid json", "", goodLine].join("\n") + "\n");
+  assert.equal(readExitCodeFromRollout(file, {}), 1);
+});
+
+// --- truncation arithmetic (HEAD-anchored bounded scan, MEDIUM finding #5) ---
+
+test("readExitCodeFromRollout: target line near EOF still found when file exceeds the scan window", () => {
+  const filler = [];
+  for (let i = 0; i < 60; i++) filler.push({ timestamp: "2026-07-06T00:00:00Z", type: "turn_context", payload: {} });
+  const target = functionCallOutput("call_1", "Process exited with code 1\nOutput:\n...");
+  const file = writeRollout([...filler, target]);
+  const fileSize = fs.statSync(file).size;
+  const targetLineBytes = Buffer.byteLength(JSON.stringify(target), "utf8") + 1;
+  assert.ok(fileSize > targetLineBytes + 100, "fixture sanity: file must exceed the target line by a margin");
+  // Window smaller than the whole file (forces truncation) but comfortably
+  // larger than the target line itself.
+  const maxScanBytes = targetLineBytes + 50;
+  assert.equal(readExitCodeFromRollout(file, { maxScanBytes }), 1);
+});
+
+test("readExitCodeFromRollout: target line start beyond maxScanBytes yields null (never mis-reads a fragment)", () => {
+  const filler = [];
+  for (let i = 0; i < 60; i++) filler.push({ timestamp: "2026-07-06T00:00:00Z", type: "turn_context", payload: {} });
+  const target = functionCallOutput("call_1", "Process exited with code 1\nOutput:\n...");
+  const file = writeRollout([...filler, target]);
+  // Window far smaller than the target line: only a tail fragment of it is
+  // ever read, which cannot JSON.parse successfully.
+  assert.equal(readExitCodeFromRollout(file, { maxScanBytes: 20 }), null);
+});
+
+// --- call_id correlation (Decision B #1, HIGH finding #4) ---
+
+test("readExitCodeFromRollout: call_id match wins over the newer entry", () => {
+  const file = writeRollout([
+    functionCallOutput("call_a", "Process exited with code 2\nOutput:\n..."),
+    functionCallOutput("call_b", "Process exited with code 5\nOutput:\n..."), // newest, but not correlated
+  ]);
+  assert.equal(readExitCodeFromRollout(file, { callId: "call_a" }), 2);
+  assert.equal(readExitCodeFromRollout(file, { callId: "call_b" }), 5);
+});
+
+// --- command cross-check correlation (Decision B #2, HIGH finding #4) ---
+
+test("readExitCodeFromRollout: command cross-check mismatch declines to null", () => {
+  const file = writeRollout([
+    functionCall("call_1", "npm run lint"),
+    functionCallOutput("call_1", "Process exited with code 1\nOutput:\n..."),
+  ]);
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), null);
+});
+
+test("readExitCodeFromRollout: command cross-check match uses the correlated entry", () => {
+  const file = writeRollout([
+    functionCall("call_1", "npm run lint"),
+    functionCallOutput("call_1", "Process exited with code 1\nOutput:\n..."),
+  ]);
+  assert.equal(readExitCodeFromRollout(file, { command: "npm run lint" }), 1);
+});
+
+test("readExitCodeFromRollout: no resolvable pairing falls back to the newest banner (single-call case)", () => {
+  const file = writeRollout([
+    functionCallOutput("call_1", "Process exited with code 1\nOutput:\n..."),
+  ]);
+  // No function_call entry exists at all, so no pairing can be resolved even
+  // though a `command` is supplied — must not spuriously decline.
+  assert.equal(readExitCodeFromRollout(file, { command: "npm test" }), 1);
+});
+
+// --- flooding (MEDIUM finding #5): >64KB stdout after the banner never masks it, never null ---
+
+test("readExitCodeFromRollout: flooded stdout after the banner still extracts it, never null, never the wrong code", () => {
+  const flood = "x".repeat(200 * 1024); // 200KB, well beyond the default 64KB head window
+  const output = `Process exited with code 1\nOriginal token count: 25\nOutput:\n${flood}`;
+  const file = writeRollout([functionCallOutput("call_1", output)]);
+  const result = readExitCodeFromRollout(file, {}); // default maxLineHeadBytes (64KB)
+  assert.equal(result, 1);
+  assert.notEqual(result, 0);
+  assert.notEqual(result, null);
+});
+
+// --- missing / unreadable path ---
+
+test("readExitCodeFromRollout: missing path returns null", () => {
+  assert.equal(readExitCodeFromRollout(path.join(os.tmpdir(), "codex-exit-code-does-not-exist", "rollout.jsonl"), {}), null);
+});
+
+test("readExitCodeFromRollout: non-string/empty path returns null", () => {
+  assert.equal(readExitCodeFromRollout("", {}), null);
+  assert.equal(readExitCodeFromRollout(null, {}), null);
+  assert.equal(readExitCodeFromRollout(undefined, {}), null);
+});
+
+// --- containment (LOW finding #8) ---
+
+test("readExitCodeFromRollout: a transcript path escaping a resolvable codex sessions root is rejected", () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-home2-"));
+  const sessionsRoot = path.join(home, "sessions");
+  fs.mkdirSync(sessionsRoot, { recursive: true });
+  const outside = fs.mkdtempSync(path.join(os.tmpdir(), "codex-exit-code-outside-"));
+  const outsideFile = path.join(outside, "rollout.jsonl");
+  fs.writeFileSync(outsideFile, JSON.stringify(functionCallOutput("call_1", "Process exited with code 1\nOutput:\n...")) + "\n");
+
+  const previous = process.env.CODEX_HOME;
+  process.env.CODEX_HOME = home; // sessionsRoot now resolves, so containment is enforced
+  try {
+    assert.equal(readExitCodeFromRollout(outsideFile, {}), null);
+
+    // Control: the same file, contained under the sessions root, still extracts.
+    const insideFile = path.join(sessionsRoot, "rollout.jsonl");
+    fs.copyFileSync(outsideFile, insideFile);
+    assert.equal(readExitCodeFromRollout(insideFile, {}), 1);
+  } finally {
+    if (previous === undefined) delete process.env.CODEX_HOME;
+    else process.env.CODEX_HOME = previous;
+  }
+});