@the-open-engine/zeroshot 6.18.0 → 6.20.0

package/src/agent-cli-provider/omp-rpc-protocol.ts

@@ -0,0 +1,396 @@
+import { getNumber, getString, isRecord } from './json';
+import { OMP_SUPPORTED_VERSION } from './omp-release';
+
+// Purely for traceability/doc; no runtime coupling to omp-release's spawn/install concerns.
+export const OMP_RPC_CONTRACT_RELEASE = OMP_SUPPORTED_VERSION;
+
+export interface OmpRpcDecoderLimits {
+  readonly maxPhysicalFrameBytes: number;
+  readonly maxReassembledFrameBytes: number;
+  readonly maxConcurrentReassemblies: number;
+  readonly maxChunksPerFrame: number;
+  readonly maxInflightReassemblyBytes: number;
+}
+
+// Verified against the pinned OMP release's rpc-frame.ts: MAX_RPC_FRAME_BYTES=1MiB, MAX_RPC_REASSEMBLED_BYTES=64MiB,
+// RPC_CHUNK_PAYLOAD_BYTES=256KiB -> ceil(64MiB/256KiB)=256 chunks max. The real decoder tracks exactly one
+// pending sequence at a time, so maxConcurrentReassemblies/maxInflightReassemblyBytes mirror that ceiling.
+export const DEFAULT_OMP_RPC_DECODER_LIMITS: OmpRpcDecoderLimits = {
+  maxPhysicalFrameBytes: 1024 * 1024,
+  maxReassembledFrameBytes: 64 * 1024 * 1024,
+  maxConcurrentReassemblies: 1,
+  maxChunksPerFrame: 256,
+  maxInflightReassemblyBytes: 64 * 1024 * 1024,
+};
+
+export interface OmpRpcInboundFrame {
+  readonly type: string;
+  readonly [key: string]: unknown;
+}
+
+export interface OmpRpcCommand {
+  readonly id?: string;
+  readonly type: string;
+  readonly [key: string]: unknown;
+}
+
+export class OmpRpcProtocolError extends Error {
+  readonly code: string;
+
+  constructor(code: string, message: string) {
+    super(message);
+    this.name = 'OmpRpcProtocolError';
+    this.code = code;
+  }
+}
+
+const KNOWN_PRE_NEGOTIATION_FRAME_TYPES: ReadonlySet<string> = new Set([
+  'ready',
+  'available_commands_update',
+  'response',
+  'extension_error',
+  'agent_start',
+  'agent_end',
+  'turn_start',
+  'turn_end',
+  'message_start',
+  'message_update',
+  'message_end',
+  'tool_execution_start',
+  'tool_execution_update',
+  'tool_execution_end',
+  'auto_compaction_start',
+  'auto_compaction_end',
+  'auto_retry_start',
+  'auto_retry_end',
+  'ttsr_triggered',
+  'todo_reminder',
+  'todo_auto_clear',
+  'extension_ui_request',
+  'host_tool_call',
+  'host_tool_cancel',
+  'host_uri_request',
+  'host_uri_cancel',
+  'prompt_result',
+  'command_output',
+  'session_info_update',
+  'config_update',
+  'subagent_lifecycle',
+  'subagent_progress',
+  'subagent_event',
+]);
+
+export function classifyOmpRpcFrameType(
+  type: string
+): 'known-pre-negotiation' | 'v2-only' | 'unknown' {
+  if (type === 'rpc_chunk') return 'v2-only';
+  if (KNOWN_PRE_NEGOTIATION_FRAME_TYPES.has(type)) return 'known-pre-negotiation';
+  return 'unknown';
+}
+
+export function assertNoPreNegotiationRpcChunk(frameType: string, negotiatedV2: boolean): void {
+  if (frameType === 'rpc_chunk' && !negotiatedV2) {
+    throw new OmpRpcProtocolError(
+      'pre-negotiation-rpc-chunk',
+      'rpc_chunk frame received before protocol v2 negotiation succeeded.'
+    );
+  }
+}
+
+const STRICT_BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+
+function decodeStrictBase64(data: unknown): Buffer {
+  if (typeof data !== 'string' || data.length === 0 || !STRICT_BASE64_PATTERN.test(data)) {
+    throw new OmpRpcProtocolError(
+      'invalid-chunk-data',
+      "rpc_chunk 'data' must be a non-empty, canonically-padded base64 string."
+    );
+  }
+  const bytes = Buffer.from(data, 'base64');
+  if (bytes.toString('base64') !== data) {
+    throw new OmpRpcProtocolError(
+      'invalid-chunk-data',
+      "rpc_chunk 'data' failed a base64 round-trip check (non-canonical encoding)."
+    );
+  }
+  return bytes;
+}
+
+function decodeStrictUtf8(bytes: Buffer): string {
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+  } catch {
+    throw new OmpRpcProtocolError(
+      'invalid-utf8-in-reassembled-frame',
+      'Reassembled rpc_chunk sequence is not valid UTF-8.'
+    );
+  }
+}
+
+function toPhysicalFrame(record: Record<string, unknown>): OmpRpcInboundFrame {
+  const type = getString(record, 'type');
+  if (type === null) {
+    throw new OmpRpcProtocolError(
+      'malformed-physical-frame',
+      "Physical frame is missing a string 'type' field."
+    );
+  }
+  return { ...record, type };
+}
+
+function toReassembledFrame(record: Record<string, unknown>, chunkId: string): OmpRpcInboundFrame {
+  const type = getString(record, 'type');
+  if (type === null) {
+    throw new OmpRpcProtocolError(
+      'malformed-json-in-reassembled-frame',
+      `rpc_chunk sequence "${chunkId}" reassembled into an object missing a string 'type' field.`
+    );
+  }
+  return { ...record, type };
+}
+
+interface ChunkMetadata {
+  readonly chunkId: string;
+  readonly index: number;
+  readonly count: number;
+  readonly byteLength: number;
+}
+
+function readChunkMetadata(
+  parsed: Record<string, unknown>,
+  limits: OmpRpcDecoderLimits
+): ChunkMetadata {
+  const chunkId = getString(parsed, 'chunkId');
+  if (chunkId === null || chunkId.length === 0 || chunkId.length > 128) {
+    throw new OmpRpcProtocolError(
+      'invalid-chunk-metadata',
+      "rpc_chunk 'chunkId' must be a non-empty string of at most 128 characters."
+    );
+  }
+
+  const index = getNumber(parsed, 'index');
+  const count = getNumber(parsed, 'count');
+  const byteLength = getNumber(parsed, 'byteLength');
+  if (
+    index === null ||
+    !Number.isSafeInteger(index) ||
+    index < 0 ||
+    count === null ||
+    !Number.isSafeInteger(count) ||
+    count < 2 ||
+    count > limits.maxChunksPerFrame ||
+    index >= count ||
+    byteLength === null ||
+    !Number.isSafeInteger(byteLength) ||
+    byteLength <= 0 ||
+    byteLength > limits.maxReassembledFrameBytes
+  ) {
+    throw new OmpRpcProtocolError(
+      'invalid-chunk-metadata',
+      "rpc_chunk has invalid 'index'/'count'/'byteLength' metadata."
+    );
+  }
+
+  return { chunkId, index, count, byteLength };
+}
+
+interface PendingReassembly {
+  readonly chunkId: string;
+  readonly count: number;
+  readonly byteLength: number;
+  nextIndex: number;
+  readonly chunks: Buffer[];
+  receivedBytes: number;
+}
+
+export class OmpRpcFrameDecoder {
+  private readonly limits: OmpRpcDecoderLimits;
+  private buffer: Buffer;
+  private finished: boolean;
+  private readonly pendingReassemblies: Map<string, PendingReassembly>;
+  private inflightReassemblyBytes: number;
+
+  constructor(limits: OmpRpcDecoderLimits) {
+    this.limits = limits;
+    this.buffer = Buffer.alloc(0);
+    this.finished = false;
+    this.pendingReassemblies = new Map();
+    this.inflightReassemblyBytes = 0;
+  }
+
+  push(chunk: Uint8Array): readonly OmpRpcInboundFrame[] {
+    if (this.finished) {
+      throw new OmpRpcProtocolError('decoder-finished', 'push() called after finish().');
+    }
+
+    this.buffer = Buffer.concat([this.buffer, Buffer.from(chunk)]);
+    const frames: OmpRpcInboundFrame[] = [];
+
+    for (;;) {
+      const newlineIndex = this.buffer.indexOf(0x0a);
+      if (newlineIndex === -1) {
+        if (this.buffer.byteLength > this.limits.maxPhysicalFrameBytes) {
+          throw new OmpRpcProtocolError(
+            'physical-frame-too-large',
+            `Buffered physical frame exceeds the ${this.limits.maxPhysicalFrameBytes}-byte limit without a terminating newline.`
+          );
+        }
+        break;
+      }
+
+      const lineBytes = this.buffer.subarray(0, newlineIndex);
+      this.buffer = this.buffer.subarray(newlineIndex + 1);
+      if (lineBytes.byteLength + 1 > this.limits.maxPhysicalFrameBytes) {
+        throw new OmpRpcProtocolError(
+          'physical-frame-too-large',
+          `Physical frame of ${lineBytes.byteLength + 1} bytes exceeds the ${this.limits.maxPhysicalFrameBytes}-byte limit.`
+        );
+      }
+
+      const frame = this.consumeLine(lineBytes);
+      if (frame !== null) frames.push(frame);
+    }
+
+    return frames;
+  }
+
+  finish(): void {
+    this.finished = true;
+    if (this.buffer.byteLength > 0) {
+      throw new OmpRpcProtocolError(
+        'incomplete-physical-frame',
+        'Stream ended with an unterminated physical frame (no trailing newline).'
+      );
+    }
+    if (this.pendingReassemblies.size > 0) {
+      throw new OmpRpcProtocolError(
+        'incomplete-chunk-sequence',
+        'Stream ended with an incomplete rpc_chunk sequence still pending.'
+      );
+    }
+  }
+
+  private consumeLine(lineBytes: Buffer): OmpRpcInboundFrame | null {
+    let value: unknown;
+    try {
+      value = JSON.parse(lineBytes.toString('utf8'));
+    } catch {
+      throw new OmpRpcProtocolError('malformed-physical-frame', 'Physical frame is not valid JSON.');
+    }
+    if (!isRecord(value)) {
+      throw new OmpRpcProtocolError(
+        'malformed-physical-frame',
+        'Physical frame must be a JSON object.'
+      );
+    }
+
+    const type = getString(value, 'type');
+    if (type !== 'rpc_chunk') {
+      if (this.pendingReassemblies.size > 0) {
+        throw new OmpRpcProtocolError(
+          'interrupted-chunk-sequence',
+          'A non-chunk frame arrived while an rpc_chunk sequence was pending.'
+        );
+      }
+      return toPhysicalFrame(value);
+    }
+
+    return this.consumeChunk(value);
+  }
+
+  private consumeChunk(parsed: Record<string, unknown>): OmpRpcInboundFrame | null {
+    const metadata = readChunkMetadata(parsed, this.limits);
+    const bytes = decodeStrictBase64(parsed.data);
+
+    let pending = this.pendingReassemblies.get(metadata.chunkId);
+    if (pending === undefined) {
+      if (metadata.index !== 0) {
+        throw new OmpRpcProtocolError(
+          'chunk-sequence-must-start-at-zero',
+          `rpc_chunk sequence "${metadata.chunkId}" must begin at index 0.`
+        );
+      }
+      if (this.pendingReassemblies.size >= this.limits.maxConcurrentReassemblies) {
+        throw new OmpRpcProtocolError(
+          'interleaved-chunk-sequence',
+          `Starting rpc_chunk sequence "${metadata.chunkId}" would exceed the concurrent-reassembly limit of ${this.limits.maxConcurrentReassemblies}.`
+        );
+      }
+      pending = {
+        chunkId: metadata.chunkId,
+        count: metadata.count,
+        byteLength: metadata.byteLength,
+        nextIndex: 0,
+        chunks: [],
+        receivedBytes: 0,
+      };
+      this.pendingReassemblies.set(metadata.chunkId, pending);
+    } else if (
+      pending.count !== metadata.count ||
+      pending.byteLength !== metadata.byteLength ||
+      pending.nextIndex !== metadata.index
+    ) {
+      throw new OmpRpcProtocolError(
+        'chunk-sequence-mismatch',
+        `rpc_chunk sequence "${metadata.chunkId}" metadata or ordering does not match the tracked sequence.`
+      );
+    }
+
+    pending.chunks.push(bytes);
+    pending.receivedBytes += bytes.byteLength;
+    this.inflightReassemblyBytes += bytes.byteLength;
+    if (this.inflightReassemblyBytes > this.limits.maxInflightReassemblyBytes) {
+      throw new OmpRpcProtocolError(
+        'inflight-reassembly-bytes-exceeded',
+        `Total in-flight rpc_chunk reassembly bytes exceed the ${this.limits.maxInflightReassemblyBytes}-byte limit.`
+      );
+    }
+    if (pending.receivedBytes > pending.byteLength) {
+      throw new OmpRpcProtocolError(
+        'chunk-sequence-exceeds-declared-length',
+        `rpc_chunk sequence "${metadata.chunkId}" received more bytes than its declared byteLength.`
+      );
+    }
+    pending.nextIndex += 1;
+    if (pending.nextIndex < pending.count) return null;
+
+    this.pendingReassemblies.delete(metadata.chunkId);
+    this.inflightReassemblyBytes -= pending.receivedBytes;
+    if (pending.receivedBytes !== pending.byteLength) {
+      throw new OmpRpcProtocolError(
+        'chunk-sequence-length-mismatch',
+        `rpc_chunk sequence "${metadata.chunkId}" completed with ${pending.receivedBytes} bytes but declared ${pending.byteLength}.`
+      );
+    }
+
+    const decodedText = decodeStrictUtf8(Buffer.concat(pending.chunks));
+    let reassembled: unknown;
+    try {
+      reassembled = JSON.parse(decodedText);
+    } catch {
+      throw new OmpRpcProtocolError(
+        'malformed-json-in-reassembled-frame',
+        `rpc_chunk sequence "${metadata.chunkId}" reassembled into invalid JSON.`
+      );
+    }
+    if (!isRecord(reassembled)) {
+      throw new OmpRpcProtocolError(
+        'non-object-reassembled-frame',
+        `rpc_chunk sequence "${metadata.chunkId}" reassembled into a non-object JSON value.`
+      );
+    }
+    return toReassembledFrame(reassembled, metadata.chunkId);
+  }
+}
+
+export function encodeOmpRpcCommand(command: OmpRpcCommand, maxFrameBytes: number): Buffer {
+  const line = `${JSON.stringify(command)}\n`;
+  const byteLength = Buffer.byteLength(line, 'utf8');
+  if (byteLength > maxFrameBytes) {
+    throw new OmpRpcProtocolError(
+      'outbound-frame-too-large',
+      `Outbound command of ${byteLength} bytes exceeds the ${maxFrameBytes}-byte limit.`
+    );
+  }
+  return Buffer.from(line, 'utf8');
+}

