mixdog 0.9.2 → 0.9.4

package/src/tui/statusline-ansi-bridge.test.mjs

@@ -1,159 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  remapCanonicalStatuslineTruecolor,
-  normalizeStatuslineAnsi,
-  statuslineFooterCacheKey,
-  statuslineFooterIdentityChanged,
-  isResetStatsState,
-  STATUSLINE_CANONICAL_TRUECOLOR,
-} from './statusline-ansi-bridge.mjs';
-import { theme, setThemeSetting } from './theme.mjs';
-
-function sgr38(r, g, b) {
-  return `\x1b[38;2;${r};${g};${b}m`;
-}
-
-function statusColorsFromTheme() {
-  const ansiRgb = (value, fallback) => {
-    const match = /^rgb\((\d+),(\d+),(\d+)\)$/.exec(String(value || '').replace(/\s+/g, ''));
-    if (!match) return fallback;
-    return sgr38(match[1], match[2], match[3]);
-  };
-  return {
-    STATUS: ansiRgb(theme.statusText, sgr38(198, 198, 198)),
-    SUBTLE: ansiRgb(theme.statusSubtle, sgr38(136, 136, 136)),
-    SUCCESS: ansiRgb(theme.success, sgr38(0, 170, 75)),
-    WARNING: ansiRgb(theme.warning, sgr38(255, 193, 7)),
-    ERROR: ansiRgb(theme.error, sgr38(220, 70, 88)),
-  };
-}
-
-test('remaps canonical truecolor sequences from ui/statusline.mjs', () => {
-  const colors = statusColorsFromTheme();
-  const subtle = sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.subtle);
-  const success = sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.success);
-  const raw = `${subtle}│\x1b[0m ${success}42%`;
-  const out = remapCanonicalStatuslineTruecolor(raw, colors);
-  assert.ok(!out.includes('38;2;136;136;136'), 'subtle canonical RGB should be replaced');
-  assert.ok(!out.includes('38;2;0;170;75'), 'success canonical RGB should be replaced');
-  assert.ok(out.includes(colors.SUBTLE));
-  assert.ok(out.includes(colors.SUCCESS));
-});
-
-test('normalizeStatuslineAnsi maps bold and legacy SGR plus truecolor', () => {
-  const colors = statusColorsFromTheme();
-  const raw = `\x1b[1mmodel\x1b[0m \x1b[33m5H\x1b[0m ${sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.error)}quota`;
-  const out = normalizeStatuslineAnsi(raw, colors);
-  assert.ok(out.includes(colors.STATUS));
-  assert.ok(out.includes(colors.WARNING));
-  assert.ok(out.includes(colors.ERROR));
-  assert.ok(!out.includes('\x1b[33m'));
-  assert.ok(!out.includes('38;2;220;70;88'));
-});
-
-test('normalizeStatuslineAnsi preserves leading diamond glyph', () => {
-  const colors = statusColorsFromTheme();
-  const subtle = sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.subtle);
-  const raw = `${subtle}◆\x1b[0m \x1b[1mgpt-4o\x1b[0m`;
-  const out = normalizeStatuslineAnsi(raw, colors);
-  assert.ok(out.includes('◆'), 'visible ◆ must remain');
-  assert.ok(out.includes('gpt-4o'));
-  assert.ok(out.indexOf('◆') < out.indexOf('gpt-4o'));
-});
-
-test('retimes bare values after reset without clobbering explicit segment colors', () => {
-  const colors = statusColorsFromTheme();
-  const subtle = colors.SUBTLE;
-  const success = colors.SUCCESS;
-  const warning = colors.WARNING;
-  const reset = '\x1b[0m';
-  const creditSeg = `${subtle}Credit${reset} $12.34`;
-  const outCredit = normalizeStatuslineAnsi(creditSeg, colors, { reset });
-  assert.ok(outCredit.includes('$12.34'));
-  const moneyIdx = outCredit.indexOf('$12.34');
-  assert.ok(moneyIdx > 0);
-  assert.ok(outCredit.slice(0, moneyIdx).includes(colors.STATUS), 'bare credit amount uses status text');
-
-  const usedLimit = `${subtle}5H${reset} $3.00/$10.00`;
-  const outUsed = normalizeStatuslineAnsi(usedLimit, colors, { reset });
-  assert.ok(outUsed.includes('$3.00/$10.00'));
-  assert.ok(outUsed.slice(0, outUsed.indexOf('$3.00')).includes(colors.STATUS));
-
-  const colored = `${subtle}5H${reset} ${warning}est $5.00${reset}`;
-  const outColored = normalizeStatuslineAnsi(colored, colors, { reset });
-  assert.ok(outColored.includes(warning), 'warning color on value must remain');
-  const estIdx = outColored.indexOf('est');
-  assert.ok(estIdx > 0);
-  assert.ok(outColored.slice(0, estIdx).includes(warning));
-});
-
-test('statuslineFooterCacheKey changes when session or route identity changes', () => {
-  const a = statuslineFooterCacheKey({ sessionId: 's1', provider: 'p', model: 'm1' });
-  const b = statuslineFooterCacheKey({ sessionId: 's2', provider: 'p', model: 'm1' });
-  const c = statuslineFooterCacheKey({ sessionId: 's1', provider: 'p', model: 'm2' });
-  assert.notEqual(a, b);
-  assert.notEqual(a, c);
-});
-
-test('statusline footer identity tracks context display boundary fields', () => {
-  const base = {
-    sessionId: 's1',
-    provider: 'p',
-    model: 'm',
-    contextWindow: 1_000_000,
-    displayContextWindow: 900_000,
-    rawContextWindow: 1_000_000,
-    compactBoundaryTokens: 900_000,
-    autoCompactTokenLimit: 810_000,
-    stats: { currentEstimatedContextTokens: 10_000 },
-  };
-  const changedDisplay = { ...base, displayContextWindow: 800_000 };
-  const changedBoundary = { ...base, compactBoundaryTokens: 800_000 };
-  const changedTrigger = { ...base, autoCompactTokenLimit: 720_000 };
-
-  assert.notEqual(statuslineFooterCacheKey(base), statuslineFooterCacheKey(changedDisplay));
-  assert.notEqual(statuslineFooterCacheKey(base), statuslineFooterCacheKey(changedBoundary));
-  assert.notEqual(statuslineFooterCacheKey(base), statuslineFooterCacheKey(changedTrigger));
-  assert.equal(statuslineFooterIdentityChanged(changedDisplay, base), true);
-  assert.equal(statuslineFooterIdentityChanged(changedBoundary, base), true);
-  assert.equal(statuslineFooterIdentityChanged(changedTrigger, base), true);
-});
-
-test('stats reset transition is footer identity change (cache must not reuse on /theme)', () => {
-  const activeStats = {
-    currentContextTokens: 1200,
-    inputTokens: 800,
-    turns: 2,
-  };
-  const resetStats = {
-    currentContextTokens: 0,
-    currentEstimatedContextTokens: 0,
-    inputTokens: 0,
-    latestInputTokens: 0,
-    promptTokens: 0,
-    turns: 0,
-  };
-  assert.equal(isResetStatsState(resetStats), true);
-  assert.equal(isResetStatsState(activeStats), false);
-  const sameRoute = { sessionId: 's1', provider: 'p', model: 'm', stats: resetStats };
-  const lastRoute = { sessionId: 's1', provider: 'p', model: 'm', stats: activeStats };
-  assert.equal(statuslineFooterCacheKey(sameRoute), statuslineFooterCacheKey(lastRoute));
-  assert.equal(statuslineFooterIdentityChanged(sameRoute, lastRoute), true);
-});
-
-test('theme switch changes normalized output when raw line is canonical', () => {
-  setThemeSetting('basic', { persist: false });
-  const colorsA = statusColorsFromTheme();
-  const raw = `${sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.success)}▓▓\x1b[0m ${sgr38(...STATUSLINE_CANONICAL_TRUECOLOR.subtle)}░░`;
-  const tonedA = normalizeStatuslineAnsi(raw, colorsA);
-
-  setThemeSetting('teal', { persist: false });
-  const colorsB = statusColorsFromTheme();
-  const tonedB = normalizeStatuslineAnsi(raw, colorsB);
-
-  assert.notEqual(tonedA, tonedB);
-  assert.ok(tonedB.includes(colorsB.SUCCESS));
-  assert.ok(tonedB.includes(colorsB.SUBTLE));
-  setThemeSetting('basic', { persist: false });
-});

