@fitlab-ai/agent-infra 0.9.4 → 0.9.6

package/dist/lib/task/orchestration.js

@@ -13,10 +13,12 @@ import { inspectPlatformPullRequest } from '../platform/pull-requests.js';
 import { 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 { CommitIntentError, commitIntentPath, createCommitIntent, digest, readCommitIntent, removeCommitIntent, removeCommitIntentByDigest, serialize, updateCommitIntent } from './commit-intent.js';
 import { inspectCommitFinalization, planCommitTaskFinalization } from './commit-finalization.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { appendActivityEntry, commitAttemptStartedNote, locateActivityLog, pairEntries } from './activity-log.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -71,6 +73,11 @@ function repositoryHead(repoRoot) {
         stdio: ['ignore', 'pipe', 'pipe']
     }).trim();
 }
+function gitRootFor(stateRoot, options) {
+    if (!options.gitWorktreeRoot)
+        return stateRoot;
+    return assertGitRepositoryBinding(stateRoot, options.gitWorktreeRoot).worktreeRoot;
+}
 function isAncestor(repoRoot, ancestor, descendant) {
     return spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
         cwd: repoRoot,
@@ -97,7 +104,8 @@ function commitFinalizationView(inspection) {
         currentHead: inspection.currentHead,
         committedHead: inspection.committedHead,
         needsAnchor: inspection.needsAnchor,
-        needsLog: inspection.needsLog
+        needsLog: inspection.needsLog,
+        attempt: inspection.attempt
     };
 }
 function validCommitRun(run, taskId) {
@@ -151,6 +159,22 @@ function resolveProjectPolicy(repoRoot, client) {
     const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     return normalizeAgentClients(raw).state[client].orchestration;
 }
+function canRecoverCodexUnsupportedPause(run, taskDir) {
+    return run.schemaVersion === 2
+        && run.status === 'paused'
+        && run.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
+        && run.modelPolicySource?.client === 'codex'
+        && run.stepCount === 0
+        && run.nextStage === null
+        && run.baseline === ''
+        && run.pendingDelegation === null
+        && run.receipts.length === 0
+        && run.commitAuthorization?.issuedAt === null
+        && run.commitAuthorization?.consumedAt === null
+        && run.completionEvidence == null
+        && !fs.existsSync(commitIntentPath(taskDir))
+        && (run.recoveryHistory ?? []).every((entry) => entry.code === 'MODEL_POLICY_SUPPLEMENTED');
+}
 function beginOrResumeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -196,6 +220,39 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
                     return failed('ORCHESTRATION_MODEL_POLICY_MISMATCH', 'provided model policy does not match the persisted run policy', resolved.taskId);
                 }
             }
