@fitlab-ai/agent-infra 0.9.8 → 0.9.9

package/lib/task/orchestration.ts

@@ -1,7 +1,6 @@
 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.ts';
 import { parseReviewSummary } from './review-artifacts.ts';
@@ -15,6 +14,7 @@ import {
   consumeDelegation,
   dispatchDelegation,
   foldBlankToNull,
+  isDelegationReceipt,
   managedDelegationRole,
   prepareDelegation,
   sealDelegation
@@ -49,75 +49,17 @@ import type { WorkspaceSnapshotContext } from './workspace-snapshot.ts';
 import { assertGitRepositoryBinding } from '../git/worktree-identity.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { hasActiveCodexLifecycleEvidence } from '../agent-clients/adapters/codex-lifecycle/store.ts';
-import {
-  CommitIntentError,
-  commitIntentPath,
-  createCommitIntent,
-  digest,
-  readCommitIntent,
-  removeCommitIntent,
-  removeCommitIntentByDigest,
-  serialize,
-  updateCommitIntent
-} from './commit-intent.ts';
-import type { CommitIntent, PushEvidence } from './commit-intent.ts';
-import {
-  inspectCommitFinalization,
-  planCommitTaskFinalization
-} from './commit-finalization.ts';
-import type { CommitFinalizationInspection } from './commit-finalization.ts';
-import { captureTaskWriteMetadata, writeTask } from './write.ts';
-import {
-  appendActivityEntry,
-  commitAttemptStartedNote,
-  locateActivityLog,
-  pairEntries
-} from './activity-log.ts';
+import type { CodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
 
 type OrchestrationStatus = 'running' | 'paused' | 'completed';
-type LegacyOrchestrationModelPolicy = Readonly<{
-  executor: string;
-  reviewer: string;
-}>;
 type ModelPolicySource = Readonly<{
   kind: 'explicit' | 'project-config';
   client: AgentClientId;
   resolvedAt: string;
 }>;
-type ModelPolicyRecovery = Readonly<{
-  code: 'MODEL_POLICY_SUPPLEMENTED';
-  recoveredAt: string;
-  previousSchemaVersion: 1;
-  previousStatus: OrchestrationStatus;
-  previousPause: Readonly<{ code: string; message: string; recoverable: boolean }> | null;
-  policySource: ModelPolicySource;
-  receiptCount: 0;
-  pendingDelegation: false;
-  resultingStatus: OrchestrationStatus;
-}>;
-type ClientCapabilityRecovery = Readonly<{
-  code: 'CLIENT_CAPABILITY_ENABLED';
-  recoveredAt: string;
-  previousSchemaVersion: 2;
-  previousStatus: 'paused';
-  previousPause: Readonly<{ code: 'ORCHESTRATION_CLIENT_UNSUPPORTED'; message: string; recoverable: boolean }>;
-  client: 'codex';
-  guards: Readonly<{
-    stepCount: 0;
-    nextStage: null;
-    baselineEmpty: true;
-    receiptCount: 0;
-    pendingDelegation: false;
-    commitAuthorizationUnused: true;
-    completionEvidenceAbsent: true;
-    commitIntentAbsent: true;
-  }>;
-  resultingStatus: 'running';
-}>;
 type ClaudeCodeCapabilityRecovery = Readonly<{
-  code: 'CLIENT_CAPABILITY_ENABLED_NO_MIGRATION';
+  code: 'CLIENT_CAPABILITY_ENABLED';
   recoveredAt: string;
-  previousSchemaVersion: 3;
   previousStatus: 'paused';
   previousPause: Readonly<{ code: 'ORCHESTRATION_CLIENT_UNSUPPORTED'; message: string; recoverable: boolean }>;
   client: 'claude-code';
@@ -129,29 +71,10 @@ type ClaudeCodeCapabilityRecovery = Readonly<{
     pendingDelegation: false;
     commitAuthorizationUnused: true;
     completionEvidenceAbsent: true;
-    commitIntentAbsent: true;
   }>;
   resultingStatus: 'running';
 }>;
-type SchemaMigrationRecovery = Readonly<{
-  code: 'SCHEMA_V3_MIGRATED';
-  recoveredAt: string;
-  previousSchemaVersion: 2;
-  previousStatus: 'paused';
-  previousPause: Readonly<{ code: string; message: string; recoverable: boolean }>;
-  guards: Readonly<{
-    stepCount: 0;
-    nextStage: null;
-    baselineEmpty: true;
-    receiptCount: 0;
-    pendingDelegation: false;
-    commitAuthorizationUnused: true;
-    completionEvidenceAbsent: true;
-    commitIntentAbsent: true;
-  }>;
-  resultingStatus: 'running';
-}>;
-type OrchestrationRecovery = ModelPolicyRecovery | ClientCapabilityRecovery | ClaudeCodeCapabilityRecovery | SchemaMigrationRecovery;
+type OrchestrationRecovery = ClaudeCodeCapabilityRecovery;
 type CleanCompletionEvidence = Readonly<{
   kind: 'reviewed-head-clean';
   observedAt: string;
@@ -163,22 +86,21 @@ type CleanCompletionEvidence = Readonly<{
   prHead: string;
 }>;
 type OrchestrationRun = Readonly<{
-  schemaVersion: 1 | 2 | 3;
   taskId: string;
   runId: string;
   status: OrchestrationStatus;
   nextStage: DelegationStage | null;
   stepCount: number;
   maxSteps: number;
-  modelPolicy?: OrchestrationModelPolicy | LegacyOrchestrationModelPolicy;
-  modelPolicySource?: ModelPolicySource;
-  recoveryHistory?: readonly OrchestrationRecovery[];
+  modelPolicy: OrchestrationModelPolicy;
+  modelPolicySource: ModelPolicySource;
+  recoveryHistory: readonly OrchestrationRecovery[];
   baseline: string;
   pendingDelegation: DelegationReceipt | null;
   receipts: readonly DelegationReceipt[];
   pause: Readonly<{ code: string; message: string; recoverable: boolean }> | null;
   commitAuthorization: Readonly<{ issuedAt: string | null; consumedAt: string | null }>;
-  completionEvidence?: CleanCompletionEvidence | null;
+  completionEvidence: CleanCompletionEvidence | null;
   createdAt: string;
   updatedAt: string;
 }>;
@@ -203,6 +125,7 @@ type OrchestrationResult = Readonly<{
     client?: AgentClientId;
     missingFields?: readonly string[];
     modelSelectionContext?: ReturnType<typeof getAgentClientModelSelection>;
+    detail?: CodexCapabilityProvenanceDetail;
   }> | null;
 }>;
 type OrchestrationStageIdentity = Readonly<{
@@ -239,40 +162,14 @@ type OrchestrationOptions = {
   }>;
   diffWorkspace?: (repoRoot: string, before: string, after: string) => string[];
   supportsLifecycleDelegation?: (client: AgentClientId) => boolean;
+  validateLifecycleCapability?: () => Exclude<OrchestrationResult['error'], null> | null;
+  consumeLifecycleCapability?: () => Exclude<OrchestrationResult['error'], null> | null;
   token?: () => string;
   monotonicNow?: () => number;
   sleep?: (milliseconds: number) => Promise<void>;
   hasActiveLifecycleEvidence?: (receipt: DelegationReceipt) => boolean;
 };
 
-type CommitIntentResult = Readonly<{
-  status: 'ready' | 'failed';
-  changed: boolean;
-  taskId: string | null;
-  intent: Readonly<{
-    mode: CommitIntent['mode'];
-    phase: CommitIntent['phase'];
-    baselineHead: string;
-    currentHead: string;
-    committedHead: string | null;
-    pushEvidence: PushEvidence | null;
-    runId: string | null;
-    receiptId: string | null;
-  }> | null;
-  finalization?: Readonly<{
-    disposition: CommitFinalizationInspection['disposition'];
-    code: CommitFinalizationInspection['code'];
-    message: string;
-    currentHead: string;
-    committedHead: string | null;
-    needsAnchor: boolean;
-    needsLog: boolean;
-    attempt: Readonly<{ attempt: string; baseline: string; agent: string }> | null;
-  }>;
-  token?: string;
-  error: Readonly<{ code: string; message: string }> | null;
-}>;
-
 function supportsLifecycleDelegation(client: AgentClientId): boolean {
   return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
     && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -284,24 +181,147 @@ function orchestrationPath(taskDir: string): string {
   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 {
+  readonly code = 'ORCHESTRATION_STATE_INVALID';
+  readonly taskId: string | null;
+
+  constructor(taskId: string | null = null) {
+    super(ORCHESTRATION_STATE_INVALID_MESSAGE);
+    this.name = 'OrchestrationStateError';
+    this.taskId = taskId;
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: unknown, keys: readonly string[]): value is Record<string, unknown> {
+  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: unknown): value is string {
+  return typeof value === 'string' && value.length > 0 && value.trim() === value;
+}
+
+function nullableText(value: unknown): value is string | null {
+  return value === null || exactText(value);
+}
+
+function isPause(value: unknown): value is NonNullable<OrchestrationRun['pause']> {
+  return hasExactKeys(value, ['code', 'message', 'recoverable'])
+    && exactText(value.code)
+    && exactText(value.message)
+    && typeof value.recoverable === 'boolean';
+}
+
+function isModelPolicySource(value: unknown): value is ModelPolicySource {
+  return hasExactKeys(value, ['kind', 'client', 'resolvedAt'])
+    && ['explicit', 'project-config'].includes(value.kind as string)
+    && isAgentClientId(value.client)
+    && exactText(value.resolvedAt);
+}
+
+function isModelPolicy(value: unknown): value is OrchestrationModelPolicy {
+  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'
+] as const;
+
+function isRecovery(value: unknown): value is OrchestrationRecovery {
+  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: unknown): value is CleanCompletionEvidence {
+  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 as number) > 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'
+] as const;
+
+function parseOrchestrationRun(value: unknown, expectedTaskId?: string): OrchestrationRun {
+  if (!hasExactKeys(value, ORCHESTRATION_RUN_KEYS)
+    || !exactText(value.taskId)
+    || (expectedTaskId !== undefined && value.taskId !== expectedTaskId)
+    || !exactText(value.runId)
+    || !['running', 'paused', 'completed'].includes(value.status as string)
+    || !(value.nextStage === null || ['analysis', 'review-analysis', 'plan', 'review-plan', 'code', 'review-code', 'commit'].includes(value.nextStage as string))
+    || !Number.isSafeInteger(value.stepCount) || (value.stepCount as number) < 0
+    || !Number.isSafeInteger(value.maxSteps) || (value.maxSteps as number) < 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 as OrchestrationRun;
+}
+
 function readRun(taskDir: string): OrchestrationRun | null {
   const file = orchestrationPath(taskDir);
   if (!fs.existsSync(file)) return null;
-  const run = JSON.parse(fs.readFileSync(file, 'utf8')) as OrchestrationRun;
-  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: string, value: unknown): void {
@@ -327,79 +347,11 @@ function failed(
   return { status: 'failed', changed: false, taskId, run: null, next: null, error: { code, message, ...details } };
 }
 
-function commitIntentFailed(code: string, message: string, taskId: string | null = null): CommitIntentResult {
-  return { status: 'failed', changed: false, taskId, intent: null, error: { code, message } };
-}
-
-function repositoryHead(repoRoot: string): string {
-  return execFileSync('git', ['rev-parse', 'HEAD'], {
-    cwd: repoRoot,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe']
-  }).trim();
-}
-
 function gitRootFor(stateRoot: string, options: OrchestrationOptions): string {
   if (!options.gitWorktreeRoot) return stateRoot;
   return assertGitRepositoryBinding(stateRoot, options.gitWorktreeRoot).worktreeRoot;
 }
 
-function isAncestor(repoRoot: string, ancestor: string, descendant: string): boolean {
-  return spawnSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
-    cwd: repoRoot,
-    stdio: 'ignore'
-  }).status === 0;
-}
-
-function commitIntentView(intent: CommitIntent, currentHead: string): NonNullable<CommitIntentResult['intent']> {
-  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: CommitFinalizationInspection): NonNullable<CommitIntentResult['finalization']> {
-  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: OrchestrationRun | null, taskId: string): run is OrchestrationRun {
-  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: unknown, taskId: string | null): CommitIntentResult {
-  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: unknown): value is string {
   return typeof value === 'string' && value.length > 0 && value.trim() === value;
 }
@@ -424,12 +376,8 @@ function sameModelPolicy(left: OrchestrationModelPolicy, right: OrchestrationMod
     && left.reviewer.reasoningEffort === right.reviewer.reasoningEffort;
 }
 
-function isV2Policy(policy: OrchestrationRun['modelPolicy']): policy is OrchestrationModelPolicy {
-  return typeof policy?.executor === 'object' && typeof policy?.reviewer === 'object';
-}
-
 function rolePolicy(run: OrchestrationRun, role: DelegationRole): OrchestrationRolePolicy | null {
-  return isV2Policy(run.modelPolicy) ? run.modelPolicy[role] : null;
+  return run.modelPolicy[role];
 }
 
 function resolveProjectPolicy(repoRoot: string, client: AgentClientId): OrchestrationModelPolicy | undefined {
@@ -439,26 +387,8 @@ function resolveProjectPolicy(repoRoot: string, client: AgentClientId): Orchestr
   return normalizeAgentClients(raw).state[client].orchestration;
 }
 
-function canRecoverCodexUnsupportedPause(run: OrchestrationRun, taskDir: string): boolean {
-  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 canRecoverClaudeCodeUnsupportedPause(run: OrchestrationRun, taskDir: string): boolean {
-  return run.schemaVersion === 3
-    && run.status === 'paused'
+  return run.status === 'paused'
     && run.pause?.code === 'ORCHESTRATION_CLIENT_UNSUPPORTED'
     && run.modelPolicySource?.client === 'claude-code'
     && run.stepCount === 0
@@ -469,23 +399,7 @@ function canRecoverClaudeCodeUnsupportedPause(run: OrchestrationRun, taskDir: st
     && run.commitAuthorization?.issuedAt === null
     && run.commitAuthorization?.consumedAt === null
     && run.completionEvidence == null
-    && !fs.existsSync(commitIntentPath(taskDir))
-    && (run.recoveryHistory ?? []).length === 0;
-}
-
-function canMigrateRecoverableV2Pause(run: OrchestrationRun, taskDir: string): boolean {
-  return run.schemaVersion === 2
-    && run.status === 'paused'
-    && run.pause?.recoverable === true
-    && 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.length === 0;
 }
 
 function beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
@@ -501,235 +415,56 @@ function beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptio
     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 as OrchestrationModelPolicy, 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 (existing.modelPolicySource.client === 'claude-code') {
-          if (!canRecoverClaudeCodeUnsupportedPause(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 as ClaudeCodeCapabilityRecovery['previousPause'];
-          const recovery: ClaudeCodeCapabilityRecovery = {
-            code: 'CLIENT_CAPABILITY_ENABLED_NO_MIGRATION',
-            recoveredAt: now,
-            previousSchemaVersion: 3,
-            previousStatus: 'paused',
-            previousPause,
-            client: 'claude-code',
-            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 (!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 as ClientCapabilityRecovery['previousPause'];
-        const recovery: ClientCapabilityRecovery = {
-          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: SchemaMigrationRecovery | null = 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: OrchestrationModelPolicy | undefined = options.modelPolicy;
-    let sourceKind: ModelPolicySource['kind'] = '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) 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 };
+    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 now = (options.now ?? (() => new Date().toISOString()))();
+      const recovery: ClaudeCodeCapabilityRecovery = {
+        code: 'CLIENT_CAPABILITY_ENABLED',
+        recoveredAt: now,
+        previousStatus: 'paused',
+        previousPause: existing.pause as ClaudeCodeCapabilityRecovery['previousPause'],
+        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: ModelPolicySource = { kind: sourceKind, client: options.client, resolvedAt: now };
-    const clearsModelPause = existing.pause?.code === 'ORCHESTRATION_MODEL_EVIDENCE_MISSING';
-    const resultingStatus = clearsModelPause ? 'running' : existing.status;
-    const recovery: OrchestrationRecovery = {
-      code: 'MODEL_POLICY_SUPPLEMENTED',
-      recoveredAt: now,
-      previousSchemaVersion: 1,
-      previousStatus: existing.status,
-      previousPause: existing.pause,
-      policySource: source,
-      receiptCount: 0,
-      pendingDelegation: false,
-      resultingStatus
-    };
-    const recovered: OrchestrationRun = 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;
@@ -751,7 +486,6 @@ function beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptio
   const now = (options.now ?? (() => new Date().toISOString()))();
   const source: ModelPolicySource = { kind: sourceKind, client: options.client, resolvedAt: now };
   const run: OrchestrationRun = {
-    schemaVersion: 3,
     taskId: resolved.taskId,
     runId: (options.id ?? randomUUID)(),
     status: 'running',
@@ -998,488 +732,6 @@ function routeOrchestration(taskRef: string, options: OrchestrationOptions = {})
   return { status: 'running', changed: false, taskId: resolved.taskId, run, next, error: null };
 }
 
-function appendCommitActivity(
-  resolved: Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>,
-  step: string,
-  agent: string,
-  note: string
-): Readonly<{ code: string; message: string }> | null {
-  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: string,
-  input: Readonly<{ agent: string }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: string,
-  input: Readonly<{ attempt: string; agent: string; code: string }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: string,
-  input: Readonly<{ agent: string; orchestrated: boolean; baselineHead: string; attempt: string }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: OrchestrationRun | null = null;
-      let sourceRunBytes: string | null = 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: string, message: string): CommitIntentResult => {
-        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: CommitIntent['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: string,
-  input: Readonly<{
-    token: string;
-    kind: 'committed' | 'pushed';
-    head: string;
-    remote?: string;
-    ref?: string;
-  }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>,
-  intent: CommitIntent,
-  agent: string
-): Readonly<{ code: string; message: string }> | null {
-  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: OrchestrationRun = 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: Extract<ReturnType<typeof resolveTaskRef>, { ok: true }>,
-  inspection: CommitFinalizationInspection,
-  agent: string,
-  remove: () => void
-): CommitIntentResult {
-  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: string,
-  input: Readonly<{ token: string; agent: string }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: string,
-  input: Readonly<{ agent: string }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: string,
-  input: Readonly<{ token: string; expectedHead: string }>,
-  options: OrchestrationOptions = {}
-): CommitIntentResult {
-  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: string, options: OrchestrationOptions = {}): CommitIntentResult {
-  const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
-  if (!resolved.ok) return commitIntentFailed(resolved.code, resolved.message, resolved.taskId);
-  let gitRoot: string;
-  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: string, options: OrchestrationOptions = {}): OrchestrationResult {
   const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
@@ -1500,27 +752,11 @@ function prepareOrchestrationDelegationUnlocked(
 ): OrchestrationResult {
   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);
   if (repositoryPending.length > 0) {
@@ -1546,6 +782,15 @@ function prepareOrchestrationDelegationUnlocked(
   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: string;
   try {
     beforeFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
@@ -1570,6 +815,15 @@ function prepareOrchestrationDelegationUnlocked(
     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,
@@ -1619,8 +873,8 @@ function dispatchOrchestrationDelegationUnlocked(
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
   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,
@@ -1667,7 +921,7 @@ function matchingDelegations(
     .filter((entry) => entry.isDirectory())
     .flatMap((entry) => {
       const run = readRun(path.join(activeRoot, entry.name));
-      if (run?.schemaVersion !== 3 || run.status !== 'running' || !run.pendingDelegation) return [];
+      if (!run || run.status !== 'running' || !run.pendingDelegation) return [];
       const receipt = run.pendingDelegation;
       return predicate(receipt)
         ? [{ taskId: entry.name, run }]
@@ -1920,7 +1174,6 @@ function activateOrchestrationDelegation(
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
   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 };
   }
@@ -1951,9 +1204,6 @@ async function awaitOrchestrationDelegationActivation(
     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
@@ -2051,9 +1301,6 @@ function recoverPreparedOrchestrationDelegation(
           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,
@@ -2093,7 +1340,6 @@ function completeOrchestrationStage(
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
   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);
   if (!result.ok) return pauseOrchestration(taskRef, result.code, result.message, true, options);
@@ -2116,7 +1362,6 @@ function inspectOrchestrationStage(
     return failed('ORCHESTRATION_STATE_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId);
   }
   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
@@ -2175,7 +1420,6 @@ function sealOrchestrationDelegation(
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
   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);
   const updated = withUpdatedRun(run, { pendingDelegation: result.receipt });
@@ -2188,7 +1432,6 @@ function advanceOrchestration(taskRef: string, options: OrchestrationOptions = {
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
   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);
   const completed = result.receipt.stage === 'commit';
@@ -2227,17 +1470,14 @@ export {
   activateOrchestrationDelegation,
   awaitOrchestrationDelegationActivation,
   advanceOrchestration,
-  abortCommitIntent,
-  beginCommitIntent,
   beginOrResumeOrchestration,
-  checkpointCommitIntent,
   commitOrchestrationStageCompletion,
-  completeCommitIntent,
   completeOrchestrationStage,
   dispatchOrchestrationDelegation,
   inspectOrchestrationStage,
   hasActivatableOrchestrationDelegation,
   hasSealableOrchestrationDelegation,
+  OrchestrationStateError,
   orchestrationPath,
   pauseMatchingOrchestrationDelegation,
   pauseOrchestration,
@@ -2245,19 +1485,14 @@ export {
   prepareOrchestrationDelegation,
   readRun,
   reconcileMatchingOrchestrationDelegation,
-  recoverCommitIntent,
   recoverPreparedOrchestrationDelegation,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealMatchingOrchestrationDelegationWithHostEvidence,
   sealOrchestrationDelegation,
-  startCommitAttempt,
-  statusCommitIntent,
   statusOrchestration,
-  terminateCommitAttempt
 };
 export type {
-  CommitIntentResult,
   OrchestrationCompletionPlanResult,
   OrchestrationModelPolicy,
   OrchestrationNext,