@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/bin/internal-cli.js

@@ -1,11 +1,32 @@
 #!/usr/bin/env node
+import { classifySandboxControlEnvironment } from '../lib/sandbox/control/client.js';
+import { formatTaskViewDiagnostic, guardTaskOperation, TaskViewOperationError } from '../lib/internal/task-operation-registry.js';
+import { INTERNAL_HANDLER_ROUTE_SELECTORS } from '../lib/internal/cli-route-inventory.js';
 const [major = 0, minor = 0] = process.versions.node.split('.').map((part) => parseInt(part, 10));
 if (major < 22 || (major === 22 && minor < 9)) {
     process.stderr.write(`agent-infra-internal requires Node.js >= 22.9.0 (current: ${process.version})\n`);
     process.exit(1);
 }
 const command = process.argv[2] || '';
+const internalRouteRegistered = Object.hasOwn(INTERNAL_HANDLER_ROUTE_SELECTORS, command);
 const taskControlCommand = command === 'task-lifecycle' || command === 'task-orchestration' || command === 'task-finalization';
+let taskViewGuardFailed = false;
+try {
+    const guard = guardTaskOperation('internal', command, process.argv.slice(3));
+    if (guard.taskView && guard.descriptor.effect === 'diagnostic') {
+        process.stderr.write(formatTaskViewDiagnostic(guard.taskView));
+    }
+}
+catch (error) {
+    taskViewGuardFailed = true;
+    if (error instanceof TaskViewOperationError) {
+        process.stderr.write(`${error.message}\n`);
+        process.exitCode = error.exitCode;
+    }
+    else {
+        throw error;
+    }
+}
 function taskControlTransportFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -13,26 +34,12 @@ function taskControlTransportFailure(message) {
     })}\n`);
     process.exit(1);
 }
-if (taskControlCommand) {
-    const env = process.env;
-    const executorMarked = Boolean(env.AGENT_INFRA_EXECUTOR_MANIFEST);
-    const controlKeys = [
-        'AGENT_INFRA_CONTROL_TOKEN', 'AGENT_INFRA_CONTROL_GENERATION',
-        'AGENT_INFRA_CONTROL_DIR', 'AGENT_INFRA_CONTROL_STATUS_DIR'
-    ];
-    const hasControlMarker = controlKeys.some((key) => Boolean(env[key]))
-        || Boolean(env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING);
-    const taskBindingMarker = hasControlMarker && Boolean(env.AGENT_INFRA_TASK_ID);
-    const hasCompleteClientConfig = controlKeys.every((key) => Boolean(env[key]))
-        && !env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING
-        && (!taskBindingMarker || Boolean(env.AGENT_INFRA_RUNTIME_DIR));
-    if (executorMarked) {
-        taskControlTransportFailure('executor context is only valid for sandbox-control execute');
+if (!taskViewGuardFailed && taskControlCommand) {
+    const environment = classifySandboxControlEnvironment();
+    if (environment.kind === 'invalid') {
+        taskControlTransportFailure(environment.message ?? 'sandbox client control configuration is invalid');
     }
-    if ((hasControlMarker || taskBindingMarker) && !hasCompleteClientConfig) {
-        taskControlTransportFailure('sandbox client control configuration is incomplete or conflicting');
-    }
-    if (hasCompleteClientConfig) {
+    if (environment.kind === 'controlled') {
         const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
         await sandboxControl(['client', command, ...process.argv.slice(3)]);
     }
@@ -45,22 +52,22 @@ if (taskControlCommand) {
             }
             case 'task-lifecycle': {
                 const { taskLifecycle } = await import('../lib/internal/task-lifecycle.js');
-                taskLifecycle(process.argv.slice(3));
+                await taskLifecycle(process.argv.slice(3));
                 break;
             }
             case 'task-finalization': {
                 const { taskFinalization } = await import('../lib/internal/task-finalization.js');
-                taskFinalization(process.argv.slice(3));
+                await taskFinalization(process.argv.slice(3));
                 break;
             }
         }
     }
 }
-else
+else if (!taskViewGuardFailed && internalRouteRegistered)
     switch (command) {
         case 'task-create': {
             const { taskCreate } = await import('../lib/internal/task-create.js');
-            taskCreate(process.argv.slice(3));
+            await taskCreate(process.argv.slice(3));
             break;
         }
         case 'sandbox-control': {
@@ -100,37 +107,37 @@ else
         }
         case 'platform-release-notes': {
             const { platformReleaseNotes } = await import('../lib/internal/platform-release-notes.js');
-            platformReleaseNotes(process.argv.slice(3));
+            await platformReleaseNotes(process.argv.slice(3));
             break;
         }
         case 'platform-context': {
             const { platformContext } = await import('../lib/internal/platform-context.js');
-            platformContext(process.argv.slice(3));
+            await platformContext(process.argv.slice(3));
             break;
         }
         case 'platform-comment': {
             const { platformComment } = await import('../lib/internal/platform-comment.js');
-            platformComment(process.argv.slice(3));
+            await platformComment(process.argv.slice(3));
             break;
         }
         case 'platform-issue': {
             const { platformIssue } = await import('../lib/internal/platform-issue.js');
-            platformIssue(process.argv.slice(3));
+            await platformIssue(process.argv.slice(3));
             break;
         }
         case 'platform-pr': {
             const { platformPr } = await import('../lib/internal/platform-pr.js');
-            platformPr(process.argv.slice(3));
+            await platformPr(process.argv.slice(3));
             break;
         }
         case 'platform-pr-review': {
             const { platformPrReview } = await import('../lib/internal/platform-pr-review.js');
-            platformPrReview(process.argv.slice(3));
+            await platformPrReview(process.argv.slice(3));
             break;
         }
         case 'pr-review-grade': {
             const { prReviewGrade } = await import('../lib/internal/pr-review-grade.js');
-            prReviewGrade(process.argv.slice(3));
+            await prReviewGrade(process.argv.slice(3));
             break;
         }
         case 'platform-checks': {
@@ -138,6 +145,16 @@ else
             await platformChecks(process.argv.slice(3));
             break;
         }
+        case 'platform-security': {
+            const { platformSecurity } = await import('../lib/internal/platform-security.js');
+            await platformSecurity(process.argv.slice(3));
+            break;
+        }
+        case 'platform-metadata': {
+            const { platformMetadata } = await import('../lib/internal/platform-metadata.js');
+            await platformMetadata(process.argv.slice(3));
+            break;
+        }
         case 'task-context': {
             const { taskContext } = await import('../lib/internal/task-context.js');
             taskContext(process.argv.slice(3));
@@ -145,17 +162,22 @@ else
         }
         case 'task-ledger': {
             const { taskLedger } = await import('../lib/internal/task-ledger.js');
-            taskLedger(process.argv.slice(3));
+            await taskLedger(process.argv.slice(3));
+            break;
+        }
+        case 'task-qualification': {
+            const { taskQualification } = await import('../lib/internal/task-qualification.js');
+            await taskQualification(process.argv.slice(3));
             break;
         }
         case 'task-warning': {
             const { taskWarning } = await import('../lib/internal/task-warning.js');
-            taskWarning(process.argv.slice(3));
+            await taskWarning(process.argv.slice(3));
             break;
         }
         case 'task-activity': {
             const { taskActivity } = await import('../lib/internal/task-activity.js');
-            taskActivity(process.argv.slice(3));
+            await taskActivity(process.argv.slice(3));
             break;
         }
         case 'task-artifact': {
@@ -170,27 +192,32 @@ else
         }
         case 'task-review': {
             const { taskReview } = await import('../lib/internal/task-review.js');
-            taskReview(process.argv.slice(3));
+            await taskReview(process.argv.slice(3));
             break;
         }
         case 'task-event': {
             const { taskEvent } = await import('../lib/internal/task-event.js');
-            taskEvent(process.argv.slice(3));
+            await taskEvent(process.argv.slice(3));
+            break;
+        }
+        case 'task-invalidation': {
+            const { taskInvalidation } = await import('../lib/internal/task-invalidation.js');
+            taskInvalidation(process.argv.slice(3));
             break;
         }
         case 'task-lifecycle': {
             const { taskLifecycle } = await import('../lib/internal/task-lifecycle.js');
-            taskLifecycle(process.argv.slice(3));
+            await taskLifecycle(process.argv.slice(3));
             break;
         }
         case 'task-finalization': {
             const { taskFinalization } = await import('../lib/internal/task-finalization.js');
-            taskFinalization(process.argv.slice(3));
+            await taskFinalization(process.argv.slice(3));
             break;
         }
         case 'task-override': {
             const { taskOverride } = await import('../lib/internal/task-override.js');
-            taskOverride(process.argv.slice(3));
+            await taskOverride(process.argv.slice(3));
             break;
         }
         case 'task-short-id': {
@@ -205,7 +232,7 @@ else
         }
         case 'task-verify': {
             const { taskVerify } = await import('../lib/internal/task-verify.js');
-            taskVerify(process.argv.slice(3));
+            await taskVerify(process.argv.slice(3));
             break;
         }
         case 'task-validate': {
@@ -221,5 +248,4 @@ else
             })}\n`);
             process.exitCode = 1;
     }
