@fitlab-ai/agent-infra 0.9.6 → 0.9.8

package/lib/task/codex-orchestration.ts

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+
 import {
   preflightCodexLifecycleEvidence,
   resolveCodexSpawnedChild,
@@ -5,9 +7,16 @@ import {
   resolveCodexThread
 } from '../agent-clients/adapters/codex-lifecycle/app-server.ts';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
+import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
+import type { LifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
+import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
+import { resolveTaskRef } from './resolve-ref.ts';
 import {
   activateMatchingOrchestrationDelegation,
+  hasActivatableOrchestrationDelegation,
+  hasSealableOrchestrationDelegation,
   pauseMatchingOrchestrationDelegation,
   prepareOrchestrationDelegation,
   reconcileMatchingOrchestrationDelegation,
@@ -16,12 +25,15 @@ import {
 import type { OrchestrationOptions, OrchestrationResult } from './orchestration.ts';
 
 type LifecycleStore = ReturnType<typeof createCodexLifecycleStore>;
+type CapabilityStore = ReturnType<typeof createCodexCapabilityStore>;
 type CodexBridgeOptions = Readonly<{
   repoRoot?: string;
   store?: LifecycleStore;
   preflight?: typeof preflightCodexLifecycleEvidence;
   resolveThread?: typeof resolveCodexThread;
   resolveTerminal?: typeof resolveCodexTerminal;
+  capabilityStore?: CapabilityStore;
+  buildIdentity?: LifecycleBuildIdentity;
   orchestrationOptions?: OrchestrationOptions;
 }>;
 
@@ -59,25 +71,68 @@ function requiredStore(options: CodexBridgeOptions): LifecycleStore {
   return options.store;
 }
 
+function controllerContext(taskId: string, repoRoot: string) {
+  const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+  return contextPath
+    ? verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot })
+    : null;
+}
+
 async function prepareCodexOrchestrationDelegation(
   taskRef: string,
   input: Readonly<{
     client: AgentClientId;
     requestedModel?: string;
     requestedReasoningEffort?: string;
+    capabilityToken?: string;
   }>,
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
   if (input.client !== 'codex') return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
   try {
-    await (options.preflight ?? preflightCodexLifecycleEvidence)(options.repoRoot ?? process.cwd());
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const resolved = resolveTaskRef(taskRef, { repoRoot });
+    if (!resolved.ok) return bridgeFailure(resolved.code, resolved.message);
+    const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
+    if (!input.capabilityToken) {
+      return bridgeFailure(
+        'ORCHESTRATION_CODEX_CAPABILITY_REQUIRED',
+        'Codex prepare requires a current-session capability token'
+      );
+    }
+    const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+    const controller = controllerContext(resolved.taskId, repoRoot);
+    const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
+    const consumed = capabilityStore.consume(input.capabilityToken, {
+      taskId: resolved.taskId,
+      hookDefinitionHash: preflight.hookDefinitionHash,
+      buildIdentity,
+      ...(controller ? { controller: {
+        instanceDigest: controller.controllerInstanceDigest,
+        controlGeneration: controller.controlGeneration
+      } } : {})
+    });
+    return prepareOrchestrationDelegation(taskRef, {
+      ...input,
+      lifecycleProvenance: {
+        ...consumed.buildIdentity,
+        hookDefinitionHash: preflight.hookDefinitionHash,
+        ...preflight.hookProvenance,
+        capabilitySessionId: consumed.sessionId!,
+        capabilityTurnId: consumed.turnId!,
+        capabilityToolUseId: consumed.toolUseId!,
+        controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+        controlGeneration: controller?.controlGeneration ?? null
+      }
+    }, coreOptions(options));
   } catch (error) {
     return bridgeFailure(
-      'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
+      error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
+        ? error.name
+        : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
       error instanceof Error ? error.message : String(error)
     );
   }
-  return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
 }
 
 async function activateCodexOrchestrationDelegation(
@@ -85,6 +140,9 @@ async function activateCodexOrchestrationDelegation(
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
   try {
+    if (!hasActivatableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+      return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+    }
     const store = requiredStore(options);
     const resolved = await (options.resolveThread ?? resolveCodexThread)(childThreadId);
     store.apply(resolved.resolution.thread);
@@ -95,6 +153,23 @@ async function activateCodexOrchestrationDelegation(
     if (record.state.status !== 'start-ready' || !evidence) {
       return pauseBridge('ORCHESTRATION_CODEX_START_EVIDENCE_INVALID', 'Codex lifecycle start evidence is not ready', options);
     }
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot, {
+      sessionId: evidence.parentThreadId,
+      turnId: evidence.parentTurnId,
+      toolUseId: evidence.spawnToolUseId
+    });
+    const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+    const contextTaskId = contextPath
+      ? (JSON.parse(fs.readFileSync(contextPath, 'utf8')) as { taskId?: unknown }).taskId
+      : null;
+    if (contextPath && typeof contextTaskId !== 'string') {
+      throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    const controller = contextPath
+      ? verifyCodexSandboxControllerContext(contextPath, contextTaskId as string, { repoRoot })
+      : null;
     return activateMatchingOrchestrationDelegation('codex', {
       nativeAgent: evidence.nativeAgent,
       childId: evidence.childThreadId,
@@ -107,9 +182,17 @@ async function activateCodexOrchestrationDelegation(
         ? { reasoningEffortFallbackReason: evidence.reasoningEffortFallbackReason }
         : {}),
       hostEvidence: {
-        kind: 'codex-lifecycle-v1',
+        kind: 'codex-lifecycle-v2',
         hookDefinitionHash: evidence.hookDefinitionHash,
-        startRevision: record.revision
+        startRevision: record.revision,
+        ...buildIdentity,
+        ...preflight.hookProvenance,
+        capabilitySessionId: evidence.parentThreadId,
+        capabilityTurnId: evidence.parentTurnId,
+        spawnToolUseId: evidence.spawnToolUseId,
+        spawnObservedAt: record.spawnObservedAt ?? undefined,
+        controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+        controlGeneration: controller?.controlGeneration ?? null
       }
     }, coreOptions(options));
   } catch (error) {
@@ -149,6 +232,9 @@ async function sealCodexOrchestrationDelegation(
   options: CodexBridgeOptions = {}
 ): Promise<OrchestrationResult> {
   try {
+    if (!hasSealableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+      return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+    }
     const store = requiredStore(options);
     const existing = store.read(childThreadId);
     if (!existing.consumer) {

package/lib/task/commands/validate.ts

@@ -169,7 +169,7 @@ function inplaceValidation(config: ReturnType<typeof loadConfig>, target: Return
   const nonce = randomUUID();
   const issuedAt = Date.now();
   const lease: SandboxControlLease = {
-    version: 1, generation: manifest.generation, nonce,
+    version: 2, generation: manifest.generation, nonce,
     owner: { pid: process.pid, startTime }, issuedAt,
     expiresAt: issuedAt + Math.min(options.timeoutMs + RECOVERY_GRACE_MS, MAX_TIMEOUT_MS + RECOVERY_GRACE_MS),
     taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,

package/lib/task/create.ts

@@ -231,6 +231,14 @@ function assertRealDirectory(directory: string, code: string): void {
   if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(code);
 }
 
+function ensureRealDirectory(directory: string, code: string): void {
+  if (fs.existsSync(directory)) {
+    assertRealDirectory(directory, code);
+    return;
+  }
+  fs.mkdirSync(directory, { mode: 0o700 });
+}
+
 function withCreateLock<T>(repoRoot: string, workspaceRoot: string, operation: () => T): T {
   const lockRoot = path.join(workspaceRoot, '.task-create.lock');
   fs.mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
@@ -289,8 +297,9 @@ function createLocalTask(value: unknown, options: LocalTaskCreateOptions): Local
   const repoRoot = fs.realpathSync.native(options.repoRoot);
   const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
   const activeRoot = path.join(workspaceRoot, 'active');
-  assertRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
-  assertRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+  ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
   const project = readProject(repoRoot);
   const canonical = canonicalTaskCreateCandidate(candidate);
   const candidateDigest = sha256(canonical);

package/lib/task/decision-intents.ts

@@ -16,6 +16,7 @@ import { resolveTaskContext } from './resolve-ref.ts';
 import { extractSection, extractSubSection, findSectionHeading } from './sections.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
+import { allowsManualOverride } from './guard-override.ts';
 
 type HumanDecisionRequest = {
   taskRef?: string;
@@ -85,7 +86,8 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
   if (!request.selector || !request.decision.trim()) return failed('DECISION_PAYLOAD_INVALID', 'selector and decision are required');
   const resolved = resolveTaskContext(request.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
-  if (resolved.state !== 'active') return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
+  const stateOverride = allowsManualOverride(options.manualOverride, 'decision-intent', 'TASK_STATE_MISMATCH');
+  if (resolved.state !== 'active' && !stateOverride) return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   let content: string;
   let rows: LedgerRow[];
   try { content = fs.readFileSync(resolved.taskMdPath, 'utf8'); rows = parseLedger(content); }
@@ -170,7 +172,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
     kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
     body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
   });
-  const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, {
+  const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
     ...options,
     taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
     metadataProvider: () => metadata

package/lib/task/delegation-receipts.ts

@@ -7,12 +7,41 @@ type DelegationRole = 'executor' | 'reviewer';
 type DelegationStage = 'analysis' | 'review-analysis' | 'plan' | 'review-plan' | 'code' | 'review-code' | 'commit';
 type DelegationStatus = 'prepared' | 'activated' | 'stage-completed' | 'sealed' | 'consumed' | 'aborted' | 'expired';
 type DelegationHostEvidence = Readonly<{
-  kind: 'codex-lifecycle-v1';
+  kind: 'codex-lifecycle-v1' | 'codex-lifecycle-v2';
   hookDefinitionHash: string;
   startRevision: number;
   stopRevision: number | null;
   consumer: string | null;
   consumedAt: string | null;
+  protocolVersion?: number;
+  packageVersion?: string;
+  internalExecutableBuildHash?: string;
+  lifecycleContractHash?: string;
+  hookSource?: 'project' | 'managed' | 'isolated-user';
+  hookSourcePathDigest?: string;
+  hookSourceHash?: string;
+  capabilitySessionId?: string;
+  capabilityTurnId?: string;
+  capabilityToolUseId?: string;
+  spawnToolUseId?: string;
+  spawnObservedAt?: string;
+  controllerInstanceDigest?: string | null;
+  controlGeneration?: string | null;
+}>;
+type DelegationLifecycleProvenance = Readonly<{
+  protocolVersion: number;
+  packageVersion: string;
+  internalExecutableBuildHash: string;
+  lifecycleContractHash: string;
+  hookDefinitionHash: string;
+  hookSource: 'project' | 'managed' | 'isolated-user';
+  hookSourcePathDigest: string;
+  hookSourceHash: string;
+  capabilitySessionId: string;
+  capabilityTurnId: string;
+  capabilityToolUseId: string;
+  controllerInstanceDigest: string | null;
+  controlGeneration: string | null;
 }>;
 
 type DelegationReceipt = Readonly<{
@@ -36,11 +65,19 @@ type DelegationReceipt = Readonly<{
   agent: string | null;
   status: DelegationStatus;
   workspaceSnapshotScope?: 'task';
+  lifecycleProvenance?: DelegationLifecycleProvenance | null;
   hostEvidence?: DelegationHostEvidence | null;
   beforeFingerprint: string;
   afterFingerprint: string | null;
   changedPaths: readonly string[];
   createdAt: string;
+  preparedMonotonicMs: number;
+  spawnDispatchMonotonicMs: number | null;
+  activationDeadlineMonotonicMs: number | null;
+  spawnDispatchedAt: string | null;
+  activationDeadlineAt: string | null;
+  startEvidenceMonotonicMs: number | null;
+  activatedMonotonicMs: number | null;
   activatedAt: string | null;
   sealedAt: string | null;
   consumedAt: string | null;
@@ -63,10 +100,16 @@ function fail(code: string, message: string): ReceiptFailure {
   return { ok: false, code, message };
 }
 
+// 空白串折叠为 null，保持"缺失即 null"的单一表示（Start/Stop 两处共用，避免任一入口把 "   " 当成已观察到的值入账）
+function foldBlankToNull(value: string | undefined): string | null {
+  return value?.trim() ? value : null;
+}
+
 function prepareDelegation(
-  input: Omit<DelegationReceipt, 'id' | 'requestedModel' | 'requestedReasoningEffort' | 'actualModel' | 'actualReasoningEffort' | 'modelFallbackReason' | 'reasoningEffortFallbackReason' | 'parentId' | 'childId' | 'spawnMode' | 'agent' | 'status' | 'hostEvidence' | 'afterFingerprint' | 'changedPaths' | 'createdAt' | 'activatedAt' | 'sealedAt' | 'consumedAt'> & Readonly<{ requestedModel: string; requestedReasoningEffort: string }>,
-  options: { id?: () => string; now?: () => string } = {}
+  input: Omit<DelegationReceipt, 'id' | 'requestedModel' | 'requestedReasoningEffort' | 'actualModel' | 'actualReasoningEffort' | 'modelFallbackReason' | 'reasoningEffortFallbackReason' | 'parentId' | 'childId' | 'spawnMode' | 'agent' | 'status' | 'hostEvidence' | 'afterFingerprint' | 'changedPaths' | 'createdAt' | 'preparedMonotonicMs' | 'spawnDispatchMonotonicMs' | 'activationDeadlineMonotonicMs' | 'spawnDispatchedAt' | 'activationDeadlineAt' | 'startEvidenceMonotonicMs' | 'activatedMonotonicMs' | 'activatedAt' | 'sealedAt' | 'consumedAt'> & Readonly<{ requestedModel: string; requestedReasoningEffort: string }>,
+  options: { id?: () => string; now?: () => string; monotonicNow?: () => number } = {}
 ): DelegationReceipt {
+  const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))();
   return Object.freeze({
     ...input,
     id: (options.id ?? randomUUID)(),
@@ -83,60 +126,136 @@ function prepareDelegation(
     afterFingerprint: null,
     changedPaths: Object.freeze([]),
     createdAt: (options.now ?? (() => new Date().toISOString()))(),
+    preparedMonotonicMs: monotonic,
+    spawnDispatchMonotonicMs: null,
+    activationDeadlineMonotonicMs: null,
+    spawnDispatchedAt: null,
+    activationDeadlineAt: null,
+    startEvidenceMonotonicMs: null,
+    activatedMonotonicMs: null,
     activatedAt: null,
     sealedAt: null,
     consumedAt: null
   });
 }
 
+function dispatchDelegation(
+  receipt: DelegationReceipt,
+  options: { now?: () => string; monotonicNow?: () => number; activationWindowMs?: number } = {}
+): ReceiptResult {
+  if (receipt.status !== 'prepared') {
+    return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+  }
+  if (receipt.spawnDispatchMonotonicMs != null || receipt.spawnDispatchedAt != null) {
+    return fail('DELEGATION_DISPATCH_REPLAY', `delegation ${receipt.id} was already dispatched`);
+  }
+  const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))();
+  const dispatchedAt = (options.now ?? (() => new Date().toISOString()))();
+  const window = options.activationWindowMs ?? 15_000;
+  return { ok: true, receipt: Object.freeze({
+    ...receipt,
+    spawnDispatchMonotonicMs: monotonic,
+    activationDeadlineMonotonicMs: monotonic + window,
+    spawnDispatchedAt: dispatchedAt,
+    activationDeadlineAt: new Date(Date.parse(dispatchedAt) + window).toISOString()
+  }) };
+}
+
 function activateDelegation(
   receipt: DelegationReceipt,
   event: Readonly<{
     nativeAgent: string;
     childId: string;
     parentId: string;
-    spawnMode: string;
+    spawnMode?: string;
     actualModel?: string;
     actualReasoningEffort?: string;
     modelFallbackReason?: string;
     reasoningEffortFallbackReason?: string;
     hostEvidence?: Readonly<{
-      kind: 'codex-lifecycle-v1';
+      kind: 'codex-lifecycle-v1' | 'codex-lifecycle-v2';
       hookDefinitionHash: string;
       startRevision: number;
+      protocolVersion?: number;
+      packageVersion?: string;
+      internalExecutableBuildHash?: string;
+      lifecycleContractHash?: string;
+      hookSource?: 'project' | 'managed' | 'isolated-user';
+      hookSourcePathDigest?: string;
+      hookSourceHash?: string;
+      capabilitySessionId?: string;
+      capabilityTurnId?: string;
+      capabilityToolUseId?: string;
+      spawnToolUseId?: string;
+      spawnObservedAt?: string;
+      controllerInstanceDigest?: string | null;
+      controlGeneration?: string | null;
     }>;
   }>,
-  options: { now?: () => string } = {}
+  options: { now?: () => string; monotonicNow?: () => number } = {}
 ): ReceiptResult {
   const managedRole = managedDelegationRole(event.nativeAgent);
   if (!managedRole) return fail('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
   if (receipt.status !== 'prepared') return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+  if (
+    receipt.spawnDispatchMonotonicMs == null
+    || receipt.spawnDispatchedAt == null
+    || receipt.activationDeadlineAt == null
+    || receipt.activationDeadlineMonotonicMs == null
+    || !Number.isFinite(Date.parse(receipt.spawnDispatchedAt))
+    || !Number.isFinite(Date.parse(receipt.activationDeadlineAt))
+  ) {
+    return fail('DELEGATION_NOT_DISPATCHED', `delegation ${receipt.id} has not reached the native spawn dispatch boundary`);
+  }
+  const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))();
+  const wallNow = Date.parse((options.now ?? (() => new Date().toISOString()))());
+  if (wallNow > Date.parse(receipt.activationDeadlineAt)) {
+    return fail('DELEGATION_ACTIVATION_TIMEOUT', `delegation ${receipt.id} activation evidence arrived after its deadline`);
+  }
   if (managedRole !== receipt.role) return fail('DELEGATION_ROLE_MISMATCH', `managed role ${managedRole} does not match ${receipt.role}`);
   if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
     return fail('DELEGATION_IDENTITY_INVALID', 'native parent/child identity does not match the prepared delegation');
   }
-  if (event.spawnMode !== 'fresh') return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
-  const actualModel = event.actualModel;
-  if (!actualModel || actualModel.trim() !== actualModel) {
-    return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
+  // spawnMode 的必需性按 client 判断：claude-code 宿主结构上不提供该字段，跳过；其余 client 维持硬校验
+  if (receipt.client !== 'claude-code' && event.spawnMode !== 'fresh') {
+    return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
+  }
+  // model/effort 维度：claude-code 如实记录、不做门禁；其余 client 维持现状硬校验（HDR-2）
+  const actualModel = foldBlankToNull(event.actualModel);
+  const actualReasoningEffort = foldBlankToNull(event.actualReasoningEffort);
+  if (receipt.client !== 'claude-code') {
+    if (!actualModel || actualModel.trim() !== actualModel) {
+      return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
+    }
   }
-  if (actualModel !== receipt.requestedModel && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
-    return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+  if (actualModel !== null && actualModel !== receipt.requestedModel) {
+    if (receipt.client !== 'claude-code' && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
+      return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+    }
   }
-  const actualReasoningEffort = event.actualReasoningEffort;
-  if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
-    return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
+  if (receipt.client !== 'claude-code') {
+    if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
+      return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
+    }
   }
   if (
-    actualReasoningEffort !== receipt.requestedReasoningEffort
-    && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')
-  ) {
-    return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+    receipt.client === 'codex'
+    && event.hostEvidence?.kind !== 'codex-lifecycle-v2'
+  ) return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex activation requires trusted lifecycle-v2 host evidence');
+  if (actualReasoningEffort !== null && actualReasoningEffort !== receipt.requestedReasoningEffort) {
+    if (receipt.client !== 'claude-code' && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
+      return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+    }
   }
-  if (actualModel === receipt.requestedModel && event.modelFallbackReason) {
+  // "无关 fallback 理由"检查对所有 client 保持不变——防止编造理由的红线，不属于 HDR-2 放宽范围
+  // actualModel/actualReasoningEffort 为 null（未观察到）时同样没有"实际不同"这回事，理由一样是无关的
+  if ((actualModel === null || actualModel === receipt.requestedModel) && event.modelFallbackReason) {
     return fail('DELEGATION_MODEL_FALLBACK_INVALID', 'model fallback reason is only valid when actual model differs');
   }
-  if (actualReasoningEffort === receipt.requestedReasoningEffort && event.reasoningEffortFallbackReason) {
+  if (
+    (actualReasoningEffort === null || actualReasoningEffort === receipt.requestedReasoningEffort)
+    && event.reasoningEffortFallbackReason
+  ) {
     return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
   }
   if (
@@ -148,12 +267,39 @@ function activateDelegation(
       || event.hostEvidence.startRevision < 1
     )
   ) return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence reference is invalid');
+  if (event.hostEvidence?.kind === 'codex-lifecycle-v2') {
+    const expected = receipt.lifecycleProvenance;
+    const spawnObservedAt = Date.parse(event.hostEvidence.spawnObservedAt ?? '');
+    const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt);
+    const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt);
+    if (
+      !expected
+      || event.hostEvidence.protocolVersion !== expected.protocolVersion
+      || event.hostEvidence.packageVersion !== expected.packageVersion
+      || event.hostEvidence.internalExecutableBuildHash !== expected.internalExecutableBuildHash
+      || event.hostEvidence.lifecycleContractHash !== expected.lifecycleContractHash
+      || event.hostEvidence.hookDefinitionHash !== expected.hookDefinitionHash
+      || event.hostEvidence.hookSource !== expected.hookSource
+      || event.hostEvidence.hookSourcePathDigest !== expected.hookSourcePathDigest
+      || event.hostEvidence.hookSourceHash !== expected.hookSourceHash
+      || event.hostEvidence.capabilitySessionId !== expected.capabilitySessionId
+      || event.hostEvidence.capabilityTurnId !== expected.capabilityTurnId
+      || !event.hostEvidence.spawnToolUseId?.trim()
+      || event.hostEvidence.spawnToolUseId === expected.capabilityToolUseId
+      || !Number.isFinite(spawnObservedAt)
+      || spawnObservedAt < spawnDispatchedAt
+      || spawnObservedAt > activationDeadlineAt
+      || event.parentId !== expected.capabilitySessionId
+      || (event.hostEvidence.controllerInstanceDigest ?? null) !== expected.controllerInstanceDigest
+      || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration
+    ) return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex lifecycle provenance does not match the prepared receipt');
+  }
   return { ok: true, receipt: Object.freeze({
     ...receipt,
     status: 'activated',
     parentId: event.parentId,
     childId: event.childId,
-    spawnMode: event.spawnMode,
+    spawnMode: event.spawnMode ?? null,
     actualModel,
     actualReasoningEffort,
     modelFallbackReason: event.modelFallbackReason ?? null,
@@ -164,10 +310,22 @@ function activateDelegation(
       consumer: null,
       consumedAt: null
     }) : receipt.hostEvidence ?? null,
-    activatedAt: (options.now ?? (() => new Date().toISOString()))()
+    startEvidenceMonotonicMs: monotonic,
+    activatedMonotonicMs: (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1_000_000n)))(),
+    activatedAt: new Date(wallNow).toISOString()
   }) };
 }
 
+function abortPreparedDelegation(receipt: DelegationReceipt): ReceiptResult {
+  if (receipt.status !== 'prepared') {
+    return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+  }
+  return {
+    ok: true,
+    receipt: Object.freeze({ ...receipt, status: 'aborted' as const })
+  };
+}
+
 function completeDelegationStage(
   receipt: DelegationReceipt,
   event: Readonly<{ stage: DelegationStage; round: number; artifact: string; agent: string }>
@@ -189,11 +347,18 @@ function sealDelegation(
     exitCode: number;
     afterFingerprint: string;
     changedPaths: readonly string[];
+    actualModel?: string;
+    actualReasoningEffort?: string;
+    modelFallbackReason?: string;
+    reasoningEffortFallbackReason?: string;
     hostEvidence?: Readonly<{ stopRevision: number; consumer: string; consumedAt: string }>;
   }>,
-  options: { now?: () => string } = {}
+  options: { now?: () => string; requireHostEvidence?: boolean } = {}
 ): ReceiptResult {
   if (receipt.status !== 'stage-completed') return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+  if (receipt.client === 'codex' && options.requireHostEvidence !== false && !event.hostEvidence) {
+    return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex sealing requires consumed lifecycle-v2 host evidence');
+  }
   if (event.childId !== receipt.childId || event.exitCode !== 0) return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
   if (receipt.role === 'reviewer') {
     const taskRoot = `.agents/workspace/active/${receipt.taskId}/`;
@@ -219,6 +384,10 @@ function sealDelegation(
     status: 'sealed',
     afterFingerprint: event.afterFingerprint,
     changedPaths: Object.freeze([...event.changedPaths]),
+    actualModel: receipt.actualModel ?? foldBlankToNull(event.actualModel),
+    actualReasoningEffort: receipt.actualReasoningEffort ?? foldBlankToNull(event.actualReasoningEffort),
+    modelFallbackReason: receipt.modelFallbackReason ?? event.modelFallbackReason ?? null,
+    reasoningEffortFallbackReason: receipt.reasoningEffortFallbackReason ?? event.reasoningEffortFallbackReason ?? null,
     hostEvidence: event.hostEvidence && receipt.hostEvidence ? Object.freeze({
       ...receipt.hostEvidence,
       ...event.hostEvidence
@@ -239,10 +408,21 @@ function consumeDelegation(receipt: DelegationReceipt, options: { now?: () => st
 
 export {
   activateDelegation,
+  abortPreparedDelegation,
   completeDelegationStage,
   consumeDelegation,
+  dispatchDelegation,
+  foldBlankToNull,
   managedDelegationRole,
   prepareDelegation,
   sealDelegation
 };
-export type { DelegationHostEvidence, DelegationReceipt, DelegationRole, DelegationStage, DelegationStatus, ReceiptResult };
+export type {
+  DelegationHostEvidence,
+  DelegationLifecycleProvenance,
+  DelegationReceipt,
+  DelegationRole,
+  DelegationStage,
+  DelegationStatus,
+  ReceiptResult
+};