@fitlab-ai/agent-infra 0.9.5 → 0.9.6

package/dist/lib/task/orchestration.js

@@ -159,6 +159,22 @@ function resolveProjectPolicy(repoRoot, client) {
     const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     return normalizeAgentClients(raw).state[client].orchestration;
 }
+function canRecoverCodexUnsupportedPause(run, taskDir) {
+    return run.schemaVersion === 2
+        && run.status === 'paused'
+        && run.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
+        && run.modelPolicySource?.client === 'codex'
+        && run.stepCount === 0
+        && run.nextStage === null
+        && run.baseline === ''
+        && run.pendingDelegation === null
+        && run.receipts.length === 0
+        && run.commitAuthorization?.issuedAt === null
+        && run.commitAuthorization?.consumedAt === null
+        && run.completionEvidence == null
+        && !fs.existsSync(commitIntentPath(taskDir))
+        && (run.recoveryHistory ?? []).every((entry) => entry.code === 'MODEL_POLICY_SUPPLEMENTED');
+}
 function beginOrResumeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -204,6 +220,39 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
                     return failed('ORCHESTRATION_MODEL_POLICY_MISMATCH', 'provided model policy does not match the persisted run policy', resolved.taskId);
                 }
             }
+            if (existing.status === 'paused' && existing.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED') {
+                if (!canRecoverCodexUnsupportedPause(existing, resolved.taskDir)) {
+                    return { status: 'paused', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
+                }
+                const now = (options.now ?? (() => new Date().toISOString()))();
+                const previousPause = existing.pause;
+                const recovery = {
+                    code: 'CLIENT_CAPABILITY_ENABLED',
+                    recoveredAt: now,
+                    previousSchemaVersion: 2,
+                    previousStatus: 'paused',
+                    previousPause,
+                    client: 'codex',
+                    guards: {
+                        stepCount: 0,
+                        nextStage: null,
+                        baselineEmpty: true,
+                        receiptCount: 0,
+                        pendingDelegation: false,
+                        commitAuthorizationUnused: true,
+                        completionEvidenceAbsent: true,
+                        commitIntentAbsent: true
+                    },
+                    resultingStatus: 'running'
+                };
+                const resumed = withUpdatedRun(existing, {
+                    status: 'running',
+                    pause: null,
+                    recoveryHistory: Object.freeze([...(existing.recoveryHistory ?? []), recovery])
+                }, () => now);
+                saveRun(resolved.taskDir, resumed);
+                return { status: 'running', changed: true, taskId: resolved.taskId, run: resumed, next: null, error: null };
+            }
             if (existing.status === 'paused' && existing.pause?.recoverable && existing.pendingDelegation === null) {
                 const resumed = withUpdatedRun(existing, { status: 'running', pause: null });
                 saveRun(resolved.taskDir, resumed);
@@ -1059,7 +1108,7 @@ function matchingDelegations(predicate, options) {
         .filter((entry) => entry.isDirectory())
         .flatMap((entry) => {
         const run = readRun(path.join(activeRoot, entry.name));
-        if (!run?.pendingDelegation)
+        if (run?.status !== 'running' || !run.pendingDelegation)
             return [];
         const receipt = run.pendingDelegation;
         return predicate(receipt)
@@ -1080,13 +1129,36 @@ function activateMatchingOrchestrationDelegation(client, event, options = {}) {
     if (!role)
         return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
     const matched = uniqueMatchingDelegation(client, (receipt) => receipt.status === 'prepared', options);
-    if ('status' in matched)
-        return matched;
+    if ('status' in matched) {
+        if (matched.error?.code !== 'ORCHESTRATION_DELEGATION_MISSING')
+            return matched;
+        const replay = uniqueMatchingDelegation(client, (receipt) => receipt.childId === event.childId && ['activated', 'stage-completed'].includes(receipt.status), options);
+        if ('status' in replay)
+            return matched;
+        const receipt = replay.run.pendingDelegation;
+        const sameEvidence = receipt.parentId === event.parentId
+            && receipt.spawnMode === event.spawnMode
+            && receipt.actualModel === event.actualModel
+            && receipt.actualReasoningEffort === event.actualReasoningEffort
+            && receipt.modelFallbackReason === (event.modelFallbackReason ?? null)
+            && receipt.reasoningEffortFallbackReason === (event.reasoningEffortFallbackReason ?? null)
+            && receipt.hostEvidence?.hookDefinitionHash === event.hostEvidence?.hookDefinitionHash;
+        if (!sameEvidence) {
+            return pauseOrchestration(replay.taskId, 'DELEGATION_REPLAY_CONFLICT', 'replayed native start evidence conflicts with the active receipt', true, options);
+        }
+        return { status: replay.run.status, changed: false, taskId: replay.taskId, run: replay.run, next: null, error: null };
+    }
     if (matched.run.receipts.some((receipt) => receipt.childId === event.childId)) {
         return pauseOrchestration(matched.taskId, 'DELEGATION_IDENTITY_REUSED', 'native child identity was already used by this run', true, options);
     }
     return activateOrchestrationDelegation(matched.taskId, event, options);
 }
+function pauseMatchingOrchestrationDelegation(client, code, message, options = {}) {
+    const matched = uniqueMatchingDelegation(client, () => true, options);
+    if ('status' in matched)
+        return matched;
+    return pauseOrchestration(matched.taskId, code, message, true, options);
+}
 function sealMatchingOrchestrationDelegation(client, event, options = {}) {
     const role = managedDelegationRole(event.nativeAgent);
     if (!role)
@@ -1119,6 +1191,63 @@ function sealMatchingOrchestrationDelegation(client, event, options = {}) {
         return pauseOrchestration(matched.taskId, 'ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), true, options);
     }
 }
+function sealMatchingOrchestrationDelegationWithHostEvidence(client, event, consumeEvidence, options = {}) {
+    const role = managedDelegationRole(event.nativeAgent);
+    if (!role)
+        return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+    const matched = uniqueMatchingDelegation(client, (receipt) => ((receipt.status === 'stage-completed' || receipt.status === 'sealed')
+        && receipt.childId === event.childId), options);
+    if ('status' in matched)
+        return matched;
+    const receipt = matched.run.pendingDelegation;
+    if (receipt.status === 'sealed') {
+        return reconcileMatchingOrchestrationDelegation(client, event.childId, options);
+    }
+    if (receipt.role !== role) {
+        return pauseOrchestration(matched.taskId, 'DELEGATION_ROLE_MISMATCH', `managed role ${role} does not match ${receipt.role}`, true, options);
+    }
+    const repoRoot = options.repoRoot ?? process.cwd();
+    try {
+        const gitRoot = gitRootFor(repoRoot, options);
+        const snapshotTaskId = receipt.workspaceSnapshotScope === 'task' ? receipt.taskId : null;
+        const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+            gitRoot,
+            stateRoot: repoRoot,
+            taskId: snapshotTaskId
+        });
+        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(gitRoot, receipt.beforeFingerprint, afterFingerprint);
+        const baseEvent = { childId: event.childId, exitCode: 0, afterFingerprint, changedPaths };
+        const validated = sealDelegation(receipt, baseEvent, { now: options.now });
+        if (!validated.ok) {
+            return pauseOrchestration(matched.taskId, validated.code, validated.message, true, options);
+        }
+        const hostEvidence = consumeEvidence(receipt);
+        const sealed = sealDelegation(receipt, { ...baseEvent, hostEvidence }, { now: options.now });
+        if (!sealed.ok)
+            return pauseOrchestration(matched.taskId, sealed.code, sealed.message, true, options);
+        const resolved = resolveTaskRef(matched.taskId, { repoRoot });
+        if (!resolved.ok)
+            return failed(resolved.code, resolved.message, resolved.taskId);
+        const updated = withUpdatedRun(matched.run, { pendingDelegation: sealed.receipt }, options.now);
+        saveRun(resolved.taskDir, updated);
+        return { status: 'running', changed: true, taskId: matched.taskId, run: updated, next: null, error: null };
+    }
+    catch (error) {
+        return pauseOrchestration(matched.taskId, 'ORCHESTRATION_CODEX_EVIDENCE_FAILED', error instanceof Error ? error.message : String(error), true, options);
+    }
+}
+function reconcileMatchingOrchestrationDelegation(client, childId, options = {}) {
+    const matched = uniqueMatchingDelegation(client, (receipt) => receipt.childId === childId, options);
+    if ('status' in matched)
+        return matched;
+    const receipt = matched.run.pendingDelegation;
+    if (receipt.status !== 'sealed'
+        || receipt.hostEvidence?.consumer !== receipt.id
+        || receipt.hostEvidence.consumedAt === null) {
+        return pauseOrchestration(matched.taskId, 'ORCHESTRATION_CODEX_RECONCILIATION_FAILED', 'Codex native spawn did not produce one sealed receipt with consumed host evidence', true, options);
+    }
+    return { status: matched.run.status, changed: false, taskId: matched.taskId, run: matched.run, next: null, error: null };
+}
 function activateOrchestrationDelegation(taskRef, event, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -1251,5 +1380,5 @@ function pauseOrchestration(taskRef, code, message, recoverable, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'paused', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, inspectOrchestrationStage, orchestrationPath, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, inspectOrchestrationStage, orchestrationPath, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt };
 //# sourceMappingURL=orchestration.js.map

package/dist/lib/task/verification-engine.js

@@ -239,12 +239,29 @@ function checkOrchestrationEvidence({ taskDir }) {
         return failResult('orchestration-evidence', 'Run model policy source or recovery history is invalid');
     }
     for (const recovery of run.recoveryHistory) {
-        if (recovery.code !== 'MODEL_POLICY_SUPPLEMENTED'
-            || recovery.previousSchemaVersion !== 1
-            || recovery.receiptCount !== 0
-            || recovery.pendingDelegation !== false
-            || !exactText(recovery.recoveredAt)
-            || !recovery.policySource) {
+        const validModelRecovery = recovery.code === 'MODEL_POLICY_SUPPLEMENTED'
+            && recovery.previousSchemaVersion === 1
+            && recovery.receiptCount === 0
+            && recovery.pendingDelegation === false
+            && exactText(recovery.recoveredAt)
+            && recovery.policySource;
+        const guards = recovery.guards;
+        const validCapabilityRecovery = recovery.code === 'CLIENT_CAPABILITY_ENABLED'
+            && recovery.previousSchemaVersion === 2
+            && recovery.previousStatus === 'paused'
+            && recovery.previousPause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
+            && recovery.client === 'codex'
+            && recovery.resultingStatus === 'running'
+            && exactText(recovery.recoveredAt)
+            && guards?.stepCount === 0
+            && guards?.nextStage === null
+            && guards?.baselineEmpty === true
+            && guards?.receiptCount === 0
+            && guards?.pendingDelegation === false
+            && guards?.commitAuthorizationUnused === true
+            && guards?.completionEvidenceAbsent === true
+            && guards?.commitIntentAbsent === true;
+        if (!validModelRecovery && !validCapabilityRecovery) {
             return failResult('orchestration-evidence', 'Run recovery history contains invalid provenance');
         }
     }
@@ -298,6 +315,21 @@ function checkOrchestrationEvidence({ taskDir }) {
                 && receipt.reasoningEffortFallbackReason !== null) {
                 return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has an unrelated reasoning-effort fallback reason`);
             }
+            if (receipt.client === 'codex') {
+                const host = receipt.hostEvidence;
+                if (host?.kind !== 'codex-lifecycle-v1'
+                    || !exactText(host.hookDefinitionHash)
+                    || !Number.isSafeInteger(host.startRevision)
+                    || host.startRevision < 1) {
+                    return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has invalid Codex start evidence`);
+                }
+                if (['sealed', 'consumed'].includes(receipt.status) && (!Number.isSafeInteger(host.stopRevision)
+                    || host.stopRevision <= host.startRevision
+                    || host.consumer !== receipt.id
+                    || !exactText(host.consumedAt))) {
+                    return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has invalid Codex consumed stop evidence`);
+                }
+            }
         }
     }
     if (run.receipts.some((receipt) => receipt.status !== 'consumed')) {

package/dist/lib/task/verification.js

@@ -16,6 +16,7 @@ const VERIFICATION_CATALOG = {
     'code.completed': gate('code-task', 'active', 'code'),
     'review-code.completed': gate('review-code', 'active', 'review-code'),
     'manual-validation.completed': gate('complete-manual-validation', 'active', 'manual-validation'),
+    'validation-run.completed': gate('run-manual-validation', 'active', 'validation-run'),
     'block-task.completed': gate('block-task', 'blocked'),
     'cancel-task.completed': gate('cancel-task', 'completed'),
     'commit.completed': gate('commit', 'active'),

package/lib/agent-clients/adapters/codex-lifecycle/app-server.ts

@@ -27,6 +27,8 @@ type AppServerTransportOptions = Readonly<{
   cwd?: string;
   env?: NodeJS.ProcessEnv;
   timeoutMs?: number;
+  rolloutReadAttempts?: number;
+  rolloutRetryMs?: number;
 }>;
 
 type CodexRuntimeIdentity = Readonly<{
@@ -37,10 +39,12 @@ type CodexRuntimeIdentity = Readonly<{
 
 const LIFECYCLE_HOOKS = Object.freeze([
   Object.freeze({ event: 'PreToolUse', matcher: '^collaborationspawn_agent$', phase: 'pre-tool' }),
-  Object.freeze({ event: 'PostToolUse', matcher: '^collaborationspawn_agent$', phase: 'post-tool' }),
-  Object.freeze({ event: 'SubagentStart', matcher: '^agent-infra-lifecycle-(executor|reviewer)$', phase: 'subagent-start' }),
-  Object.freeze({ event: 'SubagentStop', matcher: '^agent-infra-lifecycle-(executor|reviewer)$', phase: 'subagent-stop' })
+  Object.freeze({ event: 'PostToolUse', matcher: '', phase: 'post-tool' }),
+  Object.freeze({ event: 'SubagentStart', matcher: '', phase: 'subagent-start' }),
+  Object.freeze({ event: 'SubagentStop', matcher: '', phase: 'subagent-stop' })
 ]);
+const DEFAULT_ROLLOUT_READ_ATTEMPTS = 81;
+const DEFAULT_ROLLOUT_RETRY_MS = 100;
 
 function object(value: unknown): JsonObject | null {
   return value && typeof value === 'object' && !Array.isArray(value)
@@ -52,6 +56,65 @@ function nonEmpty(value: unknown): string | null {
   return typeof value === 'string' && value.trim() ? value : null;
 }
 
+function resolveCodexSpawnedChild(
+  transcriptPath: string,
+  expected: Readonly<{
+    sessionId: string;
+    toolUseId: string;
+    nativeAgent: string;
+    taskName: string;
+    requestedModel?: string;
+    requestedReasoningEffort?: string;
+  }>
+): string {
+  const name = path.basename(transcriptPath);
+  if (!transcriptPath || (!name.endsWith(`-${expected.sessionId}.jsonl`) && name !== `${expected.sessionId}.jsonl`)) {
+    throw new Error('Codex parent rollout path is invalid');
+  }
+  const stat = fs.lstatSync(transcriptPath);
+  if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('Codex parent rollout is not a regular file');
+  const maxBytes = 8 * 1024 * 1024;
+  const offset = Math.max(0, stat.size - maxBytes);
+  const buffer = Buffer.alloc(stat.size - offset);
+  const descriptor = fs.openSync(transcriptPath, 'r');
+  try {
+    fs.readSync(descriptor, buffer, 0, buffer.length, offset);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+  let text = buffer.toString('utf8');
+  if (offset) text = text.slice(text.indexOf('\n') + 1);
+  const records = text.split(/\r?\n/).filter(Boolean).map((line) => object(JSON.parse(line))).filter(Boolean);
+  const calls = records.filter((record) => {
+    const payload = object(record?.payload);
+    return record?.type === 'response_item'
+      && payload?.type === 'function_call'
+      && payload.call_id === expected.toolUseId
+      && payload.namespace === 'collaboration'
+      && payload.name === 'spawn_agent';
+  });
+  if (calls.length !== 1) throw new Error('Codex parent rollout spawn call was not found uniquely');
+  const call = object(calls[0]?.payload);
+  const args = object(JSON.parse(nonEmpty(call?.arguments) ?? '{}'));
+  if (
+    args?.agent_type !== expected.nativeAgent
+    || args.task_name !== expected.taskName
+    || (expected.requestedModel && args.model !== expected.requestedModel)
+    || (expected.requestedReasoningEffort && args.reasoning_effort !== expected.requestedReasoningEffort)
+  ) throw new Error('Codex parent rollout spawn identity does not match the hook event');
+  const activities = records.filter((record) => {
+    const payload = object(record?.payload);
+    return record?.type === 'event_msg'
+      && payload?.type === 'sub_agent_activity'
+      && payload.event_id === expected.toolUseId
+      && payload.kind === 'started'
+      && payload.agent_path === `/root/${expected.taskName}`
+      && nonEmpty(payload.agent_thread_id);
+  });
+  if (activities.length !== 1) throw new Error('Codex parent rollout child activity was not found uniquely');
+  return nonEmpty(object(activities[0]?.payload)?.agent_thread_id)!;
+}
+
 function validateCodexLifecycleHookConfig(value: unknown): void {
   const hooks = object(object(value)?.hooks);
   const valid = hooks && LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => {
@@ -63,7 +126,7 @@ function validateCodexLifecycleHookConfig(value: unknown): void {
       return entry.hooks.some((hookValue) => {
         const hook = object(hookValue);
         return hook?.type === 'command'
-          && hook.timeout === 5
+          && hook.timeout === 15
           && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`;
       });
     });
@@ -120,26 +183,38 @@ function hasCodexRuntimeLiveness(
     });
 }
 