-export {};
 //# sourceMappingURL=internal-cli.js.map

package/dist/lib/agent-client.js

@@ -6,6 +6,8 @@ import { listAgentClientAdapters } from './agent-clients/registry.js';
 import { AGENT_CLIENT_IDS, isAgentClientId } from './agent-clients/types.js';
 import { closePrompt, multiSelect } from './prompt.js';
 import { resolveTemplateDir } from './paths.js';
+import { PUBLIC_CLI_ROUTE_SELECTORS } from './internal/cli-route-inventory.js';
+const AGENT_CLIENT_OPERATIONS = PUBLIC_CLI_ROUTE_SELECTORS['agent-client'];
 const USAGE = `Usage: ai agent-client <operation>
 
 Operations:
@@ -79,6 +81,9 @@ async function cmdAgentClient(args) {
         process.stdout.write(USAGE);
         return 0;
     }
+    if (!AGENT_CLIENT_OPERATIONS.includes(operation)) {
+        throw new AgentClientCommandError('AGENT_CLIENT_OPERATION_INVALID', `Unknown operation '${operation}'`);
+    }
     if (operation === 'list') {
         if (args.length !== 1) {
             throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'list accepts no arguments');

package/dist/lib/agent-clients/next-steps.js

@@ -1,6 +1,7 @@
 import { listEnabledAgentClientAdapters } from './registry.js';
 import { renderAgentClientInvocation } from './invocation.js';
 import semver from 'semver';
+import { isTaskScopeSkill } from '../task/skill-scope.js';
 const SAFE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 const SAFE_TASK_REF = /^(?:\d+|TASK-\d{8}-\d{6})$/;
 function requireSafeName(value, field) {
@@ -19,7 +20,11 @@ function renderNextStepCommands(input) {
         throw new Error('Invalid version');
     }
     const args = [
-        ...(input.taskRef === undefined ? [] : [input.taskRef]),
+        ...(input.taskRef === undefined
+            ? []
+            : isTaskScopeSkill(input.skillName)
+                ? ['--task', input.taskRef]
+                : [input.taskRef]),
         ...(input.version === undefined ? [] : [input.version])
     ];
     const builtins = listEnabledAgentClientAdapters(input.state).map((adapter) => Object.freeze({

package/dist/lib/decide.js

@@ -94,13 +94,13 @@ export async function decide(args, options = {}) {
             metadataProvider: () => ({ timestamp: now, agentInfraVersion: options.version ?? VERSION })
         };
         let result;
-        const execute = () => {
+        const execute = async () => {
             let current = applyHumanDecision(request, writeOptions);
             if (current.status !== 'failed' || !parsedDecision.overrideTicket)
                 return current;
             if (!parsedDecision.overrideTarget || !parsedDecision.overrideScope)
                 throw new Error('override ticket requires --override-target and --override-scope');
-            const consumed = consumeHumanOverride({
+            const consumed = await consumeHumanOverride({
                 taskRef: resolved.taskId,
                 ticketId: parsedDecision.overrideTicket,
                 failureId: failureId('decision-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
@@ -120,7 +120,7 @@ export async function decide(args, options = {}) {
                 throw new Error(consumed.error.message);
             return current;
         };
-        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute);
+        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute);
         if (result.error)
             throw new Error(result.error.message);
         return 0;

package/dist/lib/internal/agent-client.js

@@ -5,6 +5,7 @@ import { normalizeCustomTUIs } from '../agent-clients/custom-tuis.js';
 import { renderNextStepCommands } from '../agent-clients/next-steps.js';
 import { getAgentClientModelSelection } from '../agent-clients/registry.js';
 import { isAgentClientId } from '../agent-clients/types.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection> [options]\n';
 function failure(code, message) {
     process.stdout.write(`${JSON.stringify({
@@ -21,7 +22,7 @@ function parseArgs(args) {
         process.stdout.write(USAGE);
         return null;
     }
-    if (args[0] !== 'next-steps') {
+    if (!internalHandlerRoute('agent-client', 'next-steps', args[0] ?? '')) {
         failure('AGENT_CLIENT_PAYLOAD_INVALID', "operation must be 'next-steps'");
         return null;
     }
@@ -72,7 +73,9 @@ function parseArgs(args) {
     };
 }
 function agentClient(args = []) {
-    if (args[0] === 'model-selection') {
+    if (!ensureInternalHandlerRoute('agent-client', args))
+        return;
+    if (internalHandlerRoute('agent-client', 'model-selection', args[0] ?? '')) {
         const values = {};
         const seen = new Set();
         for (let index = 1; index < args.length; index += 1) {

package/dist/lib/internal/cli-route-inventory.js

@@ -0,0 +1,152 @@
+export const PUBLIC_CLI_COMMAND_ALIASES = Object.freeze({
+    '': 'help',
+    s: 'sandbox',
+    t: 'task',
+    '--version': 'version',
+    '-v': 'version'
+});
+export const PUBLIC_CLI_SELECTOR_ALIASES = Object.freeze({
+    task: Object.freeze({ d: 'decisions' })
+});
+export const PUBLIC_CLI_ROUTE_SELECTORS = Object.freeze({
+    'agent-client': ['list', 'status', 'enable', 'disable', 'configure'],
+    cp: ['cp'],
+    data: ['capture', 'verify', 'audit', 'repair', 'export'],
+    decide: ['decide'],
+    help: ['help'],
+    init: ['init'],
+    merge: ['merge'],
+    run: ['create-task', 'task-skill', 'recreate'],
+    sandbox: ['create', 'exec', 'ls', 'show', 'prune', 'rebuild', 'refresh', 'rm', 'start', 'vm'],
+    server: ['start', 'stop', 'status', 'logs', '__daemon'],
+    task: ['cat', 'decisions', 'files', 'grep', 'issue-body', 'log', 'ls', 'show', 'status'],
+    sync: ['sync'],
+    update: ['update'],
+    version: ['version']
+});
+/**
+ * The selector definitions consumed by every internal handler. Keep this
+ * module free of handler imports so the pre-import task-view guard remains
+ * effective.
+ */
+export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
+    'task-create': ['input'],
+    'task-qualification': ['proposal', 'confirm', 'supersede', 'revoke'],
+    'sandbox-control': ['serve', 'execute', 'recover', 'client'],
+    'agent-client': ['next-steps', 'model-selection'],
+    'codex-lifecycle': ['preflight', 'capability-arm', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
+    'codex-sandbox-controller': ['verify-context', 'run'],
+    'git-workflow': ['inspect', 'preview-tree', 'snapshot', 'compare-trees', 'commit', 'push-rebased'],
+    'task-delivery': ['deliver'],
+    'release-workflow': ['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'],
+    'platform-release-notes': ['context', 'stage', 'publish'],
+    'platform-security': ['read', 'dismiss'],
+    'platform-metadata': ['init-labels', 'init-milestones'],
+    'platform-context': ['resolve'],
+    'platform-comment': ['list', 'owner', 'backfill', 'sync'],
+    'platform-issue': ['inspect', 'create', 'bind', 'sync'],
+    'platform-pr': ['inspect', 'summary-context', 'resolve-external', 'create', 'bind', 'skip', 'sync', 'change-report', 'summary-sync', 'sync-in-labels'],
+    'platform-pr-review': ['inspect', 'list', 'publish-pr', 'publish-task'],
+    'pr-review-grade': ['decide', 'resolve-host', 'verify-artifact'],
+    'platform-checks': ['inspect', 'watch', 'resolve-run', 'logs'],
+    'task-context': ['resolve'],
+    'task-ledger': ['decision-next-id', 'stage-status', 'finding-upsert', 'finding-respond', 'finding-review', 'decision-upsert', 'rework-intent-upsert'],
+    'task-warning': ['list', 'add', 'set-status'],
+    'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
+    'task-artifact': ['inspect', 'init', 'repair', 'finalize-local'],
+    'task-orchestration': ['status', 'progress'],
+    'task-review': ['finalize-summary'],
+    'task-event': ['event'],
+    'task-invalidation': ['reconcile'],
+    'task-override': ['diagnose', 'issue', 'consume'],
+    'task-lifecycle': ['intent'],
+    'task-finalization': ['complete'],
+    'task-short-id': ['list', 'list-verify', 'alloc', 'release', 'resolve'],
+    'task-snapshot': ['snapshot'],
+    'task-verify': ['event'],
+    'task-validate': ['snapshot', 'inplace']
+});
+export const INTERNAL_CLI_ROUTE_SELECTORS = INTERNAL_HANDLER_ROUTE_SELECTORS;
+function first(args) {
+    return args[0] ?? '';
+}
+function optionValue(args, name) {
+    const index = args.indexOf(name);
+    if (index >= 0)
+        return args[index + 1];
+    const prefix = `${name}=`;
+    return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+export function internalRouteSelector(command, args) {
+    if (command === 'sandbox-control')
+        return first(args);
+    if (command === 'task-create')
+        return 'input';
+    if (command === 'task-qualification')
+        return args[1] ?? '';
+    if (command === 'task-lifecycle')
+        return args[1] ? 'intent' : '';
+    if (command === 'task-finalization')
+        return args[1] === 'complete' ? 'complete' : '';
+    if (command === 'task-event')
+        return args[1] ? 'event' : '';
+    if (command === 'task-verify')
+        return args[0] && args[1] ? 'event' : '';
+    if (command === 'task-snapshot')
+        return 'snapshot';
+    if (command === 'task-validate')
+        return optionValue(args, '--scope') ?? 'snapshot';
+    if (command === 'task-short-id')
+        return first(args) === 'list' && args.includes('--verify') ? 'list-verify' : first(args);
+    if (command === 'task-orchestration')
+        return args[1] === 'status' ? 'status' : args[1] ? 'progress' : '';
+    if (command === 'task-review')
+        return args[1] ?? '';
+    if (command === 'task-invalidation')
+        return args[1] ?? '';
+    if (command === 'task-override')
+        return args[1] ?? '';
+    if (command === 'task-artifact')
+        return args[1] ?? '';
+    if (command === 'platform-pr-review' && first(args) === 'publish') {
+        const scope = optionValue(args, '--scope') ?? '';
+        return /^TASK-\d{8}-\d{6}$/u.test(scope) ? 'publish-task' : /^pr\d+$/u.test(scope) ? 'publish-pr' : '';
+    }
+    if (['task-ledger', 'task-warning', 'task-activity'].includes(command))
+        return args[1] ?? '';
+    if (command === 'task-delivery')
+        return args[1] ?? '';
+    if (command === 'task-context')
+        return first(args);
+    return first(args);
+}
+export function isInternalHandlerRoute(command, args) {
+    if (args[0] === '--help' || args[0] === '-h')
+        return true;
+    const selector = internalRouteSelector(command, args);
+    const selectors = INTERNAL_HANDLER_ROUTE_SELECTORS[command];
+    return Boolean(selector && selectors?.some((candidate) => candidate === selector));
+}
+/**
+ * Marks a selector at the handler's actual dispatch branch.
+ *
+ * The call is intentionally side-effect free so the top-level task-view guard
+ * can still run before a handler module is imported. Route coverage tests read
+ * these branch markers independently from the pre-import inventory.
+ */
+export function internalHandlerRoute(command, selector, actualSelector) {
+    return command.length > 0 && selector === actualSelector;
+}
+export function ensureInternalHandlerRoute(command, args) {
+    if (isInternalHandlerRoute(command, args))
+        return true;
+    const selector = internalRouteSelector(command, args);
+    process.stdout.write(`${JSON.stringify({
+        status: 'failed',
+        changed: false,
+        error: { code: 'INTERNAL_ROUTE_UNREGISTERED', message: `operation '${command} ${selector || first(args)}' is not registered` }
+    })}\n`);
+    process.exitCode = 1;
+    return false;
+}
+//# sourceMappingURL=cli-route-inventory.js.map

package/dist/lib/internal/codex-lifecycle.js

@@ -10,6 +10,7 @@ import { verifyCodexSandboxControllerContextWithWarnings } from '../agent-client
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { hasSealableOrchestrationDelegation } from '../task/orchestration.js';
 import { activateCodexOrchestrationDelegation, activateCodexSpawnDelegation, reconcileCodexOrchestrationDelegation, sealCodexOrchestrationDelegation, sealCodexParentDelegation } from '../task/codex-orchestration.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 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)$/;
 function output(value) {
@@ -144,11 +145,13 @@ function payloadText(payload, key) {
         : '';
 }
 async function codexLifecycle(args = []) {
+    if (!ensureInternalHandlerRoute('codex-lifecycle', args))
+        return;
     const parsed = parse(args);
     if (!parsed || process.exitCode)
         return;
     try {
-        if (parsed.operation === 'preflight') {
+        if (internalHandlerRoute('codex-lifecycle', 'preflight', parsed.operation)) {
             const format = parsed.values['--format'] ?? 'json';
             if (!['text', 'json'].includes(format))
                 throw new Error("format must be 'text' or 'json'");
@@ -173,7 +176,7 @@ async function codexLifecycle(args = []) {
                 output({ status: 'ready', changed: false, evidence: result, diagnostics: result.diagnostics, error: null });
             return;
         }
-        if (parsed.operation === 'capability-arm') {
+        if (internalHandlerRoute('codex-lifecycle', 'capability-arm', parsed.operation)) {
             const taskId = parsed.values['--task-id'];
             if (!taskId)
                 throw new Error('capability-arm requires --task-id');
@@ -197,7 +200,7 @@ async function codexLifecycle(args = []) {
             return;
         }
         const store = createCodexLifecycleStore({ cliVersion: cliVersion() });
-        if (parsed.operation === 'hook-event') {
+        if (internalHandlerRoute('codex-lifecycle', 'hook-event', parsed.operation)) {
             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');
@@ -337,7 +340,7 @@ async function codexLifecycle(args = []) {
         const childThreadId = parsed.values['--child-id'];
         if (!childThreadId)
             throw new Error(`operation '${parsed.operation}' requires --child-id`);
-        if (parsed.operation === 'resolve-start') {
+        if (internalHandlerRoute('codex-lifecycle', 'resolve-start', parsed.operation)) {
             if (store.read(childThreadId).state.spawn?.hookDefinitionHash !== hookDefinitionHash()) {
                 throw new Error('Codex lifecycle hook definition hash is stale');
             }
@@ -351,7 +354,7 @@ async function codexLifecycle(args = []) {
                 process.exitCode = 1;
             return;
         }
-        if (parsed.operation === 'resolve-stop') {
+        if (internalHandlerRoute('codex-lifecycle', 'resolve-stop', parsed.operation)) {
             const stopTurnId = store.read(childThreadId).state.stop?.turnId;
             if (!stopTurnId)
                 throw new Error('Codex lifecycle stop hook is not available');
@@ -363,7 +366,7 @@ async function codexLifecycle(args = []) {
             output({ status: latest.state.status, changed: true, evidence: latest.state.stopEvidence, diagnostics: [], error: latest.state.error });
             return;
         }
-        if (parsed.operation === 'consume') {
+        if (internalHandlerRoute('codex-lifecycle', 'consume', parsed.operation)) {
             const consumer = parsed.values['--consumer'];
             if (!consumer)
                 throw new Error('consume requires --consumer');

package/dist/lib/internal/codex-sandbox-controller.js

@@ -1,4 +1,5 @@
 import { runCodexSandboxController, verifyCodexSandboxControllerContextWithWarnings } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 const USAGE = 'Usage: agent-infra-internal codex-sandbox-controller <run|verify-context> [options]\n';
 function fail(code, message, exitCode = 1) {
     process.stdout.write(`${JSON.stringify({
@@ -14,7 +15,10 @@ function parse(args) {
         return null;
     }
     const operation = args[0];
-    if (!operation || !['run', 'verify-context'].includes(operation)) {
+    if (!operation || ![
+        internalHandlerRoute('codex-sandbox-controller', 'run', operation),
+        internalHandlerRoute('codex-sandbox-controller', 'verify-context', operation)
+    ].some(Boolean)) {
         process.stderr.write(USAGE);
         fail('CODEX_SANDBOX_CONTROLLER_PAYLOAD_INVALID', 'operation must be run or verify-context', 2);
         return null;
@@ -44,11 +48,13 @@ function parse(args) {
     return { operation, values };
 }
 async function codexSandboxController(args = []) {
+    if (!ensureInternalHandlerRoute('codex-sandbox-controller', args))
+        return;
     const parsed = parse(args);
     if (!parsed || process.exitCode)
         return;
     try {
-        if (parsed.operation === 'verify-context') {
+        if (internalHandlerRoute('codex-sandbox-controller', 'verify-context', parsed.operation)) {
             const contextPath = parsed.values['--context']
                 ?? process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
             if (!contextPath)

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

@@ -3,42 +3,46 @@ import { inspectGitWorkflow, previewCommitTree, pushRebasedBranch } from '../git
 import { compareReviewTrees, snapshotReview } from '../git/review-snapshot.js';
 import { resolvePostReviewGlobs } from '../task/review-fingerprint.js';
 import { executeCommitOperation } from '../task/commit-operation.js';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
 function output(value) { process.stdout.write(`${JSON.stringify(value)}\n`); }
 function gitWorkflow(args = []) {
+    if (!ensureInternalHandlerRoute('git-workflow', args))
+        return;
     const [action, ...rest] = args;
     const cwdIndex = rest.indexOf('--cwd');
     const cwd = cwdIndex >= 0 ? rest[cwdIndex + 1] : process.cwd();
     let result;
-    if (action === 'inspect') {
+    if (internalHandlerRoute('git-workflow', 'inspect', action ?? '')) {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
         result = inspectGitWorkflow(cwd ?? process.cwd(), undefined, input?.remote && input.refs ? { remote: input.remote, refs: input.refs } : undefined);
     }
-    else if (action === 'commit') {
+    else if (internalHandlerRoute('git-workflow', 'commit', action ?? '')) {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
         result = input
             ? executeCommitOperation({ cwd: cwd ?? process.cwd(), ...input })
             : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
     }
-    else if (action === 'push-rebased') {
+    else if (internalHandlerRoute('git-workflow', 'push-rebased', action ?? '')) {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
         result = input ? pushRebasedBranch({ cwd: cwd ?? process.cwd(), ...input }) : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
     }
-    else if (action === 'preview-tree') {
+    else if (internalHandlerRoute('git-workflow', 'preview-tree', action ?? '')) {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
         result = input
             ? previewCommitTree({ cwd: cwd ?? process.cwd(), paths: input.paths, expectedHead: input.expectedHead })
             : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
     }
-    else if (action === 'snapshot' || action === 'compare-trees') {
+    else if (internalHandlerRoute('git-workflow', 'snapshot', action ?? '')
+        || internalHandlerRoute('git-workflow', 'compare-trees', action ?? '')) {
         const inputIndex = rest.indexOf('--input');
         const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1], 'utf8')) : null;
         if (!input)
             result = { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
-        else if (action === 'snapshot')
+        else if (internalHandlerRoute('git-workflow', 'snapshot', action ?? ''))
             result = { status: 'no-op', changed: false, snapshot: snapshotReview({ cwd: cwd ?? process.cwd(), mode: input.mode, baseline: input.baseline, diffBase: input.diffBase, globs: input.globs ?? resolvePostReviewGlobs({}, {}) }), error: null };
         else
             result = { status: 'no-op', changed: false, comparison: compareReviewTrees({ cwd: cwd ?? process.cwd(), expected: input.expected, actual: input.actual }), error: null };