@xelauvas/xela-cli 0.1.0

package/src/utils/exportRenderer.tsx

@@ -0,0 +1,98 @@
+import React, { useRef } from 'react';
+import stripAnsi from 'strip-ansi';
+import { Messages } from '../components/Messages.js';
+import { KeybindingProvider } from '../keybindings/KeybindingContext.js';
+import { loadKeybindingsSyncWithWarnings } from '../keybindings/loadUserBindings.js';
+import type { KeybindingContextName } from '../keybindings/types.js';
+import { AppStateProvider } from '../state/AppState.js';
+import type { Tools } from '../Tool.js';
+import type { Message } from '../types/message.js';
+import { renderToAnsiString } from './staticRender.js';
+
+/**
+ * Minimal keybinding provider for static/headless renders.
+ * Provides keybinding context without the ChordInterceptor (which uses useInput
+ * and would hang in headless renders with no stdin).
+ */
+function StaticKeybindingProvider({
+  children
+}: {
+  children: React.ReactNode;
+}): React.ReactNode {
+  const {
+    bindings
+  } = loadKeybindingsSyncWithWarnings();
+  const pendingChordRef = useRef(null);
+  const handlerRegistryRef = useRef(new Map());
+  const activeContexts = useRef(new Set<KeybindingContextName>()).current;
+  return <KeybindingProvider bindings={bindings} pendingChordRef={pendingChordRef} pendingChord={null} setPendingChord={() => {}} activeContexts={activeContexts} registerActiveContext={() => {}} unregisterActiveContext={() => {}} handlerRegistryRef={handlerRegistryRef}>
+      {children}
+    </KeybindingProvider>;
+}
+
+// Upper-bound how many NormalizedMessages a Message can produce.
+// normalizeMessages splits one Message with N content blocks into N
+// NormalizedMessages — 1:1 with block count. String content = 1 block.
+// AttachmentMessage etc. have no .message and normalize to ≤1.
+function normalizedUpperBound(m: Message): number {
+  if (!('message' in m)) return 1;
+  const c = m.message.content;
+  return Array.isArray(c) ? c.length : 1;
+}
+
+/**
+ * Streams rendered messages in chunks, ANSI codes preserved. Each chunk is a
+ * fresh renderToAnsiString — yoga layout tree + Ink's screen buffer are sized
+ * to the tallest CHUNK instead of the full session. Measured (Mar 2026,
+ * 538-msg session): −55% plateau RSS vs a single full render. The sink owns
+ * the output — write to stdout for `[` dump-to-scrollback, appendFile for `v`.
+ *
+ * Messages.renderRange slices AFTER normalize→group→collapse, so tool-call
+ * grouping stays correct across chunk seams; buildMessageLookups runs on
+ * the full normalized array so tool_use↔tool_result resolves regardless of
+ * which chunk each landed in.
+ */
+export async function streamRenderedMessages(messages: Message[], tools: Tools, sink: (ansiChunk: string) => void | Promise<void>, {
+  columns,
+  verbose = false,
+  chunkSize = 40,
+  onProgress
+}: {
+  columns?: number;
+  verbose?: boolean;
+  chunkSize?: number;
+  onProgress?: (rendered: number) => void;
+} = {}): Promise<void> {
+  const renderChunk = (range: readonly [number, number]) => renderToAnsiString(<AppStateProvider>
+        <StaticKeybindingProvider>
+          <Messages messages={messages} tools={tools} commands={[]} verbose={verbose} toolJSX={null} toolUseConfirmQueue={[]} inProgressToolUseIDs={new Set()} isMessageSelectorVisible={false} conversationId="export" screen="prompt" streamingToolUses={[]} showAllInTranscript={true} isLoading={false} renderRange={range} />
+        </StaticKeybindingProvider>
+      </AppStateProvider>, columns);
+
+  // renderRange indexes into the post-collapse array whose length we can't
+  // see from here — normalize splits each Message into one NormalizedMessage
+  // per content block (unbounded per message), collapse merges some back.
+  // Ceiling is the exact normalize output count + chunkSize so the loop
+  // always reaches the empty slice where break fires (collapse only shrinks).
+  let ceiling = chunkSize;
+  for (const m of messages) ceiling += normalizedUpperBound(m);
+  for (let offset = 0; offset < ceiling; offset += chunkSize) {
+    const ansi = await renderChunk([offset, offset + chunkSize]);
+    if (stripAnsi(ansi).trim() === '') break;
+    await sink(ansi);
+    onProgress?.(offset + chunkSize);
+  }
+}
+
+/**
+ * Renders messages to a plain text string suitable for export.
+ * Uses the same React rendering logic as the interactive UI.
+ */
+export async function renderMessagesToPlainText(messages: Message[], tools: Tools = [], columns?: number): Promise<string> {
+  const parts: string[] = [];
+  await streamRenderedMessages(messages, tools, chunk => void parts.push(stripAnsi(chunk)), {
+    columns
+  });
+  return parts.join('');
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useRef","stripAnsi","Messages","KeybindingProvider","loadKeybindingsSyncWithWarnings","KeybindingContextName","AppStateProvider","Tools","Message","renderToAnsiString","StaticKeybindingProvider","children","ReactNode","bindings","pendingChordRef","handlerRegistryRef","Map","activeContexts","Set","current","normalizedUpperBound","m","c","message","content","Array","isArray","length","streamRenderedMessages","messages","tools","sink","ansiChunk","Promise","columns","verbose","chunkSize","onProgress","rendered","renderChunk","range","ceiling","offset","ansi","trim","renderMessagesToPlainText","parts","chunk","push","join"],"sources":["exportRenderer.tsx"],"sourcesContent":["import React, { useRef } from 'react'\nimport stripAnsi from 'strip-ansi'\nimport { Messages } from '../components/Messages.js'\nimport { KeybindingProvider } from '../keybindings/KeybindingContext.js'\nimport { loadKeybindingsSyncWithWarnings } from '../keybindings/loadUserBindings.js'\nimport type { KeybindingContextName } from '../keybindings/types.js'\nimport { AppStateProvider } from '../state/AppState.js'\nimport type { Tools } from '../Tool.js'\nimport type { Message } from '../types/message.js'\nimport { renderToAnsiString } from './staticRender.js'\n\n/**\n * Minimal keybinding provider for static/headless renders.\n * Provides keybinding context without the ChordInterceptor (which uses useInput\n * and would hang in headless renders with no stdin).\n */\nfunction StaticKeybindingProvider({\n  children,\n}: {\n  children: React.ReactNode\n}): React.ReactNode {\n  const { bindings } = loadKeybindingsSyncWithWarnings()\n  const pendingChordRef = useRef(null)\n  const handlerRegistryRef = useRef(new Map())\n  const activeContexts = useRef(new Set<KeybindingContextName>()).current\n\n  return (\n    <KeybindingProvider\n      bindings={bindings}\n      pendingChordRef={pendingChordRef}\n      pendingChord={null}\n      setPendingChord={() => {}}\n      activeContexts={activeContexts}\n      registerActiveContext={() => {}}\n      unregisterActiveContext={() => {}}\n      handlerRegistryRef={handlerRegistryRef}\n    >\n      {children}\n    </KeybindingProvider>\n  )\n}\n\n// Upper-bound how many NormalizedMessages a Message can produce.\n// normalizeMessages splits one Message with N content blocks into N\n// NormalizedMessages — 1:1 with block count. String content = 1 block.\n// AttachmentMessage etc. have no .message and normalize to ≤1.\nfunction normalizedUpperBound(m: Message): number {\n  if (!('message' in m)) return 1\n  const c = m.message.content\n  return Array.isArray(c) ? c.length : 1\n}\n\n/**\n * Streams rendered messages in chunks, ANSI codes preserved. Each chunk is a\n * fresh renderToAnsiString — yoga layout tree + Ink's screen buffer are sized\n * to the tallest CHUNK instead of the full session. Measured (Mar 2026,\n * 538-msg session): −55% plateau RSS vs a single full render. The sink owns\n * the output — write to stdout for `[` dump-to-scrollback, appendFile for `v`.\n *\n * Messages.renderRange slices AFTER normalize→group→collapse, so tool-call\n * grouping stays correct across chunk seams; buildMessageLookups runs on\n * the full normalized array so tool_use↔tool_result resolves regardless of\n * which chunk each landed in.\n */\nexport async function streamRenderedMessages(\n  messages: Message[],\n  tools: Tools,\n  sink: (ansiChunk: string) => void | Promise<void>,\n  {\n    columns,\n    verbose = false,\n    chunkSize = 40,\n    onProgress,\n  }: {\n    columns?: number\n    verbose?: boolean\n    chunkSize?: number\n    onProgress?: (rendered: number) => void\n  } = {},\n): Promise<void> {\n  const renderChunk = (range: readonly [number, number]) =>\n    renderToAnsiString(\n      <AppStateProvider>\n        <StaticKeybindingProvider>\n          <Messages\n            messages={messages}\n            tools={tools}\n            commands={[]}\n            verbose={verbose}\n            toolJSX={null}\n            toolUseConfirmQueue={[]}\n            inProgressToolUseIDs={new Set()}\n            isMessageSelectorVisible={false}\n            conversationId=\"export\"\n            screen=\"prompt\"\n            streamingToolUses={[]}\n            showAllInTranscript={true}\n            isLoading={false}\n            renderRange={range}\n          />\n        </StaticKeybindingProvider>\n      </AppStateProvider>,\n      columns,\n    )\n\n  // renderRange indexes into the post-collapse array whose length we can't\n  // see from here — normalize splits each Message into one NormalizedMessage\n  // per content block (unbounded per message), collapse merges some back.\n  // Ceiling is the exact normalize output count + chunkSize so the loop\n  // always reaches the empty slice where break fires (collapse only shrinks).\n  let ceiling = chunkSize\n  for (const m of messages) ceiling += normalizedUpperBound(m)\n  for (let offset = 0; offset < ceiling; offset += chunkSize) {\n    const ansi = await renderChunk([offset, offset + chunkSize])\n    if (stripAnsi(ansi).trim() === '') break\n    await sink(ansi)\n    onProgress?.(offset + chunkSize)\n  }\n}\n\n/**\n * Renders messages to a plain text string suitable for export.\n * Uses the same React rendering logic as the interactive UI.\n */\nexport async function renderMessagesToPlainText(\n  messages: Message[],\n  tools: Tools = [],\n  columns?: number,\n): Promise<string> {\n  const parts: string[] = []\n  await streamRenderedMessages(\n    messages,\n    tools,\n    chunk => void parts.push(stripAnsi(chunk)),\n    { columns },\n  )\n  return parts.join('')\n}\n"],"mappings":"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","ignoreList":[]}

package/src/utils/extraUsage.ts

@@ -0,0 +1,23 @@
+import { isClaudeAISubscriber } from './auth.js'
+import { has1mContext } from './context.js'
+
+export function isBilledAsExtraUsage(
+  model: string | null,
+  isFastMode: boolean,
+  isOpus1mMerged: boolean,
+): boolean {
+  if (!isClaudeAISubscriber()) return false
+  if (isFastMode) return true
+  if (model === null || !has1mContext(model)) return false
+
+  const m = model
+    .toLowerCase()
+    .replace(/\[1m\]$/, '')
+    .trim()
+  const isOpus46 = m === 'opus' || m.includes('opus-4-6')
+  const isSonnet46 = m === 'sonnet' || m.includes('sonnet-4-6')
+
+  if (isOpus46 && isOpus1mMerged) return false
+
+  return isOpus46 || isSonnet46
+}

package/src/utils/fastMode.ts

@@ -0,0 +1,532 @@
+import axios from 'axios'
+import { getOauthConfig, OAUTH_BETA_HEADER } from 'src/constants/oauth.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js'
+import {
+  getIsNonInteractiveSession,
+  getKairosActive,
+  preferThirdPartyAuthentication,
+} from '../bootstrap/state.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import {
+  getAnthropicApiKey,
+  getClaudeAIOAuthTokens,
+  handleOAuth401Error,
+  hasProfileScope,
+} from './auth.js'
+import { isInBundledMode } from './bundledMode.js'
+import { getGlobalConfig, saveGlobalConfig } from './config.js'
+import { logForDebugging } from './debug.js'
+import { isEnvTruthy } from './envUtils.js'
+import {
+  getDefaultMainLoopModelSetting,
+  isOpus1mMergeEnabled,
+  type ModelSetting,
+  parseUserSpecifiedModel,
+} from './model/model.js'
+import { getAPIProvider } from './model/providers.js'
+import { isEssentialTrafficOnly } from './privacyLevel.js'
+import {
+  getInitialSettings,
+  getSettingsForSource,
+  updateSettingsForSource,
+} from './settings/settings.js'
+import { createSignal } from './signal.js'
+
+export function isFastModeEnabled(): boolean {
+  return !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_FAST_MODE)
+}
+
+export function isFastModeAvailable(): boolean {
+  if (!isFastModeEnabled()) {
+    return false
+  }
+  return getFastModeUnavailableReason() === null
+}
+
+type AuthType = 'oauth' | 'api-key'
+
+function getDisabledReasonMessage(
+  disabledReason: FastModeDisabledReason,
+  authType: AuthType,
+): string {
+  switch (disabledReason) {
+    case 'free':
+      return authType === 'oauth'
+        ? 'Fast mode requires a paid subscription'
+        : 'Fast mode unavailable during evaluation. Please purchase credits.'
+    case 'preference':
+      return 'Fast mode has been disabled by your organization'
+    case 'extra_usage_disabled':
+      // Only OAuth users can have extra_usage_disabled; console users don't have this concept
+      return 'Fast mode requires extra usage billing · /extra-usage to enable'
+    case 'network_error':
+      return 'Fast mode unavailable due to network connectivity issues'
+    case 'unknown':
+      return 'Fast mode is currently unavailable'
+  }
+}
+
+export function getFastModeUnavailableReason(): string | null {
+  if (!isFastModeEnabled()) {
+    return 'Fast mode is not available'
+  }
+
+  const statigReason = getFeatureValue_CACHED_MAY_BE_STALE(
+    'tengu_penguins_off',
+    null,
+  )
+  // Statsig reason has priority over other reasons.
+  if (statigReason !== null) {
+    logForDebugging(`Fast mode unavailable: ${statigReason}`)
+    return statigReason
+  }
+
+  // Previously, fast mode required the native binary (bun build). This is no
+  // longer necessary, but we keep this option behind a flag just in case.
+  if (
+    !isInBundledMode() &&
+    getFeatureValue_CACHED_MAY_BE_STALE('tengu_marble_sandcastle', false)
+  ) {
+    return 'Fast mode requires the native binary · Install from: https://claude.com/product/claude-code'
+  }
+
+  // Not available in the SDK unless explicitly opted in via --settings.
+  // Assistant daemon mode is exempt — it's first-party orchestration, and
+  // kairosActive is set before this check runs (main.tsx:~1626 vs ~3249).
+  if (
+    getIsNonInteractiveSession() &&
+    preferThirdPartyAuthentication() &&
+    !getKairosActive()
+  ) {
+    const flagFastMode = getSettingsForSource('flagSettings')?.fastMode
+    if (!flagFastMode) {
+      const reason = 'Fast mode is not available in the Agent SDK'
+      logForDebugging(`Fast mode unavailable: ${reason}`)
+      return reason
+    }
+  }
+
+  // Only available for 1P (not Bedrock/Vertex/Foundry)
+  if (getAPIProvider() !== 'firstParty') {
+    const reason = 'Fast mode is not available on Bedrock, Vertex, or Foundry'
+    logForDebugging(`Fast mode unavailable: ${reason}`)
+    return reason
+  }
+
+  if (orgStatus.status === 'disabled') {
+    if (
+      orgStatus.reason === 'network_error' ||
+      orgStatus.reason === 'unknown'
+    ) {
+      // The org check can fail behind corporate proxies that block the
+      // endpoint. We add CLAUDE_CODE_SKIP_FAST_MODE_NETWORK_ERRORS=1 to
+      // bypass this check in the CC binary. This is OK since we have
+      // another check in the API to error out when disabled by org.
+      if (isEnvTruthy(process.env.CLAUDE_CODE_SKIP_FAST_MODE_NETWORK_ERRORS)) {
+        return null
+      }
+    }
+    const authType: AuthType =
+      getClaudeAIOAuthTokens() !== null ? 'oauth' : 'api-key'
+    const reason = getDisabledReasonMessage(orgStatus.reason, authType)
+    logForDebugging(`Fast mode unavailable: ${reason}`)
+    return reason
+  }
+
+  return null
+}
+
+// @[MODEL LAUNCH]: Update supported Fast Mode models.
+export const FAST_MODE_MODEL_DISPLAY = 'Opus 4.6'
+
+export function getFastModeModel(): string {
+  return 'opus' + (isOpus1mMergeEnabled() ? '[1m]' : '')
+}
+
+export function getInitialFastModeSetting(model: ModelSetting): boolean {
+  if (!isFastModeEnabled()) {
+    return false
+  }
+  if (!isFastModeAvailable()) {
+    return false
+  }
+  if (!isFastModeSupportedByModel(model)) {
+    return false
+  }
+  const settings = getInitialSettings()
+  // If per-session opt-in is required, fast mode starts off each session
+  if (settings.fastModePerSessionOptIn) {
+    return false
+  }
+  return settings.fastMode === true
+}
+
+export function isFastModeSupportedByModel(
+  modelSetting: ModelSetting,
+): boolean {
+  if (!isFastModeEnabled()) {
+    return false
+  }
+  const model = modelSetting ?? getDefaultMainLoopModelSetting()
+  const parsedModel = parseUserSpecifiedModel(model)
+  return parsedModel.toLowerCase().includes('opus-4-6')
+}
+
+// --- Fast mode runtime state ---
+// Separate from user preference (settings.fastMode). This tracks the actual
+// operational state: whether we're actively sending fast speed or in cooldown
+// after a rate limit.
+
+export type FastModeRuntimeState =
+  | { status: 'active' }
+  | { status: 'cooldown'; resetAt: number; reason: CooldownReason }
+
+let runtimeState: FastModeRuntimeState = { status: 'active' }
+let hasLoggedCooldownExpiry = false
+
+// --- Cooldown event listeners ---
+export type CooldownReason = 'rate_limit' | 'overloaded'
+
+const cooldownTriggered =
+  createSignal<[resetAt: number, reason: CooldownReason]>()
+const cooldownExpired = createSignal()
+export const onCooldownTriggered = cooldownTriggered.subscribe
+export const onCooldownExpired = cooldownExpired.subscribe
+
+export function getFastModeRuntimeState(): FastModeRuntimeState {
+  if (
+    runtimeState.status === 'cooldown' &&
+    Date.now() >= runtimeState.resetAt
+  ) {
+    if (isFastModeEnabled() && !hasLoggedCooldownExpiry) {
+      logForDebugging('Fast mode cooldown expired, re-enabling fast mode')
+      hasLoggedCooldownExpiry = true
+      cooldownExpired.emit()
+    }
+    runtimeState = { status: 'active' }
+  }
+  return runtimeState
+}
+
+export function triggerFastModeCooldown(
+  resetTimestamp: number,
+  reason: CooldownReason,
+): void {
+  if (!isFastModeEnabled()) {
+    return
+  }
+  runtimeState = { status: 'cooldown', resetAt: resetTimestamp, reason }
+  hasLoggedCooldownExpiry = false
+  const cooldownDurationMs = resetTimestamp - Date.now()
+  logForDebugging(
+    `Fast mode cooldown triggered (${reason}), duration ${Math.round(cooldownDurationMs / 1000)}s`,
+  )
+  logEvent('tengu_fast_mode_fallback_triggered', {
+    cooldown_duration_ms: cooldownDurationMs,
+    cooldown_reason:
+      reason as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  })
+  cooldownTriggered.emit(resetTimestamp, reason)
+}
+
+export function clearFastModeCooldown(): void {
+  runtimeState = { status: 'active' }
+}
+
+/**
+ * Called when the API rejects a fast mode request (e.g., 400 "Fast mode is
+ * not enabled for your organization"). Permanently disables fast mode using
+ * the same flow as when the prefetch discovers the org has it disabled.
+ */
+export function handleFastModeRejectedByAPI(): void {
+  if (orgStatus.status === 'disabled') {
+    return
+  }
+  orgStatus = { status: 'disabled', reason: 'preference' }
+  updateSettingsForSource('userSettings', { fastMode: undefined })
+  saveGlobalConfig(current => ({
+    ...current,
+    penguinModeOrgEnabled: false,
+  }))
+  orgFastModeChange.emit(false)
+}
+
+// --- Overage rejection listeners ---
+// Fired when a 429 indicates fast mode was rejected because extra usage
+// (overage billing) is not available. Distinct from org-level disabling.
+const overageRejection = createSignal<[message: string]>()
+export const onFastModeOverageRejection = overageRejection.subscribe
+
+function getOverageDisabledMessage(reason: string | null): string {
+  switch (reason) {
+    case 'out_of_credits':
+      return 'Fast mode disabled · extra usage credits exhausted'
+    case 'org_level_disabled':
+    case 'org_service_level_disabled':
+      return 'Fast mode disabled · extra usage disabled by your organization'
+    case 'org_level_disabled_until':
+      return 'Fast mode disabled · extra usage spending cap reached'
+    case 'member_level_disabled':
+      return 'Fast mode disabled · extra usage disabled for your account'
+    case 'seat_tier_level_disabled':
+    case 'seat_tier_zero_credit_limit':
+    case 'member_zero_credit_limit':
+      return 'Fast mode disabled · extra usage not available for your plan'
+    case 'overage_not_provisioned':
+    case 'no_limits_configured':
+      return 'Fast mode requires extra usage billing · /extra-usage to enable'
+    default:
+      return 'Fast mode disabled · extra usage not available'
+  }
+}
+
+function isOutOfCreditsReason(reason: string | null): boolean {
+  return reason === 'org_level_disabled_until' || reason === 'out_of_credits'
+}
+
+/**
+ * Called when a 429 indicates fast mode was rejected because extra usage
+ * is not available. Permanently disables fast mode (unless the user has
+ * ran out of credits) and notifies with a reason-specific message.
+ */
+export function handleFastModeOverageRejection(reason: string | null): void {
+  const message = getOverageDisabledMessage(reason)
+  logForDebugging(
+    `Fast mode overage rejection: ${reason ?? 'unknown'} — ${message}`,
+  )
+  logEvent('tengu_fast_mode_overage_rejected', {
+    overage_disabled_reason: (reason ??
+      'unknown') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  })
+  // Disable fast mode permanently unless the user has ran out of credits
+  if (!isOutOfCreditsReason(reason)) {
+    updateSettingsForSource('userSettings', { fastMode: undefined })
+    saveGlobalConfig(current => ({
+      ...current,
+      penguinModeOrgEnabled: false,
+    }))
+  }
+  overageRejection.emit(message)
+}
+
+export function isFastModeCooldown(): boolean {
+  return getFastModeRuntimeState().status === 'cooldown'
+}
+
+export function getFastModeState(
+  model: ModelSetting,
+  fastModeUserEnabled: boolean | undefined,
+): 'off' | 'cooldown' | 'on' {
+  const enabled =
+    isFastModeEnabled() &&
+    isFastModeAvailable() &&
+    !!fastModeUserEnabled &&
+    isFastModeSupportedByModel(model)
+  if (enabled && isFastModeCooldown()) {
+    return 'cooldown'
+  }
+  if (enabled) {
+    return 'on'
+  }
+  return 'off'
+}
+
+// Disabled reason returned by the API. The API is the canonical source for why
+// fast mode is disabled (free account, admin preference, extra usage not enabled).
+export type FastModeDisabledReason =
+  | 'free'
+  | 'preference'
+  | 'extra_usage_disabled'
+  | 'network_error'
+  | 'unknown'
+
+// In-memory cache of the fast mode status from the API.
+// Distinct from the user's fastMode app state — this represents
+// whether the org *allows* fast mode and why it may be disabled.
+// Modeled as a discriminated union so the invalid state
+// (disabled without a reason) is unrepresentable.
+type FastModeOrgStatus =
+  | { status: 'pending' }
+  | { status: 'enabled' }
+  | { status: 'disabled'; reason: FastModeDisabledReason }
+
+let orgStatus: FastModeOrgStatus = { status: 'pending' }
+
+// Listeners notified when org-level fast mode status changes
+const orgFastModeChange = createSignal<[orgEnabled: boolean]>()
+export const onOrgFastModeChanged = orgFastModeChange.subscribe
+
+type FastModeResponse = {
+  enabled: boolean
+  disabled_reason: FastModeDisabledReason | null
+}
+
+async function fetchFastModeStatus(
+  auth: { accessToken: string } | { apiKey: string },
+): Promise<FastModeResponse> {
+  const endpoint = `${getOauthConfig().BASE_API_URL}/api/claude_code_penguin_mode`
+  const headers: Record<string, string> =
+    'accessToken' in auth
+      ? {
+          Authorization: `Bearer ${auth.accessToken}`,
+          'anthropic-beta': OAUTH_BETA_HEADER,
+        }
+      : { 'x-api-key': auth.apiKey }
+
+  const response = await axios.get<FastModeResponse>(endpoint, { headers })
+  return response.data
+}
+
+const PREFETCH_MIN_INTERVAL_MS = 30_000
+let lastPrefetchAt = 0
+let inflightPrefetch: Promise<void> | null = null
+
+/**
+ * Resolve orgStatus from the persisted cache without making any API calls.
+ * Used when startup prefetches are throttled to avoid hitting the network
+ * while still making fast mode availability checks work.
+ */
+export function resolveFastModeStatusFromCache(): void {
+  if (!isFastModeEnabled()) {
+    return
+  }
+  if (orgStatus.status !== 'pending') {
+    return
+  }
+  const isAnt = process.env.USER_TYPE === 'ant'
+  const cachedEnabled = getGlobalConfig().penguinModeOrgEnabled === true
+  orgStatus =
+    isAnt || cachedEnabled
+      ? { status: 'enabled' }
+      : { status: 'disabled', reason: 'unknown' }
+}
+
+export async function prefetchFastModeStatus(): Promise<void> {
+  // Skip network requests if nonessential traffic is disabled
+  if (isEssentialTrafficOnly()) {
+    return
+  }
+
+  if (!isFastModeEnabled()) {
+    return
+  }
+
+  if (inflightPrefetch) {
+    logForDebugging(
+      'Fast mode prefetch in progress, returning in-flight promise',
+    )
+    return inflightPrefetch
+  }
+
+  // Service key OAuth sessions lack user:profile scope → endpoint 403s.
+  // Resolve orgStatus from cache and bail before burning the throttle window.
+  // API key auth is unaffected.
+  const apiKey = getAnthropicApiKey()
+  const hasUsableOAuth =
+    getClaudeAIOAuthTokens()?.accessToken && hasProfileScope()
+  if (!hasUsableOAuth && !apiKey) {
+    const isAnt = process.env.USER_TYPE === 'ant'
+    const cachedEnabled = getGlobalConfig().penguinModeOrgEnabled === true
+    orgStatus =
+      isAnt || cachedEnabled
+        ? { status: 'enabled' }
+        : { status: 'disabled', reason: 'preference' }
+    return
+  }
+
+  const now = Date.now()
+  if (now - lastPrefetchAt < PREFETCH_MIN_INTERVAL_MS) {
+    logForDebugging('Skipping fast mode prefetch, fetched recently')
+    return
+  }
+  lastPrefetchAt = now
+
+  const fetchWithCurrentAuth = async (): Promise<FastModeResponse> => {
+    const currentTokens = getClaudeAIOAuthTokens()
+    const auth =
+      currentTokens?.accessToken && hasProfileScope()
+        ? { accessToken: currentTokens.accessToken }
+        : apiKey
+          ? { apiKey }
+          : null
+    if (!auth) {
+      throw new Error('No auth available')
+    }
+    return fetchFastModeStatus(auth)
+  }
+
+  async function doFetch(): Promise<void> {
+    try {
+      let status: FastModeResponse
+      try {
+        status = await fetchWithCurrentAuth()
+      } catch (err) {
+        const isAuthError =
+          axios.isAxiosError(err) &&
+          (err.response?.status === 401 ||
+            (err.response?.status === 403 &&
+              typeof err.response?.data === 'string' &&
+              err.response.data.includes('OAuth token has been revoked')))
+        if (isAuthError) {
+          const failedAccessToken = getClaudeAIOAuthTokens()?.accessToken
+          if (failedAccessToken) {
+            await handleOAuth401Error(failedAccessToken)
+            status = await fetchWithCurrentAuth()
+          } else {
+            throw err
+          }
+        } else {
+          throw err
+        }
+      }
+
+      const previousEnabled =
+        orgStatus.status !== 'pending'
+          ? orgStatus.status === 'enabled'
+          : getGlobalConfig().penguinModeOrgEnabled
+      orgStatus = status.enabled
+        ? { status: 'enabled' }
+        : {
+            status: 'disabled',
+            reason: status.disabled_reason ?? 'preference',
+          }
+      if (previousEnabled !== status.enabled) {
+        // When org disables fast mode, permanently turn off the user's fast mode setting
+        if (!status.enabled) {
+          updateSettingsForSource('userSettings', { fastMode: undefined })
+        }
+        saveGlobalConfig(current => ({
+          ...current,
+          penguinModeOrgEnabled: status.enabled,
+        }))
+        orgFastModeChange.emit(status.enabled)
+      }
+      logForDebugging(
+        `Org fast mode: ${status.enabled ? 'enabled' : `disabled (${status.disabled_reason ?? 'preference'})`}`,
+      )
+    } catch (err) {
+      // On failure: ants default to enabled (don't block internal users).
+      // External users: fall back to the cached penguinModeOrgEnabled value;
+      // if no positive cache, disable with network_error reason.
+      const isAnt = process.env.USER_TYPE === 'ant'
+      const cachedEnabled = getGlobalConfig().penguinModeOrgEnabled === true
+      orgStatus =
+        isAnt || cachedEnabled
+          ? { status: 'enabled' }
+          : { status: 'disabled', reason: 'network_error' }
+      logForDebugging(
+        `Failed to fetch org fast mode status, defaulting to ${orgStatus.status === 'enabled' ? 'enabled (cached)' : 'disabled (network_error)'}: ${err}`,
+        { level: 'error' },
+      )
+      logEvent('tengu_org_penguin_mode_fetch_failed', {})
+    } finally {
+      inflightPrefetch = null
+    }
+  }
+
+  inflightPrefetch = doFetch()
+  return inflightPrefetch
+}