mixdog 0.9.55 → 0.9.59

package/scripts/mouse-tracking-restore-smoke.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+/**
+ * Regression harness for the ctrl+wheel mouse-mode restore state machine.
+ *
+ * Run: node scripts/mouse-tracking-restore-smoke.mjs
+ */
+import {
+  cancelPendingMouseTrackingRestores,
+  createMouseTrackingRestoreScheduler,
+} from '../src/tui/app/use-mouse-input.mjs';
+
+const expected = '\x1b[?1000h\x1b[?1002h\x1b[?1006h\x1b[?1007l';
+const expectedPassthrough = '\x1b[?1006l\x1b[?1002l\x1b[?1000l\x1b[?1007l';
+let failures = 0;
+
+function check(name, condition) {
+  if (condition) console.log(`ok   - ${name}`);
+  else {
+    failures += 1;
+    console.log(`FAIL - ${name}`);
+  }
+}
+
+function fakeTimers() {
+  const entries = [];
+  return {
+    entries,
+    setTimeoutFn(fn, delay) {
+      const entry = { fn, delay, cleared: false, ran: false, unref() {} };
+      entries.push(entry);
+      return entry;
+    },
+    clearTimeoutFn(entry) {
+      entry.cleared = true;
+    },
+    runNext() {
+      const entry = entries.find((item) => !item.cleared && !item.ran);
+      if (!entry) return false;
+      entry.ran = true;
+      entry.fn();
+      return true;
+    },
+  };
+}
+
+function createHarness({ alwaysFail = false } = {}) {
+  const timers = fakeTimers();
+  const writes = [];
+  const stdout = {
+    write(value, callback) {
+      writes.push({ value, callback });
+      if (alwaysFail) callback(Object.assign(new Error('temporarily unavailable'), { code: 'EAGAIN' }));
+      return false; // backpressure alone is not failure
+    },
+  };
+  const scheduler = createMouseTrackingRestoreScheduler(stdout, timers);
+  scheduler.attach();
+  return { scheduler, timers, writes };
+}
+
+{
+  const { scheduler, timers, writes } = createHarness();
+  scheduler.schedule();
+  check('initial restore is delayed 700ms', timers.entries[0]?.delay === 700);
+  timers.runNext();
+  check('restore emits all mouse modes plus alternate-scroll off', writes[0]?.value === expected);
+  writes[0].callback(Object.assign(new Error('temporarily unavailable'), { code: 'EAGAIN' }));
+  check('async EAGAIN schedules a 200ms retry', timers.entries[1]?.delay === 200);
+  scheduler.detach();
+}
+
+{
+  const { scheduler, timers, writes } = createHarness({ alwaysFail: true });
+  scheduler.schedule();
+  while (timers.runNext()) { /* drain deterministic retries */ }
+  check('async failure is capped at five retries', writes.length === 6);
+  check('retry cap leaves no runnable timer', timers.runNext() === false);
+  scheduler.detach();
+}
+
+{
+  const { scheduler, timers, writes } = createHarness();
+  scheduler.schedule();
+  const staleTimer = timers.entries[0];
+  scheduler.schedule();
+  staleTimer.fn(); // simulate a callback already queued when clearTimeout ran
+  check('stale-generation restore callback is a no-op', writes.length === 0);
+  timers.runNext();
+  check('current generation still restores', writes.length === 1);
+  scheduler.detach();
+}
+
+{
+  const { scheduler, timers, writes } = createHarness();
+  scheduler.passthrough();
+  check('ctrl+wheel emits the guarded passthrough modes', writes[0]?.value === expectedPassthrough);
+  const queuedBeforeTerminalRestore = timers.entries[0];
+  cancelPendingMouseTrackingRestores();
+  queuedBeforeTerminalRestore.fn();
+  const writesAtRestore = writes.length;
+  scheduler.passthrough(); // late buffered ctrl+wheel after restoreTerminal()
+  check('late ctrl+wheel after terminal restore emits no mode bytes',
+    writes.length === writesAtRestore && timers.runNext() === false);
+}
+
+console.log(failures === 0 ? '\nALL PASS' : `\n${failures} FAILURE(S)`);
+process.exit(failures === 0 ? 0 : 1);