-function parseCodexThreadResolution(readValue: unknown, resumeValue: unknown): ThreadResolution {
+function parseCodexThreadResolution(readValue: unknown, rolloutRecords: readonly unknown[]): ThreadResolution {
   const readRoot = object(readValue);
-  const resumeRoot = object(resumeValue);
   const thread = object(readRoot?.thread);
-  const resumedThread = object(resumeRoot?.thread);
   const source = object(thread?.source);
   const subAgent = object(source?.subAgent);
   const threadSpawn = object(subAgent?.thread_spawn);
+  const sessionMeta = rolloutRecords
+    .map(object)
+    .find((record) => record?.type === 'session_meta');
+  const sessionPayload = object(sessionMeta?.payload);
+  const turnContext = rolloutRecords
+    .map(object)
+    .filter((record) => record?.type === 'turn_context')
+    .at(-1);
+  const turnPayload = object(turnContext?.payload);
   const childThreadId = nonEmpty(thread?.id);
   const parentThreadId = nonEmpty(thread?.parentThreadId);
   const sourceParentThreadId = nonEmpty(threadSpawn?.parent_thread_id);
-  const resumedChildThreadId = nonEmpty(resumedThread?.id);
-  const model = nonEmpty(resumeRoot?.model);
-  const reasoningEffort = nonEmpty(resumeRoot?.reasoningEffort ?? object(resumeRoot?.settings)?.effort);
+  const rolloutChildThreadId = nonEmpty(sessionPayload?.id);
+  const rolloutParentThreadId = nonEmpty(sessionPayload?.parent_thread_id);
+  const agentRole = nonEmpty(sessionPayload?.agent_role);
+  const model = nonEmpty(turnPayload?.model);
+  const reasoningEffort = nonEmpty(turnPayload?.effort);
   const forkedFromId = thread?.forkedFromId;
   if (
     !childThreadId
-    || resumedChildThreadId !== childThreadId
+    || rolloutChildThreadId !== childThreadId
     || !parentThreadId
     || !sourceParentThreadId
+    || rolloutParentThreadId !== parentThreadId
+    || rolloutParentThreadId !== sourceParentThreadId
+    || !/^agent-infra-lifecycle-(executor|reviewer)$/.test(agentRole ?? '')
     || !model
     || !reasoningEffort
     || (forkedFromId !== null && typeof forkedFromId !== 'string')
@@ -152,7 +227,8 @@ function parseCodexThreadResolution(readValue: unknown, resumeValue: unknown): T
       childThreadId,
       parentThreadId,
       forkedFromId,
-      sourceParentThreadId
+      sourceParentThreadId,
+      nativeAgent: agentRole!
     }),
     settings: Object.freeze({
       type: 'app-settings',
@@ -163,6 +239,49 @@ function parseCodexThreadResolution(readValue: unknown, resumeValue: unknown): T
   });
 }
 
