@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/lib/agent-clients/adapters/codex-lifecycle/controller-context.ts

@@ -0,0 +1,180 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { getProcessIdentityState, type ProcessIdentity } from '../../../server/process-state.ts';
+import type { CodexControllerLeaseProofV1, CodexControllerLeaseV1 } from '../../../sandbox/control/controller-registration.ts';
+import { computeLifecycleBuildIdentity, type LifecycleBuildIdentity } from './build-identity.ts';
+
+const HEX_256 = /^[a-f0-9]{64}$/u;
+
+export type CodexSandboxControllerContextV2 = Readonly<{
+  version: 2;
+  taskId: string;
+  controlGeneration: string;
+  controllerInstanceDigest: string;
+  controllerProcess: ProcessIdentity;
+  controllerLease: Readonly<{ version: 1; leaseId: string; leaseSecret: string }>;
+  issuedAt: number;
+  expiresAt: number;
+  buildIdentity: LifecycleBuildIdentity;
+  hookDefinitionHash: string;
+  lifecycleProfilesHash: string;
+}>;
+
+function exactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  return Object.keys(value).sort().join(',') === [...keys].sort().join(',');
+}
+
+function digestProfiles(repoRoot: string): string {
+  const files = [
+    path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-executor.toml'),
+    path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-reviewer.toml')
+  ];
+  const hash = crypto.createHash('sha256');
+  for (const file of files.sort()) {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
+    hash.update(path.basename(file));
+    hash.update('\0');
+    hash.update(fs.readFileSync(file));
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+function validProcess(value: unknown): value is ProcessIdentity {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const identity = value as Record<string, unknown>;
+  return exactKeys(identity, ['pid', 'startTime'])
+    && Number.isSafeInteger(identity.pid) && (identity.pid as number) > 0
+    && Number.isSafeInteger(identity.startTime) && (identity.startTime as number) >= 0;
+}
+
+function validBuildIdentity(value: unknown): value is LifecycleBuildIdentity {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const identity = value as Record<string, unknown>;
+  return exactKeys(identity, [
+    'internalExecutableBuildHash', 'lifecycleContractHash', 'packageVersion', 'protocolVersion'
+  ])
+    && identity.protocolVersion === 3
+    && typeof identity.packageVersion === 'string' && identity.packageVersion.length > 0
+    && typeof identity.internalExecutableBuildHash === 'string' && HEX_256.test(identity.internalExecutableBuildHash)
+    && typeof identity.lifecycleContractHash === 'string' && HEX_256.test(identity.lifecycleContractHash);
+}
+
+function validateContext(value: unknown): CodexSandboxControllerContextV2 {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  const context = value as Record<string, unknown>;
+  const lease = context.controllerLease as Record<string, unknown> | null;
+  if (!exactKeys(context, [
+    'buildIdentity', 'controlGeneration', 'controllerInstanceDigest', 'controllerLease',
+    'controllerProcess', 'expiresAt', 'hookDefinitionHash', 'issuedAt',
+    'lifecycleProfilesHash', 'taskId', 'version'
+  ])
+    || context.version !== 2
+    || typeof context.taskId !== 'string' || context.taskId.length === 0
+    || typeof context.controlGeneration !== 'string' || context.controlGeneration.length === 0
+    || typeof context.controllerInstanceDigest !== 'string' || !HEX_256.test(context.controllerInstanceDigest)
+    || !validProcess(context.controllerProcess)
+    || !lease || !exactKeys(lease, ['leaseId', 'leaseSecret', 'version'])
+    || lease.version !== 1
+    || typeof lease.leaseId !== 'string' || !HEX_256.test(lease.leaseId)
+    || typeof lease.leaseSecret !== 'string' || !HEX_256.test(lease.leaseSecret)
+    || !Number.isSafeInteger(context.issuedAt)
+    || !Number.isSafeInteger(context.expiresAt)
+    || (context.expiresAt as number) <= (context.issuedAt as number)
+    || !validBuildIdentity(context.buildIdentity)
+    || typeof context.hookDefinitionHash !== 'string' || !HEX_256.test(context.hookDefinitionHash)
+    || typeof context.lifecycleProfilesHash !== 'string' || !HEX_256.test(context.lifecycleProfilesHash)) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  return context as unknown as CodexSandboxControllerContextV2;
+}
+
+export function contextFromControllerLease(
+  lease: CodexControllerLeaseV1,
+  hashes: Readonly<{ hookDefinitionHash: string; lifecycleProfilesHash: string }>
+): CodexSandboxControllerContextV2 {
+  return Object.freeze({
+    version: 2,
+    taskId: lease.taskId,
+    controlGeneration: lease.controlGeneration,
+    controllerInstanceDigest: lease.controllerInstanceDigest,
+    controllerProcess: lease.controllerProcess,
+    controllerLease: Object.freeze({ version: 1, leaseId: lease.leaseId, leaseSecret: lease.leaseSecret }),
+    issuedAt: lease.issuedAt,
+    expiresAt: lease.expiresAt,
+    buildIdentity: lease.buildIdentity,
+    hookDefinitionHash: hashes.hookDefinitionHash,
+    lifecycleProfilesHash: hashes.lifecycleProfilesHash
+  });
+}
+
+export function writeCodexSandboxControllerContext(
+  contextPath: string,
+  context: CodexSandboxControllerContextV2
+): void {
+  validateContext(context);
+  fs.mkdirSync(path.dirname(contextPath), { recursive: true, mode: 0o700 });
+  const temporary = path.join(path.dirname(contextPath), `.${path.basename(contextPath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(context, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+    fs.chmodSync(temporary, 0o600);
+    fs.renameSync(temporary, contextPath);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+export function verifyCodexSandboxControllerContext(
+  contextPath: string,
+  options: Readonly<{
+    repoRoot?: string;
+    now?: number;
+    generation?: string;
+    probeProcess?: (identity: ProcessIdentity) => 'alive' | 'dead' | 'unknown';
+  }> = {}
+): CodexSandboxControllerContextV2 {
+  let stat: fs.Stats;
+  try {
+    stat = fs.lstatSync(contextPath);
+  } catch {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  if (!stat.isFile() || stat.isSymbolicLink()
+    || (process.platform !== 'win32' && (stat.mode & 0o077) !== 0)) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  let context: CodexSandboxControllerContextV2;
+  try {
+    context = validateContext(JSON.parse(fs.readFileSync(contextPath, 'utf8')));
+  } catch {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  const repoRoot = options.repoRoot ?? process.cwd();
+  const generation = options.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
+  const state = (options.probeProcess ?? getProcessIdentityState)(context.controllerProcess);
+  if (context.controlGeneration !== generation
+    || context.expiresAt <= (options.now ?? Date.now())
+    || state !== 'alive') {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  if (JSON.stringify(computeLifecycleBuildIdentity(repoRoot)) !== JSON.stringify(context.buildIdentity)
+    || crypto.createHash('sha256').update(fs.readFileSync(path.join(repoRoot, '.codex', 'hooks.json'))).digest('hex') !== context.hookDefinitionHash
+    || digestProfiles(repoRoot) !== context.lifecycleProfilesHash) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
+  }
+  return Object.freeze(context);
+}
+
+export function controllerProofFromContext(context: CodexSandboxControllerContextV2): CodexControllerLeaseProofV1 {
+  return Object.freeze({
+    version: 1,
+    leaseId: context.controllerLease.leaseId,
+    leaseSecret: context.controllerLease.leaseSecret,
+    controllerProcess: context.controllerProcess
+  });
+}

package/lib/agent-clients/adapters/codex-lifecycle/evidence.ts

@@ -147,6 +147,16 @@ function same(left: unknown, right: unknown): boolean {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+function sameChildCorrelation(
+  left: Extract<CodexLifecycleEvent, { type: 'hook-child' }>,
+  right: Extract<CodexLifecycleEvent, { type: 'hook-child' }>
+): boolean {
+  return left.sessionId === right.sessionId
+    && left.childThreadId === right.childThreadId
+    && left.parentThreadId === right.parentThreadId
+    && left.nativeAgent === right.nativeAgent;
+}
+
 function requiredStrings(event: CodexLifecycleEvent): boolean {
   return Object.entries(event).every(([key, value]) =>
     key === 'forkedFromId'
@@ -286,6 +296,15 @@ function reduceCodexLifecycleEvent(
   const existing = state[key];
   if (existing) {
     if (same(existing, event)) return state;
+    if (
+      existing.type === 'hook-child'
+      && event.type === 'hook-child'
+      && sameChildCorrelation(existing, event)
+      && (existing.source === 'parent-rollout') !== (event.source === 'parent-rollout')
+    ) {
+      if (existing.source !== 'parent-rollout') return state;
+      return derive(Object.freeze({ ...state, child: Object.freeze({ ...event }) }));
+    }
     return invalid(state, 'CODEX_EVIDENCE_REPLAY_CONFLICT', `conflicting '${event.type}' event`);
   }
   return derive(Object.freeze({ ...state, [key]: Object.freeze({ ...event }) }));

package/lib/agent-clients/adapters/codex-lifecycle/manifest-files.json

@@ -3,6 +3,7 @@
     "bin/internal-cli.ts",
     "lib/internal/codex-lifecycle.ts",
     "lib/internal/codex-sandbox-controller.ts",
+    "lib/internal/sandbox-control.ts",
     "lib/internal/task-orchestration.ts",
     "lib/task/codex-orchestration.ts",
     "lib/task/delegation-receipts.ts",
@@ -10,10 +11,17 @@
     "lib/agent-clients/adapters/codex-lifecycle/build-identity.ts",
     "lib/agent-clients/adapters/codex-lifecycle/capability-store.ts",
     "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.ts",
+    "lib/agent-clients/adapters/codex-lifecycle/controller-context.ts",
     "lib/agent-clients/adapters/codex-lifecycle/app-server.ts",
     "lib/agent-clients/adapters/codex-lifecycle/evidence.ts",
     "lib/agent-clients/adapters/codex-lifecycle/store.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/manifest-files.json"
+    "lib/agent-clients/adapters/codex-lifecycle/manifest-files.json",
+    "lib/sandbox/control/protocol.ts",
+    "lib/sandbox/control/client.ts",
+    "lib/sandbox/control/executor.ts",
+    "lib/sandbox/control/controller-registration.ts",
+    "lib/server/process-state.ts",
+    "lib/sandbox/shell.ts"
   ],
   "contractFiles": [
     ".codex/hooks.json",

package/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.ts

@@ -6,36 +6,32 @@ import path from 'node:path';
 import semver from 'semver';
 import * as toml from 'smol-toml';
 
-import { requestSandboxControl } from '../../../sandbox/control/client.ts';
+import {
+  requestCodexControllerClose,
+  requestCodexControllerOpen,
+  requestCodexControllerVerify,
+  requestSandboxControl
+} from '../../../sandbox/control/client.ts';
 import { readSandboxControlStatus } from '../../../sandbox/control/state.ts';
-import { getProcessStartTime, isProcessAlive } from '../../../server/process-state.ts';
+import { getProcessStartTime, type ProcessIdentity } from '../../../server/process-state.ts';
 import { computeLifecycleBuildIdentity } from './build-identity.ts';
-import type { LifecycleBuildIdentity } from './build-identity.ts';
+import {
+  contextFromControllerLease,
+  controllerProofFromContext,
+  verifyCodexSandboxControllerContext as verifyContextFile,
+  writeCodexSandboxControllerContext,
+  type CodexSandboxControllerContextV2
+} from './controller-context.ts';
 
 type ControllerControl = Readonly<{
   token: string;
   generation: string;
   channelDir: string;
   statusDir: string;
-}>;
-
-type CodexSandboxControllerContext = Readonly<{
-  version: 1;
-  taskId: string;
-  controlGeneration: string;
-  controllerInstanceDigest: string;
-  parentPid: number;
-  parentStartTime: number;
-  issuedAt: number;
-  expiresAt: number;
-  buildIdentity: LifecycleBuildIdentity;
-  hookDefinitionHash: string;
-  lifecycleProfilesHash: string;
+  runtimeDir: string;
 }>;
 
 type ControllerInput = Readonly<{
-  taskId: string;
-  taskRef: string;
   executorModel?: string;
   executorReasoningEffort?: string;
   reviewerModel?: string;
@@ -50,6 +46,8 @@ type ControllerOptions = Readonly<{
   now?: () => number;
   codexVersion?: () => string;
   verifyTaskBinding?: (taskId: string, control: ControllerControl) => void;
+  openController?: typeof requestCodexControllerOpen;
+  closeController?: typeof requestCodexControllerClose;
   environment?: NodeJS.ProcessEnv;
 }>;
 
@@ -59,11 +57,18 @@ type PreparedCodexSandboxController = Readonly<{
   env: NodeJS.ProcessEnv;
   home: string;
   contextPath: string;
-  context: CodexSandboxControllerContext;
+  context: CodexSandboxControllerContextV2;
   cleanup: () => void;
 }>;
 
-const CONTEXT_TTL_MS = 4 * 60 * 60 * 1_000;
+type VerifyContextOptions = Readonly<{
+  repoRoot?: string;
+  now?: number;
+  generation?: string;
+  probeProcess?: (identity: ProcessIdentity) => 'alive' | 'dead' | 'unknown';
+  control?: ControllerControl;
+  requestControllerVerify?: typeof requestCodexControllerVerify;
+}>;
 
 function digestFiles(files: readonly string[]): string {
   const hash = crypto.createHash('sha256');
@@ -95,13 +100,38 @@ function controlFromEnvironment(): ControllerControl {
   const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
   const channelDir = process.env.AGENT_INFRA_CONTROL_DIR;
   const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
-  if (!token || !generation || !channelDir || !statusDir) {
+  const runtimeDir = process.env.AGENT_INFRA_RUNTIME_DIR;
+  if (!token || !generation || !channelDir || !statusDir || !runtimeDir) {
     throw new Error('CODEX_SANDBOX_CONTROLLER_CONTROL_MISSING');
   }
-  return { token, generation, channelDir, statusDir };
+  return { token, generation, channelDir, statusDir, runtimeDir };
+}
+
+function verifyRuntime(runtimeDir: string): void {
+  let stat: fs.Stats;
+  try {
+    stat = fs.lstatSync(runtimeDir);
+  } catch {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
+  }
+  const probe = path.join(runtimeDir, `.controller-${process.pid}-${crypto.randomUUID()}.probe`);
+  try {
+    fs.writeFileSync(probe, 'runtime-probe\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+    if (fs.readFileSync(probe, 'utf8') !== 'runtime-probe\n') {
+      throw new Error('probe mismatch');
+    }
+  } catch {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
+  } finally {
+    fs.rmSync(probe, { force: true });
+  }
 }
 
 function verifyControl(taskId: string, control: ControllerControl): void {
+  verifyRuntime(control.runtimeDir);
   let status: ReturnType<typeof readSandboxControlStatus> | null = null;
   let lastError: unknown = null;
   for (let attempt = 0; attempt < 5; attempt += 1) {
@@ -136,6 +166,30 @@ function verifyControl(taskId: string, control: ControllerControl): void {
   if (payload.taskId !== taskId) throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
 }
 
+function verifyCodexSandboxControllerContext(
+  contextPath: string,
+  options: VerifyContextOptions = {}
+): CodexSandboxControllerContextV2 {
+  const control = options.control ?? controlFromEnvironment();
+  const context = verifyContextFile(contextPath, {
+    repoRoot: options.repoRoot,
+    now: options.now,
+    generation: control.generation,
+    probeProcess: options.probeProcess
+  });
+  const verified = (options.requestControllerVerify ?? requestCodexControllerVerify)({
+    controllerProof: controllerProofFromContext(context),
+    ...control,
+    timeoutMs: 30_000
+  });
+  if (verified.binding.taskId !== context.taskId
+    || verified.binding.controlGeneration !== context.controlGeneration
+    || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+  }
+  return context;
+}
+
 function detectedCodexVersion(): string {
   const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
   const version = /codex-cli\s+(\d+\.\d+\.\d+)/u.exec(result.stdout ?? '')?.[1];
@@ -214,6 +268,7 @@ function isolatedEnvironment(
     AGENT_INFRA_CONTROL_GENERATION: control.generation,
     AGENT_INFRA_CONTROL_DIR: control.channelDir,
     AGENT_INFRA_CONTROL_STATUS_DIR: control.statusDir,
+    AGENT_INFRA_RUNTIME_DIR: control.runtimeDir,
     AGENT_INFRA_CODEX_CONTROLLER_CONTEXT: contextPath
   };
 }
@@ -229,7 +284,6 @@ function prepareCodexSandboxController(
   const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
   const sourceHome = path.resolve(options.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'));
   const control = options.control ?? controlFromEnvironment();
-  (options.verifyTaskBinding ?? verifyControl)(input.taskId, control);
   const version = (options.codexVersion ?? detectedCodexVersion)();
   if (!semver.gte(version, '0.147.0')) throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNSUPPORTED');
 
@@ -238,46 +292,33 @@ function prepareCodexSandboxController(
   fs.mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
   fs.chmodSync(runtimeRoot, 0o700);
   const key = crypto.createHash('sha256')
-    .update(`${input.taskId}\0${control.generation}`)
+    .update(`${process.pid}\0${control.generation}`)
     .digest('hex');
-  const leasePath = path.join(runtimeRoot, `${key}.lease.json`);
-  if (fs.existsSync(leasePath)) {
-    const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8')) as { pid?: number; startTime?: number };
-    if (Number.isSafeInteger(lease.pid) && typeof lease.startTime === 'number'
-      && getProcessStartTime(lease.pid!) === lease.startTime) {
-      throw new Error('CODEX_SANDBOX_CONTROLLER_BUSY');
-    }
-    fs.unlinkSync(leasePath);
-  }
-
   const parentStartTime = getProcessStartTime(process.pid);
   if (!parentStartTime) throw new Error('CODEX_SANDBOX_CONTROLLER_PROCESS_IDENTITY_INVALID');
-  const instanceDigest = crypto.randomBytes(32).toString('hex');
-  fs.writeFileSync(leasePath, `${JSON.stringify({
-    version: 1,
-    pid: process.pid,
-    startTime: parentStartTime,
-    taskId: input.taskId,
-    generation: control.generation,
-    instanceDigest
-  })}\n`, { mode: 0o600, flag: 'wx' });
-
   const home = fs.mkdtempSync(path.join(runtimeRoot, `${key}-`));
   fs.chmodSync(home, 0o700);
   let cleaned = false;
+  let context: CodexSandboxControllerContextV2 | null = null;
   const cleanup = () => {
     if (cleaned) return;
     cleaned = true;
+    if (context) {
+      try {
+        (options.closeController ?? requestCodexControllerClose)({
+          controllerProcess: context.controllerProcess,
+          controllerProof: controllerProofFromContext(context),
+          ...control,
+          timeoutMs: 30_000
+        });
+      } catch {
+        // The wrapper is exiting; dead-process recovery safely handles an unknown close result.
+      }
+    }
     const relative = path.relative(runtimeRoot, home);
     if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
       fs.rmSync(home, { recursive: true, force: true });
     }
-    try {
-      const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8')) as { instanceDigest?: string };
-      if (lease.instanceDigest === instanceDigest) fs.unlinkSync(leasePath);
-    } catch {
-      // A missing or replaced lease is owned by another cleanup path.
-    }
   };
 
   try {
@@ -306,22 +347,25 @@ function prepareCodexSandboxController(
     }
 
     const buildIdentity = computeLifecycleBuildIdentity(repoRoot);
-    const now = (options.now ?? Date.now)();
-    const context: CodexSandboxControllerContext = Object.freeze({
-      version: 1,
-      taskId: input.taskId,
-      controlGeneration: control.generation,
-      controllerInstanceDigest: instanceDigest,
-      parentPid: process.pid,
-      parentStartTime,
-      issuedAt: now,
-      expiresAt: now + CONTEXT_TTL_MS,
-      buildIdentity,
+    const opened = (options.openController ?? requestCodexControllerOpen)({
+      controllerProcess: { pid: process.pid, startTime: parentStartTime },
+      ...control,
+      timeoutMs: 30_000
+    });
+    const taskId = opened.lease.taskId;
+    context = contextFromControllerLease(opened.lease, {
       hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex'),
       lifecycleProfilesHash: digestFiles([executor, reviewer])
     });
+    if (opened.lease.controlGeneration !== control.generation
+      || opened.lease.controllerProcess.pid !== process.pid
+      || opened.lease.controllerProcess.startTime !== parentStartTime
+      || JSON.stringify(opened.lease.buildIdentity) !== JSON.stringify(buildIdentity)) {
+      throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
+    }
+    (options.verifyTaskBinding ?? verifyControl)(taskId, control);
     const contextPath = path.join(home, 'controller-context.json');
-    fs.writeFileSync(contextPath, `${JSON.stringify(context, null, 2)}\n`, { mode: 0o600 });
+    writeCodexSandboxControllerContext(contextPath, context);
 
     const shimDir = path.join(home, 'bin');
     fs.mkdirSync(shimDir, { mode: 0o700 });
@@ -337,7 +381,7 @@ function prepareCodexSandboxController(
       input.reviewerModel ? `--reviewer-model ${input.reviewerModel}` : '',
       input.reviewerReasoningEffort ? `--reviewer-reasoning-effort ${input.reviewerReasoningEffort}` : ''
     ].filter(Boolean).join(' ');
-    const prompt = `$run-task ${input.taskRef}${policy ? ` ${policy}` : ''}`;
+    const prompt = `$run-task ${taskId}${policy ? ` ${policy}` : ''}`;
     const args = Object.freeze([
       'exec',
       '--enable', 'hooks',
@@ -352,7 +396,7 @@ function prepareCodexSandboxController(
       home,
       shimDir,
       contextPath,
-      input.taskId,
+      taskId,
       control,
       providerEnvironment,
       options.environment ?? process.env
@@ -372,32 +416,6 @@ function prepareCodexSandboxController(
   }
 }
 
-function verifyCodexSandboxControllerContext(
-  contextPath: string,
-  taskId: string,
-  options: Readonly<{ repoRoot?: string; now?: number; generation?: string }> = {}
-): CodexSandboxControllerContext {
-  const stat = fs.lstatSync(contextPath);
-  if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-  }
-  const context = JSON.parse(fs.readFileSync(contextPath, 'utf8')) as CodexSandboxControllerContext;
-  const generation = options.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
-  if (context.version !== 1
-    || context.taskId !== taskId
-    || context.controlGeneration !== generation
-    || context.expiresAt < (options.now ?? Date.now())
-    || getProcessStartTime(context.parentPid) !== context.parentStartTime
-    || !isProcessAlive(context.parentPid)) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-  }
-  const current = computeLifecycleBuildIdentity(options.repoRoot ?? process.cwd());
-  if (JSON.stringify(current) !== JSON.stringify(context.buildIdentity)) {
-    throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
-  }
-  return Object.freeze(context);
-}
-
 async function runCodexSandboxController(
   input: ControllerInput,
   options: ControllerOptions = {}
@@ -442,10 +460,11 @@ async function runCodexSandboxController(
 export {
   prepareCodexSandboxController,
   runCodexSandboxController,
-  verifyCodexSandboxControllerContext
+  verifyCodexSandboxControllerContext,
+  controllerProofFromContext
 };
 export type {
-  CodexSandboxControllerContext,
+  CodexSandboxControllerContextV2 as CodexSandboxControllerContext,
   ControllerControl,
   ControllerInput,
   ControllerOptions,

package/lib/agent-clients/adapters/codex-lifecycle/store.ts

@@ -11,6 +11,7 @@ import type {
   CodexLifecycleEvent,
   CodexLifecycleState
 } from './evidence.ts';
+import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.ts';
 
 type StoredCodexLifecycle = Readonly<{
   schemaVersion: 1;
@@ -105,7 +106,7 @@ function writeRecord(file: string, record: StoredCodexLifecycle, expectedRevisio
 }
 
 function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
-  const root = options.root ?? path.join(process.cwd(), '.agents', 'workspace', '.runtime', 'codex-lifecycle');
+  const root = options.root ?? resolveAgentRuntimeStoreRoot({ store: 'lifecycle' });
   const now = options.now ?? (() => new Date().toISOString());
   fs.mkdirSync(root, { recursive: true, mode: 0o700 });
   fs.chmodSync(root, 0o700);