@yancyyu/openhermit 1.5.8

package/src/shared/types/terminal.ts

@@ -0,0 +1,49 @@
+/**
+ * Terminal types — shared between main, preload, and renderer processes.
+ *
+ * Used for embedded PTY terminal (xterm.js + node-pty).
+ */
+
+// =============================================================================
+// PTY Spawn Options
+// =============================================================================
+
+/**
+ * Options for spawning a new PTY process.
+ */
+export interface PtySpawnOptions {
+  /** Command to run (default: user's shell) */
+  command?: string;
+  /** Arguments for the command */
+  args?: string[];
+  /** Working directory */
+  cwd?: string;
+  /** Environment variables (merged with process.env) */
+  env?: Record<string, string>;
+  /** Initial terminal columns */
+  cols?: number;
+  /** Initial terminal rows */
+  rows?: number;
+}
+
+// =============================================================================
+// Preload API
+// =============================================================================
+
+/**
+ * Terminal API exposed via preload bridge.
+ */
+export interface TerminalAPI {
+  /** Spawn a new PTY process. Returns unique pty ID. */
+  spawn: (options?: PtySpawnOptions) => Promise<string>;
+  /** Write data to PTY stdin (fire-and-forget). */
+  write: (ptyId: string, data: string) => void;
+  /** Resize PTY terminal (fire-and-forget). */
+  resize: (ptyId: string, cols: number, rows: number) => void;
+  /** Kill PTY process (fire-and-forget). */
+  kill: (ptyId: string) => void;
+  /** Subscribe to PTY data output. Returns cleanup function. */
+  onData: (cb: (event: unknown, ptyId: string, data: string) => void) => () => void;
+  /** Subscribe to PTY exit events. Returns cleanup function. */
+  onExit: (cb: (event: unknown, ptyId: string, exitCode: number) => void) => () => void;
+}

package/src/shared/types/visualization.ts

@@ -0,0 +1,60 @@
+/**
+ * Visualization-specific types for Hermit.
+ *
+ * These types are used for waterfall chart visualization
+ * and are shared between main and renderer processes.
+ */
+
+import type { TokenUsage } from '@main/types';
+
+// =============================================================================
+// Waterfall Chart Types
+// =============================================================================
+
+/**
+ * Waterfall item for visualization.
+ */
+export interface WaterfallItem {
+  /** Unique item identifier */
+  id: string;
+  /** Display label */
+  label: string;
+  /** Item start time */
+  startTime: Date;
+  /** Item end time */
+  endTime: Date;
+  /** Duration in milliseconds */
+  durationMs: number;
+  /** Token usage for this item */
+  tokenUsage: TokenUsage;
+  /** Hierarchy depth (0 = main session) */
+  level: number;
+  /** Item type */
+  type: 'chunk' | 'subagent' | 'tool';
+  /** Whether executed in parallel */
+  isParallel: boolean;
+  /** Parent item ID */
+  parentId?: string;
+  /** Group ID for parallel items */
+  groupId?: string;
+  /** Additional metadata for display */
+  metadata?: {
+    subagentType?: string;
+    toolName?: string;
+    messageCount?: number;
+  };
+}
+
+/**
+ * Complete waterfall chart data.
+ */
+export interface WaterfallData {
+  /** All waterfall items */
+  items: WaterfallItem[];
+  /** Earliest timestamp in the session */
+  minTime: Date;
+  /** Latest timestamp in the session */
+  maxTime: Date;
+  /** Total session duration in milliseconds */
+  totalDurationMs: number;
+}

package/src/shared/utils/__tests__/contextMetrics.test.ts

