@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/dist/lib/internal/release-workflow.js

@@ -1,112 +1,78 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import crypto from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import semver from 'semver';
 import { commitExplicitPaths, inspectGitWorkflow, pushGitRefs } from '../git/workflow.js';
 import { inspectPlatformRelease, reconcileReleaseMilestones } from '../platform/releases.js';
 import { inspectHomebrewChannel, inspectNpmChannel } from '../release/channels.js';
 import { releaseSnapshot } from '../release/workflow.js';
-function command(cwd, executable, args) {
-    return spawnSync(executable, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+import { collectDemoTranscript } from './demo-transcript.js';
+import { createDemoPromotion, promoteDemoAssets, recoverDemoPromotion } from './demo-promotion.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+function command(cwd, executable, args, options = {}) {
+    return spawnSync(executable, args, {
+        cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, ...options.env }
+    });
 }
-// The tape is the canonical init interaction contract. Do not hash all of
-// lib/init.ts: non-visual config serialization changes must not re-record it.
-const DEMO_INPUT_PATHS = [
-    'assets/demo-init.tape',
-    'scripts/demo-regen.sh',
-    'scripts/normalize-gif-duration.py',
-    'bin/cli.ts',
-    'lib/log.ts',
-    'lib/prompt.ts',
-    'lib/paths.ts',
-    'lib/render.ts',
-    'lib/sandbox/engines/'
-];
-const DEMO_DIGEST_PATH = 'assets/demo-init.inputs.sha256';
+const DEMO_DIGEST_PATH = 'assets/demo-init.transcript.sha256';
 const DEMO_OUTPUT_PATH = 'assets/demo-init.gif';
 const DEMO_MAX_BYTES = 4 * 1024 * 1024;
-function demoInputFiles(cwd) {
-    const files = new Set();
-    for (const input of DEMO_INPUT_PATHS) {
-        if (input.endsWith('/')) {
-            const listed = command(cwd, 'git', ['ls-files', '--', input]);
-            if (listed.status !== 0)
-                throw new Error(String(listed.stderr || `Unable to list ${input}`));
-            const directoryFiles = String(listed.stdout).split('\n').filter(Boolean);
-            if (!directoryFiles.length)
-                throw new Error(`Canonical demo input directory is empty: ${input}`);
-            for (const file of directoryFiles)
-                files.add(file.replaceAll('\\', '/'));
-        }
-        else {
-            files.add(input);
-        }
-    }
-    const sorted = [...files].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
-    if (!sorted.length)
-        throw new Error('Canonical demo input set is empty');
-    for (const file of sorted) {
-        const absolute = path.join(cwd, file);
-        if (!fs.statSync(absolute).isFile())
-            throw new Error(`Canonical demo input is not a file: ${file}`);
-    }
-    return sorted;
-}
-function computeDemoInputDigest(cwd) {
-    const hash = crypto.createHash('sha256');
-    for (const file of demoInputFiles(cwd)) {
-        const bytes = fs.readFileSync(path.join(cwd, file));
-        hash.update(file);
-        hash.update('\0');
-        hash.update(String(bytes.byteLength));
-        hash.update('\0');
-        hash.update(bytes);
-        hash.update('\0');
-    }
-    return hash.digest('hex');
-}
 function validGif(filePath) {
     if (!fs.existsSync(filePath))
         return false;
     const header = fs.readFileSync(filePath).subarray(0, 6).toString('ascii');
     return header === 'GIF87a' || header === 'GIF89a';
 }
