@gakim-digital/dexter-bridge 0.5.20 → 0.11.0

package/src/agent.js

@@ -2,41 +2,87 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import crossSpawn from 'cross-spawn';
-import { postRunEvent } from './api.js';
-import { createCompanionUsageAccumulator, parseAgentOutput } from './agentOutput.js';
+import { getFramerProjectAuthorization, postRunEvent } from './api.js';
+import {
+  createCompanionUsageAccumulator,
+  createClaudeProgressParser,
+  normalizeCompanionTokenUsage,
+  parseAgentOutput,
+} from './agentOutput.js';
 import {
   DEFAULT_BRIDGE_AGENT,
   companionModelDefinition,
   companionModelsForAgent,
+  normalizeBridgeProduct,
   normalizeAgentName,
   normalizeCompanionModelName,
 } from './config.js';
 import {
+  assertOutcomeResponseContract,
+  buildOutcomePrompt,
   buildModelTurnDeltaPrompt,
   buildModelTurnFallbackPrompt,
   buildModelTurnPrompt,
   extractJsonObject,
   modelTurnOutputSchema,
   normalizeModelTurnCompletion,
+  normalizeOutcomeCompletion,
+  normalizeStructuredResponseContract,
+  outcomeOutputSchema,
   runSummary,
+  STRUCTURED_RESPONSE_CONTRACTS,
 } from './protocol.js';
+import { clip, createRunLogger, errorMeta, logLocationHint, summarizePayload, summarizeToolResult } from './logger.js';
 import {
-  clip,
-  createRunLogger,
-  errorMeta,
-  logLocationHint,
-  summarizePayload,
-  summarizeToolResult,
-} from './logger.js';
+  claudeNativeSkillPrompt,
+  materializeNativeSkills,
+  nativeSkillLifecycle,
+  normalizeNativeSkills,
+} from './nativeSkills.js';
 import { createLocalAgentAdapter } from './providers/index.js';
+import {
+  collectOutcomeWorkspaceChanges,
+  materializeOutcomeWorkspace,
+  removeOutcomeWorkspace,
+} from './outcomeWorkspace.js';
+import {
+  codexDynamicToolSpecs,
+  createHarnessToolRuntime,
+} from './harnessTools.js';
+import { createFramerAgentToolRuntime } from './framerAgentTools.js';
+
+const HARNESS_MCP_SERVER_PATH = fileURLToPath(
+  new URL('./harnessMcpServer.js', import.meta.url),
+);
+
+export function harnessMcpProcessEnvironment(
+  gateway,
+  versions = process.versions,
+  allowedToolNames,
+) {
+  return {
+    INSTAWEB_HARNESS_GATEWAY_URL: gateway.url,
+    INSTAWEB_HARNESS_GATEWAY_TOKEN: gateway.token,
+    ...(Array.isArray(allowedToolNames)
+      ? {
+          INSTAWEB_HARNESS_ALLOWED_TOOLS:
+            JSON.stringify(allowedToolNames),
+        }
+      : {}),
+    ...(versions?.electron ? { ELECTRON_RUN_AS_NODE: '1' } : {}),
+  };
+}
 
 const companionModelSessions = new Map();
 const sharedProviderAdapters = new Map();
 const MAX_COMPANION_MODEL_SESSIONS = 64;
 
 function enabledFlag(value, fallback = false) {
-  const raw = String(value ?? '').trim().toLowerCase();
+  const raw = String(value ?? '')
+    .trim()
+    .toLowerCase();
   if (!raw) return fallback;
   return !['0', 'false', 'no', 'off', 'disabled'].includes(raw);
 }