package/src/agent-cli-provider/provider-registry.ts

@@ -8,6 +8,7 @@ import { opencodeAdapter } from './adapters/opencode';
 import { ompAdapter } from './adapters/omp';
 import { piAdapter } from './adapters/pi';
 import { resolveClaudeCommand } from './claude-command';
+import { OMP_INSTALL_COMMAND } from './omp-release';
 import type { ModelLevel, ProviderAdapter, StructuredOutputRecoveryAdapter } from './types';
 
 export type ProviderCapabilityState = boolean | 'experimental';
@@ -71,6 +72,7 @@ export interface ProviderDockerMetadata {
 
 interface ProviderRegistryEntryBase {
   readonly id: string;
+  readonly default: boolean;
   readonly aliases: readonly string[];
   readonly displayName: string;
   readonly binary: string;
@@ -176,6 +178,7 @@ const kiroAdapter = createAcpAdapter({
 export const providerRegistry = [
   {
     id: 'claude',
+    default: true,
     aliases: ['anthropic'],
     displayName: 'Claude',
     binary: 'claude',
@@ -214,6 +217,7 @@ export const providerRegistry = [
   },
   {
     id: 'codex',
+    default: false,
     aliases: ['openai'],
     displayName: 'Codex',
     binary: 'codex',
@@ -255,6 +259,7 @@ export const providerRegistry = [
   },
   {
     id: 'gateway',
+    default: false,
     aliases: [],
     displayName: 'Gateway',
     binary: 'node',
@@ -303,6 +308,7 @@ export const providerRegistry = [
   },
   {
     id: 'gemini',
+    default: false,
     aliases: ['google'],
     displayName: 'Gemini',
     binary: 'gemini',
@@ -340,6 +346,7 @@ export const providerRegistry = [
   },
   {
     id: 'opencode',
+    default: false,
     aliases: [],
     displayName: 'Opencode',
     binary: 'opencode',
@@ -380,6 +387,7 @@ export const providerRegistry = [
   },
   {
     id: 'pi',
+    default: false,
     aliases: [],
     displayName: 'Pi',
     binary: 'pi',
@@ -419,12 +427,13 @@ export const providerRegistry = [
   },
   {
     id: 'omp',
+    default: false,
     aliases: [],
     displayName: 'OMP',
     binary: 'omp',
     command: { kind: 'fixed', command: 'omp', args: [] },
     invoke: SPAWN_INVOKE,
-    installInstructions: 'npm install -g --ignore-scripts @oh-my-pi/pi-coding-agent',
+    installInstructions: OMP_INSTALL_COMMAND,
     authInstructions: 'omp\n/login',
     credentialPaths: ['~/.omp'],
     credentialEnvKeys: ompAdapter.credentialEnvKeys,
@@ -457,6 +466,7 @@ export const providerRegistry = [
   },
   {
     id: 'kiro',
+    default: false,
     aliases: [],
     displayName: 'Kiro',
     binary: 'kiro-cli',
@@ -494,6 +504,7 @@ export const providerRegistry = [
   },
   {
     id: 'copilot',
+    default: false,
     aliases: [],
     displayName: 'Copilot',
     binary: 'copilot',
@@ -565,6 +576,23 @@ export const providerAliasMap: Readonly<Record<string, RegistryProviderId>> = Ob
   }, {})
 );
 
+export function assertExactlyOneDefaultProvider<T extends { id: string; default: boolean }>(
+  entries: readonly T[]
+): T['id'] {
+  const defaults = entries.filter((e) => e.default);
+  const [onlyDefault, ...rest] = defaults;
+  if (!onlyDefault || rest.length > 0) {
+    throw new Error(
+      `Provider registry must declare exactly one default provider; found ${defaults.length}${defaults.length ? ' (' + defaults.map((e) => e.id).join(', ') + ')' : ''}`
+    );
+  }
+  return onlyDefault.id;
+}
+const DEFAULT_PROVIDER_ID = assertExactlyOneDefaultProvider(providerRegistry);
+export function getDefaultProviderId(): RegistryProviderId {
+  return DEFAULT_PROVIDER_ID;
+}
+
 export function normalizeProviderName(name: string): RegistryProviderId | string {
   const normalized = name.toLowerCase();
   return providerAliasMap[normalized] ?? name;

package/src/agent-cli-provider/single-agent-runtime.ts

@@ -3,6 +3,7 @@ import { UnsupportedProviderCapabilityError } from './errors';
 import { normalizeGatewayBuildOptions, resolveGatewayConfiguration } from './gateway-tools';
 import { isRecord } from './json';
 import {
+  getDefaultProviderId,
   getProviderRegistryEntry,
   resolveProviderCommand,
   supportsProviderCapability,
@@ -414,7 +415,7 @@ function adapterForRuntimeInput(
 ): ProviderAdapter {
   const configured =
     provider ?? optionalString(settings.defaultProvider, 'settings.defaultProvider');
-  return getProviderAdapter(configured ?? 'claude');
+  return getProviderAdapter(configured ?? getDefaultProviderId());
 }
 
 function runtimeProviderSettings(

package/src/agent-wrapper.js

@@ -13,7 +13,7 @@
 const LogicEngine = require('./logic-engine');
 const { validateAgentConfig } = require('./agent/agent-config');
 const { loadSettings, validateModelAgainstMax, VALID_MODELS } = require('../lib/settings');
-const { normalizeProviderName } = require('../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { buildContext } = require('./agent/agent-context-builder');
 const { collectQueuedGuidance } = require('./agent/guidance-queue');
@@ -160,9 +160,9 @@ class AgentWrapper {
       this.config.provider ||
       clusterConfig.defaultProvider ||
       settings.defaultProvider ||
-      'claude';
+      getDefaultProviderId();
 
-    return normalizeProviderName(resolved) || 'claude';
+    return normalizeProviderName(resolved) || getDefaultProviderId();
   }
 
   _resolveModelSpec() {

package/src/claude-task-runner.js

@@ -9,7 +9,7 @@ const { spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const TaskRunner = require('./task-runner');
 const { loadSettings } = require('../lib/settings');
-const { normalizeProviderName } = require('../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
 const { prependWorktreeToolBinToEnv } = require('./worktree-tooling-env');
 const { applyDarwinKeychainBoundaryToEnv } = require('./darwin-keychain-boundary');
@@ -200,7 +200,9 @@ class ClaudeTaskRunner extends TaskRunner {
     } = options;
 
     const settings = loadSettings();
-    const providerName = normalizeProviderName(provider || settings.defaultProvider || 'claude');
+    const providerName = normalizeProviderName(
+      provider || settings.defaultProvider || getDefaultProviderId()
+    );
     const { providerModule, providerSettings, levelOverrides } = this._getProviderContext(
       providerName,
       settings
@@ -736,7 +738,7 @@ class ClaudeTaskRunner extends TaskRunner {
     rejectCallerSuppliedModelProvenance(options);
     const {
       agentId = 'unknown',
-      provider = 'claude',
+      provider = getDefaultProviderId(),
       model = null,
       modelLevel = null,
       modelSpec: explicitModelSpec = null,

package/src/config-validator.js

@@ -14,6 +14,7 @@
 const { loadSettings } = require('../lib/settings');
 const {
   VALID_PROVIDERS,
+  getDefaultProviderId,
   normalizeProviderName,
   providerSupportsCapability,
 } = require('../lib/provider-names');
@@ -1987,8 +1988,8 @@ function resolveProviderName(agent, config, settings) {
     agent.provider ||
     config.defaultProvider ||
     settings.defaultProvider ||
-    'claude';
-  return normalizeProviderName(resolved) || 'claude';
+    getDefaultProviderId();
+  return normalizeProviderName(resolved) || getDefaultProviderId();
 }
 
 function validateProviderLevel(provider, requestedLevel, minLevel, maxLevel) {

package/src/isolation-manager.js

@@ -16,7 +16,11 @@ const os = require('os');
 const fs = require('fs');
 const { loadSettings } = require('../lib/settings');
 const { CLAUDE_AUTH_ENV_VARS, resolveClaudeAuth } = require('../lib/settings/claude-auth');
-const { normalizeProviderName, getProviderMetadata } = require('../lib/provider-names');
+const {
+  normalizeProviderName,
+  getProviderMetadata,
+  getDefaultProviderId,
+} = require('../lib/provider-names');
 const {
   MOUNT_PRESETS,
   resolveMounts,
@@ -236,7 +240,7 @@ class IsolationManager {
 
     const settings = loadSettings();
     const providerName = normalizeProviderName(
-      config.provider || settings.defaultProvider || 'claude'
+      config.provider || settings.defaultProvider || getDefaultProviderId()
     );
     const containerHome = config.containerHome || settings.dockerContainerHome || '/root';
 

package/src/orchestrator.js

@@ -46,7 +46,7 @@ const { generateName } = require('./name-generator');
 const configValidator = require('./config-validator');
 const TemplateResolver = require('./template-resolver');
 const { loadSettings } = require('../lib/settings');
-const { normalizeProviderName } = require('../lib/provider-names');
+const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { resolveRunPlan } = require('../lib/run-plan');
 const { isProcessRunning } = require('../lib/process-liveness');
 const { getProvider } = require('./providers');
@@ -313,8 +313,8 @@ class Orchestrator {
       clusterConfig.forceProvider ||
       clusterConfig.defaultProvider ||
       settings.defaultProvider ||
-      'claude';
-    return normalizeProviderName(resolved) || 'claude';
+      getDefaultProviderId();
+    return normalizeProviderName(resolved) || getDefaultProviderId();
   }
 
   /**

package/src/preflight.js

@@ -21,6 +21,7 @@ const {
 const { loadSettings, getClaudeCommand } = require('../lib/settings.js');
 const {
   VALID_PROVIDERS,
+  getDefaultProviderId,
   getProviderMetadata,
   normalizeProviderName,
   resolveProviderCommand,
@@ -597,7 +598,7 @@ async function runPreflight(options = {}) {
     };
   }
   const providerName = normalizeProviderName(
-    options.provider || settings.defaultProvider || 'claude'
+    options.provider || settings.defaultProvider || getDefaultProviderId()
   );
 
   const providerResult = validateProvider(providerName, options);