package/scripts/provider-admission-scheduler-test.mjs

@@ -4,6 +4,7 @@ import { execFileSync } from 'node:child_process';
 import {
     PROVIDER_ACCOUNT_CONCURRENCY,
     PROVIDER_ACCOUNT_MAX_QUEUE,
+    PROVIDER_COOLDOWN_FAIL_FAST_MS,
     ProviderAdmissionScheduler,
     notifyCurrentAnthropicRateLimit,
     providerAdmissionKey,
@@ -579,3 +580,102 @@ test('first-byte deadlines remain 60 seconds', () => {
     assert.equal(PROVIDER_WS_FIRST_MEANINGFUL_TIMEOUT_MS, 60_000);
     assert.equal(WS_PRE_RESPONSE_CREATED_MS, 60_000);
 });
+
+test('long quota cooldown fails fast with a visible error and reset unblocks the lane', async () => {
+    assert.equal(PROVIDER_COOLDOWN_FAIL_FAST_MS, 60_000);
+    let now = 50_000;
+    const timers = new Set();
+    const scheduler = new ProviderAdmissionScheduler({
+        concurrency: 2,
+        now: () => now,
+        setTimer(fn, delay) {
+            const timer = { fn, at: now + delay };
+            timers.add(timer);
+            return timer;
+        },
+        clearTimer(timer) { timers.delete(timer); },
+    });
+
+    const gate = deferred();
+    const trigger = deferred();
+    let queuedRan = false;
+    const running = scheduler.run('anthropic-oauth:acct', async () => {
+        await gate.promise;
+        return 'running-done';
+    });
+    // Second slot reports the quota-window 429 mid-flight once `trigger` fires,
+    // while the third request is already parked in the queue.
+    const second = scheduler.run('anthropic-oauth:acct', async () => {
+        await trigger.promise;
+        notifyCurrentAnthropicRateLimit(
+            Object.assign(new Error('quota window'), { httpStatus: 429, retryAfterMs: 3_600_000 }),
+        );
+        await gate.promise;
+        return 'second-done';
+    });
+    const queued = scheduler.run('anthropic-oauth:acct', async () => { queuedRan = true; });
+    await new Promise((r) => setImmediate(r));
+
+    // Quota-window 429 (hours-long Retry-After) lands mid-flight: the queued
+    // request must be rejected visibly, never parked until the window resets.
+    trigger.resolve();
+    await assert.rejects(queued, (error) => error?.code === 'EPROVIDERCOOLDOWN'
+        && /cooldown/i.test(error?.message)
+        && /retryAfter=(?:1h|59m|60m)/.test(error?.message));
+    assert.equal(queuedRan, false);
+
+    // New submissions fail fast while the long cooldown is active.
+    await assert.rejects(
+        scheduler.run('anthropic-oauth:acct', async () => 'blocked'),
+        (error) => error?.code === 'EPROVIDERCOOLDOWN' && error?.httpStatus === 429,
+    );
+
+    // Re-login / account switch resets the cooldown and restores the lane.
+    assert.equal(scheduler.resetCooldowns('anthropic-oauth'), 1);
+    const lane = scheduler.lanes.get('anthropic-oauth:acct');
+    assert.equal(lane.cooldownUntil, 0);
+    assert.equal(lane.limit, 2);
+
+    gate.resolve();
+    assert.equal(await running, 'running-done');
+    assert.equal(await second, 'second-done');
+    assert.equal(await scheduler.run('anthropic-oauth:acct', async () => 'unblocked'), 'unblocked');
+});
+
+test('short burst cooldown still parks the queue without failing turns', async () => {
+    let now = 10_000;
+    const timers = new Set();
+    const scheduler = new ProviderAdmissionScheduler({
+        concurrency: 1,
+        now: () => now,
+        setTimer(fn, delay) {
+            const timer = { fn, at: now + delay };
+            timers.add(timer);
+            return timer;
+        },
+        clearTimer(timer) { timers.delete(timer); },
+    });
+    const advance = async (ms) => {
+        now += ms;
+        for (const timer of [...timers]) {
+            if (timer.at <= now) {
+                timers.delete(timer);
+                timer.fn();
+            }
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+    };
+
+    await scheduler.run('anthropic-oauth:acct', async () => {
+        notifyCurrentAnthropicRateLimit(
+            Object.assign(new Error('burst'), { httpStatus: 429, retryAfterMs: 5_000 }),
+        );
+        return 'reporter';
+    }).catch(() => {});
+    let ran = false;
+    const parked = scheduler.run('anthropic-oauth:acct', async () => { ran = true; return 'parked-ok'; });
+    await new Promise((r) => setImmediate(r));
+    assert.equal(ran, false);
+    await advance(5_000);
+    assert.equal(await parked, 'parked-ok');
+});

package/scripts/provider-contract-test.mjs

@@ -32,6 +32,8 @@ import {
     billableInputTokensForProvider,
     isInclusiveProvider,
 } from '../src/runtime/shared/llm/cost.mjs';
+import { createProviderAuthApi } from '../src/session-runtime/provider-auth-api.mjs';
+import { createProviderUsage } from '../src/session-runtime/provider-usage.mjs';
 
 function stream(events) {
     return {
@@ -41,6 +43,53 @@ function stream(events) {
     };
 }
 
+test('provider setup refresh waits for keychain readiness and bypasses stale setup state', async () => {
+    const calls = [];
+    const api = createProviderAuthApi({
+        awaitKeychainPrewarm: async () => { calls.push('prewarm'); },
+        reloadFullConfig: () => { calls.push('reload'); },
+        cachedProviderSetup: async (options) => {
+            calls.push(['setup', options]);
+            return { generation: 2 };
+        },
+    });
+
+    assert.deepEqual(await api.getProviderSetup({ refresh: true }), { generation: 2 });
+    assert.deepEqual(calls, ['prewarm', 'reload', ['setup', { force: true }]]);
+});
+
+test('forced provider setup waits for an in-flight snapshot and then rebuilds it', async () => {
+    let releaseFirst;
+    let builds = 0;
+    const usage = createProviderUsage({
+        caches: {
+            providerSetupCache: {},
+            providerSetupQuickCache: {},
+            providerSetupPromise: null,
+        },
+        displayConfig: () => ({}),
+        providerSetup: async () => {
+            builds += 1;
+            if (builds === 1) await new Promise((resolve) => { releaseFirst = resolve; });
+            return { generation: builds };
+        },
+        getReg: () => new Map(),
+        getConfig: () => ({}),
+        getProviderSetupWarmupTimer: () => null,
+        scheduleProviderSetupWarmup() {},
+        isCloseRequested: () => false,
+    });
+
+    const initial = usage.cachedProviderSetup();
+    await Promise.resolve();
+    const refreshed = usage.cachedProviderSetup({ force: true });
+    releaseFirst();
+
+    assert.deepEqual(await initial, { generation: 1 });
+    assert.deepEqual(await refreshed, { generation: 2 });
+    assert.equal(builds, 2);
+});
+
 test('current vendor preset defaults and OpenCode Go protocol routes are pinned', () => {
     assert.equal(OPENAI_COMPAT_PRESETS.xai.defaultModel, 'grok-4.5');
     assert.equal(OPENAI_COMPAT_PRESETS.deepseek.defaultModel, 'deepseek-v4-pro');

package/scripts/resource-admission-test.mjs

@@ -464,8 +464,11 @@ test('abort during adoption detaches once, resolves once, and releases once', as
     configurable: true,
     get() {
       abortedReads += 1;
-      if (abortedReads === 2) controller.abort(new Error('cancelled during adoption'));
-      return abortedReads >= 2;
+      // Read #1: the bounded admission-wait wrapper (_acquireShellLeaseBounded).
+      // Read #2: the pre-spawn abort check. Read #3: the _autoBackground
+      // adoption re-check — the abort must land exactly there.
+      if (abortedReads === 3) controller.abort(new Error('cancelled during adoption'));
+      return abortedReads >= 3;
     },
   });
   let detachCalls = 0;

package/scripts/session-ingest-compaction-smoke.mjs

@@ -238,4 +238,42 @@ function refsFor(messages, opts) {
   assert(rdb.rows.length === rowsBefore, 'RESTART+drop: no duplicate rows created')
 }
 
+// ── WARM runtime + JSON-cloned replay (desktop/session resume) ───────────────
+// The memory daemon can outlive a surface that reloads the same session JSON.
+// Every transcript message is then a new object while the ingest runtime's
+// WeakMaps remain warm. The replay must reuse prior source_refs, and only a
+// genuinely appended suffix may insert.
+{
+  const rdb = createFakeDb()
+  const S = 'warm-json-clone-sess'
+  const rt = makeRuntime(rdb)
+  const original = [
+    mk('user', 'optimize session switching'),
+    mk('assistant', 'I will inspect the transition path'),
+    mk('user', 'go ahead'),
+    mk('assistant', 'working'),
+  ]
+  await rt.ingestSessionMessages({ sessionId: S, messages: original, limit: 5000 })
+  const beforeReplay = rdb.rows.length
+
+  const clonedReplay = JSON.parse(JSON.stringify(original))
+  await rt.ingestSessionMessages({ sessionId: S, messages: clonedReplay, limit: 5000 })
+  assert(
+    rdb.rows.length === beforeReplay,
+    `WARM CLONE: JSON-reloaded transcript must insert 0 duplicates (before=${beforeReplay} after=${rdb.rows.length})`,
+  )
+
+  // Reload the whole array again and append text identical to an older row.
+  // Snapshot reconciliation reuses the cloned prefix while the suffix consumes
+  // the historical occurrence high-water.
+  const clonedWithAppend = JSON.parse(JSON.stringify(original))
+  clonedWithAppend.push(mk('assistant', 'working'))
+  await rt.ingestSessionMessages({ sessionId: S, messages: clonedWithAppend, limit: 5000 })
+  assert(rdb.rows.length === beforeReplay + 1, 'WARM CLONE: exactly one genuinely appended row must insert')
+
+  const clonedAgain = JSON.parse(JSON.stringify(clonedWithAppend))
+  await rt.ingestSessionMessages({ sessionId: S, messages: clonedAgain, limit: 5000 })
+  assert(rdb.rows.length === beforeReplay + 1, 'WARM CLONE: replay after append must remain idempotent')
+}
+
 process.stdout.write('session ingest compaction-append smoke passed \u2713\n')

package/scripts/steering-drain-buckets-test.mjs

@@ -122,6 +122,21 @@ test('post-turn drain does not send queued slash command to model', async () =>
   assert.equal(bag.pending[0].content, '/clear');
 });
 
+test('restoreQueued can edit one visible steering entry without draining its siblings', () => {
+  const { flow, bag } = makeFlow();
+  const first = flow.makeQueueEntry('first follow-up', { mode: 'prompt' });
+  const second = flow.makeQueueEntry('second follow-up', { mode: 'prompt' });
+  bag.pending.push(first, second);
+  bag.getState().queued = [first, second];
+
+  const restored = flow.restoreQueued('current draft', second.id);
+
+  assert.equal(restored.count, 1);
+  assert.equal(restored.text, 'second follow-up\ncurrent draft');
+  assert.deepEqual(bag.pending.map((entry) => entry.id), [first.id]);
+  assert.deepEqual(bag.getState().queued.map((entry) => entry.id), [first.id]);
+});
+
 // Minimal store bag for createRunTurn: only the surface the streaming/steering
 // finalize path touches. runtime.ask is a caller-supplied mock that drives the
 // text-delta / steer-message callbacks.

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

@@ -10,6 +10,10 @@ import { createEngineApiA } from '../src/tui/engine/session-api.mjs';
 function makeEngine({
   autoClearBeforeSubmit,
   autoClearEnabled = false,
+  autoClearConfig = null,
+  sessionLastUsedAt = Date.now() - 1000,
+  contextStatus = null,
+  compactionSettings = {},
   runtimeClear = async () => true,
 } = {}) {
   let seq = 0;
@@ -29,9 +33,10 @@ function makeEngine({
       session: {
         id: 'session_1',
         messages: [{ role: 'user', content: 'existing prompt' }],
-        lastUsedAt: Date.now() - 1000,
+        lastUsedAt: sessionLastUsedAt,
       },
-      getCompactionSettings: () => ({}),
+      getCompactionSettings: () => compactionSettings,
+      contextStatus: () => contextStatus,
       clear: runtimeClear,
       consumePendingSessionReset: () => null,
       ask: async (text) => {
@@ -47,6 +52,7 @@ function makeEngine({
     listeners: new Set(),
     pendingNotificationKeys: new Set(),
     displayedExecutionNotificationKeys: new Set(),
+    clearToastTimers: () => {},
     getState: () => state,
     set: (patch) => {
       if (!patch || typeof patch !== 'object') return false;
@@ -65,7 +71,7 @@ function makeEngine({
       executed.push(text);
       state = { ...state, items: [...state.items, { kind: 'user', id, text }] };
     },
-    autoClearState: () => ({ enabled: autoClearEnabled, idleMs: 0, minContextPercent: 0 }),
+    autoClearState: () => autoClearConfig || ({ enabled: autoClearEnabled, idleMs: 0, minContextPercent: 0 }),
     agentStatusState: () => ({}),
     routeState: () => ({}),
     syncContextStats: () => {},
@@ -164,6 +170,51 @@ test('runtime clear false skips auto-clear and sends the first post-failure prom
   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;

package/scripts/tool-smoke.mjs

@@ -185,9 +185,8 @@ function assertOk(name, result, pattern = null) {
 {
   const publicStrategy = resolveCacheStrategy('worker');
   assert(publicStrategy.tools === 'none', `Anthropic tools must not spend a cache_control BP: ${JSON.stringify(publicStrategy)}`);
-  // BP1~3 stay 1h (pool-stable prefix); volatile message tail is 5m for all
-  // sessions — see resolveCacheStrategy docs (trace p99 gap ≈ 4.5min).
-  assert(publicStrategy.system === '1h' && publicStrategy.tier3 === '1h' && publicStrategy.messages === '5m', `public cache tiers changed unexpectedly: ${JSON.stringify(publicStrategy)}`);
+  // BP1~3 and the volatile message tail stay 1h; see resolveCacheStrategy.
+  assert(publicStrategy.system === '1h' && publicStrategy.tier3 === '1h' && publicStrategy.messages === '1h', `public cache tiers changed unexpectedly: ${JSON.stringify(publicStrategy)}`);
   assert(cacheCapabilityForProvider('anthropic-oauth') === 'explicit-breakpoint', 'Anthropic OAuth should remain explicit-breakpoint');
   assert(cacheCapabilityForProvider('openai-oauth') === 'key-prefix', 'OpenAI OAuth should remain key-prefix');
   assert(cacheCapabilityForProvider('xai') === 'key-prefix', 'xAI should remain key-prefix');

package/scripts/tui-ambiguous-width-test.mjs

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import sliceAnsi from 'slice-ansi';
+import stringWidth from 'string-width';
+
+// Make the Windows Terminal policy deterministic on every test host. Dynamic
+// imports matter because both policy copies resolve the gate once at load.
+process.env.MIXDOG_TUI_AMBIGUOUS_WIDE = '1';
+
+const [{ displayStringWidth }, {
+  default: wrapText,
+  sliceTextByDisplayWidth,
+  sliceTextByDisplayWidthWithPolicy,
+}, { default: Output }] = await Promise.all([
+  import('../vendor/ink/build/display-width.js'),
+  import('../vendor/ink/build/wrap-text.js'),
+  import('../vendor/ink/build/output.js'),
+]);
+
+const BODY = '①첫째 ②둘째 ③셋째 한국어 본문 텍스트가 이어집니다';
+
+test('Windows Terminal wide glyph wrapping keeps every transcript body line in budget', () => {
+  const budget = 12;
+  const lines = wrapText(BODY, budget, 'wrap').split('\n');
+  assert.ok(lines.length > 1, 'harness input must wrap');
+  for (const line of lines) {
+    assert.ok(
+      displayStringWidth(line) <= budget,
+      `${JSON.stringify(line)} is ${displayStringWidth(line)} cells (budget ${budget})`,
+    );
+  }
+});
+
+test('Output materializes the reserved cell after a policy-widened glyph', () => {
+  const text = '②{ M }';
+  assert.equal(stringWidth(text), 6, 'plain/native cursor advance is the broken 1-cell baseline');
+  assert.equal(displayStringWidth(text), 7, 'Ink layout reserves two cells for ②');
+
+  const output = new Output({ width: 20, height: 1 });
+  output.write(0, 0, text, { transformers: [] });
+  const rendered = output.get().output;
+
+  assert.equal(rendered, '② { M }', 'serialized bytes must advance over the reserved cell');
+  assert.equal(stringWidth(rendered), 7, 'emitted terminal cursor width matches the 7-cell layout');
+
+  const excluded = new Output({ width: 20, height: 1 });
+  excluded.write(0, 0, '└A ←B ↻C', { transformers: [] });
+  assert.equal(excluded.get().output, '└A ←B ↻C', 'box/figure glyphs must not gain padding');
+});
+
+test('horizontal output clipping uses the wide-glyph display columns', () => {
+  const budget = 12;
+  const output = new Output({ width: 40, height: 1 });
+  output.clip({ x1: 0, x2: budget });
+  output.write(0, 0, BODY, { transformers: [] });
+  output.unclip();
+
+  const rendered = output.get().output;
+  assert.ok(
+    stringWidth(rendered) <= budget,
+    `${JSON.stringify(rendered)} escaped clip at ${stringWidth(rendered)} emitted cells`,
+  );
+});
+
+test('left-edge clipping drops a glyph intersected by x1 and keeps mixed Korean text aligned', () => {
+  const output = new Output({ width: 40, height: 1 });
+  output.clip({ x1: 3, x2: 15 });
+  output.write(0, 0, '가①나②다③ 한국어', { transformers: [] });
+  output.unclip();
+
+  const rendered = output.get().output;
+  assert.ok(rendered.startsWith('   나'), JSON.stringify(rendered));
+  assert.ok(stringWidth(rendered) <= 15);
+});
+
+test('one-cell clip drops a two-cell circled digit instead of crossing x2', () => {
+  const output = new Output({ width: 10, height: 1 });
+  output.clip({ x1: 0, x2: 1 });
+  output.write(0, 0, '①A', { transformers: [] });
+  output.unclip();
+
+  const rendered = output.get().output;
+  assert.equal(rendered, '');
+  assert.ok(displayStringWidth(rendered) <= 1);
+});
+
+test('policy-off and no-problem slices preserve upstream slice-ansi bytes', () => {
+  const styledProblem = '\x1b[31m①AB\x1b[39m';
+  assert.equal(
+    sliceTextByDisplayWidthWithPolicy(styledProblem, 0, 2, false),
+    sliceAnsi(styledProblem, 0, 2),
+  );
+
+  const styledPlain = '\x1b[31mplain\x1b[39m';
+  assert.equal(
+    sliceTextByDisplayWidth(styledPlain, 1, 4),
+    sliceAnsi(styledPlain, 1, 4),
+  );
+
+  const excludedArrows = '\x1b[36m←↑→↓ ↻ tail\x1b[39m';
+  assert.equal(
+    sliceTextByDisplayWidth(excludedArrows, 1, 7),
+    sliceAnsi(excludedArrows, 1, 7),
+  );
+});
+
+test('left clipping re-opens parameterized OSC 8 hyperlinks', () => {
+  const open = '\x1b]8;id=x;https://example.test\x07';
+  const linked = `${open}가①나\x1b]8;;\x07`;
+  const sliced = sliceTextByDisplayWidth(linked, 2, 6);
+  assert.ok(sliced.startsWith(open), JSON.stringify(sliced));
+  assert.match(sliced, /①나/);
+});

package/scripts/tui-runtime-load-bench.mjs

@@ -9,6 +9,11 @@ import { rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+// Match the production CLI (src/cli.mjs defaults NODE_ENV to production):
+// otherwise the bench measures react-reconciler's dev-build overhead that
+// real runs no longer pay.
+process.env.NODE_ENV ||= 'production';
+
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const entry = join(ROOT, 'scripts', 'tui-runtime-load-bench-entry.jsx');
 const outfile = join(ROOT, 'scripts', '.tui-runtime-load-bench.tmp.mjs');