@fitlab-ai/agent-infra 0.11.11 → 0.11.13

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

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 
-import { createCodexLifecycleStore } from './store.ts';
-import type { StoredCodexLifecycle } from './store.ts';
+import { createCodexLifecycleStore, readCodexLifecycleActivationEvidence } from './store.ts';
+import type { CodexLifecycleActivationEvidence, StoredCodexLifecycle } from './store.ts';
 import { managedDelegationRole } from '../../../task/delegation-receipts.ts';
 import type { DelegationReceipt } from '../../../task/delegation-receipts.ts';
 import { normalizeAgentToken } from '../../tokens.ts';
@@ -10,7 +10,6 @@ import type { ActivityLogSection, StepRow } from '../../../task/activity-log.ts'
 import { captureTaskWriteMetadata, writeTask } from '../../../task/write.ts';
 import { parseTypedTaskFrontmatter } from '../../../task/frontmatter.ts';
 import { resolveTaskRef } from '../../../task/resolve-ref.ts';
-import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.ts';
 import {
   recoverActivatedOrchestrationDelegationUnderLock,
   readRun
@@ -93,10 +92,12 @@ function rowForReceipt(rows: readonly StepRow[], receipt: DelegationReceipt): St
 
 function readLifecycleStore(
   options: LifecycleRecoveryOptions,
-  repoRoot: string
+  repoRoot: string,
+  taskId: string
 ): ReturnType<typeof createCodexLifecycleStore> {
   return options.lifecycleStore ?? createCodexLifecycleStore({
-    root: resolveAgentRuntimeStoreRoot({ repoRoot, store: 'lifecycle' }),
+    repoRoot,
+    taskId,
     cliVersion: 'recovery',
     now: options.now
   });
@@ -119,39 +120,10 @@ function validateStopRecord(
   record: StoredCodexLifecycle,
   receipt: DelegationReceipt
 ): { ok: true } | { ok: false; code: string; message: string } {
-  const start = record.state.startEvidence;
-  const stop = record.state.stopEvidence;
-  const provenance = receipt.lifecycleProvenance;
-  const host = receipt.hostEvidence;
-  if (
-    receipt.client !== 'codex'
-    || !provenance
-    || host?.kind !== 'codex-lifecycle-v2'
-    || !start
-    || !stop
-    || record.state.status !== 'stop-ready'
-    || stop.terminalStatus !== 'completed'
-    || stop.hookStopObserved !== true
-    || start.childThreadId !== receipt.childId
-    || start.parentThreadId !== receipt.parentId
-    || managedDelegationRole(start.nativeAgent) !== receipt.role
-    || start.hookDefinitionHash !== provenance.hookDefinitionHash
-    || host.hookDefinitionHash !== provenance.hookDefinitionHash
-    || host.capabilitySessionId !== provenance.capabilitySessionId
-    || host.capabilityTurnId !== provenance.capabilityTurnId
-    || host.capabilityToolUseId !== provenance.capabilityToolUseId
-    || host.spawnToolUseId !== start.spawnToolUseId
-    || !host.spawnObservedAt
-    || host.spawnObservedAt !== record.spawnObservedAt
-    || host.controllerInstanceDigest !== provenance.controllerInstanceDigest
-    || host.controlGeneration !== provenance.controlGeneration
-    || typeof host.controllerInstanceDigest !== 'string'
-    || typeof host.controlGeneration !== 'string'
-    || host.startRevision < 1
-    || record.revision <= host.startRevision
-    || record.state.child?.childThreadId !== receipt.childId
-    || record.state.stop?.childThreadId !== receipt.childId
-  ) {
+  if (!stopRecordMatchesReceipt(record, receipt)) {
+    return { ok: false, code: 'RECOVERY_TASK_BINDING_MISMATCH', message: 'lifecycle evidence belongs to a different task receipt' };
+  }
+  if (!stopEvidenceMatchesReceipt(record, receipt)) {
     return { ok: false, code: 'RECOVERY_STOP_EVIDENCE_INVALID', message: 'Codex stop evidence does not match the activated receipt' };
   }
   if (record.consumer !== null && record.consumer !== receipt.id) {
@@ -160,6 +132,104 @@ function validateStopRecord(
   return { ok: true };
 }
 
+function stopRecordMatchesReceipt(record: StoredCodexLifecycle, receipt: DelegationReceipt): boolean {
+  return record.taskBinding?.runId === receipt.runId
+    && record.taskBinding.receiptId === receipt.id;
+}
+
+function stopEvidenceMatchesReceipt(record: StoredCodexLifecycle, receipt: DelegationReceipt): boolean {
+  const start = record.state.startEvidence;
+  const stop = record.state.stopEvidence;
+  const host = readCodexLifecycleActivationEvidence(receipt);
+  if (!stopRecordHasRequiredEvidence(record, receipt, start, stop, host)) return false;
+  return spawnMatchesReceipt(record, receipt, host!, start!)
+    && childMatchesReceipt(record, receipt, start!, stop!)
+    && hostEvidenceMatches(record, receipt, host!, start!);
+}
+
+function stopRecordHasRequiredEvidence(
+  record: StoredCodexLifecycle,
+  receipt: DelegationReceipt,
+  start: StoredCodexLifecycle['state']['startEvidence'],
+  stop: StoredCodexLifecycle['state']['stopEvidence'],
+  host: CodexLifecycleActivationEvidence | null
+): boolean {
+  return receipt.client === 'codex'
+    && host?.kind === 'codex-lifecycle-v2'
+    && Boolean(start && stop && record.state.spawn && record.state.child && record.state.stop)
+    && record.state.status === 'stop-ready'
+    && stop?.terminalStatus === 'completed'
+    && stop.hookStopObserved === true;
+}
+
+function spawnMatchesReceipt(
+  record: StoredCodexLifecycle,
+  receipt: DelegationReceipt,
+  host: CodexLifecycleActivationEvidence,
+  start: NonNullable<StoredCodexLifecycle['state']['startEvidence']>
+): boolean {
+  const spawn = record.state.spawn;
+  return Boolean(spawn)
+    && spawn!.sessionId === start.parentThreadId
+    && spawn!.turnId === host.capabilityTurnId
+    && spawn!.toolUseId === host.spawnToolUseId
+    && spawn!.nativeAgent === start.nativeAgent
+    && spawn!.hookDefinitionHash === host.hookDefinitionHash
+    && spawn!.requestedModel === receipt.requestedModel
+    && spawn!.requestedReasoningEffort === receipt.requestedReasoningEffort
+    && spawn!.taskBinding?.runId === receipt.runId
+    && spawn!.taskBinding.receiptId === receipt.id;
+}
+
+function childMatchesReceipt(
+  record: StoredCodexLifecycle,
+  receipt: DelegationReceipt,
+  start: NonNullable<StoredCodexLifecycle['state']['startEvidence']>,
+  stop: NonNullable<StoredCodexLifecycle['state']['stopEvidence']>
+): boolean {
+  const child = record.state.child;
+  const stopState = record.state.stop;
+  return Boolean(child && stopState)
+    && child!.sessionId === start.parentThreadId
+    && stopState!.turnId === child!.turnId
+    && (stopState!.source === 'parent-rollout'
+      ? stop.turnId === record.state.terminal?.turnId
+      : child!.turnId === stop.turnId)
+    && child!.childThreadId === receipt.childId
+    && child!.nativeAgent === start.nativeAgent
+    && stopState!.childThreadId === receipt.childId
+    && stopState!.nativeAgent === start.nativeAgent
+    && start.childThreadId === receipt.childId
+    && start.parentThreadId === receipt.parentId
+    && managedDelegationRole(start.nativeAgent) === receipt.role;
+}
+
+function hostEvidenceMatches(
+  record: StoredCodexLifecycle,
+  receipt: DelegationReceipt,
+  host: CodexLifecycleActivationEvidence,
+  start: NonNullable<StoredCodexLifecycle['state']['startEvidence']>
+): boolean {
+  return start.hookDefinitionHash === host.hookDefinitionHash
+    && host.capabilitySessionId === start.parentThreadId
+    && host.capabilityTurnId === record.state.spawn?.turnId
+    && host.spawnToolUseId === start.spawnToolUseId
+    && Boolean(host.spawnObservedAt)
+    && host.spawnObservedAt === record.spawnObservedAt
+    && typeof host.controllerInstanceDigest === 'string'
+    && typeof host.controlGeneration === 'string'
+    && hostRevisionMatches(record, receipt, host);
+}
+
+function hostRevisionMatches(record: StoredCodexLifecycle, receipt: DelegationReceipt, host: CodexLifecycleActivationEvidence): boolean {
+  return typeof host.controllerInstanceDigest === 'string'
+    && typeof host.controlGeneration === 'string'
+    && host.startRevision >= 1
+    && record.revision > host.startRevision
+    && record.state.child?.childThreadId === receipt.childId
+    && record.state.stop?.childThreadId === receipt.childId;
+}
+
 function abortedCandidates(run: OrchestrationRun, rows: readonly StepRow[]): RecoveryCandidate[] {
   const candidates = run.receipts.flatMap((receipt) => {
     if (receipt.status !== 'aborted' || receipt.activatedAt === null || receipt.client !== 'codex') return [];
@@ -228,62 +298,117 @@ function recoverStartedLifecycleUnderLock(
 
   const rows = openRows(section);
   const pending = run.pendingDelegation;
-  if (!pending) {
-    const candidates = abortedCandidates(run, rows);
-    if (candidates.length === 0) return result(request, 'no-op', { taskId });
-    if (candidates.length > 1) {
-      return failure(request, 'conflict', 'RECOVERY_CANDIDATE_AMBIGUOUS', 'more than one aborted delegation has an open lifecycle row', { taskId });
-    }
-    return appendRecoveryLog(request, taskId, section, candidates[0]!, resolved.repoRoot, options.writeTask ?? writeTask);
+  if (!pending) return recoverAbortedLifecycle(request, taskId, section, resolved.repoRoot, run, rows, options);
+  return recoverActiveLifecycle(request, taskId, section, resolved.repoRoot, run, rows, pending, options);
+}
+
+function recoverAbortedLifecycle(
+  request: LifecycleRecoveryRequest,
+  taskId: string,
+  section: ActivityLogSection,
+  repoRoot: string,
+  run: OrchestrationRun,
+  rows: readonly StepRow[],
+  options: LifecycleRecoveryOptions
+): LifecycleRecoveryResult {
+  const candidates = abortedCandidates(run, rows);
+  if (candidates.length === 0) return result(request, 'no-op', { taskId });
+  if (candidates.length > 1) {
+    return failure(request, 'conflict', 'RECOVERY_CANDIDATE_AMBIGUOUS', 'more than one aborted delegation has an open lifecycle row', { taskId });
   }
+  return appendRecoveryLog(request, taskId, section, candidates[0]!, repoRoot, options.writeTask ?? writeTask);
+}
+
+function recoverActiveLifecycle(
+  request: LifecycleRecoveryRequest,
+  taskId: string,
+  section: ActivityLogSection,
+  repoRoot: string,
+  run: OrchestrationRun,
+  rows: readonly StepRow[],
+  pending: DelegationReceipt,
+  options: LifecycleRecoveryOptions
+): LifecycleRecoveryResult {
   if (pending.status !== 'activated') return result(request, 'no-op', { taskId });
   if (pending.client !== 'codex' || run.status !== 'running' || run.pause !== null) {
     return failure(request, 'conflict', 'RECOVERY_ORCHESTRATION_INVALID', 'activated recovery requires one running Codex delegation', {
       taskId, receiptId: pending.id, childId: pending.childId
     });
   }
+  const rowResult = matchingActiveRecoveryRow(request, taskId, rows, pending);
+  if ('result' in rowResult) return rowResult.result;
+  const evidenceResult = consumeRecoveryEvidence(request, taskId, repoRoot, pending, options);
+  if ('result' in evidenceResult) return evidenceResult.result;
+  return finishActiveRecovery(request, taskId, section, repoRoot, pending, rowResult.row, options);
+}
+
+function matchingActiveRecoveryRow(
+  request: LifecycleRecoveryRequest,
+  taskId: string,
+  rows: readonly StepRow[],
+  pending: DelegationReceipt
+): { row: StepRow } | { result: LifecycleRecoveryResult } {
   const matchingRows = rowForReceipt(rows, pending);
   if (matchingRows.length !== 1 || normalizeAgentToken(matchingRows[0]!.agent) !== 'codex' || matchingRows[0]!.note !== 'started') {
-    return failure(request, 'conflict', 'RECOVERY_LOG_CONFLICT', 'activated delegation does not have one matching open lifecycle row', {
+    return { result: failure(request, 'conflict', 'RECOVERY_LOG_CONFLICT', 'activated delegation does not have one matching open lifecycle row', {
       taskId, receiptId: pending.id, childId: pending.childId
-    });
+    }) };
   }
   if (!pending.childId) {
-    return failure(request, 'conflict', 'RECOVERY_DELEGATION_INVALID', 'activated delegation has no child identity', { taskId, receiptId: pending.id });
+    return { result: failure(request, 'conflict', 'RECOVERY_DELEGATION_INVALID', 'activated delegation has no child identity', { taskId, receiptId: pending.id }) };
   }
-  const store = readLifecycleStore(options, resolved.repoRoot);
-  const stored = readStoredEvidence(store, pending.childId);
-  if ('error' in stored) return failure(request, 'owner-unknown', 'RECOVERY_STORE_UNKNOWN', stored.error.message, { taskId, receiptId: pending.id, childId: pending.childId });
-  if ('missing' in stored) return failure(request, 'owner-unknown', 'RECOVERY_STOP_EVIDENCE_MISSING', 'matching Codex lifecycle stop evidence is missing', { taskId, receiptId: pending.id, childId: pending.childId });
-  const evidence = validateStopRecord(stored, pending);
-  if (!evidence.ok) return failure(request, evidence.code === 'RECOVERY_CONSUMER_CONFLICT' ? 'conflict' : 'owner-unknown', evidence.code, evidence.message, { taskId, receiptId: pending.id, childId: pending.childId });
+  return { row: matchingRows[0]! };
+}
 
+function consumeRecoveryEvidence(
+  request: LifecycleRecoveryRequest,
+  taskId: string,
+  repoRoot: string,
+  pending: DelegationReceipt,
+  options: LifecycleRecoveryOptions
+): { consumed: StoredCodexLifecycle } | { result: LifecycleRecoveryResult } {
+  const store = readLifecycleStore(options, repoRoot, taskId);
+  const stored = readStoredEvidence(store, pending.childId!);
+  if ('error' in stored) return { result: failure(request, 'owner-unknown', 'RECOVERY_STORE_UNKNOWN', stored.error.message, { taskId, receiptId: pending.id, childId: pending.childId }) };
+  if ('missing' in stored) return { result: failure(request, 'owner-unknown', 'RECOVERY_STOP_EVIDENCE_MISSING', 'matching Codex lifecycle stop evidence is missing', { taskId, receiptId: pending.id, childId: pending.childId }) };
+  const evidence = validateStopRecord(stored, pending);
+  if (!evidence.ok) return { result: failure(request, evidence.code === 'RECOVERY_CONSUMER_CONFLICT' ? 'conflict' : 'owner-unknown', evidence.code, evidence.message, { taskId, receiptId: pending.id, childId: pending.childId }) };
   let consumed = stored;
   if (stored.consumer === null) {
     try {
-      consumed = store.consume(pending.childId, pending.id, pending.hostEvidence?.hookDefinitionHash);
+      consumed = store.consumeWithinTaskLock(pending.childId!, pending.id, stored.state.startEvidence?.hookDefinitionHash, {
+        taskId: pending.taskId, runId: pending.runId, receiptId: pending.id
+      });
     } catch (error) {
-      return failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_CONSUME_FAILED', error instanceof Error ? error.message : String(error), { taskId, receiptId: pending.id, childId: pending.childId });
+      return { result: failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_CONSUME_FAILED', error instanceof Error ? error.message : String(error), { taskId, receiptId: pending.id, childId: pending.childId }) };
     }
   }
-  if (!consumed.consumedAt) {
-    return failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_INVALID', 'consumed stop evidence has no timestamp', { taskId, receiptId: pending.id, childId: pending.childId });
-  }
+  return consumed.consumedAt
+    ? { consumed }
+    : { result: failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_INVALID', 'consumed stop evidence has no timestamp', { taskId, receiptId: pending.id, childId: pending.childId }) };
+}
+
+function finishActiveRecovery(
+  request: LifecycleRecoveryRequest,
+  taskId: string,
+  section: ActivityLogSection,
+  repoRoot: string,
+  pending: DelegationReceipt,
+  row: StepRow,
+  options: LifecycleRecoveryOptions
+): LifecycleRecoveryResult {
   const recovered = recoverActivatedOrchestrationDelegationUnderLock(taskId, {
     receiptId: pending.id,
     stage: pending.stage,
     round: pending.round,
     artifact: pending.artifact,
     startedAgent: request.agent,
-    childId: pending.childId,
-    stopRevision: consumed.revision,
-    consumer: pending.id,
-    consumedAt: consumed.consumedAt
-  }, { ...options.orchestration, repoRoot: resolved.repoRoot, now: options.now });
+    childId: pending.childId!
+  }, { ...options.orchestration, repoRoot, now: options.now });
   if (recovered.status === 'failed' || !recovered.run) {
     return failure(request, 'owner-unknown', recovered.error?.code ?? 'RECOVERY_ORCHESTRATION_FAILED', recovered.error?.message ?? 'orchestration recovery failed', { taskId, receiptId: pending.id, childId: pending.childId });
   }
-  return appendRecoveryLog(request, taskId, section, { receipt: recovered.run.receipts.at(-1)!, row: matchingRows[0]! }, resolved.repoRoot, options.writeTask ?? writeTask);
+  return appendRecoveryLog(request, taskId, section, { receipt: recovered.run.receipts.at(-1)!, row }, repoRoot, options.writeTask ?? writeTask);
 }
 
 function recoverStartedLifecycleFromAdapter(

package/lib/{internal/codex-sandbox-controller.ts → agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.ts}

@@ -1,8 +1,8 @@
 import {
   runCodexSandboxController,
   verifyCodexSandboxControllerContextWithWarnings
-} from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
-import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
+} from './sandbox-controller.ts';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from '../../../internal/cli-route-inventory.ts';
 
 const USAGE = 'Usage: agent-infra-internal codex-sandbox-controller <run|verify-context> [options]\n';
 

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

@@ -10,7 +10,7 @@ import {
   requestCodexControllerClose,
   requestCodexControllerOpen,
   requestCodexControllerVerify
-} from '../../../sandbox/control/client.ts';
+} from './controller-client.ts';
 import { getProcessStartTime, type ProcessIdentity } from '../../../server/process-state.ts';
 import { LIFECYCLE_PROTOCOL_VERSION, type LifecycleIdentityWarning } from './build-identity.ts';
 import {
@@ -126,8 +126,7 @@ function verifyControllerBinding(
     ...control,
     timeoutMs: 30_000
   });
-  if (verified.binding.taskId !== context.taskId
-    || verified.binding.controlGeneration !== context.controlGeneration
+  if (verified.binding.controlGeneration !== context.controlGeneration
     || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
     throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
   }
@@ -150,8 +149,7 @@ function verifyCodexSandboxControllerContextWithWarnings(
     ...control,
     timeoutMs: 30_000
   });
-  if (verified.binding.taskId !== context.taskId
-    || verified.binding.controlGeneration !== context.controlGeneration
+  if (verified.binding.controlGeneration !== context.controlGeneration
     || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
     throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
   }