@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/dist/lib/task/orchestration.js

@@ -1,14 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { execFileSync, spawnSync } from 'node:child_process';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseReviewSummary } from './review-artifacts.js';
 import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, managedDelegationRole, prepareDelegation, sealDelegation } from './delegation-receipts.js';
+import { activateDelegation, 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 { inspectPlatformPullRequest } from '../platform/pull-requests.js';
 import { getAgentClientCapability, getAgentClientDelegationEvidence, getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
@@ -16,10 +16,6 @@ import { captureRepositorySnapshot, captureWorkspaceSnapshot, diffWorkspaceSnaps
 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 { 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'
@@ -29,26 +25,138 @@ function supportsLifecycleDelegation(client) {
 function orchestrationPath(taskDir) {
     return path.join(taskDir, 'orchestration.json');
 }
+const ORCHESTRATION_STATE_INVALID_MESSAGE = 'orchestration.json does not match the current runtime structure; finish or clear active runs before upgrading';
+class OrchestrationStateError extends Error {
+    code = 'ORCHESTRATION_STATE_INVALID';
+    taskId;
+    constructor(taskId = null) {
+        super(ORCHESTRATION_STATE_INVALID_MESSAGE);
+        this.name = 'OrchestrationStateError';
+        this.taskId = taskId;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    if (!isRecord(value))
+        return false;
+    const actual = Object.keys(value);
+    return actual.length === keys.length && keys.every((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+function exactText(value) {
+    return typeof value === 'string' && value.length > 0 && value.trim() === value;
+}
+function nullableText(value) {
+    return value === null || exactText(value);
+}
+function isPause(value) {
+    return hasExactKeys(value, ['code', 'message', 'recoverable'])
+        && exactText(value.code)
+        && exactText(value.message)
+        && typeof value.recoverable === 'boolean';
+}
+function isModelPolicySource(value) {
+    return hasExactKeys(value, ['kind', 'client', 'resolvedAt'])
+        && ['explicit', 'project-config'].includes(value.kind)
+        && isAgentClientId(value.client)
+        && exactText(value.resolvedAt);
+}
+function isModelPolicy(value) {
+    if (!hasExactKeys(value, ['executor', 'reviewer']))
+        return false;
+    return [value.executor, value.reviewer].every((role) => hasExactKeys(role, ['model', 'reasoningEffort'])
+        && exactText(role.model)
+        && exactText(role.reasoningEffort));
+}
+const RECOVERY_GUARD_KEYS = [
+    'stepCount', 'nextStage', 'baselineEmpty', 'receiptCount', 'pendingDelegation',
+    'commitAuthorizationUnused', 'completionEvidenceAbsent'
+];
+function isRecovery(value) {
+    if (!hasExactKeys(value, [
+        'code', 'recoveredAt', 'previousStatus', 'previousPause', 'client', 'guards', 'resultingStatus'
+    ]))
+        return false;
+    const guards = value.guards;
+    return value.code === 'CLIENT_CAPABILITY_ENABLED'
+        && exactText(value.recoveredAt)
+        && value.previousStatus === 'paused'
+        && isPause(value.previousPause)
+        && value.previousPause.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
+        && value.client === 'claude-code'
+        && 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';
+}
+function isCompletionEvidence(value) {
+    return hasExactKeys(value, [
+        'kind', 'observedAt', 'head', 'headTree', 'worktreeTree', 'lastReviewedCommit', 'prNumber', 'prHead'
+    ])
+        && value.kind === 'reviewed-head-clean'
+        && exactText(value.observedAt)
+        && exactText(value.head)
+        && exactText(value.headTree)
+        && exactText(value.worktreeTree)
+        && exactText(value.lastReviewedCommit)
+        && Number.isSafeInteger(value.prNumber)
+        && value.prNumber > 0
+        && exactText(value.prHead);
+}
+const ORCHESTRATION_RUN_KEYS = [
+    'taskId', 'runId', 'status', 'nextStage', 'stepCount', 'maxSteps', 'modelPolicy',
+    'modelPolicySource', 'recoveryHistory', 'baseline', 'pendingDelegation', 'receipts',
+    'pause', 'commitAuthorization', 'completionEvidence', 'createdAt', 'updatedAt'
+];
+function parseOrchestrationRun(value, expectedTaskId) {
+    if (!hasExactKeys(value, ORCHESTRATION_RUN_KEYS)
+        || !exactText(value.taskId)
+        || (expectedTaskId !== undefined && value.taskId !== expectedTaskId)
+        || !exactText(value.runId)
+        || !['running', 'paused', 'completed'].includes(value.status)
+        || !(value.nextStage === null || ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code', 'commit'].includes(value.nextStage))
+        || !Number.isSafeInteger(value.stepCount) || value.stepCount < 0
+        || !Number.isSafeInteger(value.maxSteps) || value.maxSteps < 1
+        || !isModelPolicy(value.modelPolicy)
+        || !isModelPolicySource(value.modelPolicySource)
+        || !Array.isArray(value.recoveryHistory) || !value.recoveryHistory.every(isRecovery)
+        || typeof value.baseline !== 'string'
+        || !(value.pendingDelegation === null || isDelegationReceipt(value.pendingDelegation))
+        || !Array.isArray(value.receipts) || !value.receipts.every(isDelegationReceipt)
+        || !(value.pause === null || isPause(value.pause))
+        || !hasExactKeys(value.commitAuthorization, ['issuedAt', 'consumedAt'])
+        || !nullableText(value.commitAuthorization.issuedAt)
+        || !nullableText(value.commitAuthorization.consumedAt)
+        || !(value.completionEvidence === null || isCompletionEvidence(value.completionEvidence))
+        || !exactText(value.createdAt)
+        || !exactText(value.updatedAt)) {
+        throw new OrchestrationStateError();
+    }
+    const receipts = [...value.receipts, ...(value.pendingDelegation ? [value.pendingDelegation] : [])];
+    if (receipts.some((receipt) => receipt.taskId !== value.taskId || receipt.runId !== value.runId)) {
+        throw new OrchestrationStateError();
+    }
+    return value;
+}
 function readRun(taskDir) {
     const file = orchestrationPath(taskDir);
     if (!fs.existsSync(file))
         return null;
-    const run = JSON.parse(fs.readFileSync(file, 'utf8'));
-    if (![2, 3].includes(run.schemaVersion) || !isV2Policy(run.modelPolicy))
-        return run;
-    return {
-        ...run,
-        modelPolicy: {
-            executor: {
-                model: run.modelPolicy.executor.model,
-                reasoningEffort: run.modelPolicy.executor.reasoningEffort
-            },
-            reviewer: {
-                model: run.modelPolicy.reviewer.model,
-                reasoningEffort: run.modelPolicy.reviewer.reasoningEffort
-            }
-        }
-    };
+    const taskId = path.basename(taskDir);
+    try {
+        return parseOrchestrationRun(JSON.parse(fs.readFileSync(file, 'utf8')), taskId);
+    }
+    catch (error) {
+        if (error instanceof OrchestrationStateError)
+            throw new OrchestrationStateError(taskId);
+        throw new OrchestrationStateError(taskId);
+    }
 }
 function atomicWrite(file, value) {
     const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
@@ -64,70 +172,11 @@ function withUpdatedRun(run, updates, now) {
 function failed(code, message, taskId = null, details = {}) {
     return { status: 'failed', changed: false, taskId, run: null, next: null, error: { code, message, ...details } };
 }
-function commitIntentFailed(code, message, taskId = null) {
-    return { status: 'failed', changed: false, taskId, intent: null, error: { code, message } };
-}
-function repositoryHead(repoRoot) {
-    return execFileSync('git', ['rev-parse', 'HEAD'], {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        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,
-        stdio: 'ignore'
-    }).status === 0;
-}
-function commitIntentView(intent, currentHead) {
-    return {
-        mode: intent.mode,
-        phase: intent.phase,
-        baselineHead: intent.baselineHead,
-        currentHead,
-        committedHead: intent.committedHead,
-        pushEvidence: intent.pushEvidence,
-        runId: intent.orchestration?.runId ?? null,
-        receiptId: intent.orchestration?.receiptId ?? null
-    };
-}
-function commitFinalizationView(inspection) {
-    return {
-        disposition: inspection.disposition,
-        code: inspection.code,
-        message: inspection.message,
-        currentHead: inspection.currentHead,
-        committedHead: inspection.committedHead,
-        needsAnchor: inspection.needsAnchor,
-        needsLog: inspection.needsLog,
-        attempt: inspection.attempt
-    };
-}
-function validCommitRun(run, taskId) {
-    return run !== null
-        && [1, 2, 3].includes(run.schemaVersion)
-        && run.taskId === taskId
-        && ['running', 'paused', 'completed'].includes(run.status)
-        && Array.isArray(run.receipts)
-        && Object.prototype.hasOwnProperty.call(run, 'pendingDelegation')
-        && typeof run.commitAuthorization === 'object'
-        && run.commitAuthorization !== null
-        && Object.prototype.hasOwnProperty.call(run.commitAuthorization, 'issuedAt')
-        && Object.prototype.hasOwnProperty.call(run.commitAuthorization, 'consumedAt');
-}
-function mapCommitIntentError(error, taskId) {
-    if (error instanceof CommitIntentError)
-        return commitIntentFailed(error.code, error.message, taskId);
-    if (error instanceof TaskExecutionLockError)
-        return commitIntentFailed(error.code, error.message, taskId);
-    return commitIntentFailed('ORCHESTRATION_COMMIT_INTENT_INVALID', error instanceof Error ? error.message : String(error), taskId);
-}
 function validModel(value) {
     return typeof value === 'string' && value.length > 0 && value.trim() === value;
 }
@@ -147,11 +196,8 @@ function sameModelPolicy(left, right) {
         && left.reviewer.model === right.reviewer.model
         && left.reviewer.reasoningEffort === right.reviewer.reasoningEffort;
 }
-function isV2Policy(policy) {
-    return typeof policy?.executor === 'object' && typeof policy?.reviewer === 'object';
-}
 function rolePolicy(run, role) {
-    return isV2Policy(run.modelPolicy) ? run.modelPolicy[role] : null;
+    return run.modelPolicy[role];
 }
 function resolveProjectPolicy(repoRoot, client) {
     const configPath = path.join(repoRoot, '.agents', '.airc.json');
@@ -160,26 +206,10 @@ 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'
+function canRecoverClaudeCodeUnsupportedPause(run, taskDir) {
+    return 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 canMigrateRecoverableV2Pause(run, taskDir) {
-    return run.schemaVersion === 2
-        && run.status === 'paused'
-        && run.pause?.recoverable === true
+        && run.modelPolicySource?.client === 'claude-code'
         && run.stepCount === 0
         && run.nextStage === null
         && run.baseline === ''
@@ -188,7 +218,7 @@ function canMigrateRecoverableV2Pause(run, taskDir) {
         && run.commitAuthorization?.issuedAt === null
         && run.commitAuthorization?.consumedAt === null
         && run.completionEvidence == null
-        && !fs.existsSync(commitIntentPath(taskDir));
+        && run.recoveryHistory.length === 0;
 }
 function beginOrResumeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
@@ -205,193 +235,57 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
         return failed('ORCHESTRATION_STATE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
     }
     if (existing) {
-        if (![1, 2, 3].includes(existing.schemaVersion)
-            || !Array.isArray(existing.receipts)
-            || !Object.prototype.hasOwnProperty.call(existing, 'pendingDelegation')) {
-            return failed('ORCHESTRATION_STATE_INVALID', 'orchestration state has an invalid schema', resolved.taskId);
-        }
-        if (existing.status === 'completed' && existing.schemaVersion === 1) {
+        if (existing.status === 'completed') {
             return { status: 'completed', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
         }
-        if (existing.schemaVersion === 2 || existing.schemaVersion === 3) {
-            const policyError = validateModelPolicy(isV2Policy(existing.modelPolicy) ? existing.modelPolicy : undefined);
-            if (policyError
-                || !existing.modelPolicySource
-                || !isAgentClientId(existing.modelPolicySource.client)
-                || !Array.isArray(existing.recoveryHistory)) {
-                return failed('ORCHESTRATION_STATE_INVALID', `schemaVersion ${existing.schemaVersion} orchestration state is incomplete`, resolved.taskId);
-            }
-            if (existing.status === 'completed') {
-                return { status: 'completed', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
-            }
-            if (existing.schemaVersion === 2 && existing.status === 'running') {
-                return failed('ORCHESTRATION_STATE_INVALID', 'active schemaVersion 2 runs cannot be advanced by lifecycle protocol v3', resolved.taskId);
-            }
-            if (existing.modelPolicySource.client !== options.client) {
-                return failed('ORCHESTRATION_CLIENT_MISMATCH', 'provided client does not match the persisted run policy source', resolved.taskId);
-            }
-            if (options.modelPolicy) {
-                const suppliedError = validateModelPolicy(options.modelPolicy);
-                if (suppliedError)
-                    return failed(suppliedError.code, suppliedError.message, resolved.taskId);
-                if (!sameModelPolicy(existing.modelPolicy, options.modelPolicy)) {
-                    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, {
-                    schemaVersion: 3,
-                    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) {
-                if (existing.schemaVersion === 2 && !canMigrateRecoverableV2Pause(existing, resolved.taskDir)) {
-                    const paused = withUpdatedRun(existing, {
-                        pause: {
-                            code: 'ORCHESTRATION_SCHEMA_MIGRATION_REQUIRED',
-                            message: 'schemaVersion 2 recoverable pause contains execution evidence and cannot migrate automatically',
-                            recoverable: false
-                        }
-                    });
-                    saveRun(resolved.taskDir, paused);
-                    return { status: 'paused', changed: true, taskId: resolved.taskId, run: paused, next: null, error: null };
-                }
-                const now = (options.now ?? (() => new Date().toISOString()))();
-                const recovery = existing.schemaVersion === 2 ? {
-                    code: 'SCHEMA_V3_MIGRATED',
-                    recoveredAt: now,
-                    previousSchemaVersion: 2,
-                    previousStatus: 'paused',
-                    previousPause: existing.pause,
-                    guards: {
-                        stepCount: 0,
-                        nextStage: null,
-                        baselineEmpty: true,
-                        receiptCount: 0,
-                        pendingDelegation: false,
-                        commitAuthorizationUnused: true,
-                        completionEvidenceAbsent: true,
-                        commitIntentAbsent: true
-                    },
-                    resultingStatus: 'running'
-                } : null;
-                const resumed = withUpdatedRun(existing, {
-                    schemaVersion: 3,
-                    status: 'running',
-                    pause: null,
-                    ...(recovery ? { 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 };
-            }
-            return { status: existing.status, changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
+        if (existing.modelPolicySource.client !== options.client) {
+            return failed('ORCHESTRATION_CLIENT_MISMATCH', 'provided client does not match the persisted run policy source', resolved.taskId);
         }
-        let policy = options.modelPolicy;
-        let sourceKind = 'explicit';
-        if (!policy) {
-            try {
-                policy = resolveProjectPolicy(resolved.repoRoot, options.client);
-                sourceKind = 'project-config';
-            }
-            catch (error) {
-                return failed('ORCHESTRATION_CONFIG_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
+        if (options.modelPolicy) {
+            const suppliedError = validateModelPolicy(options.modelPolicy);
+            if (suppliedError)
+                return failed(suppliedError.code, suppliedError.message, resolved.taskId);
+            if (!sameModelPolicy(existing.modelPolicy, options.modelPolicy)) {
+                return failed('ORCHESTRATION_MODEL_POLICY_MISMATCH', 'provided model policy does not match the persisted run policy', resolved.taskId);
             }
         }
-        const policyError = validateModelPolicy(policy);
-        if (policyError) {
-            return failed(policyError.code, policyError.message, resolved.taskId, {
-                client: options.client,
-                missingFields: ['executor.model', 'executor.reasoningEffort', 'reviewer.model', 'reviewer.reasoningEffort'],
-                modelSelectionContext: getAgentClientModelSelection(options.client)
-            });
-        }
-        if (existing.pendingDelegation !== null) {
-            const alreadyPaused = existing.status === 'paused' && existing.pause?.code === 'ORCHESTRATION_DELEGATION_BUSY';
-            if (alreadyPaused)
-                return { status: 'paused', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
-            const paused = withUpdatedRun(existing, {
-                status: 'paused',
-                pause: { code: 'ORCHESTRATION_DELEGATION_BUSY', message: 'legacy run has a pending delegation', recoverable: false }
-            });
-            saveRun(resolved.taskDir, paused);
-            return { status: 'paused', changed: true, taskId: resolved.taskId, run: paused, next: null, error: null };
-        }
-        if (existing.receipts.length > 0) {
-            const alreadyPaused = existing.status === 'paused' && existing.pause?.code === 'ORCHESTRATION_HISTORICAL_EFFORT_UNVERIFIED';
-            if (alreadyPaused)
+        if (existing.status === 'paused' && existing.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED') {
+            if (existing.modelPolicySource.client !== 'claude-code'
+                || !canRecoverClaudeCodeUnsupportedPause(existing, resolved.taskDir)) {
                 return { status: 'paused', changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
-            const paused = withUpdatedRun(existing, {
-                status: 'paused',
-                pause: {
-                    code: 'ORCHESTRATION_HISTORICAL_EFFORT_UNVERIFIED',
-                    message: 'legacy receipts do not contain actual reasoning-effort evidence',
-                    recoverable: false
-                }
-            });
-            saveRun(resolved.taskDir, paused);
-            return { status: 'paused', changed: true, taskId: resolved.taskId, run: paused, next: null, error: null };
+            }
+            const now = (options.now ?? (() => new Date().toISOString()))();
+            const recovery = {
+                code: 'CLIENT_CAPABILITY_ENABLED',
+                recoveredAt: now,
+                previousStatus: 'paused',
+                previousPause: existing.pause,
+                client: 'claude-code',
+                guards: {
+                    stepCount: 0,
+                    nextStage: null,
+                    baselineEmpty: true,
+                    receiptCount: 0,
+                    pendingDelegation: false,
+                    commitAuthorizationUnused: true,
+                    completionEvidenceAbsent: 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.modelPolicy
-            && typeof existing.modelPolicy.executor === 'string'
-            && (existing.modelPolicy.executor !== policy.executor.model
-                || existing.modelPolicy.reviewer !== policy.reviewer.model)) {
-            return failed('ORCHESTRATION_MODEL_POLICY_MISMATCH', 'provided model policy does not match the persisted run policy', resolved.taskId);
+        if (existing.status === 'paused' && existing.pause?.recoverable && existing.pendingDelegation === null) {
+            const resumed = withUpdatedRun(existing, { status: 'running', pause: null }, options.now);
+            saveRun(resolved.taskDir, resumed);
+            return { status: 'running', changed: true, taskId: resolved.taskId, run: resumed, next: null, error: null };
         }
-        const now = (options.now ?? (() => new Date().toISOString()))();
-        const source = { kind: sourceKind, client: options.client, resolvedAt: now };
-        const clearsModelPause = existing.pause?.code === 'ORCHESTRATION_MODEL_EVIDENCE_MISSING';
-        const resultingStatus = clearsModelPause ? 'running' : existing.status;
-        const recovery = {
-            code: 'MODEL_POLICY_SUPPLEMENTED',
-            recoveredAt: now,
-            previousSchemaVersion: 1,
-            previousStatus: existing.status,
-            previousPause: existing.pause,
-            policySource: source,
-            receiptCount: 0,
-            pendingDelegation: false,
-            resultingStatus
-        };
-        const recovered = Object.freeze({
-            ...existing,
-            schemaVersion: 3,
-            status: resultingStatus,
-            modelPolicy: policy,
-            modelPolicySource: source,
-            recoveryHistory: Object.freeze([recovery]),
-            pause: clearsModelPause ? null : existing.pause,
-            updatedAt: now
-        });
-        saveRun(resolved.taskDir, recovered);
-        return { status: resultingStatus, changed: true, taskId: resolved.taskId, run: recovered, next: null, error: null };
+        return { status: existing.status, changed: false, taskId: resolved.taskId, run: existing, next: null, error: null };
     }
     let policy = options.modelPolicy;
     let sourceKind = 'explicit';
@@ -414,7 +308,6 @@ function beginOrResumeOrchestration(taskRef, options = {}) {
     const now = (options.now ?? (() => new Date().toISOString()))();
     const source = { kind: sourceKind, client: options.client, resolvedAt: now };
     const run = {
-        schemaVersion: 3,
         taskId: resolved.taskId,
         runId: (options.id ?? randomUUID)(),
         status: 'running',
@@ -656,401 +549,6 @@ 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(gitRoot);
-            if (currentHead !== input.baselineHead) {
-                return commitIntentFailed('ORCHESTRATION_COMMIT_BASELINE_MISMATCH', 'baseline HEAD does not match the repository HEAD', resolved.taskId);
-            }
-            if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
-                try {
-                    readCommitIntent(resolved.taskDir, resolved.taskId);
-                }
-                catch (error) {
-                    return mapCommitIntentError(error, resolved.taskId);
-                }
-                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;
-            if (fs.existsSync(runFile)) {
-                sourceRunBytes = fs.readFileSync(runFile, 'utf8');
-                try {
-                    run = readRun(resolved.taskDir);
-                }
-                catch (error) {
-                    return commitIntentFailed('ORCHESTRATION_STATE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
-                }
-                if (!validCommitRun(run, resolved.taskId)) {
-                    return commitIntentFailed('ORCHESTRATION_STATE_INVALID', 'orchestration state has an invalid schema', resolved.taskId);
-                }
-            }
-            const now = (options.now ?? (() => new Date().toISOString()))();
-            const failAndPause = (code, message) => {
-                if (run?.status === 'running') {
-                    saveRun(resolved.taskDir, withUpdatedRun(run, {
-                        status: 'paused', pause: { code, message, recoverable: true }
-                    }, () => now));
-                }
-                return commitIntentFailed(code, message, resolved.taskId);
-            };
-            let orchestration = null;
-            if (!input.orchestrated) {
-                if (run?.pendingDelegation) {
-                    return commitIntentFailed('ORCHESTRATION_STANDALONE_BUSY', 'standalone commit is blocked by a pending orchestration delegation', resolved.taskId);
-                }
-            }
-            else {
-                if (!run || run.status !== 'running') {
-                    return commitIntentFailed('ORCHESTRATION_RUN_NOT_RUNNING', 'orchestrated commit requires a running orchestration', resolved.taskId);
-                }
-                const receipt = run.pendingDelegation;
-                if (!receipt
-                    || receipt.status !== 'activated'
-                    || receipt.stage !== 'commit'
-                    || receipt.round !== 1
-                    || receipt.artifact !== 'commit'
-                    || receipt.role !== 'executor') {
-                    return failAndPause('ORCHESTRATION_PROVENANCE_MISMATCH', 'orchestrated commit requires one matching activated commit delegation');
-                }
-                if (!run.commitAuthorization.issuedAt || run.commitAuthorization.consumedAt) {
-                    return failAndPause('ORCHESTRATION_COMMIT_AUTHORIZATION_INVALID', 'orchestrated commit requires an unconsumed one-use authorization');
-                }
-                const planned = planOrchestrationStageCompletion(taskRef, {
-                    stage: 'commit', round: 1, artifact: 'commit', role: 'executor', agent: input.agent
-                }, { ...options, now: () => now });
-                if (planned.result.status === 'failed' || !planned.plan?.updatedRun.pendingDelegation) {
-                    return failAndPause(planned.result.error?.code ?? 'ORCHESTRATION_PROVENANCE_MISMATCH', planned.result.error?.message ?? 'commit delegation could not be completed');
-                }
-                const plannedRunBytes = serialize(planned.plan.updatedRun);
-                orchestration = {
-                    runId: run.runId,
-                    receiptId: receipt.id,
-                    authorizationIssuedAt: run.commitAuthorization.issuedAt,
-                    sourceRunDigest: digest(sourceRunBytes),
-                    plannedRunDigest: digest(plannedRunBytes),
-                    completionUpdatedAt: planned.plan.updatedRun.updatedAt,
-                    plannedReceipt: planned.plan.updatedRun.pendingDelegation
-                };
-            }
-            const created = createCommitIntent(resolved.taskDir, {
-                taskId: resolved.taskId,
-                mode: input.orchestrated ? 'orchestrated' : 'standalone',
-                phase: 'prepared',
-                baselineHead: input.baselineHead,
-                committedHead: null,
-                pushEvidence: null,
-                orchestration,
-                createdAt: now,
-                updatedAt: now
-            }, { token: options.token });
-            return {
-                status: 'ready', changed: true, taskId: resolved.taskId,
-                intent: commitIntentView(created.intent, currentHead), token: created.token, error: null
-            };
-        });
-    }
-    catch (error) {
-        return mapCommitIntentError(error, resolved.taskId);
-    }
-}
-function checkpointCommitIntent(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.checkpoint', () => {
-            const intent = readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            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(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') {
-                const expectedHead = intent.committedHead ?? intent.baselineHead;
-                if (input.head !== expectedHead || !input.remote || !input.ref) {
-                    return commitIntentFailed('ORCHESTRATION_COMMIT_INTENT_STATE_INVALID', 'pushed checkpoint requires matching remote, ref and HEAD', resolved.taskId);
-                }
-            }
-            const now = (options.now ?? (() => new Date().toISOString()))();
-            const updated = updateCommitIntent(resolved.taskDir, resolved.taskId, input.token, input.kind === 'committed'
-                ? { phase: 'committed', committedHead: input.head, updatedAt: now }
-                : {
-                    phase: 'pushed', committedHead: intent.committedHead ?? intent.baselineHead, updatedAt: now,
-                    pushEvidence: { remote: input.remote, ref: input.ref, head: input.head }
-                });
-            return {
-                status: 'ready', changed: true, taskId: resolved.taskId,
-                intent: commitIntentView(updated, currentHead), error: null
-            };
-        });
-    }
-    catch (error) {
-        return mapCommitIntentError(error, resolved.taskId);
-    }
-}
-function completeCommitOrchestration(resolved, intent, agent) {
-    if (intent.orchestration === null)
-        return null;
-    if (intent.orchestration.plannedReceipt.agent !== agent) {
-        return { code: 'ORCHESTRATION_PROVENANCE_MISMATCH', message: 'completion agent does not match the planned receipt' };
-    }
-    const runFile = orchestrationPath(resolved.taskDir);
-    if (!fs.existsSync(runFile)) {
-        return { code: 'ORCHESTRATION_RUN_MISSING', message: 'orchestration run disappeared' };
-    }
-    const currentBytes = fs.readFileSync(runFile, 'utf8');
-    const currentDigest = digest(currentBytes);
-    if (currentDigest === intent.orchestration.sourceRunDigest) {
-        const run = readRun(resolved.taskDir);
-        if (!run)
-            return { code: 'ORCHESTRATION_RUN_MISSING', message: 'orchestration run disappeared' };
-        const plannedRun = Object.freeze({
-            ...run,
-            pendingDelegation: intent.orchestration.plannedReceipt,
-            updatedAt: intent.orchestration.completionUpdatedAt
-        });
-        if (digest(serialize(plannedRun)) !== intent.orchestration.plannedRunDigest) {
-            return { code: 'ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', message: 'planned orchestration bytes no longer match the intent' };
-        }
-        atomicWrite(runFile, plannedRun);
-        if (digest(fs.readFileSync(runFile)) !== intent.orchestration.plannedRunDigest) {
-            return { code: 'ORCHESTRATION_COMMIT_COMPLETE_PARTIAL', message: 'orchestration completion could not be verified' };
-        }
-    }
-    else if (currentDigest !== intent.orchestration.plannedRunDigest) {
-        return { code: 'ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', message: 'orchestration state changed after commit begin' };
-    }
-    return null;
-}
-function finalizeCommitIntentUnlocked(resolved, inspection, agent, remove) {
-    if (inspection.disposition !== 'recoverable' || !inspection.intent) {
-        return commitIntentFailed(inspection.code ?? 'COMMIT_FINALIZATION_PENDING', inspection.message, resolved.taskId);
-    }
-    if (inspection.intent.orchestration !== null
-        && inspection.intent.orchestration.plannedReceipt.agent !== agent) {
-        return commitIntentFailed('ORCHESTRATION_PROVENANCE_MISMATCH', 'completion agent does not match the planned receipt', resolved.taskId);
-    }
-    const metadata = captureTaskWriteMetadata();
-    const taskPlan = planCommitTaskFinalization(resolved.taskDir, inspection, agent, metadata.timestamp);
-    const written = writeTask({
-        taskRef: resolved.taskId,
-        expectedState: 'active',
-        mutations: taskPlan.mutations
-    }, {
-        repoRoot: resolved.repoRoot,
-        metadataProvider: () => metadata
-    });
-    if (written.status === 'failed') {
-        return commitIntentFailed(written.error.code, written.error.message, resolved.taskId);
-    }
-    const orchestrationError = completeCommitOrchestration(resolved, inspection.intent, agent);
-    if (orchestrationError) {
-        return commitIntentFailed(orchestrationError.code, orchestrationError.message, resolved.taskId);
-    }
-    try {
-        remove();
-    }
-    catch (error) {
-        return commitIntentFailed('ORCHESTRATION_COMMIT_COMPLETE_PARTIAL', error instanceof Error ? error.message : String(error), resolved.taskId);
-    }
-    return { status: 'ready', changed: true, taskId: resolved.taskId, intent: null, error: null };
-}
-function completeCommitIntent(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.complete', () => {
-            readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const inspection = inspectCommitFinalization(resolved.taskDir, gitRoot, resolved.taskId);
-            return finalizeCommitIntentUnlocked(resolved, inspection, input.agent, () => {
-                removeCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            });
-        });
-    }
-    catch (error) {
-        return mapCommitIntentError(error, resolved.taskId);
-    }
-}
-function recoverCommitIntent(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.recover', () => {
-            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 };
-            }
-            if (!inspection.intentDigest) {
-                return commitIntentFailed(inspection.code ?? 'COMMIT_FINALIZATION_EVIDENCE_MISSING', inspection.message, resolved.taskId);
-            }
-            return finalizeCommitIntentUnlocked(resolved, inspection, input.agent, () => {
-                removeCommitIntentByDigest(resolved.taskDir, resolved.taskId, inspection.intentDigest);
-            });
-        });
-    }
-    catch (error) {
-        return mapCommitIntentError(error, resolved.taskId);
-    }
-}
-function abortCommitIntent(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.abort', () => {
-            const intent = readCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            const currentHead = repositoryHead(gitRoot);
-            if (intent.phase !== 'prepared'
-                || intent.pushEvidence !== null
-                || input.expectedHead !== intent.baselineHead
-                || currentHead !== intent.baselineHead) {
-                return commitIntentFailed('ORCHESTRATION_COMMIT_RECOVERY_REQUIRED', 'commit intent has side effects or repository drift', resolved.taskId);
-            }
-            removeCommitIntent(resolved.taskDir, resolved.taskId, input.token);
-            return { status: 'ready', changed: true, taskId: resolved.taskId, intent: null, error: null };
-        });
-    }
-    catch (error) {
-        return mapCommitIntentError(error, resolved.taskId);
-    }
-}
-function statusCommitIntent(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return commitIntentFailed(resolved.code, resolved.message, 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,
-        taskId: resolved.taskId,
-        intent: inspection.intent ? commitIntentView(inspection.intent, inspection.currentHead) : null,
-        finalization: commitFinalizationView(inspection),
-        error: null
-    };
-}
 function statusOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
@@ -1064,26 +562,12 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
-    if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
-        try {
-            readCommitIntent(resolved.taskDir, resolved.taskId);
-        }
-        catch (error) {
-            return failed('ORCHESTRATION_COMMIT_INTENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
-        }
-        return failed('ORCHESTRATION_COMMIT_INTENT_BUSY', 'an active commit intent blocks delegation preparation', resolved.taskId);
-    }
     if (!(options.supportsLifecycleDelegation ?? supportsLifecycleDelegation)(input.client)) {
         return failed('ORCHESTRATION_CLIENT_UNSUPPORTED', `client '${input.client}' does not support lifecycle orchestration`, resolved.taskId);
     }
     const run = readRun(resolved.taskDir);
     if (!run || run.status !== 'running')
         return failed('ORCHESTRATION_RUN_NOT_RUNNING', 'a running orchestration is required', resolved.taskId);
-    if (run.schemaVersion !== 3) {
-        return failed('ORCHESTRATION_STATE_INVALID', 'delegation preparation requires orchestration schemaVersion 3', resolved.taskId);
-    }
-    if (!isV2Policy(run.modelPolicy))
-        return failed('ORCHESTRATION_MODEL_EVIDENCE_MISSING', 'running orchestration has no persisted model policy', resolved.taskId);
     if (run.pendingDelegation)
         return failed('ORCHESTRATION_DELEGATION_BUSY', 'the run already has a pending delegation', resolved.taskId);
     const repositoryPending = matchingDelegations(() => true, options);
@@ -1112,6 +596,10 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
     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 capabilityValidationError = options.validateLifecycleCapability?.();
+    if (capabilityValidationError) {
+        return failed(capabilityValidationError.code, capabilityValidationError.message, resolved.taskId, capabilityValidationError.detail ? { detail: capabilityValidationError.detail } : {});
+    }
     let beforeFingerprint;
     try {
         beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
@@ -1137,6 +625,10 @@ function prepareOrchestrationDelegationUnlocked(taskRef, input, options = {}) {
         lifecycleProvenance: input.lifecycleProvenance ?? null,
         beforeFingerprint
     }, { id: options.id, now: options.now, monotonicNow: options.monotonicNow });
+    const capabilityError = options.consumeLifecycleCapability?.();
+    if (capabilityError) {
+        return failed(capabilityError.code, capabilityError.message, resolved.taskId, capabilityError.detail ? { detail: capabilityError.detail } : {});
+    }
     const updated = withUpdatedRun(run, {
         nextStage: next.stage,
         pendingDelegation: receipt,
@@ -1167,8 +659,8 @@ function dispatchOrchestrationDelegationUnlocked(taskRef, options = {}) {
     const run = readRun(resolved.taskDir);
     if (!run?.pendingDelegation)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
-    if (run.schemaVersion !== 3 || run.status !== 'running') {
-        return failed('ORCHESTRATION_STATE_INVALID', 'spawn dispatch requires a running schemaVersion 3 orchestration', resolved.taskId);
+    if (run.status !== 'running') {
+        return failed('ORCHESTRATION_STATE_INVALID', 'spawn dispatch requires a running orchestration', resolved.taskId);
     }
     const result = dispatchDelegation(run.pendingDelegation, {
         now: options.now,
@@ -1202,7 +694,7 @@ function matchingDelegations(predicate, options) {
         .filter((entry) => entry.isDirectory())
         .flatMap((entry) => {
         const run = readRun(path.join(activeRoot, entry.name));
-        if (run?.schemaVersion !== 3 || run.status !== 'running' || !run.pendingDelegation)
+        if (!run || run.status !== 'running' || !run.pendingDelegation)
             return [];
         const receipt = run.pendingDelegation;
         return predicate(receipt)
@@ -1240,9 +732,9 @@ function activateMatchingOrchestrationDelegation(client, event, options = {}) {
             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.spawnMode ?? null) === (event.spawnMode ?? null)
+            && (receipt.actualModel ?? null) === foldBlankToNull(event.actualModel)
+            && (receipt.actualReasoningEffort ?? null) === foldBlankToNull(event.actualReasoningEffort)
             && receipt.modelFallbackReason === (event.modelFallbackReason ?? null)
             && receipt.reasoningEffortFallbackReason === (event.reasoningEffortFallbackReason ?? null)
             && receipt.hostEvidence?.hookDefinitionHash === event.hostEvidence?.hookDefinitionHash;
@@ -1287,7 +779,11 @@ function sealMatchingOrchestrationDelegation(client, event, options = {}) {
             childId: event.childId,
             exitCode: 0,
             afterFingerprint,
-            changedPaths
+            changedPaths,
+            actualModel: event.actualModel,
+            actualReasoningEffort: event.actualReasoningEffort,
+            modelFallbackReason: event.modelFallbackReason,
+            reasoningEffortFallbackReason: event.reasoningEffortFallbackReason
         }, options);
     }
     catch (error) {
@@ -1358,8 +854,6 @@ function activateOrchestrationDelegation(taskRef, event, options = {}) {
     const run = readRun(resolved.taskDir);
     if (!run?.pendingDelegation)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
-    if (run.schemaVersion !== 3)
-        return failed('ORCHESTRATION_STATE_INVALID', 'active delegation requires schemaVersion 3', resolved.taskId);
     if (run.status !== 'running') {
         return { status: run.status, changed: false, taskId: resolved.taskId, run, next: null, error: null };
     }
@@ -1387,9 +881,6 @@ async function awaitOrchestrationDelegationActivation(taskRef, event, options =
         if (!run?.pendingDelegation) {
             return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
         }
-        if (run.schemaVersion !== 3) {
-            return failed('ORCHESTRATION_STATE_INVALID', 'activation barrier requires schemaVersion 3', resolved.taskId);
-        }
         const receipt = run.pendingDelegation;
         const matches = receipt.stage === event.stage
             && receipt.round === event.round
@@ -1440,16 +931,13 @@ function recoverPreparedOrchestrationDelegation(taskRef, options = {}) {
             const activeLifecycleEvidence = options.hasActiveLifecycleEvidence?.(receipt)
                 ?? (receipt.client === 'codex'
                     && receipt.lifecycleProvenance
-                    && hasActiveCodexLifecycleEvidence(path.join(resolved.repoRoot, '.agents', 'workspace', '.runtime', 'codex-lifecycle'), {
+                    && 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);
             }
-            if (fs.existsSync(commitIntentPath(resolved.taskDir))) {
-                return failed('ORCHESTRATION_PREPARED_RECOVERY_UNSAFE', 'active commit intent blocks prepared recovery', resolved.taskId);
-            }
             const current = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
                 gitRoot: gitRootFor(resolved.repoRoot, options),
                 stateRoot: resolved.repoRoot,
@@ -1485,8 +973,6 @@ function completeOrchestrationStage(taskRef, event, options = {}) {
     const run = readRun(resolved.taskDir);
     if (!run)
         return { status: 'running', changed: false, taskId: resolved.taskId, run: null, next: null, error: null };
-    if (run.schemaVersion !== 3)
-        return failed('ORCHESTRATION_STATE_INVALID', 'stage completion requires schemaVersion 3', resolved.taskId);
     if (!run.pendingDelegation)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'active run has no pending delegation', resolved.taskId);
     const result = completeDelegationStage(run.pendingDelegation, event);
@@ -1509,8 +995,6 @@ function inspectOrchestrationStage(taskRef, event, options = {}) {
     }
     if (!run)
         return failed('ORCHESTRATION_RUN_MISSING', 'no orchestration run exists', resolved.taskId);
-    if (run.schemaVersion !== 3)
-        return failed('ORCHESTRATION_STATE_INVALID', 'stage inspection requires schemaVersion 3', resolved.taskId);
     const receipt = run.pendingDelegation;
     if (!receipt
         || receipt.status !== 'activated'
@@ -1555,8 +1039,6 @@ function sealOrchestrationDelegation(taskRef, event, options = {}) {
     const run = readRun(resolved.taskDir);
     if (!run?.pendingDelegation)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
-    if (run.schemaVersion !== 3)
-        return failed('ORCHESTRATION_STATE_INVALID', 'delegation sealing requires schemaVersion 3', resolved.taskId);
     const result = sealDelegation(run.pendingDelegation, event, { now: options.now });
     if (!result.ok)
         return pauseOrchestration(taskRef, result.code, result.message, true, options);
@@ -1571,8 +1053,6 @@ function advanceOrchestration(taskRef, options = {}) {
     const run = readRun(resolved.taskDir);
     if (!run?.pendingDelegation)
         return failed('ORCHESTRATION_DELEGATION_MISSING', 'no pending delegation exists', resolved.taskId);
-    if (run.schemaVersion !== 3)
-        return failed('ORCHESTRATION_STATE_INVALID', 'orchestration advance requires schemaVersion 3', resolved.taskId);
     const result = consumeDelegation(run.pendingDelegation, { now: options.now });
     if (!result.ok)
         return pauseOrchestration(taskRef, result.code, result.message, true, options);
@@ -1601,5 +1081,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, abortCommitIntent, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, commitOrchestrationStageCompletion, completeCommitIntent, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, orchestrationPath, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverCommitIntent, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt };
+export { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, awaitOrchestrationDelegationActivation, advanceOrchestration, beginOrResumeOrchestration, commitOrchestrationStageCompletion, completeOrchestrationStage, dispatchOrchestrationDelegation, inspectOrchestrationStage, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, OrchestrationStateError, orchestrationPath, pauseMatchingOrchestrationDelegation, pauseOrchestration, planOrchestrationStageCompletion, prepareOrchestrationDelegation, readRun, reconcileMatchingOrchestrationDelegation, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence, sealOrchestrationDelegation, statusOrchestration, };
 //# sourceMappingURL=orchestration.js.map