@@ -0,0 +1,260 @@
+import { describe, expect, it } from 'vitest';
+
+import { deriveContextMetrics, inferContextWindowTokens } from '../contextMetrics';
+
+describe('contextMetrics', () => {
+  it('derives exact Anthropic prompt and context usage', () => {
+    const metrics = deriveContextMetrics({
+      providerId: 'anthropic',
+      modelName: 'claude-sonnet-4-5-20250929',
+      usage: {
+        input_tokens: 1_200,
+        cache_creation_input_tokens: 400,
+        cache_read_input_tokens: 600,
+        output_tokens: 200,
+      },
+      visibleContextTokens: 550,
+    });
+
+    expect(metrics.contextWindowTokens).toBe(200_000);
+    expect(metrics.promptInputTokens).toBe(2_200);
+    expect(metrics.contextUsedTokens).toBe(2_400);
+    expect(metrics.promptInputSource).toBe('anthropic_usage');
+    expect(metrics.contextUsedPercentOfContextWindow).toBeCloseTo(1.2);
+    expect(metrics.visibleContextPercentOfPromptInput).toBeCloseTo(25);
+  });
+
+  it('derives exact OpenAI Responses usage', () => {
+    const metrics = deriveContextMetrics({
+      modelName: 'gpt-5.4',
+      usage: {
+        input_tokens: 5_000,
+        output_tokens: 250,
+      },
+      visibleContextTokens: 900,
+    });
+
+    expect(metrics.contextWindowTokens).toBe(1_050_000);
+    expect(metrics.promptInputTokens).toBe(5_000);
+    expect(metrics.contextUsedTokens).toBe(5_250);
+    expect(metrics.promptInputSource).toBe('openai_responses_usage');
+    expect(metrics.promptInputPercentOfContextWindow).toBeCloseTo(0.47619, 4);
+  });
+
+  it('derives exact OpenAI chat usage without double-counting cache or reasoning breakdowns', () => {
+    const metrics = deriveContextMetrics({
+      providerId: 'codex',
+      modelName: 'gpt-5.4',
+      usage: {
+        prompt_tokens: 2_006,
+        completion_tokens: 300,
+        prompt_tokens_details: {
+          cached_tokens: 1_920,
+        },
+        completion_tokens_details: {
+          reasoning_tokens: 120,
+        },
+      },
+      visibleContextTokens: 900,
+    });
+
+    expect(metrics.contextWindowTokens).toBe(1_050_000);
+    expect(metrics.promptInputTokens).toBe(2_006);
+    expect(metrics.outputTokens).toBe(300);
+    expect(metrics.contextUsedTokens).toBe(2_306);
+    expect(metrics.promptInputSource).toBe('openai_chat_usage');
+  });
+
+  it('does not double-count OpenAI cached-token breakdowns in Responses usage', () => {
+    const metrics = deriveContextMetrics({
+      providerId: 'codex',
+      modelName: 'gpt-5.2-codex',
+      usage: {
+        input_tokens: 7_500,
+        output_tokens: 120,
+        input_tokens_details: {
+          cached_tokens: 7_168,
+        },
+        output_tokens_details: {
+          reasoning_tokens: 80,
+        },
+      },
+    });
+
+    expect(metrics.contextWindowTokens).toBe(400_000);
+    expect(metrics.promptInputTokens).toBe(7_500);
+    expect(metrics.outputTokens).toBe(120);
+    expect(metrics.contextUsedTokens).toBe(7_620);
+    expect(metrics.promptInputSource).toBe('openai_responses_usage');
+  });
+
+  it('marks Codex prompt-side usage unavailable when telemetry reports fake zeros', () => {
+    const metrics = deriveContextMetrics({
+      providerId: 'codex',
+      modelName: 'gpt-5.4-mini',
+      usage: {
+        input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        output_tokens: 35,
+      },
+      visibleContextTokens: 700,
+    });
+
+    expect(metrics.contextWindowTokens).toBe(400_000);
+    expect(metrics.promptInputTokens).toBeNull();
+    expect(metrics.contextUsedTokens).toBeNull();
+    expect(metrics.promptInputSource).toBe('unavailable');
+    expect(metrics.visibleContextPercentOfPromptInput).toBeNull();
+  });
+
+  it('infers Anthropic native 1M windows from current raw model ids', () => {
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'claude-opus-4-7',
+      })
+    ).toBe(1_000_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'claude-opus-4-6',
+      })
+    ).toBe(1_000_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'claude-sonnet-4-6',
+      })
+    ).toBe(1_000_000);
+  });
+
+  it('keeps older raw Anthropic models at 200K unless 1M is explicitly requested', () => {
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'claude-sonnet-4-5-20250929',
+      })
+    ).toBe(200_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'opus[1m]',
+      })
+    ).toBe(1_000_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'claude-sonnet-4-5-20250929[1m]',
+      })
+    ).toBe(1_000_000);
+  });
+
+  it('respects limitContext for Anthropic even when the raw model supports 1M', () => {
+    expect(
+      inferContextWindowTokens({
+        providerId: 'anthropic',
+        modelName: 'claude-opus-4-6',
+        limitContext: true,
+      })
+    ).toBe(200_000);
+  });
+
+  it('infers Anthropic correctly from 1M aliases even when providerId is omitted', () => {
+    const metrics = deriveContextMetrics({
+      modelName: 'opus[1m]',
+      usage: {
+        input_tokens: 1_500,
+        output_tokens: 100,
+      },
+    });
+
+    expect(metrics.providerId).toBe('anthropic');
+    expect(metrics.contextWindowTokens).toBe(1_000_000);
+    expect(metrics.promptInputTokens).toBe(1_500);
+    expect(metrics.contextUsedTokens).toBe(1_600);
+    expect(metrics.promptInputSource).toBe('anthropic_usage');
+  });
+
+  it('supports Codex/OpenAI model-specific context windows', () => {
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.4-pro',
+      })
+    ).toBe(1_050_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.4-mini',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'codex-mini-latest',
+      })
+    ).toBe(200_000);
+  });
+
+  it('covers the current team Codex model matrix with documented context windows', () => {
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.4-mini',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.3-codex',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.3-codex-spark',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.2',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.2-codex',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.1-codex-mini',
+      })
+    ).toBe(400_000);
+    expect(
+      inferContextWindowTokens({
+        providerId: 'codex',
+        modelName: 'gpt-5.1-codex-max',
+      })
+    ).toBe(400_000);
+  });
+
+  it('prefers an explicit context window override over inferred model defaults', () => {
+    const metrics = deriveContextMetrics({
+      providerId: 'anthropic',
+      modelName: 'claude-opus-4-6',
+      contextWindowTokens: 200_000,
+      usage: {
+        input_tokens: 1_000,
+        output_tokens: 100,
+      },
+    });
+
+    expect(metrics.contextWindowTokens).toBe(200_000);
+    expect(metrics.promptInputTokens).toBe(1_000);
+    expect(metrics.contextUsedTokens).toBe(1_100);
+  });
+});