package/src/tui/transcript-tool-failures.test.mjs

@@ -1,111 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  formatHookDenialDetail,
-  hasUsefulFailedToolResultBody,
-  isFullyFailedToolBatch,
-  isHookApprovalDenialToolItem,
-  isHookApprovalDenialToolResult,
-  shouldSuppressFullyFailedToolItem,
-} from './transcript-tool-failures.mjs';
-
-const hookDeniedItem = {
-  kind: 'tool',
-  name: 'shell',
-  args: { command: 'rm -rf /' },
-  result: 'Error: tool "shell" denied by hook: approval required but no approval UI is available (policy)',
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const noisyFailedItem = {
-  kind: 'tool',
-  name: 'grep',
-  args: { pattern: 'foo' },
-  result: 'no matches',
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const emptyFailedItem = {
-  kind: 'tool',
-  name: 'grep',
-  args: { pattern: 'foo' },
-  result: null,
-  rawResult: null,
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const failedTaskJsonStringArgs = {
-  kind: 'tool',
-  name: 'shell',
-  args: '{"task_id":"t1","status":"failed","error":"boom"}',
-  result: null,
-  rawResult: null,
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-const failedTaskInputWrapperArgs = {
-  kind: 'tool',
-  name: 'shell',
-  args: { input: { task_id: 't2', status: 'timeout' } },
-  result: null,
-  rawResult: null,
-  isError: true,
-  count: 1,
-  completedCount: 1,
-};
-
-test('detects hook denial result text', () => {
-  assert.equal(
-    isHookApprovalDenialToolResult('Error: tool "read" denied by hook: blocked'),
-    true,
-  );
-  assert.equal(
-    isHookApprovalDenialToolResult('Error: tool "shell" denied by hook: approval required but no approval UI is available'),
-    true,
-  );
-  assert.equal(isHookApprovalDenialToolResult('grep: no matches'), false);
-});
-
-test('fully-failed hook denials are not suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(hookDeniedItem), true);
-  assert.equal(isHookApprovalDenialToolItem(hookDeniedItem), true);
-  assert.equal(shouldSuppressFullyFailedToolItem(hookDeniedItem), false);
-});
-
-test('fully-failed non-hook errors with visible body stay visible', () => {
-  assert.equal(isFullyFailedToolBatch(noisyFailedItem), true);
-  assert.equal(hasUsefulFailedToolResultBody(noisyFailedItem), true);
-  assert.equal(shouldSuppressFullyFailedToolItem(noisyFailedItem), false);
-});
-
-test('fully-failed non-hook errors without useful body stay suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(emptyFailedItem), true);
-  assert.equal(hasUsefulFailedToolResultBody(emptyFailedItem), false);
-  assert.equal(shouldSuppressFullyFailedToolItem(emptyFailedItem), true);
-});
-
-test('failed background task with JSON-string args is not suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(failedTaskJsonStringArgs), false);
-  assert.equal(shouldSuppressFullyFailedToolItem(failedTaskJsonStringArgs), false);
-});
-
-test('failed background task with input-wrapped args is not suppressed', () => {
-  assert.equal(isFullyFailedToolBatch(failedTaskInputWrapperArgs), false);
-  assert.equal(shouldSuppressFullyFailedToolItem(failedTaskInputWrapperArgs), false);
-});
-
-test('formatHookDenialDetail strips tool prefix', () => {
-  assert.equal(
-    formatHookDenialDetail(hookDeniedItem.result),
-    'denied by hook: approval required but no approval UI is available (policy)',
-  );
-});
-

package/src/ui/markdown.test.mjs

@@ -1,70 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { env } from 'node:process';
-import { renderMarkdown } from './markdown.mjs';
-import { refreshColorSupport, stripAnsi } from './ansi.mjs';
-
-test.before(() => {
-  env.FORCE_COLOR = '1';
-  refreshColorSupport();
-});
-
-test('renderMarkdown never throws on garbage input', () => {
-  assert.doesNotThrow(() => renderMarkdown('**unclosed `fence\n> quote\n'));
-  assert.equal(renderMarkdown(null), '');
-});
-
-test('diff fenced blocks color hunks and +/- lines', () => {
-  const src = [
-    '```diff',
-    '--- a/file.mjs',
-    '+++ b/file.mjs',
-    '@@ -1,2 +1,2 @@',
-    '-old',
-    '+new',
-    '```',
-  ].join('\n');
-  const out = renderMarkdown(src);
-  assert.match(out, /\x1b\[38;2;204;157;44/);
-  assert.match(out, /\x1b\[38;2;0;170;75/);
-  assert.match(out, /\x1b\[38;2;220;70;88/);
-  assert.ok(stripAnsi(out).includes('diff'));
-});
-
-test('inline code and headings use Mixdog accent colors', () => {
-  const out = renderMarkdown('# Title\nUse `code` here.');
-  assert.match(out, /\x1b\[38;2;215;119;87/);
-  assert.match(out, /\x1b\[38;2;138;190;183/);
-});
-
-test('longer fence opener does not close on shorter backtick line inside block', () => {
-  const src = ['````', '```', 'still inside', '````'].join('\n');
-  const plain = stripAnsi(renderMarkdown(src));
-  assert.ok(plain.includes('still inside'));
-  assert.ok(!plain.includes('```\nstill'));
-});
-
-test('mixed backtick-tilde closer does not end backtick fence', () => {
-  const src = ['```', '``~', 'still inside', '```'].join('\n');
-  const plain = stripAnsi(renderMarkdown(src));
-  assert.ok(plain.includes('still inside'));
-  assert.ok(plain.includes('``~'));
-});
-
-test('fenced code block body rows include right border', () => {
-  const out = stripAnsi(renderMarkdown('```js\nx\n```'));
-  const rows = out.split('\n').filter((line) => line.startsWith('│ '));
-  assert.ok(rows.length >= 1);
-  for (const row of rows) {
-    assert.match(row, /│\s*$/);
-  }
-});
-
-test('inline code inside link labels is preserved', () => {
-  const out = renderMarkdown('[see `foo`](https://example.com)');
-  const plain = stripAnsi(out);
-  assert.ok(plain.includes('foo'));
-  assert.ok(plain.includes('https://example.com'));
-  assert.match(out, /\x1b\[38;2;138;190;183/);
-});
-

package/src/ui/statusline-context-label.test.mjs

@@ -1,15 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { contextPctDisplayLabel } from './statusline.mjs';
-
-test('contextPctDisplayLabel clamps displayed percent at 100', () => {
-  assert.equal(contextPctDisplayLabel(105), '100');
-  assert.equal(contextPctDisplayLabel(100.9), '100');
-  assert.equal(contextPctDisplayLabel(99.2), '99');
-});
-
-test('contextPctDisplayLabel keeps sub-1% decimal display', () => {
-  assert.equal(contextPctDisplayLabel(0.45), '0.5');
-  assert.equal(contextPctDisplayLabel(0.04), '0');
-});
-

package/src/vendor/statusline/bin/statusline-lib.mjs

@@ -1,186 +0,0 @@
-// mixdog statusline renderer — function form for in-daemon reuse.
-//
-// Mirrors `bin/statusline.mjs` exactly, but takes the CC stdin JSON as an
-// argument and returns the rendered status text instead of reading fd 0 and
-// writing to process.stdout. This allows the hook-pipe daemon to compute the
-// statusline without paying the ~100ms bun cold-start on every refresh tick.
-
-import fs from 'fs';
-import os from 'os';
-import http from 'node:http';
-import path from 'path';
-import { formatGatewayLimitSegments, loadGatewayStatus } from './statusline-route.mjs';
-import {
-  isClaudeNativeModelSelection,
-  isMixdogModelSelection,
-  writeClaudeCodeCurrentSnapshot,
-} from '../src/gateway/claude-current.mjs';
-import {
-  ANTHROPIC_OFFICIAL_BASE_URL,
-  syncAnthropicBaseUrl,
-  syncAutoCompactWindow,
-} from '../scripts/lib/gateway-settings.mjs';
-import {
-  readGatewaySessionRoute,
-  readLatestGatewayHostRoute,
-} from '../src/gateway/session-routes.mjs';
-
-function claudeConfigDir() {
-  return process.env.MIXDOG_CONFIG_DIR || path.join(os.homedir(), '.mixdog');
-}
-
-function pluginDataDir() {
-  return process.env.MIXDOG_DATA_DIR || path.join(process.env.MIXDOG_HOME || path.join(os.homedir(), '.mixdog'), 'data');
-}
-
-function writeFileIfChangedSync(file, content) {
-  try {
-    if (fs.existsSync(file) && fs.readFileSync(file, 'utf8') === content) return true;
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, content);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function gatewayPort() {
-  const envPort = Number(process.env.MIXDOG_GATEWAY_PORT);
-  if (Number.isFinite(envPort) && envPort > 0) return Math.floor(envPort);
-  try {
-    const cfg = JSON.parse(fs.readFileSync(path.join(pluginDataDir(), 'mixdog-config.json'), 'utf8'));
-    const port = Number(cfg?.gateway?.port);
-    if (Number.isFinite(port) && port > 0) return Math.floor(port);
-  } catch {}
-  return 3468;
-}
-
-function readGatewayConfig() {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(pluginDataDir(), 'mixdog-config.json'), 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function gatewayOwnsMainBaseUrl() {
-  const cfg = readGatewayConfig();
-  if (cfg?.modules?.gateway?.enabled !== true) return false;
-  return cfg?.gateway?.mode === 'claude-current';
-}
-
-function settingsModelIsMixdog() {
-  try {
-    const settings = JSON.parse(fs.readFileSync(path.join(claudeConfigDir(), 'settings.json'), 'utf8'));
-    return isMixdogModelSelection(settings?.model);
-  } catch {
-    return false;
-  }
-}
-
-function routeUsesNonClaudeGateway(route) {
-  if (!route || typeof route !== 'object') return false;
-  const provider = String(route.defaultProvider || route.provider || '').trim();
-  const model = String(route.defaultModel || route.model || '').trim();
-  if (!provider || !model) return false;
-  return provider !== 'anthropic-oauth' && provider !== 'anthropic';
-}
-
-function storedRouteNeedsGatewayStatus(sessionId, clientHostPid) {
-  try {
-    if (!(Number(clientHostPid) > 0)) return false;
-    const route = readGatewaySessionRoute(sessionId, { clientHostPid })
-      || readLatestGatewayHostRoute(clientHostPid, { excludeSessionId: sessionId });
-    return routeUsesNonClaudeGateway(route);
-  } catch {
-    return false;
-  }
-}
-
-function shouldLoadGatewayStatus(currentRoute, sessionId, clientHostPid) {
-  if (process.env.MIXDOG_STATUSLINE_STANDALONE === '1') return false;
-  if (process.env.MIXDOG_STANDALONE === '1') return true;
-  if (!isClaudeNativeModelSelection(currentRoute)) return true;
-  // Native model selection, but the gateway still owns the main base URL in
-  // claude-current mode: every request flows through 3468, so the gateway's
-  // oauth usage cache (5H/7D) is the only quota source — CC's stdin rate_limits
-  // arrive empty on a gateway-proxied native route. Read the gateway status so
-  // the usage segment renders instead of going blank.
-  return gatewayOwnsMainBaseUrl()
-    || storedRouteNeedsGatewayStatus(sessionId, clientHostPid)
-    || settingsModelIsMixdog();
-}
-
-function traceStatusline(message) {
-  if (!process.env.MIXDOG_STATUSLINE_TRACE) return;
-  try {
-    fs.appendFileSync(path.join(pluginDataDir(), 'statusline-trace.log'), `${new Date().toISOString()} ${message}\n`);
-  } catch {}
-}
-
-function syncBaseUrlForCurrentModel(route) {
-  if (!route) return;
-  const target = isMixdogModelSelection(route) || gatewayOwnsMainBaseUrl() || settingsModelIsMixdog()
-    ? `http://127.0.0.1:${gatewayPort()}`
-    : isClaudeNativeModelSelection(route)
-      ? ANTHROPIC_OFFICIAL_BASE_URL
-      : '';
-  if (!target) return;
-  const result = syncAnthropicBaseUrl(target, { requireExisting: true });
-  if (!result.ok) traceStatusline(`[base-url-sync] ${result.error || 'failed'}`);
-}
-
-function syncBaseUrlForGatewayStatus(status) {
-  if (!status?.provider || !status?.model) return;
-  const result = syncAnthropicBaseUrl(`http://127.0.0.1:${gatewayPort()}`, { requireExisting: true });
-  if (!result.ok) traceStatusline(`[base-url-sync:gateway-status] ${result.error || 'failed'}`);
-}
-
-function syncCompactWindowValue(win, label) {
-  if (!(Number.isFinite(Number(win)) && Number(win) > 0)) return;
-  const result = syncAutoCompactWindow(Math.floor(Number(win)));
-  if (!result.ok) traceStatusline(`[compact-window-sync:${label}] ${result.error || 'failed'}`);
-}
-
-function compactWindowForRouteLike(route) {
-  if (!route || typeof route !== 'object') return null;
-  const num = (v) => {
-    const n = Number(v);
-    return Number.isFinite(n) && n > 0 ? n : 0;
-  };
-  const explicit = num(route.autoCompactTokenLimit ?? route.auto_compact_token_limit);
-  const raw = num(route.rawContextWindow ?? route.raw_context_window ?? route.contextWindow ?? route.context_window);
-  const context = num(route.contextWindow ?? route.context_window);
-  const pct = num(route.effectiveContextWindowPercent ?? route.effective_context_window_percent) || 90;
-  const effective = context || (raw > 0 ? Math.max(1, Math.floor(raw * Math.min(100, pct) / 100)) : 0);
-  if (explicit > 0 && effective > 0) return Math.min(explicit, effective);
-  if (explicit > 0) return explicit;
-  return effective > 0 ? effective : null;
-}
-
-function syncCompactWindowForCurrentModel(route) {
-  if (!isClaudeNativeModelSelection(route)) return;
-  try {
-    syncCompactWindowValue(compactWindowForRouteLike(route), 'current');
-  } catch (e) {
-    traceStatusline(`[compact-window-sync:current] ${e?.message || e}`);
-  }
-}
-
-function syncCompactWindowForGatewayStatus(status) {
-  if (!status?.provider || !status?.model) return;
-  syncCompactWindowValue(compactWindowForRouteLike(status), 'gateway-status');
-}
-
-function writeStatuslineLastSnapshot(json) {
-  if (!json) return;
-  try { JSON.parse(json); } catch { return; }
-  try {
-    const file = path.join(claudeConfigDir(), 'cc-statusline-last.json');
-    const tmp = `${file}.${process.pid}.tmp`;
-    if (fs.existsSync(file) && fs.readFileSync(file, 'utf8') === json) return;
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(tmp, json);
-    fs.renameSync(tmp, file);
-  } catch {}
-}

package/src/vendor/statusline/bin/statusline-route.test.mjs

@@ -1,80 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { formatGatewayLimitSegments } from './statusline-route.mjs';
-
-test('formatGatewayLimitSegments hides OpenAI OAuth credit balance on L1', () => {
-  const segments = formatGatewayLimitSegments({
-    provider: 'openai-oauth',
-    providerKind: 'oauth',
-    source: 'openai-codex-wham',
-    quotaWindows: [
-      { label: '5H', source: 'openai-codex-oauth', usedPct: 42 },
-      { label: '7D', source: 'openai-codex-oauth', usedPct: 5 },
-    ],
-    balance: {
-      source: 'openai-codex-credits',
-      remainingUsd: 12.34,
-    },
-  }, { COLS: 120 });
-
-  assert.deepEqual(segments, ['5H 42%', '7D 5%']);
-  assert.equal(segments.some((segment) => /Credit|\$12\.34/.test(segment)), false);
-});
-
-test('formatGatewayLimitSegments falls back to percent for OpenAI OAuth credit windows', () => {
-  const segments = formatGatewayLimitSegments({
-    provider: 'openai-oauth',
-    providerKind: 'oauth',
-    quotaWindows: [
-      {
-        label: '5H',
-        source: 'openai-codex-oauth',
-        usedPct: 55,
-        remainingUsd: 4,
-        usedUsd: 6,
-        limitUsd: 10,
-        remainingCredits: 40,
-        usedCredits: 60,
-        limitCredits: 100,
-      },
-    ],
-  }, { COLS: 120 });
-
-  assert.deepEqual(segments, ['5H 55%']);
-});
-
-test('formatGatewayLimitSegments keeps non-OpenAI OAuth credit balance on L1', () => {
-  const segments = formatGatewayLimitSegments({
-    provider: 'anthropic-oauth',
-    providerKind: 'oauth',
-    source: 'anthropic-oauth',
-    quotaWindows: [
-      { label: '5H', source: 'anthropic-oauth', usedPct: 20 },
-    ],
-    balance: {
-      source: 'anthropic-oauth-extra',
-      remainingUsd: 7.5,
-    },
-  }, { COLS: 120 });
-
-  assert.ok(segments.includes('Credit $7.50'));
-});
-
-test('formatGatewayLimitSegments suppresses OpenAI OAuth credit via providerId even without a source hint', () => {
-  // Mirrors the merged quotaStatus shape (mergeQuotaStatus) where `source` may
-  // be absent and `balance.source` is generic: the providerId === openai-oauth
-  // branch alone must still suppress any Credit/$ leak on L1.
-  const segments = formatGatewayLimitSegments({
-    provider: 'openai-oauth',
-    providerKind: 'oauth',
-    quotaWindows: [
-      { label: '5H', source: 'openai-codex-oauth', usedPct: 30 },
-    ],
-    balance: {
-      remainingUsd: 99.99,
-    },
-  }, { COLS: 120 });
-
-  assert.deepEqual(segments, ['5H 30%']);
-  assert.equal(segments.some((segment) => /Credit|\$/.test(segment)), false);
-});