@gakim-digital/dexter-bridge 0.5.21 → 0.11.0

package/src/cli.js

@@ -1,5 +1,7 @@
 import os from 'node:os';
+import path from 'node:path';
 import readline from 'node:readline/promises';
+import { spawn } from 'node:child_process';
 import {
   BRIDGE_BUILD_FINGERPRINT,
   BRIDGE_CAPABILITIES,
@@ -14,7 +16,7 @@ import {
   resolveCompanionModelName,
   saveConfigPatch,
 } from './config.js';
-import { checkAllAgents, executeRun } from './agent.js';
+import { checkAgentAvailability, checkAllAgents, executeRun } from './agent.js';
 import {
   claimPairing,
   DexterBridgeApiError,
@@ -27,22 +29,30 @@ import {
   logLocationHint,
 } from './logger.js';
 import { createLocalAgentAdapter } from './providers/index.js';
+import {
+  discoverRuntimeProfiles,
+  normalizeRuntimeSelection,
+  publicRuntimeProfile,
+  runtimeDriver,
+  runtimeProfileMap,
+} from './runtimeProfiles.js';
 
 function usage() {
   return [
     'Local Agent Bridge for Dexter and InstaWebAI',
     '',
     'Usage:',
-    '  dexter-bridge connect [code-or-token] [--agent claude-code|codex|dry-run] [--model <model>] [--once] [--api <url>]',
+    '  dexter-bridge connect [code-or-token] --runtime codex|claude-code|opencode [--once] [--api <url>]',
     '  dexter-bridge pair <code-or-token> [--api <url>]',
-    '  dexter-bridge start [--agent claude-code|codex|dry-run] [--model <model>] [--once] [--api <url>]',
-    '  dexter-bridge status [--api <url>]',
-    '  dexter-bridge doctor',
+    '  dexter-bridge start [--runtime codex|claude-code|opencode] [--once] [--api <url>]',
+    '  dexter-bridge status [--runtime codex|claude-code|opencode] [--api <url>]',
+    '  dexter-bridge doctor [--runtime codex|claude-code|opencode]',
     '  dexter-bridge logout',
     '',
     'Environment:',
     '  DEXTER_API_URL              API base URL, e.g. https://api.example.com/iwm-api/0.0.1',
-    '  DEXTER_BRIDGE_AGENT         claude-code, codex, or dry-run',
+    '  DEXTER_BRIDGE_RUNTIME       codex, claude-code, or opencode',
+    '  DEXTER_BRIDGE_AGENT         claude-code, codex, opencode, or dry-run',
     '  DEXTER_BRIDGE_MODEL         Companion model, e.g. claude-code:sonnet or codex:gpt-5.5',
     '  DEXTER_BRIDGE_CLAUDE_BIN    Claude CLI binary name/path',
     '  DEXTER_BRIDGE_CLAUDE_ARGS   Claude CLI args, default: -p',
@@ -52,6 +62,39 @@ function usage() {
   ].join('\n');
 }
 
+function requestedRuntime(flags = {}, config = {}, env = process.env) {
+  const raw = flags.runtime || env.DEXTER_BRIDGE_RUNTIME || config.runtimeSelection;
+  if (!raw) return null;
+  const runtime = normalizeRuntimeSelection(raw);
+  if (runtime) return runtime;
+  const error = new Error('Runtime must be codex, claude-code, or opencode.');
+  error.code = 'DEXTER_RUNTIME_INVALID';
+  error.exitCode = 2;
+  throw error;
+}
+
+function runtimeAgent(runtime) {
+  if (runtime === 'codex') return 'codex';
+  if (runtime === 'claude-code') return 'claude-code';
+  return 'dry-run';
+}
+
+function runtimeLabel(runtime) {
+  if (runtime === 'codex') return 'Codex';
+  if (runtime === 'claude-code') return 'Claude Code';
+  if (runtime === 'opencode') return 'OpenCode';
+  return 'Local agent';
+}
+
+function configDirForFlags(flags, env = process.env) {
+  if (flags['config-dir']) return flags['config-dir'];
+  if (env.DEXTER_BRIDGE_CONFIG_DIR) return defaultConfigDir(env);
+  const runtime = requestedRuntime(flags, {}, env);
+  return runtime
+    ? path.join(defaultConfigDir(env), 'app-builder', runtime)
+    : defaultConfigDir(env);
+}
+
 function parseArgv(argv) {
   const flags = {};
   const positional = [];
@@ -111,6 +154,46 @@ function pollBackoffMs(failureCount, baseMs = 1000, maxMs = 30000) {
   return Math.min(maximum, base * (2 ** Math.min(10, failures - 1)));
 }
 
+function startRunAwakeGuard({
+  platform = process.platform,
+  env = process.env,
+  spawnImpl = spawn,
+  pid = process.pid,
+} = {}) {
+  if (
+    platform !== 'darwin'
+    || ['0', 'false', 'no', 'off'].includes(
+      String(env.DEXTER_BRIDGE_PREVENT_IDLE_SLEEP || 'true').trim().toLowerCase(),
+    )
+  ) {
+    return null;
+  }
+  try {
+    const child = spawnImpl(
+      '/usr/bin/caffeinate',
+      ['-i', '-m', '-w', String(pid)],
+      {
+        stdio: 'ignore',
+        windowsHide: true,
+      },
+    );
+    child.once?.('error', () => undefined);
+    child.unref?.();
+    return {
+      close() {
+        if (child.killed) return;
+        try {
+          child.kill('SIGTERM');
+        } catch {
+          // The guard already exited with its parent process.
+        }
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
 async function executeClaimedRun({
   run,
   execute = executeRun,
@@ -118,7 +201,9 @@ async function executeClaimedRun({
   once = false,
   logger,
   product,
+  preventIdleSleep = false,
 }) {
+  const awakeGuard = preventIdleSleep ? startRunAwakeGuard() : null;
   try {
     await execute(run, executeOptions);
     return true;
@@ -131,6 +216,8 @@ async function executeClaimedRun({
     const productName = normalizeBridgeProduct(product).name;
     console.error(`${productName} run ${run?.runId || 'unknown'} failed; continuing to poll.`);
     return false;
+  } finally {
+    awakeGuard?.close();
   }
 }
 
@@ -177,17 +264,37 @@ function agentEnvironment(config = {}, baseEnv = process.env) {
   return env;
 }
 
-async function inspectAvailability(config = {}) {
+async function inspectAvailability(config = {}, runtimeSelection = null) {
   try {
-    const checks = await checkAllAgents({ env: agentEnvironment(config) });
-    const allChecks = [...checks.agents, checks.dryRun];
+    const bridgeEnv = agentEnvironment(config);
+    const checks =
+      runtimeSelection === 'codex' || runtimeSelection === 'claude-code'
+        ? {
+            agents: [
+              await checkAgentAvailability(runtimeSelection, undefined, {
+                env: bridgeEnv,
+              }),
+            ],
+            dryRun: null,
+          }
+        : runtimeSelection === 'opencode'
+          ? { agents: [], dryRun: null }
+          : await checkAllAgents({ env: bridgeEnv });
+    const allChecks = [...checks.agents, ...(checks.dryRun ? [checks.dryRun] : [])];
     const available = allChecks.filter((check) => check.ok);
+    const runtimeProfiles = await discoverRuntimeProfiles({
+      agentChecks: checks.agents,
+      config,
+      env: bridgeEnv,
+      runtimeSelection,
+    });
+    const profileModels = runtimeProfiles.flatMap((profile) => profile.models || []);
     return {
       metadata: {
         availableAgents: available.map((check) => check.agent).join(','),
-        availableModels: available.flatMap((check) => check.models || []).join(','),
+        availableModels: profileModels.map((model) => model.id).join(','),
         availableModelDetails: JSON.stringify(
-          available.flatMap((check) => check.modelDetails || []),
+          profileModels,
         ),
         agentVersions: available.map((check) => `${check.agent}=${check.version || 'unknown'}`).join(','),
         bridgeCapabilities: BRIDGE_CAPABILITIES.join(','),
@@ -202,6 +309,7 @@ async function inspectAvailability(config = {}) {
       ),
       agents: checks.agents,
       dryRun: checks.dryRun,
+      runtimeProfiles,
     };
   } catch {
     return {
@@ -217,19 +325,41 @@ async function inspectAvailability(config = {}) {
       agentCommands: {},
       agents: [],
       dryRun: null,
+      runtimeProfiles: [],
     };
   }
 }
 
-async function availabilityMetadata(config = {}) {
-  return (await inspectAvailability(config)).metadata;
-}
-
 function selectedAgentCheck(availability, agent) {
   if (agent === 'dry-run') return availability.dryRun;
   return availability.agents.find((check) => check.agent === agent) || null;
 }
 
+function requireAvailableRuntime(availability, runtimeSelection) {
+  const driver = runtimeDriver(runtimeSelection);
+  const profile = availability.runtimeProfiles.find(
+    (candidate) => candidate.driver === driver,
+  );
+  if (profile?.authState === 'ready' && profile.models?.length) return profile;
+
+  if (runtimeSelection === 'codex' || runtimeSelection === 'claude-code') {
+    requireAvailableAgent(
+      availability,
+      runtimeSelection,
+      process.platform,
+    );
+  }
+
+  const error = new Error(
+    runtimeSelection === 'opencode'
+      ? 'OpenCode is not ready. Install OpenCode, connect a model provider in OpenCode, then run this command again.'
+      : `${runtimeLabel(runtimeSelection)} did not advertise any usable models.`,
+  );
+  error.code = 'DEXTER_RUNTIME_NOT_READY';
+  error.exitCode = 2;
+  throw error;
+}
+
 function requireAvailableAgent(availability, agent, platform = process.platform) {
   const check = selectedAgentCheck(availability, agent);
   if (check?.ok) return check;
@@ -260,11 +390,26 @@ async function pairCommand({ apiBaseUrl, args, flags, configDir }) {
   if (!codeOrToken) throw new Error('Pairing code or token is required.');
   const isToken = /^dcpp_/i.test(codeOrToken);
   const config = readConfig(configDir);
-  const agent = resolveAgentName({ flagValue: flags.agent, config });
-  const requestedModel = resolveCompanionModelName({ flagValue: flags.model, config, agent });
-  const availability = await inspectAvailability(config);
-  const check = requireAvailableAgent(availability, agent);
-  const model = availableModel(check, requestedModel);
+  const runtimeSelection = requestedRuntime(flags, config);
+  const agent = runtimeSelection
+    ? runtimeAgent(runtimeSelection)
+    : resolveAgentName({ flagValue: flags.agent, config });
+  const requestedModel = runtimeSelection
+    ? flags.model || config.model
+    : resolveCompanionModelName({ flagValue: flags.model, config, agent });
+  const availability = await inspectAvailability(config, runtimeSelection);
+  const runtimeProfile = runtimeSelection
+    ? requireAvailableRuntime(availability, runtimeSelection)
+    : null;
+  const check = runtimeProfile
+    ? null
+    : availability.agents.find((candidate) => candidate.agent === agent && candidate.ok)
+      || availability.agents.find((candidate) => candidate.ok)
+      || availability.dryRun;
+  const model = runtimeProfile
+    ? runtimeProfile.models.find((candidate) => candidate.id === requestedModel)?.id
+      || runtimeProfile.models[0].id
+    : availableModel(check, requestedModel);
   const result = await claimPairing(apiBaseUrl, {
     pairingCode: isToken ? undefined : codeOrToken,
     pairingToken: isToken ? codeOrToken : undefined,
@@ -272,11 +417,14 @@ async function pairCommand({ apiBaseUrl, args, flags, configDir }) {
     agent,
     model,
     metadata: availability.metadata,
+    runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
+    runtimeSelection,
   });
   saveConfigPatch({
     apiBaseUrl,
     agent,
     model,
+    runtimeSelection,
     product: normalizeBridgeProduct(result.product),
     deviceToken: result.deviceToken,
     device: result.device,
@@ -285,14 +433,27 @@ async function pairCommand({ apiBaseUrl, args, flags, configDir }) {
   }, configDir);
   const product = normalizeBridgeProduct(result.product);
   console.log(`Paired ${product.name} Bridge: ${result.device?.name || 'device'}`);
+  if (runtimeSelection) {
+    console.log(`Runtime: ${runtimeProfile?.label || runtimeLabel(runtimeSelection)}`);
+  }
   console.log(`API: ${apiBaseUrl}`);
 }
 
 async function statusCommand({ apiBaseUrl, config, configDir }) {
   const product = normalizeBridgeProduct(config.product);
   const deviceToken = requireDeviceToken(config);
-  const agent = resolveAgentName({ config });
-  const model = resolveCompanionModelName({ config, agent });
+  const runtimeSelection = requestedRuntime({}, config);
+  const agent = runtimeSelection
+    ? runtimeAgent(runtimeSelection)
+    : resolveAgentName({ config });
+  const availability = await inspectAvailability(config, runtimeSelection);
+  const runtimeProfile = runtimeSelection
+    ? requireAvailableRuntime(availability, runtimeSelection)
+    : null;
+  const model = runtimeProfile
+    ? runtimeProfile.models.find((candidate) => candidate.id === config.model)?.id
+      || runtimeProfile.models[0].id
+    : resolveCompanionModelName({ config, agent });
   let result;
   try {
     result = await heartbeat(apiBaseUrl, {
@@ -300,7 +461,8 @@ async function statusCommand({ apiBaseUrl, config, configDir }) {
       status: 'ready',
       agent,
       model,
-      metadata: await availabilityMetadata(config),
+      metadata: availability.metadata,
+      runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
     });
   } catch (error) {
     if (isInvalidPairingError(error)) throw clearInvalidPairing(configDir, error);
@@ -308,6 +470,9 @@ async function statusCommand({ apiBaseUrl, config, configDir }) {
   }
   console.log(`Status: ${result.device?.online ? 'online' : 'paired'}`);
   console.log(`Device: ${result.device?.name || `${product.name} Bridge`}`);
+  if (runtimeSelection) {
+    console.log(`Runtime: ${runtimeProfile?.label || runtimeLabel(runtimeSelection)}`);
+  }
   console.log(`Model: ${result.device?.model?.displayName || model}`);
   console.log(`API: ${apiBaseUrl}`);
 }
@@ -326,32 +491,59 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
     activeConfig = readConfig(configDir);
     deviceToken = activeConfig.deviceToken;
   }
-  const agent = resolveAgentName({ flagValue: flags.agent, config: activeConfig });
   const product = normalizeBridgeProduct(activeConfig.product);
-  const requestedModel = resolveCompanionModelName({ flagValue: flags.model, config: activeConfig, agent });
+  const runtimeSelection = requestedRuntime(flags, activeConfig);
+  if (product.connectionScope === 'app-builder' && !runtimeSelection) {
+    const error = new Error('This App Builder connection requires --runtime codex, --runtime claude-code, or --runtime opencode.');
+    error.code = 'DEXTER_RUNTIME_REQUIRED';
+    error.exitCode = 2;
+    throw error;
+  }
+  const agent = runtimeSelection
+    ? runtimeAgent(runtimeSelection)
+    : resolveAgentName({ flagValue: flags.agent, config: activeConfig });
+  const requestedModel = runtimeSelection
+    ? flags.model || activeConfig.model
+    : resolveCompanionModelName({ flagValue: flags.model, config: activeConfig, agent });
   const waitMs = Number(flags['wait-ms'] || 25000);
   const once = Boolean(flags.once);
   const bridgeEnv = agentEnvironment(activeConfig);
-  const availability = await inspectAvailability(activeConfig);
-  const check = requireAvailableAgent(availability, agent);
-  const model = availableModel(check, requestedModel);
+  const availability = await inspectAvailability(activeConfig, runtimeSelection);
+  const runtimeProfile = runtimeSelection
+    ? requireAvailableRuntime(availability, runtimeSelection)
+    : null;
+  const check = runtimeProfile
+    ? null
+    : requireAvailableAgent(availability, agent);
+  const model = runtimeProfile
+    ? runtimeProfile.models.find((candidate) => candidate.id === requestedModel)?.id
+      || runtimeProfile.models[0].id
+    : availableModel(check, requestedModel);
   const metadata = availability.metadata;
   const pollLogger = createRunLogger({ runId: 'bridge-poll' });
+  const profiles = runtimeProfileMap(availability.runtimeProfiles);
   const providerAdapters = new Map();
-  const providerAdapterForAgent = (runAgent) => {
-    if (providerAdapters.has(runAgent)) return providerAdapters.get(runAgent);
-    const adapter = createLocalAgentAdapter(runAgent, {
+  const providerAdapterForProfile = (runtimeProfile) => {
+    const profile = profiles.get(runtimeProfile?.id) || runtimeProfile;
+    if (!profile?.id) return null;
+    if (providerAdapters.has(profile.id)) return providerAdapters.get(profile.id);
+    const adapter = createLocalAgentAdapter(profile, {
       env: bridgeEnv,
       product,
       trace: pollLogger,
+      credentials: profile.credentials,
     });
-    providerAdapters.set(runAgent, adapter);
+    providerAdapters.set(profile.id, adapter);
     return adapter;
   };
   let pollFailureCount = 0;
 
   console.log(`${product.name} Bridge connected to ${apiBaseUrl}`);
-  console.log(`Agent: ${agent}`);
+  console.log(
+    `${runtimeSelection ? 'Runtime' : 'Agent'}: ${
+      runtimeSelection ? runtimeProfile?.label || runtimeLabel(runtimeSelection) : agent
+    }`,
+  );
   console.log(`Model: ${model}`);
   console.log(`Logs: ${logLocationHint()}`);
   console.log('Waiting for runs...');
@@ -360,7 +552,14 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
     while (true) {
       let poll;
       try {
-        poll = await pollRun(apiBaseUrl, { deviceToken, waitMs, agent, model, metadata });
+        poll = await pollRun(apiBaseUrl, {
+          deviceToken,
+          waitMs,
+          agent,
+          model,
+          metadata,
+          runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
+        });
         pollFailureCount = 0;
       } catch (error) {
         if (isInvalidPairingError(error)) {
@@ -382,10 +581,21 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
       }
       if (poll.run) {
         console.log(`Claimed run ${poll.run.runId}.`);
-        const runAgent = normalizeAgentName(poll.run?.companion?.agent || agent);
+        const runtimeProfile = poll.run?.runtimeProfile || null;
+        const runAgent = normalizeAgentName(
+          poll.run?.companion?.agent
+          || (
+            runtimeProfile?.driver === 'claude-code-cli'
+              ? 'claude-code'
+              : runtimeProfile?.driver === 'opencode'
+                ? 'opencode'
+                : 'codex'
+          ),
+        );
         await executeClaimedRun({
           run: poll.run,
           once,
+          preventIdleSleep: true,
           logger: pollLogger,
           product,
           executeOptions: {
@@ -393,7 +603,14 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
             deviceToken,
             agent: runAgent,
             selectedModel: model,
-            providerAdapter: providerAdapterForAgent(runAgent),
+            runtimeProfile,
+            providerAdapter: runtimeProfile
+              ? providerAdapterForProfile(runtimeProfile)
+              : createLocalAgentAdapter(runAgent, {
+                  env: bridgeEnv,
+                  product,
+                  trace: pollLogger,
+                }),
             product,
             env: bridgeEnv,
             maxSteps: flags['max-steps'],
@@ -413,7 +630,14 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
   }
 }
 
-async function doctorCommand() {
+async function doctorCommand(runtimeSelection = null) {
+  if (runtimeSelection) {
+    const availability = await inspectAvailability({}, runtimeSelection);
+    const profile = requireAvailableRuntime(availability, runtimeSelection);
+    console.log(`${runtimeLabel(runtimeSelection)}: ready`);
+    console.log(`Models: ${profile.models.map((model) => model.displayName || model.id).join(', ')}`);
+    return;
+  }
   const checks = await checkAllAgents();
   for (const check of checks.agents) {
     if (check.ok) console.log(`${check.command}: ok ${check.output || ''}`.trim());
@@ -428,7 +652,7 @@ export async function runCli(argv) {
     return;
   }
 
-  const configDir = parsed.flags['config-dir'] || defaultConfigDir();
+  const configDir = configDirForFlags(parsed.flags);
   const config = readConfig(configDir);
   const apiBaseUrl = resolveApiBaseUrl({
     flagValue: parsed.flags.api,
@@ -460,7 +684,7 @@ export async function runCli(argv) {
       await statusCommand({ apiBaseUrl, config, configDir });
       return;
     case 'doctor':
-      await doctorCommand();
+      await doctorCommand(requestedRuntime(parsed.flags, config));
       return;
     case 'logout':
       {
@@ -477,11 +701,15 @@ export async function runCli(argv) {
 export const __private__ = {
   agentEnvironment,
   clearInvalidPairing,
+  configDirForFlags,
   executeClaimedRun,
+  startRunAwakeGuard,
   isInvalidPairingError,
   parseArgv,
   pollBackoffMs,
+  requestedRuntime,
   availableModel,
+  requireAvailableRuntime,
   requireAvailableAgent,
   selectedAgentCheck,
   usage,

package/src/config.js

@@ -17,6 +17,18 @@ export const BRIDGE_BUILD_FINGERPRINT = crypto
     './cli.js',
     './config.js',
     './protocol.js',
+    './nativeSkills.js',
+    './harnessTools.js',
+    './harnessMcpServer.js',
+    './framerAgentTools.js',
+    './outcomeWorkspace.js',
+    './runtimeProfiles.js',
+    './providers/index.js',
+    './providers/codexAppServer.js',
+    './providers/codexStructuredOutput.js',
+    './providers/directByok.js',
+    './providers/openCode.js',
+    './providers/acp.js',
   ].map((relativePath) => {
     const url = new URL(relativePath, import.meta.url);
     return `${relativePath}\u0000${fs.readFileSync(url, 'utf8')}`;
@@ -24,8 +36,16 @@ export const BRIDGE_BUILD_FINGERPRINT = crypto
   .digest('hex');
 export const BRIDGE_CAPABILITIES = [
   'model-turn-v1',
+  'outcome-run-v1',
+  'harness-tools-v1',
+  'framer-agent-v1',
+  'framer-project-bootstrap-v1',
+  'project-shell-v1',
   'build-fingerprint-v1',
   'tool-schema-parity-v1',
+  'runtime-profiles-v1',
+  'native-skills-v1',
+  'model-progress-v1',
 ];
 export const BRIDGE_PRODUCTS = {
   dexter: {
@@ -39,12 +59,11 @@ export const BRIDGE_PRODUCTS = {
     connectionScope: 'app-builder',
   },
 };
-// Codex is the default local agent: driving Claude Code from a user's Claude.ai
-// subscription needs prior written approval from Anthropic for commercial use, so
-// 'claude-code' only runs when the server offers it (see policy gating in
-// framerCompanionModels.ts and docs/dexter-connect-onboarding-plan.md §0).
+// Codex remains the default local agent. Claude Code is enabled only when the
+// user explicitly connects the locally installed CLI and chooses one of its
+// reported models.
 export const DEFAULT_BRIDGE_AGENT = 'codex';
-export const BRIDGE_AGENTS = ['claude-code', 'codex', 'dry-run'];
+export const BRIDGE_AGENTS = ['claude-code', 'codex', 'opencode', 'dry-run'];
 export const COMPANION_MODEL_DEFINITIONS = [
   {
     id: 'claude-code:fable',
@@ -179,7 +198,7 @@ export function configFilePath(configDir = defaultConfigDir()) {
   return path.join(configDir, 'config.json');
 }
 
-export function normalizeApiBaseUrl(value) {
+export function normalizeApiBaseUrl(value, { allowInsecureHttp = false } = {}) {
   const raw = String(value || DEFAULT_API_BASE_URL).trim();
   let parsed;
   try {
@@ -196,7 +215,10 @@ export function normalizeApiBaseUrl(value) {
   if (parsed.username || parsed.password) {
     throw new Error('Bridge API URL must not contain embedded credentials.');
   }
-  if (parsed.protocol !== 'https:' && !(parsed.protocol === 'http:' && loopback)) {
+  if (
+    parsed.protocol !== 'https:'
+    && !(parsed.protocol === 'http:' && (loopback || allowInsecureHttp))
+  ) {
     throw new Error('Bridge API URL must use HTTPS. HTTP is allowed only for localhost development.');
   }
   if (parsed.search || parsed.hash) {
@@ -209,6 +231,7 @@ export function normalizeAgentName(value, fallback = DEFAULT_BRIDGE_AGENT) {
   const raw = String(value || '').trim().toLowerCase();
   if (raw === 'claude' || raw === 'claude_code' || raw === 'claude-code') return 'claude-code';
   if (raw === 'openai-codex' || raw === 'openai_codex' || raw === 'codex') return 'codex';
+  if (raw === 'open-code' || raw === 'open_code' || raw === 'opencode') return 'opencode';
   if (raw === 'dryrun' || raw === 'dry_run' || raw === 'dry-run') return 'dry-run';
   return BRIDGE_AGENTS.includes(fallback) ? fallback : DEFAULT_BRIDGE_AGENT;
 }