package/src/shared/utils/__tests__/ephemeralProjectPath.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+
+import { isEphemeralProjectPath } from '../ephemeralProjectPath';
+
+function absolutePath(...segments: string[]): string {
+  return `/${segments.join('/')}`;
+}
+
+describe('isEphemeralProjectPath', () => {
+  it('detects generated MCP project paths', () => {
+    expect(isEphemeralProjectPath(absolutePath('tmp', 'rendered_mcp_config', 'project'))).toBe(
+      true
+    );
+    expect(isEphemeralProjectPath('/Users/test/rendered_mcp_123/project')).toBe(true);
+    expect(isEphemeralProjectPath(absolutePath('tmp', 'portable-mcp-live', 'project'))).toBe(true);
+  });
+
+  it('detects Codex appstyle temp workspaces only under temp roots', () => {
+    expect(
+      isEphemeralProjectPath(
+        '/private/var/folders/7b/ydmc_b0n251bc4hss4tz8y880000gn/T/codex-agent-teams-appstyle-zudek6i9'
+      )
+    ).toBe(true);
+    expect(isEphemeralProjectPath(absolutePath('tmp', 'codex-agent-teams-appstyle-zudek6i9'))).toBe(
+      true
+    );
+    expect(
+      isEphemeralProjectPath(
+        'C:\\Users\\test\\AppData\\Local\\Temp\\codex-agent-teams-appstyle-zudek6i9'
+      )
+    ).toBe(true);
+    expect(isEphemeralProjectPath('/Users/test/projects/codex-agent-teams-appstyle-real')).toBe(
+      false
+    );
+  });
+
+  it('keeps normal project paths selectable', () => {
+    expect(isEphemeralProjectPath('/Users/test/projects/claude_team')).toBe(false);
+    expect(isEphemeralProjectPath('')).toBe(false);
+    expect(isEphemeralProjectPath(null)).toBe(false);
+  });
+});