+function readCodexRolloutRecords(readValue: unknown, childThreadId: string): readonly unknown[] {
+  const thread = object(object(readValue)?.thread);
+  const rolloutPath = nonEmpty(thread?.path);
+  const rolloutName = rolloutPath ? path.basename(rolloutPath) : '';
+  if (!rolloutPath || (rolloutName !== `${childThreadId}.jsonl` && !rolloutName.endsWith(`-${childThreadId}.jsonl`))) {
+    throw new Error('Codex App Server rollout path is invalid');
+  }
+  const stat = fs.statSync(rolloutPath);
+  if (!stat.isFile()) throw new Error('Codex App Server rollout path is not a regular file');
+  const maxBytes = 1024 * 1024;
+  const bytes = Math.min(stat.size, maxBytes);
+  const descriptor = fs.openSync(rolloutPath, 'r');
+  try {
+    const buffer = Buffer.alloc(bytes);
+    fs.readSync(descriptor, buffer, 0, bytes, 0);
+    const text = buffer.toString('utf8');
+    const completeText = stat.size <= maxBytes ? text : text.slice(0, text.lastIndexOf('\n'));
+    return Object.freeze(completeText.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line)));
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+async function resolveCodexRolloutRecords(
+  readValue: unknown,
+  childThreadId: string,
+  attempts: number,
+  retryMs: number
+): Promise<readonly unknown[]> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const records = readCodexRolloutRecords(readValue, childThreadId);
+      parseCodexThreadResolution(readValue, records);
+      return records;
+    } catch (error) {
+      lastError = error;
+      if (attempt + 1 < attempts) await new Promise((resolve) => setTimeout(resolve, retryMs));
+    }
+  }
+  throw lastError;
+}
+
 function parseCodexTurnCompleted(value: unknown): Extract<CodexLifecycleEvent, { type: 'app-terminal' }> {
   const root = object(value);
   const turn = object(root?.turn);
@@ -333,12 +452,17 @@ async function resolveCodexThread(
     const readResult = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: false }));
     const readThread = object(readResult?.thread);
     if (nonEmpty(readThread?.id) !== childThreadId) throw new Error('Codex App Server returned the wrong child thread');