-function writeDigestAtomically(cwd, digest) {
-    const target = path.join(cwd, DEMO_DIGEST_PATH);
-    const temporary = `${target}.tmp-${process.pid}`;
-    fs.writeFileSync(temporary, `${digest}\n`);
-    fs.renameSync(temporary, target);
-}
-function runOptionalDemo(cwd, run = command) {
-    let digest;
-    try {
-        digest = computeDemoInputDigest(cwd);
+async function runOptionalDemo(cwd, run = command, collect = collectDemoTranscript) {
+    const recovery = recoverDemoPromotion(cwd);
+    if (recovery?.status === 'failed') {
+        return { status: 'failed', reasonCode: recovery.code === 'DEMO_PROMOTION_CLEANUP_FAILED' ? recovery.code : 'DEMO_PROMOTION_RECOVERY_REQUIRED', message: recovery.message, outputPath: null };
     }
-    catch (error) {
-        return { status: 'failed', reasonCode: 'DEMO_DIGEST_FAILED', message: String(error), outputPath: null };
+    const transcript = await collect(cwd);
+    if (transcript.status === 'failed') {
+        return { status: 'failed', reasonCode: transcript.reasonCode, message: transcript.message, outputPath: null };
     }
     const digestPath = path.join(cwd, DEMO_DIGEST_PATH);
     const priorDigest = fs.existsSync(digestPath) ? fs.readFileSync(digestPath, 'utf8').trim() : '';
-    if (/^[0-9a-f]{64}$/.test(priorDigest) && priorDigest === digest) {
-        return { status: 'skipped', reasonCode: 'DEMO_INPUTS_UNCHANGED', message: null, outputPath: null };
+    if (/^[0-9a-f]{64}$/.test(priorDigest) && priorDigest === transcript.sha256) {
+        return { status: 'skipped', reasonCode: 'DEMO_TRANSCRIPT_UNCHANGED', message: null, outputPath: null };
     }
+    const promotion = createDemoPromotion(cwd, transcript.transcript);
+    const discardPromotion = () => fs.rmSync(promotion.directory, { recursive: true, force: true });
     const lfs = run(cwd, 'git', ['lfs', 'version']);
     if (lfs.status !== 0) {
+        discardPromotion();
         return { status: 'failed', reasonCode: 'GIT_LFS_MISSING', message: String(lfs.stderr || lfs.stdout), outputPath: null };
     }
     const lfsAttribute = run(cwd, 'git', ['check-attr', 'filter', '--', DEMO_OUTPUT_PATH]);
     if (lfsAttribute.status !== 0 || !String(lfsAttribute.stdout).trim().endsWith(': lfs')) {
+        discardPromotion();
         return { status: 'failed', reasonCode: 'GIT_LFS_MISSING', message: `${DEMO_OUTPUT_PATH} is not tracked by Git LFS`, outputPath: null };
     }
     const vhs = run(cwd, 'vhs', ['--version']);
-    if (vhs.status !== 0)
-        return { status: 'skipped', reasonCode: 'VHS_MISSING', message: null, outputPath: null };
+    if (vhs.status !== 0) {
+        discardPromotion();
+        return {
+            status: 'failed',
+            reasonCode: 'VHS_MISSING',
+            message: String(vhs.stderr || vhs.stdout) || 'VHS is required to record the changed demo transcript',
+            outputPath: null
+        };
+    }
     const ffmpeg = run(cwd, 'ffmpeg', ['-version']);
-    if (ffmpeg.status !== 0)
-        return { status: 'skipped', reasonCode: 'FFMPEG_MISSING', message: null, outputPath: null };
-    const demo = run(cwd, 'npm', ['run', 'demo:regen']);
+    if (ffmpeg.status !== 0) {
+        discardPromotion();
+        return {
+            status: 'failed',
+            reasonCode: 'FFMPEG_MISSING',
+            message: String(ffmpeg.stderr || ffmpeg.stdout) || 'ffmpeg is required to record the changed demo transcript',
+            outputPath: null
+        };
+    }
+    const stagedOutputPath = path.relative(cwd, promotion.staging.gif).replaceAll(path.sep, '/');
+    const demo = run(cwd, 'npm', ['run', 'demo:regen'], { env: { DEMO_OUTPUT_PATH: stagedOutputPath } });
     if (demo.status !== 0) {
+        discardPromotion();
         return {
             status: 'failed',
             reasonCode: 'DEMO_COMMAND_FAILED',
@@ -115,7 +81,8 @@ function runOptionalDemo(cwd, run = command) {
         };
     }
     const outputPath = DEMO_OUTPUT_PATH;
-    if (!fs.existsSync(path.join(cwd, outputPath))) {
+    if (!fs.existsSync(promotion.staging.gif)) {
+        discardPromotion();
         return {
             status: 'failed',
             reasonCode: 'DEMO_OUTPUT_MISSING',
@@ -123,18 +90,24 @@ function runOptionalDemo(cwd, run = command) {
             outputPath: null
         };
     }
-    const absoluteOutput = path.join(cwd, outputPath);
+    const absoluteOutput = promotion.staging.gif;
     if (!validGif(absoluteOutput)) {
+        discardPromotion();
         return { status: 'failed', reasonCode: 'DEMO_OUTPUT_INVALID', message: `${outputPath} is not a GIF`, outputPath: null };
     }
     if (fs.statSync(absoluteOutput).size > DEMO_MAX_BYTES) {
+        discardPromotion();
         return { status: 'failed', reasonCode: 'DEMO_OUTPUT_TOO_LARGE', message: `${outputPath} exceeds 4 MiB`, outputPath: null };
     }
-    const pointer = run(cwd, 'git', ['lfs', 'pointer', `--file=${outputPath}`]);
+    const pointer = run(cwd, 'git', ['lfs', 'pointer', `--file=${stagedOutputPath}`]);
     if (pointer.status !== 0 || !String(pointer.stdout).includes(`size ${fs.statSync(absoluteOutput).size}`)) {
+        discardPromotion();
         return { status: 'failed', reasonCode: 'DEMO_OUTPUT_INVALID', message: 'Git LFS could not produce a matching pointer', outputPath: null };
     }
-    writeDigestAtomically(cwd, digest);
+    const promoted = promoteDemoAssets(cwd, promotion.staging, `${process.pid}-${Date.now()}`);
+    if (promoted.status === 'failed') {
+        return { status: 'failed', reasonCode: promoted.code ?? 'DEMO_PROMOTION_FAILED', message: promoted.message, outputPath: null };
+    }
     return { status: 'recorded', reasonCode: null, message: null, outputPath };
 }
 function git(cwd, args, run = command, trim = true) {
@@ -188,7 +161,7 @@ function inspectPostReleaseFacts(cwd, commit, run = command) {
         remoteHead,
         newVersion,
         changedPaths,
-        demoInputSha256: digest && /^[0-9a-f]{64}$/.test(digest) ? digest : null,
+        demoTranscriptSha256: digest && /^[0-9a-f]{64}$/.test(digest) ? digest : null,
         worktree: snapshot?.worktree ?? [],
         staged: snapshot?.staged ?? []
     };
@@ -295,13 +268,21 @@ async function releaseWorkflow(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-prepare', 'post-publish'].includes(action || '') || !semver.valid(version)) {
+    if (![
+        internalHandlerRoute('release-workflow', 'inspect', action || ''),
+        internalHandlerRoute('release-workflow', 'prepare', action || ''),
+        internalHandlerRoute('release-workflow', 'publish', action || ''),
+        internalHandlerRoute('release-workflow', 'post-prepare', action || ''),
+        internalHandlerRoute('release-workflow', 'post-publish', action || '')
+    ].some(Boolean) || !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;
     }
+    if (!ensureInternalHandlerRoute('release-workflow', args))
+        return;
     const before = releaseSnapshot(version, await inspectFacts(cwd, version));
-    if (action === 'inspect') {
+    if (internalHandlerRoute('release-workflow', 'inspect', action || '')) {
         process.stdout.write(`${JSON.stringify({ status: 'no-op', changed: false, snapshot: before, error: null })}\n`);
         return;
     }
@@ -310,10 +291,11 @@ async function releaseWorkflow(args = []) {
         process.exitCode = 1;
         return;
     }
-    if (action === 'prepare') {
+    if (internalHandlerRoute('release-workflow', 'prepare', action || '')) {
         if (before.phase !== 'unprepared') {
             const milestones = await reconcileReleaseMilestones(version, { cwd });
-            process.stdout.write(`${JSON.stringify({ ...milestones, snapshot: before })}\n`);
+            const snapshot = releaseSnapshot(version, await inspectFacts(cwd, version));
+            process.stdout.write(`${JSON.stringify({ ...milestones, snapshot })}\n`);
             process.exitCode = milestones.status === 'failed' ? 1 : milestones.status === 'blocked' ? 2 : 0;
             return;
         }
@@ -363,7 +345,7 @@ async function releaseWorkflow(args = []) {
         process.exitCode = failed ? 1 : blocked ? 2 : 0;
         return;
     }
-    if (action === 'publish') {
+    if (internalHandlerRoute('release-workflow', 'publish', action || '')) {
         if (!before.facts.localTag || !['prepared', 'partially-published'].includes(before.phase)) {
             process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_PHASE_INVALID', message: `Cannot publish from ${before.phase}` } })}\n`);
             process.exitCode = 1;
@@ -376,7 +358,7 @@ async function releaseWorkflow(args = []) {
         process.exitCode = result.status === 'failed' ? 1 : result.status === 'degraded' ? 2 : 0;
         return;
     }
-    if (action === 'post-publish') {
+    if (internalHandlerRoute('release-workflow', 'post-publish', action || '')) {
         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`);
@@ -415,6 +397,11 @@ async function releaseWorkflow(args = []) {
         process.exitCode = blocked ? 2 : 1;
         return;
     }
+    if (!internalHandlerRoute('release-workflow', 'post-prepare', action || '')) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: { code: 'RELEASE_INPUT_INVALID', message: 'release-workflow action is not registered' } })}\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;
@@ -432,6 +419,12 @@ async function releaseWorkflow(args = []) {
         process.exitCode = before.facts.smoke === 'failed' ? 1 : 2;
         return;
     }
+    const recovery = recoverDemoPromotion(cwd);
+    if (recovery?.status === 'failed') {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: true, snapshot: before, error: { code: recovery.code, message: recovery.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
     const worktreeError = inspectPostWorktree(cwd);
     if (worktreeError) {
         process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, snapshot: before, error: worktreeError })}\n`);
@@ -444,7 +437,7 @@ async function releaseWorkflow(args = []) {
         process.exitCode = 1;
         return;
     }
-    const demo = runOptionalDemo(cwd);
+    const demo = await runOptionalDemo(cwd);
     if (demo.status === 'failed') {
         process.stdout.write(`${JSON.stringify({ status: 'failed', changed: true, snapshot: before, demo, error: { code: 'RELEASE_POST_DEMO_FAILED', message: demo.message } })}\n`);
         process.exitCode = 1;
@@ -473,5 +466,5 @@ async function releaseWorkflow(args = []) {
     }
     process.stdout.write(`${JSON.stringify({ status: 'applied', changed: true, demo, snapshot, error: null })}\n`);
 }
-export { changedPaths, computeDemoInputDigest, inspectFacts, inspectLocalReleaseFacts, inspectPostReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
+export { changedPaths, inspectFacts, inspectLocalReleaseFacts, inspectPostReleaseFacts, inspectPostWorktree, releaseSmokeStatus, releaseWorkflow, runOptionalDemo };
 //# sourceMappingURL=release-workflow.js.map

package/dist/lib/internal/sandbox-control.js

@@ -1,8 +1,106 @@
-import { recoverSandboxControl, requestSandboxControl, requestSandboxTaskFinalization, requestSandboxTaskControl, SandboxControlClientError } from '../sandbox/control/client.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { recoverSandboxControl, requestSandboxControl, requestSandboxTaskFinalization, requestSandboxTaskControl, requestSandboxTaskWorkflow, resolveVisibleActiveShortId, SandboxControlClientError } from '../sandbox/control/client.js';
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { serveSandboxControl } from '../sandbox/control/server.js';
 import { runSandboxControlExecutor } from '../sandbox/control/executor.js';
 import { controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
+import { parseTaskCreateResult, taskCreateExitCode } from '../task/create-service.js';
+import { createTaskWorkflowRequest } from '../sandbox/control/task-workflow.js';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
+import { routeOrchestration } from '../task/orchestration.js';
+import { parseArtifactName } from '../task/artifact-name.js';
+function valueAfter(args, flag) {
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === flag)
+            return args[index + 1];
+        if (args[index]?.startsWith(`${flag}=`))
+            return args[index].slice(flag.length + 1);
+    }
+    return undefined;
+}
+function withoutValue(args, flag) {
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === flag) {
+            index += 1;
+            continue;
+        }
+        if (args[index]?.startsWith(`${flag}=`))
+            continue;
+        result.push(args[index]);
+    }
+    return result;
+}
+function lifecycleIds(authorityRef, taskId) {
+    const digest = (label) => createHash('sha256')
+        .update(`${label}\0${taskId}\0${authorityRef}`, 'utf8')
+        .digest('hex');
+    return { operationId: digest('operation'), lifecycleRequestId: digest('lifecycle-request') };
+}
+function lifecycleAuthorityIdentity(authorityRef, taskId, requestId, phase, family, artifact, round) {
+    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+    if (!authorityRef || !contextPath)
+        return undefined;
+    const routed = verifyCodexSandboxControllerContextWithWarnings(contextPath, { repoRoot: process.cwd() });
+    const buildIdentity = computeLifecycleBuildIdentity(process.cwd());
+    const hookDefinitionHash = createHash('sha256')
+        .update(readFileSync(path.join(process.cwd(), '.codex', 'hooks.json')))
+        .digest('hex');
+    const ids = lifecycleIds(authorityRef, taskId);
+    return {
+        version: 1,
+        requestId,
+        operationId: ids.operationId,
+        phase,
+        taskId,
+        family,
+        artifact,
+        round,
+        lifecycleRequestId: ids.lifecycleRequestId,
+        authorityRef,
+        expectedControlGeneration: routed.context.controlGeneration,
+        expectedControllerInstanceDigest: routed.context.controllerInstanceDigest,
+        expectedBuildIdentityDigest: createHash('sha256').update(JSON.stringify(buildIdentity)).digest('hex'),
+        expectedHookDefinitionHash: hookDefinitionHash
+    };
+}
+function lifecycleAuthoritySelector(args) {
+    if (!isCanonicalCodexPrepare(args))
+        return undefined;
+    const authorityRef = valueAfter(args, '--capability-ref');
+    const taskId = args[0];
+    if (!authorityRef || !taskId)
+        return undefined;
+    const routed = routeOrchestration(taskId);
+    if (!routed.next || !['analysis', 'plan', 'code'].includes(routed.next.stage))
+        return undefined;
+    return lifecycleAuthorityIdentity(authorityRef, taskId, randomUUID(), 'orchestration.prepare', routed.next.stage === 'analysis' ? 'analysis' : routed.next.stage === 'plan' ? 'plan' : 'code', routed.next.artifact, routed.next.round);
+}
+function lifecycleWorkflowAuthoritySelector(originalArgs, workflow) {
+    const authorityRef = valueAfter(originalArgs, '--capability-ref');
+    if (!authorityRef)
+        return undefined;
+    if (workflow.operation === 'artifact-finalize-local') {
+        const family = valueAfter(workflow.args, '--family');
+        const artifact = valueAfter(workflow.args, '--artifact');
+        const parsed = artifact ? parseArtifactName(artifact) : null;
+        if ((family !== 'analysis' && family !== 'plan' && family !== 'code')
+            || !parsed || parsed.family !== family)
+            return undefined;
+        return lifecycleAuthorityIdentity(authorityRef, workflow.taskId, workflow.id, 'artifact.finalize-local', family, artifact, parsed.round);
+    }
+    if (workflow.operation !== 'event')
+        return undefined;
+    const completed = /^(analysis|plan|code)\.completed$/u.exec(workflow.args[1] ?? '');
+    const artifact = valueAfter(workflow.args, '--artifact');
+    const parsed = artifact ? parseArtifactName(artifact) : null;
+    if (!completed || !parsed || parsed.family !== completed[1])
+        return undefined;
+    return lifecycleAuthorityIdentity(authorityRef, workflow.taskId, workflow.id, 'task-event.completed', completed[1], artifact, parsed.round);
+}
 function isCanonicalCodexPrepare(args) {
     if (args[1] !== 'prepare')
         return false;
@@ -28,6 +126,19 @@ function writeClientError(error) {
     if (error.requestId)
         process.stderr.write(`SANDBOX_CONTROL_REQUEST_ID: ${error.requestId}\n`);
 }
+function recoveredExitCode(response) {
+    if (response.phase !== 'completed')
+        return response.exitCode ?? 1;
+    try {
+        const result = parseTaskCreateResult(JSON.parse(response.stdout));
+        if (result.control?.requestId === response.id)
+            return taskCreateExitCode(result);
+    }
+    catch {
+        // Other control families use their own result envelopes.
+    }
+    return response.exitCode ?? 1;
+}
 function sandboxFinalizationClient(args) {
     if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
         const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message: 'task ref, complete intent, and --agent are required', retryable: false };
@@ -71,8 +182,10 @@ function sandboxFinalizationClient(args) {
     process.exitCode = response.exitCode ?? 1;
 }
 async function sandboxControl(args) {
+    if (!ensureInternalHandlerRoute('sandbox-control', args))
+        return;
     const [operation, ...rest] = args;
-    if (operation === 'serve') {
+    if (internalHandlerRoute('sandbox-control', 'serve', operation ?? '')) {
         const manifestIndex = rest.indexOf('--manifest');
         const manifest = manifestIndex >= 0 ? rest[manifestIndex + 1] : undefined;
         if (!manifest)
@@ -90,7 +203,7 @@ async function sandboxControl(args) {
         }
         return;
     }
-    if (operation === 'execute') {
+    if (internalHandlerRoute('sandbox-control', 'execute', operation ?? '')) {
         const requestIndex = rest.indexOf('--request');
         const nonceIndex = rest.indexOf('--nonce');
         const request = requestIndex >= 0 ? rest[requestIndex + 1] : undefined;
@@ -100,7 +213,7 @@ async function sandboxControl(args) {
         await runSandboxControlExecutor(request, nonce);
         return;
     }
-    if (operation === 'recover') {
+    if (internalHandlerRoute('sandbox-control', 'recover', operation ?? '')) {
         if (rest.length !== 1 || !rest[0])
             throw new Error('sandbox-control recover requires <request-id>');
         let response;
@@ -118,15 +231,60 @@ async function sandboxControl(args) {
         process.stderr.write(response.stderr);
         process.exitCode = response.phase === 'rejected'
             ? response.error?.retryable ? 75 : 1
-            : response.exitCode ?? 1;
+            : recoveredExitCode(response);
         return;
     }
-    if (operation === 'client') {
+    if (internalHandlerRoute('sandbox-control', 'client', operation ?? '')) {
         const [family = '', ...commandArgs] = rest;
         if (family === 'task-finalization') {
             sandboxFinalizationClient(commandArgs);
             return;
         }
+        if (family === 'task-workflow') {
+            const command = commandArgs[0];
+            const taskId = process.env.AGENT_INFRA_TASK_ID;
+            const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
+            if (!command || !taskId || !generation) {
+                process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'SANDBOX_CONTROL_REQUEST_INVALID', message: 'task-workflow requires a bound task and generation' } })}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            let workflow;
+            try {
+                const args = withoutValue(commandArgs.slice(1), '--capability-ref');
+                if (/^\d+$/.test(args[0] ?? '')) {
+                    const resolved = resolveVisibleActiveShortId(args[0]);
+                    if (resolved !== taskId)
+                        throw new Error('SANDBOX_TASK_REF_MISMATCH');
+                    args[0] = resolved;
+                }
+                workflow = createTaskWorkflowRequest(command, args, taskId, generation);
+            }
+            catch (error) {
+                process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'SANDBOX_CONTROL_REQUEST_INVALID', message: error instanceof Error ? error.message : String(error) } })}\n`);
+                process.exitCode = 1;
+                return;
+            }
+            let response;
+            try {
+                const authority = lifecycleWorkflowAuthoritySelector(commandArgs, workflow);
+                response = requestSandboxTaskWorkflow({
+                    workflow,
+                    ...(authority ? { authority } : {})
+                });
+            }
+            catch (error) {
+                if (!(error instanceof SandboxControlClientError))
+                    throw error;
+                writeClientError(error);
+                process.exitCode = error.detail.retryable ? 75 : 1;
+                return;
+            }
+            process.stdout.write(response.stdout);
+            process.stderr.write(response.stderr);
+            process.exitCode = response.phase === 'rejected' ? response.error?.retryable ? 75 : 1 : response.exitCode ?? 1;
+            return;
+        }
         let response;
         try {
             if (family === 'task-orchestration' && isCanonicalCodexPrepare(commandArgs)) {
@@ -134,7 +292,13 @@ async function sandboxControl(args) {
                 const proof = contextPath
                     ? controllerProofFromContext(verifyCodexSandboxControllerContextWithWarnings(contextPath).context)
                     : null;
-                response = requestSandboxTaskControl({ family, args: commandArgs, controllerProof: proof });
+                const authority = lifecycleAuthoritySelector(commandArgs);
+                response = requestSandboxTaskControl({
+                    family,
+                    args: commandArgs,
+                    controllerProof: authority ? null : proof,
+                    ...(authority ? { authority } : {})
+                });
             }
             else {
                 response = requestSandboxControl({ family, args: commandArgs });

package/dist/lib/internal/task-activity.js

@@ -2,6 +2,7 @@ import { applyPrReviewActivityIntent, inspectPrReviewActivity } from '../task/ac
 import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = `Usage: agent-infra-internal task-activity <task-ref> pr-review-inspect
        agent-infra-internal task-activity <task-ref> pr-review-start --agent <agent> --artifact <canonical.md> --head <40hex> [--dry-run]
        agent-infra-internal task-activity <task-ref> pr-review-complete --agent <agent> --artifact <canonical.md> --head <40hex> --verdict <approved|changes-requested|commented> --blockers <N> --major <N> --minor <N> [--dry-run]
@@ -33,12 +34,20 @@ function usageFailure(message) {
     process.exitCode = 1;
 }
 async function taskActivity(args = []) {
+    if (!ensureInternalHandlerRoute('task-activity', args))
+        return;
     if (args[0] === '--help' || args[0] === '-h') {
         process.stdout.write(USAGE);
         return;
     }
     const [taskRef, kind] = args;
-    if (!taskRef || taskRef.startsWith('--') || !kind || !OPERATIONS.has(kind)) {
+    if (!taskRef || taskRef.startsWith('--') || !kind || !OPERATIONS.has(kind)
+        || ![
+            internalHandlerRoute('task-activity', 'pr-review-inspect', kind),
+            internalHandlerRoute('task-activity', 'pr-review-start', kind),
+            internalHandlerRoute('task-activity', 'pr-review-complete', kind),
+            internalHandlerRoute('task-activity', 'pr-review-terminate', kind)
+        ].some(Boolean)) {
         usageFailure('task ref and a supported PR review intent are required');
         return;
     }
@@ -78,7 +87,7 @@ async function taskActivity(args = []) {
         usageFailure(`${kind} does not accept '${unexpected}'`);
         return;
     }
-    if (kind === 'pr-review-inspect') {
+    if (internalHandlerRoute('task-activity', 'pr-review-inspect', kind)) {
         const result = inspectPrReviewActivity(values);
         process.stdout.write(`${JSON.stringify(result)}\n`);
         if (result.status === 'failed')
@@ -91,9 +100,9 @@ async function taskActivity(args = []) {
             return;
         }
     }
-    const operationRequired = kind === 'pr-review-complete'
+    const operationRequired = internalHandlerRoute('task-activity', 'pr-review-complete', kind)
         ? ['verdict', 'blockers', 'major', 'minor']
-        : kind === 'pr-review-terminate' ? ['outcome', 'reason'] : [];
+        : internalHandlerRoute('task-activity', 'pr-review-terminate', kind) ? ['outcome', 'reason'] : [];
     for (const key of operationRequired) {
         if (values[key] === undefined) {
             usageFailure(`${kind} requires '${key}'`);