@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/agent-clients/adapters/antigravity-cli.ts

@@ -11,7 +11,6 @@ const antigravityCliAdapter = defineAgentClientAdapter({
     commands: { level: 'integrated' },
     hooks: { level: 'compatible' },
     subagents: { level: 'unsupported' },
-    orchestration: { level: 'unsupported' },
     sandbox: { level: 'integrated' },
     verification: { level: 'compatible' }
   },
@@ -20,10 +19,6 @@ const antigravityCliAdapter = defineAgentClientAdapter({
     command: '/model',
     guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
   },
-  delegationEvidence: {
-    actualModel: 'unavailable',
-    actualReasoningEffort: 'unavailable'
-  },
   project: {
     ownedPathPrefixes: [],
     managed: [],

package/lib/agent-clients/adapters/claude-code-credentials.ts

@@ -581,25 +581,6 @@ export function reconcileClaudeCredentials(home: string, options: ReconcileOptio
   };
 }
 
-export function syncClaudeCredentialsFromKeychain(home: string, project: string, options: ReconcileOptions = {}) {
-  const result = reconcileClaudeCredentials(home, {
-    ...options,
-    singleProject: project
-  });
-  if (result.status !== 'OK' && result.status !== 'KEYCHAIN_WRITE_FAILED') {
-    return {
-      status: result.status,
-      written: false
-    };
-  }
-
-  return {
-    status: result.status === 'KEYCHAIN_WRITE_FAILED' ? 'OK' : result.status,
-    written: result.filesWritten.includes(project),
-    expiresAt: result.expiresAt
-  };
-}
-
 export function formatRemaining(expiresAt: unknown): string {
   if (typeof expiresAt !== 'number') {
     return 'unknown';

package/lib/agent-clients/adapters/claude-code.ts

@@ -16,7 +16,6 @@ const claudeCodeAdapter = defineAgentClientAdapter({
     commands: { level: 'integrated' },
     hooks: { level: 'integrated' },
     subagents: { level: 'experimental' },
-    orchestration: { level: 'experimental' },
     sandbox: { level: 'integrated' },
     verification: { level: 'compatible' }
   },
@@ -25,14 +24,6 @@ const claudeCodeAdapter = defineAgentClientAdapter({
     command: '/model',
     guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
   },
-  delegationEvidence: {
-    actualModel: 'host-event',
-    actualReasoningEffort: 'spawn-ack',
-    spawnModeRequired: false,
-    actualModelRequired: false,
-    actualReasoningEffortRequired: false,
-    fallbackReasonRequired: false
-  },
   project: {
     ownedPathPrefixes: ['.claude/'],
     managed: ['.claude/commands/', '.claude/agents/', '.claude/rules/'],

package/lib/agent-clients/adapters/codex.ts

@@ -4,44 +4,6 @@ import {
   codexBeforeContainerCreateHook,
   codexRecoveryChecks
 } from './codex-sandbox.ts';
-import { parseCodexLifecycleBinding } from './codex-lifecycle/binding.ts';
-import { isCodexDelegationReceiptEvidence, isCodexLifecycleActivationEvidence } from './codex-lifecycle/evidence.ts';
-
-function codexCarrierError(code: string): Error {
-  const error = new Error(code);
-  error.name = code;
-  return error;
-}
-
-function codexStageToken(stage: string): string {
-  const tokens: Readonly<Record<string, string>> = {
-    analysis: 'a',
-    plan: 'p',
-    code: 'c',
-    'review-analysis': 'ra',
-    'review-plan': 'rp',
-    'review-code': 'rc',
-    commit: 'm'
-  };
-  const token = tokens[stage];
-  if (!token) throw codexCarrierError('CODEX_LIFECYCLE_SPAWN_IDENTITY_INVALID');
-  return token;
-}
-
-function codexLaunchCarrier(
-  adapterContext: string,
-  identity: Readonly<{ stage: string; round: number; role: string }>
-): Readonly<Record<string, string>> {
-  if (!Number.isSafeInteger(identity.round) || identity.round < 1
-    || !['executor', 'reviewer'].includes(identity.role)) {
-    throw codexCarrierError('CODEX_LIFECYCLE_SPAWN_IDENTITY_INVALID');
-  }
-  const label = `${codexStageToken(identity.stage)}_${identity.role === 'reviewer' ? 'r' : 'e'}_r${identity.round}`;
-  const taskName = `${label}${adapterContext}`;
-  const parsed = parseCodexLifecycleBinding(taskName);
-  if (!parsed) throw codexCarrierError('CODEX_LIFECYCLE_LAUNCH_CONTEXT_INVALID');
-  return Object.freeze({ task_name: parsed.taskName });
-}
 
 const codexAdapter = defineAgentClientAdapter({
   id: 'codex',
@@ -53,7 +15,6 @@ const codexAdapter = defineAgentClientAdapter({
     commands: { level: 'integrated' },
     hooks: { level: 'integrated' },
     subagents: { level: 'experimental' },
-    orchestration: { level: 'experimental' },
     sandbox: { level: 'integrated' },
     verification: { level: 'compatible' }
   },
@@ -62,23 +23,6 @@ const codexAdapter = defineAgentClientAdapter({
     command: '/model',
     guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
   },
-  delegationEvidence: {
-    actualModel: 'app-server',
-    actualReasoningEffort: 'app-server'
-  },
-  orchestrationAdapter: {
-    validateActivationEvidence: isCodexLifecycleActivationEvidence,
-    validateReceiptEvidence: isCodexDelegationReceiptEvidence,
-    createLaunchCarrier: codexLaunchCarrier,
-    prepareDelegation: async (...args) => {
-      const { prepareCodexOrchestrationDelegation } = await import('./codex-orchestration.ts');
-      return prepareCodexOrchestrationDelegation(...args);
-    },
-    recoverStarted: async (...args) => {
-      const { recoverStartedLifecycleFromAdapter } = await import('./codex-lifecycle/recovery.ts');
-      return recoverStartedLifecycleFromAdapter(...args);
-    }
-  },
   project: {
     ownedPathPrefixes: ['.codex/'],
     managed: ['.codex/hooks.json', '.codex/agents/'],

package/lib/agent-clients/adapters/opencode.ts

@@ -17,7 +17,6 @@ const opencodeAdapter = defineAgentClientAdapter({
     commands: { level: 'integrated' },
     hooks: { level: 'compatible' },
     subagents: { level: 'unsupported' },
-    orchestration: { level: 'unsupported' },
     sandbox: { level: 'integrated' },
     verification: { level: 'compatible' }
   },
@@ -26,10 +25,6 @@ const opencodeAdapter = defineAgentClientAdapter({
     command: '/models',
     guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
   },
-  delegationEvidence: {
-    actualModel: 'unavailable',
-    actualReasoningEffort: 'unavailable'
-  },
   project: {
     ownedPathPrefixes: ['.opencode/'],
     managed: ['.opencode/commands/'],

package/lib/agent-clients/adapters/traecli.ts

@@ -11,7 +11,6 @@ const traecliAdapter = defineAgentClientAdapter({
     commands: { level: 'integrated' },
     hooks: { level: 'compatible' },
     subagents: { level: 'experimental' },
-    orchestration: { level: 'experimental' },
     sandbox: { level: 'integrated' },
     verification: { level: 'compatible' }
   },
@@ -20,10 +19,6 @@ const traecliAdapter = defineAgentClientAdapter({
     command: '/model',
     guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
   },
-  delegationEvidence: {
-    actualModel: 'unavailable',
-    actualReasoningEffort: 'unavailable'
-  },
   project: {
     ownedPathPrefixes: ['.traecli/'],
     managed: ['.traecli/commands/'],

package/lib/agent-clients/config.ts

@@ -6,8 +6,7 @@ import type {
   AgentClientConfig,
   AgentClientId,
   AgentClientsConfig,
-  AgentClientState,
-  OrchestrationModelPolicy
+  AgentClientState
 } from './types.ts';
 
 type AgentClientConfigInput = Readonly<Record<string, unknown>>;
@@ -54,49 +53,12 @@ function fail(code: AgentClientDiagnosticCode, path: string): never {
   throw new AgentClientConfigError({ code, path });
 }
 
-function parseExactText(value: unknown, path: string): string {
-  if (typeof value !== 'string' || value.length === 0 || value.trim() !== value) {
-    fail('INVALID_AGENT_CLIENTS', path);
-  }
-  return value;
-}
-
-function parseOrchestrationPolicy(value: unknown, path: string): OrchestrationModelPolicy {
-  if (!isRecord(value)) fail('INVALID_AGENT_CLIENTS', path);
-  const keys = Object.keys(value);
-  if (
-    keys.length !== 2
-    || !hasOwn(value, 'executor')
-    || !hasOwn(value, 'reviewer')
-  ) {
-    fail('INVALID_AGENT_CLIENTS', path);
-  }
-  const parseRole = (candidate: unknown, rolePath: string) => {
-    if (
-      !isRecord(candidate)
-      || Object.keys(candidate).length !== 2
-      || !hasOwn(candidate, 'model')
-      || !hasOwn(candidate, 'reasoningEffort')
-    ) {
-      fail('INVALID_AGENT_CLIENTS', rolePath);
-    }
-    return Object.freeze({
-      model: parseExactText(candidate.model, `${rolePath}.model`),
-      reasoningEffort: parseExactText(candidate.reasoningEffort, `${rolePath}.reasoningEffort`)
-    });
-  };
-  const executor = parseRole(value.executor, `${path}.executor`);
-  const reviewer = parseRole(value.reviewer, `${path}.reviewer`);
-  return Object.freeze({ executor, reviewer });
-}
-
 function parseCanonical(value: unknown): AgentClientState {
   if (!Array.isArray(value)) fail('INVALID_AGENT_CLIENTS', 'agentClients');
 
   const entries = new Map<AgentClientId, Readonly<{
     enabled: boolean;
     installInSandbox: boolean;
-    orchestration?: OrchestrationModelPolicy;
   }>>();
 
   for (const [index, candidate] of value.entries()) {
@@ -105,11 +67,10 @@ function parseCanonical(value: unknown): AgentClientState {
 
     const keys = Object.keys(candidate);
     if (
-      (keys.length !== 3 && keys.length !== 4)
+      keys.length !== 3
       || !hasOwn(candidate, 'id')
       || !hasOwn(candidate, 'enabled')
       || !hasOwn(candidate, 'installInSandbox')
-      || (keys.length === 4 && !hasOwn(candidate, 'orchestration'))
     ) {
       fail('INVALID_AGENT_CLIENTS', path);
     }
@@ -127,10 +88,7 @@ function parseCanonical(value: unknown): AgentClientState {
     }
     entries.set(candidate.id, {
       enabled: candidate.enabled,
-      installInSandbox: candidate.installInSandbox,
-      ...(hasOwn(candidate, 'orchestration')
-        ? { orchestration: parseOrchestrationPolicy(candidate.orchestration, `${path}.orchestration`) }
-        : {})
+      installInSandbox: candidate.installInSandbox
     });
   }
 
@@ -147,25 +105,11 @@ function serializeAgentClients(state: AgentClientState): AgentClientsConfig {
   return AGENT_CLIENT_IDS.map((id): AgentClientConfig => ({
     id,
     enabled: state[id].enabled,
-    installInSandbox: state[id].installInSandbox,
-    ...(state[id].orchestration
-      ? { orchestration: structuredClone(state[id].orchestration) }
-      : {})
+    installInSandbox: state[id].installInSandbox
   }));
 }
 
-function normalizeAgentClients(
-  input: AgentClientConfigInput
-): NormalizeAgentClientsResult {
-  if (!hasOwn(input, 'agentClients')) fail('MISSING_AGENT_CLIENT', 'agentClients');
-  const state = parseCanonical(input.agentClients);
-  for (const [index, id] of AGENT_CLIENT_IDS.entries()) {
-    const entry = Array.isArray(input.agentClients) ? input.agentClients[index] : undefined;
-    if (!isRecord(entry) || entry.id !== id) {
-      fail('INVALID_AGENT_CLIENTS', `agentClients[${index}].id`);
-    }
-  }
-  if (hasOwn(input, 'tuis')) fail('INVALID_AGENT_CLIENTS', 'tuis');
+function validateSandboxTools(input: AgentClientConfigInput): void {
   const sandbox = isRecord(input.sandbox) ? input.sandbox : undefined;
   if (sandbox && hasOwn(sandbox, 'customTools')) {
     fail('INVALID_AGENT_CLIENTS', 'sandbox.customTools');
@@ -180,6 +124,21 @@ function normalizeAgentClients(
       }
     }
   }
+}
+
+function normalizeAgentClients(
+  input: AgentClientConfigInput
+): NormalizeAgentClientsResult {
+  if (!hasOwn(input, 'agentClients')) fail('MISSING_AGENT_CLIENT', 'agentClients');
+  const state = parseCanonical(input.agentClients);
+  for (const [index, id] of AGENT_CLIENT_IDS.entries()) {
+    const entry = Array.isArray(input.agentClients) ? input.agentClients[index] : undefined;
+    if (!isRecord(entry) || entry.id !== id) {
+      fail('INVALID_AGENT_CLIENTS', `agentClients[${index}].id`);
+    }
+  }
+  if (hasOwn(input, 'tuis')) fail('INVALID_AGENT_CLIENTS', 'tuis');
+  validateSandboxTools(input);
   return {
     state,
     canonical: serializeAgentClients(state)

package/lib/agent-clients/registry.ts

@@ -5,12 +5,7 @@ import type {
   AgentClientManifestEntry,
   AgentClientRegistry
 } from './adapter.ts';
-import type {
-  AgentClientCapabilityId,
-  AgentClientCapabilitySupport,
-  AgentClientState,
-  AgentClientSupportLevel
-} from './types.ts';
+import type { AgentClientState } from './types.ts';
 
 function buildRegistry(): Readonly<{
   registry: AgentClientRegistry;
@@ -97,35 +92,10 @@ function listInstalledAgentClientAdapters(
   );
 }
 
-function getAgentClientCapability(
-  id: unknown,
-  capability: AgentClientCapabilityId
-): AgentClientCapabilitySupport {
-  return getAgentClientAdapter(id).capabilities[capability];
-}
-
 function getAgentClientModelSelection(id: unknown) {
   return getAgentClientAdapter(id).modelSelection;
 }
 
-function getAgentClientDelegationEvidence(id: unknown) {
-  return getAgentClientAdapter(id).delegationEvidence;
-}
-
-function listEnabledAgentClientAdaptersByCapability(
-  state: AgentClientState,
-  capability: AgentClientCapabilityId,
-  acceptedLevels: readonly AgentClientSupportLevel[]
-): readonly AgentClientAdapter[] {
-  const accepted = new Set(acceptedLevels);
-  return Object.freeze(
-    AGENT_CLIENT_ADAPTERS.filter((adapter) =>
-      state[adapter.id].enabled
-      && accepted.has(adapter.capabilities[capability].level)
-    )
-  );
-}
-
 function createAgentClientManifest(): readonly AgentClientManifestEntry[] {
   return Object.freeze(
     AGENT_CLIENT_ADAPTERS.map((adapter) => Object.freeze({
@@ -152,11 +122,8 @@ export {
   AGENT_CLIENT_REGISTRY,
   createAgentClientManifest,
   getAgentClientAdapter,
-  getAgentClientCapability,
-  getAgentClientDelegationEvidence,
   getAgentClientModelSelection,
   listAgentClientAdapters,
   listEnabledAgentClientAdapters,
-  listEnabledAgentClientAdaptersByCapability,
   listInstalledAgentClientAdapters
 };

package/lib/agent-clients/schema.ts

@@ -31,15 +31,6 @@ const AGENT_CLIENTS_SCHEMA = {
           installInSandbox: {
             type: 'boolean'
           },
-          orchestration: {
-            type: 'object',
-            additionalProperties: false,
-            required: ['executor', 'reviewer'],
-            properties: {
-              executor: { $ref: '#/definitions/orchestrationRolePolicy' },
-              reviewer: { $ref: '#/definitions/orchestrationRolePolicy' }
-            }
-          }
         }
       }))
     },
@@ -66,15 +57,6 @@ const AGENT_CLIENTS_SCHEMA = {
     }
   },
   definitions: {
-    orchestrationRolePolicy: {
-      type: 'object',
-      additionalProperties: false,
-      required: ['model', 'reasoningEffort'],
-      properties: {
-        model: { type: 'string', minLength: 1 },
-        reasoningEffort: { type: 'string', minLength: 1 }
-      }
-    },
     agentClientCapabilityId: {
       type: 'string',
       enum: [...AGENT_CLIENT_CAPABILITY_IDS]

package/lib/agent-clients/tokens.ts

@@ -5,8 +5,7 @@ export const AGENT_TOKEN_VALUES = ['claude', 'codex', 'antigravity', 'opencode',
 export type AgentToken = (typeof AGENT_TOKEN_VALUES)[number];
 export const KNOWN_AI_AGENTS: ReadonlySet<string> = new Set(AGENT_TOKEN_VALUES);
 
-// Long name -> short name mapping: `claude-code` reuses the existing
-// orchestration precedent, and `antigravity-cli` is the active client.
+// Long name -> short name mapping for the activity-log agent field.
 export const AGENT_LONG_NAMES: Readonly<Record<string, string>> = {
   'claude-code': 'claude',
   'antigravity-cli': 'antigravity'

package/lib/agent-clients/types.ts

@@ -8,21 +8,10 @@ const AGENT_CLIENT_IDS = [
 
 type AgentClientId = (typeof AGENT_CLIENT_IDS)[number];
 
-type OrchestrationRolePolicy = Readonly<{
-  model: string;
-  reasoningEffort: string;
-}>;
-
-type OrchestrationModelPolicy = Readonly<{
-  executor: OrchestrationRolePolicy;
-  reviewer: OrchestrationRolePolicy;
-}>;
-
 type AgentClientConfig = Readonly<{
   id: AgentClientId;
   enabled: boolean;
   installInSandbox: boolean;
-  orchestration?: OrchestrationModelPolicy;
 }>;
 
 type AgentClientsConfig = readonly AgentClientConfig[];
@@ -33,7 +22,6 @@ type AgentClientState = Readonly<
     Readonly<{
       enabled: boolean;
       installInSandbox: boolean;
-      orchestration?: OrchestrationModelPolicy;
     }>
   >
 >;
@@ -44,7 +32,6 @@ const AGENT_CLIENT_CAPABILITY_IDS = [
   'commands',
   'hooks',
   'subagents',
-  'orchestration',
   'sandbox',
   'verification'
 ] as const;
@@ -81,8 +68,6 @@ export {
 };
 export type {
   AgentClientId,
-  OrchestrationRolePolicy,
-  OrchestrationModelPolicy,
   AgentClientConfig,
   AgentClientsConfig,
   AgentClientState,

package/lib/decide.ts

@@ -71,6 +71,7 @@ export async function decide(args: string[], options: DecideOptions = {}): Promi
     };
     const result = await applyHumanDecision(request, writeOptions);
     if (result.error) throw new Error(result.error.message);
+    for (const warning of result.warnings ?? []) process.stderr.write(`Warning: ${warning.code}: ${warning.message}\n`);
     return 0;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/lib/git/worktree-identity.ts

@@ -67,18 +67,8 @@ function assertGitWorktreeBinding(
   return worktree;
 }
 
-function assertGitRepositoryBinding(stateRoot: string, worktreeRoot: string): GitWorktreeIdentity {
-  const state = resolveGitWorktreeIdentity(stateRoot);
-  const worktree = resolveGitWorktreeIdentity(worktreeRoot);
-  if (!sameFilesystemEntry(state.commonDir, worktree.commonDir)) {
-    throw new Error('SANDBOX_CONTROL_WORKTREE_INVALID: state and worktree roots have different Git common directories');
-  }
-  return worktree;
-}
-
 export {
   assertGitWorktreeBinding,
-  assertGitRepositoryBinding,
   normalizeCanonicalPath,
   resolveGitWorktreeIdentity,
   sameFilesystemEntry

package/lib/internal/agent-client.ts

@@ -7,11 +7,11 @@ import {
 } from '../agent-clients/config.ts';
 import { normalizeCustomToolInvocations } from '../agent-clients/custom-tool-invocations.ts';
 import { renderNextStepCommands } from '../agent-clients/next-steps.ts';
-import { getAgentClientAdapter, getAgentClientModelSelection } from '../agent-clients/registry.ts';
+import { getAgentClientModelSelection } from '../agent-clients/registry.ts';
 import { isAgentClientId } from '../agent-clients/types.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection|launch-carrier> [options]\n';
+const USAGE = 'Usage: agent-infra-internal agent-client <next-steps|model-selection> [options]\n';
 
 type ParsedArgs = Readonly<{
   skillName: string;
@@ -20,14 +20,6 @@ type ParsedArgs = Readonly<{
   format: 'text' | 'json';
 }>;
 
-type LaunchCarrierArgs = Readonly<{
-  client: string;
-  adapterContext: string;
-  stage: string;
-  round: number;
-  role: string;
-}>;
-
 function failure(code: string, message: string): void {
   process.stdout.write(`${JSON.stringify({
     status: 'failed',
@@ -92,63 +84,6 @@ function parseArgs(args: string[]): ParsedArgs | null {
   };
 }
 
-function parseLaunchCarrierArgs(args: string[]): LaunchCarrierArgs | null {
-  const allowed = new Set(['--client', '--adapter-context', '--stage', '--round', '--role', '--format']);
-  const values: Record<string, string> = {};
-  const seen = new Set<string>();
-  for (let index = 1; index < args.length; index += 1) {
-    const flag = args[index]!;
-    if (!allowed.has(flag) || seen.has(flag)) {
-      failure('AGENT_CLIENT_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
-      return null;
-    }
-    const value = args[++index];
-    if (!value || value.startsWith('--')) {
-      failure('AGENT_CLIENT_PAYLOAD_INVALID', `option '${flag}' requires a value`);
-      return null;
-    }
-    seen.add(flag);
-    values[flag] = value;
-  }
-  const round = Number(values['--round']);
-  if (!isAgentClientId(values['--client']) || !values['--adapter-context'] || !values['--stage'] || !values['--role']
-    || !Number.isSafeInteger(round) || round < 1 || (values['--format'] ?? 'json') !== 'json') {
-    failure('AGENT_CLIENT_PAYLOAD_INVALID', 'launch-carrier requires client, adapter context, stage, positive round, role, and json format');
-    return null;
-  }
-  return {
-    client: values['--client']!,
-    adapterContext: values['--adapter-context']!,
-    stage: values['--stage']!,
-    round,
-    role: values['--role']!
-  };
-}
-
-function launchCarrier(args: string[]): void {
-  const parsed = parseLaunchCarrierArgs(args);
-  if (!parsed) return;
-  const createCarrier = getAgentClientAdapter(parsed.client).orchestrationAdapter?.createLaunchCarrier;
-  if (!createCarrier) {
-    process.stdout.write(`${JSON.stringify({
-      status: 'failed', changed: false, client: parsed.client, carrier: null,
-      error: { code: 'AGENT_CLIENT_LAUNCH_CARRIER_UNSUPPORTED', message: `Agent Client '${parsed.client}' does not support lifecycle launch carriers` }
-    })}\n`);
-    process.exitCode = 1;
-    return;
-  }
-  try {
-    const carrier = createCarrier(parsed.adapterContext, { stage: parsed.stage, round: parsed.round, role: parsed.role });
-    process.stdout.write(`${JSON.stringify({ status: 'ready', changed: false, client: parsed.client, carrier, error: null })}\n`);
-  } catch (error) {
-    process.stdout.write(`${JSON.stringify({
-      status: 'failed', changed: false, client: parsed.client, carrier: null,
-      error: { code: error instanceof Error && error.name ? error.name : 'AGENT_CLIENT_LAUNCH_CARRIER_INVALID', message: error instanceof Error ? error.message : String(error) }
-    })}\n`);
-    process.exitCode = 1;
-  }
-}
-
 function modelSelection(args: string[]): void {
   const values: Record<string, string> = {};
   const seen = new Set<string>();
@@ -245,9 +180,6 @@ function writeNextStepOutput(
 
 function agentClient(args: string[] = []): void {
   if (!ensureInternalHandlerRoute('agent-client', args)) return;
-  if (internalHandlerRoute('agent-client', 'launch-carrier', args[0] ?? '')) {
-    return launchCarrier(args);
-  }
   if (internalHandlerRoute('agent-client', 'model-selection', args[0] ?? '')) {
     return modelSelection(args);
   }

package/lib/internal/cli-route-inventory.ts

@@ -36,8 +36,7 @@ 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', 'launch-carrier'],
-  'codex-lifecycle': ['preflight', 'hook-event', 'resolve-start', 'resolve-stop', 'consume'],
+  'agent-client': ['next-steps', 'model-selection'],
   'git-workflow': ['inspect', 'preview-tree', 'snapshot', 'compare-trees', 'commit', 'push-rebased'],
   'task-delivery': ['deliver'],
   'release-workflow': ['inspect', 'prepare', 'publish', 'post-prepare', 'post-publish'],
@@ -57,7 +56,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-warning': ['list', 'add', 'set-status'],
   'task-activity': ['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate'],
   'task-artifact': ['inspect', 'init', 'preflight', 'finalize-local'],
-  'task-orchestration': ['status', 'progress'],
   'task-review': ['preflight', 'finalize-summary'],
   'task-event': ['event'],
   'task-lifecycle': ['intent'],
@@ -95,7 +93,6 @@ export function internalRouteSelector(command: string, args: readonly string[]):
   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-artifact') return args[1] ?? '';
   if (command === 'platform-pr-review' && first(args) === 'publish') {