+            if (existing.status === 'paused' && existing.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED') {
+                if (!canRecoverCodexUnsupportedPause(existing, resolved.taskDir)) {
+                    return { status: 'paused', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
+                }
+                const now = (options.now ?? (() => new Date().toISOString()))();
+                const previousPause = existing.pause;
+                const recovery = {
+                    code: 'CLIENT_CAPABILITY_ENABLED',
+                    recoveredAt: now,
+                    previousSchemaVersion: 2,
+                    previousStatus: 'paused',
+                    previousPause,
+                    client: 'codex',
+                    guards: {
+                        stepCount: 0,
+                        nextStage: null,
+                        baselineEmpty: true,
+                        receiptCount: 0,
+                        pendingDelegation: false,
+                        commitAuthorizationUnused: true,
+                        completionEvidenceAbsent: true,
+                        commitIntentAbsent: true
+                    },
+                    resultingStatus: 'running'
+                };
+                const resumed = withUpdatedRun(existing, {
+                    status: 'running',
+                    pause: null,
+                    recoveryHistory: Object.freeze([...(existing.recoveryHistory ?? []), recovery])
+                }, () => now);
+                saveRun(resolved.taskDir, resumed);
+                return { status: 'running', changed: true, taskId: resolved.taskId, run: resumed, next: null, error: null };
+            }
             if (existing.status === 'paused' && existing.pause?.recoverable && existing.pendingDelegation === null) {
                 const resumed = withUpdatedRun(existing, { status: 'running', pause: null });
                 saveRun(resolved.taskDir, resumed);
@@ -399,6 +456,13 @@ function routeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
+    let gitRoot;
+    try {
+        gitRoot = gitRootFor(resolved.repoRoot, options);
+    }
+    catch (error) {
+        return failed('ORCHESTRATION_WORKTREE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
     let content;
     try {
         content = fs.readFileSync(resolved.taskMdPath, 'utf8');
@@ -469,7 +533,7 @@ function routeOrchestration(taskRef, options = {}) {
         const capture = options.captureRepository ?? captureRepositorySnapshot;
         let before;
         try {
-            before = capture(resolved.repoRoot);
+            before = capture(gitRoot);
         }
         catch (error) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -484,7 +548,7 @@ function routeOrchestration(taskRef, options = {}) {
         const inspect = options.inspectPullRequest ?? inspectPlatformPullRequest;
         let inspection;
         try {
-            inspection = inspect(resolved.taskId, { cwd: resolved.repoRoot });
+            inspection = inspect(resolved.taskId, { cwd: gitRoot });
         }
         catch (error) {
             return failed('ORCHESTRATION_PR_INSPECTION_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -505,7 +569,7 @@ function routeOrchestration(taskRef, options = {}) {
         }
         let after;
         try {
-            after = capture(resolved.repoRoot);
+            after = capture(gitRoot);
         }
         catch (error) {
             return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -538,13 +602,101 @@ function routeOrchestration(taskRef, options = {}) {
     }
     return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
+function appendCommitActivity(resolved, step, agent, note) {
+    const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    const activity = locateActivityLog(taskContent);
+    if (!activity)
+        return { code: 'ORCHESTRATION_TASK_INVALID', message: 'task activity log is missing or ambiguous' };
+    const metadata = captureTaskWriteMetadata();
+    const written = writeTask({
+        taskRef: resolved.taskId,
+        expectedState: 'active',
+        mutations: [{
+                kind: 'section',
+                aliases: ['活动日志', 'Activity Log'],
+                heading: activity.heading,
+                body: appendActivityEntry(activity, { time: metadata.timestamp, step, agent, note })
+            }]
+    }, { repoRoot: resolved.repoRoot, metadataProvider: () => metadata });
+    return written.status === 'failed' ? written.error : null;
+}
+function startCommitAttempt(taskRef, input, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
+    try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-attempt.start', () => {
+            if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists', resolved.taskId);
+            }
+            const taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
+            const activity = locateActivityLog(taskContent);
+            if (!activity)
+                return commitIntentFailed('ORCHESTRATION_TASK_INVALID', 'task activity log is missing or ambiguous', resolved.taskId);
+            const open = pairEntries(activity.entries).filter((row) => row.step === 'Commit' && row.started !== '' && row.done === '');
+            if (open.length > 0) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_ATTEMPT_BUSY', 'an open Commit activity entry already exists', resolved.taskId);
+            }
+            const currentHead = repositoryHead(gitRoot);
+            const attempt = (options.id ?? randomUUID)();
+            const error = appendCommitActivity(resolved, 'Commit [started]', input.agent, commitAttemptStartedNote({
+                attempt,
+                baseline: currentHead,
+                agent: input.agent
+            }));
+            if (error)
+                return commitIntentFailed(error.code, error.message, resolved.taskId);
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            return {
+                status: 'ready', changed: true, taskId: resolved.taskId, intent: null,
+                finalization: commitFinalizationView(inspection), error: null
+            };
+        });
+    }
+    catch (error) {
+        return mapCommitIntentError(error, resolved.taskId);
+    }
+}
+function terminateCommitAttempt(taskRef, input, options = {}) {
+    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok)
+        return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
+    try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
+        return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-attempt.terminate', () => {
+            if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'an active commit intent must be aborted or recovered first', resolved.taskId);
+            }
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            if (inspection.disposition !== 'retryable-start'
+                || inspection.attempt?.attempt !== input.attempt
+                || inspection.attempt.agent !== input.agent
+                || inspection.attempt.baseline !== inspection.currentHead) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'commit attempt identity or repository HEAD has drifted', resolved.taskId);
+            }
+            const error = appendCommitActivity(resolved, 'Commit [aborted]', input.agent, `aborted; attempt=${input.attempt}; code=${input.code}`);
+            if (error)
+                return commitIntentFailed(error.code, error.message, resolved.taskId);
+            return {
+                status: 'ready', changed: true, taskId: resolved.taskId, intent: null,
+                finalization: commitFinalizationView(inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId)),
+                error: null
+            };
+        });
+    }
+    catch (error) {
+        return mapCommitIntentError(error, resolved.taskId);
+    }
+}
 function beginCommitIntent(taskRef, input, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.begin', () => {
-            const currentHead = repositoryHead(resolved.repoRoot);
+            const currentHead = repositoryHead(gitRoot);
             if (currentHead !== input.baselineHead) {
                 return commitIntentFailed('ORCHESTRATION_COMMIT_BASELINE_MISMATCH', 'baseline HEAD does not match the repository HEAD', resolved.taskId);
             }
@@ -557,6 +709,13 @@ function beginCommitIntent(taskRef, input, options = {}) {
                 }
                 return commitIntentFailed('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent already exists', resolved.taskId);
             }
