@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/task/write.js

@@ -5,6 +5,7 @@ import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { mutateTableRow, upsertSection } from './sections.js';
+import { lifecycleExecutions, prReviewExecution, serializeLifecycleExecution } from './lifecycle-execution.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 const DEFAULT_FILE_SYSTEM = {
     readFileSync: (file) => fs.readFileSync(file, 'utf8'),
@@ -104,7 +105,16 @@ function writeTaskCore(request, options = {}) {
             }
             const before = candidate;
             if (mutation.kind === 'frontmatter') {
-                candidate = updateTaskFrontmatter(candidate, mutation.set, mutation.remove);
+                let set = mutation.set;
+                if (mutation.lifecycleExecutionDomain) {
+                    const proposed = updateTaskFrontmatter(candidate, mutation.set);
+                    const open = mutation.lifecycleExecutionDomain === 'ordinary'
+                        ? lifecycleExecutions(proposed)
+                        : lifecycleExecutions(candidate);
+                    const pr = prReviewExecution(mutation.lifecycleExecutionDomain === 'pr-review' ? proposed : candidate);
+                    set = { ...mutation.set, lifecycle_execution: serializeLifecycleExecution(open, undefined, pr) };
+                }
+                candidate = updateTaskFrontmatter(candidate, set, mutation.remove);
                 operations.push({
                     index,
                     kind: 'frontmatter',

package/lib/agent-clients/adapter.ts

@@ -8,10 +8,6 @@ import type {
   AgentClientCapabilityMap,
   AgentClientId
 } from './types.ts';
-import type {
-  OrchestrationOptions,
-  OrchestrationResult
-} from '../task/orchestration.ts';
 import {
   SANDBOX_HOOK_PHASES
 } from '../sandbox/tool-types.ts';
@@ -42,56 +38,6 @@ type AgentClientModelSelectionContext =
       guidance: string;
     }>;
 
-type AgentClientDelegationEvidence = Readonly<{
-  actualModel: 'host-event' | 'app-server' | 'unavailable';
-  actualReasoningEffort: 'host-event' | 'app-server' | 'spawn-ack' | 'unavailable';
-  spawnModeRequired?: boolean;
-  actualModelRequired?: boolean;
-  actualReasoningEffortRequired?: boolean;
-  fallbackReasonRequired?: boolean;
-}>;
-
-type AgentClientLifecycleRecoveryRequest = Readonly<{
-  taskRef: string;
-  intent: 'recover-started';
-  agent: string;
-  auto: true;
-}>;
-
-type AgentClientLifecycleRecoveryResult = Readonly<{
-  status: 'applied' | 'no-op' | 'owner-unknown' | 'conflict';
-  changed: boolean;
-  targetState: 'active';
-  requestRef: string;
-  intent: 'recover-started';
-  taskId: string | null;
-  receiptId: string | null;
-  childId: string | null;
-  error: Readonly<{ code: string; message: string }> | null;
-}>;
-
-type AgentClientOrchestrationAdapter = Readonly<{
-  validateActivationEvidence?: (evidence: unknown, parentId: string) => boolean;
-  validateReceiptEvidence?: (receipt: unknown) => boolean;
-  createLaunchCarrier?: (
-    adapterContext: string,
-    identity: Readonly<{ stage: string; round: number; role: string }>
-  ) => Readonly<Record<string, string>>;
-  prepareDelegation?: (
-    taskRef: string,
-    input: Readonly<{
-      client: AgentClientId;
-      requestedModel?: string;
-      requestedReasoningEffort?: string;
-    }>,
-    options?: Readonly<{ repoRoot?: string; orchestrationOptions?: OrchestrationOptions }>
-  ) => Promise<OrchestrationResult>;
-  recoverStarted?: (
-    request: AgentClientLifecycleRecoveryRequest,
-    options: Readonly<{ repoRoot: string }>
-  ) => AgentClientLifecycleRecoveryResult | Promise<AgentClientLifecycleRecoveryResult>;
-}>;
-
 type AgentClientSeedCommand = Readonly<{
   templates: Readonly<{
     en: string;
@@ -123,8 +69,6 @@ type AgentClientAdapter = Readonly<{
   invocation: string;
   capabilities: AgentClientCapabilities;
   modelSelection: AgentClientModelSelectionContext;
-  delegationEvidence: AgentClientDelegationEvidence;
-  orchestrationAdapter?: AgentClientOrchestrationAdapter;
   project: AgentClientProjectDescriptor;
   sandbox: AgentClientSandboxDescriptor;
 }>;
@@ -399,18 +343,6 @@ function defineAgentClientAdapter(
     throw new Error(`Agent Client '${candidate.id}' has an invalid model-selection context`);
   }
 
-  const evidence = candidate.delegationEvidence;
-  if (
-    !evidence
-    || !['host-event', 'app-server', 'unavailable'].includes(evidence.actualModel)
-    || !['host-event', 'app-server', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)
-    || ['spawnModeRequired', 'actualModelRequired', 'actualReasoningEffortRequired', 'fallbackReasonRequired']
-      .some((key) => evidence[key as keyof AgentClientDelegationEvidence] !== undefined
-        && typeof evidence[key as keyof AgentClientDelegationEvidence] !== 'boolean')
-  ) {
-    throw new Error(`Agent Client '${candidate.id}' has invalid delegation evidence`);
-  }
-
   if (
     typeof candidate.project !== 'object'
     || candidate.project === null
@@ -701,10 +633,6 @@ function defineAgentClientAdapter(
     invocation: candidate.invocation,
     capabilities: Object.freeze(capabilities),
     modelSelection: frozenModelSelection,
-    delegationEvidence: Object.freeze({ ...evidence }),
-    ...(candidate.orchestrationAdapter === undefined
-      ? {}
-      : { orchestrationAdapter: Object.freeze({ ...candidate.orchestrationAdapter }) }),
     project: Object.freeze({
       ownedPathPrefixes: Object.freeze(paths),
       ...projectAssets,
@@ -726,10 +654,6 @@ export type {
   AgentClientAdapter,
   AgentClientCapabilities,
   AgentClientCustomCommandDescriptor,
-  AgentClientDelegationEvidence,
-  AgentClientLifecycleRecoveryRequest,
-  AgentClientLifecycleRecoveryResult,
-  AgentClientOrchestrationAdapter,
   AgentClientManifestEntry,
   AgentClientModelSelectionContext,
   AgentClientProjectDescriptor,

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