@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/lib/task/orchestration.ts

@@ -8,7 +8,7 @@ import { validateCurrentTaskContract } from './current-contract.ts';
 import { parseReviewSummary } from './review-artifacts.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.ts';
 import type { LedgerDocument } from './ledger.ts';
-import { resolveTaskRef } from './resolve-ref.ts';
+import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
 import {
   activateDelegation,
   abortActivatedDelegation,
@@ -23,14 +23,13 @@ import {
   sealDelegation
 } from './delegation-receipts.ts';
 import type {
-  DelegationLifecycleProvenance,
   DelegationReceipt,
   DelegationRole,
   DelegationStage
 } from './delegation-receipts.ts';
 import { normalizeAgentClients } from '../agent-clients/config.ts';
-import { resolveAgentRuntimeStoreRoot } from '../runtime/agent-runtime.ts';
 import {
+  getAgentClientAdapter,
   getAgentClientCapability,
   getAgentClientDelegationEvidence,
   getAgentClientModelSelection
@@ -50,8 +49,6 @@ import type { RepositorySnapshot } from './workspace-snapshot.ts';
 import type { WorkspaceSnapshotContext } from './workspace-snapshot.ts';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
-import { hasActiveCodexLifecycleEvidence } from '../agent-clients/adapters/codex-lifecycle/store.ts';
-import type { CodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
 import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.ts';
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.ts';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.ts';
@@ -66,24 +63,23 @@ type ModelPolicySource = Readonly<{
   client: AgentClientId;
   resolvedAt: string;
 }>;
-type ClaudeCodeCapabilityRecovery = Readonly<{
+type ClientCapabilityRecovery = Readonly<{
   code: 'CLIENT_CAPABILITY_ENABLED';
   recoveredAt: string;
   previousStatus: 'paused';
   previousPause: Readonly<{ code: 'ORCHESTRATION_CLIENT_UNSUPPORTED'; message: string; recoverable: boolean }>;
-  client: 'claude-code';
+  client: AgentClientId;
   guards: Readonly<{
     stepCount: 0;
     nextStage: null;
     baselineEmpty: true;
     receiptCount: 0;
     pendingDelegation: false;
-    commitAuthorizationUnused: true;
     completionEvidenceAbsent: true;
   }>;
   resultingStatus: 'running';
 }>;
-type OrchestrationRecovery = ClaudeCodeCapabilityRecovery;
+type OrchestrationRecovery = ClientCapabilityRecovery;
 type CleanCompletionEvidence = Readonly<{
   kind: 'reviewed-head-clean';
   observedAt: string;
@@ -108,7 +104,6 @@ type OrchestrationRun = Readonly<{
   pendingDelegation: DelegationReceipt | null;
   receipts: readonly DelegationReceipt[];
   pause: Readonly<{ code: string; message: string; recoverable: boolean }> | null;
-  commitAuthorization: Readonly<{ issuedAt: string | null; consumedAt: string | null }>;
   completionEvidence: CleanCompletionEvidence | null;
   createdAt: string;
   updatedAt: string;
@@ -128,6 +123,7 @@ type OrchestrationResult = Readonly<{
   taskId: string | null;
   run: OrchestrationRun | null;
   next: OrchestrationNext | null;
+  adapterContext?: string;
   warnings?: readonly Readonly<{ code: string; message: string; action: string }>[];
   error: Readonly<{
     code: string;
@@ -135,7 +131,7 @@ type OrchestrationResult = Readonly<{
     client?: AgentClientId;
     missingFields?: readonly string[];
     modelSelectionContext?: ReturnType<typeof getAgentClientModelSelection>;
-    detail?: CodexCapabilityProvenanceDetail;
+    detail?: unknown;
   }> | null;
 }>;
 type OrchestrationStageIdentity = Readonly<{
@@ -155,6 +151,7 @@ type OrchestrationCompletionPlanResult = Readonly<{
 }>;
 type OrchestrationOptions = {
   repoRoot?: string;
+  taskId?: string;
   gitWorktreeRoot?: string;
   diagnosticLog?: OrchestrationDiagnosticLogger;
   id?: () => string;
@@ -191,7 +188,7 @@ function supportsLifecycleDelegation(client: AgentClientId): boolean {
 }
 
 function orchestrationPath(taskDir: string): string {
-  return path.join(taskDir, 'orchestration.json');
+  return path.join(taskDir, '.runtime', 'orchestration.json');
 }
 
 const ORCHESTRATION_STATE_INVALID_MESSAGE = 'orchestration.json does not match the current runtime structure; the file was left unchanged; rebuild the sandbox or manually repair the state before retrying';
@@ -250,7 +247,7 @@ function isModelPolicy(value: unknown): value is OrchestrationModelPolicy {
 
 const RECOVERY_GUARD_KEYS = [
   'stepCount', 'nextStage', 'baselineEmpty', 'receiptCount', 'pendingDelegation',
-  'commitAuthorizationUnused', 'completionEvidenceAbsent'
+  'completionEvidenceAbsent'
 ] as const;
 
 function isRecovery(value: unknown): value is OrchestrationRecovery {
@@ -263,14 +260,13 @@ function isRecovery(value: unknown): value is OrchestrationRecovery {
     && value.previousStatus === 'paused'
     && isPause(value.previousPause)
     && value.previousPause.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
-    && value.client === 'claude-code'
+    && isAgentClientId(value.client)
     && hasExactKeys(guards, RECOVERY_GUARD_KEYS)
     && guards.stepCount === 0
     && guards.nextStage === null
     && guards.baselineEmpty === true
     && guards.receiptCount === 0
     && guards.pendingDelegation === false
-    && guards.commitAuthorizationUnused === true
     && guards.completionEvidenceAbsent === true
     && value.resultingStatus === 'running';
 }
@@ -292,15 +288,14 @@ export function isCompletionEvidence(value: unknown): value is CleanCompletionEv
 const ORCHESTRATION_RUN_KEYS = [
   'taskId', 'runId', 'status', 'nextStage', 'stepCount', 'maxSteps', 'modelPolicy',
   'modelPolicySource', 'recoveryHistory', 'baseline', 'pendingDelegation', 'receipts',
-  'pause', 'commitAuthorization', 'completionEvidence', 'createdAt', 'updatedAt'
+  'pause', 'completionEvidence', 'createdAt', 'updatedAt'
 ] as const;
 
-function orchestrationStateReasonCodes(value: unknown, expectedTaskId?: string): string[] {
+function orchestrationStateReasonCodes(value: unknown): string[] {
   if (!hasExactKeys(value, ORCHESTRATION_RUN_KEYS)) return ['top-level-keys'];
   const record = value;
   const reasons: string[] = [];
   if (!exactText(record.taskId)) reasons.push('taskId');
-  else if (expectedTaskId !== undefined && record.taskId !== expectedTaskId) reasons.push('taskId-mismatch');
   if (!exactText(record.runId)) reasons.push('runId');
   if (!['running', 'paused', 'completed'].includes(record.status as string)) reasons.push('status');
   if (!(record.nextStage === null || ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code', 'commit'].includes(record.nextStage as string))) {
@@ -315,19 +310,13 @@ function orchestrationStateReasonCodes(value: unknown, expectedTaskId?: string):
   if (!(record.pendingDelegation === null || isDelegationReceipt(record.pendingDelegation))) reasons.push('pendingDelegation');
   if (!Array.isArray(record.receipts) || !record.receipts.every(isDelegationReceipt)) reasons.push('receipts');
   if (!(record.pause === null || isPause(record.pause))) reasons.push('pause');
-  if (!hasExactKeys(record.commitAuthorization, ['issuedAt', 'consumedAt'])) {
-    reasons.push('commitAuthorization');
-  } else {
-    if (!nullableText(record.commitAuthorization.issuedAt)) reasons.push('commitAuthorization.issuedAt');
-    if (!nullableText(record.commitAuthorization.consumedAt)) reasons.push('commitAuthorization.consumedAt');
-  }
   if (!(record.completionEvidence === null || isCompletionEvidence(record.completionEvidence))) reasons.push('completionEvidence');
   if (!exactText(record.createdAt)) reasons.push('createdAt');
   if (!exactText(record.updatedAt)) reasons.push('updatedAt');
   if (Array.isArray(record.receipts) && record.receipts.every(isDelegationReceipt)
     && (record.pendingDelegation === null || isDelegationReceipt(record.pendingDelegation))) {
     const receipts = [...record.receipts, ...(record.pendingDelegation ? [record.pendingDelegation] : [])];
-    if (receipts.some((receipt) => receipt.taskId !== record.taskId || receipt.runId !== record.runId)) {
+    if (receipts.some((receipt) => receipt.runId !== record.runId)) {
       reasons.push('receipt-identity');
     }
   }
@@ -375,7 +364,7 @@ function fileObservation(file: string): OrchestrationDiagnosticFields {
 }
 
 function parseOrchestrationRun(value: unknown, expectedTaskId?: string): OrchestrationRun {
-  const reasonCodes = orchestrationStateReasonCodes(value, expectedTaskId);
+  const reasonCodes = orchestrationStateReasonCodes(value);
   if (reasonCodes.length > 0) throw new OrchestrationStateError(expectedTaskId ?? null, reasonCodes);
   return value as OrchestrationRun;
 }
@@ -420,7 +409,100 @@ function readRun(taskDir: string, options: Pick<OrchestrationOptions, 'diagnosti
   }
 }
 
+function findDelegation(run: OrchestrationRun, receiptId: string): Readonly<{
+  receipt: DelegationReceipt;
+  location: 'pending' | 'history';
+}> | null {
+  if (run.pendingDelegation?.id === receiptId) return { receipt: run.pendingDelegation, location: 'pending' };
+  const receipt = run.receipts.find((entry) => entry.id === receiptId);
+  return receipt ? { receipt, location: 'history' } : null;
+}
+
+function readDelegationAdapterEvidence(
+  taskRef: string,
+  receiptId: string,
+  adapterId: AgentClientId,
+  options: OrchestrationOptions = {}
+): unknown {
+  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
+  const run = readRun(resolved.taskDir, options);
+  const found = run && findDelegation(run, receiptId);
+  if (!found || found.receipt.client !== adapterId) return null;
+  return found.receipt.adapterEvidence?.[adapterId] ?? null;
+}
+
+function mutateDelegationAdapterEvidence(
+  taskRef: string,
+  receiptId: string,
+  adapterId: AgentClientId,
+  mutate: (current: unknown) => unknown,
+  options: OrchestrationOptions = {}
+): unknown {
+  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
+  return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, false);
+}
+
+function mutateDelegationAdapterEvidenceWithinTaskLock(
+  taskRef: string,
+  receiptId: string,
+  adapterId: AgentClientId,
+  mutate: (current: unknown) => unknown,
+  options: OrchestrationOptions = {}
+): unknown {
+  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
+  return mutateDelegationAdapterEvidenceAtResolved(resolved, receiptId, adapterId, mutate, options, true);
+}
+
+function mutateDelegationAdapterEvidenceAtResolved(
+  resolved: Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>,
+  receiptId: string,
+  adapterId: AgentClientId,
+  mutate: (current: unknown) => unknown,
+  options: OrchestrationOptions,
+  taskLockHeld: boolean
+): unknown {
+  const update = () => {
+    try {
+      const run = readRun(resolved.taskDir, options);
+      const found = run && findDelegation(run, receiptId);
+      if (!run || !found || found.receipt.client !== adapterId) {
+        throw new Error('ORCHESTRATION_DELEGATION_MISSING: adapter evidence has no matching task receipt');
+      }
+      const current = found.receipt.adapterEvidence?.[adapterId] ?? null;
+      const nextState = mutate(current);
+      const serialized = JSON.stringify(nextState);
+      if (serialized === undefined) throw new Error('Agent adapter evidence must be JSON serializable');
+      if (serialized === JSON.stringify(current)) return JSON.parse(serialized) as unknown;
+      const adapterEvidence = Object.freeze({
+        ...(found.receipt.adapterEvidence ?? {}),
+        [adapterId]: JSON.parse(serialized) as unknown
+      });
+      const nextReceipt = Object.freeze({ ...found.receipt, adapterEvidence });
+      const updated = found.location === 'pending'
+        ? withUpdatedRun(run, { pendingDelegation: nextReceipt }, options.now)
+        : withUpdatedRun(run, {
+            receipts: Object.freeze(run.receipts.map((receipt) => receipt.id === receiptId ? nextReceipt : receipt))
+          }, options.now);
+      saveRun(resolved.taskDir, updated);
+      return JSON.parse(serialized) as unknown;
+    } catch (error) {
+      mutationError = error;
+      return null;
+    }
+  };
+  let mutationError: unknown;
+  const result = taskLockHeld
+    ? update()
+    : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `agent-adapter.${adapterId}.evidence`, update);
+  if (mutationError) throw mutationError;
+  return result;
+}
+
 function atomicWrite(file: string, value: unknown): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
   const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
   fs.writeFileSync(temp, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', flag: 'wx' });
   fs.renameSync(temp, file);
@@ -483,17 +565,16 @@ function resolveProjectPolicy(repoRoot: string, client: AgentClientId): Orchestr
   return normalizeAgentClients(raw).state[client].orchestration;
 }
 
-function canRecoverClaudeCodeUnsupportedPause(run: OrchestrationRun, taskDir: string): boolean {
+function canRecoverUnsupportedClientPause(run: OrchestrationRun): boolean {
   return run.status === 'paused'
     && run.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
-    && run.modelPolicySource?.client === 'claude-code'
+    && isAgentClientId(run.modelPolicySource?.client)
+    && supportsLifecycleDelegation(run.modelPolicySource.client)
     && 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
     && run.recoveryHistory.length === 0;
 }
@@ -525,24 +606,22 @@ function beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptio
       }
     }
     if (existing.status === 'paused' && existing.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED') {
-      if (existing.modelPolicySource.client !== 'claude-code'
-        || !canRecoverClaudeCodeUnsupportedPause(existing, resolved.taskDir)) {
+      if (!canRecoverUnsupportedClientPause(existing)) {
         return { status: 'paused', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
       }
       const now = (options.now ?? (() => new Date().toISOString()))();
-      const recovery: ClaudeCodeCapabilityRecovery = {
+      const recovery: ClientCapabilityRecovery = {
         code: 'CLIENT_CAPABILITY_ENABLED',
         recoveredAt: now,
         previousStatus: 'paused',
-        previousPause: existing.pause as ClaudeCodeCapabilityRecovery['previousPause'],
-        client: 'claude-code',
+        previousPause: existing.pause as ClientCapabilityRecovery['previousPause'],
+        client: existing.modelPolicySource.client,
         guards: {
           stepCount: 0,
           nextStage: null,
           baselineEmpty: true,
           receiptCount: 0,
           pendingDelegation: false,
-          commitAuthorizationUnused: true,
           completionEvidenceAbsent: true
         },
         resultingStatus: 'running'
@@ -595,7 +674,6 @@ function beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptio
     pendingDelegation: null,
     receipts: [],
     pause: null,
-    commitAuthorization: { issuedAt: null, consumedAt: null },
     completionEvidence: null,
     createdAt: now,
     updatedAt: now
@@ -828,13 +906,58 @@ function statusOrchestration(taskRef: string, options: OrchestrationOptions = {}
   return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
 }
 
+function validatePreparedModelPolicy(
+  taskId: string,
+  run: OrchestrationRun,
+  next: NonNullable<OrchestrationResult['next']>,
+  input: Readonly<{ requestedModel?: string; requestedReasoningEffort?: string }>
+): OrchestrationResult | null {
+  if (!validModel(input.requestedModel)) {
+    return failed('ORCHESTRATION_REQUESTED_MODEL_REQUIRED', 'prepare requires the exact requested model identity', taskId);
+  }
+  if (!validModel(input.requestedReasoningEffort)) {
+    return failed('ORCHESTRATION_REQUESTED_REASONING_EFFORT_REQUIRED', 'prepare requires the exact requested reasoning effort', taskId);
+  }
+  const expectedPolicy = run.modelPolicy[next.role];
+  if (input.requestedModel !== expectedPolicy.model) {
+    return failed('ORCHESTRATION_REQUESTED_MODEL_MISMATCH', `requested model does not match the persisted ${next.role} model`, taskId);
+  }
+  if (input.requestedReasoningEffort !== expectedPolicy.reasoningEffort) {
+    return failed('ORCHESTRATION_REQUESTED_REASONING_EFFORT_MISMATCH', `requested reasoning effort does not match the persisted ${next.role} policy`, taskId);
+  }
+  return null;
+}
+
+function captureTaskSnapshot(taskId: string, repoRoot: string, options: OrchestrationOptions): string {
+  return (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+    gitRoot: gitRootFor(repoRoot, options),
+    stateRoot: repoRoot,
+    taskId
+  });
+}
+
+function validateDelegationRun(
+  taskRef: string,
+  taskId: string,
+  run: OrchestrationRun | null,
+  options: OrchestrationOptions
+): OrchestrationResult | null {
+  if (!run || run.status !== 'running') {
+    return failed('ORCHESTRATION_RUN_NOT_RUNNING', 'a running orchestration is required', taskId);
+  }
+  if (run.pendingDelegation) return failed('ORCHESTRATION_DELEGATION_BUSY', 'the run already has a pending delegation', taskId);
+  if (run.stepCount >= run.maxSteps) {
+    return pauseOrchestration(taskRef, 'ORCHESTRATION_MAX_STEPS', 'maximum orchestration steps reached', true, options);
+  }
+  return null;
+}
+
 function prepareOrchestrationDelegationUnlocked(
   taskRef: string,
   input: Readonly<{
     client: AgentClientId;
     requestedModel?: string;
     requestedReasoningEffort?: string;
-    lifecycleProvenance?: DelegationLifecycleProvenance;
   }>,
   options: OrchestrationOptions = {}
 ): OrchestrationResult {
@@ -852,54 +975,34 @@ function prepareOrchestrationDelegationUnlocked(
     requestedReasoningEffort: input.requestedReasoningEffort ?? null
   });
   const run = readRun(resolved.taskDir, options);
-  if (!run || run.status !== 'running') return failed('ORCHESTRATION_RUN_NOT_RUNNING', 'a running orchestration is required', resolved.taskId);
-  if (run.pendingDelegation) return failed('ORCHESTRATION_DELEGATION_BUSY', 'the run already has a pending delegation', resolved.taskId);
-  const repositoryPending = matchingDelegations(() => true, options);
-  if (repositoryPending.length > 0) {
-    return failed('ORCHESTRATION_DELEGATION_BUSY', 'the repository already has a pending lifecycle delegation', resolved.taskId);
-  }
-  if (run.stepCount >= run.maxSteps) return pauseOrchestration(taskRef, 'ORCHESTRATION_MAX_STEPS', 'maximum orchestration steps reached', true, options);
+  const runFailure = validateDelegationRun(taskRef, resolved.taskId, run, options);
+  if (runFailure) return runFailure;
+  const activeRun = run!;
   const routed = routeOrchestration(taskRef, options);
   if (!routed.next) return routed;
   const next = routed.next;
-  if (!validModel(input.requestedModel)) {
-    return failed('ORCHESTRATION_REQUESTED_MODEL_REQUIRED', 'prepare requires the exact requested model identity', resolved.taskId);
-  }
-  if (!validModel(input.requestedReasoningEffort)) {
-    return failed('ORCHESTRATION_REQUESTED_REASONING_EFFORT_REQUIRED', 'prepare requires the exact requested reasoning effort', resolved.taskId);
-  }
-  const expectedPolicy = run.modelPolicy[next.role];
-  if (input.requestedModel !== expectedPolicy.model) {
-    return failed('ORCHESTRATION_REQUESTED_MODEL_MISMATCH', `requested model does not match the persisted ${next.role} model`, resolved.taskId);
-  }
-  if (input.requestedReasoningEffort !== expectedPolicy.reasoningEffort) {
-    return failed('ORCHESTRATION_REQUESTED_REASONING_EFFORT_MISMATCH', `requested reasoning effort does not match the persisted ${next.role} policy`, resolved.taskId);
-  }
+  const policyFailure = validatePreparedModelPolicy(resolved.taskId, activeRun, next, input);
+  if (policyFailure) return policyFailure;
   let beforeFingerprint: string;
   try {
-    beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
-      gitRoot: gitRootFor(resolved.repoRoot, options),
-      stateRoot: resolved.repoRoot,
-      taskId: resolved.taskId
-    });
+    beforeFingerprint = captureTaskSnapshot(resolved.taskId, resolved.repoRoot, options);
   } catch (error) {
     return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
   }
   const receipt = prepareDelegation({
     taskId: resolved.taskId,
-    runId: run.runId,
+    runId: activeRun.runId,
     role: next.role,
     stage: next.stage,
     round: next.round,
     artifact: next.artifact,
     client: input.client,
-    requestedModel: input.requestedModel,
-    requestedReasoningEffort: input.requestedReasoningEffort,
+    requestedModel: input.requestedModel!,
+    requestedReasoningEffort: input.requestedReasoningEffort!,
     workspaceSnapshotScope: 'task',
-    lifecycleProvenance: input.lifecycleProvenance ?? null,
     beforeFingerprint
   }, { id: options.id, now: options.now, monotonicNow: options.monotonicNow });
-  const updated = withUpdatedRun(run, {
+  const updated = withUpdatedRun(activeRun, {
     nextStage: next.stage,
     pendingDelegation: receipt
   });
@@ -913,7 +1016,6 @@ function prepareOrchestrationDelegation(
     client: AgentClientId;
     requestedModel?: string;
     requestedReasoningEffort?: string;
-    lifecycleProvenance?: DelegationLifecycleProvenance;
   }>,
   options: OrchestrationOptions = {}
 ): OrchestrationResult {
@@ -922,14 +1024,9 @@ function prepareOrchestrationDelegation(
   try {
     return withTaskExecutionLock(
       resolved.repoRoot,
-      '__repository__',
-      'task-orchestration.prepare.repository',
-      () => withTaskExecutionLock(
-        resolved.repoRoot,
-        resolved.taskId,
-        'task-orchestration.prepare.task',
-        () => prepareOrchestrationDelegationUnlocked(taskRef, input, options)
-      )
+      resolved.taskId,
+      'task-orchestration.prepare.task',
+      () => prepareOrchestrationDelegationUnlocked(taskRef, input, options)
     );
   } catch (error) {
     if (error instanceof TaskExecutionLockError) return failed(error.code, error.message, resolved.taskId);
@@ -967,14 +1064,9 @@ function dispatchOrchestrationDelegation(
   try {
     return withTaskExecutionLock(
       resolved.repoRoot,
-      '__repository__',
-      'task-orchestration.dispatch.repository',
-      () => withTaskExecutionLock(
-        resolved.repoRoot,
-        resolved.taskId,
-        'task-orchestration.dispatch.task',
-        () => dispatchOrchestrationDelegationUnlocked(taskRef, options)
-      )
+      resolved.taskId,
+      'task-orchestration.dispatch.task',
+      () => dispatchOrchestrationDelegationUnlocked(taskRef, options)
     );
   } catch (error) {
     if (error instanceof TaskExecutionLockError) return failed(error.code, error.message, resolved.taskId);
@@ -982,49 +1074,28 @@ function dispatchOrchestrationDelegation(
   }
 }
 
+type MatchingDelegationsResult =
+  | Readonly<{ ok: true; matches: readonly { taskId: string; run: OrchestrationRun }[] }>
+  | Readonly<{ ok: false; error: OrchestrationResult }>;
+
 function matchingDelegations(
   predicate: (receipt: DelegationReceipt) => boolean,
   options: OrchestrationOptions
-): Array<{ taskId: string; run: OrchestrationRun }> {
+): MatchingDelegationsResult {
+  const taskId: unknown = options.taskId;
+  if (taskId === undefined || taskId === '') {
+    return { ok: false, error: failed('ORCHESTRATION_TASK_ID_REQUIRED', 'taskId is required for lifecycle matching') };
+  }
+  if (typeof taskId !== 'string' || !TASK_ID_RE.test(taskId)) {
+    return { ok: false, error: failed('ORCHESTRATION_TASK_ID_INVALID', 'taskId must be a canonical TASK-id') };
+  }
   const repoRoot = options.repoRoot ?? process.cwd();
-  const activeRoot = path.join(repoRoot, '.agents', 'workspace', 'active');
-  if (!fs.existsSync(activeRoot)) return [];
-  emitDiagnostic(options, 'orchestration-active-scan-start', {
-    activeRoot
-  });
-  const matches = fs.readdirSync(activeRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .flatMap((entry) => {
-      const candidateTaskId = entry.name;
-      const candidateTaskDir = path.join(activeRoot, candidateTaskId);
-      emitDiagnostic(options, 'orchestration-active-scan-candidate', {
-        candidateTaskId,
-        candidateTaskDir,
-        orchestrationPath: orchestrationPath(candidateTaskDir)
-      });
-      let run: OrchestrationRun | null;
-      try {
-        run = readRun(candidateTaskDir, options);
-      } catch (error) {
-        emitDiagnostic(options, 'orchestration-active-scan-candidate-failed', {
-          candidateTaskId,
-          candidateTaskDir,
-          errorType: error instanceof Error ? error.name : typeof error,
-          reasonCodes: error instanceof OrchestrationStateError ? error.reasonCodes.join(',') : null
-        });
-        throw error;
-      }
-      if (!run || run.status !== 'running' || !run.pendingDelegation) return [];
-      const receipt = run.pendingDelegation;
-      return predicate(receipt)
-        ? [{ taskId: candidateTaskId, run }]
-        : [];
-    });
-  emitDiagnostic(options, 'orchestration-active-scan-finished', {
-    activeRoot,
-    matchingDelegations: matches.length
-  });
-  return matches;
+  const taskDir = path.join(repoRoot, '.agents', 'workspace', 'active', taskId);
+  const run = readRun(taskDir, options);
+  const matches = run && run.status === 'running' && run.pendingDelegation && predicate(run.pendingDelegation)
+    ? [{ taskId, run }]
+    : [];
+  return { ok: true, matches };
 }
 
 function uniqueMatchingDelegation(
@@ -1032,12 +1103,13 @@ function uniqueMatchingDelegation(
   predicate: (receipt: DelegationReceipt) => boolean,
   options: OrchestrationOptions
 ): { taskId: string; run: OrchestrationRun } | OrchestrationResult {
-  const matches = matchingDelegations(
+  const lookup = matchingDelegations(
     (receipt) => receipt.client === client && predicate(receipt),
     options
   );
+  if (!lookup.ok) return lookup.error;
+  const matches = lookup.matches;
   if (matches.length === 0) return failed('ORCHESTRATION_DELEGATION_MISSING', 'no matching lifecycle delegation exists');
-  if (matches.length > 1) return failed('ORCHESTRATION_DELEGATION_AMBIGUOUS', 'multiple lifecycle delegations match the native hook event');
   return matches[0]!;
 }
 
@@ -1046,13 +1118,14 @@ function hasActivatableOrchestrationDelegation(
   childId: string,
   options: OrchestrationOptions = {}
 ): boolean {
-  return matchingDelegations(
+  const lookup = matchingDelegations(
     (receipt) => receipt.client === client && (
       receipt.status === 'prepared'
       || (receipt.childId === childId && ['activated', 'stage-completed'].includes(receipt.status))
     ),
     options
-  ).length > 0;
+  );
+  return lookup.ok && lookup.matches.length > 0;
 }
 
 function hasSealableOrchestrationDelegation(
@@ -1060,12 +1133,13 @@ function hasSealableOrchestrationDelegation(
   childId: string,
   options: OrchestrationOptions = {}
 ): boolean {
-  return matchingDelegations(
+  const lookup = matchingDelegations(
     (receipt) => receipt.client === client
       && receipt.childId === childId
       && ['stage-completed', 'sealed'].includes(receipt.status),
     options
-  ).length > 0;
+  );
+  return lookup.ok && lookup.matches.length > 0;
 }
 
 function activateMatchingOrchestrationDelegation(
@@ -1095,7 +1169,8 @@ function activateMatchingOrchestrationDelegation(
       && (receipt.actualReasoningEffort ?? null) === foldBlankToNull(event.actualReasoningEffort)
       && receipt.modelFallbackReason === (event.modelFallbackReason ?? null)
       && receipt.reasoningEffortFallbackReason === (event.reasoningEffortFallbackReason ?? null)
-      && receipt.hostEvidence?.hookDefinitionHash === event.hostEvidence?.hookDefinitionHash;
+      && (event.clientEvidence === undefined
+        || JSON.stringify(receipt.adapterEvidence?.[client]) === JSON.stringify(event.clientEvidence));
     if (!sameEvidence) {
       return pauseOrchestration(replay.taskId, 'DELEGATION_REPLAY_CONFLICT', 'replayed native start evidence conflicts with the active receipt', true, options);
     }
@@ -1128,7 +1203,8 @@ function sealMatchingOrchestrationDelegation(
     modelFallbackReason?: string;
     reasoningEffortFallbackReason?: string;
   }>,
-  options: OrchestrationOptions = {}
+  options: OrchestrationOptions = {},
+  beforeSeal?: () => OrchestrationResult | null
 ): OrchestrationResult {
   const role = managedDelegationRole(event.nativeAgent);
   if (!role) return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
@@ -1161,7 +1237,7 @@ function sealMatchingOrchestrationDelegation(
       actualReasoningEffort: event.actualReasoningEffort,
       modelFallbackReason: event.modelFallbackReason,
       reasoningEffortFallbackReason: event.reasoningEffortFallbackReason
-    }, options);
+    }, { runId: receipt.runId, receiptId: receipt.id }, options, beforeSeal);
   } catch (error) {
     return pauseOrchestration(
       matched.taskId,
@@ -1173,68 +1249,6 @@ function sealMatchingOrchestrationDelegation(
   }
 }
 
-function sealMatchingOrchestrationDelegationWithHostEvidence(
-  client: AgentClientId,
-  event: Readonly<{ nativeAgent: string; childId: string }>,
-  consumeEvidence: (receipt: DelegationReceipt) => Readonly<{
-    stopRevision: number;
-    consumer: string;
-    consumedAt: string;
-  }>,
-  options: OrchestrationOptions = {}
-): OrchestrationResult {
-  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, requireHostEvidence: false });
-    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: AgentClientId,
   childId: string,
@@ -1247,15 +1261,11 @@ function reconcileMatchingOrchestrationDelegation(
   );
   if ('status' in matched) return matched;
   const receipt = matched.run.pendingDelegation!;
-  if (
-    receipt.status !== 'sealed'
-    || receipt.hostEvidence?.consumer !== receipt.id
-    || receipt.hostEvidence.consumedAt === null
-  ) {
+  if (receipt.status !== 'sealed' || receipt.childId !== childId) {
     return pauseOrchestration(
       matched.taskId,
-      'ORCHESTRATION_CODEX_RECONCILIATION_FAILED',
-      'Codex native spawn did not produce one sealed receipt with consumed host evidence',
+      'ORCHESTRATION_DELEGATION_RECONCILIATION_FAILED',
+      'native child did not produce one sealed delegation receipt',
       true,
       options
     );
@@ -1275,9 +1285,21 @@ function activateOrchestrationDelegation(
   if (run.status !== 'running') {
     return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
   }
+  const validateAdapterEvidence = getAgentClientAdapter(run.pendingDelegation.client)
+    .orchestrationAdapter?.validateActivationEvidence;
+  if (validateAdapterEvidence && !validateAdapterEvidence(event.clientEvidence, event.parentId)) {
+    return pauseOrchestration(
+      taskRef,
+      'DELEGATION_ADAPTER_EVIDENCE_REQUIRED',
+      'native activation lacks valid evidence from the agent adapter',
+      true,
+      options
+    );
+  }
   const result = activateDelegation(run.pendingDelegation, event, {
     now: options.now,
-    monotonicNow: options.monotonicNow
+    monotonicNow: options.monotonicNow,
+    evidencePolicy: getAgentClientDelegationEvidence(run.pendingDelegation.client)
   });
   if (!result.ok) {
     if (result.code === 'DELEGATION_IGNORED') return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
@@ -1380,22 +1402,12 @@ function recoverPreparedOrchestrationDelegation(
       ) {
         return failed('ORCHESTRATION_PREPARED_RECOVERY_EARLY', 'prepared receipt activation deadline has not elapsed', resolved.taskId);
       }
-      const activeLifecycleEvidence = options.hasActiveLifecycleEvidence?.(receipt)
-        ?? (
-          receipt.client === 'codex'
-          && receipt.lifecycleProvenance
-          && hasActiveCodexLifecycleEvidence(
-          resolveAgentRuntimeStoreRoot({ repoRoot: resolved.repoRoot, store: 'lifecycle' }),
-            {
-              nativeAgent: `agent-infra-lifecycle-${receipt.role}`,
-              hookDefinitionHash: receipt.lifecycleProvenance.hookDefinitionHash
-            }
-          )
-        );
-      if (activeLifecycleEvidence) {
+      const activeAdapterEvidence = options.hasActiveLifecycleEvidence?.(receipt)
+        ?? Object.keys(receipt.adapterEvidence ?? {}).length > 0;
+      if (activeAdapterEvidence) {
         return failed(
           'ORCHESTRATION_PREPARED_RECOVERY_ACTIVE_EVIDENCE',
-          'active Codex lifecycle evidence blocks prepared receipt recovery',
+          'active agent adapter evidence blocks prepared receipt recovery',
           resolved.taskId
         );
       }
@@ -1436,18 +1448,14 @@ type ActivatedRecoveryEvent = Readonly<{
   artifact: string;
   startedAgent: string;
   childId: string;
-  stopRevision: number;
-  consumer: string;
-  consumedAt: string;
+  clientEvidence?: unknown;
 }>;
 
 function recoveryReceiptMatches(
   receipt: DelegationReceipt,
-  taskId: string,
   event: ActivatedRecoveryEvent
 ): boolean {
-  return receipt.taskId === taskId
-    && receipt.stage === event.stage
+  return receipt.stage === event.stage
     && receipt.round === event.round
     && receipt.artifact === event.artifact
     && receipt.childId === event.childId
@@ -1469,7 +1477,7 @@ function recoverActivatedOrchestrationDelegationUnderLock(
   ];
   const receipt = matches.find((candidate) => candidate.id === event.receiptId);
   if (!receipt) return failed('ORCHESTRATION_DELEGATION_MISSING', 'recovery receipt does not exist', resolved.taskId);
-  if (!recoveryReceiptMatches(receipt, resolved.taskId, event)) {
+  if (!recoveryReceiptMatches(receipt, event)) {
     return failed('ORCHESTRATION_PROVENANCE_MISMATCH', 'recovery selector does not match the delegation receipt', resolved.taskId);
   }
   if (receipt.status === 'aborted' && run.pendingDelegation === null) {
@@ -1486,9 +1494,7 @@ function recoverActivatedOrchestrationDelegationUnderLock(
   }
   const aborted = abortActivatedDelegation(receipt, {
     childId: event.childId,
-    stopRevision: event.stopRevision,
-    consumer: event.consumer,
-    consumedAt: event.consumedAt
+    clientEvidence: event.clientEvidence
   });
   if (!aborted.ok) return failed(aborted.code, aborted.message, resolved.taskId);
   const updated = withUpdatedRun(run, {
@@ -1585,17 +1591,32 @@ function commitOrchestrationStageCompletion(plan: OrchestrationStageCompletion):
 function sealOrchestrationDelegation(
   taskRef: string,
   event: Parameters<typeof sealDelegation>[1],
-  options: OrchestrationOptions = {}
+  expected?: Readonly<{ runId: string; receiptId: string }>,
+  options: OrchestrationOptions = {},
+  beforeSeal?: () => OrchestrationResult | null
 ): OrchestrationResult {
-  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+  const orchestrationOptions = options;
+  const resolved = resolveTaskRef(taskRef, { repoRoot: orchestrationOptions.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
-  const run = readRun(resolved.taskDir, options);
-  if (!run?.pendingDelegation) return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
-  const result = sealDelegation(run.pendingDelegation, event, { now: options.now });
-  if (!result.ok) return pauseOrchestration(taskRef, result.code, result.message, true, options);
-  const updated = withUpdatedRun(run, { pendingDelegation: result.receipt });
-  saveRun(resolved.taskDir, updated);
-  return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+  return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.seal', () => {
+    const run = readRun(resolved.taskDir, orchestrationOptions);
+    if (!run?.pendingDelegation) return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
+    if (expected && (run.runId !== expected.runId || run.pendingDelegation.id !== expected.receiptId)) {
+      return failed('ORCHESTRATION_DELEGATION_CHANGED', 'pending delegation changed while collecting completion evidence', resolved.taskId);
+    }
+    const preSealFailure = beforeSeal?.();
+    if (preSealFailure) return preSealFailure;
+    const current = beforeSeal ? readRun(resolved.taskDir, orchestrationOptions) : run;
+    if (!current?.pendingDelegation) return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
+    if (expected && (current.runId !== expected.runId || current.pendingDelegation.id !== expected.receiptId)) {
+      return failed('ORCHESTRATION_DELEGATION_CHANGED', 'pending delegation changed before it was sealed', resolved.taskId);
+    }
+    const result = sealDelegation(current.pendingDelegation, event, { now: orchestrationOptions.now });
+    if (!result.ok) return pauseOrchestration(taskRef, result.code, result.message, true, orchestrationOptions);
+    const updated = withUpdatedRun(current, { pendingDelegation: result.receipt });
+    saveRun(resolved.taskDir, updated);
+    return { status: 'running', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
+  });
 }
 
 function advanceOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
@@ -1649,6 +1670,9 @@ export {
   hasSealableOrchestrationDelegation,
   OrchestrationStateError,
   orchestrationPath,
+  readDelegationAdapterEvidence,
+  mutateDelegationAdapterEvidence,
+  mutateDelegationAdapterEvidenceWithinTaskLock,
   pauseMatchingOrchestrationDelegation,
   pauseOrchestration,
   planOrchestrationStageCompletion,
@@ -1659,7 +1683,6 @@ export {
   recoverActivatedOrchestrationDelegationUnderLock,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
-  sealMatchingOrchestrationDelegationWithHostEvidence,
   sealOrchestrationDelegation,
   statusOrchestration,
 };