-    const resumeResult = await transport.request('thread/resume', { threadId: childThreadId });
     let resolution: ThreadResolution;
     try {
-      resolution = parseCodexThreadResolution(readResult, resumeResult);
+      const rolloutRecords = await resolveCodexRolloutRecords(
+        readResult,
+        childThreadId,
+        options.rolloutReadAttempts ?? DEFAULT_ROLLOUT_READ_ATTEMPTS,
+        options.rolloutRetryMs ?? DEFAULT_ROLLOUT_RETRY_MS
+      );
+      resolution = parseCodexThreadResolution(readResult, rolloutRecords);
     } catch {
-      throw new Error('Codex App Server resumed settings are unavailable');
+      throw new Error('Codex App Server rollout metadata is unavailable');
     }
     const reroutes = transport.notifications
       .filter((entry) => entry.method === 'model/rerouted')
@@ -368,6 +492,8 @@ async function resolveCodexTerminal(
     if (nonEmpty(thread?.id) !== childThreadId) throw new Error('Codex App Server returned the wrong child thread');
     const turns = Array.isArray(thread?.turns) ? thread.turns : [];
     const turn = turns.at(-1);
+    const turnValue = object(turn);
+    if (!turnValue || turnValue.status === 'inProgress') throw new Error('CODEX_TURN_NOT_TERMINAL');
     return parseCodexTurnCompleted({ threadId: childThreadId, turn });
   } finally {
     transport.close();
@@ -434,6 +560,7 @@ export {
   parseCodexHooksList,
   parseCodexThreadResolution,
   parseCodexTurnCompleted,
+  resolveCodexSpawnedChild,
   preflightCodexLifecycleEvidence,
   resolveCodexTerminal,
   resolveCodexThread,

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

@@ -21,7 +21,9 @@ type CodexLifecycleEvent =
       sessionId: string;
       turnId: string;
       childThreadId: string;
+      parentThreadId: string;
       nativeAgent: string;
+      source?: 'hook' | 'parent-rollout';
     }>
   | Readonly<{
       type: 'app-thread';
@@ -29,6 +31,7 @@ type CodexLifecycleEvent =
       parentThreadId: string;
       forkedFromId: string | null;
       sourceParentThreadId: string;
+      nativeAgent: string;
     }>
   | Readonly<{
       type: 'app-settings';
@@ -56,6 +59,7 @@ type CodexLifecycleEvent =
       turnId: string;
       childThreadId: string;
       nativeAgent: string;
+      source?: 'hook' | 'parent-rollout';
     }>;
 
 type CodexStartEvidence = Readonly<{
@@ -79,7 +83,7 @@ type CodexStopEvidence = Readonly<{
   childThreadId: string;
   turnId: string;
   terminalStatus: 'completed';
-  hookStopObserved: true;
+  hookStopObserved: boolean;
 }>;
 
 type CodexLifecycleStatus =
@@ -153,20 +157,32 @@ function requiredStrings(event: CodexLifecycleEvent): boolean {
 function derive(state: CodexLifecycleState): CodexLifecycleState {
   const { spawn, child, thread, settings, reroute, terminal, stop } = state;
   if (spawn && child && (
-    spawn.sessionId !== child.sessionId
+    spawn.sessionId !== child.parentThreadId
     || spawn.nativeAgent !== child.nativeAgent
   )) {
     return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook spawn and child identity do not match');
   }
+  if (child && child.sessionId !== child.parentThreadId) {
+    return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'child event session does not match the parent thread');
+  }
   if (child && thread && child.childThreadId !== thread.childThreadId) {
     return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server child identity do not match');
   }
+  if (child && thread && child.nativeAgent !== thread.nativeAgent) {
+    return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server agent roles do not match');
+  }
+  if (child && thread && child.parentThreadId !== thread.parentThreadId) {
+    return invalid(state, 'CODEX_EVIDENCE_PARENT_MISMATCH', 'hook and App Server parent identity do not match');
+  }
   if (spawn && thread && (
     thread.parentThreadId !== spawn.sessionId
     || thread.sourceParentThreadId !== spawn.sessionId
   )) {
     return invalid(state, 'CODEX_EVIDENCE_PARENT_MISMATCH', 'App Server parent identity does not match the spawning session');
   }
+  if (spawn && thread && spawn.nativeAgent !== thread.nativeAgent) {
+    return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'spawn and App Server agent roles do not match');
+  }
   if (thread?.forkedFromId !== null && thread?.forkedFromId !== undefined) {
     return invalid(state, 'CODEX_EVIDENCE_FORK_FORBIDDEN', 'forked child threads are not fresh lifecycle evidence');
   }
@@ -233,7 +249,7 @@ function derive(state: CodexLifecycleState): CodexLifecycleState {
       childThreadId: startEvidence.childThreadId,
       turnId: terminal.turnId,
       terminalStatus: 'completed',
-      hookStopObserved: true
+      hookStopObserved: stop.source !== 'parent-rollout'
     });
   }
   const status: CodexLifecycleStatus = stopEvidence

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

