@fitlab-ai/agent-infra 0.9.5 → 0.9.6

package/lib/git/workflow.ts

@@ -129,7 +129,6 @@ function pushRebasedBranch(input: PushRebasedInput, runner: GitRunner = defaultR
     .map((name) => value(runner, input.cwd, ['rev-parse', '--git-path', name]))
     .filter((candidate): candidate is string => Boolean(candidate));
   if (snapshot.worktree.length > 0 || snapshot.staged.length > 0 ||
-      run(runner, input.cwd, ['rev-parse', '-q', '--verify', 'REBASE_HEAD']).status === 0 ||
       rebasePaths.some((candidate) => fs.existsSync(path.isAbsolute(candidate) ? candidate : path.join(input.cwd, candidate)))) {
     return { status: 'failed' as const, changed: false, snapshot, operations: [], error: { code: 'GIT_LOCAL_STATE_UNSAFE', message: 'Working tree must be clean with no rebase in progress' } };
   }

package/lib/internal/codex-lifecycle.ts

@@ -10,11 +10,19 @@ import {
 } from '../agent-clients/adapters/codex-lifecycle/app-server.ts';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
 import type { CodexLifecycleEvent } from '../agent-clients/adapters/codex-lifecycle/evidence.ts';
+import {
+  activateCodexOrchestrationDelegation,
+  activateCodexSpawnDelegation,
+  reconcileCodexOrchestrationDelegation,
+  sealCodexOrchestrationDelegation,
+  sealCodexParentDelegation
+} from '../task/codex-orchestration.ts';
 
 const USAGE = 'Usage: agent-infra-internal codex-lifecycle <hook-event|resolve-start|resolve-stop|preflight|consume> [options]\n';
 const MANAGED_AGENT = /^agent-infra-lifecycle-(executor|reviewer)$/;
 
 type Parsed = Readonly<{ operation: string; values: Readonly<Record<string, string>> }>;
+type UnresolvedHookChild = Omit<Extract<CodexLifecycleEvent, { type: 'hook-child' }>, 'parentThreadId'>;
 
 function output(value: unknown): void {
   process.stdout.write(`${JSON.stringify(value)}\n`);
@@ -25,6 +33,15 @@ function failure(code: string, message: string): void {
   process.exitCode = 1;
 }
 
+function outputBridgeResult(result: Awaited<ReturnType<typeof activateCodexOrchestrationDelegation>>): void {
+  if (result.error?.code === 'ORCHESTRATION_DELEGATION_MISSING') {
+    output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
+    return;
+  }
+  output(result);
+  if (result.status !== 'running') process.exitCode = 1;
+}
+
 function parse(args: string[]): Parsed | null {
   if (args[0] === '--help' || args[0] === '-h') {
     process.stdout.write(USAGE);
@@ -36,7 +53,7 @@ function parse(args: string[]): Parsed | null {
     return null;
   }
   const allowed = {
-    'hook-event': ['--event'],
+    'hook-event': ['--event', '--bridge'],
     'resolve-start': ['--child-id'],
     'resolve-stop': ['--child-id'],
     preflight: ['--format', '--session-id', '--turn-id', '--tool-use-id'],
@@ -85,7 +102,7 @@ async function readStdin(): Promise<unknown> {
   return JSON.parse(input || '{}') as unknown;
 }
 
-function recordFromPayload(phase: string, payload: unknown): CodexLifecycleEvent | null {
+function recordFromPayload(phase: string, payload: unknown): CodexLifecycleEvent | UnresolvedHookChild | null {
   if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
     throw new Error('Codex lifecycle hook payload must be an object');
   }
@@ -120,6 +137,13 @@ function recordFromPayload(phase: string, payload: unknown): CodexLifecycleEvent
   throw new Error(`unknown Codex lifecycle hook phase '${phase}'`);
 }
 
+function payloadText(payload: unknown, key: string): string {
+  return payload && typeof payload === 'object' && !Array.isArray(payload)
+    && typeof (payload as Record<string, unknown>)[key] === 'string'
+    ? (payload as Record<string, string>)[key]!
+    : '';
+}
+
 async function codexLifecycle(args: string[] = []): Promise<void> {
   const parsed = parse(args);
   if (!parsed || process.exitCode) return;
@@ -153,12 +177,92 @@ async function codexLifecycle(args: string[] = []): Promise<void> {
       if (!phase || !['pre-tool', 'subagent-start', 'post-tool', 'subagent-stop'].includes(phase)) {
         throw new Error('hook-event requires a known --event');
       }
-      const event = recordFromPayload(phase, await readStdin());
+      if (parsed.values['--bridge'] !== undefined && parsed.values['--bridge'] !== 'true') {
+        throw new Error("hook-event --bridge must be 'true'");
+      }
+      const payload = await readStdin();
+      if (phase === 'post-tool' && parsed.values['--bridge'] === 'true') {
+        const toolName = payloadText(payload, 'toolName');
+        if (toolName === 'collaborationspawn_agent') {
+          const nativeAgent = payloadText(payload, 'nativeAgent');
+          if (!MANAGED_AGENT.test(nativeAgent)) {
+            output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
+            return;
+          }
+          const requestedModel = payloadText(payload, 'requestedModel');
+          const requestedReasoningEffort = payloadText(payload, 'requestedReasoningEffort');
+          const bridged = await activateCodexSpawnDelegation({
+            sessionId: payloadText(payload, 'sessionId'),
+            turnId: payloadText(payload, 'turnId'),
+            toolUseId: payloadText(payload, 'toolUseId'),
+            transcriptPath: payloadText(payload, 'transcriptPath'),
+            nativeAgent,
+            taskName: payloadText(payload, 'taskName'),
+            ...(requestedModel ? { requestedModel } : {}),
+            ...(requestedReasoningEffort ? { requestedReasoningEffort } : {})
+          }, { store });
+          outputBridgeResult(bridged);
+          return;
+        }
+        if (toolName === 'collaborationwait_agent') {
+          outputBridgeResult(await sealCodexParentDelegation(payloadText(payload, 'sessionId'), { store }));
+          return;
+        }
+        output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
+        return;
+      }
+      const event = recordFromPayload(phase, payload);
       if (!event) {
+        if (phase === 'post-tool' && parsed.values['--bridge'] === 'true') {
+          const value = payload as Record<string, unknown>;
+          const childThreadId = String(value.childThreadId ?? '');
+          const reconciled = reconcileCodexOrchestrationDelegation(childThreadId);
+          outputBridgeResult(reconciled);
+          return;
+        }
         output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
         return;
       }
+      if (parsed.values['--bridge'] === 'true' && event.type === 'hook-stop') {
+        try {
+          if (store.read(event.childThreadId).consumer) {
+            const bridged = await sealCodexOrchestrationDelegation(event.childThreadId, { store });
+            outputBridgeResult(bridged);
+            return;
+          }
+        } catch {
+          // The normal apply path below owns missing or invalid evidence errors.
+        }
+      }
+      if (parsed.values['--bridge'] === 'true' && event.type === 'hook-child') {
+        const resolved = await resolveCodexThread(event.childThreadId);
+        store.apply({
+          ...event,
+          parentThreadId: resolved.resolution.thread.parentThreadId
+        });
+        const bridged = await activateCodexOrchestrationDelegation(event.childThreadId, {
+          store,
+          resolveThread: async () => resolved
+        });
+        outputBridgeResult(bridged);
+        return;
+      }
+      if (event.type === 'hook-child') {
+        const resolved = await resolveCodexThread(event.childThreadId);
+        const result = store.apply({
+          ...event,
+          parentThreadId: resolved.resolution.thread.parentThreadId
+        });
+        output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: resolved.diagnostics, error: result.state.error });
+        if (result.state.status === 'invalid') process.exitCode = 1;
+        return;
+      }
       const result = store.apply(event);
+      if (parsed.values['--bridge'] === 'true' && event.type === 'hook-stop') {
+        const bridged = await sealCodexOrchestrationDelegation(event.childThreadId, { store });
+        outputBridgeResult(bridged);
+        return;
+      }
       output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: [], error: result.state.error });
       if (result.state.status === 'invalid') process.exitCode = 1;
       return;

package/lib/internal/release-workflow.ts

@@ -8,7 +8,7 @@ import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs } from '../git/wor
 import { inspectPlatformRelease, reconcileReleaseMilestones } from '../platform/releases.ts';
 import { inspectHomebrewChannel, inspectNpmChannel } from '../release/channels.ts';
 import { releaseSnapshot } from '../release/workflow.ts';
-import type { ReleaseFacts } from '../release/workflow.ts';
+import type { PostReleaseFacts, ReleaseFacts } from '../release/workflow.ts';
 
 function command(cwd: string, executable: string, args: string[]) {
   return spawnSync(executable, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
@@ -168,12 +168,52 @@ function inspectLocalReleaseFacts(cwd: string, version: string, run: CommandRunn
   const localTagConflict = Boolean(tagCommit && !localTag && !localTagAncestor);
   const postSubject = `chore: prepare next dev iteration after v${version}`;
   const postLog = localTag || localTagAncestor
-    ? git(cwd, ['log', '--format=%s', `${tag}..HEAD`], run) ?? ''
+    ? git(cwd, ['log', '--format=%H%x00%s', `${tag}..HEAD`], run) ?? ''
     : '';
-  const postCommit = postLog.split('\n').some((subject) => subject === postSubject);
+  const postCommit = postLog.split('\n').map((line) => line.split('\0'))
+    .find(([, subject]) => subject === postSubject)?.[0] ?? null;
   return { localTag, localTagAncestor, localTagConflict, postCommit };
 }
 
+function inspectPostReleaseFacts(
+  cwd: string,
+  commit: string | null,
+  run: CommandRunner = command
+): PostReleaseFacts {
+  const inspected = inspectGitWorkflow(cwd);
+  const snapshot = inspected.snapshot;
+  const branch = snapshot?.branch ?? '';
+  const remoteLine = branch ? git(cwd, ['ls-remote', '--heads', 'origin', `refs/heads/${branch}`], run) : null;
+  const remoteHead = remoteLine?.split(/\s+/)[0] ?? null;
+  const packageJson = commit ? git(cwd, ['show', `${commit}:package.json`], run, false) : null;
+  let newVersion: string | null = null;
+  if (packageJson) {
+    try {
+      const version = (JSON.parse(packageJson) as { version?: unknown }).version;
+      newVersion = typeof version === 'string' ? version : null;
+    } catch {
+      newVersion = null;
+    }
+  }
+  const paths = commit ? git(cwd, ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', commit], run, false) : null;
+  const changedPaths = paths ? paths.split('\0').filter(Boolean)
+    .sort((left, right) => Buffer.from(left).compare(Buffer.from(right))) : [];
+  const digest = commit ? git(cwd, ['show', `${commit}:${DEMO_DIGEST_PATH}`], run) : null;
+  return {
+    commit,
+    isHead: Boolean(commit && snapshot?.head === commit),
+    published: Boolean(commit && remoteHead === commit),
+    branch,
+    upstream: snapshot?.upstream ?? null,
+    remoteHead,
+    newVersion,
+    changedPaths,
+    demoInputSha256: digest && /^[0-9a-f]{64}$/.test(digest) ? digest : null,
+    worktree: snapshot?.worktree ?? [],
+    staged: snapshot?.staged ?? []
+  };
+}
+
 function releaseSmokeStatus(workflows: Array<Record<string, unknown>>, version: string, tagCommit: string | null): ReleaseFacts['smoke'] {
   const manualTitle = `Post-Release Smoke v${version}`;
   const targets = workflows.filter((run) => {
@@ -220,12 +260,15 @@ async function inspectFacts(cwd: string, version: string): Promise<ReleaseFacts>
   const workflows = platform.workflows as Array<Record<string, unknown>>;
   const smoke = releaseSmokeStatus(workflows, version, localTagTarget);
   return {
-    ...local,
+    localTag: local.localTag,
+    localTagAncestor: local.localTagAncestor,
+    localTagConflict: local.localTagConflict,
     remoteBranch: Boolean(remoteBranch && remoteBranch.split(/\s+/)[0] === head), remoteTag: Boolean(remoteTag),
     githubRelease: platform.platform.type !== 'github'
       ? true
       : platform.status === 'blocked' ? null : Boolean(platform.release?.published),
-    npm: npm.published, homebrew: homebrew.published, smoke
+    npm: npm.published, homebrew: homebrew.published, smoke,
+    post: inspectPostReleaseFacts(cwd, local.postCommit)
   };
 }
 
@@ -258,13 +301,21 @@ function updateReleaseMetadata(cwd: string, version: string): void {
   }
 }
 
+function optionValues(args: string[], name: string): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === name) values.push(args[index + 1] ?? '');
+  }
+  return values;
+}
+
 async function releaseWorkflow(args: string[] = []): Promise<void> {
   const [action, rawVersion, ...rest] = args;
   const version = String(rawVersion || '').replace(/^v/, '');
   const cwdIndex = rest.indexOf('--cwd');
   const cwd = path.resolve(cwdIndex >= 0 && rest[cwdIndex + 1] ? rest[cwdIndex + 1]! : process.cwd());
-  if (!['inspect', 'prepare', 'publish', 'post'].includes(action || '') || !semver.valid(version)) {
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'RELEASE_INPUT_INVALID', message: 'Usage: release-workflow inspect|prepare|publish|post <version>' } })}\n`);
+  if (!['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'].includes(action || '') || !semver.valid(version)) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'RELEASE_INPUT_INVALID', message: 'Usage: release-workflow inspect|prepare|publish|post-prepare|post-publish <version>' } })}\n`);
     process.exitCode = 1; return;
   }
   const before = releaseSnapshot(version, await inspectFacts(cwd, version));
