mixdog 0.9.63 → 0.9.64

package/scripts/streaming-tail-window-test.mjs

@@ -1,175 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  windowPlainStreamingText,
-} from '../src/tui/markdown/streaming-markdown.mjs';
-import {
-  measureStreamingMarkdownRenderedRows,
-  measureStreamingMarkdownRenderedRowsUncached,
-} from '../src/tui/markdown/measure-rendered-rows.mjs';
-import {
-  buildTranscriptRowIndex,
-  streamingRowEstimateStateForId,
-  streamingEstimateRows,
-  transcriptRenderWindow,
-} from '../src/tui/app/transcript-window.mjs';
-
-function assertCachedEqualsDirect(text, columns, key) {
-  const cached = measureStreamingMarkdownRenderedRows(text, columns, key);
-  const direct = measureStreamingMarkdownRenderedRowsUncached(text, columns, key);
-  assert.equal(cached, direct);
-  return cached;
-}
-
-test('bottom-pinned plain streaming text keeps only the visible suffix', () => {
-  const lines = Array.from({ length: 100 }, (_, index) => `plain line ${index}`);
-  const full = lines.join('\n');
-  const windowed = windowPlainStreamingText(full, 80, 12);
-
-  assert.equal(windowed, lines.slice(-12).join('\n'));
-  assert.ok(measureStreamingMarkdownRenderedRows(full, 83, 'plain-window-full') > 12);
-});
-
-test('markdown streaming text is never internally windowed', () => {
-  const markdown = `${'plain history\n'.repeat(100)}**live markdown**`;
-  assert.equal(windowPlainStreamingText(markdown, 80, 12), markdown.trim());
-});
-
-test('wrapped plain lines consume the streaming row budget', () => {
-  const lines = ['old', 'x'.repeat(160), 'new'];
-  assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 2), lines.slice(-1).join('\n'));
-  assert.equal(windowPlainStreamingText(lines.join('\n'), 80, 3), lines.slice(-2).join('\n'));
-});
-
-test('streaming row memo preserves plain append and resize measurements', () => {
-  const key = 'plain-row-memo';
-  const before = 'alpha\nbeta '.concat('x'.repeat(80));
-  const after = `${before}\ngamma ${'y'.repeat(120)}`;
-
-  assertCachedEqualsDirect(before, 40, key);
-  assertCachedEqualsDirect(after, 40, key);
-  assertCachedEqualsDirect(after, 24, key);
-});
-
-test('streaming row memo preserves markdown stable-prefix measurements', () => {
-  const key = 'markdown-row-memo';
-  const before = '# Heading\n\nSettled paragraph.\n\n**live';
-  const after = `${before} suffix**`;
-
-  assertCachedEqualsDirect(before, 48, key);
-  assertCachedEqualsDirect(after, 48, key);
-  assert.equal(
-    measureStreamingMarkdownRenderedRows(after, 48, key),
-    measureStreamingMarkdownRenderedRowsUncached(after, 48, key),
-  );
-});
-
-test('streaming row memo preserves fences, lists, and tables', () => {
-  const cases = [
-    ['fence', ['# Intro\n\n```js\nconst value = 1;', '# Intro\n\n```js\nconst value = 1;\nconsole.log(value);']],
-    ['list', ['- first item\n- second', '- first item\n- second item with wrapped detail '.repeat(3)]],
-    ['table', ['| A | B |\n| - | - |\n| one | two |', '| A | B |\n| - | - |\n| one | two |\n| three | four |']],
-  ];
-  for (const [name, values] of cases) {
-    for (const value of values) assertCachedEqualsDirect(value, 36, `shape-${name}`);
-  }
-});
-
-test('render-mode changes reset the streaming estimate high-water', () => {
-  const id = 'render-mode-flip';
-  streamingEstimateRows({
-    id,
-    kind: 'assistant',
-    streaming: false,
-    text: 'large settled markdown paragraph '.repeat(80),
-  }, 24, false);
-  const flipped = streamingEstimateRows({
-    id,
-    kind: 'assistant',
-    streaming: true,
-    text: 'short',
-  }, 24, false);
-  const fresh = streamingEstimateRows({
-    id: 'render-mode-fresh',
-    kind: 'assistant',
-    streaming: true,
-    text: 'short',
-  }, 24, false);
-  assert.equal(flipped, fresh);
-});
-
-test('stream estimate LRU evicts tail and high-water state in lockstep', () => {
-  const id = 'lru-evicted-stream';
-  streamingEstimateRows({
-    id,
-    kind: 'assistant',
-    streaming: true,
-    text: 'long streaming response '.repeat(80),
-  }, 24, false);
-  assert.deepEqual(streamingRowEstimateStateForId(id), {
-    tailEstimate: true,
-    highWater: true,
-  });
-
-  // Production cleanup when no measured-height layout effect runs: admitting
-  // eight newer stream ids evicts this oldest id from the bounded estimate LRU.
-  for (let index = 0; index < 8; index++) {
-    streamingEstimateRows({
-      id: `lru-newer-${index}`,
-      kind: 'assistant',
-      streaming: true,
-      text: `newer ${index}`,
-    }, 24, false);
-  }
-  assert.deepEqual(streamingRowEstimateStateForId(id), {
-    tailEstimate: false,
-    highWater: false,
-  });
-
-  // Reusing the evicted id must start from its new response, not retain the
-  // much taller high-water geometry from the aborted stream above.
-  const reused = streamingEstimateRows({
-    id,
-    kind: 'assistant',
-    streaming: true,
-    text: 'short',
-  }, 24, false);
-  const fresh = streamingEstimateRows({
-    id: 'lru-evicted-stream-fresh',
-    kind: 'assistant',
-    streaming: true,
-    text: 'short',
-  }, 24, false);
-  assert.equal(reused, fresh);
-});
-
-test('cached tail rows preserve rendered-window bytes', () => {
-  const items = Array.from({ length: 20 }, (_, index) => ({
-    id: `notice-${index}`,
-    kind: 'notice',
-    text: `notice ${index}`,
-  }));
-  const tail = {
-    id: 'window-byte-tail',
-    kind: 'assistant',
-    streaming: true,
-    text: '# Result\n\n- first\n- second\n\n| A | B |\n| - | - |\n| one | two |',
-  };
-  const allItems = [...items, tail];
-  const cachedIndex = buildTranscriptRowIndex(allItems, { columns: 36 });
-  const directTailRows = 1 + measureStreamingMarkdownRenderedRowsUncached(tail.text, 36, tail.id);
-  const directRows = [...cachedIndex.rows.slice(0, -1), directTailRows];
-  const directPrefix = [0];
-  for (const rows of directRows) directPrefix.push(directPrefix.at(-1) + rows);
-  const directIndex = {
-    rows: directRows,
-    prefixRows: directPrefix,
-    totalRows: directPrefix.at(-1),
-  };
-  const options = { scrollOffset: 4, viewportHeight: 8, columns: 36 };
-  assert.equal(
-    JSON.stringify(transcriptRenderWindow(allItems, { ...options, rowIndex: cachedIndex })),
-    JSON.stringify(transcriptRenderWindow(allItems, { ...options, rowIndex: directIndex })),
-  );
-});

