@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/dist/lib/task/orchestration.js

@@ -6,16 +6,14 @@ import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { parseReviewSummary } from './review-artifacts.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
-import { resolveTaskRef } from './resolve-ref.js';
+import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.js';
 import { activateDelegation, abortActivatedDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, isDelegationReceipt, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
 import { normalizeAgentClients } from '../agent-clients/config.js';
-import { resolveAgentRuntimeStoreRoot } from '../runtime/agent-runtime.js';
-import { getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
+import { getAgentClientAdapter, getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
 import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots } from './workspace-snapshot.js';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
-import { hasActiveCodexLifecycleEvidence } from '../agent-clients/adapters/codex-lifecycle/store.js';
 import { extractReviewBaseline, extractReviewDiffBase, extractReviewTargetHead, extractReviewedHead } from './review-fingerprint.js';
 import { resolveDeliveryTarget, resolveDiffBase, resolveTargetHead } from './delivery-target.js';
 import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js';
@@ -29,7 +27,7 @@ function supportsLifecycleDelegation(client) {
         && getAgentClientDelegationEvidence(client).actualReasoningEffort !== 'unavailable';
 }
 function orchestrationPath(taskDir) {
-    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';
 class OrchestrationStateError extends Error {
@@ -79,7 +77,7 @@ function isModelPolicy(value) {
 }
 const RECOVERY_GUARD_KEYS = [
     'stepCount', 'nextStage', 'baselineEmpty', 'receiptCount', 'pendingDelegation',
-    'commitAuthorizationUnused', 'completionEvidenceAbsent'
+    'completionEvidenceAbsent'
 ];
 function isRecovery(value) {
     if (!hasExactKeys(value, [
@@ -92,14 +90,13 @@ function isRecovery(value) {
         && 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';
 }
@@ -119,17 +116,15 @@ export function isCompletionEvidence(value) {
 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'
 ];
-function orchestrationStateReasonCodes(value, expectedTaskId) {
+function orchestrationStateReasonCodes(value) {
     if (!hasExactKeys(value, ORCHESTRATION_RUN_KEYS))
         return ['top-level-keys'];
     const record = value;
     const reasons = [];
     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))
@@ -155,15 +150,6 @@ function orchestrationStateReasonCodes(value, expectedTaskId) {
         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))
@@ -173,7 +159,7 @@ function orchestrationStateReasonCodes(value, expectedTaskId) {
     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');
         }
     }
@@ -223,7 +209,7 @@ function fileObservation(file) {
     }
 }
 function parseOrchestrationRun(value, expectedTaskId) {
-    const reasonCodes = orchestrationStateReasonCodes(value, expectedTaskId);
+    const reasonCodes = orchestrationStateReasonCodes(value);
     if (reasonCodes.length > 0)
         throw new OrchestrationStateError(expectedTaskId ?? null, reasonCodes);
     return value;
@@ -268,7 +254,77 @@ function readRun(taskDir, options = {}) {
         throw new OrchestrationStateError(taskId, reasonCodes);
     }
 }
+function findDelegation(run, receiptId) {
+    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, receiptId, adapterId, options = {}) {
+    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, receiptId, adapterId, mutate, options = {}) {
+    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, receiptId, adapterId, mutate, options = {}) {
+    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, receiptId, adapterId, mutate, options, taskLockHeld) {
+    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);
+            const adapterEvidence = Object.freeze({
+                ...(found.receipt.adapterEvidence ?? {}),
+                [adapterId]: JSON.parse(serialized)
+            });
+            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);
+        }
+        catch (error) {
+            mutationError = error;
+            return null;
+        }
+    };
+    let mutationError;
+    const result = taskLockHeld
+        ? update()
+        : withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `agent-adapter.${adapterId}.evidence`, update);
+    if (mutationError)
+        throw mutationError;
+    return result;
+}
 function atomicWrite(file, value) {
+    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);
@@ -316,17 +372,16 @@ function resolveProjectPolicy(repoRoot, client) {
     const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     return normalizeAgentClients(raw).state[client].orchestration;
 }