@@ -131,7 +131,7 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
     if (event.type === 'hook-child') {
       const matches = recordFiles(root).filter((file) => {
         const state = readRecord(file).state;
-        return state.spawn?.sessionId === event.sessionId
+        return state.spawn?.sessionId === event.parentThreadId
           && state.spawn.nativeAgent === event.nativeAgent
           && (!state.child || state.child.childThreadId === event.childThreadId);
       });
@@ -179,6 +179,45 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
     });
   }
 
+  function applyToSpawn(
+    identity: Readonly<{ sessionId: string; turnId: string; toolUseId: string }>,
+    event: Extract<CodexLifecycleEvent, { type: 'hook-child' }>
+  ): CodexLifecycleStoreResult {
+    return withWriteLock(() => {
+      const file = path.join(root, `${digest(`${identity.sessionId}\0${identity.turnId}\0${identity.toolUseId}`)}.json`);
+      if (!fs.existsSync(file)) throw new Error('Codex lifecycle spawn identity was not found');
+      const current = readRecord(file);
+      if (current.consumer) throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+      if (
+        current.state.spawn?.sessionId !== identity.sessionId
+        || current.state.spawn.turnId !== identity.turnId
+        || current.state.spawn.toolUseId !== identity.toolUseId
+      ) throw new Error('Codex lifecycle spawn identity does not match the stored event');
+      const nextState = reduceCodexLifecycleEvent(current.state, event);
+      const next = Object.freeze({
+        ...current,
+        revision: current.revision + 1,
+        state: nextState,
+        updatedAt: now()
+      });
+      writeRecord(file, next, current.revision);
+      return Object.freeze({ path: file, revision: next.revision, state: next.state });
+    });
+  }
+
+  function findByParent(parentThreadId: string): readonly StoredCodexLifecycle[] {
+    const matches = recordFiles(root)
+      .map(readRecord)
+      .filter((record) => record.state.startEvidence?.parentThreadId === parentThreadId
+        && ['start-ready', 'observed-terminal', 'stop-ready'].includes(record.state.status));
+    const unconsumed = matches.filter((record) => !record.consumer);
+    if (unconsumed.length > 1) throw new Error(`Codex lifecycle parent '${parentThreadId}' has ambiguous active children`);
+    if (unconsumed.length === 1) return Object.freeze(unconsumed);
+    return Object.freeze(matches
+      .filter((record) => record.consumer && record.state.status === 'stop-ready')
+      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)));
+  }
+
   function read(childThreadId: string): StoredCodexLifecycle {
     const matches = findByChild(childThreadId);
     if (matches.length !== 1) throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
@@ -196,7 +235,16 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
       if (matches.length !== 1) throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
       const file = matches[0]!;
       const current = readRecord(file);
-      if (current.consumer) throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+      if (current.consumer) {
+        if (current.consumer !== consumer) {
+          throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+        }
+        if (
+          expectedHookDefinitionHash
+          && current.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash
+        ) throw new Error('Codex lifecycle hook definition hash is stale');
+        return current;
+      }
       if (current.state.status !== 'stop-ready') throw new Error('Codex lifecycle evidence is not stop-ready');
       if (
         expectedHookDefinitionHash
@@ -239,7 +287,7 @@ function createCodexLifecycleStore(options: CodexLifecycleStoreOptions) {
     });
   }
 
-  return Object.freeze({ root, apply, consume, expireBefore, read });
+  return Object.freeze({ root, apply, applyToSpawn, consume, expireBefore, findByParent, read });
 }
 
 export { createCodexLifecycleStore };

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

@@ -15,7 +15,7 @@ const codexAdapter = defineAgentClientAdapter({
     commands: { level: 'integrated' },
     hooks: { level: 'integrated' },
     subagents: { level: 'experimental' },
-    orchestration: { level: 'unsupported' },
+    orchestration: { level: 'experimental' },
     sandbox: { level: 'integrated' },
     verification: { level: 'compatible' }
   },