package/scripts/submit-commandbusy-race-test.mjs

@@ -1,257 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { createSessionFlow } from '../src/tui/engine/session-flow.mjs';
-import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
-
-// Regression harness for prompt loss when a submit races an in-flight session
-// command (commandBusy) or an auto-clear. Wires the real session-flow queue
-// (enqueue/drain) + the real submit() against a minimal bag whose set() mirrors
-// engine.mjs's commandBusy-release drain kick.
-function makeEngine({
-  autoClearBeforeSubmit,
-  autoClearEnabled = false,
-  autoClearConfig = null,
-  sessionLastUsedAt = Date.now() - 1000,
-  contextStatus = null,
-  compactionSettings = {},
-  runtimeClear = async () => true,
-} = {}) {
-  let seq = 0;
-  const executed = [];
-  const providerRequests = [];
-  let resolveProviderDispatch;
-  const providerDispatch = new Promise((resolve) => { resolveProviderDispatch = resolve; });
-  let state = {
-    items: [{ kind: 'user', id: 'existing', text: 'existing prompt' }],
-    queued: [],
-    busy: false,
-    commandBusy: false,
-  };
-  const bag = {
-    runtime: {
-      id: 'session_1',
-      session: {
-        id: 'session_1',
-        messages: [{ role: 'user', content: 'existing prompt' }],
-        lastUsedAt: sessionLastUsedAt,
-      },
-      getCompactionSettings: () => compactionSettings,
-      contextStatus: () => contextStatus,
-      clear: runtimeClear,
-      consumePendingSessionReset: () => null,
-      ask: async (text) => {
-        providerRequests.push(text);
-        resolveProviderDispatch(text);
-        return { result: { content: 'ok' }, session: bag.runtime.session };
-      },
-    },
-    nextId: () => `id_${++seq}`,
-    tuiDebug: () => {},
-    flags: {},
-    pending: [],
-    listeners: new Set(),
-    pendingNotificationKeys: new Set(),
-    displayedExecutionNotificationKeys: new Set(),
-    clearToastTimers: () => {},
-    getState: () => state,
-    set: (patch) => {
-      if (!patch || typeof patch !== 'object') return false;
-      const released = state.commandBusy === true
-        && Object.prototype.hasOwnProperty.call(patch, 'commandBusy')
-        && patch.commandBusy === false;
-      state = { ...state, ...patch };
-      if (released) queueMicrotask(() => { void bag.drain?.(); });
-      return true;
-    },
-    pushItem: (item) => { state = { ...state, items: [...state.items, item] }; },
-    patchItem: () => {},
-    replaceItems: (x) => x,
-    pushNotice: () => {},
-    pushUserOrSyntheticItem: (text, id) => {
-      executed.push(text);
-      state = { ...state, items: [...state.items, { kind: 'user', id, text }] };
-    },
-    autoClearState: () => autoClearConfig || ({ enabled: autoClearEnabled, idleMs: 0, minContextPercent: 0 }),
-    agentStatusState: () => ({}),
-    routeState: () => ({}),
-    syncContextStats: () => {},
-    denyAllToolApprovals: () => {},
-    updateAgentJobCard: () => {},
-    requeueEntriesFront: () => {},
-    resetStatsAndSyncContext: () => {},
-    flushDeferredExecutionPendingResumeKick: () => {},
-    runTurn: async (text) => {
-      await bag.runtime.ask(text);
-      return 'ok';
-    },
-  };
-  Object.assign(bag, createSessionFlow(bag));
-  if (autoClearBeforeSubmit) bag.autoClearBeforeSubmit = autoClearBeforeSubmit;
-  const api = createEngineApiA(bag);
-  return {
-    api,
-    bag,
-    getExecuted: () => executed,
-    getProviderRequests: () => providerRequests,
-    waitForProviderDispatch: (timeoutMs = 250) => new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error(`provider dispatch timed out after ${timeoutMs}ms`)), timeoutMs);
-      providerDispatch.then((text) => {
-        clearTimeout(timer);
-        resolve(text);
-      }, reject);
-    }),
-    getState: () => bag.getState(),
-    mutateState: (mutator) => { mutator(state); },
-  };
-}
-
-const tick = () => new Promise((r) => setTimeout(r, 0));
-
-test('submit during commandBusy queues the prompt instead of dropping it', async () => {
-  const { api, bag, getExecuted } = makeEngine();
-  bag.set({ commandBusy: true });
-  const ok = api.submit('queued while busy');
-  assert.equal(ok, true, 'submit accepted (not dropped)');
-  assert.equal(bag.pending.length, 1, 'prompt preserved in queue');
-  await tick();
-  assert.equal(getExecuted().length, 0, 'drain bails while commandBusy');
-  bag.set({ commandBusy: false });
-  await tick(); await tick();
-  assert.deepEqual(getExecuted(), ['queued while busy'], 'prompt runs after command releases');
-  assert.equal(bag.pending.length, 0);
-});
-
-test('blocked drain retries even if commandBusy is cleared outside set hook', async () => {
-  const { api, bag, getExecuted, mutateState } = makeEngine();
-  bag.set({ commandBusy: true });
-  assert.equal(api.submit('queued until direct release'), true);
-  assert.equal(bag.pending.length, 1);
-  await tick();
-  assert.equal(getExecuted().length, 0);
-
-  mutateState((state) => { state.commandBusy = false; });
-  await new Promise((r) => setTimeout(r, 80));
-  assert.deepEqual(getExecuted(), ['queued until direct release']);
-  assert.equal(bag.pending.length, 0);
-});
-
-test('idle submit runs the prompt after autoClearBeforeSubmit resolves', async () => {
-  const { api, getExecuted, bag } = makeEngine();
-  const ok = api.submit('idle prompt');
-  assert.equal(ok, true);
-  await tick(); await tick();
-  assert.deepEqual(getExecuted(), ['idle prompt']);
-  assert.equal(bag.pending.length, 0);
-});
-
-test('submit still enqueues when autoClearBeforeSubmit rejects', async () => {
-  const { api, getExecuted } = makeEngine({
-    autoClearBeforeSubmit: () => Promise.reject(new Error('compaction timed out')),
-  });
-  const ok = api.submit('survives rejection');
-  assert.equal(ok, true);
-  await tick(); await tick();
-  assert.deepEqual(getExecuted(), ['survives rejection'], 'rejected auto-clear must not lose the prompt');
-});
-
-test('runtime clear false skips auto-clear and sends the first post-failure prompt to the provider', async () => {
-  const {
-    api, bag, getExecuted, getProviderRequests, getState,
-  } = makeEngine({ autoClearEnabled: true, runtimeClear: async () => false });
-
-  assert.equal(api.submit('first after failed auto-clear'), true);
-  await tick(); await tick();
-
-  assert.deepEqual(getExecuted(), ['first after failed auto-clear'], 'user card remains visible');
-  assert.deepEqual(getProviderRequests(), ['first after failed auto-clear'], 'first post-failure input reaches provider');
-  assert.equal(getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
-  assert.equal(getState().items.some((item) => item.label === 'Auto-clear complete'), false);
-  assert.equal(getState().items.some((item) => item.id === 'existing'), true, 'failed clear preserves the existing session UI');
-  assert.equal(bag.runtime.session.messages[0].content, 'existing prompt', 'failed clear preserves the runtime session');
-});
-
-test('idle submit compacts when a zero usedTokens field has a live estimate above the context gate', async () => {
-  const clearCalls = [];
-  const { api, getState } = makeEngine({
-    autoClearConfig: { enabled: true, idleMs: 60_000, minContextPercent: 10 },
-    sessionLastUsedAt: Date.now() - 120_000,
-    contextStatus: {
-      usedTokens: 0,
-      currentEstimatedTokens: 20,
-      compaction: { triggerTokens: 100 },
-    },
-    compactionSettings: { compactType: 'summary' },
-    runtimeClear: async (options) => {
-      clearCalls.push(options);
-      return true;
-    },
-  });
-
-  assert.equal(api.submit('after real idle'), true);
-  await tick(); await tick(); await tick();
-  assert.deepEqual(clearCalls, [{ compactType: 'summary', requireCompactSuccess: true }]);
-  assert.equal(getState().items.some((item) => item.label === 'Auto-clear complete'), true);
-});
-
-test('idle submit skips auto-clear when context gate operands are non-finite', async () => {
-  for (const contextStatus of [
-    { usedTokens: Infinity, compaction: { triggerTokens: 100 } },
-    { usedTokens: 20, compaction: { triggerTokens: Infinity } },
-  ]) {
-    const clearCalls = [];
-    const { api } = makeEngine({
-      autoClearConfig: { enabled: true, idleMs: 60_000, minContextPercent: 10 },
-      sessionLastUsedAt: Date.now() - 120_000,
-      contextStatus,
-      compactionSettings: { compactType: 'summary' },
-      runtimeClear: async (options) => {
-        clearCalls.push(options);
-        return true;
-      },
-    });
-    assert.equal(api.submit('after real idle'), true);
-    await tick(); await tick();
-    assert.deepEqual(clearCalls, []);
-  }
-});
-
-test('late runtime clear false keeps the UI skipped and sends the first post-timeout prompt', async () => {
-  let resolveClear;
-  let harness;
-  const autoClearBeforeSubmit = () => harness.bag.performSessionClear({
-    verb: 'Auto-clearing idle conversation',
-    doneLabel: 'Auto-clear complete',
-    skipLabel: 'Auto-clear skipped',
-    surface: 'auto-clear',
-    useCompaction: true,
-    compactTimeoutMs: 5,
-  });
-  harness = makeEngine({
-    autoClearBeforeSubmit,
-    runtimeClear: () => new Promise((resolve) => { resolveClear = resolve; }),
-  });
-  harness.bag.runtime.getCompactionSettings = () => ({ compactType: 'summary' });
-
-  assert.equal(harness.api.submit('first after timed-out auto-clear'), true);
-  await harness.waitForProviderDispatch();
-  assert.equal(typeof resolveClear, 'function', 'compacting clear started');
-  assert.deepEqual(
-    harness.getProviderRequests(),
-    ['first after timed-out auto-clear'],
-    'first post-timeout input reaches provider before late clear settles',
-  );
-
-  resolveClear(false);
-  await tick(); await tick();
-
-  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear skipped'), true);
-  assert.equal(harness.getState().items.some((item) => item.label === 'Auto-clear complete'), false);
-  assert.equal(harness.getState().items.some((item) => item.id === 'existing'), true, 'late false preserves the existing session UI');
-  assert.equal(harness.bag.runtime.session.messages[0].content, 'existing prompt', 'late false preserves the runtime session');
-});
-
-test('empty and whitespace submits are still rejected', () => {
-  const { api, bag } = makeEngine();
-  assert.equal(api.submit('   '), false);
-  assert.equal(bag.pending.length, 0);
-});

package/scripts/task-bench.mjs

@@ -1,205 +0,0 @@
-#!/usr/bin/env node
-// task-bench.mjs — quantify "how efficiently a task finished" and A/B compare.
-//
-// Thin wrapper over session-bench.mjs: it runs session-bench --json for a set
-// of sessions, compresses the result into a one-line SCORECARD (wall / turns /
-// tools / speed / context / cache / anti-patterns / completed), averages a
-// group, and diffs two groups (before vs after a rule/brief change).
-//
-// Usage:
-//   node scripts/task-bench.mjs --session <id[,id2,...]>          scorecard(s)
-//   node scripts/task-bench.mjs --session a,b,c --group           one averaged card
-//   node scripts/task-bench.mjs --vs before.json after.json       A/B diff
-//   node scripts/task-bench.mjs --session a,b --save before.json  freeze a group
-// Input is constant (finished sessions are immutable); only rules/briefs change
-// between the two frozen groups you compare.
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
-
-const __dir = dirname(fileURLToPath(import.meta.url));
-const SESSION_BENCH = resolve(__dir, 'session-bench.mjs');
-
-function argValue(name, fallback = null) {
-  const idx = process.argv.indexOf(name);
-  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
-  const pref = `${name}=`;
-  const hit = process.argv.find((a) => a.startsWith(pref));
-  return hit ? hit.slice(pref.length) : fallback;
-}
-function hasFlag(name) { return process.argv.includes(name); }
-function num(v) { const n = Number(v); return Number.isFinite(n) ? n : 0; }
-function uniq(items) {
-  return [...new Set((items || []).filter(Boolean))];
-}
-
-function runSessionBench(sessionId) {
-  // Returns the parsed session-bench JSON for one session id (BOM-safe).
-  const raw = execFileSync('node', [SESSION_BENCH, '--session', sessionId, '--json'], {
-    encoding: 'utf8', maxBuffer: 64 * 1024 * 1024,
-  });
-  const s = raw.replace(/^\uFEFF/, '');
-  const i = s.indexOf('{');
-  return JSON.parse(i >= 0 ? s.slice(i) : s);
-}
-
-// Compress a session-bench report into the scorecard metrics.
-function scorecard(report) {
-  const sum = report.summary || {};
-  const cache = report.cache || {};
-  const tools = report.tools || {};
-  const tr = report.time_range || {};
-  const route = Array.isArray(report.stages?.turns) ? report.stages.turns.find((t) => t?.model || t?.provider) : null;
-  const tokenSession = Array.isArray(report.tokens?.sessions) ? report.tokens.sessions[0] : null;
-  const issues = Array.isArray(report.issues) ? report.issues : [];
-  const antipatterns =
-    (tools.read_fragmentation?.length || 0) +
-    (tools.sequential_tool_clusters?.length || 0) +
-    (tools.duplicates?.length || 0) +
-    (tools.failed_repeats?.length || 0);
-  const turns = num(sum.turns);
-  const toolCalls = num(sum.tool_calls);
-  const promptTokens = num(cache.prompt_tokens);
-  const cachedTokens = num(cache.cached_tokens);
-  const uncachedTokens = tokenSession?.uncached_tokens != null
-    ? num(tokenSession.uncached_tokens)
-    : Math.max(0, promptTokens - cachedTokens);
-  const outputTokens = tokenSession
-    ? num(tokenSession.total_output) + num(tokenSession.total_thinking)
-    : 0;
-  // prompt growth = chronological last-first prompt from the per-session token
-  // summary. (growth_turns is sorted by prompt_delta desc — NOT chronological —
-  // so deriving growth from it produced garbage/negative values.)
-  const promptGrowth = tokenSession?.prompt_growth != null ? num(tokenSession.prompt_growth) : null;
-  return {
-    provider: route?.provider || null,
-    model: route?.model || null,
-    wall_ms: num(tr.span_ms),
-    turns,
-    tool_calls: toolCalls,
-    tools_per_turn: turns ? Math.round((toolCalls / turns) * 10) / 10 : 0,
-    total_tool_ms: num(sum.total_tool_ms),
-    llm_stream_ms: num(sum.llm_stream_ms),
-    cache_ratio: num(cache.usage_cache_ratio ?? sum.cache_ratio),
-    cached_tokens: cachedTokens,
-    prompt_tokens: promptTokens,
-    uncached_tokens: uncachedTokens,
-    output_tokens: outputTokens,
-    cache_weighted_input_10: Math.max(0, uncachedTokens + cachedTokens * 0.1),
-    cache_weighted_input_25: Math.max(0, uncachedTokens + cachedTokens * 0.25),
-    prompt_growth: promptGrowth,
-    antipatterns,
-    issues: issues.length,
-    issue_types: uniq(issues.map((i) => i?.type)),
-    read_fragmentation_paths: uniq((tools.read_fragmentation || []).map((f) => f?.path)),
-  };
-}
-
-function averageCards(cards) {
-  if (!cards.length) return null;
-  const keys = Object.keys(cards[0]).filter((k) => cards.some((c) => typeof c[k] === 'number' && Number.isFinite(c[k])));
-  const out = { n: cards.length };
-  for (const k of keys) {
-    const vals = cards.map((c) => num(c[k]));
-    out[k] = Math.round((vals.reduce((a, b) => a + b, 0) / vals.length) * 10) / 10;
-  }
-  return out;
-}
-
-function fmtMs(ms) { const n = num(ms); return n >= 1000 ? `${(n / 1000).toFixed(1)}s` : `${Math.round(n)}ms`; }
-function fmtTok(n) { const v = num(n); return v >= 1000 ? `${(v / 1000).toFixed(1)}k` : String(Math.round(v)); }
-function fmtPct(n) { return `${Math.round(num(n) * 100)}%`; }
-
-const CARD_ORDER = ['wall_ms', 'turns', 'tool_calls', 'tools_per_turn', 'cache_ratio', 'cache_weighted_input_10', 'prompt_growth', 'antipatterns', 'issues'];
-function fmtCardVal(k, v) {
-  if (v == null) return '-';
-  if (k === 'wall_ms' || k === 'total_tool_ms' || k === 'llm_stream_ms') return fmtMs(v);
-  if (k === 'cache_ratio') return fmtPct(v);
-  if (k === 'prompt_growth' || k === 'cache_weighted_input_10') return fmtTok(v);
-  return String(v);
-}
-function renderCard(label, card) {
-  const parts = CARD_ORDER.map((k) => `${k}=${fmtCardVal(k, card[k])}`);
-  return `${label}: ${parts.join('  ')}`;
-}
-
-function pctDelta(before, after) {
-  const b = num(before); const a = num(after);
-  if (b === 0) return a === 0 ? '0%' : 'n/a';
-  const d = Math.round(((a - b) / Math.abs(b)) * 100);
-  return `${d > 0 ? '+' : ''}${d}%`;
-}
-// For these metrics LOWER is better (efficiency); cache_ratio higher is better.
-const LOWER_BETTER = new Set(['wall_ms', 'turns', 'tool_calls', 'tools_per_turn', 'total_tool_ms', 'llm_stream_ms', 'prompt_growth', 'cache_weighted_input_10', 'cache_weighted_input_25', 'antipatterns', 'issues']);
-
-function renderDiff(before, after) {
-  const L = [];
-  L.push(`A/B compare  (before n=${before.n || 1}  after n=${after.n || 1})`);
-  for (const k of CARD_ORDER) {
-    const b = before[k]; const a = after[k];
-    const delta = pctDelta(b, a);
-    let verdict = '';
-    if (delta !== 'n/a' && delta !== '0%') {
-      const improved = LOWER_BETTER.has(k) ? num(a) < num(b) : num(a) > num(b);
-      verdict = improved ? ' ✓' : ' ✗';
-    }
-    L.push(`- ${k.padEnd(16)} ${fmtCardVal(k, b).padStart(9)} → ${fmtCardVal(k, a).padStart(9)}  ${delta.padStart(6)}${verdict}`);
-  }
-  return L.join('\n');
-}
-
-// ---- main ----
-const jsonMode = hasFlag('--json');
-const allowPartial = hasFlag('--allow-partial');
-const vs = argValue('--vs', null);
-
-if (vs) {
-  // --vs before.json after.json : diff two frozen group cards
-  const idx = process.argv.indexOf('--vs');
-  const beforePath = process.argv[idx + 1];
-  const afterPath = process.argv[idx + 2];
-  if (!beforePath || !afterPath) { console.error('usage: --vs <before.json> <after.json>'); process.exit(1); }
-  const before = JSON.parse(readFileSync(resolve(beforePath), 'utf8'));
-  const after = JSON.parse(readFileSync(resolve(afterPath), 'utf8'));
-  const b = before.group || before;
-  const a = after.group || after;
-  if (jsonMode) console.log(JSON.stringify({ before: b, after: a }, null, 2));
-  else console.log(renderDiff(b, a));
-  process.exit(0);
-}
-
-const sessionArg = argValue('--session', null);
-if (!sessionArg) { console.error('usage: --session <id[,id2,...]> [--group] [--save file.json] [--json] [--allow-partial]  |  --vs before.json after.json'); process.exit(1); }
-const ids = sessionArg.split(',').map((s) => s.trim()).filter(Boolean);
-const cards = [];
-const skipped = [];
-for (const id of ids) {
-  try { cards.push({ session: id, ...scorecard(runSessionBench(id)) }); }
-  catch (e) {
-    skipped.push({ session: id, error: e.message || String(e) });
-    console.error(`skip ${id}: ${e.message}`);
-  }
-}
-if (!cards.length) { console.error('no sessions scored'); process.exit(1); }
-if (skipped.length && !allowPartial) {
-  const partial = { error: `only scored ${cards.length}/${ids.length} sessions`, sessions: ids, skipped, cards, group: averageCards(cards.map(({ session, ...c }) => c)) };
-  if (jsonMode) console.log(JSON.stringify(partial, null, 2));
-  else console.error(partial.error);
-  process.exit(1);
-}
-
-const group = hasFlag('--group') || argValue('--save', null);
-const groupCard = averageCards(cards.map(({ session, ...c }) => c));
-const savePath = argValue('--save', null);
-if (savePath) {
-  writeFileSync(resolve(savePath), JSON.stringify({ sessions: ids, cards, skipped, group: groupCard }, null, 2));
-  console.error(`saved group (n=${cards.length}) → ${resolve(savePath)}`);
-}
-if (jsonMode) {
-  console.log(JSON.stringify({ cards, skipped, group: groupCard }, null, 2));
-} else if (group) {
-  console.log(renderCard(`group (n=${cards.length})`, groupCard));
-} else {
-  for (const c of cards) console.log(renderCard(c.session.slice(0, 22), c));
-}