+            const attemptInspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            if (attemptInspection.disposition !== 'retryable-start'
+                || attemptInspection.attempt?.attempt !== input.attempt
+                || attemptInspection.attempt.agent !== input.agent
+                || attemptInspection.attempt.baseline !== input.baselineHead) {
+                return commitIntentFailed('ORCHESTRATION_COMMIT_ATTEMPT_MISMATCH', 'commit begin requires one matching retryable Commit attempt', resolved.taskId);
+            }
             const runFile = orchestrationPath(resolved.taskDir);
             let run = null;
             let sourceRunBytes = null;
@@ -646,13 +805,14 @@ function checkpointCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.checkpoint', () => {
             const intent = readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const currentHead = repositoryHead(resolved.repoRoot);
+            const currentHead = repositoryHead(gitRoot);
             if (currentHead !== input.head) {
                 return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'checkpoint HEAD does not match the repository HEAD', resolved.taskId);
             }
-            if (input.kind === 'committed' && !isAncestor(resolved.repoRoot, intent.baselineHead, input.head)) {
+            if (input.kind === 'committed' && !isAncestor(gitRoot, intent.baselineHead, input.head)) {
                 return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'committed HEAD does not descend from the baseline', resolved.taskId);
             }
             if (input.kind === 'pushed') {
@@ -750,9 +910,10 @@ function completeCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.complete', () => {
             readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const inspection = inspectCommitFinalization(resolved.taskDir, resolved.repoRoot, resolved.taskId);
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
             return finalizeCommitIntentUnlocked(resolved, inspection, input.agent, () => {
                 removeCommitIntent(resolved.taskDir, resolved.taskId, input.token);
             });
@@ -767,8 +928,15 @@ function recoverCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.recover', () => {
-            const inspection = inspectCommitFinalization(resolved.taskDir, resolved.repoRoot, resolved.taskId);
+            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
+            if (inspection.disposition === 'retryable-start') {
+                return {
+                    status: 'ready', changed: false, taskId: resolved.taskId, intent: null,
+                    finalization: commitFinalizationView(inspection), error: null
+                };
+            }
             if (inspection.disposition === 'prepared' && inspection.intentDigest) {
                 removeCommitIntentByDigest(resolved.taskDir, resolved.taskId, inspection.intentDigest);
                 return { status: 'ready', changed: true, taskId: resolved.taskId, intent: null, error: null };
@@ -790,9 +958,10 @@ function abortCommitIntent(taskRef, input, options = {}) {
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
     try {
+        const gitRoot = gitRootFor(resolved.repoRoot, options);
         return withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'commit-intent.abort', () => {
             const intent = readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const currentHead = repositoryHead(resolved.repoRoot);
+            const currentHead = repositoryHead(gitRoot);
             if (intent.phase !== 'prepared'
                 || intent.pushEvidence !== null
                 || input.expectedHead !== intent.baselineHead
@@ -811,7 +980,14 @@ function statusCommitIntent(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
-    const inspection = inspectCommitFinalization(resolved.taskDir, resolved.repoRoot, resolved.taskId);
+    let gitRoot;
+    try {
+        gitRoot = gitRootFor(resolved.repoRoot, options);
+    }
+    catch (error) {
+        return commitIntentFailed('ORCHESTRATION_WORKTREE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+    }
+    const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
     return {
         status: 'ready',
         changed: false,
@@ -878,7 +1054,11 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     }
     let beforeFingerprint;
     try {
-        beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)(resolved.repoRoot, resolved.taskId);
+        beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+            gitRoot: gitRootFor(resolved.repoRoot, options),
+            stateRoot: resolved.repoRoot,
+            taskId: resolved.taskId
+        });
     }
     catch (error) {
         return failed('ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), resolved.taskId);
@@ -928,7 +1108,7 @@ function matchingDelegations(predicate, options) {
         .filter((entry) => entry.isDirectory())
         .flatMap((entry) => {
         const run = readRun(path.join(activeRoot, entry.name));
-        if (!run?.pendingDelegation)
+        if (run?.status !== 'running' || !run.pendingDelegation)
             return [];
         const receipt = run.pendingDelegation;
         return predicate(receipt)
@@ -949,13 +1129,36 @@ function activateMatchingOrchestrationDelegation(client, event, options = {}) {
     if (!role)
         return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
     const matched = uniqueMatchingDelegation(client, (receipt) => receipt.status === 'prepared', options);
-    if ('status' in matched)
-        return matched;
+    if ('status' in matched) {
+        if (matched.error?.code !== 'ORCHESTRATION_DELEGATION_MISSING')
+            return matched;
+        const replay = uniqueMatchingDelegation(client, (receipt) => receipt.childId === event.childId && ['activated', 'stage-completed'].includes(receipt.status), options);
+        if ('status' in replay)
+            return matched;
+        const receipt = replay.run.pendingDelegation;
+        const sameEvidence = receipt.parentId === event.parentId
+            && receipt.spawnMode === event.spawnMode
+            && receipt.actualModel === event.actualModel
+            && receipt.actualReasoningEffort === event.actualReasoningEffort
+            && receipt.modelFallbackReason === (event.modelFallbackReason ?? null)
+            && receipt.reasoningEffortFallbackReason === (event.reasoningEffortFallbackReason ?? null)
+            && receipt.hostEvidence?.hookDefinitionHash === event.hostEvidence?.hookDefinitionHash;
+        if (!sameEvidence) {
+            return pauseOrchestration(replay.taskId, 'DELEGATION_REPLAY_CONFLICT', 'replayed native start evidence conflicts with the active receipt', true, options);
+        }
+        return { status: replay.run.status, changed: false, taskId: replay.taskId, run: replay.run, next: null, error: null };
+    }
     if (matched.run.receipts.some((receipt) => receipt.childId === event.childId)) {
         return pauseOrchestration(matched.taskId, 'DELEGATION_IDENTITY_REUSED', 'native child identity was already used by this run', true, options);
     }
     return activateOrchestrationDelegation(matched.taskId, event, options);
 }
+function pauseMatchingOrchestrationDelegation(client, code, message, options = {}) {
+    const matched = uniqueMatchingDelegation(client, () => true, options);
+    if ('status' in matched)
+        return matched;
+    return pauseOrchestration(matched.taskId, code, message, true, options);
+}
 function sealMatchingOrchestrationDelegation(client, event, options = {}) {
     const role = managedDelegationRole(event.nativeAgent);
     if (!role)
@@ -969,9 +1172,14 @@ function sealMatchingOrchestrationDelegation(client, event, 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)(repoRoot, snapshotTaskId);
-        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(repoRoot, receipt.beforeFingerprint, afterFingerprint);
+        const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+            gitRoot,
+            stateRoot: repoRoot,
+            taskId: snapshotTaskId
+        });
+        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(gitRoot, receipt.beforeFingerprint, afterFingerprint);
         return sealOrchestrationDelegation(matched.taskId, {
             childId: event.childId,
             exitCode: 0,
@@ -983,6 +1191,63 @@ function sealMatchingOrchestrationDelegation(client, event, options = {}) {
         return pauseOrchestration(matched.taskId, 'ORCHESTRATION_SNAPSHOT_FAILED', error instanceof Error ? error.message : String(error), true, options);
     }
 }
+function sealMatchingOrchestrationDelegationWithHostEvidence(client, event, consumeEvidence, options = {}) {
+    const role = managedDelegationRole(event.nativeAgent);
+    if (!role)
+        return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+    const matched = uniqueMatchingDelegation(client, (receipt) => ((receipt.status === 'stage-completed' || receipt.status === 'sealed')
+        && receipt.childId === event.childId), options);
+    if ('status' in matched)
+        return matched;
+    const receipt = matched.run.pendingDelegation;
+    if (receipt.status === 'sealed') {
+        return reconcileMatchingOrchestrationDelegation(client, event.childId, options);
+    }
+    if (receipt.role !== role) {
+        return pauseOrchestration(matched.taskId, 'DELEGATION_ROLE_MISMATCH', `managed role ${role} does not match ${receipt.role}`, true, options);
+    }
+    const repoRoot = options.repoRoot ?? process.cwd();
+    try {
+        const gitRoot = gitRootFor(repoRoot, options);
+        const snapshotTaskId = receipt.workspaceSnapshotScope === 'task' ? receipt.taskId : null;
+        const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+            gitRoot,
+            stateRoot: repoRoot,
+            taskId: snapshotTaskId
+        });
+        const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(gitRoot, receipt.beforeFingerprint, afterFingerprint);
+        const baseEvent = { childId: event.childId, exitCode: 0, afterFingerprint, changedPaths };
+        const validated = sealDelegation(receipt, baseEvent, { now: options.now });
+        if (!validated.ok) {
+            return pauseOrchestration(matched.taskId, validated.code, validated.message, true, options);
+        }
+        const hostEvidence = consumeEvidence(receipt);
+        const sealed = sealDelegation(receipt, { ...baseEvent, hostEvidence }, { now: options.now });
+        if (!sealed.ok)
+            return pauseOrchestration(matched.taskId, sealed.code, sealed.message, true, options);
+        const resolved = resolveTaskRef(matched.taskId, { repoRoot });
+        if (!resolved.ok)
+            return failed(resolved.code, resolved.message, resolved.taskId);
+        const updated = withUpdatedRun(matched.run, { pendingDelegation: sealed.receipt }, options.now);
+        saveRun(resolved.taskDir, updated);
+        return { status: 'running', changed: true, taskId: matched.taskId, run: updated, next: null, error: null };
+    }
+    catch (error) {
+        return pauseOrchestration(matched.taskId, 'ORCHESTRATION_CODEX_EVIDENCE_FAILED', error instanceof Error ? error.message : String(error), true, options);
+    }
+}
+function reconcileMatchingOrchestrationDelegation(client, childId, options = {}) {
+    const matched = uniqueMatchingDelegation(client, (receipt) => receipt.childId === childId, options);
+    if ('status' in matched)
+        return matched;
+    const receipt = matched.run.pendingDelegation;
+    if (receipt.status !== 'sealed'
+        || receipt.hostEvidence?.consumer !== receipt.id
+        || receipt.hostEvidence.consumedAt === null) {
+        return pauseOrchestration(matched.taskId, 'ORCHESTRATION_CODEX_RECONCILIATION_FAILED', 'Codex native spawn did not produce one sealed receipt with consumed host evidence', true, options);
+    }
+    return { status: matched.run.status, changed: false, taskId: matched.taskId, run: matched.run, next: null, error: null };
+}
 function activateOrchestrationDelegation(taskRef, event, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -1115,5 +1380,5 @@ function pauseOrchestration(taskRef, code, message, recoverable, options = {}) {
     saveRun(resolved.taskDir, updated);
     return { status: 'paused', changed: true, taskId: resolved.taskId, run: updated, next: null, error: null };
 }
-export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, inspectOrchestrationStage, orchestrationPath, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusCommitIntent, statusOrchestration };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, inspectOrchestrationStage, orchestrationPath, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt };
 //# sourceMappingURL=orchestration.js.map

package/dist/lib/task/review-fingerprint.js

@@ -1,6 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { artifactName, maxRound } from "./review-artifacts.js";
+const REVIEWED_TREE_RE = /^[a-f0-9]{40,64}$/;
+export function parseReviewedGitTree(value) {
+    return REVIEWED_TREE_RE.test(value) ? value : null;
+}
 // Paths excluded from the post-review coverage gate. Fail-closed: the gate
 // covers ALL tracked changes by default. This default denylist is EMPTY —
 // projects opt into exclusions explicitly via review.post_review_exclude_globs.

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

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

package/dist/lib/task/verification.js

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

package/dist/lib/task/workspace-snapshot.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -25,12 +26,70 @@ function captureWorktreeTree(repoRoot, forcedPath) {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }
 }
-function captureWorkspaceSnapshot(repoRoot, taskId) {
+function captureLegacyWorkspaceSnapshot(repoRoot, taskId) {
     const workspaceRelative = taskId
         ? `.agents/workspace/active/${taskId}`
         : '.agents/workspace/active';
     return captureWorktreeTree(repoRoot, workspaceRelative);
 }
+function taskFileFingerprints(stateRoot, taskId) {
+    const activeRoot = path.join(stateRoot, '.agents', 'workspace', 'active');
+    const roots = taskId ? [path.join(activeRoot, taskId)] : [activeRoot];
+    const records = [];
+    const visit = (absolute, relative) => {
+        const stat = fs.lstatSync(absolute);
+        if (stat.isDirectory()) {
+            for (const name of fs.readdirSync(absolute).sort()) {
+                visit(path.join(absolute, name), path.posix.join(relative, name));
+            }
+            return;
+        }
+        if (!stat.isFile() && !stat.isSymbolicLink())
+            return;
+        const content = stat.isSymbolicLink()
+            ? Buffer.from(fs.readlinkSync(absolute))
+            : fs.readFileSync(absolute);
+        records.push({
+            path: relative,
+            mode: stat.mode & 0o777,
+            kind: stat.isSymbolicLink() ? 'symlink' : 'file',
+            sha256: createHash('sha256').update(content).digest('hex')
+        });
+    };
+    for (const root of roots) {
+        if (!fs.existsSync(root))
+            continue;
+        const relative = path.posix.join('.agents/workspace/active', path.relative(activeRoot, root).split(path.sep).join('/'));
+        visit(root, relative.replace(/\/$/, ''));
+    }
+    return records.sort((left, right) => left.path.localeCompare(right.path));
+}
+function encodeWorkspaceFingerprint(value) {
+    return `ws2:${Buffer.from(JSON.stringify(value)).toString('base64url')}`;
+}
+function decodeWorkspaceFingerprint(value) {
+    if (!value.startsWith('ws2:'))
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(value.slice(4), 'base64url').toString('utf8'));
+        if (parsed.version !== 2 || !/^[a-f0-9]{40,64}$/.test(parsed.gitTree) || !Array.isArray(parsed.taskFiles)) {
+            throw new Error('invalid workspace fingerprint fields');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`ORCHESTRATION_SNAPSHOT_FAILED: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function captureWorkspaceSnapshot(contextOrRoot, taskId) {
+    if (typeof contextOrRoot === 'string')
+        return captureLegacyWorkspaceSnapshot(contextOrRoot, taskId ?? null);
+    return encodeWorkspaceFingerprint({
+        version: 2,
+        gitTree: captureWorktreeTree(contextOrRoot.gitRoot, null),
+        taskFiles: taskFileFingerprints(contextOrRoot.stateRoot, contextOrRoot.taskId)
+    });
+}
 function captureRepositorySnapshot(repoRoot) {
     return {
         head: git(repoRoot, null, ['rev-parse', 'HEAD']).trim(),
@@ -39,8 +98,24 @@ function captureRepositorySnapshot(repoRoot) {
     };
 }
 function diffWorkspaceSnapshots(repoRoot, before, after) {
-    const output = git(repoRoot, null, ['diff', '--name-only', '-z', before, after]);
-    return output.split('\0').filter(Boolean);
+    const beforeV2 = decodeWorkspaceFingerprint(before);
+    const afterV2 = decodeWorkspaceFingerprint(after);
+    if ((beforeV2 === null) !== (afterV2 === null)) {
+        throw new Error('ORCHESTRATION_SNAPSHOT_FAILED: workspace fingerprint versions cannot be mixed');
+    }
+    if (!beforeV2 || !afterV2) {
+        const output = git(repoRoot, null, ['diff', '--name-only', '-z', before, after]);
+        return output.split('\0').filter(Boolean);
+    }
+    const output = git(repoRoot, null, ['diff', '--name-only', '-z', beforeV2.gitTree, afterV2.gitTree]);
+    const changed = new Set(output.split('\0').filter(Boolean));
+    const beforeFiles = new Map(beforeV2.taskFiles.map((record) => [record.path, JSON.stringify(record)]));
+    const afterFiles = new Map(afterV2.taskFiles.map((record) => [record.path, JSON.stringify(record)]));
+    for (const filePath of new Set([...beforeFiles.keys(), ...afterFiles.keys()])) {
+        if (beforeFiles.get(filePath) !== afterFiles.get(filePath))
+            changed.add(filePath);
+    }
+    return [...changed].sort();
 }
 export { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnapshots };
 //# sourceMappingURL=workspace-snapshot.js.map