-function canRecoverClaudeCodeUnsupportedPause(run, taskDir) {
+function canRecoverUnsupportedClientPause(run) {
     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;
 }
@@ -360,8 +415,7 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
             }
         }
         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()))();
@@ -370,14 +424,13 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
                 recoveredAt: now,
                 previousStatus: 'paused',
                 previousPause: existing.pause,
-                client: 'claude-code',
+                client: existing.modelPolicySource.client,
                 guards: {
                     stepCount: 0,
                     nextStage: null,
                     baselineEmpty: true,
                     receiptCount: 0,
                     pendingDelegation: false,
-                    commitAuthorizationUnused: true,
                     completionEvidenceAbsent: true
                 },
                 resultingStatus: 'running'
@@ -431,7 +484,6 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
         pendingDelegation: null,
         receipts: [],
         pause: null,
-        commitAuthorization: { issuedAt: null, consumedAt: null },
         completionEvidence: null,
         createdAt: now,
         updatedAt: now
@@ -657,6 +709,40 @@ function statusOrchestration(taskRef, options = {}) {
         return failed('ORCHESTRATION_RUN_MISSING', 'no orchestration run exists', resolved.taskId);
     return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
 }
+function validatePreparedModelPolicy(taskId, run, next, input) {
+    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, repoRoot, options) {
+    return (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+        gitRoot: gitRootFor(repoRoot, options),
+        stateRoot: repoRoot,
+        taskId
+    });
+}
+function validateDelegationRun(taskRef, taskId, run, options) {
+    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, input, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -673,47 +759,27 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
         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;
     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,
@@ -722,10 +788,9 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
         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
     });