@@ -310,10 +361,51 @@ async function releaseWorkflow(args: string[] = []): Promise<void> {
     const result = pushGitRefs({ cwd, remote: 'origin', refs });
     process.stdout.write(`${JSON.stringify({ ...result, snapshot: releaseSnapshot(version, await inspectFacts(cwd, version)) })}\n`); process.exitCode = result.status === 'failed' ? 1 : result.status === 'degraded' ? 2 : 0; return;
   }
+  if (action === 'post-publish') {
+    const expectedValues = optionValues(rest, '--expected-sha256');
+    if (expectedValues.length !== 1 || !/^sha256:[0-9a-f]{64}$/.test(expectedValues[0]!)) {
+      process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_INPUT_INVALID', message: 'post-publish requires one --expected-sha256 sha256:<64 hex>' } })}\n`);
+      process.exitCode = 1; return;
+    }
+    if (before.phase === 'complete') {
+      process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
+      return;
+    }
+    const confirmation = 'postConfirmation' in before ? before.postConfirmation : null;
+    if (before.phase !== 'post-prepared' || !confirmation) {
+      process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: confirmation ? 'RELEASE_PHASE_INVALID' : 'RELEASE_POST_CONFIRMATION_UNAVAILABLE', message: 'Post-release facts cannot authorize publish' } })}\n`);
+      process.exitCode = 1; return;
+    }
+    if (confirmation.sha256 !== expectedValues[0]) {
+      process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_POST_SNAPSHOT_MISMATCH', message: 'Post-release confirmation snapshot changed' } })}\n`);
+      process.exitCode = 1; return;
+    }
+    const channelsComplete = before.facts.githubRelease === true && before.facts.npm === true && before.facts.homebrew === true;
+    if (!channelsComplete || before.facts.smoke !== 'success') {
+      process.stdout.write(`${JSON.stringify({ status: before.facts.smoke === 'failed' ? 'failed' : 'blocked', changed: false, snapshot: before, error: { code: 'RELEASE_CHANNELS_PENDING', message: 'Release channels or smoke workflow are not complete' } })}\n`);
+      process.exitCode = before.facts.smoke === 'failed' ? 1 : 2; return;
+    }
+    const pushed = pushGitRefs({ cwd, remote: 'origin', refs: [before.facts.post.branch] });
+    const snapshot = releaseSnapshot(version, await inspectFacts(cwd, version));
+    if (snapshot.phase === 'complete') {
+      process.stdout.write(`${JSON.stringify({ ...pushed, status: 'applied', changed: true, snapshot, error: null })}\n`);
+      return;
+    }
+    const blocked = pushed.status !== 'failed';
+    process.stdout.write(`${JSON.stringify({ ...pushed, status: blocked ? 'blocked' : 'failed', snapshot, error: pushed.error ?? { code: 'RELEASE_PROGRESS_PENDING', message: 'Post-release push is not visible at the expected remote head' } })}\n`);
+    process.exitCode = blocked ? 2 : 1; return;
+  }
+
   if (before.phase === 'complete') {
     process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
     return;
   }
