@fitlab-ai/agent-infra 0.9.5 → 0.9.6

package/lib/task/orchestration.ts

@@ -74,7 +74,7 @@ type ModelPolicySource = Readonly<{
   client: AgentClientId;
   resolvedAt: string;
 }>;
-type OrchestrationRecovery = Readonly<{
+type ModelPolicyRecovery = Readonly<{
   code: 'MODEL_POLICY_SUPPLEMENTED';
   recoveredAt: string;
   previousSchemaVersion: 1;
@@ -85,6 +85,26 @@ type OrchestrationRecovery = Readonly<{
   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 OrchestrationRecovery = ModelPolicyRecovery | ClientCapabilityRecovery;
 type CleanCompletionEvidence = Readonly<{
   kind: 'reviewed-head-clean';
   observedAt: string;
@@ -369,6 +389,23 @@ 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 beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptions = {}): OrchestrationResult {
   const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
@@ -415,6 +452,39 @@ function beginOrResumeOrchestration(taskRef: string, options: OrchestrationOptio
           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 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, {
+          status: 'running',
+          pause: null,
+          recoveryHistory: Object.freeze([...(existing.recoveryHistory ?? []), recovery])
+        }, () => now);
+        saveRun(resolved.taskDir, resumed);
+        return { status: 'running', changed: true, taskId: resolved.taskId, run: resumed, next: null, error: null };
+      }
       if (existing.status === 'paused' && existing.pause?.recoverable && existing.pendingDelegation === null) {
         const resumed = withUpdatedRun(existing, { status: 'running', pause: null });
         saveRun(resolved.taskDir, resumed);
@@ -1377,7 +1447,7 @@ function matchingDelegations(
     .filter((entry) => entry.isDirectory())
     .flatMap((entry) => {
       const run = readRun(path.join(activeRoot, entry.name));
-      if (!run?.pendingDelegation) return [];
+      if (run?.status !== 'running' || !run.pendingDelegation) return [];
       const receipt = run.pendingDelegation;
       return predicate(receipt)
         ? [{ taskId: entry.name, run }]
@@ -1411,13 +1481,44 @@ function activateMatchingOrchestrationDelegation(
     (receipt) => receipt.status === 'prepared',
     options
   );
-  if ('status' in matched) return matched;
+  if ('status' in matched) {
+    if (matched.error?.code !== 'ORCHESTRATION_DELEGATION_MISSING') return matched;
+    const replay = uniqueMatchingDelegation(
+      client,
+      (receipt) => receipt.childId === event.childId && ['activated', 'stage-completed'].includes(receipt.status),
+      options
+    );
+    if ('status' in replay) return matched;
+    const receipt = replay.run.pendingDelegation!;
+    const sameEvidence = receipt.parentId === event.parentId
+      && receipt.spawnMode === event.spawnMode
+      && receipt.actualModel === event.actualModel
+      && receipt.actualReasoningEffort === event.actualReasoningEffort
+      && receipt.modelFallbackReason === (event.modelFallbackReason ?? null)
+      && receipt.reasoningEffortFallbackReason === (event.reasoningEffortFallbackReason ?? null)
+      && receipt.hostEvidence?.hookDefinitionHash === event.hostEvidence?.hookDefinitionHash;
+    if (!sameEvidence) {
+      return pauseOrchestration(replay.taskId, 'DELEGATION_REPLAY_CONFLICT', 'replayed native start evidence conflicts with the active receipt', true, options);
+    }
+    return { status: replay.run.status, changed: false, taskId: replay.taskId, run: replay.run, next: null, error: null };
+  }
   if (matched.run.receipts.some((receipt) => receipt.childId === event.childId)) {
     return pauseOrchestration(matched.taskId, 'DELEGATION_IDENTITY_REUSED', 'native child identity was already used by this run', true, options);
   }
   return activateOrchestrationDelegation(matched.taskId, event, options);
 }
 
+function pauseMatchingOrchestrationDelegation(
+  client: AgentClientId,
+  code: string,
+  message: string,
+  options: OrchestrationOptions = {}
+): OrchestrationResult {
+  const matched = uniqueMatchingDelegation(client, () => true, options);
+  if ('status' in matched) return matched;
+  return pauseOrchestration(matched.taskId, code, message, true, options);
+}
+
 function sealMatchingOrchestrationDelegation(
   client: AgentClientId,
   event: Readonly<{ nativeAgent: string; childId: string }>,
@@ -1462,6 +1563,96 @@ function sealMatchingOrchestrationDelegation(
   }
 }
 
+function sealMatchingOrchestrationDelegationWithHostEvidence(
+  client: AgentClientId,
+  event: Readonly<{ nativeAgent: string; childId: string }>,
+  consumeEvidence: (receipt: DelegationReceipt) => Readonly<{
+    stopRevision: number;
+    consumer: string;
+    consumedAt: string;
+  }>,
+  options: OrchestrationOptions = {}
+): OrchestrationResult {
+  const role = managedDelegationRole(event.nativeAgent);
+  if (!role) return failed('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
+  const matched = uniqueMatchingDelegation(
+    client,
+    (receipt) => (
+      (receipt.status === 'stage-completed' || receipt.status === 'sealed')
+      && receipt.childId === event.childId
+    ),
+    options
+  );
+  if ('status' in matched) return matched;
+  const receipt = matched.run.pendingDelegation!;
+  if (receipt.status === 'sealed') {
+    return reconcileMatchingOrchestrationDelegation(client, event.childId, options);
+  }
+  if (receipt.role !== role) {
+    return pauseOrchestration(matched.taskId, 'DELEGATION_ROLE_MISMATCH', `managed role ${role} does not match ${receipt.role}`, true, options);
+  }
+  const repoRoot = options.repoRoot ?? process.cwd();
+  try {
+    const gitRoot = gitRootFor(repoRoot, options);
+    const snapshotTaskId = receipt.workspaceSnapshotScope === 'task' ? receipt.taskId : null;
+    const afterFingerprint = (options.captureWorkspace ?? captureWorkspaceSnapshot)({
+      gitRoot,
+      stateRoot: repoRoot,
+      taskId: snapshotTaskId
+    });
+    const changedPaths = (options.diffWorkspace ?? diffWorkspaceSnapshots)(gitRoot, receipt.beforeFingerprint, afterFingerprint);
+    const baseEvent = { childId: event.childId, exitCode: 0, afterFingerprint, changedPaths };
+    const validated = sealDelegation(receipt, baseEvent, { now: options.now });
+    if (!validated.ok) {
+      return pauseOrchestration(matched.taskId, validated.code, validated.message, true, options);
+    }
+    const hostEvidence = consumeEvidence(receipt);
+    const sealed = sealDelegation(receipt, { ...baseEvent, hostEvidence }, { now: options.now });
+    if (!sealed.ok) return pauseOrchestration(matched.taskId, sealed.code, sealed.message, true, options);
+    const resolved = resolveTaskRef(matched.taskId, { repoRoot });
+    if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
+    const updated = withUpdatedRun(matched.run, { pendingDelegation: sealed.receipt }, options.now);
+    saveRun(resolved.taskDir, updated);
+    return { status: 'running', changed: true, taskId: matched.taskId, run: updated, next: null, error: null };
+  } catch (error) {
+    return pauseOrchestration(
+      matched.taskId,
+      'ORCHESTRATION_CODEX_EVIDENCE_FAILED',
+      error instanceof Error ? error.message : String(error),
+      true,
+      options
+    );
+  }
+}
+
+function reconcileMatchingOrchestrationDelegation(
+  client: AgentClientId,
+  childId: string,
+  options: OrchestrationOptions = {}
+): OrchestrationResult {
+  const matched = uniqueMatchingDelegation(
+    client,
+    (receipt) => receipt.childId === childId,
+    options
+  );
+  if ('status' in matched) return matched;
+  const receipt = matched.run.pendingDelegation!;
+  if (
+    receipt.status !== 'sealed'
+    || receipt.hostEvidence?.consumer !== receipt.id
+    || receipt.hostEvidence.consumedAt === null
+  ) {
+    return pauseOrchestration(
+      matched.taskId,
+      'ORCHESTRATION_CODEX_RECONCILIATION_FAILED',
+      'Codex native spawn did not produce one sealed receipt with consumed host evidence',
+      true,
+      options
+    );
+  }
+  return { status: matched.run.status, changed: false, taskId: matched.taskId, run: matched.run, next: null, error: null };
+}
+
 function activateOrchestrationDelegation(
   taskRef: string,
   event: Parameters<typeof activateDelegation>[1],
@@ -1628,13 +1819,16 @@ export {
   completeOrchestrationStage,
   inspectOrchestrationStage,
   orchestrationPath,
+  pauseMatchingOrchestrationDelegation,
   pauseOrchestration,
   planOrchestrationStageCompletion,
   prepareOrchestrationDelegation,
   readRun,
+  reconcileMatchingOrchestrationDelegation,
   recoverCommitIntent,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
+  sealMatchingOrchestrationDelegationWithHostEvidence,
   sealOrchestrationDelegation,
   startCommitAttempt,
   statusCommitIntent,
@@ -1650,5 +1844,6 @@ export type {
   OrchestrationRun,
   OrchestrationStageCompletion,
   OrchestrationStageIdentity,
-  OrchestrationStatus
+  OrchestrationStatus,
+  OrchestrationOptions
 };

package/lib/task/verification-engine.ts

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

package/lib/task/verification.ts

@@ -11,7 +11,7 @@ import type { TaskWorkspaceState } from './resolve-ref.ts';
 type VerificationEvent =
   | 'analyze.awaiting-input' | 'analyze.completed'
   | 'review-analysis.completed' | 'plan.completed' | 'review-plan.completed'
-  | 'code.completed' | 'review-code.completed' | 'manual-validation.completed'
+  | 'code.completed' | 'review-code.completed' | 'manual-validation.completed' | 'validation-run.completed'
   | 'block-task.completed' | 'cancel-task.completed' | 'commit.completed'
   | 'complete-task.preflight' | 'complete-task.completed'
   | 'create-pr.completed' | 'create-task.completed'
@@ -62,6 +62,7 @@ const VERIFICATION_CATALOG: Readonly<Record<VerificationEvent, VerificationSpec>
   'code.completed': gate('code-task', 'active', 'code'),
   'review-code.completed': gate('review-code', 'active', 'review-code'),
   'manual-validation.completed': gate('complete-manual-validation', 'active', 'manual-validation'),
+  'validation-run.completed': gate('run-manual-validation', 'active', 'validation-run'),
   'block-task.completed': gate('block-task', 'blocked'),
   'cancel-task.completed': gate('cancel-task', 'completed'),
   'commit.completed': gate('commit', 'active'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitlab-ai/agent-infra",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "Bootstrap tool for AI multi-tool collaboration infrastructure — works with Claude Code, Codex, Antigravity CLI, and OpenCode",
   "license": "MIT",
   "type": "module",

package/templates/.agents/hooks/lifecycle-delegation.js

@@ -5,6 +5,8 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 const MAX_INPUT_BYTES = 64 * 1024;
+const repoPackageJson = fileURLToPath(new URL('../../package.json', import.meta.url));
+const sourceInternalCli = fileURLToPath(new URL('../../bin/internal-cli.ts', import.meta.url));
 const localInternalCli = fileURLToPath(new URL('../../dist/bin/internal-cli.js', import.meta.url));
 const codexHooks = fileURLToPath(new URL('../../.codex/hooks.json', import.meta.url));
 const clientIndex = process.argv.indexOf('--client');
@@ -13,6 +15,27 @@ if (client !== 'claude-code' && client !== 'codex') {
   process.stderr.write('Lifecycle delegation hook requires a supported --client value\n');
   process.exit(1);
 }
+
+function internalCliInvocation(args) {
+  let isAgentInfraSourceCheckout = false;
+  try {
+    isAgentInfraSourceCheckout = JSON.parse(readFileSync(repoPackageJson, 'utf8')).name === '@fitlab-ai/agent-infra';
+  } catch {
+    // Installed project hooks do not require a repository package.json.
+  }
+  if (isAgentInfraSourceCheckout && existsSync(sourceInternalCli)) {
+    return {
+      command: process.execPath,
+      commandArgs: ['--experimental-strip-types', sourceInternalCli, ...args],
+      shell: false
+    };
+  }
+  if (existsSync(localInternalCli)) {
+    return { command: process.execPath, commandArgs: [localInternalCli, ...args], shell: false };
+  }
+  return { command: 'agent-infra-internal', commandArgs: args, shell: process.platform === 'win32' };
+}
+
 let input = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => {
@@ -34,15 +57,28 @@ process.stdin.on('end', () => {
   const explicitPhase = phaseIndex >= 0 ? process.argv[phaseIndex + 1] : '';
   const hook = String(explicitPhase || event.hook_event_name || event.event || '').toLowerCase();
   const toolInput = event.tool_input && typeof event.tool_input === 'object' ? event.tool_input : {};
+  const toolName = String(event.tool_name || event.tool || '').toLowerCase();
+  let toolResponse = {};
+  try {
+    toolResponse = typeof event.tool_response === 'string'
+      ? JSON.parse(event.tool_response)
+      : (event.tool_response || {});
+  } catch {
+    // Core ignores opaque tool responses; only the host timeout bit is forwarded.
+  }
   const nativeAgent = event.agent_name || event.agent_type || event.agent?.name
     || toolInput.agent_type || toolInput.agent || toolInput.name;
-  if (!String(nativeAgent || '').startsWith('agent-infra-lifecycle-')) process.exit(0);
   if (client === 'codex') {
     const phases = new Set(['pre-tool', 'subagent-start', 'post-tool', 'subagent-stop']);
     if (!phases.has(hook)) {
       process.stderr.write('Managed Codex lifecycle hook event has an unknown type\n');
       process.exit(1);
     }
+    const managedAgent = /^agent-infra-lifecycle-(executor|reviewer)$/.test(String(nativeAgent || ''));
+    const parentReconcile = hook === 'post-tool'
+      && toolName === 'collaborationwait_agent'
+      && toolResponse.timed_out !== true;
+    if (!managedAgent && !parentReconcile) process.exit(0);
     const hookDefinitionHash = createHash('sha256').update(readFileSync(codexHooks)).digest('hex');
     const normalized = {
       sessionId: String(event.session_id || ''),
@@ -52,19 +88,20 @@ process.stdin.on('end', () => {
       nativeAgent: String(nativeAgent),
       requestedModel: String(toolInput.model || ''),
       requestedReasoningEffort: String(toolInput.reasoning_effort || toolInput.reasoningEffort || ''),
-      hookDefinitionHash
+      hookDefinitionHash,
+      toolName,
+      taskName: String(toolInput.task_name || ''),
+      transcriptPath: String(event.transcript_path || '')
     };
-    const args = ['codex-lifecycle', 'hook-event', '--event', hook];
+    const args = ['codex-lifecycle', 'hook-event', '--event', hook, '--bridge', 'true'];
     try {
-      const useLocal = existsSync(localInternalCli);
-      const command = useLocal ? process.execPath : 'agent-infra-internal';
-      const commandArgs = useLocal ? [localInternalCli, ...args] : args;
+      const { command, commandArgs, shell } = internalCliInvocation(args);
       const output = execFileSync(command, commandArgs, {
         encoding: 'utf8',
         input: JSON.stringify(normalized),
-        shell: !useLocal && process.platform === 'win32',
+        shell,
         stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 5_000
+        timeout: 15_000
       });
       process.stdout.write(output);
     } catch (error) {
@@ -74,6 +111,7 @@ process.stdin.on('end', () => {
     }
     return;
   }
+  if (!/^agent-infra-lifecycle-(executor|reviewer)$/.test(String(nativeAgent || ''))) process.exit(0);
   const start = hook.includes('start');
   const stop = hook.includes('stop');
   if (!start && !stop) {
@@ -102,12 +140,10 @@ process.stdin.on('end', () => {
     );
   }
   try {
-    const useLocal = existsSync(localInternalCli);
-    const command = useLocal ? process.execPath : 'agent-infra-internal';
-    const commandArgs = useLocal ? [localInternalCli, ...args] : args;
+    const { command, commandArgs, shell } = internalCliInvocation(args);
     const output = execFileSync(command, commandArgs, {
       encoding: 'utf8',
-      shell: !useLocal && process.platform === 'win32',
+      shell,
       stdio: ['ignore', 'pipe', 'pipe']
     });
     process.stdout.write(output);

package/templates/.agents/rules/lifecycle-orchestration.en.md

@@ -10,7 +10,7 @@
 
 ## Recovery
 
-`orchestration.json` is the detailed state source. A v2 run persists complete policy, source, and append-only recovery history. Only a v1 run with no pending delegation and zero receipts may be upgraded in place after supplying a complete policy; any historical receipt stays paused because effort is unverifiable. Migration is forward-only: old binaries must not advance active v2 runs.
+`orchestration.json` is the detailed state source. A v2 run persists complete policy, source, and append-only recovery history. Only a v1 run with no pending delegation and zero receipts may be upgraded in place after supplying a complete policy; any historical receipt stays paused because effort is unverifiable. A historical Codex `ORCHESTRATION_CLIENT_UNSUPPORTED` v2 pause appends `CLIENT_CAPABILITY_ENABLED` and resumes only when step count, next stage, baseline, receipts, pending delegation, commit authorization, completion evidence, and commit intent all prove that execution never advanced; unknown or non-empty evidence preserves the pause. Migration is forward-only: old binaries must not advance active v2 runs.
 
 ## Model Policy
 

package/templates/.agents/rules/lifecycle-orchestration.zh-CN.md

@@ -10,7 +10,7 @@
 
 ## 恢复语义
 
-`orchestration.json` 是详细状态源。v2 run 保存完整策略、来源与 append-only 恢复历史。只有无 pending delegation 且零历史 receipt 的 v1 run 可在补齐完整策略后原地升级；任一历史 receipt 因缺 effort 证据保持暂停。其他阻塞、未封存 receipt 或基线漂移继续保持暂停。迁移是 forward-only，旧二进制不得推进 v2 active run。
+`orchestration.json` 是详细状态源。v2 run 保存完整策略、来源与 append-only 恢复历史。只有无 pending delegation 且零历史 receipt 的 v1 run 可在补齐完整策略后原地升级；任一历史 receipt 因缺 effort 证据保持暂停。Codex 的历史 `ORCHESTRATION_CLIENT_UNSUPPORTED` v2 pause 仅在 stepCount、nextStage、baseline、receipts、pending delegation、commit authorization、completion evidence 与 commit intent 全部证明从未推进时追加 `CLIENT_CAPABILITY_ENABLED` 并恢复；任一未知或非空证据保持原暂停。迁移是 forward-only，旧二进制不得推进 v2 active run。
 
 ## 模型策略
 

package/templates/.agents/rules/no-mid-flow-questions.en.md

@@ -47,6 +47,7 @@ SKILLs currently covered by this exemption:
 
 - `release`: may confirm publish after presenting the latest release snapshot
 - `create-release-note`: may confirm publish after presenting exact staged notes and their digest
+- `post-release`: may confirm a normal push after preparing the local post commit and presenting the complete `postConfirmation` and digest
 
 ### Exemption 5: Complete model policy missing at lifecycle start
 

package/templates/.agents/rules/no-mid-flow-questions.zh-CN.md

@@ -47,6 +47,7 @@
 
 - `release`：展示最新 release snapshot 后确认是否 publish
 - `create-release-note`：展示 stage 后的精确 notes 与摘要后确认是否 publish
+- `post-release`：完成本地 post commit 并展示完整 `postConfirmation` 与摘要后确认是否普通 push
 
 ### 例外 5：生命周期启动缺少完整模型策略
 

package/templates/.agents/skills/post-release/SKILL.en.md

@@ -15,16 +15,42 @@ Require one explicit canonical SemVer `{version}`. Do not fall back to the lates
 agent-infra-internal release-workflow inspect {version}
 ```
 
-Pending or unknown is blocked; a definite failure is failed.
+Pending or unknown is blocked; a definite failure is failed. Report `complete` directly from external facts.
 
-## 2. Run Post-release
+## 2. Prepare Local Post-release Work
+
+When incomplete, run:
 
 ```bash
-agent-infra-internal release-workflow post {version}
+agent-infra-internal release-workflow post-prepare {version}
+agent-infra-internal release-workflow inspect {version}
 ```
 
-The core owns build, next development version, inline artifacts, explicit-path commit, normal push, and post-write inspection.
+The core owns build, the optional demo, next development version, inline artifacts, and the explicit-path post commit. This action must not push. Replays recover from Git and channel facts without repeating completed work.
+
+## 3. Check the Confirmation Snapshot
+
+- `complete`: report completion without asking or publishing.
+- `postConfirmation` present: display every field and its `sha256`, then continue to step 4.
+- `postConfirmation` absent: report diagnostics such as `isHead=false` or a dirty worktree/index and stop without asking or publishing.
 
-## 3. Report the Snapshot
+## 4. Authorize the Current Snapshot
+
+Only after displaying the complete `postConfirmation` in the current session, ask once whether to publish. Continue only for an unambiguous affirmative answer. Denial, adjustment, a question, ambiguity, or interruption stops. Authorization never carries across sessions or snapshots.
+
+## 5. Publish the Confirmed Snapshot
+
+```bash
+agent-infra-internal release-workflow post-publish {version} \
+  --expected-sha256 "{post-confirmation-sha256}"
+```
+
+The core re-inspects and verifies the digest before one normal branch push; force pushes are forbidden. On snapshot drift, stop and return to step 1 for a new display and authorization.
+
+## 6. Re-inspect and Report
+
+```bash
+agent-infra-internal release-workflow inspect {version}
+```
 
-Report channel, smoke, commit, and push facts without presenting degraded or blocked as complete.
+Report all channel, released/new version, smoke, post commit, and remote branch facts. Describe completion only for phase `complete`; never present failed, degraded, or blocked as success.

package/templates/.agents/skills/post-release/SKILL.zh-CN.md

@@ -15,16 +15,42 @@ description: >
 agent-infra-internal release-workflow inspect {version}
 ```
 
-pending/unknown 必须 blocked，确定失败必须 failed。
+pending/unknown 必须 blocked，确定失败必须 failed。`complete` 直接按外部事实报告完成。
 
-## 2. 执行后处理
+## 2. 准备本地后处理
+
+尚未完成时执行：
 
 ```bash
-agent-infra-internal release-workflow post {version}
+agent-infra-internal release-workflow post-prepare {version}
+agent-infra-internal release-workflow inspect {version}
 ```
 
-core 负责 build、下一开发版本、内联产物、显式路径 commit 与普通 push，并在写后复核。
+core 负责 build、可选 demo、下一开发版本、内联产物和显式路径 post commit；该动作不得 push。重跑从 Git 与渠道事实恢复，不重复已完成操作。
+
+## 3. 检查确认快照
+
+- `complete`：报告完成，不询问、不 publish。
+- 存在 `postConfirmation`：展示完整字段和 `sha256`，进入步骤 4。
+- 不存在 `postConfirmation`：报告 `isHead=false`、工作树或暂存区非空等诊断并停止，不询问、不 publish。
 
-## 3. 输出摘要
+## 4. 获取当前快照授权
+
+仅在当前会话已展示完整 `postConfirmation` 后询问一次是否发布。只有无歧义肯定答复才继续；否定、调整、疑问、歧义或中断均停止。授权不跨会话或快照复用。
+
+## 5. 发布已确认快照
+
+```bash
+agent-infra-internal release-workflow post-publish {version} \
+  --expected-sha256 "{post-confirmation-sha256}"
+```
+
+core 重新 inspect 并校验摘要后仅执行普通 branch push，禁止 force push。摘要漂移时停止并回到步骤 1 重新展示、重新确认。
+
+## 6. 写后复核并报告
+
+```bash
+agent-infra-internal release-workflow inspect {version}
+```
 
-报告全部渠道、smoke、commit 与 push 事实，不把 degraded/blocked 表述为完成。
+报告全部渠道、released/new version、smoke、post commit 与远端 branch 事实；只有阶段为 `complete` 才表述为完成，不把 failed/degraded/blocked 表述为成功。