package/src/shared/utils/__tests__/teamProvider.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  inferTeamProviderIdFromModel,
+  isTeamProviderId,
+  normalizeOptionalTeamProviderId,
+} from '../teamProvider';
+
+describe('inferTeamProviderIdFromModel', () => {
+  it('recognizes Anthropic aliases with 1m suffixes', () => {
+    expect(inferTeamProviderIdFromModel('opus[1m]')).toBe('anthropic');
+    expect(inferTeamProviderIdFromModel('sonnet[1m]')).toBe('anthropic');
+    expect(inferTeamProviderIdFromModel('haiku[1m]')).toBe('anthropic');
+  });
+
+  it('recognizes full provider-scoped model ids', () => {
+    expect(inferTeamProviderIdFromModel('claude-opus-4-6')).toBe('anthropic');
+    expect(inferTeamProviderIdFromModel('gpt-5.4')).toBe('codex');
+    expect(inferTeamProviderIdFromModel('gemini-2.5-pro')).toBe('gemini');
+    expect(inferTeamProviderIdFromModel('opencode/default')).toBe('opencode');
+    expect(inferTeamProviderIdFromModel('openai/gpt-5.4')).toBe('opencode');
+    expect(inferTeamProviderIdFromModel('openrouter/moonshotai/kimi-k2')).toBe('opencode');
+  });
+
+  it('treats OpenCode as a valid explicit team provider id', () => {
+    expect(isTeamProviderId('opencode')).toBe(true);
+    expect(normalizeOptionalTeamProviderId('opencode')).toBe('opencode');
+  });
+});

package/src/shared/utils/agentLanguage.ts

