@fitlab-ai/agent-infra 0.9.5 → 0.9.7

package/lib/git/workflow.ts

@@ -20,6 +20,10 @@ function value(runner: GitRunner, cwd: string, args: readonly string[], trim = t
   return result.status === 0 ? (trim ? result.stdout.trim() : result.stdout.replace(/\n$/, '')) : null;
 }
 
+function nulPaths(output: string): string[] {
+  return output.split('\0').filter(Boolean);
+}
+
 function cleanMessage(message: string): string {
   return message.replace(/(https?:\/\/)[^\s/@:]+(?::[^\s/@]*)?@/gi, '$1***@').trim();
 }
@@ -68,8 +72,27 @@ function commitExplicitPaths(input: { cwd: string; paths: readonly string[]; mes
   const selected = new Set(input.paths);
   const unrelatedStaged = before.snapshot.staged.filter((candidate) => !selected.has(candidate));
   if (unrelatedStaged.length > 0) return { status: 'failed' as const, changed: false, snapshot: before.snapshot, operations: [], error: { code: 'GIT_STAGED_SCOPE_MISMATCH', message: `Unrelated staged paths: ${unrelatedStaged.join(', ')}` } };
-  const add = run(runner, input.cwd, ['add', '--', ...input.paths]);
-  if (add.status !== 0) return { status: 'failed' as const, changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'stage', status: 'failed' as const, message: add.stderr.trim() }], error: { code: 'GIT_STAGE_FAILED', message: add.stderr.trim() } };
+  const stageFailure = (message: string) => ({ status: 'failed' as const, changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'stage', status: 'failed' as const, message }], error: { code: 'GIT_STAGE_FAILED', message } });
+  const indexed = run(runner, input.cwd, ['ls-files', '-z', '--', ...input.paths]);
+  if (indexed.status !== 0) return stageFailure(indexed.stderr.trim());
+  const headed = run(runner, input.cwd, ['ls-tree', '-r', '--name-only', '-z', 'HEAD', '--', ...input.paths]);
+  if (headed.status !== 0) return stageFailure(headed.stderr.trim());
+  const indexedPaths = new Set(nulPaths(indexed.stdout));
+  const headPaths = new Set(nulPaths(headed.stdout));
+  const trackedPaths: string[] = [];
+  const addPaths: string[] = [];
+  for (const candidate of input.paths) {
+    if (indexedPaths.has(candidate)) trackedPaths.push(candidate);
+    else if (!headPaths.has(candidate) || fs.existsSync(path.join(input.cwd, candidate))) addPaths.push(candidate);
+  }
+  if (trackedPaths.length > 0) {
+    const update = run(runner, input.cwd, ['add', '-u', '--', ...trackedPaths]);
+    if (update.status !== 0) return stageFailure(update.stderr.trim());
+  }
+  if (addPaths.length > 0) {
+    const add = run(runner, input.cwd, ['add', '--', ...addPaths]);
+    if (add.status !== 0) return stageFailure(add.stderr.trim());
+  }
   const staged = run(runner, input.cwd, ['diff', '--cached', '--quiet', '--']);
   if (staged.status === 0) return { status: 'no-op' as const, changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'stage', status: 'no-op' as const }], error: null };
   if (input.expectedTree) {
@@ -129,7 +152,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

@@ -9,12 +9,24 @@ import {
   resolveCodexThread
 } from '../agent-clients/adapters/codex-lifecycle/app-server.ts';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
+import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
+import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
 import type { CodexLifecycleEvent } from '../agent-clients/adapters/codex-lifecycle/evidence.ts';
+import { resolveTaskRef } from '../task/resolve-ref.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 USAGE = 'Usage: agent-infra-internal codex-lifecycle <capability-arm|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 +37,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 +57,8 @@ function parse(args: string[]): Parsed | null {
     return null;
   }
   const allowed = {
-    'hook-event': ['--event'],
+    'capability-arm': ['--task-id'],
+    'hook-event': ['--event', '--bridge'],
     'resolve-start': ['--child-id'],
     'resolve-stop': ['--child-id'],
     preflight: ['--format', '--session-id', '--turn-id', '--tool-use-id'],
@@ -75,6 +97,16 @@ function hookDefinitionHash(): string {
   return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
 }
 
+function controllerBinding(taskId: string) {
+  const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+  if (!contextPath) return undefined;
+  const context = verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot: process.cwd() });
+  return {
+    instanceDigest: context.controllerInstanceDigest,
+    controlGeneration: context.controlGeneration
+  };
+}
+
 async function readStdin(): Promise<unknown> {
   let input = '';
   process.stdin.setEncoding('utf8');
@@ -85,7 +117,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 +152,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;
@@ -147,18 +186,150 @@ async function codexLifecycle(args: string[] = []): Promise<void> {
       return;
     }
 
+    if (parsed.operation === 'capability-arm') {
+      const taskId = parsed.values['--task-id'];
+      if (!taskId) throw new Error('capability-arm requires --task-id');
+      const resolved = resolveTaskRef(taskId, { repoRoot: process.cwd() });
+      if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
+      const armed = createCodexCapabilityStore().arm({
+        taskId: resolved.taskId,
+        buildIdentity: computeLifecycleBuildIdentity(process.cwd()),
+        controller: controllerBinding(resolved.taskId)
+      });
+      output({
+        status: 'armed',
+        changed: true,
+        capabilityToken: armed.token,
+        marker: armed.marker,
+        expiresAt: armed.expiresAt,
+        buildIdentity: armed.buildIdentity,
+        error: null
+      });
+      return;
+    }
+
     const store = createCodexLifecycleStore({ cliVersion: cliVersion() });
     if (parsed.operation === 'hook-event') {
       const phase = parsed.values['--event'];
       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') {
+        const capabilityToken = payloadText(payload, 'capabilityToken');
+        if (capabilityToken) {
+          const capabilityStore = createCodexCapabilityStore();
+          const armed = capabilityStore.inspect(capabilityToken);
+          const capability = createCodexCapabilityStore().attest({
+            token: capabilityToken,
+            sessionId: payloadText(payload, 'sessionId'),
+            turnId: payloadText(payload, 'turnId'),
+            toolUseId: payloadText(payload, 'toolUseId'),
+            hookDefinitionHash: payloadText(payload, 'hookDefinitionHash'),
+            buildIdentity: computeLifecycleBuildIdentity(process.cwd()),
+            controller: controllerBinding(armed.taskId)
+          });
+          output({
+            status: capability.status,
+            changed: true,
+            evidence: {
+              revision: capability.revision,
+              sessionId: capability.sessionId,
+              turnId: capability.turnId,
+              toolUseId: capability.toolUseId,
+              expiresAt: capability.expiresAt
+            },
+            diagnostics: [],
+            error: null
+          });
+          return;
+        }
+      }
+      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/codex-sandbox-controller.ts

@@ -0,0 +1,109 @@
+import {
+  runCodexSandboxController,
+  verifyCodexSandboxControllerContext
+} from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
+
+const USAGE = 'Usage: agent-infra-internal codex-sandbox-controller <run|verify-context> [options]\n';
+
+function fail(code: string, message: string, exitCode = 1): void {
+  process.stdout.write(`${JSON.stringify({
+    status: 'failed',
+    changed: false,
+    error: { code, message }
+  })}\n`);
+  process.exitCode = exitCode;
+}
+
+function parse(args: string[]): Readonly<{ operation: string; values: Readonly<Record<string, string>> }> | null {
+  if (args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    return null;
+  }
+  const operation = args[0];
+  if (!operation || !['run', 'verify-context'].includes(operation)) {
+    process.stderr.write(USAGE);
+    fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', 'operation must be run or verify-context', 2);
+    return null;
+  }
+  const allowed = new Set([
+    '--task-id',
+    '--task-ref',
+    '--context',
+    '--executor-model',
+    '--executor-reasoning-effort',
+    '--reviewer-model',
+    '--reviewer-reasoning-effort'
+  ]);
+  const values: Record<string, string> = {};
+  for (let index = 1; index < args.length; index += 1) {
+    const flag = args[index]!;
+    const value = args[++index];
+    if (!allowed.has(flag) || Object.hasOwn(values, flag) || !value || value.startsWith('--')) {
+      fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', `invalid option '${flag}'`, 2);
+      return null;
+    }
+    values[flag] = value;
+  }
+  return { operation, values };
+}
+
+async function codexSandboxController(args: string[] = []): Promise<void> {
+  const parsed = parse(args);
+  if (!parsed || process.exitCode) return;
+  const taskId = parsed.values['--task-id'];
+  if (!taskId) {
+    fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', '--task-id is required', 2);
+    return;
+  }
+  try {
+    if (parsed.operation === 'verify-context') {
+      const contextPath = parsed.values['--context']
+        ?? process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+      if (!contextPath) throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_MISSING');
+      const context = verifyCodexSandboxControllerContext(contextPath, taskId);
+      process.stdout.write(`${JSON.stringify({
+        status: 'ready',
+        changed: false,
+        context: {
+          taskId: context.taskId,
+          controlGeneration: context.controlGeneration,
+          controllerInstanceDigest: context.controllerInstanceDigest,
+          expiresAt: context.expiresAt,
+          buildIdentity: context.buildIdentity,
+          hookDefinitionHash: context.hookDefinitionHash,
+          lifecycleProfilesHash: context.lifecycleProfilesHash
+        },
+        error: null
+      })}\n`);
+      return;
+    }
+    const taskRef = parsed.values['--task-ref'];
+    if (!taskRef) throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_REF_REQUIRED');
+    const policy = [
+      '--executor-model',
+      '--executor-reasoning-effort',
+      '--reviewer-model',
+      '--reviewer-reasoning-effort'
+    ];
+    if (policy.some((flag) => parsed.values[flag] !== undefined)
+      && policy.some((flag) => parsed.values[flag] === undefined)) {
+      throw new Error('CODEX_SANDBOX_CONTROLLER_MODEL_POLICY_INVALID');
+    }
+    const exitCode = await runCodexSandboxController({
+      taskId,
+      taskRef,
+      executorModel: parsed.values['--executor-model'],
+      executorReasoningEffort: parsed.values['--executor-reasoning-effort'],
+      reviewerModel: parsed.values['--reviewer-model'],
+      reviewerReasoningEffort: parsed.values['--reviewer-reasoning-effort']
+    });
+    process.exitCode = exitCode;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1]
+      ?? 'CODEX_SANDBOX_CONTROLLER_FAILED';
+    fail(code, message);
+  }
+}
+
+export { codexSandboxController };

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 };