@@ -737,7 +802,7 @@ function prepareOrchestrationDelegation(taskRef, input, options = {}) {
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
     try {
-        return withTaskExecutionLock(resolved.repoRoot, '__repository__', 'task-orchestration.prepare.repository', () => withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.prepare.task', () => prepareOrchestrationDelegationUnlocked(taskRef, input, options)));
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.prepare.task', () => prepareOrchestrationDelegationUnlocked(taskRef, input, options));
     }
     catch (error) {
         if (error instanceof TaskExecutionLockError)
@@ -770,7 +835,7 @@ function dispatchOrchestrationDelegation(taskRef, options = {}) {
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
     try {
-        return withTaskExecutionLock(resolved.repoRoot, '__repository__', 'task-orchestration.dispatch.repository', () => withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.dispatch.task', () => dispatchOrchestrationDelegationUnlocked(taskRef, options)));
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-orchestration.dispatch.task', () => dispatchOrchestrationDelegationUnlocked(taskRef, options));
     }
     catch (error) {
         if (error instanceof TaskExecutionLockError)
@@ -779,65 +844,40 @@ function dispatchOrchestrationDelegation(taskRef, options = {}) {
     }
 }
 function matchingDelegations(predicate, options) {
+    const taskId = 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;
-        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(client, predicate, options) {
-    const matches = matchingDelegations((receipt) => receipt.client === client && predicate(receipt), options);
+    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];
 }
 function hasActivatableOrchestrationDelegation(client, childId, options = {}) {
-    return matchingDelegations((receipt) => receipt.client === client && (receipt.status === 'prepared'
-        || (receipt.childId === childId && ['activated', 'stage-completed'].includes(receipt.status))), options).length > 0;
+    const lookup = matchingDelegations((receipt) => receipt.client === client && (receipt.status === 'prepared'
+        || (receipt.childId === childId && ['activated', 'stage-completed'].includes(receipt.status))), options);
+    return lookup.ok && lookup.matches.length > 0;
 }
 function hasSealableOrchestrationDelegation(client, childId, options = {}) {
-    return matchingDelegations((receipt) => receipt.client === client
+    const lookup = matchingDelegations((receipt) => receipt.client === client
         && receipt.childId === childId
-        && ['stage-completed', 'sealed'].includes(receipt.status), options).length > 0;
+        && ['stage-completed', 'sealed'].includes(receipt.status), options);
+    return lookup.ok && lookup.matches.length > 0;
 }
 function activateMatchingOrchestrationDelegation(client, event, options = {}) {
     const role = managedDelegationRole(event.nativeAgent);
@@ -857,7 +897,8 @@ function activateMatchingOrchestrationDelegation(client, event, options = {}) {
             && (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);
         }
@@ -874,7 +915,7 @@ function pauseMatchingOrchestrationDelegation(client, code, message, options = {
         return matched;
     return pauseOrchestration(matched.taskId, code, message, true, options);
 }
-function sealMatchingOrchestrationDelegation(client, event, options = {}) {
+function sealMatchingOrchestrationDelegation(client, event, options = {}, beforeSeal) {
     const role = managedDelegationRole(event.nativeAgent);
     if (!role)
         return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
@@ -904,66 +945,19 @@ function sealMatchingOrchestrationDelegation(client, event, options = {}) {
             actualReasoningEffort: event.actualReasoningEffort,
             modelFallbackReason: event.modelFallbackReason,
             reasoningEffortFallbackReason: event.reasoningEffortFallbackReason
-        }, options);
+        }, { runId: receipt.runId, receiptId: receipt.id }, options, beforeSeal);
     }
     catch (error) {
         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, 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, 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);
+    if (receipt.status !== 'sealed' || receipt.childId !== childId) {
+        return pauseOrchestration(matched.taskId, 'ORCHESTRATION_DELEGATION_RECONCILIATION_FAILED', 'native child did not produce one sealed delegation receipt', true, options);
     }
     return { status: matched.run.status, changed: false, taskId: matched.taskId, run: matched.run, next: null, error: null };
 }
@@ -977,9 +971,15 @@ function activateOrchestrationDelegation(taskRef, event, options = {}) {
     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')
@@ -1048,15 +1048,10 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
                 && wallNow <= Date.parse(receipt.activationDeadlineAt)) {
                 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) {
-                return failed('ORCHESTRATION_PREPARED_RECOVERY_ACTIVE_EVIDENCE', 'active Codex lifecycle evidence blocks prepared receipt recovery', resolved.taskId);
+            const activeAdapterEvidence = options.hasActiveLifecycleEvidence?.(receipt)
+                ?? Object.keys(receipt.adapterEvidence ?? {}).length > 0;
+            if (activeAdapterEvidence) {
+                return failed('ORCHESTRATION_PREPARED_RECOVERY_ACTIVE_EVIDENCE', 'active agent adapter evidence blocks prepared receipt recovery', resolved.taskId);
             }
             const current = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
                 gitRoot: gitRootFor(resolved.repoRoot, options),
@@ -1086,9 +1081,8 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
         return failed('ORCHESTRATION_PREPARED_RECOVERY_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
 }
-function recoveryReceiptMatches(receipt, taskId, event) {
-    return receipt.taskId === taskId
-        && receipt.stage === event.stage
+function recoveryReceiptMatches(receipt, event) {
+    return receipt.stage === event.stage
         && receipt.round === event.round
         && receipt.artifact === event.artifact
         && receipt.childId === event.childId
@@ -1108,7 +1102,7 @@ function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, option
     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) {
@@ -1125,9 +1119,7 @@ function recoverActivatedOrchestrationDelegationUnderLock(taskRef, event, option
     }
     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);
@@ -1207,19 +1199,34 @@ function planOrchestrationStageCompletion(taskRef, event, options = {}) {
 function commitOrchestrationStageCompletion(plan) {
     saveRun(plan.taskDir, plan.updatedRun);
 }
-function sealOrchestrationDelegation(taskRef, event, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+function sealOrchestrationDelegation(taskRef, event, expected, options = {}, beforeSeal) {
+    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, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
@@ -1255,5 +1262,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, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, recoverActivatedOrchestrationDelegationUnderLock, routeOrchestration, sealMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence, sealOrchestrationDelegation, statusOrchestration, };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, readDelegationAdapterEvidence, mutateDelegationAdapterEvidence, mutateDelegationAdapterEvidenceWithinTaskLock, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, recoverActivatedOrchestrationDelegationUnderLock, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration, };
 //# sourceMappingURL=orchestration.js.map