@@ -0,0 +1,122 @@
+/**
+ * Agent language configuration utilities.
+ * Pure functions — no Electron or DOM dependencies.
+ */
+
+export interface AgentLanguageOption {
+  readonly value: string;
+  readonly label: string;
+  readonly flag: string;
+}
+
+/** Curated list of language options for agent communication (sorted alphabetically after System). */
+export const AGENT_LANGUAGE_OPTIONS: readonly AgentLanguageOption[] = [
+  { value: 'system', label: 'System', flag: '\u{1F310}' },
+  { value: 'af', label: 'Afrikaans', flag: '\u{1F1FF}\u{1F1E6}' },
+  { value: 'am', label: 'Amharic', flag: '\u{1F1EA}\u{1F1F9}' },
+  { value: 'ar', label: 'Arabic', flag: '\u{1F1F8}\u{1F1E6}' },
+  { value: 'az', label: 'Azerbaijani', flag: '\u{1F1E6}\u{1F1FF}' },
+  { value: 'be', label: 'Belarusian', flag: '\u{1F1E7}\u{1F1FE}' },
+  { value: 'bg', label: 'Bulgarian', flag: '\u{1F1E7}\u{1F1EC}' },
+  { value: 'bn', label: 'Bengali', flag: '\u{1F1E7}\u{1F1E9}' },
+  { value: 'bs', label: 'Bosnian', flag: '\u{1F1E7}\u{1F1E6}' },
+  { value: 'ca', label: 'Catalan', flag: '\u{1F1EA}\u{1F1F8}' },
+  { value: 'cs', label: 'Czech', flag: '\u{1F1E8}\u{1F1FF}' },
+  {
+    value: 'cy',
+    label: 'Welsh',
+    flag: '\u{1F3F4}\u{E0067}\u{E0062}\u{E0077}\u{E006C}\u{E0073}\u{E007F}',
+  },
+  { value: 'da', label: 'Danish', flag: '\u{1F1E9}\u{1F1F0}' },
+  { value: 'de', label: 'German', flag: '\u{1F1E9}\u{1F1EA}' },
+  { value: 'el', label: 'Greek', flag: '\u{1F1EC}\u{1F1F7}' },
+  { value: 'en', label: 'English', flag: '\u{1F1FA}\u{1F1F8}' },
+  { value: 'es', label: 'Spanish', flag: '\u{1F1EA}\u{1F1F8}' },
+  { value: 'et', label: 'Estonian', flag: '\u{1F1EA}\u{1F1EA}' },
+  { value: 'eu', label: 'Basque', flag: '\u{1F1EA}\u{1F1F8}' },
+  { value: 'fa', label: 'Persian', flag: '\u{1F1EE}\u{1F1F7}' },
+  { value: 'fi', label: 'Finnish', flag: '\u{1F1EB}\u{1F1EE}' },
+  { value: 'fil', label: 'Filipino', flag: '\u{1F1F5}\u{1F1ED}' },
+  { value: 'fr', label: 'French', flag: '\u{1F1EB}\u{1F1F7}' },
+  { value: 'ga', label: 'Irish', flag: '\u{1F1EE}\u{1F1EA}' },
+  { value: 'gl', label: 'Galician', flag: '\u{1F1EA}\u{1F1F8}' },
+  { value: 'gu', label: 'Gujarati', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'he', label: 'Hebrew', flag: '\u{1F1EE}\u{1F1F1}' },
+  { value: 'hi', label: 'Hindi', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'hr', label: 'Croatian', flag: '\u{1F1ED}\u{1F1F7}' },
+  { value: 'hu', label: 'Hungarian', flag: '\u{1F1ED}\u{1F1FA}' },
+  { value: 'hy', label: 'Armenian', flag: '\u{1F1E6}\u{1F1F2}' },
+  { value: 'id', label: 'Indonesian', flag: '\u{1F1EE}\u{1F1E9}' },
+  { value: 'is', label: 'Icelandic', flag: '\u{1F1EE}\u{1F1F8}' },
+  { value: 'it', label: 'Italian', flag: '\u{1F1EE}\u{1F1F9}' },
+  { value: 'ja', label: 'Japanese', flag: '\u{1F1EF}\u{1F1F5}' },
+  { value: 'ka', label: 'Georgian', flag: '\u{1F1EC}\u{1F1EA}' },
+  { value: 'kk', label: 'Kazakh', flag: '\u{1F1F0}\u{1F1FF}' },
+  { value: 'km', label: 'Khmer', flag: '\u{1F1F0}\u{1F1ED}' },
+  { value: 'kn', label: 'Kannada', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'ko', label: 'Korean', flag: '\u{1F1F0}\u{1F1F7}' },
+  { value: 'lt', label: 'Lithuanian', flag: '\u{1F1F1}\u{1F1F9}' },
+  { value: 'lv', label: 'Latvian', flag: '\u{1F1F1}\u{1F1FB}' },
+  { value: 'mk', label: 'Macedonian', flag: '\u{1F1F2}\u{1F1F0}' },
+  { value: 'ml', label: 'Malayalam', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'mn', label: 'Mongolian', flag: '\u{1F1F2}\u{1F1F3}' },
+  { value: 'mr', label: 'Marathi', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'ms', label: 'Malay', flag: '\u{1F1F2}\u{1F1FE}' },
+  { value: 'my', label: 'Burmese', flag: '\u{1F1F2}\u{1F1F2}' },
+  { value: 'ne', label: 'Nepali', flag: '\u{1F1F3}\u{1F1F5}' },
+  { value: 'nl', label: 'Dutch', flag: '\u{1F1F3}\u{1F1F1}' },
+  { value: 'no', label: 'Norwegian', flag: '\u{1F1F3}\u{1F1F4}' },
+  { value: 'pa', label: 'Punjabi', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'pl', label: 'Polish', flag: '\u{1F1F5}\u{1F1F1}' },
+  { value: 'pt', label: 'Portuguese', flag: '\u{1F1E7}\u{1F1F7}' },
+  { value: 'ro', label: 'Romanian', flag: '\u{1F1F7}\u{1F1F4}' },
+  { value: 'ru', label: 'Russian', flag: '\u{1F1F7}\u{1F1FA}' },
+  { value: 'si', label: 'Sinhala', flag: '\u{1F1F1}\u{1F1F0}' },
+  { value: 'sk', label: 'Slovak', flag: '\u{1F1F8}\u{1F1F0}' },
+  { value: 'sl', label: 'Slovenian', flag: '\u{1F1F8}\u{1F1EE}' },
+  { value: 'sq', label: 'Albanian', flag: '\u{1F1E6}\u{1F1F1}' },
+  { value: 'sr', label: 'Serbian', flag: '\u{1F1F7}\u{1F1F8}' },
+  { value: 'sv', label: 'Swedish', flag: '\u{1F1F8}\u{1F1EA}' },
+  { value: 'sw', label: 'Swahili', flag: '\u{1F1F0}\u{1F1EA}' },
+  { value: 'ta', label: 'Tamil', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'te', label: 'Telugu', flag: '\u{1F1EE}\u{1F1F3}' },
+  { value: 'th', label: 'Thai', flag: '\u{1F1F9}\u{1F1ED}' },
+  { value: 'tr', label: 'Turkish', flag: '\u{1F1F9}\u{1F1F7}' },
+  { value: 'uk', label: 'Ukrainian', flag: '\u{1F1FA}\u{1F1E6}' },
+  { value: 'ur', label: 'Urdu', flag: '\u{1F1F5}\u{1F1F0}' },
+  { value: 'uz', label: 'Uzbek', flag: '\u{1F1FA}\u{1F1FF}' },
+  { value: 'vi', label: 'Vietnamese', flag: '\u{1F1FB}\u{1F1F3}' },
+  { value: 'zh', label: 'Chinese', flag: '\u{1F1E8}\u{1F1F3}' },
+  { value: 'zu', label: 'Zulu', flag: '\u{1F1FF}\u{1F1E6}' },
+] as const;
+
+/**
+ * Resolves a language code to a human-readable language name.
+ *
+ * - `'system'` → resolved from `systemLocale` via `Intl.DisplayNames` (e.g. "English", "Русский")
+ * - Known BCP-47 code → human name via `Intl.DisplayNames`
+ * - Fallback → returns the code itself
+ */
+export function resolveLanguageName(code: string, systemLocale?: string): string {
+  const effectiveCode = code === 'system' ? extractPrimaryLanguage(systemLocale ?? 'en') : code;
+
+  try {
+    const displayNames = new Intl.DisplayNames([effectiveCode], { type: 'language' });
+    const name = displayNames.of(effectiveCode);
+    if (name) {
+      return name.charAt(0).toUpperCase() + name.slice(1);
+    }
+  } catch {
+    // Intl.DisplayNames not available or invalid code — fall through
+  }
+
+  // Fallback: check our curated list
+  const option = AGENT_LANGUAGE_OPTIONS.find((o) => o.value === effectiveCode);
+  return option?.label ?? effectiveCode;
+}
+
+/** Extracts primary language subtag from a locale string (e.g. "en-US" → "en"). */
+function extractPrimaryLanguage(locale: string): string {
+  const dash = locale.indexOf('-');
+  return dash > 0 ? locale.slice(0, dash) : locale;
+}