+  if (before.phase === 'post-prepared') {
+    const confirmation = 'postConfirmation' in before ? before.postConfirmation : null;
+    const status = confirmation ? 'no-op' : 'blocked';
+    process.stdout.write(`${JSON.stringify({ status, changed: false, snapshot: before, error: confirmation ? null : { code: 'RELEASE_POST_CONFIRMATION_UNAVAILABLE', message: 'Post commit is not the clean current HEAD' } })}\n`);
+    process.exitCode = confirmation ? 0 : 2; return;
+  }
   const channelsComplete = before.facts.githubRelease === true && before.facts.npm === true && before.facts.homebrew === true;
   if (!['published', 'post-pending'].includes(before.phase) || !channelsComplete || before.facts.smoke !== 'success') {
     process.stdout.write(`${JSON.stringify({ status: before.facts.smoke === 'failed' ? 'failed' : 'blocked', changed: false, snapshot: before, error: { code: 'RELEASE_CHANNELS_PENDING', message: 'Release channels or smoke workflow are not complete' } })}\n`); process.exitCode = before.facts.smoke === 'failed' ? 1 : 2; return;
@@ -338,10 +430,14 @@ async function releaseWorkflow(args: string[] = []): Promise<void> {
   }
   const committed = commitExplicitPaths({ cwd, paths: changedPaths(cwd), message: `chore: prepare next dev iteration after v${version}` });
   if (committed.status === 'failed') { process.stdout.write(`${JSON.stringify(committed)}\n`); process.exitCode = 1; return; }
-  const branch = git(cwd, ['branch', '--show-current']) || '';
-  const pushed = pushGitRefs({ cwd, remote: 'origin', refs: [branch] });
-  process.stdout.write(`${JSON.stringify({ ...pushed, demo, snapshot: releaseSnapshot(version, await inspectFacts(cwd, version)) })}\n`); process.exitCode = pushed.status === 'failed' ? 1 : pushed.status === 'degraded' ? 2 : 0;
+  const snapshot = releaseSnapshot(version, await inspectFacts(cwd, version));
+  const confirmation = 'postConfirmation' in snapshot ? snapshot.postConfirmation : null;
+  if (snapshot.phase !== 'post-prepared' || !confirmation) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: true, demo, snapshot, error: { code: 'RELEASE_POST_CONFIRMATION_UNAVAILABLE', message: 'Prepared post commit did not produce a confirmation snapshot' } })}\n`);
+    process.exitCode = 1; return;
+  }
+  process.stdout.write(`${JSON.stringify({ status: 'applied', changed: true, demo, snapshot, error: null })}\n`);
 }
 
-export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
+export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 export type { CommandRunner, DemoResult };

package/lib/internal/sandbox-control.ts

@@ -1,24 +1,56 @@
-import { requestSandboxControl } from '../sandbox/control/client.ts';
+import { requestSandboxControl, SandboxControlClientError } from '../sandbox/control/client.ts';
 import { serveSandboxControl } from '../sandbox/control/server.ts';
+import { runSandboxControlExecutor } from '../sandbox/control/executor.ts';
 
-function sandboxControl(args: string[]): void {
+async function sandboxControl(args: string[]): Promise<void> {
   const [operation, ...rest] = args;
   if (operation === 'serve') {
     const manifestIndex = rest.indexOf('--manifest');
     const manifest = manifestIndex >= 0 ? rest[manifestIndex + 1] : undefined;
     if (!manifest) throw new Error('sandbox-control serve requires --manifest');
-    serveSandboxControl(manifest);
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    process.once('SIGINT', abort);
+    process.once('SIGTERM', abort);
+    try {
+      await serveSandboxControl(manifest, controller.signal);
+    } finally {
+      process.off('SIGINT', abort);
+      process.off('SIGTERM', abort);
+    }
+    return;
+  }
+  if (operation === 'execute') {
+    const requestIndex = rest.indexOf('--request');
+    const nonceIndex = rest.indexOf('--nonce');
+    const request = requestIndex >= 0 ? rest[requestIndex + 1] : undefined;
+    const nonce = nonceIndex >= 0 ? rest[nonceIndex + 1] : undefined;
+    if (!request || !nonce) throw new Error('sandbox-control execute requires --request and --nonce');
+    await runSandboxControlExecutor(request, nonce);
     return;
   }
   if (operation === 'client') {
     const [family = '', ...commandArgs] = rest;
-    const response = requestSandboxControl({ family, args: commandArgs });
+    let response;
+    try {
+      response = requestSandboxControl({ family, args: commandArgs });
+    } catch (error) {
+      if (!(error instanceof SandboxControlClientError)) throw error;
+      process.stderr.write(`${error.detail.message}\n`);
+      process.exitCode = error.detail.retryable ? 75 : 1;
+      return;
+    }
     process.stdout.write(response.stdout);
     process.stderr.write(response.stderr);
-    process.exitCode = response.exitCode;
+    if (response.phase === 'rejected') {
+      process.stderr.write(response.error?.message ?? response.stderr);
+      process.exitCode = response.error?.retryable ? 75 : 1;
+    } else {
+      process.exitCode = response.exitCode ?? 1;
+    }
     return;
   }
-  throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | client <family> [args...]');
+  throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | execute --request <path> --nonce <nonce> | client <family> [args...]');
 }
 
 export { sandboxControl };

package/lib/internal/task-create.ts

@@ -1,15 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import { requestSandboxTaskCreate } from '../sandbox/control/client.ts';
+import { requestSandboxTaskCreate, SandboxControlClientError } from '../sandbox/control/client.ts';
 import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.ts';
 import { validateTaskCreateCandidate } from '../task/create.ts';
 import { createTask, type TaskCreateResult } from '../task/create-service.ts';
 
-function failed(code: string, message: string): TaskCreateResult {
+function failed(code: string, message: string, retryable = false): TaskCreateResult {
   return {
-    status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
-    operations: [], warnings: [], error: { code, message, retryable: false }
+    status: retryable ? 'blocked' : 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
+    operations: [], warnings: [], error: { code, message, retryable }
   };
 }
 
@@ -33,6 +33,14 @@ function taskCreate(args: string[]): void {
     const candidate = validateTaskCreateCandidate(JSON.parse(fs.readFileSync(inputPath, 'utf8')));
     if (process.env.AGENT_INFRA_CONTROL_TOKEN) {
       const response = requestSandboxTaskCreate({ candidate });
+      if (response.phase === 'rejected') {
+        output(failed(
+          response.error?.code ?? 'SANDBOX_CONTROL_REJECTED',
+          response.error?.message ?? response.stderr,
+          response.error?.retryable ?? false
+        ));
+        return;
+      }
       process.stdout.write(response.stdout);
       process.stderr.write(response.stderr);
       process.exitCode = response.exitCode;
@@ -40,6 +48,10 @@ function taskCreate(args: string[]): void {
     }
     output(createTask(candidate, { repoRoot: process.cwd() }));
   } catch (error) {
+    if (error instanceof SandboxControlClientError) {
+      output(failed(error.detail.code, error.detail.message, error.detail.retryable));
+      return;
+    }
     const message = error instanceof Error ? error.message : String(error);
     const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_INPUT_INVALID';
     output(failed(code, message));

package/lib/internal/task-orchestration.ts

@@ -9,7 +9,6 @@ import {
   checkpointCommitIntent,
   completeCommitIntent,
   pauseOrchestration,
-  prepareOrchestrationDelegation,
   recoverCommitIntent,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
@@ -19,6 +18,7 @@ import {
   statusOrchestration,
   terminateCommitAttempt
 } from '../task/orchestration.ts';
+import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.ts';
 import { isAgentClientId } from '../agent-clients/types.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
 
@@ -33,7 +33,7 @@ function usageFailure(message: string): void {
   process.exitCode = 2;
 }
 
-function taskOrchestration(args: string[] = []): void {
+async function taskOrchestration(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') {
     process.stdout.write(USAGE);
     return;
@@ -212,11 +212,11 @@ function taskOrchestration(args: string[] = []): void {
   } else if (intent === 'prepare') {
     const missing = requireValues(['--client']);
     if (missing) { usageFailure(`intent 'prepare' requires '${missing}'`); return; }
-    result = prepareOrchestrationDelegation(taskRef!, {
+    result = await prepareCodexOrchestrationDelegation(taskRef!, {
       client: values['--client'] as AgentClientId,
       requestedModel: values['--requested-model'],
       requestedReasoningEffort: values['--requested-reasoning-effort']
-    }, coreOptions);
+    }, { orchestrationOptions: coreOptions });
   } else if (intent === 'hook-start') {
     const missing = requireValues([
       ...(taskRef === 'auto' ? ['--client'] : []),

package/lib/platform/issue-comments.ts

@@ -39,6 +39,7 @@ const ARTIFACT_TITLES: Record<string, string> = {
   code: '实现报告',
   'review-code': '代码审查',
   'manual-validation': '人工验证报告',
+  'validation-run': '验证运行证据',
   'pr-review': 'PR 审查报告'
 };
 
@@ -75,7 +76,7 @@ function renderTaskComment(content: string, taskId: string, agent: string): stri
 
 function artifactIdentity(artifact: string): { stem: string; title: string } {
   const stem = path.basename(artifact, '.md');
-  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|pr-review)(?:-r(\d+))?$/);
+  const match = stem.match(/^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r(\d+))?$/);
   if (!match) throw new Error(`unsupported artifact '${artifact}'`);
   const base = ARTIFACT_TITLES[match[1]!]!;
   const round = match[2] ? Number(match[2]) : 1;

package/lib/release/workflow.ts

@@ -1,32 +1,81 @@
-type ReleasePhase = 'unprepared' | 'prepared' | 'partially-published' | 'published' | 'post-pending' | 'complete';
-type ReleaseFacts = { localTag: boolean; localTagAncestor?: boolean; localTagConflict?: boolean; remoteBranch: boolean; remoteTag: boolean; githubRelease: boolean | null; npm: boolean | null; homebrew: boolean | null; smoke: 'success' | 'pending' | 'failed' | null; postCommit: boolean };
+import crypto from 'node:crypto';
+
+type ReleasePhase = 'unprepared' | 'prepared' | 'partially-published' | 'published' | 'post-pending' | 'post-prepared' | 'complete';
+type PostReleaseFacts = {
+  commit: string | null;
+  isHead: boolean;
+  published: boolean;
+  branch: string;
+  upstream: string | null;
+  remoteHead: string | null;
+  newVersion: string | null;
+  changedPaths: string[];
+  demoInputSha256: string | null;
+  worktree: string[];
+  staged: string[];
+};
+type ReleaseFacts = {
+  localTag: boolean;
+  localTagAncestor?: boolean;
+  localTagConflict?: boolean;
+  remoteBranch: boolean;
+  remoteTag: boolean;
+  githubRelease: boolean | null;
+  npm: boolean | null;
+  homebrew: boolean | null;
+  smoke: 'success' | 'pending' | 'failed' | null;
+  post: PostReleaseFacts;
+};
+type PostConfirmation = {
+  version: string;
+  commit: string;
+  branch: string;
+  upstream: string | null;
+  remoteHead: string | null;
+  newVersion: string | null;
+  changedPaths: string[];
+  demoInputSha256: string | null;
+  worktree: string[];
+  staged: string[];
+  sha256: string;
+};
+
+function byteSort(values: readonly string[]): string[] {
+  return [...values].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
+}
 
 function deriveReleasePhase(facts: ReleaseFacts): ReleasePhase {
   if (!facts.localTag && !facts.localTagAncestor) return 'unprepared';
+  if (facts.post.commit) return facts.post.published ? 'complete' : 'post-prepared';
   if (!facts.remoteBranch && !facts.remoteTag) return 'prepared';
   if (!facts.remoteBranch || !facts.remoteTag) return 'partially-published';
   if (facts.githubRelease !== true || facts.npm !== true || facts.homebrew !== true) return 'published';
-  if (facts.smoke !== 'success' || !facts.postCommit) return 'post-pending';
-  return 'complete';
+  return 'post-pending';
 }
 
-function releaseSnapshot(version: string, facts: ReleaseFacts) {
-  return { version, tag: `v${version.replace(/^v/, '')}`, phase: deriveReleasePhase(facts), facts };
+function createPostConfirmation(version: string, post: PostReleaseFacts): PostConfirmation | null {
+  if (!post.commit || !post.isHead || post.worktree.length || post.staged.length) return null;
+  const canonical = {
+    version,
+    commit: post.commit,
+    branch: post.branch,
+    upstream: post.upstream,
+    remoteHead: post.remoteHead,
+    newVersion: post.newVersion,
+    changedPaths: byteSort(post.changedPaths),
+    demoInputSha256: post.demoInputSha256,
+    worktree: byteSort(post.worktree),
+    staged: byteSort(post.staged)
+  };
+  const sha256 = `sha256:${crypto.createHash('sha256').update(JSON.stringify(canonical), 'utf8').digest('hex')}`;
+  return { ...canonical, sha256 };
 }
 
-async function runReleaseAction(input: { version: string; action: 'inspect' | 'prepare' | 'publish' | 'post'; inspect: () => Promise<ReleaseFacts>; prepare?: () => Promise<void>; publish?: () => Promise<void>; post?: () => Promise<void> }) {
-  const before = releaseSnapshot(input.version, await input.inspect());
-  if (input.action === 'inspect') return { status: 'no-op' as const, changed: false, before, snapshot: before, error: null };
-  if (before.facts.localTagConflict) return { status: 'failed' as const, changed: false, before, snapshot: before, error: { code: 'GIT_TAG_CONFLICT', message: `Tag ${before.tag} is not reachable from HEAD` } };
-  const allowed = input.action === 'prepare' ? before.phase === 'unprepared'
-    : input.action === 'publish' ? before.facts.localTag && ['prepared', 'partially-published'].includes(before.phase)
-      : ['published', 'post-pending'].includes(before.phase);
-  if (!allowed) return { status: before.phase === 'complete' ? 'no-op' as const : 'failed' as const, changed: false, before, snapshot: before, error: before.phase === 'complete' ? null : { code: 'RELEASE_PHASE_INVALID', message: `Cannot ${input.action} from ${before.phase}` } };
-  await input[input.action]?.();
-  const snapshot = releaseSnapshot(input.version, await input.inspect());
-  const progressed = snapshot.phase !== before.phase;
-  return { status: progressed ? 'applied' as const : 'blocked' as const, changed: progressed, before, snapshot, error: progressed ? null : { code: 'RELEASE_PROGRESS_PENDING', message: `${input.action} has not reached the next observable phase` } };
+function releaseSnapshot(version: string, facts: ReleaseFacts) {
+  const snapshot = { version, tag: `v${version.replace(/^v/, '')}`, phase: deriveReleasePhase(facts), facts };
+  const postConfirmation = createPostConfirmation(version, facts.post);
+  return postConfirmation ? { ...snapshot, postConfirmation } : snapshot;
 }
 
-export { deriveReleasePhase, releaseSnapshot, runReleaseAction };
-export type { ReleaseFacts, ReleasePhase };
+export { createPostConfirmation, deriveReleasePhase, releaseSnapshot };
+export type { PostConfirmation, PostReleaseFacts, ReleaseFacts, ReleasePhase };