@xelauvas/xela-cli 0.3.0 → 0.4.0

package/src/tools/WorkflowTool/runtime.ts

@@ -0,0 +1,331 @@
+import vm from 'node:vm'
+import { DEFAULT_CONCURRENCY } from './constants.js'
+
+export type WorkflowMeta = {
+  name: string
+  description: string
+  phases?: Array<{ title: string; detail?: string }>
+}
+
+export type WorkflowAgentOptions = {
+  label?: string
+  phase?: string
+  schema?: unknown
+  model?: string
+  subagent_type?: string
+  allowedTools?: string[]
+  maxTurns?: number
+}
+
+export type WorkflowHost = {
+  /** Run one subagent to completion and return its final text. */
+  runAgent: (
+    prompt: string,
+    options: WorkflowAgentOptions,
+    agentIndex: number,
+  ) => Promise<string>
+  onPhase?: (title: string) => void
+  onLog?: (line: string) => void
+  signal: AbortSignal
+  maxAgents: number
+}
+
+export class WorkflowScriptError extends Error {}
+
+const FORBIDDEN = [
+  { re: /^\s*import\s/m, what: 'import statements' },
+  { re: /\brequire\s*\(/, what: 'require()' },
+  { re: /\bprocess\s*\./, what: 'process' },
+  { re: /\beval\s*\(/, what: 'eval()' },
+  { re: /\bFunction\s*\(/, what: 'Function()' },
+]
+
+/**
+ * Splits the script into its `export const meta = {...}` literal and the body.
+ * The literal is evaluated in an empty context; anything that is not a plain
+ * object literal fails there, which is the "pure literal" rule.
+ */
+export function parseWorkflowScript(script: string): {
+  meta: WorkflowMeta
+  body: string
+} {
+  for (const { re, what } of FORBIDDEN) {
+    if (re.test(script)) {
+      throw new WorkflowScriptError(`Workflow scripts cannot use ${what}`)
+    }
+  }
+  const match = /export\s+const\s+meta\s*=\s*/.exec(script)
+  if (!match) {
+    throw new WorkflowScriptError(
+      'Workflow script must begin with `export const meta = {...}`',
+    )
+  }
+  const start = match.index + match[0].length
+  const end = findBalancedEnd(script, start)
+  if (end < 0) {
+    throw new WorkflowScriptError('Unterminated meta object literal')
+  }
+  const literal = script.slice(start, end + 1)
+  let meta: unknown
+  try {
+    meta = vm.runInNewContext(`(${literal})`, Object.create(null), {
+      timeout: 1000,
+    })
+  } catch (e) {
+    throw new WorkflowScriptError(
+      `meta must be a pure object literal: ${(e as Error).message}`,
+    )
+  }
+  if (
+    !meta ||
+    typeof meta !== 'object' ||
+    typeof (meta as WorkflowMeta).name !== 'string' ||
+    typeof (meta as WorkflowMeta).description !== 'string'
+  ) {
+    throw new WorkflowScriptError(
+      'meta needs string `name` and `description` fields',
+    )
+  }
+  const body = script.slice(0, match.index) + script.slice(end + 1)
+  return {
+    meta: JSON.parse(JSON.stringify(meta)) as WorkflowMeta,
+    body: body.replace(/^\s*;/, ''),
+  }
+}
+
+function findBalancedEnd(text: string, openIndex: number): number {
+  if (text[openIndex] !== '{') return -1
+  let depth = 0
+  let quote: string | null = null
+  for (let i = openIndex; i < text.length; i++) {
+    const ch = text[i]!
+    if (quote) {
+      if (ch === '\\') i++
+      else if (ch === quote) quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'" || ch === '`') quote = ch
+    else if (ch === '{') depth++
+    else if (ch === '}') {
+      depth--
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+/** Pulls the first JSON object/array out of a model answer (tolerates prose and code fences). */
+export function extractJson(text: string): unknown {
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(text)
+  const candidates = [fenced?.[1], text].filter(
+    (s): s is string => typeof s === 'string',
+  )
+  for (const candidate of candidates) {
+    const trimmed = candidate.trim()
+    try {
+      return JSON.parse(trimmed)
+    } catch {
+      // fall through to a bracket scan
+    }
+    for (const open of ['{', '[']) {
+      const close = open === '{' ? '}' : ']'
+      const first = trimmed.indexOf(open)
+      const last = trimmed.lastIndexOf(close)
+      if (first >= 0 && last > first) {
+        try {
+          return JSON.parse(trimmed.slice(first, last + 1))
+        } catch {
+          // try the other bracket
+        }
+      }
+    }
+  }
+  throw new WorkflowScriptError(
+    `Agent did not return JSON: ${text.slice(0, 200)}`,
+  )
+}
+
+async function runWithConcurrency<T>(
+  thunks: Array<() => Promise<T>>,
+  concurrency: number,
+  signal: AbortSignal,
+  onError: (index: number, err: unknown) => void,
+): Promise<Array<T | null>> {
+  const results: Array<T | null> = new Array(thunks.length).fill(null)
+  let next = 0
+  const worker = async (): Promise<void> => {
+    while (next < thunks.length) {
+      if (signal.aborted) return
+      const index = next++
+      try {
+        results[index] = await thunks[index]!()
+      } catch (err) {
+        onError(index, err)
+        results[index] = null
+      }
+    }
+  }
+  const workers = Array.from(
+    { length: Math.max(1, Math.min(concurrency, thunks.length)) },
+    () => worker(),
+  )
+  await Promise.all(workers)
+  return results
+}
+
+/**
+ * Runs the workflow body inside a vm context with the script API as globals.
+ * Resolves to whatever the script returns.
+ */
+export async function runWorkflowScript(
+  body: string,
+  args: unknown,
+  host: WorkflowHost,
+): Promise<unknown> {
+  let agentCount = 0
+  const log = (...parts: unknown[]): void => {
+    host.onLog?.(
+      parts
+        .map(p => (typeof p === 'string' ? p : safeStringify(p)))
+        .join(' '),
+    )
+  }
+
+  const agent = async (
+    prompt: unknown,
+    options: WorkflowAgentOptions = {},
+  ): Promise<unknown> => {
+    if (typeof prompt !== 'string' || prompt.trim() === '') {
+      throw new WorkflowScriptError('agent(prompt) needs a non-empty string')
+    }
+    if (host.signal.aborted) throw new WorkflowScriptError('Workflow aborted')
+    if (agentCount >= host.maxAgents) {
+      throw new WorkflowScriptError(
+        `Workflow exceeded max_agents (${host.maxAgents}); raise max_agents or launch fewer agents`,
+      )
+    }
+    const index = agentCount++
+    if (options.phase) host.onPhase?.(options.phase)
+    let fullPrompt = prompt
+    if (options.schema) {
+      fullPrompt +=
+        `\n\nRespond with ONLY a JSON value matching this JSON Schema, no prose, no markdown fences:\n` +
+        safeStringify(options.schema)
+    }
+    const text = await host.runAgent(fullPrompt, options, index)
+    return options.schema ? extractJson(text) : text
+  }
+
+  const parallel = async (
+    items: unknown,
+    options: { concurrency?: number } = {},
+  ): Promise<unknown[]> => {
+    if (!Array.isArray(items)) {
+      throw new WorkflowScriptError('parallel() expects an array of () => Promise')
+    }
+    const thunks = items.map((item, i) => {
+      if (typeof item === 'function') return item as () => Promise<unknown>
+      if (item && typeof (item as Promise<unknown>).then === 'function') {
+        return () => item as Promise<unknown>
+      }
+      throw new WorkflowScriptError(
+        `parallel(): item ${i} is neither a function nor a promise`,
+      )
+    })
+    return runWithConcurrency(
+      thunks,
+      options.concurrency ?? DEFAULT_CONCURRENCY,
+      host.signal,
+      (i, err) => log(`parallel[${i}] failed: ${errorText(err)}`),
+    )
+  }
+
+  const pipeline = async (
+    items: unknown,
+    ...stages: unknown[]
+  ): Promise<unknown[]> => {
+    if (!Array.isArray(items)) {
+      throw new WorkflowScriptError('pipeline() expects an array as first argument')
+    }
+    if (stages.length === 0 || stages.some(s => typeof s !== 'function')) {
+      throw new WorkflowScriptError('pipeline() needs one or more stage functions')
+    }
+    const fns = stages as Array<(input: unknown) => Promise<unknown>>
+    const thunks = items.map(item => async () => {
+      let value: unknown = item
+      for (const stage of fns) {
+        value = await stage(value)
+      }
+      return value
+    })
+    return runWithConcurrency(thunks, DEFAULT_CONCURRENCY, host.signal, (i, err) =>
+      log(`pipeline[${i}] failed: ${errorText(err)}`),
+    )
+  }
+
+  const phase = async (title: unknown, fn?: unknown): Promise<unknown> => {
+    if (typeof title === 'string') host.onPhase?.(title)
+    if (typeof fn === 'function') return (fn as () => Promise<unknown>)()
+    return undefined
+  }
+
+  const sleep = (ms: unknown): Promise<void> =>
+    new Promise(resolve => {
+      const t = setTimeout(resolve, Math.max(0, Number(ms) || 0))
+      t.unref()
+    })
+
+  const sandbox: Record<string, unknown> = {
+    agent,
+    parallel,
+    pipeline,
+    phase,
+    sleep,
+    log,
+    console: { log, info: log, warn: log, error: log },
+    args: args === undefined ? undefined : JSON.parse(JSON.stringify(args)),
+    JSON,
+    Math,
+    Date,
+    Promise,
+    Array,
+    Object,
+    String,
+    Number,
+    Boolean,
+    RegExp,
+    Error,
+    Set,
+    Map,
+    setTimeout,
+    clearTimeout,
+    structuredClone,
+  }
+  const context = vm.createContext(sandbox, { name: 'workflow' })
+  const wrapped = `(async () => {\n${body}\n})()`
+  const script = new vm.Script(wrapped, { filename: 'workflow.js' })
+  const resultPromise = script.runInContext(context) as Promise<unknown>
+  return await Promise.race([
+    resultPromise,
+    new Promise<never>((_, reject) => {
+      if (host.signal.aborted) reject(new WorkflowScriptError('Workflow aborted'))
+      host.signal.addEventListener(
+        'abort',
+        () => reject(new WorkflowScriptError('Workflow aborted')),
+        { once: true },
+      )
+    }),
+  ])
+}
+
+export function errorText(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
+
+export function safeStringify(value: unknown): string {
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value)
+  } catch {
+    return String(value)
+  }
+}

package/src/tools.ts

@@ -23,9 +23,7 @@ const SuggestBackgroundPRTool =
         .SuggestBackgroundPRTool
     : null
 const SleepTool =
-  feature('PROACTIVE') || feature('KAIROS')
-    ? require('./tools/SleepTool/SleepTool.js').SleepTool
-    : null
+  feature('PROACTIVE') || feature('KAIROS') ? SleepToolImpl : null
 const cronTools = feature('AGENT_TRIGGERS')
   ? [
       require('./tools/ScheduleCronTool/CronCreateTool.js').CronCreateTool,
@@ -36,20 +34,15 @@ const cronTools = feature('AGENT_TRIGGERS')
 const RemoteTriggerTool = feature('AGENT_TRIGGERS_REMOTE')
   ? require('./tools/RemoteTriggerTool/RemoteTriggerTool.js').RemoteTriggerTool
   : null
-const MonitorTool = feature('MONITOR_TOOL')
-  ? require('./tools/MonitorTool/MonitorTool.js').MonitorTool
-  : null
-const SendUserFileTool = feature('KAIROS')
-  ? require('./tools/SendUserFileTool/SendUserFileTool.js').SendUserFileTool
-  : null
+// Static import (not require): the Monitor shares the notification queue and
+// task registry with the main loop, and the CJS require shim would hand it
+// private copies of those modules.
+const MonitorTool = feature('MONITOR_TOOL') ? MonitorToolImpl : null
+const SendUserFileTool =
+  feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION') ? SendUserFileToolImpl : null
 const PushNotificationTool =
-  feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION')
-    ? require('./tools/PushNotificationTool/PushNotificationTool.js')
-        .PushNotificationTool
-    : null
-const SubscribePRTool = feature('KAIROS_GITHUB_WEBHOOKS')
-  ? require('./tools/SubscribePRTool/SubscribePRTool.js').SubscribePRTool
-  : null
+  feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION') ? PushNotificationToolImpl : null
+const SubscribePRTool = feature('KAIROS_GITHUB_WEBHOOKS') ? SubscribePRToolImpl : null
 /* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
 import { TaskOutputTool } from './tools/TaskOutputTool/TaskOutputTool.js'
 import { WebSearchTool } from './tools/WebSearchTool/WebSearchTool.js'
@@ -90,8 +83,7 @@ import { isTodoV2Enabled } from './utils/tasks.js'
 /* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
 const VerifyPlanExecutionTool =
   process.env.CLAUDE_CODE_VERIFY_PLAN === 'true'
-    ? require('./tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.js')
-        .VerifyPlanExecutionTool
+    ? VerifyPlanExecutionToolImpl
     : null
 /* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
 import { SYNTHETIC_OUTPUT_TOOL_NAME } from './tools/SyntheticOutputTool/SyntheticOutputTool.js'
@@ -104,32 +96,29 @@ export {
 import { feature } from 'bun:bundle'
 // Dead code elimination: conditional import for OVERFLOW_TEST_TOOL
 /* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-const OverflowTestTool = feature('OVERFLOW_TEST_TOOL')
-  ? require('./tools/OverflowTestTool/OverflowTestTool.js').OverflowTestTool
-  : null
-const CtxInspectTool = feature('CONTEXT_COLLAPSE')
-  ? require('./tools/CtxInspectTool/CtxInspectTool.js').CtxInspectTool
-  : null
+const OverflowTestTool = feature('OVERFLOW_TEST_TOOL') ? OverflowTestToolImpl : null
+const CtxInspectTool = feature('CONTEXT_COLLAPSE') ? CtxInspectToolImpl : null
 const TerminalCaptureTool = feature('TERMINAL_PANEL')
-  ? require('./tools/TerminalCaptureTool/TerminalCaptureTool.js')
-      .TerminalCaptureTool
+  ? TerminalCaptureToolImpl
   : null
 const WebBrowserTool = feature('WEB_BROWSER_TOOL')
-  ? require('./tools/WebBrowserTool/WebBrowserTool.js').WebBrowserTool
+  ? WebBrowserToolImpl
   : null
 const coordinatorModeModule = feature('COORDINATOR_MODE')
   ? (require('./coordinator/coordinatorMode.js') as typeof import('./coordinator/coordinatorMode.js'))
   : null
 const SnipTool = feature('HISTORY_SNIP')
-  ? require('./tools/SnipTool/SnipTool.js').SnipTool
+  ? SnipToolImpl
   : null
 const ListPeersTool = feature('UDS_INBOX')
-  ? require('./tools/ListPeersTool/ListPeersTool.js').ListPeersTool
+  ? ListPeersToolImpl
   : null
+// Static import (see MonitorTool): the workflow shares the task registry and
+// notification queue with the app
 const WorkflowTool = feature('WORKFLOW_SCRIPTS')
   ? (() => {
-      require('./tools/WorkflowTool/bundled/index.js').initBundledWorkflows()
-      return require('./tools/WorkflowTool/WorkflowTool.js').WorkflowTool
+      initBundledWorkflows()
+      return WorkflowToolImpl
     })()
   : null
 /* eslint-enable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
@@ -140,6 +129,21 @@ import { isEnvTruthy } from './utils/envUtils.js'
 import { isPowerShellToolEnabled } from './utils/shell/shellToolUtils.js'
 import { isAgentSwarmsEnabled } from './utils/agentSwarmsEnabled.js'
 import { isWorktreeModeEnabled } from './utils/worktreeModeEnabled.js'
+import { MonitorTool as MonitorToolImpl } from './tools/MonitorTool/MonitorTool.js'
+import { SendUserFileTool as SendUserFileToolImpl } from './tools/SendUserFileTool/SendUserFileTool.js'
+import { PushNotificationTool as PushNotificationToolImpl } from './tools/PushNotificationTool/PushNotificationTool.js'
+import { SubscribePRTool as SubscribePRToolImpl } from './tools/SubscribePRTool/SubscribePRTool.js'
+import { OverflowTestTool as OverflowTestToolImpl } from './tools/OverflowTestTool/OverflowTestTool.js'
+import { SleepTool as SleepToolImpl } from './tools/SleepTool/SleepTool.js'
+import { TerminalCaptureTool as TerminalCaptureToolImpl } from './tools/TerminalCaptureTool/TerminalCaptureTool.js'
+import { WebBrowserTool as WebBrowserToolImpl } from './tools/WebBrowserTool/WebBrowserTool.js'
+import { SnipTool as SnipToolImpl } from './tools/SnipTool/SnipTool.js'
+import { ListPeersTool as ListPeersToolImpl } from './tools/ListPeersTool/ListPeersTool.js'
+import { VerifyPlanExecutionTool as VerifyPlanExecutionToolImpl } from './tools/VerifyPlanExecutionTool/VerifyPlanExecutionTool.js'
+import { CtxInspectTool as CtxInspectToolImpl } from './tools/CtxInspectTool/CtxInspectTool.js'
+import { WorkflowTool as WorkflowToolImpl } from './tools/WorkflowTool/WorkflowTool.js'
+import { initBundledWorkflows } from './tools/WorkflowTool/bundled/index.js'
+import { DiscoverSkillsTool as DiscoverSkillsToolImpl } from './tools/DiscoverSkillsTool/DiscoverSkillsTool.js'
 import {
   REPL_TOOL_NAME,
   REPL_ONLY_TOOLS,
@@ -231,6 +235,7 @@ export function getAllBaseTools(): Tools {
     ...(VerifyPlanExecutionTool ? [VerifyPlanExecutionTool] : []),
     ...(process.env.USER_TYPE === 'ant' && REPLTool ? [REPLTool] : []),
     ...(WorkflowTool ? [WorkflowTool] : []),
+    ...(feature('EXPERIMENTAL_SKILL_SEARCH') ? [DiscoverSkillsToolImpl] : []),
     ...(SleepTool ? [SleepTool] : []),
     ...cronTools,
     ...(RemoteTriggerTool ? [RemoteTriggerTool] : []),

package/src/utils/betas.ts

@@ -163,6 +163,11 @@ export function modelSupportsAutoMode(model: string): boolean {
     // External: firstParty-only at launch (PI probes not wired for
     // Bedrock/Vertex/Foundry yet). Checked before allowModels so the GB
     // override can't enable auto mode on unsupported providers.
+    // OpenAI-compatible backend: the classifier runs on the local model itself
+    // (getClassifierModel falls back to the main loop model), so no provider gate
+    if (process.env.OPENAI_API_KEY) {
+      return true
+    }
     if (process.env.USER_TYPE !== 'ant' && getAPIProvider() !== 'firstParty') {
       return false
     }

package/src/utils/context.ts

@@ -52,6 +52,15 @@ export function getContextWindowForModel(
   model: string,
   betas?: string[],
 ): number {
+  // OpenAI-compatible backends: the real window comes from the server (a local
+  // llama.cpp may run 32k-128k), so auto-compact and the context meter follow it
+  // instead of the Claude default
+  if (process.env.OPENAI_API_KEY && process.env.OPENAI_CONTEXT_WINDOW) {
+    const override = parseInt(process.env.OPENAI_CONTEXT_WINDOW, 10)
+    if (!isNaN(override) && override > 0) {
+      return override
+    }
+  }
   // Allow override via environment variable (ant-only)
   // This takes precedence over all other context window resolution, including 1M detection,
   // so users can cap the effective context window for local decisions (auto-compact, etc.)

package/src/utils/conversationRecovery.ts

@@ -64,7 +64,7 @@ const LEGACY_BRIEF_TOOL_NAME: string | null =
         require('../tools/BriefTool/prompt.js') as typeof import('../tools/BriefTool/prompt.js')
       ).LEGACY_BRIEF_TOOL_NAME
     : null
-const SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS')
+const SEND_USER_FILE_TOOL_NAME: string | null = feature('KAIROS') || feature('KAIROS_PUSH_NOTIFICATION')
   ? (
       require('../tools/SendUserFileTool/prompt.js') as typeof import('../tools/SendUserFileTool/prompt.js')
     ).SEND_USER_FILE_TOOL_NAME

package/src/utils/forkedAgent.ts

@@ -105,6 +105,8 @@ export type ForkedAgentParams = {
   maxTurns?: number
   /** Optional callback invoked for each message as it arrives (for streaming UI) */
   onMessage?: (message: Message) => void
+  /** Called for every raw stream event (text deltas etc.) before they are dropped. */
+  onStreamEvent?: (event: unknown) => void
   /** Skip sidechain transcript recording (e.g., for ephemeral work like speculation) */
   skipTranscript?: boolean
   /** Skip writing new prompt cache entries on the last message. For
@@ -496,6 +498,7 @@ export async function runForkedAgent({
   maxOutputTokens,
   maxTurns,
   onMessage,
+  onStreamEvent,
   skipTranscript,
   skipCacheWrite,
 }: ForkedAgentParams): Promise<ForkedAgentResult> {
@@ -556,6 +559,7 @@ export async function runForkedAgent({
     })) {
       // Extract real usage from message_delta stream events (final usage per API call)
       if (message.type === 'stream_event') {
+        onStreamEvent?.(message)
         if (
           'event' in message &&
           message.event?.type === 'message_delta' &&

package/src/utils/logoV2Utils.ts

@@ -253,9 +253,13 @@ export function getLogoDisplayData(): {
   const cwd = serverUrl
     ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, '')}`
     : displayPath
-  const billingType = isClaudeAISubscriber()
-    ? getSubscriptionName()
-    : 'API Usage Billing'
+  const billingType = process.env.OPENAI_API_KEY
+    ? process.env.OPENAI_BASE_URL && /localhost|127\.0\.0\.1/.test(process.env.OPENAI_BASE_URL)
+      ? 'Local model'
+      : 'OpenAI-compatible API'
+    : isClaudeAISubscriber()
+      ? getSubscriptionName()
+      : 'API Usage Billing'
   const agentName = getInitialSettings().agent
 
   return {

package/src/utils/messageQueueManager.ts

@@ -50,13 +50,27 @@ function logOperation(operation: QueueOperation, content?: string): void {
 // Within the same priority, commands are processed FIFO.
 // ============================================================================
 
-const commandQueue: QueuedCommand[] = []
-/** Frozen snapshot — recreated on every mutation for useSyncExternalStore. */
-let snapshot: readonly QueuedCommand[] = Object.freeze([])
-const queueChanged = createSignal()
+// Process-wide state. Feature-gated modules are loaded through the CJS
+// `require` shim and get their own copy of this module; without a shared
+// store they would enqueue into a queue nobody drains.
+type QueueGlobals = {
+  commandQueue: QueuedCommand[]
+  /** Frozen snapshot — recreated on every mutation for useSyncExternalStore. */
+  snapshot: readonly QueuedCommand[]
+  queueChanged: ReturnType<typeof createSignal>
+}
+const queueGlobals: QueueGlobals = ((
+  globalThis as unknown as { __xelaMessageQueue?: QueueGlobals }
+).__xelaMessageQueue ??= {
+  commandQueue: [],
+  snapshot: Object.freeze([]),
+  queueChanged: createSignal(),
+})
+const commandQueue: QueuedCommand[] = queueGlobals.commandQueue
+const queueChanged = queueGlobals.queueChanged
 
 function notifySubscribers(): void {
-  snapshot = Object.freeze([...commandQueue])
+  queueGlobals.snapshot = Object.freeze([...commandQueue])
   queueChanged.emit()
 }
 
@@ -76,7 +90,7 @@ export const subscribeToCommandQueue = queueChanged.subscribe
  * Returns a frozen array that only changes reference on mutation.
  */
 export function getCommandQueueSnapshot(): readonly QueuedCommand[] {
-  return snapshot
+  return queueGlobals.snapshot
 }
 
 // ============================================================================
@@ -328,12 +342,12 @@ export function clearCommandQueue(): void {
 }
 
 /**
- * Clear all commands and reset snapshot.
+ * Clear all commands and reset queueGlobals.snapshot.
  * Used for test cleanup.
  */
 export function resetCommandQueue(): void {
   commandQueue.length = 0
-  snapshot = Object.freeze([])
+  queueGlobals.snapshot = Object.freeze([])
 }
 
 // ============================================================================
@@ -492,7 +506,7 @@ export const subscribeToPendingNotifications = subscribeToCommandQueue
 
 /** @deprecated Use getCommandQueueSnapshot */
 export function getPendingNotificationsSnapshot(): readonly QueuedCommand[] {
-  return snapshot
+  return queueGlobals.snapshot
 }
 
 /** @deprecated Use hasCommandsInQueue */

package/src/utils/model/model.ts

@@ -63,6 +63,12 @@ export function isNonCustomOpusModel(model: ModelName): boolean {
  * 4. Settings (from user's saved settings)
  */
 export function getUserSpecifiedModelSetting(): ModelSetting | undefined {
+  // OpenAI-compatible backend: the configured model wins over any Claude model
+  // left in settings, so the UI shows what actually answers
+  if (process.env.OPENAI_API_KEY) {
+    return process.env.OPENAI_MODEL || 'gpt-4o'
+  }
+
   let specifiedModel: ModelSetting | undefined
 
   const modelOverride = getMainLoopModelOverride()
@@ -74,8 +80,7 @@ export function getUserSpecifiedModelSetting(): ModelSetting | undefined {
   }
 
   // Ignore the user-specified model if it's not in the availableModels allowlist.
-  // Skip this check on OpenAI backend — the allowlist is for Claude models only.
-  if (specifiedModel && !process.env.OPENAI_API_KEY && !isModelAllowed(specifiedModel)) {
+  if (specifiedModel && !isModelAllowed(specifiedModel)) {
     return undefined
   }
 
@@ -95,12 +100,8 @@ export function getUserSpecifiedModelSetting(): ModelSetting | undefined {
  * @returns The resolved model name to use
  */
 export function getMainLoopModel(): ModelName {
-  // When using OpenAI backend, respect user-selected model, fall back to OPENAI_MODEL
+  // When using OpenAI backend, return the OpenAI model name directly
   if (process.env.OPENAI_API_KEY) {
-    const model = getUserSpecifiedModelSetting()
-    if (model !== undefined && model !== null) {
-      return model
-    }
     return process.env.OPENAI_MODEL || 'gpt-4o'
   }
   const model = getUserSpecifiedModelSetting()
@@ -165,9 +166,9 @@ export function getRuntimeMainLoopModel(params: {
 }): ModelName {
   const { permissionMode, mainLoopModel, exceeds200kTokens = false } = params
 
-  // When using OpenAI backend, use the passed-in model (already resolved by caller)
+  // When using OpenAI backend, always use the configured model
   if (process.env.OPENAI_API_KEY) {
-    return mainLoopModel || process.env.OPENAI_MODEL || 'gpt-4o'
+    return process.env.OPENAI_MODEL || 'gpt-4o'
   }
 
   // opusplan uses Opus in plan mode without [1m] suffix.