package/src/shared/utils/anthropicLaunchModel.ts

@@ -0,0 +1,96 @@
+import { getAnthropicDefaultTeamModel } from './anthropicModelDefaults';
+import { isDefaultProviderModelSelection } from './providerModelSelection';
+
+function stripOneMillionSuffix(model: string): string {
+  return model.replace(/(?:\[1m\])+$/i, '');
+}
+
+function supportsOneMillionContext(model: string): boolean {
+  const normalized = stripOneMillionSuffix(model.trim().toLowerCase());
+  return (
+    normalized === 'opus' ||
+    normalized === 'sonnet' ||
+    normalized.startsWith('claude-opus-') ||
+    normalized.startsWith('claude-sonnet-')
+  );
+}
+
+function getOneMillionLaunchModel(model: string, limitContext: boolean | undefined): string {
+  const baseModel = stripOneMillionSuffix(model.trim());
+  if (!baseModel || limitContext || !supportsOneMillionContext(baseModel)) {
+    return baseModel;
+  }
+  return `${baseModel}[1m]`;
+}
+
+function normalizeAvailableLaunchModels(
+  availableLaunchModels: Iterable<string> | undefined
+): Set<string> {
+  const normalized = new Set<string>();
+  for (const model of availableLaunchModels ?? []) {
+    const trimmed = model.trim();
+    if (trimmed) {
+      normalized.add(trimmed);
+    }
+  }
+  return normalized;
+}
+
+function chooseAvailableModel(
+  availableModels: Set<string>,
+  candidates: readonly string[]
+): string | null {
+  if (availableModels.size === 0) {
+    return null;
+  }
+
+  for (const candidate of candidates) {
+    if (availableModels.has(candidate)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+export function resolveAnthropicLaunchModel(params: {
+  selectedModel?: string | null;
+  limitContext?: boolean;
+  availableLaunchModels?: Iterable<string>;
+  defaultLaunchModel?: string | null;
+}): string | null {
+  const selectedModel = params.selectedModel?.trim() ?? '';
+  const availableModels = normalizeAvailableLaunchModels(params.availableLaunchModels);
+
+  if (!selectedModel || isDefaultProviderModelSelection(selectedModel)) {
+    const staticDefault = getAnthropicDefaultTeamModel(params.limitContext);
+    const runtimeDefault = params.defaultLaunchModel?.trim() || null;
+    const preferredDefault = getOneMillionLaunchModel(staticDefault, params.limitContext);
+    const runtimeDefaultBase = runtimeDefault ? stripOneMillionSuffix(runtimeDefault) : null;
+    if (availableModels.size === 0) {
+      return preferredDefault;
+    }
+
+    return (
+      chooseAvailableModel(availableModels, [
+        preferredDefault,
+        runtimeDefault ? getOneMillionLaunchModel(runtimeDefault, params.limitContext) : '',
+        runtimeDefaultBase ?? '',
+        staticDefault,
+        stripOneMillionSuffix(staticDefault),
+      ]) ?? preferredDefault
+    );
+  }
+
+  const baseModel = stripOneMillionSuffix(selectedModel);
+  if (!baseModel) {
+    return null;
+  }
+
+  const preferredModel = getOneMillionLaunchModel(baseModel, params.limitContext);
+  if (availableModels.size === 0) {
+    return preferredModel;
+  }
+
+  return chooseAvailableModel(availableModels, [preferredModel, baseModel]) ?? preferredModel;
+}

package/src/shared/utils/anthropicModelDefaults.ts

@@ -0,0 +1,3 @@
+export function getAnthropicDefaultTeamModel(_limitContext?: boolean): string {
+  return 'opus';
+}

package/src/shared/utils/apiErrorDetector.ts

@@ -0,0 +1,13 @@
+/**
+ * Detects API error messages from Claude CLI output.
+ * Pattern: "API Error: <status_code>" at the beginning of the text.
+ */
+
+const API_ERROR_RE = /^API Error:\s*\d{3}/;
+
+/**
+ * Returns true if the message text starts with "API Error: <status_code>".
+ */
+export function isApiErrorMessage(text: string): boolean {
+  return API_ERROR_RE.test(text);
+}