@@ -46,7 +92,9 @@ function deltaModelSessionsEnabled(env = process.env) {
 }
 
 function companionSessionKey(run) {
-  return run?.modelTurn?.session?.goalSessionId
+  return run?.outcome?.session?.goalSessionId
+    || run?.outcome?.session?.sessionId
+    || run?.modelTurn?.session?.goalSessionId
     || run?.modelTurn?.session?.sessionId
     || run?.turnId
     || run?.runId;
@@ -76,6 +124,22 @@ function resumeFailure(error) {
   return /resume|session|thread|conversation|not found|unknown id|expired/i.test(message);
 }
 
+function freshSessionRetryFailure(error, adapter) {
+  return adapter?.id === 'codex' && [
+    'APP_AGENT_TURN_INACTIVITY_TIMEOUT',
+    'CODEX_STRUCTURED_OUTPUT_MALFORMED',
+    'CODEX_STRUCTURED_OUTPUT_INVALID',
+    'CODEX_TOOL_ARGUMENTS_TRANSPORT_INVALID',
+    'CODEX_TOOL_ARGUMENTS_MALFORMED',
+    'CODEX_TOOL_ARGUMENTS_NOT_OBJECT',
+  ].includes(error?.code);
+}
+
+function providerAttemptCount(value) {
+  const direct = Number(value?.providerAttemptCount);
+  return Number.isFinite(direct) && direct > 0 ? Math.floor(direct) : 1;
+}
+
 export const AGENT_DEFINITIONS = {
   'claude-code': {
     id: 'claude-code',
@@ -109,6 +173,7 @@ function nowIso() {
 
 const TERMINAL_EVENT_TYPES = new Set(['done', 'error']);
 const TERMINAL_EVENT_MAX_ATTEMPTS = 5;
+const TOOL_EVENT_MAX_ATTEMPTS = 3;
 
 function waitForRetry(delayMs) {
   return new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -116,25 +181,30 @@ function waitForRetry(delayMs) {
 
 function terminalEventRetryDelay(error, attempt) {
   const status = Number(error?.status);
-  const retryable =
-    !Number.isFinite(status)
-    || status === 408
-    || status === 429
-    || status >= 500;
+  const retryable = !Number.isFinite(status) || status === 408 || status === 429 || status >= 500;
   if (!retryable) return null;
   if (Number.isFinite(error?.retryAfterMs) && error.retryAfterMs > 0) {
     return Math.min(65_000, Math.max(250, error.retryAfterMs));
   }
-  return Math.min(8_000, 500 * (2 ** (attempt - 1)));
+  return Math.min(8_000, 500 * 2 ** (attempt - 1));
 }
 
-function createEventPoster({ apiBaseUrl, deviceToken, run, fetchImpl, trace }) {
+function createEventPoster({
+  apiBaseUrl,
+  deviceToken,
+  run,
+  fetchImpl,
+  trace,
+  allowInsecureHttp = false,
+}) {
   return async function send(type, payload = {}) {
     const eventId = `${type}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     const started = Date.now();
     const maxAttempts = TERMINAL_EVENT_TYPES.has(type)
       ? TERMINAL_EVENT_MAX_ATTEMPTS
-      : 1;
+      : type === 'tool_call'
+        ? TOOL_EVENT_MAX_ATTEMPTS
+        : 1;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
       trace?.info('event_post_start', {
         type,
@@ -147,6 +217,7 @@ function createEventPoster({ apiBaseUrl, deviceToken, run, fetchImpl, trace }) {
           deviceToken,
           runId: run.runId,
           fetchImpl,
+          allowInsecureHttp,
           event: {
             type,
             eventId,
@@ -165,10 +236,7 @@ function createEventPoster({ apiBaseUrl, deviceToken, run, fetchImpl, trace }) {
         });
         return response;
       } catch (error) {
-        const retryDelayMs =
-          attempt < maxAttempts
-            ? terminalEventRetryDelay(error, attempt)
-            : null;
+        const retryDelayMs = attempt < maxAttempts ? terminalEventRetryDelay(error, attempt) : null;
         trace?.error('event_post_failed', {
           type,
           eventId,
@@ -192,7 +260,10 @@ function commandFromEnv(name, fallback, env = process.env) {
 function parseExtraArgs(value, fallback = '') {
   const source = value === undefined || value === null || value === '' ? fallback : value;
   if (!source) return [];
-  return String(source).split(/\s+/).map((item) => item.trim()).filter(Boolean);
+  return String(source)
+    .split(/\s+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
 }
 
 function argsAlreadySelectModel(args) {
@@ -204,7 +275,11 @@ function argsIncludeFlag(args, flag) {
 }
 
 function structuredUsageEnabled(env = process.env) {
-  return String(env.DEXTER_BRIDGE_STRUCTURED_USAGE || 'true').trim().toLowerCase() !== 'false';
+  return (
+    String(env.DEXTER_BRIDGE_STRUCTURED_USAGE || 'true')
+      .trim()
+      .toLowerCase() !== 'false'
+  );
 }
 
 function argsWithRequiredAgentFlags(args, definition) {
@@ -220,15 +295,44 @@ const CLAUDE_CLI_MODEL_IDS = {
   haiku: 'claude-haiku-4-5-20251001',
 };
 
-const CLAUDE_MODEL_ENGINE_SYSTEM_PROMPT = [
-  'You are a model-only completion engine embedded inside Dexter.',
-  'The user prompt contains Dexter messages and a catalog of remote tools as data.',
-  'Never execute, simulate, or emit native Claude Code tool calls for those tool names.',
-  'The only allowed tool is StructuredOutput, supplied by the JSON schema.',
-  'Encode requested Dexter actions only inside StructuredOutput.toolCalls.',
-  'Do not inspect the filesystem, project, shell, plugins, skills, MCP servers, or browser.',
-  'Be concise: reason only as much as needed to choose the next remote Dexter action.',
-].join(' ');
+function claudeModelEngineSystemPrompt(product) {
+  const name = normalizeBridgeProduct(product).name;
+  return [
+    `You are a model-only completion engine embedded inside ${name}.`,
+    `The user prompt contains ${name} messages and a catalog of remote tools as data.`,
+    'Never execute, simulate, or emit native Claude Code tool calls for those tool names.',
+    'The only allowed tool is StructuredOutput, supplied by the JSON schema.',
+    `Encode requested ${name} actions only inside StructuredOutput.toolCalls.`,
+    'Use only the explicitly invoked InstaWebAI native skill package. Do not discover or invoke any other skills.',
+    'Do not inspect the filesystem, project, shell, plugins, MCP servers, or browser.',
+    `Be concise: reason only as much as needed to choose the next remote ${name} action.`,
+  ].join(' ');
+}
+
+function claudeOutcomeSystemPrompt(product) {
+  const name = normalizeBridgeProduct(product).name;
+  if (normalizeBridgeProduct(product).id === 'dexter') {
+    return [
+      `You are an autonomous Framer harness embedded inside ${name}.`,
+      'Work only through the approved Framer Agent tools connected to the user-selected project.',
+      'Inspect the project, perform the requested work, verify the result, and return the structured outcome.',
+      'Do not access local credentials, unrelated files, other projects, account settings, or billing.',
+      'Do not publish unless the assignment explicitly authorizes publishing.',
+      'Call progress_update before the first inspection or edit and at meaningful phase changes.',
+      `Return only the structured outcome result requested by ${name}.`,
+    ].join(' ');
+  }
+  return [
+    `You are a coding harness embedded inside ${name}.`,
+    'Work only inside the current isolated workspace and through the approved InstaWebAI harness tools.',
+    'Read and edit the files needed to complete the entire assigned outcome.',
+    'Run the commands, preview tools, and browser checks needed to build and verify the app without asking for approval.',
+    'Call progress_update before the first inspection or edit and again at every meaningful phase change. Keep each update to one or two natural first-person sentences about what you are doing, why it matters, or what comes next.',
+    'Do not access parent directories, environment files, credentials, unrelated user files, plugins, or the external network.',
+    'Prioritize working behavior and contract correctness before visual polish.',
+    `Return only the structured outcome result requested by ${name}.`,
+  ].join(' ');
+}
 
 export function mapClaudeCliModelId(value) {
   const raw = String(value || '').trim();
@@ -238,20 +342,17 @@ export function mapClaudeCliModelId(value) {
 function argsWithSelectedModel(args, modelDefinition, definition) {
   if (!modelDefinition?.invocationName || modelDefinition.invocationName === 'dry-run') return args;
   if (argsAlreadySelectModel(args)) return args;
-  const invocationName = definition.id === 'claude-code'
-    ? mapClaudeCliModelId(modelDefinition.invocationName)
-    : modelDefinition.invocationName;
+  const invocationName =
+    definition.id === 'claude-code'
+      ? mapClaudeCliModelId(modelDefinition.invocationName)
+      : modelDefinition.invocationName;
   return [...args, '--model', invocationName];
 }
 
 function argsWithStructuredOutput(args, definition, env = process.env) {
   if (!structuredUsageEnabled(env)) return args;
   if (definition.id === 'claude-code') {
-    const streamed = [
-      ...argsWithoutFlagValue(args, '--output-format'),
-      '--output-format',
-      'stream-json',
-    ];
+    const streamed = [...argsWithoutFlagValue(args, '--output-format'), '--output-format', 'stream-json'];
     if (!argsIncludeFlag(streamed, '--include-partial-messages')) {
       streamed.push('--include-partial-messages');
     }
@@ -264,21 +365,72 @@ function argsWithStructuredOutput(args, definition, env = process.env) {
   return args;
 }
 
-function argsWithClaudeIsolation(args, definition) {
+function argsWithClaudeIsolation(args, definition, options = {}) {
   if (definition.id !== 'claude-code') return args;
   const isolated = argsWithoutVariadicFlag(args, '--tools');
-  isolated.push('--tools', '');
-  if (!argsIncludeFlag(isolated, '--disable-slash-commands')) isolated.push('--disable-slash-commands');
-  if (!argsIncludeFlag(isolated, '--strict-mcp-config')) isolated.push('--strict-mcp-config');
-  if (!argsIncludeFlag(isolated, '--no-chrome')) isolated.push('--no-chrome');
-  return isolated;
+  const harnessToolNames = Array.isArray(options.harnessToolNames)
+    ? options.harnessToolNames
+    : [
+        'workspace_inspect',
+        'workspace_sync',
+        'shell_run',
+        'preview_control',
+        'browser_control',
+        'data_inspect',
+        'verification_run',
+      ];
+  const harnessTools = harnessToolNames.map(
+    (name) => `mcp__instawebai__${name}`,
+  );
+  const nativeTools = options.framerHarness
+    ? harnessTools
+    : [
+        'Read',
+        'Write',
+        'Edit',
+        'Glob',
+        'Grep',
+        'Bash',
+        ...(options.nativeSkillsEnabled ? ['Skill'] : []),
+        ...harnessTools,
+      ];
+  isolated.push(
+    '--tools',
+    options.harnessMode
+      ? nativeTools.join(',')
+      : options.nativeSkillsEnabled
+        ? 'Skill'
+        : '',
+  );
+  const withoutDisabledSkills = isolated.filter((arg) => arg !== '--disable-slash-commands');
+  if (!options.nativeSkillsEnabled) withoutDisabledSkills.push('--disable-slash-commands');
+  const withoutAllowedTools = argsWithoutVariadicFlag(withoutDisabledSkills, '--allowedTools');
+  const projectSettingsOnly = argsWithoutFlagValue(withoutAllowedTools, '--setting-sources');
+  projectSettingsOnly.push('--setting-sources', 'project');
+  const permissionMode = argsWithoutFlagValue(projectSettingsOnly, '--permission-mode');
+  permissionMode.push(
+    '--permission-mode',
+    options.harnessMode && !options.framerHarness ? 'acceptEdits' : 'dontAsk',
+  );
+  if (options.harnessMode) permissionMode.push('--allowedTools', nativeTools.join(','));
+  if (!argsIncludeFlag(permissionMode, '--strict-mcp-config')) permissionMode.push('--strict-mcp-config');
+  if (!argsIncludeFlag(permissionMode, '--no-chrome')) permissionMode.push('--no-chrome');
+  let configured = permissionMode;
+  if (options.harnessMode && options.mcpConfig) {
+    configured = argsWithoutFlagValue(configured, '--mcp-config');
+    configured.push('--mcp-config', JSON.stringify(options.mcpConfig));
+  }
+  if (options.harnessMode && !argsIncludeFlag(configured, '--restricted')) {
+    configured.push('--restricted');
+  }
+  return configured;
 }
 
 function normalizeClaudeEffort(value, fallback = 'medium') {
-  const effort = String(value || '').trim().toLowerCase();
-  return ['low', 'medium', 'high', 'xhigh', 'max'].includes(effort)
-    ? effort
-    : fallback;
+  const effort = String(value || '')
+    .trim()
+    .toLowerCase();
+  return ['low', 'medium', 'high', 'xhigh', 'max'].includes(effort) ? effort : fallback;
 }
 
 function claudeEffortForStep(step, env = process.env) {
@@ -303,7 +455,9 @@ function argsWithClaudeModelEngine(args, definition, options = {}, env = process
   return [
     ...isolated,
     '--system-prompt',
-    CLAUDE_MODEL_ENGINE_SYSTEM_PROMPT,
+    options.harnessMode
+      ? claudeOutcomeSystemPrompt(options.product)
+      : claudeModelEngineSystemPrompt(options.product),
     '--effort',
     claudeEffortForStep(options.step, env),
   ];
@@ -337,33 +491,61 @@ function argsWithoutVariadicFlag(args, flag) {
   return filtered;
 }
 
+function normalizeClaudeJsonSchema(value, path = '$') {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => normalizeClaudeJsonSchema(item, `${path}[${index}]`));
+  }
+  if (!value || typeof value !== 'object') return value;
+
+  const normalized = Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [
+      key,
+      normalizeClaudeJsonSchema(nested, `${path}.${key}`),
+    ]),
+  );
+  for (const [exclusiveKey, inclusiveKey] of [
+    ['exclusiveMinimum', 'minimum'],
+    ['exclusiveMaximum', 'maximum'],
+  ]) {
+    const exclusive = normalized[exclusiveKey];
+    if (typeof exclusive !== 'boolean') continue;
+    if (!exclusive) {
+      delete normalized[exclusiveKey];
+      continue;
+    }
+    const bound = normalized[inclusiveKey];
+    if (typeof bound !== 'number' || !Number.isFinite(bound)) {
+      throw new Error(
+        `Invalid Claude JSON Schema at ${path}: ${exclusiveKey}: true requires a finite ${inclusiveKey}.`,
+      );
+    }
+    normalized[exclusiveKey] = bound;
+    delete normalized[inclusiveKey];
+  }
+  return normalized;
+}
+
 function compactClaudeOutputSchema(outputSchema) {
   const toolCalls = outputSchema?.properties?.toolCalls;
   const itemSchema = toolCalls?.items;
-  const variants = Array.isArray(itemSchema?.anyOf)
-    ? itemSchema.anyOf
-    : itemSchema
-      ? [itemSchema]
-      : [];
-  const toolNames = Array.from(new Set(
-    variants.flatMap((variant) => (
-      Array.isArray(variant?.properties?.name?.enum)
-        ? variant.properties.name.enum.filter((name) => typeof name === 'string' && name)
-        : []
-    )),
-  ));
+  const variants = Array.isArray(itemSchema?.anyOf) ? itemSchema.anyOf : itemSchema ? [itemSchema] : [];
+  const toolNames = Array.from(
+    new Set(
+      variants.flatMap((variant) =>
+        Array.isArray(variant?.properties?.name?.enum)
+          ? variant.properties.name.enum.filter((name) => typeof name === 'string' && name)
+          : [],
+      ),
+    ),
+  );
   return {
     type: 'object',
     properties: {
       text: { type: 'string' },
       toolCalls: {
         type: 'array',
-        ...(Number.isFinite(Number(toolCalls?.minItems))
-          ? { minItems: Number(toolCalls.minItems) }
-          : {}),
-        ...(Number.isFinite(Number(toolCalls?.maxItems))
-          ? { maxItems: Number(toolCalls.maxItems) }
-          : {}),
+        ...(Number.isFinite(Number(toolCalls?.minItems)) ? { minItems: Number(toolCalls.minItems) } : {}),
+        ...(Number.isFinite(Number(toolCalls?.maxItems)) ? { maxItems: Number(toolCalls.maxItems) } : {}),
         items: {
           type: 'object',
           properties: {
@@ -388,16 +570,24 @@ function compactClaudeOutputSchema(outputSchema) {
   };
 }
 
-function argsWithOutputSchema(args, definition, outputSchema, platform = process.platform) {
+function argsWithOutputSchema(
+  args,
+  definition,
+  outputSchema,
+  responseContract = 'model-turn',
+) {
   if (definition.id !== 'claude-code' || !outputSchema) return args;
-  const launchSchema = platform === 'win32'
-    ? compactClaudeOutputSchema(outputSchema)
-    : outputSchema;
-  return [
-    ...argsWithoutFlagValue(args, '--json-schema'),
-    '--json-schema',
-    JSON.stringify(launchSchema),
-  ];
+  const normalizedResponseContract =
+    normalizeStructuredResponseContract(responseContract);
+  const normalizedSchema = normalizeClaudeJsonSchema(outputSchema);
+  // Model turns use a compact transport envelope because their tool catalog can
+  // contain flexible schemas. Harness outcomes already use a small, strict,
+  // provider-neutral result schema and must remain in that direct shape.
+  const launchSchema =
+    normalizedResponseContract === STRUCTURED_RESPONSE_CONTRACTS.OUTCOME
+      ? assertOutcomeResponseContract(responseContract, normalizedSchema)
+      : compactClaudeOutputSchema(normalizedSchema);
+  return [...argsWithoutFlagValue(args, '--json-schema'), '--json-schema', JSON.stringify(launchSchema)];
 }
 
 function argsWithPromptInput(args, definition) {
@@ -452,7 +642,12 @@ function argsWithResumedSession(args, definition, sessionId) {
 }
 
 function agentSessionResumeEnabled(definition, env = process.env) {
-  if (String(env.DEXTER_BRIDGE_SESSION_RESUME || 'true').trim().toLowerCase() === 'false') return false;
+  if (
+    String(env.DEXTER_BRIDGE_SESSION_RESUME || 'true')
+      .trim()
+      .toLowerCase() === 'false'
+  )
+    return false;
   const baseArgs = parseExtraArgs(env[definition.argsEnv], definition.defaultArgs);
   if (definition.id === 'claude-code' && argsIncludeFlag(baseArgs, '--no-session-persistence')) return false;
   if (definition.id === 'codex' && argsIncludeFlag(baseArgs, '--ephemeral')) return false;
@@ -464,13 +659,17 @@ export function buildAgentArgs(definition, modelDefinition, env = process.env, o
   const requiredArgs = argsWithRequiredAgentFlags(baseArgs, definition);
   const modelArgs = argsWithSelectedModel(requiredArgs, modelDefinition, definition);
   const structuredArgs = argsWithStructuredOutput(modelArgs, definition, env);
-  const isolatedArgs = argsWithClaudeIsolation(structuredArgs, definition);
+  const isolatedArgs = argsWithClaudeIsolation(
+    structuredArgs,
+    definition,
+    options,
+  );
   const modelEngineArgs = argsWithClaudeModelEngine(isolatedArgs, definition, options, env);
   const schemaArgs = argsWithOutputSchema(
     modelEngineArgs,
     definition,
     options.outputSchema,
-    options.platform,
+    options.responseContract,
   );
   const resumedArgs = argsWithResumedSession(schemaArgs, definition, options.resumeSessionId);
   return argsWithPromptInput(resumedArgs, definition);
@@ -493,7 +692,12 @@ let cachedLoginShellEnvMeta = { attempted: false, loaded: false, keys: 0 };
 
 function loginShellEnv() {
   if (process.env.DEXTER_BRIDGE_DISABLE_LOGIN_SHELL_ENV === '1' || process.platform === 'win32') {
-    cachedLoginShellEnvMeta = { attempted: false, loaded: false, keys: 0, disabled: true };
+    cachedLoginShellEnvMeta = {
+      attempted: false,
+      loaded: false,
+      keys: 0,
+      disabled: true,
+    };
     return {};
   }
   if (cachedLoginShellEnv) return cachedLoginShellEnv;
@@ -557,20 +761,18 @@ export function mergePathEntries(paths, platform = process.platform) {
 
 export function processEnvWithCliPath(baseEnv = process.env, platform = process.platform) {
   const pathApi = platform === 'win32' ? path.win32 : path.posix;
-  const homeDirectory = platform === 'win32'
-    ? String(
-      baseEnv.USERPROFILE
-      || baseEnv.HOME
-      || (process.platform === 'win32' ? os.homedir() : ''),
-    ).trim()
-    : String(baseEnv.HOME || (platform === process.platform ? os.homedir() : '')).trim();
-  const fallbackPath = platform === 'win32'
-    ? [
-      homeDirectory ? pathApi.join(homeDirectory, '.local', 'bin') : '',
-      baseEnv.APPDATA ? pathApi.join(baseEnv.APPDATA, 'npm') : '',
-      baseEnv.LOCALAPPDATA ? pathApi.join(baseEnv.LOCALAPPDATA, 'Programs') : '',
-    ]
-    : ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin'];
+  const homeDirectory =
+    platform === 'win32'
+      ? String(baseEnv.USERPROFILE || baseEnv.HOME || (process.platform === 'win32' ? os.homedir() : '')).trim()
+      : String(baseEnv.HOME || (platform === process.platform ? os.homedir() : '')).trim();
+  const fallbackPath =
+    platform === 'win32'
+      ? [
+          homeDirectory ? pathApi.join(homeDirectory, '.local', 'bin') : '',
+          baseEnv.APPDATA ? pathApi.join(baseEnv.APPDATA, 'npm') : '',
+          baseEnv.LOCALAPPDATA ? pathApi.join(baseEnv.LOCALAPPDATA, 'Programs') : '',
+        ]
+      : ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin'];
   const shellEnv = platform === 'win32' ? {} : loginShellEnv();
   const existingPath = String(baseEnv.PATH || '');
   const mergedPath = mergePathEntries([shellEnv.PATH, existingPath, ...fallbackPath], platform);
@@ -581,7 +783,11 @@ export function processEnvWithCliPath(baseEnv = process.env, platform = process.
   };
 }
 
-export function resolveAgentCwd(env = process.env, currentWorkingDirectory = process.cwd(), platform = process.platform) {
+export function resolveAgentCwd(
+  env = process.env,
+  currentWorkingDirectory = process.cwd(),
+  platform = process.platform,
+) {
   const explicit = String(env.DEXTER_BRIDGE_AGENT_CWD || env.DEXTER_BRIDGE_WORKDIR || '').trim();
   if (explicit) return explicit;
   const pathApi = platform === 'win32' ? path.win32 : path.posix;
@@ -592,7 +798,9 @@ export function resolveAgentCwd(env = process.env, currentWorkingDirectory = pro
 
 function processEnvSummary(env, platform = process.platform) {
   const delimiter = platform === 'win32' ? ';' : ':';
-  const pathEntries = String(env.PATH || '').split(delimiter).filter(Boolean);
+  const pathEntries = String(env.PATH || '')
+    .split(delimiter)
+    .filter(Boolean);
   return {
     hasAzureOpenAiApiKey: Boolean(env.AZURE_OPENAI_API_KEY),
     hasOpenAiApiKey: Boolean(env.OPENAI_API_KEY),
@@ -604,18 +812,28 @@ function processEnvSummary(env, platform = process.platform) {
   };
 }
 
-export function executableCandidates(command, env = process.env, platform = process.platform, existsSync = fs.existsSync) {
+export function executableCandidates(
+  command,
+  env = process.env,
+  platform = process.platform,
+  existsSync = fs.existsSync,
+) {
   const raw = String(command || '').trim();
   if (!raw) return [];
   if (/[\\/]/.test(raw)) return [raw];
   const delimiter = platform === 'win32' ? ';' : ':';
   const pathApi = platform === 'win32' ? path.win32 : path.posix;
-  const pathEntries = String(env.PATH || '').split(delimiter).filter(Boolean);
-  const extensions = platform === 'win32'
-    ? path.win32.extname(raw)
-      ? ['']
-      : String(env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
-    : [''];
+  const pathEntries = String(env.PATH || '')
+    .split(delimiter)
+    .filter(Boolean);
+  const extensions =
+    platform === 'win32'
+      ? path.win32.extname(raw)
+        ? ['']
+        : String(env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+            .split(';')
+            .filter(Boolean)
+      : [''];
   const candidates = [];
   for (const directory of pathEntries) {
     for (const extension of extensions) {
@@ -630,7 +848,12 @@ export function executableCandidates(command, env = process.env, platform = proc
   return [...new Set(candidates.length ? candidates : [raw])];
 }
 
-export function resolveExecutableCommand(command, env = process.env, platform = process.platform, existsSync = fs.existsSync) {
+export function resolveExecutableCommand(
+  command,
+  env = process.env,
+  platform = process.platform,
+  existsSync = fs.existsSync,
+) {
   return executableCandidates(command, env, platform, existsSync)[0] || String(command || '').trim();
 }
 
@@ -640,7 +863,9 @@ export function parseAgentVersion(output) {
 }
 
 function versionParts(value) {
-  const match = String(value || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
+  const match = String(value || '')
+    .trim()
+    .match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/);
   return match ? match.slice(1).map(Number) : null;
 }
 
@@ -669,9 +894,7 @@ export function selectAgentRuntime(inspections, definition, modelDefinition) {
     return {
       ok: false,
       command: first?.command || definition.fallbackCommand,
-      code: first?.code === 'ENOENT'
-        ? 'DEXTER_AGENT_NOT_FOUND'
-        : first?.code,
+      code: first?.code === 'ENOENT' ? 'DEXTER_AGENT_NOT_FOUND' : first?.code,
       error: first?.error || `${definition.label} is not installed or could not be started.`,
       candidates: inspections,
     };
@@ -679,7 +902,9 @@ export function selectAgentRuntime(inspections, definition, modelDefinition) {
 
   const ranked = successful
     .map((inspection, index) => ({ ...inspection, discoveryIndex: index }))
-    .sort((left, right) => compareAgentVersions(right.version, left.version) || left.discoveryIndex - right.discoveryIndex);
+    .sort(
+      (left, right) => compareAgentVersions(right.version, left.version) || left.discoveryIndex - right.discoveryIndex,
+    );
   const compatible = ranked.find((inspection) => modelSupportsAgentVersion(modelDefinition, inspection.version));
   if (compatible) {
     return {
@@ -697,14 +922,19 @@ export function selectAgentRuntime(inspections, definition, modelDefinition) {
     ...found,
     ok: false,
     code: 'DEXTER_AGENT_MODEL_VERSION_UNSUPPORTED',
-    error: `${modelLabel} requires ${definition.label} ${requiredVersion} or newer. Dexter found ${foundVersion} at ${found.command}. Update ${definition.label} or set ${definition.commandEnv} to the full path of a compatible installation.`,
+    error: `${modelLabel} requires ${definition.label} ${requiredVersion} or newer. The bridge found ${foundVersion} at ${found.command}. Update ${definition.label} or set ${definition.commandEnv} to the full path of a compatible installation.`,
     candidates: inspections,
   };
 }
 
 export function processInvocation(command, args, env = process.env, platform = process.platform) {
   const resolvedCommand = resolveExecutableCommand(command, env, platform);
-  return { command: resolvedCommand, args, resolvedCommand, windowsHide: platform === 'win32' };
+  return {
+    command: resolvedCommand,
+    args,
+    resolvedCommand,
+    windowsHide: platform === 'win32',
+  };
 }
 
 function safeCommandArgs(args) {
@@ -722,12 +952,85 @@ function normalizeDiagnosticLine(line) {
     .replace(/\s+/g, ' ');
 }
 
-export function agentFailureMessage(command, code, stdout = '', stderr = '') {
-  const combined = [stderr, stdout].filter(Boolean).join('\n').trim();
-  const lines = combined
+function jsonDiagnosticEvents(value) {
+  return String(value || '')
     .split(/\r?\n/)
-    .map(normalizeDiagnosticLine)
-    .filter(Boolean);
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .flatMap((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? [parsed] : [];
+      } catch {
+        return [];
+      }
+    });
+}
+
+function claudeFailureDetails(stdout) {
+  const events = jsonDiagnosticEvents(stdout);
+  const init = [...events].reverse().find((event) => event.type === 'system' && event.subtype === 'init');
+  const model = typeof init?.model === 'string' ? init.model.trim().toLowerCase() : '';
+  const rateLimit = [...events]
+    .reverse()
+    .find(
+      (event) =>
+        event.type === 'rate_limit_event' && event.rate_limit_info && typeof event.rate_limit_info === 'object',
+    );
+  const rateLimitInfo = rateLimit?.rate_limit_info;
+  if (rateLimitInfo?.errorCode === 'credits_required' || rateLimitInfo?.overageDisabledReason === 'out_of_credits') {
+    if (model.includes('fable')) {
+      return {
+        code: 'CLAUDE_CREDITS_REQUIRED',
+        message:
+          'Claude Fable could not run because this Claude account has no extra-usage credits available. '
+          + 'Add Claude usage credits or switch this run to Opus or Sonnet.',
+      };
+    }
+    return {
+      code: 'CLAUDE_CREDITS_REQUIRED',
+      message:
+        'Claude Code could not run because this Claude account is out of credits. '
+        + 'Add credits or enable extra usage in Claude, then retry. You can also switch to Codex.',
+    };
+  }
+  if (rateLimitInfo?.status === 'rejected') {
+    const resetAt = Number(rateLimitInfo.resetsAt);
+    const resetMessage = Number.isFinite(resetAt)
+      ? ` Try again after ${new Date(resetAt * 1000).toISOString()}.`
+      : ' Try again later.';
+    return {
+      code: 'CLAUDE_RATE_LIMITED',
+      message: `Claude Code is currently rate limited.${resetMessage}`,
+    };
+  }
+
+  const resultError = [...events]
+    .reverse()
+    .find((event) => event.type === 'result' && (event.is_error === true || event.subtype === 'error'));
+  const resultMessages = Array.isArray(resultError?.errors)
+    ? resultError.errors.filter((message) => typeof message === 'string' && message.trim())
+    : [];
+  const resultMessage =
+    resultMessages.join(' ') || (typeof resultError?.result === 'string' ? resultError.result.trim() : '');
+  if (resultMessage) {
+    return {
+      code: 'CLAUDE_RUN_FAILED',
+      message: `Claude Code could not complete this model turn: ${clip(resultMessage, 700)}`,
+    };
+  }
+
+  return null;
+}
+
+export function agentFailureDetails(command, code, stdout = '', stderr = '') {
+  if (/(^|[/\\])claude(?:\.exe)?$/i.test(String(command || ''))) {
+    const claudeFailure = claudeFailureDetails(stdout);
+    if (claudeFailure) return claudeFailure;
+  }
+
+  const combined = [stderr, stdout].filter(Boolean).join('\n').trim();
+  const lines = combined.split(/\r?\n/).map(normalizeDiagnosticLine).filter(Boolean);
   const diagnosticPatterns = [
     /missing environment variable/i,
     /not inside a trusted directory/i,
@@ -742,26 +1045,37 @@ export function agentFailureMessage(command, code, stdout = '', stderr = '') {
     /^failed\b/i,
   ];
   const diagnostics = lines.filter((line) => diagnosticPatterns.some((pattern) => pattern.test(line)));
-  const detail = diagnostics.length
-    ? diagnostics.slice(-3).join(' ')
-    : clip(combined, 1000);
-  return `${command} exited with code ${code}.${detail ? ` ${clip(detail, 1000)}` : ''}`.trim();
+  const detail = diagnostics.length ? diagnostics.slice(-3).join(' ') : clip(combined, 1000);
+  return {
+    code: 'AGENT_PROCESS_FAILED',
+    message: `${command} exited with code ${code}.${detail ? ` ${clip(detail, 1000)}` : ''}`.trim(),
+  };
 }
 
-function runProcess(command, args, stdin, {
-  timeoutMs = 120000,
-  maxDurationMs,
-  trace,
-  childEnv: providedChildEnv,
-  platform = process.platform,
-  signal,
-  killGraceMs = 250,
-} = {}) {
+export function agentFailureMessage(command, code, stdout = '', stderr = '') {
+  return agentFailureDetails(command, code, stdout, stderr).message;
+}
+
+function runProcess(
+  command,
+  args,
+  stdin,
+  {
+    timeoutMs = 120000,
+    maxDurationMs,
+    trace,
+    childEnv: providedChildEnv,
+    cwd: providedCwd,
+    platform = process.platform,
+    signal,
+    killGraceMs = 250,
+    onProgress,
+    stdoutProgress,
+  } = {},
+) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
-      const error = signal.reason instanceof Error
-        ? signal.reason
-        : new Error('The model process was cancelled.');
+      const error = signal.reason instanceof Error ? signal.reason : new Error('The model process was cancelled.');
       error.code = error.code || 'RUN_CANCELLED';
       reject(error);
       return;
@@ -772,7 +1086,10 @@ function runProcess(command, args, stdin, {
     // hardDeadlineMs bounds total wall-clock time regardless of activity.
     const hardDeadlineMs = Math.max(maxDurationMs || timeoutMs * 5, 10);
     const childEnv = processEnvWithCliPath(providedChildEnv || process.env, platform);
-    const cwd = resolveAgentCwd(childEnv, process.cwd(), platform);
+    const cwd =
+      typeof providedCwd === 'string' && providedCwd.trim()
+        ? providedCwd
+        : resolveAgentCwd(childEnv, process.cwd(), platform);
     const invocation = processInvocation(command, args, childEnv, platform);
     trace?.info('agent_process_spawn', {
       command,
@@ -791,11 +1108,18 @@ function runProcess(command, args, stdin, {
       windowsHide: invocation.windowsHide,
       detached: platform !== 'win32',
     });
+    onProgress?.({
+      kind: 'turn_started',
+      provider: 'cli',
+      occurredAt: new Date().toISOString(),
+    });
     let stdout = '';
     let stderr = '';
     let settled = false;
+    let terminationError = null;
     let inactivityTimer = null;
     let forceKillTimer = null;
+    let terminationFallbackTimer = null;
     const killChildTree = (killSignal) => {
       if (platform !== 'win32' && child.pid) {
         try {
@@ -815,38 +1139,50 @@ function runProcess(command, args, stdin, {
       clearTimeout(inactivityTimer);
       clearTimeout(deadlineTimer);
     };
-    const terminateChildTree = () => {
+    const settleWithError = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      clearTimeout(forceKillTimer);
+      clearTimeout(terminationFallbackTimer);
+      signal?.removeEventListener('abort', abort);
+      error.stdout = stdout;
+      error.stderr = stderr;
+      reject(error);
+    };
+    const terminateChildTree = (error) => {
       killChildTree('SIGTERM');
-      forceKillTimer = setTimeout(() => killChildTree('SIGKILL'), killGraceMs);
+      forceKillTimer = setTimeout(() => {
+        killChildTree('SIGKILL');
+        terminationFallbackTimer = setTimeout(
+          () => settleWithError(error),
+          Math.max(killGraceMs, 250),
+        );
+        terminationFallbackTimer.unref?.();
+      }, killGraceMs);
       forceKillTimer.unref?.();
     };
     const abort = () => {
-      if (settled) return;
-      settled = true;
+      if (settled || terminationError) return;
       clearTimers();
-      terminateChildTree();
-      const error = signal?.reason instanceof Error
-        ? signal.reason
-        : new Error('The model process was cancelled.');
+      const error = signal?.reason instanceof Error ? signal.reason : new Error('The model process was cancelled.');
       error.code = error.code || 'RUN_CANCELLED';
-      error.stdout = stdout;
-      error.stderr = stderr;
+      terminationError = error;
+      terminateChildTree(error);
       trace?.info('agent_process_cancelled', {
         command,
         durationMs: Date.now() - started,
       });
-      reject(error);
     };
-    const timeOut = (message) => {
-      if (settled) return;
-      settled = true;
+    const timeOut = (code, message) => {
+      if (settled || terminationError) return;
       clearTimers();
-      terminateChildTree();
       const error = new Error(message);
-      error.code = 'AGENT_TIMEOUT';
-      error.stdout = stdout;
-      error.stderr = stderr;
+      error.code = code;
+      error.retryable = true;
       error.timedOut = true;
+      terminationError = error;
+      terminateChildTree(error);
       trace?.error('agent_process_timeout', {
         command,
         durationMs: Date.now() - started,
@@ -857,47 +1193,74 @@ function runProcess(command, args, stdin, {
         stdoutExcerpt: clip(stdout, 1000),
         stderrExcerpt: clip(stderr, 1000),
       });
-      reject(error);
     };
     const armInactivityTimer = () => {
       clearTimeout(inactivityTimer);
       inactivityTimer = setTimeout(() => {
-        timeOut(`${command} produced no output for ${timeoutMs}ms.`);
+        timeOut(
+          'APP_AGENT_TURN_INACTIVITY_TIMEOUT',
+          `${command} timed out after ${timeoutMs}ms without meaningful output.`,
+        );
       }, timeoutMs);
     };
     const deadlineTimer = setTimeout(() => {
-      timeOut(`${command} timed out after ${hardDeadlineMs}ms.`);
+      timeOut(
+        'APP_AGENT_TURN_HARD_TIMEOUT',
+        `${command} timed out after ${hardDeadlineMs}ms at the safety limit.`,
+      );
     }, hardDeadlineMs);
     signal?.addEventListener('abort', abort, { once: true });
     armInactivityTimer();
 
     child.stdout.on('data', (chunk) => {
-      stdout += chunk.toString('utf8');
-      armInactivityTimer();
+      const text = chunk.toString('utf8');
+      stdout += text;
+      if (!terminationError) {
+        armInactivityTimer();
+        stdoutProgress?.push(text);
+        onProgress?.({
+          kind: 'output_delta',
+          provider: 'cli',
+          occurredAt: new Date().toISOString(),
+        });
+      }
     });
     child.stderr.on('data', (chunk) => {
       stderr += chunk.toString('utf8');
-      armInactivityTimer();
+      if (!terminationError) {
+        armInactivityTimer();
+        onProgress?.({
+          kind: 'output_delta',
+          provider: 'cli',
+          occurredAt: new Date().toISOString(),
+        });
+      }
     });
     child.on('error', (error) => {
       if (settled) return;
-      settled = true;
-      clearTimers();
-      clearTimeout(forceKillTimer);
-      signal?.removeEventListener('abort', abort);
+      if (terminationError) {
+        settleWithError(terminationError);
+        return;
+      }
       trace?.error('agent_process_error', {
         command,
         durationMs: Date.now() - started,
         error: errorMeta(error),
       });
-      reject(error);
+      settleWithError(error);
     });
     child.on('close', (code) => {
       if (settled) return;
+      if (terminationError) {
+        settleWithError(terminationError);
+        return;
+      }
       settled = true;
       clearTimers();
       clearTimeout(forceKillTimer);
+      clearTimeout(terminationFallbackTimer);
       signal?.removeEventListener('abort', abort);
+      stdoutProgress?.flush();
       const meta = {
         command,
         code,
@@ -912,9 +1275,14 @@ function runProcess(command, args, stdin, {
         resolve({ stdout, stderr, code });
         return;
       }
-      const failureMessage = agentFailureMessage(command, code, stdout, stderr);
-      trace?.error('agent_process_exit_nonzero', { ...meta, failureMessage });
-      const error = new Error(failureMessage);
+      const failure = agentFailureDetails(command, code, stdout, stderr);
+      trace?.error('agent_process_exit_nonzero', {
+        ...meta,
+        failureCode: failure.code,
+        failureMessage: failure.message,
+      });
+      const error = new Error(failure.message);
+      error.code = failure.code;
       error.stdout = stdout;
       error.stderr = stderr;
       error.exitCode = code;
@@ -929,11 +1297,26 @@ function definitionForAgent(agent) {
   return AGENT_DEFINITIONS[normalizeAgentName(agent)] || AGENT_DEFINITIONS[DEFAULT_BRIDGE_AGENT];
 }
 
+function definitionForRuntimeProfile(profile, fallbackAgent) {
+  if (!profile) return definitionForAgent(fallbackAgent);
+  if (profile.driver === 'claude-code-cli') return AGENT_DEFINITIONS['claude-code'];
+  if (profile.driver === 'codex-app-server') return AGENT_DEFINITIONS.codex;
+  return {
+    id: profile.id || profile.driver,
+    label: profile.label || profile.driver || 'Local runtime',
+    model: profile.models?.[0]?.id || 'local-runtime',
+  };
+}
+
 function adapterSessionId(run) {
   return run?.turnId || run?.runId;
 }
 
 function adapterInvocationModel(run, selectedModel, agent) {
+  const runtimeInvocation = run?.runtimeProfile?.model?.invocationName;
+  if (typeof runtimeInvocation === 'string' && runtimeInvocation.trim()) {
+    return runtimeInvocation.trim();
+  }
   const explicit = run?.companion?.model?.invocationName;
   if (typeof explicit === 'string' && explicit.trim()) return explicit.trim();
   if (selectedModel?.invocationName) return selectedModel.invocationName;
@@ -945,9 +1328,7 @@ function adapterInvocationModel(run, selectedModel, agent) {
 
 function controlRequestsCancellation(response) {
   return Boolean(
-    response?.control?.cancelRequested
-    || response?.status === 'cancelled'
-    || response?.status === 'expired',
+    response?.control?.cancelRequested || response?.status === 'cancelled' || response?.status === 'expired',
   );
 }
 
@@ -964,26 +1345,38 @@ function waitForControl(delayMs, signal) {
       return;
     }
     const timer = setTimeout(resolve, delayMs);
-    signal?.addEventListener('abort', () => {
-      clearTimeout(timer);
-      reject(signal.reason || new Error('Control monitor stopped.'));
-    }, { once: true });
+    signal?.addEventListener(
+      'abort',
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason || new Error('Control monitor stopped.'));
+      },
+      { once: true },
+    );
   });
 }
 
 class CompanionRunCancelledError extends Error {
-  constructor(message = 'The Dexter companion model turn was cancelled.') {
+  constructor(message = 'The local bridge model turn was cancelled.') {
     super(message);
     this.name = 'CompanionRunCancelledError';
     this.code = 'RUN_CANCELLED';
   }
 }
 
-async function callProviderAdapter(adapter, input, {
-  send,
-  trace,
-  controlPollMs = 5_000,
-} = {}) {
+async function callProviderAdapter(
+  adapter,
+  input,
+  {
+    send,
+    trace,
+    controlPollMs = 5_000,
+    providerProgressIntervalMs = 2_000,
+    cancellationGraceMs = 15_000,
+    product,
+  } = {},
+) {
+  const productName = normalizeBridgeProduct(product).name;
   if (!adapter || typeof adapter.runModelTurn !== 'function') {
     throw new Error('The selected provider adapter cannot execute model turns.');
   }
@@ -991,12 +1384,81 @@ async function callProviderAdapter(adapter, input, {
   let finished = false;
   let cancelRequested = false;
   let cancelSent = false;
+  let cancelTimer = null;
+  let cancelActionPromise = null;
+  let rejectCancellation;
+  let lastProviderProgressSentAt = 0;
+  let activityChain = Promise.resolve();
+  const cancellation = new Promise((_, reject) => {
+    rejectCancellation = reject;
+  });
 
-  async function requestCancel() {
+  function requestCancel() {
     cancelRequested = true;
-    if (cancelSent) return;
+    if (cancelSent) return cancelActionPromise;
     cancelSent = true;
-    await adapter.cancel?.(input.sessionId);
+    cancelTimer = setTimeout(() => {
+      void adapter.resetSession?.(input.sessionId);
+      rejectCancellation(new CompanionRunCancelledError(
+        'The provider did not finish cancelling before the cleanup deadline.',
+      ));
+    }, cancellationGraceMs);
+    cancelTimer.unref?.();
+    cancelActionPromise = Promise.resolve()
+      .then(() => adapter.cancel?.(input.sessionId))
+      .catch((error) => {
+        trace?.warn('adapter_cancel_failed', {
+          error: errorMeta(error),
+        });
+      });
+    return cancelActionPromise;
+  }
+
+  function waitForCancellationAcknowledgement(providerTurn) {
+    return Promise.race([
+      Promise.allSettled([
+        providerTurn,
+        cancelActionPromise || Promise.resolve(),
+      ]),
+      cancellation,
+    ]);
+  }
+
+  function finishCancellation() {
+    return new CompanionRunCancelledError();
+  }
+
+  function postActivity(payload) {
+    activityChain = activityChain
+      .then(async () => {
+        if (finished) return;
+        const response = await send('activity', payload);
+        if (controlRequestsCancellation(response)) await requestCancel();
+      })
+      .catch((error) => {
+        if (!finished) {
+          trace?.warn('adapter_activity_post_failed', {
+            error: errorMeta(error),
+          });
+        }
+      });
+    return activityChain;
+  }
+
+  function reportProviderProgress(progress = {}) {
+    if (finished || cancelRequested) return;
+    const now = Date.now();
+    if (now - lastProviderProgressSentAt < providerProgressIntervalMs) return;
+    lastProviderProgressSentAt = now;
+    void postActivity({
+      stage: 'model_turn',
+      source: 'provider',
+      meaningful: true,
+      kind: progress.kind || 'output_delta',
+      provider: progress.provider || adapter.id || null,
+      occurredAt: progress.occurredAt || new Date(now).toISOString(),
+      message: `${adapter.label || adapter.id || 'Provider'} is actively generating the next ${productName} action.`,
+    });
   }
 
   async function monitorControl() {
@@ -1004,11 +1466,12 @@ async function callProviderAdapter(adapter, input, {
       try {
         await waitForControl(controlPollMs, monitorAbort.signal);
         if (finished || monitorAbort.signal.aborted) return;
-        const response = await send('activity', {
+        await postActivity({
           stage: 'model_turn',
-          message: `${adapter.label || adapter.id || 'Provider'} is still generating the next Dexter action.`,
+          source: 'bridge',
+          meaningful: false,
+          message: `${adapter.label || adapter.id || 'Provider'} is still generating the next ${productName} action.`,
         });
-        if (controlRequestsCancellation(response)) await requestCancel();
       } catch (error) {
         if (monitorAbort.signal.aborted) return;
         trace?.warn('adapter_control_poll_failed', { error: errorMeta(error) });
@@ -1017,15 +1480,28 @@ async function callProviderAdapter(adapter, input, {
   }
 
   const controlMonitor = monitorControl();
+  const providerTurn = Promise.resolve().then(() =>
+    adapter.runModelTurn({
+      ...input,
+      onProgress: reportProviderProgress,
+    }));
   try {
-    const result = await adapter.runModelTurn(input);
-    if (cancelRequested) throw new CompanionRunCancelledError();
+    const result = await Promise.race([providerTurn, cancellation]);
+    await Promise.race([activityChain, cancellation]);
+    if (cancelRequested) {
+      await waitForCancellationAcknowledgement(providerTurn);
+      throw finishCancellation();
+    }
     return result;
   } catch (error) {
-    if (cancelRequested) throw new CompanionRunCancelledError();
+    if (cancelRequested) {
+      await waitForCancellationAcknowledgement(providerTurn).catch(() => undefined);
+      throw finishCancellation();
+    }
     throw error;
   } finally {
     finished = true;
+    clearTimeout(cancelTimer);
     monitorAbort.abort();
     await controlMonitor.catch(() => undefined);
   }
@@ -1035,35 +1511,32 @@ export async function resolveAgentRuntime(definition, modelDefinition, options =
   const platform = options.platform || process.platform;
   const childEnv = processEnvWithCliPath(options.env || process.env, platform);
   const configuredCommand = commandFromEnv(definition.commandEnv, definition.fallbackCommand, childEnv);
-  const candidates = executableCandidates(
-    configuredCommand,
-    childEnv,
-    platform,
-    options.existsSync || fs.existsSync,
-  );
-  const inspect = options.inspect || (async (command) => {
-    try {
-      const result = await runProcess(command, ['--version'], '', {
-        timeoutMs: 10000,
-        childEnv,
-        platform,
-      });
-      const output = (result.stdout || result.stderr || '').trim();
-      return {
-        ok: true,
-        command,
-        output,
-        version: parseAgentVersion(output),
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        command,
-        code: error?.code,
-        error: error?.message || String(error || ''),
-      };
-    }
-  });
+  const candidates = executableCandidates(configuredCommand, childEnv, platform, options.existsSync || fs.existsSync);
+  const inspect =
+    options.inspect
+    || (async (command) => {
+      try {
+        const result = await runProcess(command, ['--version'], '', {
+          timeoutMs: 10000,
+          childEnv,
+          platform,
+        });
+        const output = (result.stdout || result.stderr || '').trim();
+        return {
+          ok: true,
+          command,
+          output,
+          version: parseAgentVersion(output),
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          command,
+          code: error?.code,
+          error: error?.message || String(error || ''),
+        };
+      }
+    });
   const inspections = await Promise.all(candidates.map((candidate) => inspect(candidate)));
   return selectAgentRuntime(inspections, definition, modelDefinition);
 }
@@ -1122,7 +1595,10 @@ export async function checkAgentAuthentication(agent, runtime, options = {}) {
   const childEnv = processEnvWithCliPath(options.env || process.env, platform);
   const inspect = options.inspect || inspectClaudeAuthentication;
   try {
-    const authentication = await inspect(runtime.command, { childEnv, platform });
+    const authentication = await inspect(runtime.command, {
+      childEnv,
+      platform,
+    });
     if (authentication?.loggedIn === true) {
       return {
         ok: true,
@@ -1152,7 +1628,13 @@ async function callLocalJsonAgent(agent, prompt, options = {}) {
   const args = buildAgentArgs(definition, modelDefinition, process.env, {
     resumeSessionId: options.resumeSessionId,
     outputSchema: options.outputSchema,
+    responseContract: options.responseContract,
     step: options.step,
+    product: options.product,
+    nativeSkillsEnabled: options.nativeSkillsEnabled,
+    harnessMode: options.harnessMode,
+    mcpConfig: options.mcpConfig,
+    harnessToolNames: options.harnessToolNames,
   });
   const timeoutMs = options.timeoutMs || Number(process.env.DEXTER_BRIDGE_AGENT_TIMEOUT_MS || 120000);
   const maxDurationMs = boundedDurationMs(
@@ -1178,13 +1660,17 @@ async function callLocalJsonAgent(agent, prompt, options = {}) {
     maxDurationMs,
     trace: options.trace,
     signal: options.signal,
+    cwd: options.cwd,
+    onProgress: options.onProgress,
+    stdoutProgress:
+      definition.id === 'claude-code'
+        ? createClaudeProgressParser(options.onProgress, { cwd: options.cwd })
+        : undefined,
   });
 }
 
 function agentErrorWithOutputUsage(agent, error) {
-  const failure = error instanceof Error
-    ? error
-    : new Error(String(error || 'The companion model call failed.'));
+  const failure = error instanceof Error ? error : new Error(String(error || 'The companion model call failed.'));
   const parsed = parseAgentOutput(agent, failure.stdout || '');
   if (!parsed.usageAvailable) return failure;
   const accumulator = createCompanionUsageAccumulator(agent);
@@ -1195,7 +1681,9 @@ function agentErrorWithOutputUsage(agent, error) {
 }
 
 async function executeModelTurnRun(run, send, agent, options = {}) {
-  if (normalizeAgentName(agent) === 'dry-run') {
+  const product = normalizeBridgeProduct(run?.product || options.product);
+  const productName = product.name;
+  if (normalizeAgentName(agent) === 'dry-run' && !options.providerAdapter) {
     await send('done', {
       operationType: 'chat',
       outcome: 'answer',
@@ -1210,30 +1698,50 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
     });
     return;
   }
-  const definition = definitionForAgent(agent);
-  const requestedModel = run?.companion?.model?.id || run?.model || options.selectedModel;
-  const selectedModel = companionModelDefinition(requestedModel, definition.id);
-  const selectedModelId = typeof requestedModel === 'string' && requestedModel.trim()
-    ? requestedModel.trim()
-    : selectedModel?.id || definition.model;
+  const definition = definitionForRuntimeProfile(run?.runtimeProfile, agent);
+  const requestedModel =
+    run?.runtimeProfile?.model?.id || run?.companion?.model?.id || run?.model || options.selectedModel;
+  const selectedModel = run?.runtimeProfile?.model || companionModelDefinition(requestedModel, definition.id);
+  const selectedModelId =
+    typeof requestedModel === 'string' && requestedModel.trim()
+      ? requestedModel.trim()
+      : selectedModel?.id || definition.model;
   const adapter = options.providerAdapter || null;
   const sessionKey = companionSessionKey(run);
   const rememberedSession = rememberedCompanionSession(sessionKey);
-  const deltaRequested =
-    deltaModelSessionsEnabled(options.env)
-    && run?.modelTurn?.session?.contextMode === 'delta';
+  const nativeSkills = normalizeNativeSkills(run?.modelTurn?.nativeSkills);
+  const nativeProvider =
+    definition.id === 'claude-code'
+      ? 'claude-code'
+      : adapter?.id === 'codex' || definition.id === 'codex'
+        ? 'codex'
+        : null;
+  const materializedNativeSkills =
+    nativeProvider === 'claude-code'
+      ? materializeNativeSkills(nativeSkills, {
+          provider: nativeProvider,
+          sessionId: sessionKey,
+        })
+      : null;
+  const deltaRequested = deltaModelSessionsEnabled(options.env) && run?.modelTurn?.session?.contextMode === 'delta';
   let callContextMode = deltaRequested && rememberedSession ? 'delta' : 'full';
-  let prompt = callContextMode === 'delta'
-    ? buildModelTurnDeltaPrompt(run.modelTurn)
-    : deltaRequested
-      ? buildModelTurnFallbackPrompt(run.modelTurn)
-      : buildModelTurnPrompt(run.modelTurn);
+  let prompt =
+    callContextMode === 'delta'
+      ? buildModelTurnDeltaPrompt(run.modelTurn, product)
+      : deltaRequested
+        ? buildModelTurnFallbackPrompt(run.modelTurn, product)
+        : buildModelTurnPrompt(run.modelTurn, product);
+  if (materializedNativeSkills) {
+    prompt = claudeNativeSkillPrompt(prompt, materializedNativeSkills);
+  }
   const callStartedAt = Date.now();
   let providerSessionId;
   let fallbackAfterResumeFailure = false;
+  let providerAttempts = 0;
+  let retryReason = null;
   const statusResponse = await send('status', {
     stage: 'model_turn',
-    message: `${definition.label} is generating the next Dexter action.`,
+    message: `${definition.label} is generating the next ${productName} action.`,
   });
   if (controlRequestsCancellation(statusResponse)) {
     if (adapter) await adapter.cancel?.(adapterSessionId(run));
@@ -1241,32 +1749,35 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
   }
   const usageAccumulator = createCompanionUsageAccumulator(definition.id);
   const failedModelCall = (error) => {
-    const failure = error instanceof Error
-      ? error
-      : new Error(String(error || 'The companion model call failed.'));
+    const failure = error instanceof Error ? error : new Error(String(error || 'The companion model call failed.'));
     usageAccumulator.add(failure.companionUsage || {});
     const snapshot = usageAccumulator.snapshot();
     failure.companionUsage = {
       ...snapshot,
-      modelCalls: [{
-        callId: run.runId,
-        step: Number(run?.modelTurn?.step ?? 0),
-        model: selectedModelId,
-        status: 'failed',
-        durationMs: Date.now() - callStartedAt,
-        promptChars: prompt.length,
-        requestedContextMode: deltaRequested ? 'delta' : 'full',
-        contextMode: callContextMode,
-        resumed: callContextMode === 'delta',
-        resumeSessionAvailable: Boolean(rememberedSession),
-        fallbackAfterResumeFailure,
-        ...snapshot.tokenUsage,
-        estimatedCostUSD: snapshot.estimatedCostUSD,
-      }],
+      modelCalls: [
+        {
+          callId: run.runId,
+          step: Number(run?.modelTurn?.step ?? 0),
+          model: selectedModelId,
+          status: 'failed',
+          durationMs: Date.now() - callStartedAt,
+          promptChars: prompt.length,
+          requestedContextMode: deltaRequested ? 'delta' : 'full',
+          contextMode: callContextMode,
+          resumed: callContextMode === 'delta',
+          resumeSessionAvailable: Boolean(rememberedSession),
+          fallbackAfterResumeFailure,
+          providerAttemptCount: Math.max(1, providerAttempts),
+          retryReason,
+          ...snapshot.tokenUsage,
+          estimatedCostUSD: snapshot.estimatedCostUSD,
+        },
+      ],
     };
     return failure;
   };
   let resultText;
+  let nativeSkillStatus = null;
   if (adapter) {
     const sessionId = sessionKey || adapterSessionId(run);
     const invocationModel = adapterInvocationModel(run, selectedModel, definition.id);
@@ -1287,22 +1798,19 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
       prompt,
       model: invocationModel,
       outputSchema: modelTurnOutputSchema(run.modelTurn),
-      timeoutMs: boundedDurationMs(
-        options.timeoutMs ?? options.env?.DEXTER_BRIDGE_AGENT_TIMEOUT_MS,
-        120000,
-        1000,
-      ),
+      responseContract: STRUCTURED_RESPONSE_CONTRACTS.MODEL_TURN,
+      timeoutMs: boundedDurationMs(options.timeoutMs ?? options.env?.DEXTER_BRIDGE_AGENT_TIMEOUT_MS, 120000, 1000),
       maxDurationMs: boundedDurationMs(
-        run?.modelTurn?.maxDurationMs
-          ?? options.maxDurationMs
-          ?? options.env?.DEXTER_BRIDGE_AGENT_MAX_DURATION_MS,
+        run?.modelTurn?.maxDurationMs ?? options.maxDurationMs ?? options.env?.DEXTER_BRIDGE_AGENT_MAX_DURATION_MS,
         600000,
         1000,
       ),
+      nativeSkills,
     };
     const adapterOptions = {
       send,
       trace: options.trace,
+      product,
       controlPollMs: boundedDurationMs(
         options.controlPollMs ?? options.env?.DEXTER_BRIDGE_CONTROL_POLL_MS,
         5_000,
@@ -1313,36 +1821,72 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
     let result;
     try {
       result = await callProviderAdapter(adapter, adapterInput, adapterOptions);
+      providerAttempts += providerAttemptCount(result);
+      retryReason = result?.retryReason || retryReason;
     } catch (error) {
-      if (callContextMode !== 'delta' || !resumeFailure(error)) throw failedModelCall(error);
+      const retryResumeFailure = callContextMode === 'delta' && resumeFailure(error);
+      const retryFreshSession = freshSessionRetryFailure(error, adapter);
+      providerAttempts += providerAttemptCount(error);
+      if (!retryResumeFailure && !retryFreshSession) {
+        throw failedModelCall(error);
+      }
       usageAccumulator.add(error?.companionUsage || {});
       fallbackAfterResumeFailure = true;
+      retryReason =
+        error?.code === 'APP_AGENT_TURN_INACTIVITY_TIMEOUT'
+          ? 'timeout'
+          : retryFreshSession
+            ? 'transport_error'
+            : 'resume_failure';
       callContextMode = 'full';
-      prompt = buildModelTurnFallbackPrompt(run.modelTurn);
+      prompt = buildModelTurnFallbackPrompt(run.modelTurn, product);
+      if (materializedNativeSkills) {
+        prompt = claudeNativeSkillPrompt(prompt, materializedNativeSkills);
+      }
       await adapter.resetSession?.(sessionId);
       options.trace?.warn('agent_adapter_resume_fallback', {
         sessionId,
         error: errorMeta(error),
         fallbackPromptChars: prompt.length,
       });
-      result = await callProviderAdapter(adapter, { ...adapterInput, prompt }, adapterOptions)
+      const retryTimeoutMs = retryFreshSession
+        ? boundedDurationMs(options.env?.DEXTER_BRIDGE_CODEX_RETRY_TIMEOUT_MS, 180000, 1000)
+        : adapterInput.timeoutMs;
+      result = await callProviderAdapter(
+        adapter,
+        {
+          ...adapterInput,
+          prompt,
+          timeoutMs: retryTimeoutMs,
+          maxTransportCorrectionAttempts: 1,
+        },
+        adapterOptions,
+      )
+        .then((result) => {
+          providerAttempts += providerAttemptCount(result);
+          retryReason = retryReason || result?.retryReason || null;
+          return result;
+        })
         .catch((error) => {
+          providerAttempts += providerAttemptCount(error);
           throw failedModelCall(error);
         });
     }
     usageAccumulator.add(result);
     resultText = result?.text;
     providerSessionId = result?.threadId || result?.sessionId;
+    nativeSkillStatus = result?.nativeSkillLifecycle || null;
   } else {
-    const runtime = options.runtime || await resolveAgentRuntime(definition, selectedModel, {
-      env: options.env,
-    });
+    const runtime =
+      options.runtime
+      || (await resolveAgentRuntime(definition, selectedModel, {
+        env: options.env,
+      }));
     if (!runtime.ok) {
       throw new Error(runtime.error || `${definition.label} is not available.`);
     }
     const resumeSessionId =
-      callContextMode === 'delta'
-      && agentSessionResumeEnabled(definition, options.env)
+      callContextMode === 'delta' && agentSessionResumeEnabled(definition, options.env)
         ? rememberedSession?.providerSessionId
         : undefined;
     const cliAbort = new AbortController();
@@ -1355,23 +1899,60 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
     );
     let cliFinished = false;
     let cliCancelled = false;
+    let lastProviderProgressSentAt = 0;
+    let activityChain = Promise.resolve();
+    const requestCliCancel = () => {
+      if (cliCancelled) return;
+      cliCancelled = true;
+      cliAbort.abort(
+        Object.assign(
+          new Error(`The ${productName} bridge model turn was cancelled.`),
+          { code: 'RUN_CANCELLED' },
+        ),
+      );
+    };
+    const postCliActivity = (payload) => {
+      activityChain = activityChain
+        .then(async () => {
+          const response = await send('activity', payload);
+          if (controlRequestsCancellation(response)) requestCliCancel();
+        })
+        .catch((error) => {
+          if (!cliFinished) {
+            options.trace?.warn('cli_activity_post_failed', {
+              error: errorMeta(error),
+            });
+          }
+        });
+      return activityChain;
+    };
+    const reportCliProgress = (progress = {}) => {
+      if (cliFinished || cliCancelled) return;
+      const now = Date.now();
+      if (now - lastProviderProgressSentAt < 2_000) return;
+      lastProviderProgressSentAt = now;
+      void postCliActivity({
+        stage: 'model_turn',
+        source: 'provider',
+        meaningful: true,
+        kind: progress.kind || 'output_delta',
+        provider: definition.id,
+        occurredAt: progress.occurredAt || new Date(now).toISOString(),
+        message: `${definition.label} is actively generating the next ${productName} action.`,
+      });
+    };
     const controlMonitor = (async () => {
       while (!cliFinished && !monitorAbort.signal.aborted) {
         try {
           await waitForControl(controlPollMs, monitorAbort.signal);
           if (cliFinished || monitorAbort.signal.aborted) return;
-          const response = await send('activity', {
+          await postCliActivity({
             stage: 'model_turn',
-            message: `${definition.label} is still generating the next Dexter action.`,
+            source: 'bridge',
+            meaningful: false,
+            message: `${definition.label} is still generating the next ${productName} action.`,
           });
-          if (controlRequestsCancellation(response)) {
-            cliCancelled = true;
-            cliAbort.abort(Object.assign(
-              new Error('The Dexter companion model turn was cancelled.'),
-              { code: 'RUN_CANCELLED' },
-            ));
-            return;
-          }
+          if (cliCancelled) return;
         } catch (error) {
           if (monitorAbort.signal.aborted) return;
           options.trace?.warn('cli_control_poll_failed', {
@@ -1388,9 +1969,14 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
         runtime,
         resumeSessionId,
         outputSchema: modelTurnOutputSchema(run.modelTurn),
+        responseContract: STRUCTURED_RESPONSE_CONTRACTS.MODEL_TURN,
         step: run?.modelTurn?.step,
+        product,
         maxDurationMs: run?.modelTurn?.maxDurationMs ?? options.maxDurationMs,
         signal: cliAbort.signal,
+        cwd: materializedNativeSkills?.workspace,
+        nativeSkillsEnabled: Boolean(materializedNativeSkills),
+        onProgress: reportCliProgress,
       });
     } catch (error) {
       if (cliCancelled || error?.code === 'RUN_CANCELLED') {
@@ -1401,7 +1987,10 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
       usageAccumulator.add(failure.companionUsage || {});
       fallbackAfterResumeFailure = true;
       callContextMode = 'full';
-      prompt = buildModelTurnFallbackPrompt(run.modelTurn);
+      prompt = buildModelTurnFallbackPrompt(run.modelTurn, product);
+      if (materializedNativeSkills) {
+        prompt = claudeNativeSkillPrompt(prompt, materializedNativeSkills);
+      }
       options.trace?.warn('agent_cli_resume_fallback', {
         resumeSessionId,
         error: errorMeta(failure),
@@ -1413,9 +2002,14 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
         runtime,
         resumeSessionId: undefined,
         outputSchema: modelTurnOutputSchema(run.modelTurn),
+        responseContract: STRUCTURED_RESPONSE_CONTRACTS.MODEL_TURN,
         step: run?.modelTurn?.step,
+        product,
         maxDurationMs: run?.modelTurn?.maxDurationMs ?? options.maxDurationMs,
         signal: cliAbort.signal,
+        cwd: materializedNativeSkills?.workspace,
+        nativeSkillsEnabled: Boolean(materializedNativeSkills),
+        onProgress: reportCliProgress,
       }).catch((error) => {
         if (cliCancelled || error?.code === 'RUN_CANCELLED') {
           throw new CompanionRunCancelledError();
@@ -1427,10 +2021,19 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
       monitorAbort.abort();
       await controlMonitor.catch(() => undefined);
     }
+    await activityChain;
+    if (cliCancelled) throw new CompanionRunCancelledError();
     const parsed = parseAgentOutput(definition.id, result.stdout);
     usageAccumulator.add(parsed);
     resultText = parsed.resultText;
     providerSessionId = parsed.sessionId;
+    nativeSkillStatus = materializedNativeSkills
+      ? nativeSkillLifecycle(
+          materializedNativeSkills,
+          'slash-command',
+          callContextMode === 'delta',
+        )
+      : null;
   }
   if (providerSessionId || adapter) {
     rememberCompanionSession(sessionKey, {
@@ -1451,6 +2054,8 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
     resumed: callContextMode === 'delta',
     resumeSessionAvailable: Boolean(rememberedSession),
     fallbackAfterResumeFailure,
+    providerAttemptCount: Math.max(1, providerAttempts),
+    retryReason,
     ...usageSnapshot.tokenUsage,
     estimatedCostUSD: usageSnapshot.estimatedCostUSD,
   };
@@ -1460,10 +2065,7 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
   };
   let completion;
   try {
-    completion = normalizeModelTurnCompletion(
-      extractJsonObject(resultText),
-      selectedModelId,
-    );
+    completion = normalizeModelTurnCompletion(extractJsonObject(resultText), selectedModelId);
   } catch (error) {
     error.companionUsage = {
       ...usage,
@@ -1476,30 +2078,507 @@ async function executeModelTurnRun(run, send, agent, options = {}) {
     outcome: 'answer',
     completion,
     model: selectedModelId,
+    ...(nativeSkillStatus
+      ? { nativeSkillLifecycle: nativeSkillStatus }
+      : {}),
     ...usage,
   });
 }
 
-export async function executeRun(run, {
-  apiBaseUrl,
-  deviceToken,
-  agent = process.env.DEXTER_BRIDGE_AGENT || DEFAULT_BRIDGE_AGENT,
-  fetchImpl,
-  log = console.log,
-  logDir,
-  selectedModel,
-  providerAdapter,
-  adapterOptions,
-  env = process.env,
-  controlPollMs,
-  inspectAgentAuthentication,
-} = {}) {
+async function executeOutcomeRun(run, send, agent, options = {}) {
+  const product = normalizeBridgeProduct(run?.product || options.product);
+  const definition = definitionForRuntimeProfile(run?.runtimeProfile, agent);
+  const requestedModel =
+    run?.runtimeProfile?.model?.id
+    || run?.companion?.model?.id
+    || run?.model
+    || options.selectedModel;
+  const selectedModel =
+    run?.runtimeProfile?.model
+    || companionModelDefinition(requestedModel, definition.id);
+  const selectedModelId =
+    typeof requestedModel === 'string' && requestedModel.trim()
+      ? requestedModel.trim()
+      : selectedModel?.id || definition.model;
+  const outcomeMaxDurationMs = boundedDurationMs(
+    run?.outcome?.maxDurationMs
+      ?? options.maxDurationMs
+      ?? options.env?.DEXTER_BRIDGE_AGENT_MAX_DURATION_MS,
+    20 * 60_000,
+    1_000,
+  );
+  const outcomeInactivityTimeoutMs = Math.min(
+    outcomeMaxDurationMs,
+    boundedDurationMs(
+      options.timeoutMs ?? options.env?.DEXTER_BRIDGE_AGENT_TIMEOUT_MS,
+      10 * 60_000,
+      1_000,
+    ),
+  );
+  const sessionKey = companionSessionKey(run);
+  const infrastructureAbortController = new AbortController();
+  const controlMonitorAbort = new AbortController();
+  let finished = false;
+  let cancelRequested = false;
+  let cancelAction = null;
+  let rejectCancellation;
+  let latestTokenUsage = normalizeCompanionTokenUsage();
+  let activityChain = Promise.resolve();
+  const cancellation = new Promise((_, reject) => {
+    rejectCancellation = reject;
+  });
+  const cancellationError = () => {
+    const error = new CompanionRunCancelledError();
+    error.companionUsage = {
+      tokenUsage: latestTokenUsage,
+      usageAvailable: latestTokenUsage.totalTokens > 0,
+      usageSource: definition.id,
+      usageAccuracy: latestTokenUsage.totalTokens > 0 ? 'reported' : 'unavailable',
+    };
+    return error;
+  };
+  const requestCancel = () => {
+    if (cancelRequested) return cancelAction;
+    cancelRequested = true;
+    infrastructureAbortController.abort();
+    cancelAction = Promise.resolve(options.providerAdapter?.cancel?.(sessionKey))
+      .catch((error) => {
+        options.trace?.warn?.('outcome_cancel_failed', { error: errorMeta(error) });
+      });
+    rejectCancellation(cancellationError());
+    return cancelAction;
+  };
+  const postActivity = (payload) => {
+    activityChain = activityChain
+      .then(async () => {
+        if (finished) return;
+        const response = await send('activity', payload);
+        if (controlRequestsCancellation(response)) await requestCancel();
+      })
+      .catch((error) => {
+        if (!finished) {
+          options.trace?.warn?.('outcome_activity_post_failed', {
+            error: errorMeta(error),
+          });
+        }
+      });
+    return activityChain;
+  };
+  const progress = (event = {}) => {
+    if (event.tokenUsage) {
+      latestTokenUsage = normalizeCompanionTokenUsage(event.tokenUsage);
+    }
+    if (event.kind === 'token_usage') {
+      void postActivity({
+        stage: 'outcome',
+        outcomeId: run?.outcome?.outcomeId,
+        source: event.source || 'provider',
+        meaningful: false,
+        kind: 'token_usage',
+        provider: definition.id,
+        tokenUsage: event.tokenUsage || undefined,
+        occurredAt: event.occurredAt || new Date().toISOString(),
+      });
+      return;
+    }
+    const meaningful =
+      Boolean(event.message || event.name) ||
+      event.kind === 'turn_started';
+    if (!meaningful) return;
+    const userFacingUpdate = event.kind === 'status_update';
+    void postActivity({
+      stage: 'outcome',
+      outcomeId: run?.outcome?.outcomeId,
+      source: event.source || 'provider',
+      meaningful: true,
+      kind: userFacingUpdate ? 'output_delta' : event.kind || 'output_delta',
+      provider: definition.id,
+      tool: event.name || undefined,
+      toolPhase: event.phase || undefined,
+      activity:
+        event.activity ||
+        (userFacingUpdate ? `assistant-progress:${Date.now()}` : undefined),
+      paths: event.paths || undefined,
+      tokenUsage: event.tokenUsage || undefined,
+      occurredAt: event.occurredAt || new Date().toISOString(),
+      message:
+        event.message ||
+        (event.name
+          ? `${definition.label} is using ${event.name}.`
+          : `${definition.label} started implementing your request.`),
+    });
+  };
+  const monitorControl = async () => {
+    while (!finished && !controlMonitorAbort.signal.aborted) {
+      try {
+        await waitForControl(
+          Math.max(500, Number(options.controlPollMs) || 5_000),
+          controlMonitorAbort.signal,
+        );
+        if (finished || controlMonitorAbort.signal.aborted) return;
+        const response = await send('activity', {
+          stage: 'outcome',
+          outcomeId: run?.outcome?.outcomeId,
+          source: 'bridge',
+          meaningful: false,
+          kind: 'heartbeat',
+          provider: definition.id,
+          occurredAt: new Date().toISOString(),
+          message: `${definition.label} is still working.`,
+        });
+        if (controlRequestsCancellation(response)) await requestCancel();
+      } catch (error) {
+        if (!controlMonitorAbort.signal.aborted && !cancelRequested) {
+          options.trace?.warn?.('outcome_control_poll_failed', {
+            error: errorMeta(error),
+          });
+        }
+      }
+    }
+  };
+  const controlMonitor = monitorControl();
+  const rememberedSession =
+    rememberedCompanionSession(sessionKey) ||
+    (run?.outcome?.session?.providerSessionId
+      ? {
+          providerSessionId: run.outcome.session.providerSessionId,
+          agent: definition.id,
+          updatedAt: Date.now(),
+        }
+      : null);
+  const framerAgentOutcome =
+    run?.outcome?.kind === 'framer-project'
+    || run?.outcome?.context?.executionMode === 'framer-agent';
+  const materialized = materializeOutcomeWorkspace(run?.outcome, {
+    sessionId: run?.outcome?.context?.harnessSessionId || sessionKey,
+  });
+  const nativeSkills = normalizeNativeSkills(run?.outcome?.nativeSkills);
+  const nativeProvider =
+    definition.id === 'claude-code'
+      ? 'claude-code'
+      : definition.id === 'opencode' ||
+          options.providerAdapter?.driverKind === 'opencode'
+        ? 'opencode'
+      : options.providerAdapter?.id === 'codex' || definition.id === 'codex'
+        ? 'codex'
+        : null;
+  const materializedNativeSkills =
+    nativeProvider === 'claude-code' || nativeProvider === 'opencode'
+      ? materializeNativeSkills(nativeSkills, {
+          provider: nativeProvider,
+          sessionId: run?.outcome?.context?.harnessSessionId || sessionKey,
+          projectDirectory: materialized.directory,
+        })
+      : null;
+  const harnessTools = framerAgentOutcome
+    ? createFramerAgentToolRuntime({
+        assignment: run?.outcome,
+        cwd: materialized.directory,
+        env: options.env,
+        trace: options.trace,
+        onActivity: progress,
+        runCli: options.framerAgentRunCli,
+        authorizeProject:
+          options.apiBaseUrl && options.deviceToken
+            ? ({ initiate, forceRefresh, signal }) =>
+                getFramerProjectAuthorization(options.apiBaseUrl, {
+                  deviceToken: options.deviceToken,
+                  runId: run.runId,
+                  initiate,
+                  forceRefresh,
+                  fetchImpl: options.fetchImpl,
+                  signal,
+                  allowInsecureHttp: options.allowInsecureHttp,
+                })
+            : undefined,
+        openAuthorizationUrl: options.openAuthorizationUrl,
+      })
+    : createHarnessToolRuntime({
+        assignment: run?.outcome,
+        materialized,
+        send,
+        trace: options.trace,
+        onActivity: progress,
+      });
+  let prompt = buildOutcomePrompt(run.outcome, product);
+  if (materializedNativeSkills) {
+    prompt = claudeNativeSkillPrompt(prompt, materializedNativeSkills);
+  }
+  const schema = outcomeOutputSchema();
+  assertOutcomeResponseContract(
+    STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
+    schema,
+  );
+  const callStartedAt = Date.now();
+  const usageAccumulator = createCompanionUsageAccumulator(definition.id);
+  let providerAttempts = 0;
+  let result;
+  try {
+    if (framerAgentOutcome) {
+      await Promise.race([harnessTools.preflight(), cancellation]);
+    }
+    const gateway =
+      definition.id === 'codex' ? null : await harnessTools.startGateway();
+    const mcpServer = gateway
+      ? {
+          command: process.execPath,
+          args: [HARNESS_MCP_SERVER_PATH],
+          cwd: materialized.directory,
+          environment: harnessMcpProcessEnvironment(
+            gateway,
+            process.versions,
+            harnessTools.toolNames,
+          ),
+        }
+      : null;
+    const mcpConfig = mcpServer
+      ? {
+          mcpServers: {
+            instawebai: {
+              command: mcpServer.command,
+              args: mcpServer.args,
+              env: mcpServer.environment,
+            },
+          },
+        }
+      : null;
+    const statusResponse = await send('status', {
+      stage: 'outcome',
+      outcomeId: run?.outcome?.outcomeId,
+      message: `${definition.label} is implementing ${run?.outcome?.title || 'the requested outcome'}.`,
+    });
+    if (controlRequestsCancellation(statusResponse)) {
+      await options.providerAdapter?.cancel?.(sessionKey);
+      throw new CompanionRunCancelledError();
+    }
+    const providerExecution = (async () => {
+      if (options.providerAdapter?.runOutcome) {
+        const providerResult = await options.providerAdapter.runOutcome({
+          runId: run.runId,
+          sessionId: sessionKey,
+          resumeSessionId: rememberedSession?.providerSessionId,
+          prompt,
+          model: adapterInvocationModel(run, selectedModel, definition.id),
+          outputSchema: schema,
+          responseContract: STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
+          timeoutMs: outcomeInactivityTimeoutMs,
+          maxDurationMs: outcomeMaxDurationMs,
+          cwd: materialized.directory,
+          nativeSkills,
+          framerHarness: framerAgentOutcome,
+          harnessTools: {
+            definitions: codexDynamicToolSpecs(harnessTools.definitions),
+            invoke: harnessTools.invoke,
+            ...(mcpConfig ? { mcpConfig } : {}),
+            ...(mcpServer ? { mcpServer } : {}),
+          },
+          onProgress: progress,
+        });
+        providerAttempts += providerAttemptCount(providerResult);
+        return providerResult;
+      }
+      const runtime =
+        options.runtime
+        || (await resolveAgentRuntime(definition, selectedModel, {
+          env: options.env,
+        }));
+      if (!runtime.ok) {
+        throw new Error(runtime.error || `${definition.label} is not available.`);
+      }
+      const resumeSessionId =
+        agentSessionResumeEnabled(definition, options.env)
+          ? rememberedSession?.providerSessionId
+          : undefined;
+      let processResult;
+      try {
+        providerAttempts += 1;
+        processResult = await callLocalJsonAgent(definition.id, prompt, {
+          ...options,
+          model: selectedModelId,
+          timeoutMs: outcomeInactivityTimeoutMs,
+          runtime,
+          resumeSessionId,
+          outputSchema: schema,
+          responseContract: STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
+          product,
+          step: 0,
+          maxDurationMs: outcomeMaxDurationMs,
+          cwd: materialized.directory,
+          harnessMode: true,
+          framerHarness: framerAgentOutcome,
+          harnessToolNames: harnessTools.toolNames,
+          nativeSkillsEnabled: Boolean(materializedNativeSkills),
+          signal: infrastructureAbortController.signal,
+          ...(mcpConfig ? { mcpConfig } : {}),
+          onProgress: progress,
+        });
+      } catch (error) {
+        if (!resumeSessionId || !resumeFailure(error)) throw error;
+        providerAttempts += 1;
+        processResult = await callLocalJsonAgent(definition.id, prompt, {
+          ...options,
+          model: selectedModelId,
+          timeoutMs: outcomeInactivityTimeoutMs,
+          runtime,
+          outputSchema: schema,
+          responseContract: STRUCTURED_RESPONSE_CONTRACTS.OUTCOME,
+          product,
+          step: 0,
+          maxDurationMs: outcomeMaxDurationMs,
+          cwd: materialized.directory,
+          harnessMode: true,
+          framerHarness: framerAgentOutcome,
+          harnessToolNames: harnessTools.toolNames,
+          nativeSkillsEnabled: Boolean(materializedNativeSkills),
+          signal: infrastructureAbortController.signal,
+          ...(mcpConfig ? { mcpConfig } : {}),
+          onProgress: progress,
+        });
+      }
+      const parsedOutput = parseAgentOutput(definition.id, processResult.stdout);
+      return {
+        ...parsedOutput,
+        text: parsedOutput.resultText,
+        sessionId: parsedOutput.sessionId,
+      };
+    })();
+    const infrastructureFailure = harnessTools
+      .waitForFatalInfrastructure()
+      .then(async (error) => {
+        options.trace?.error?.('harness_infrastructure_failed', {
+          code: error?.code,
+          message: error?.message,
+        });
+        infrastructureAbortController.abort(error);
+        await Promise.resolve(
+          options.providerAdapter?.cancel?.(sessionKey),
+        ).catch(() => undefined);
+        throw error;
+      });
+    try {
+      result = await Promise.race([
+        providerExecution,
+        infrastructureFailure,
+        cancellation,
+      ]);
+      await Promise.race([activityChain, cancellation]);
+    } catch (error) {
+      if (cancelRequested) throw cancellationError();
+      throw error;
+    }
+    const providerSessionId = result?.threadId || result?.sessionId;
+    if (providerSessionId || options.providerAdapter) {
+      rememberCompanionSession(sessionKey, {
+        providerSessionId:
+          providerSessionId ||
+          rememberedSession?.providerSessionId ||
+          sessionKey,
+        agent: definition.id,
+        updatedAt: Date.now(),
+      });
+    }
+    usageAccumulator.add(result);
+    const completion = normalizeOutcomeCompletion(
+      extractJsonObject(result?.text || result?.resultText || ''),
+      run?.outcome?.outcomeId,
+    );
+    let synchronization = null;
+    if (harnessTools.directWorkspace) {
+      synchronization = await harnessTools.inspect();
+    } else if (
+      completion.status === 'ready_for_verification'
+      || harnessTools.hasPendingChanges()
+    ) {
+      synchronization = await harnessTools.synchronize();
+    }
+    const files = harnessTools.directWorkspace
+      ? []
+      : collectOutcomeWorkspaceChanges(run.outcome, materialized);
+    const normalized = synchronization
+      ? {
+          ...completion,
+          synchronized: synchronization.synchronized !== false,
+          sourceHash:
+            synchronization?.sourceHash || harnessTools.sourceHash() || null,
+          ...(typeof harnessTools.summary === 'function'
+            ? { framer: harnessTools.summary() }
+            : {}),
+        }
+      : completion;
+    const usageSnapshot = usageAccumulator.snapshot();
+    await send('done', {
+      operationType: 'outcome',
+      outcome: {
+        ...normalized,
+        files,
+      },
+      model: selectedModelId,
+      providerSessionId:
+        providerSessionId ||
+        rememberedSession?.providerSessionId ||
+        sessionKey,
+      ...usageSnapshot,
+      modelCalls: [
+        {
+          callId: run.runId,
+          outcomeId: run?.outcome?.outcomeId,
+          model: selectedModelId,
+          status:
+            normalized.status === 'ready_for_verification'
+              ? 'succeeded'
+              : normalized.status,
+          durationMs: Date.now() - callStartedAt,
+          providerAttemptCount: Math.max(1, providerAttempts),
+          ...usageSnapshot.tokenUsage,
+          estimatedCostUSD: usageSnapshot.estimatedCostUSD,
+        },
+      ],
+    });
+  } finally {
+    finished = true;
+    controlMonitorAbort.abort();
+    await controlMonitor.catch(() => undefined);
+    await harnessTools
+      .close({ waitForPending: !cancelRequested })
+      .catch(() => undefined);
+    removeOutcomeWorkspace(materialized);
+  }
+}
+
+export async function executeRun(
+  run,
+  {
+    apiBaseUrl,
+    deviceToken,
+    agent = process.env.DEXTER_BRIDGE_AGENT || DEFAULT_BRIDGE_AGENT,
+    product: configuredProduct,
+    fetchImpl,
+    log = console.log,
+    logDir,
+    selectedModel,
+    providerAdapter,
+    adapterOptions,
+    env = process.env,
+    controlPollMs,
+    inspectAgentAuthentication,
+    runtimeProfile: suppliedRuntimeProfile,
+    framerAgentRunCli,
+    openAuthorizationUrl,
+    allowInsecureHttp = false,
+  } = {},
+) {
+  const product = normalizeBridgeProduct(run?.product || configuredProduct);
+  const productName = product.name;
   if (!run?.runId) throw new Error('Companion run payload is missing runId.');
-  if (run?.protocol?.version !== 'dexter-companion-v4') {
-    throw new Error(`Unsupported Dexter Companion protocol ${run.protocol.version}. Update Dexter Bridge and reconnect.`);
+  if (!['dexter-companion-v4', 'dexter-companion-v5', 'dexter-companion-v6', 'dexter-companion-v7', 'dexter-companion-v8'].includes(run?.protocol?.version)) {
+    throw new Error(`Unsupported bridge protocol ${run.protocol.version}. Update the local bridge and reconnect.`);
   }
-  if (run?.kind !== 'model_turn' || run?.protocol?.mode !== 'model_turn') {
-    throw new Error('Dexter Companion v4 only accepts server-owned model_turn runs.');
+  const modelTurnRun =
+    run?.kind === 'model_turn' && run?.protocol?.mode === 'model_turn';
+  const outcomeRun =
+    run?.kind === 'outcome' && run?.protocol?.mode === 'outcome';
+  if (!modelTurnRun && !outcomeRun) {
+    throw new Error('The local bridge only accepts server-owned model_turn or outcome runs.');
   }
   const writeLine = (message) => {
     if (typeof log !== 'function') return;
@@ -1507,40 +2586,59 @@ export async function executeRun(run, {
     else log(message);
   };
   const trace = createRunLogger({ runId: run.runId, logDir, mirror: log });
-  const send = createEventPoster({ apiBaseUrl, deviceToken, run, fetchImpl, trace });
-  const normalizedAgent = normalizeAgentName(run?.companion?.agent || agent);
-  const runModel = run?.companion?.model?.id || run?.model || selectedModel;
+  const send = createEventPoster({
+    apiBaseUrl,
+    deviceToken,
+    run,
+    fetchImpl,
+    trace,
+    allowInsecureHttp,
+  });
+  const runtimeProfile = run?.runtimeProfile || suppliedRuntimeProfile || null;
+  const normalizedAgent = normalizeAgentName(
+    run?.companion?.agent || (runtimeProfile?.driver === 'claude-code-cli' ? 'claude-code' : agent),
+  );
+  const runModel = runtimeProfile?.model?.id || run?.companion?.model?.id || run?.model || selectedModel;
   const usageAccumulator = createCompanionUsageAccumulator(normalizedAgent);
   const adapterProvided = providerAdapter !== undefined;
-  const shareAdapter = !adapterProvided && deltaModelSessionsEnabled(env);
+  const shareAdapter =
+    !adapterProvided &&
+    (
+      (modelTurnRun && deltaModelSessionsEnabled(env)) ||
+      (outcomeRun && runtimeProfile?.capabilities?.sessionResume === true)
+    );
+  const sharedAdapterKey = `${product.id}:${runtimeProfile?.id || normalizedAgent}`;
   let activeAdapter = adapterProvided ? providerAdapter : null;
   if (!adapterProvided && shareAdapter) {
-    activeAdapter = sharedProviderAdapters.get(normalizedAgent) || null;
+    activeAdapter = sharedProviderAdapters.get(sharedAdapterKey) || null;
     if (!activeAdapter) {
-      activeAdapter = createLocalAgentAdapter(normalizedAgent, {
+      activeAdapter = createLocalAgentAdapter(runtimeProfile || normalizedAgent, {
         ...adapterOptions,
         env: adapterOptions?.env || env,
+        product,
         trace,
       });
-      if (activeAdapter) sharedProviderAdapters.set(normalizedAgent, activeAdapter);
+      if (activeAdapter) sharedProviderAdapters.set(sharedAdapterKey, activeAdapter);
     }
   } else if (!adapterProvided) {
-    activeAdapter = createLocalAgentAdapter(normalizedAgent, {
+    activeAdapter = createLocalAgentAdapter(runtimeProfile || normalizedAgent, {
       ...adapterOptions,
       env: adapterOptions?.env || env,
+      product,
       trace,
     });
   }
   const ownsAdapter = !adapterProvided && !shareAdapter && Boolean(activeAdapter);
-  if (
-    activeAdapter?.id
-    && activeAdapter.id !== normalizedAgent
-  ) {
+  if (activeAdapter?.profileId && runtimeProfile?.id && activeAdapter.profileId !== runtimeProfile.id) {
+    if (ownsAdapter) activeAdapter.close?.();
+    throw new Error(`Provider adapter ${activeAdapter.profileId} cannot execute runtime profile ${runtimeProfile.id}.`);
+  }
+  if (!runtimeProfile && activeAdapter?.id && activeAdapter.id !== normalizedAgent) {
     if (ownsAdapter) activeAdapter.close?.();
     throw new Error(`Provider adapter ${activeAdapter.id} cannot execute ${normalizedAgent} runs.`);
   }
-  writeLine(`Running Dexter companion run ${run.runId} (${normalizedAgent}, ${runModel || 'default model'}).`);
-  writeLine(`Dexter Bridge run log: ${trace.filePath || logLocationHint(logDir)}`);
+  writeLine(`Running ${productName} bridge run ${run.runId} (${normalizedAgent}, ${runModel || 'default model'}).`);
+  writeLine(`${productName} Bridge run log: ${trace.filePath || logLocationHint(logDir)}`);
   trace.info('run_start', {
     apiBaseUrl,
     agent: normalizedAgent,
@@ -1554,12 +2652,13 @@ export async function executeRun(run, {
     if (!activeAdapter && normalizedAgent !== 'dry-run') {
       const definition = definitionForAgent(normalizedAgent);
       const selectedModelDefinition = companionModelDefinition(runModel, normalizedAgent);
-      runtime = await resolveAgentRuntime(definition, selectedModelDefinition, { env });
+      runtime = await resolveAgentRuntime(definition, selectedModelDefinition, {
+        env,
+      });
       if (!runtime.ok) {
-        throw Object.assign(
-          new Error(runtime.error || `${definition.label} is not available.`),
-          { code: runtime.code },
-        );
+        throw Object.assign(new Error(runtime.error || `${definition.label} is not available.`), {
+          code: runtime.code,
+        });
       }
       const authentication = await checkAgentAuthentication(normalizedAgent, runtime, {
         env,
@@ -1572,7 +2671,7 @@ export async function executeRun(run, {
         });
       }
     }
-    await executeModelTurnRun(run, send, normalizedAgent, {
+    const executionOptions = {
       model: runModel || selectedModel,
       selectedModel: runModel || selectedModel,
       providerAdapter: activeAdapter,
@@ -1580,8 +2679,23 @@ export async function executeRun(run, {
       trace,
       env,
       controlPollMs,
+      product,
+      runtimeProfile,
+      framerAgentRunCli,
+      apiBaseUrl,
+      deviceToken,
+      fetchImpl,
+      openAuthorizationUrl,
+      allowInsecureHttp,
+    };
+    if (outcomeRun) {
+      await executeOutcomeRun(run, send, normalizedAgent, executionOptions);
+    } else {
+      await executeModelTurnRun(run, send, normalizedAgent, executionOptions);
+    }
+    trace.info('run_done', {
+      status: outcomeRun ? 'outcome_sent' : 'model_turn_sent',
     });
-    trace.info('run_done', { status: 'model_turn_sent' });
     return { cancelled: false };
   } catch (error) {
     if (error?.code === 'RUN_CANCELLED') {
@@ -1591,14 +2705,16 @@ export async function executeRun(run, {
         outcome: 'cancelled',
         message: error.message,
         code: 'RUN_CANCELLED',
+        ...(error?.companionUsage || usageAccumulator.snapshot()),
       }).catch(() => undefined);
       return { cancelled: true };
     }
     trace.error('run_failed', { error: errorMeta(error) });
     await send('error', {
       stage: 'agent',
-      message: error?.message || 'Local Companion failed.',
+      message: error?.message || 'Local bridge failed.',
       code: error?.code,
+      retryable: error?.retryable === true,
       ...(error?.companionUsage || usageAccumulator.snapshot()),
     }).catch(() => undefined);
     throw error;
@@ -1615,7 +2731,11 @@ export function __resetAgentSessionsForTests() {
 
 export function checkCommand(command, args = ['--version'], timeoutMs = 10000) {
   return runProcess(command, args, '', { timeoutMs })
-    .then((result) => ({ ok: true, command, output: (result.stdout || result.stderr || '').trim() }))
+    .then((result) => ({
+      ok: true,
+      command,
+      output: (result.stdout || result.stderr || '').trim(),
+    }))
     .catch((error) => ({ ok: false, command, error: error.message }));
 }
 
@@ -1642,20 +2762,64 @@ export async function checkAgentAvailability(agent, model, options = {}) {
     existsSync: options.existsSync,
     inspect: options.inspectRuntime,
   });
-  const supportedModels = companionModelsForAgent(normalizedAgent)
-    .filter((candidate) => modelSupportsAgentVersion(candidate, runtime.version))
-    .map((candidate) => candidate.id);
+  const supportedModels = companionModelsForAgent(normalizedAgent).filter((candidate) =>
+    modelSupportsAgentVersion(candidate, runtime.version),
+  );
   if (!runtime.ok) {
     return {
       ...runtime,
       agent: definition.id,
       label: definition.label,
-      models: supportedModels,
+      models: supportedModels.map((candidate) => candidate.id),
+      modelDetails: supportedModels,
       installed: false,
       signedIn: false,
       status: 'unavailable',
     };
   }
+  if (normalizedAgent === 'codex') {
+    const adapter =
+      options.providerAdapter
+      || createLocalAgentAdapter('codex', {
+        env: options.env,
+      });
+    try {
+      const detection = await adapter.detect();
+      if (!detection.ok || !detection.signedIn) {
+        return {
+          ...runtime,
+          ...detection,
+          ok: false,
+          agent: definition.id,
+          label: definition.label,
+          models: supportedModels.map((candidate) => candidate.id),
+          modelDetails: supportedModels,
+          installed: detection.installed !== false,
+          signedIn: false,
+          status: detection.installed === false ? 'unavailable' : 'authentication_required',
+          code: detection.installed === false ? 'DEXTER_AGENT_NOT_FOUND' : AGENT_AUTHENTICATION_REQUIRED_CODE,
+          error:
+            detection.error
+            || 'Codex is not signed in. Run `codex login` on this computer, then run the bridge command again.',
+        };
+      }
+      const reportedModels = await adapter.models();
+      return {
+        ...runtime,
+        ...detection,
+        ok: true,
+        agent: definition.id,
+        label: definition.label,
+        models: reportedModels.map((candidate) => candidate.id),
+        modelDetails: reportedModels,
+        installed: true,
+        signedIn: true,
+        status: 'ready',
+      };
+    } finally {
+      if (!options.providerAdapter) adapter.close?.();
+    }
+  }
   const authentication = await checkAgentAuthentication(normalizedAgent, runtime, {
     env: options.env,
     platform: options.platform,
@@ -1667,7 +2831,8 @@ export async function checkAgentAvailability(agent, model, options = {}) {
     ok: runtime.ok && authentication.ok,
     agent: definition.id,
     label: definition.label,
-    models: supportedModels,
+    models: supportedModels.map((candidate) => candidate.id),
+    modelDetails: supportedModels,
     installed: true,
   };
 }