@animalabs/connectome-host 0.3.9 → 0.3.10

package/src/commands.ts

@@ -14,6 +14,7 @@
  *   /clear         — Clear conversation display
  *   /mcp list|add|remove|env — Manage MCPL server config
  *   /budget [N]    — Show/set stream token budget (e.g. /budget 1m)
+ *   /fast [on|off|status] — Toggle Codex subscription Fast mode
  *   /session       — Session management (list, new, switch, rename, delete)
  *   /recipe        — Show current recipe info
  *   /newtopic      — Reset head window (auto-summarize or with user context)
@@ -37,6 +38,10 @@ interface AppContext {
   sessionManager: import('./session-manager.js').SessionManager;
   recipe: Recipe;
   branchState: BranchState;
+  codexAdapter?: {
+    isFastMode(): boolean;
+    setFastMode(enabled: boolean): void;
+  };
   switchSession(id: string): Promise<void>;
 }
 
@@ -152,6 +157,7 @@ export function handleCommand(command: string, app: AppContext): CommandResult {
           { text: '  /mcp remove <id>       Remove a server', style: 'system' },
           { text: '  /mcp env <id> K=V ...  Set env vars on server', style: 'system' },
           { text: '  /budget [tokens]       Show/set stream token budget', style: 'system' },
+          { text: '  /fast [on|off|status]  Toggle Codex subscription Fast mode', style: 'system' },
           { text: '  /session               Show current session', style: 'system' },
           { text: '  /session list          List all sessions', style: 'system' },
           { text: '  /session new [name]    Create new session', style: 'system' },
@@ -211,6 +217,9 @@ export function handleCommand(command: string, app: AppContext): CommandResult {
     case 'budget':
       return handleBudget(framework, args[0]);
 
+    case 'fast':
+      return handleFast(app, args[0]);
+
     case 'session':
       return handleSession(app, args);
 
@@ -233,6 +242,42 @@ export function handleCommand(command: string, app: AppContext): CommandResult {
   }
 }
 
+function handleFast(app: AppContext, mode?: string): CommandResult {
+  const adapter = app.codexAdapter;
+  if (!adapter) {
+    return {
+      lines: [{
+        text: '/fast is available only when agent.provider is "openai-codex".',
+        style: 'system',
+      }],
+    };
+  }
+
+  const normalized = mode?.toLowerCase();
+  if (normalized === undefined || normalized === 'status') {
+    return {
+      lines: [{
+        text: `Codex Fast mode request is ${adapter.isFastMode() ? 'ON' : 'OFF'}.`,
+        style: 'system',
+      }],
+    };
+  }
+  if (normalized !== 'on' && normalized !== 'off') {
+    return { lines: [{ text: 'Usage: /fast [on|off|status]', style: 'system' }] };
+  }
+
+  const enabled = normalized === 'on';
+  adapter.setFastMode(enabled);
+  return {
+    lines: [{
+      text: enabled
+        ? 'Codex Fast mode requested (higher subscription credit consumption when applied).'
+        : 'Codex Fast mode request disabled.',
+      style: 'system',
+    }],
+  };
+}
+
 // ---------------------------------------------------------------------------
 // /session subcommands
 // ---------------------------------------------------------------------------

package/src/extensions.ts

@@ -0,0 +1,201 @@
+/**
+ * Recipe extensions — the loading seam for deployment-specific code.
+ *
+ * A recipe may declare an `extensions` block mapping a name to a local
+ * TypeScript/JavaScript module that registers custom context strategies
+ * and/or framework modules:
+ *
+ *   "extensions": {
+ *     "zk-strategy": {
+ *       "kind": "strategy",
+ *       "path": "./extensions/zk-strategy/index.ts",
+ *       "config": { "floodWindowMs": 250 }
+ *     }
+ *   }
+ *
+ * The entry module must export a `register` function (named or default):
+ *
+ *   export function register(api: ExtensionApi, config: Record<string, unknown>) {
+ *     api.registerStrategy('zk', (ctx) => new ZkStrategy({ ...ctx.config }));
+ *     api.registerModule((ctx) => new ZkFeederModule(config));
+ *   }
+ *
+ * Design constraint: this loader is deliberately dumb. It resolves nothing,
+ * fetches nothing, and negotiates no versions — it imports a local path and
+ * calls `register`. The invariant "this path exists and is compatible with
+ * the host's dependency tree" is established at install time by build
+ * tooling (connectome-cook), not here. Extensions run in-process and share
+ * the host's node_modules, so `extends AutobiographicalStrategy` resolves
+ * against the exact @animalabs/* versions the host ships.
+ *
+ * `kind` declares the extension's primary purpose. It gates recipe
+ * validation (a non-built-in `agent.strategy.type` is only accepted when at
+ * least one `kind: "strategy"` extension is declared) and informs build
+ * tooling; it does NOT restrict what `register` may call — a strategy
+ * extension may also register a companion module.
+ */
+
+import { isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { ContextStrategy, Module } from '@animalabs/agent-framework';
+import type { Recipe, RecipeExtension, RecipeStrategy } from './recipe.js';
+
+// ---------------------------------------------------------------------------
+// Factory contexts
+// ---------------------------------------------------------------------------
+
+export interface StrategyFactoryContext {
+  /** The recipe's `agent.strategy` block verbatim — including keys the
+   *  built-in schema doesn't know about, so custom strategies can define
+   *  their own knobs without upstream schema changes. */
+  config: RecipeStrategy & Record<string, unknown>;
+  /** Resolved agent model id (recipe/env fallback chain already applied). */
+  model: string;
+  /** Resolved IANA time zone for the session. */
+  timeZone: string;
+}
+
+export type StrategyFactory = (ctx: StrategyFactoryContext) => ContextStrategy;
+
+export interface ModuleFactoryContext {
+  timeZone: string;
+  /** Session store path (Chronicle data dir) — same value createFramework uses. */
+  storePath: string;
+  /** Resolved agent model id. */
+  model: string;
+  /** The declaring extension entry's `config` blob, verbatim. */
+  config: Record<string, unknown>;
+}
+
+export type ModuleFactory = (ctx: ModuleFactoryContext) => Module;
+
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+
+export interface ExtensionApi {
+  /** Register a context-strategy factory under a `agent.strategy.type` name.
+   *  Built-in names and duplicate registrations are rejected. */
+  registerStrategy(type: string, factory: StrategyFactory): void;
+  /** Register a framework-module factory. Instantiated after the built-in
+   *  module list is assembled; if the instance has a `setFramework` method
+   *  it is called after framework creation (same duck-typed contract the
+   *  built-in modules use). */
+  registerModule(factory: ModuleFactory): void;
+}
+
+export interface RegisteredModule {
+  /** Name of the extension entry that registered this factory. */
+  extensionName: string;
+  factory: ModuleFactory;
+  /** The extension entry's `config`, passed to the factory context. */
+  config: Record<string, unknown>;
+}
+
+export interface ExtensionRegistry {
+  strategies: Map<string, StrategyFactory>;
+  modules: RegisteredModule[];
+}
+
+export const BUILTIN_STRATEGY_TYPES = ['autobiographical', 'passthrough', 'frontdesk'] as const;
+
+export function isBuiltinStrategyType(type: string): boolean {
+  return (BUILTIN_STRATEGY_TYPES as readonly string[]).includes(type);
+}
+
+/** An empty registry — used when a recipe declares no extensions. */
+export function emptyExtensionRegistry(): ExtensionRegistry {
+  return { strategies: new Map(), modules: [] };
+}
+
+// ---------------------------------------------------------------------------
+// Loader
+// ---------------------------------------------------------------------------
+
+/**
+ * Import every extension declared by the recipe and collect registrations.
+ *
+ * Paths must be absolute by the time this runs — `loadRecipe` resolves
+ * relative extension paths against the recipe file's directory. Errors are
+ * wrapped with the extension name + path so a broken deployment names the
+ * component instead of surfacing a bare import stack.
+ */
+export async function loadExtensions(recipe: Recipe): Promise<ExtensionRegistry> {
+  const registry = emptyExtensionRegistry();
+  for (const [name, ext] of Object.entries(recipe.extensions ?? {})) {
+    await loadOneExtension(name, ext, registry);
+  }
+  return registry;
+}
+
+async function loadOneExtension(
+  name: string,
+  ext: RecipeExtension,
+  registry: ExtensionRegistry,
+): Promise<void> {
+  if (!isAbsolute(ext.path)) {
+    throw new Error(
+      `extension "${name}": path "${ext.path}" is not absolute. ` +
+      `Relative paths are resolved by loadRecipe against the recipe file's directory; ` +
+      `URL-loaded recipes must use absolute extension paths.`,
+    );
+  }
+
+  let mod: Record<string, unknown>;
+  try {
+    mod = await import(pathToFileURL(ext.path).href) as Record<string, unknown>;
+  } catch (err) {
+    throw new Error(
+      `extension "${name}": failed to import ${ext.path}: ` +
+      `${err instanceof Error ? err.message : String(err)}`,
+      { cause: err },
+    );
+  }
+
+  const register = (mod.register ?? mod.default) as unknown;
+  if (typeof register !== 'function') {
+    throw new Error(
+      `extension "${name}" (${ext.path}) must export a "register" function ` +
+      `(named export or default export); got ${typeof register}.`,
+    );
+  }
+
+  const config = ext.config ?? {};
+  const api: ExtensionApi = {
+    registerStrategy(type, factory) {
+      if (typeof type !== 'string' || !type) {
+        throw new Error(`extension "${name}": registerStrategy requires a non-empty type name`);
+      }
+      if (isBuiltinStrategyType(type)) {
+        throw new Error(
+          `extension "${name}": strategy type "${type}" collides with a built-in strategy`,
+        );
+      }
+      if (registry.strategies.has(type)) {
+        throw new Error(
+          `extension "${name}": strategy type "${type}" is already registered by another extension`,
+        );
+      }
+      if (typeof factory !== 'function') {
+        throw new Error(`extension "${name}": registerStrategy("${type}") requires a factory function`);
+      }
+      registry.strategies.set(type, factory);
+    },
+    registerModule(factory) {
+      if (typeof factory !== 'function') {
+        throw new Error(`extension "${name}": registerModule requires a factory function`);
+      }
+      registry.modules.push({ extensionName: name, factory, config });
+    },
+  };
+
+  try {
+    await Promise.resolve((register as (api: ExtensionApi, config: Record<string, unknown>) => unknown)(api, config));
+  } catch (err) {
+    throw new Error(
+      `extension "${name}" (${ext.path}): register() threw: ` +
+      `${err instanceof Error ? err.message : String(err)}`,
+      { cause: err },
+    );
+  }
+}

package/src/framework-agent-config.ts

@@ -24,20 +24,28 @@ export function buildFrameworkAgentConfig(
     maxStreamTokens: recipe.agent.maxStreamTokens ?? 150000,
     contextBudgetTokens: recipe.agent.contextBudgetTokens,
     ...(recipe.agent.cacheTtl && { cacheTtl: recipe.agent.cacheTtl }),
-    ...(recipe.agent.provider === 'openai-responses' && {
+    // Bedrock legacy Claude models reject cache_control outright
+    // ("your request did not allow prompt caching") — suppress markers.
+    ...(recipe.agent.provider === 'bedrock' && { promptCaching: false }),
+    // Prefill scaffold (anthropic-xml formatter), e.g. chapterx CLI-sim's
+    // '<cmd>cat untitled.txt</cmd>' — part of migrating prefill-era bots.
+    ...(recipe.agent.prefillUserMessage && { prefillUserMessage: recipe.agent.prefillUserMessage }),
+    ...((recipe.agent.provider === 'openai-responses' || recipe.agent.provider === 'openai-codex') && {
       providerParams: {
         reasoning: {
           effort: recipe.agent.responses?.reasoningEffort ?? 'high',
           context: recipe.agent.responses?.reasoningContext ?? 'all_turns',
         },
-        ...(recipe.agent.responses?.serviceTier ? {
-          service_tier: recipe.agent.responses.serviceTier,
-        } : {}),
-        ...(recipe.agent.responses?.compactThreshold ? {
-          context_management: [{
-            type: 'compaction',
-            compact_threshold: recipe.agent.responses.compactThreshold,
-          }],
+        ...(recipe.agent.provider === 'openai-responses' ? {
+          ...(recipe.agent.responses?.serviceTier ? {
+            service_tier: recipe.agent.responses.serviceTier,
+          } : {}),
+          ...(recipe.agent.responses?.compactThreshold ? {
+            context_management: [{
+              type: 'compaction',
+              compact_threshold: recipe.agent.responses.compactThreshold,
+            }],
+          } : {}),
         } : {}),
       },
     }),

package/src/framework-strategy.ts

@@ -5,6 +5,7 @@ import {
 } from '@animalabs/agent-framework';
 import type { Recipe, RecipeStrategy } from './recipe.js';
 import { FrontdeskStrategy } from './strategies/frontdesk-strategy.js';
+import { isBuiltinStrategyType, type ExtensionRegistry } from './extensions.js';
 
 const PASSTHROUGH_KEYS: ReadonlyArray<keyof RecipeStrategy> = [
   'enforceBudget',
@@ -39,9 +40,29 @@ export function buildFrameworkStrategy(
   recipe: Recipe,
   model: string,
   timeZone: string,
+  extensions?: ExtensionRegistry,
 ): ContextStrategy {
   const strategyConfig = recipe.agent.strategy;
   const strategyType = strategyConfig?.type ?? 'autobiographical';
+
+  // Non-built-in types resolve through the extension registry. Validation
+  // already required a strategy-kind extension to be declared; this catches
+  // the declared-but-didn't-register case with a precise error.
+  if (!isBuiltinStrategyType(strategyType)) {
+    const factory = extensions?.strategies.get(strategyType);
+    if (!factory) {
+      const known = extensions ? Array.from(extensions.strategies.keys()) : [];
+      throw new Error(
+        `strategy type "${strategyType}" is not built-in and no loaded extension registered it. ` +
+        `Registered custom types: ${known.length ? known.join(', ') : '(none)'}.`,
+      );
+    }
+    return factory({
+      config: (strategyConfig ?? {}) as RecipeStrategy & Record<string, unknown>,
+      model,
+      timeZone,
+    });
+  }
   const autobiographicalOpts: Record<string, unknown> = {
     headWindowTokens: strategyConfig?.headWindowTokens ?? 4000,
     recentWindowTokens: strategyConfig?.recentWindowTokens ?? 30000,

package/src/index.ts

@@ -16,12 +16,17 @@
  */
 
 import {
+  AnthropicXmlFormatter,
+  BedrockAdapter,
   Membrane,
   NativeFormatter,
   OpenAIResponsesAPIAdapter,
   OpenAIResponsesFormatter,
+  OpenRouterAdapter,
 } from '@animalabs/membrane';
 import { LoggingAnthropicAdapter } from './logging-adapter.js';
+import { LoggingBedrockAdapter } from './logging-bedrock-adapter.js';
+import { CodexSubscriptionAdapter } from './codex-subscription-adapter.js';
 import { CallLedger } from './call-ledger.js';
 import { SettingsModule } from './modules/settings-module.js';
 import { AgentFramework, WorkspaceModule, resolveTimeZone, type Module, type MountConfig } from '@animalabs/agent-framework';
@@ -57,6 +62,7 @@ import {
 import { createBranchState, resetBranchState, handleExport, type BranchState } from './commands.js';
 import { buildFrameworkAgentConfig } from './framework-agent-config.js';
 import { buildFrameworkStrategy } from './framework-strategy.js';
+import { loadExtensions } from './extensions.js';
 
 export type { AppContext };
 
@@ -69,6 +75,8 @@ const config = {
   // precedence over the API key so requests never carry both auth schemes.
   authToken: process.env.ANTHROPIC_AUTH_TOKEN,
   openaiApiKey: process.env.OPENAI_API_KEY,
+  openrouterApiKey: process.env.OPENROUTER_API_KEY,
+  codexBinary: process.env.CODEX_BINARY,
   model: process.env.MODEL,
   dataDir: process.env.DATA_DIR || './data',
 };
@@ -91,6 +99,7 @@ interface AppContext {
   agentName: string;
   branchState: BranchState;
   userMessageCount: number;
+  codexAdapter?: CodexSubscriptionAdapter;
 
   /** Stop current framework, switch to a different session, start new framework. */
   switchSession(id: string): Promise<void>;
@@ -143,10 +152,16 @@ async function createFramework(
   settingsModule: SettingsModule,
   callLedger: CallLedger | null,
 ): Promise<AgentFramework> {
-  const model = config.model || recipe.agent.model || 'claude-opus-4-6';
+  const model = config.model || recipe.agent.model ||
+    (recipe.agent.provider === 'openai-codex' ? 'gpt-5.4' : 'claude-opus-4-6');
   const modules = recipe.modules ?? {};
   const timeZone = resolveTimeZone(recipe.agent.timezone);
 
+  // Load recipe extensions first — custom strategies must be registered
+  // before buildFrameworkStrategy runs, and custom modules join the module
+  // list below. The loader is a dumb local import; see src/extensions.ts.
+  const extensionRegistry = await loadExtensions(recipe);
+
   // -- Build module list --
   // SettingsModule is constructed in main() (before the adapter, so the
   // adapter can read its state for cross-cutting concerns like reasoning).
@@ -342,6 +357,16 @@ async function createFramework(
     moduleInstances.push(new ObserversModule({ path: observersPath }));
   }
 
+  // Extension-registered modules. Instantiated last so built-in modules keep
+  // their historical positions; each factory gets the minimal runtime context
+  // plus its declaring extension's config blob.
+  const extensionModules: Module[] = [];
+  for (const entry of extensionRegistry.modules) {
+    const instance = entry.factory({ timeZone, storePath, model, config: entry.config });
+    extensionModules.push(instance);
+    moduleInstances.push(instance);
+  }
+
   // -- Build MCP server list --
   //
   // Recipes are opt-in: a file entry from mcpl-servers.json is loaded only
@@ -401,14 +426,14 @@ async function createFramework(
   // No server augmentation needed — gate is wired via FrameworkConfig.gate
 
   // -- Build strategy --
-  const strategy = buildFrameworkStrategy(recipe, model, timeZone);
+  const strategy = buildFrameworkStrategy(recipe, model, timeZone, extensionRegistry);
   const agentConfig = buildFrameworkAgentConfig(recipe, agentName, model, strategy);
 
   // -- Create framework --
   const framework = await AgentFramework.create({
     storePath,
     membrane,
-    agents: [agentConfig],
+agents: [agentConfig],
     modules: moduleInstances,
     mcplServers: finalServers,
     gate: gateOptions,
@@ -467,6 +492,13 @@ async function createFramework(
     channelModeModule.setFramework(framework);
   }
 
+  // Extension modules get the same duck-typed post-creation hook the
+  // built-ins use: if the instance exposes setFramework, call it.
+  for (const instance of extensionModules) {
+    const hooked = instance as unknown as { setFramework?: (f: AgentFramework) => void };
+    hooked.setFramework?.(framework);
+  }
+
   if (mcplAdminModule) {
     mcplAdminModule.setFramework(framework);
   }
@@ -733,10 +765,18 @@ async function main() {
   const recipe = await resolveRecipe();
   const provider = recipe.agent.provider ?? 'anthropic';
 
+  if (provider === 'openrouter' && !config.openrouterApiKey) {
+    console.error('Missing OPENROUTER_API_KEY for recipe provider "openrouter".');
+    process.exit(1);
+  }
   if (provider === 'openai-responses' && !config.openaiApiKey) {
     console.error('Missing OPENAI_API_KEY for recipe provider "openai-responses".');
     process.exit(1);
   }
+  if (provider === 'bedrock' && !(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)) {
+    console.error('Missing AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY for recipe provider "bedrock".');
+    process.exit(1);
+  }
   if (provider === 'anthropic' && !config.apiKey && !config.authToken) {
     console.error('Missing ANTHROPIC_API_KEY (or ANTHROPIC_AUTH_TOKEN). Set one in .env or environment.');
     process.exit(1);
@@ -761,22 +801,54 @@ async function main() {
         defaultTtl: recipe.agent.cacheTtl ?? '5m',
       })
     : null;
-  // OAuth (subscription) auth wins over API-key auth when both are present.
-  // Subscription tokens (sk-ant-oat…) additionally require the oauth beta
-  // header on every request.
+  // The Codex subscription adapter owns ChatGPT login/refresh independently
+  // of the API-key transports below.
+  const codexAdapter = provider === 'openai-codex'
+    ? new CodexSubscriptionAdapter({
+        codexBinary: config.codexBinary,
+        fastMode: recipe.agent.codex?.fastMode ?? false,
+      })
+    : undefined;
+  const openrouterAdapter = provider === 'openrouter'
+    ? new OpenRouterAdapter({
+        apiKey: config.openrouterApiKey!,
+        xTitle: recipe.agent.name ?? recipe.name,
+      })
+    : undefined;
+  // Bedrock: legacy Claude models (3.5 Sonnet 0620/1022, Opus 3) that have
+  // left the Anthropic API but survive on AWS. The adapter reads AWS_* env
+  // vars (AWS_REGION defaults us-west-2) and maps standard Claude model IDs
+  // to Bedrock IDs (explicit map + `anthropic.<id>-v1:0` fallback). Uses the
+  // Anthropic-native message shape, so NativeFormatter applies unchanged.
+  // No CallLedger: prompt caching is rejected outright by legacy Bedrock
+  // models (tested 2026-07-21). Wrapped for llm-calls.jsonl visibility.
+  const bedrockAdapter = provider === 'bedrock'
+    ? new LoggingBedrockAdapter({}, llmLogPath)
+    : undefined;
   const adapter = provider === 'openai-responses'
     ? new OpenAIResponsesAPIAdapter({
         apiKey: config.openaiApiKey!,
         baseURL: process.env.OPENAI_BASE_URL || undefined,
       })
-    : new LoggingAnthropicAdapter(
+    : bedrockAdapter ?? openrouterAdapter ?? codexAdapter ?? new LoggingAnthropicAdapter(
         {
+          // Anthropic OAuth wins over API-key auth when both are present.
+          // Subscription tokens additionally require this beta header.
+          // Recipe-declared betas (agent.anthropicBetas, e.g. context-1m)
+          // are merged into the same anthropic-beta header either way.
           ...(config.authToken
             ? {
                 authToken: config.authToken,
-                defaultHeaders: { 'anthropic-beta': 'oauth-2025-04-20' },
+                defaultHeaders: {
+                  'anthropic-beta': ['oauth-2025-04-20', ...(recipe.agent.anthropicBetas ?? [])].join(','),
+                },
               }
-            : { apiKey: config.apiKey! }),
+            : {
+                apiKey: config.apiKey!,
+                ...(recipe.agent.anthropicBetas?.length
+                  ? { defaultHeaders: { 'anthropic-beta': recipe.agent.anthropicBetas.join(',') } }
+                  : {}),
+              }),
           baseURL: process.env.ANTHROPIC_BASE_URL || undefined,
         },
         llmLogPath,
@@ -815,9 +887,15 @@ async function main() {
   const agentName = resolved.name;
 
   const membrane = new Membrane(adapter, {
-    formatter: provider === 'openai-responses'
+    formatter: provider === 'openai-responses' || provider === 'openai-codex'
       ? new OpenAIResponsesFormatter()
-      : new NativeFormatter(),
+      : recipe.agent.formatter === 'anthropic-xml'
+        ? new AnthropicXmlFormatter()
+        : new NativeFormatter(),
+    // Bedrock legacy Claude models 400 on any cache_control block
+    // ("your request did not allow prompt caching") — suppress the
+    // historical promptCaching=true default on that transport.
+    ...(provider === 'bedrock' ? { defaultPromptCaching: false } : {}),
     // Anchor the assistant role for internal callers that don't set
     // request.assistantParticipant themselves (autobio compression,
     // executeMerge). Mismatch here flips stored assistant turns to
@@ -837,6 +915,7 @@ async function main() {
     agentName,
     branchState: createBranchState(),
     userMessageCount: 0,
+    codexAdapter,
 
     async switchSession(id: string) {
       handleExport(this);
@@ -884,14 +963,18 @@ async function main() {
   setupMcplStderrLog(app, storePath);
   getWebUiModule(framework)?.setApp(app);
 
-  if (headless) {
-    const { runHeadless } = await import('./headless.js');
-    await runHeadless(app, process.argv.slice(2));
-  } else if (noTui) {
-    await runPiped(app);
-  } else {
-    const { runTui } = await import('./tui.js');
-    await runTui(app);
+  try {
+    if (headless) {
+      const { runHeadless } = await import('./headless.js');
+      await runHeadless(app, process.argv.slice(2));
+    } else if (noTui) {
+      await runPiped(app);
+    } else {
+      const { runTui } = await import('./tui.js');
+      await runTui(app);
+    }
+  } finally {
+    codexAdapter?.dispose();
   }
 }