@semalt-ai/code 1.19.0 → 1.20.0

package/test/replay-web-persist.test.js

@@ -0,0 +1,241 @@
+'use strict';
+
+// Output Refactor — Phase 6c-i: persist web-op cores, with ZERO visible change.
+//
+// Web tools (web_search/http_get) are intercepted in chat-turn.js BEFORE they
+// become a normal ToolOperation descriptor (they collapse into the live web
+// summary). Before 6c-i the interception returned `undefined`, so the agent
+// loop's `displayCore || null` push stored a `null` slot and the web op fell to
+// the legacy whole-blob / summarizeToolResult fallback on replay. 6c-i makes the
+// interception return a dedicated web-op core `{v:1,kind:'web',…}` that the slot
+// now carries on BOTH rails — while every replay reader is taught to treat a
+// web-core as "no descriptor → fallback". Net contract: replay output is
+// BYTE-IDENTICAL to today. Aggregation lands in 6c-ii, not here.
+//
+// These tests pin:
+//   1. POSITIVE — serializeWebOp sources fields from ctx; the core lands in the
+//      slot on the native {role:'tool'} message AND the XML `_display[]` array.
+//   2. 6c-ii FLIP (headline) — replay of a native web message and of an XML blob
+//      containing a web op now AGGREGATES the web-core(s) into the committed
+//      `✓ web · …` summary, byte-identical to the live committed line. (These were
+//      6c-i "no-op replay" cases; 6c-ii deliberately makes web activity visible on
+//      replay. Persistence/shape/inv.1/live-tracker pins below are unchanged.)
+//   3. INV.1 — `content` byte-identical; the web-core is never folded into content.
+//   4. ANTI-PING-PONG — fresh live web display unchanged; 6a/6b normal-tool parity
+//      and Phase 1 fresh-render still byte-identical.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+// Force a colour-capable env so byte comparisons are stable (node:test runs each
+// file in its own process — no leak to other suites). Mirrors the 6a/6b suites.
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+
+const { buildToolOperation, serializeOperation, descriptorFromStored } = require('../lib/ui/tool-operation');
+const { renderOperation } = require('../lib/ui/render-operation');
+const { ChatHistory } = require('../lib/ui/chat-history');
+const { createChatSession } = require('../lib/commands/chat-session');
+const {
+  serializeWebOp,
+  isWebCore,
+  aggregateWebOps,
+  webSummaryText,
+  createWebActivityTracker,
+} = require('../lib/ui/web-activity');
+
+const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+const CFG = { diff_max_lines: 50, shell_preview_lines: 5 };
+
+// A normal (non-web) fixture used to prove a MIXED blob (normal + web) still
+// drops to the whole-blob summary — i.e. the gate fails on the web slot.
+const EDIT_DIFF = buildToolOperation({
+  id: 'tool-1', tag: 'edit_file', arg: 'lib/x.js', attrs: { path: 'lib/x.js' },
+  status: 'ok', durationMs: 12, diff: { before: 'a\nb\nc\n', after: 'a\nB\nc\n', path: 'lib/x.js' },
+});
+
+// Tool ctx objects exactly as onToolEnd receives them: { attrs, meta, error }.
+// web_search with a query + a 200/bytes meta; http_get error case with a url and
+// a transport error (no status/bytes).
+const SEARCH_CTX = { attrs: { query: 'коррупционные скандалы 2024' }, meta: { status_code: 200, bytes: 4096 }, error: null };
+const FETCH_ERR_CTX = { attrs: { url: 'https://example.com/blocked' }, meta: null, error: { message: 'Request timeout' } };
+
+// ── Faithful models of the agent.js per-rail persistence of onToolEnd's return.
+// Native: _nativeToolMessage attaches `_display` only when truthy (agent.js:352-355),
+// receiving the already-`|| null`-ed slot. XML: messages.push({…, _display:
+// displayCores.slice()}) with each slot = `displayCore || null` (agent.js:1959-1963).
+function nativeToolMsg(content, core) {
+  const slot = core || null;            // the agent loop's `displayCore || null` push
+  const msg = { role: 'tool', content };
+  if (slot) msg._display = slot;        // _nativeToolMessage: attach only when truthy
+  return msg;
+}
+function xmlBlob(results, cores) {
+  const m = {
+    role: 'user',
+    content: `Tool execution results:\n\n${results.join('\n\n')}\n\nContinue with the task. If everything is done, summarize what was accomplished.`,
+  };
+  if (cores !== undefined) m._display = cores.map((c) => c || null); // `displayCore || null` per slot
+  return m;
+}
+
+// Drive the REAL replay (chat-session.displayLoadedMessages) over one loaded
+// message and capture exactly what is committed to scrollback.
+function replay(loadedMessage, cfg) {
+  const ch = new ChatHistory();
+  const out = [];
+  ch._commit = (t) => out.push(t);
+  const session = createChatSession({ chatHistory: ch, getConfig: () => cfg || CFG });
+  session.displayLoadedMessages([loadedMessage]);
+  return out.join('');
+}
+
+// ───────────────────────────────────────────────────────────────────────────
+// 1. POSITIVE — serializeWebOp sources fields from ctx, and the core lands in the
+//    slot on BOTH rails (guards web-op persistence on native + XML).
+// ───────────────────────────────────────────────────────────────────────────
+test('serializeWebOp: sources query/status/bytes (search) and url/error (fetch) from ctx, flat for aggregateWebOps (guards core shape)', () => {
+  const search = serializeWebOp(SEARCH_CTX, 'web_search', 300);
+  assert.deepStrictEqual(search, {
+    v: 1, kind: 'web', tag: 'web_search',
+    query: 'коррупционные скандалы 2024', url: undefined,
+    status: 200, bytes: 4096, error: undefined, durationMs: 300,
+  });
+  const fetch = serializeWebOp(FETCH_ERR_CTX, 'http_get', 50);
+  assert.deepStrictEqual(fetch, {
+    v: 1, kind: 'web', tag: 'http_get',
+    query: undefined, url: 'https://example.com/blocked',
+    status: undefined, bytes: undefined, error: 'Request timeout', durationMs: 50,
+  });
+  // The flat fields are exactly what aggregateWebOps reads (so 6c-ii can feed
+  // these cores directly): 1 search query, and the errored fetch shows as blocked.
+  const text = webSummaryText(aggregateWebOps([search, fetch]));
+  assert.match(text, /search "коррупционные/);
+  assert.match(text, /0 sources read/);
+  assert.match(text, /1 blocked/);
+  // Both are recognized as web-cores; a normal descriptor core is NOT.
+  assert.ok(isWebCore(search) && isWebCore(fetch), 'web-cores recognized');
+  assert.ok(!isWebCore(serializeOperation(EDIT_DIFF)), 'a normal descriptor core is not a web-core');
+});
+
+test('persistence: the web-op core lands in the slot on the native {role:tool} message AND the XML _display[] array (guards both rails)', () => {
+  const core = serializeWebOp(SEARCH_CTX, 'web_search', 300);
+  // Native: truthy core → attached verbatim as `_display`.
+  const native = nativeToolMsg('web search "…" (5 results)', core);
+  assert.deepStrictEqual(native._display, core, 'native {role:tool}._display carries the web-core');
+  // XML: the slot that used to be `null` now holds the web-core.
+  const blob = xmlBlob(['edited lib/x.js', 'fetched'], [serializeOperation(EDIT_DIFF), core]);
+  assert.deepStrictEqual(blob._display[1], core, 'XML _display[] slot carries the web-core (no longer null)');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 2. 6c-ii FLIP (headline visible change) — replay now AGGREGATES web-cores into
+//    the committed `✓ web · …` summary instead of the legacy fallback. These two
+//    were the 6c-i "no-op replay" cases; 6c-ii deliberately makes them visible.
+//    Full oracle-parity coverage (interleaving, cross-iteration, both rails) lives
+//    in test/replay-web-aggregate.test.js — these pin the persist-file's own rails.
+// ───────────────────────────────────────────────────────────────────────────
+
+// Drive the live tracker over a single op and return its committed summary line —
+// the byte-exact oracle a replayed web summary must reproduce.
+function liveOracle(tag, input, ctx, durationMs) {
+  const frames = [];
+  const tracker = createWebActivityTracker({ writerModule: {
+    startActivity: () => {}, updateActivity: () => {},
+    endActivity: (_id, line) => frames.push(line),
+  } });
+  tracker.start(tag, input);
+  tracker.end(tag, 'done', durationMs, ctx);
+  tracker.flush();
+  return frames[frames.length - 1];
+}
+
+test('6c-ii: a native web {role:tool} message now replays as the aggregated web summary, byte-identical to live (flip of 6c-i invisibility)', () => {
+  const core = serializeWebOp(FETCH_ERR_CTX, 'http_get', 120);
+  const oracle = liveOracle('http_get', 'https://example.com/blocked', FETCH_ERR_CTX, 120);
+  const committed = replay(nativeToolMsg('web · GET https://example.com\n<page body…>', core));
+  assert.strictEqual(committed, oracle, 'native web message replays as the aggregated summary, byte-identical to the live committed line');
+  // Not vacuous, and it IS the aggregated web summary (not the legacy fallback).
+  assert.match(stripAnsi(committed), /web/);
+  assert.match(stripAnsi(committed), /1 blocked/);
+});
+
+test('6c-ii: an XML blob mixing a normal slot + a web-op slot now renders the normal op per-slot AND aggregates the web op below it (gate passes)', () => {
+  const core = serializeWebOp(SEARCH_CTX, 'web_search', 300);
+  const results = ['edited lib/x.js', 'web search results…'];
+  // The normal slot alone replays per-slot (6b path) — same render the mixed blob
+  // must reproduce for its non-web slot.
+  const editOnly = replay(xmlBlob(results, [serializeOperation(EDIT_DIFF)]));
+  const webOracle = liveOracle('web_search', SEARCH_CTX.attrs.query, SEARCH_CTX, 300);
+  const mixed = replay(xmlBlob(results, [serializeOperation(EDIT_DIFF), core]));
+  assert.strictEqual(mixed, editOnly + webOracle, 'normal slot renders per-slot; the web slot aggregates into the summary committed below it');
+  // The non-web slot IS now rendered individually (its diff body appears) — the
+  // 6c-i whole-blob fallback no longer applies once every slot is a valid core.
+  const diffBody = renderOperation(descriptorFromStored(serializeOperation(EDIT_DIFF)), { mode: 'ansi', phase: 'detail', maxLines: 50 });
+  assert.ok(diffBody.length > 0 && mixed.includes(diffBody), 'the non-web slot is rendered per-slot (no whole-blob fallback)');
+  // And the web op is no longer hidden: its summary is visible.
+  assert.match(stripAnsi(mixed), /web/);
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 3. INV.1 — `content` is byte-identical; the web-core never enters `content`.
+// ───────────────────────────────────────────────────────────────────────────
+test('inv.1: attaching the web-core leaves the XML feedback content byte-identical and out of the model-facing string (guards the chokepoint)', () => {
+  const core = serializeWebOp(SEARCH_CTX, 'web_search', 300);
+  const results = ['edited lib/x.js', 'web search results…'];
+  const expectedContent = `Tool execution results:\n\n${results.join('\n\n')}\n\nContinue with the task. If everything is done, summarize what was accomplished.`;
+  const blob = xmlBlob(results, [serializeOperation(EDIT_DIFF), core]);
+  assert.strictEqual(blob.content, expectedContent, 'content equals the results.join-wrapped string, byte-for-byte');
+  assert.ok(!blob.content.includes('kind'), 'no web-core framing leaked into content');
+  assert.ok(!blob.content.includes('коррупционные'), 'the query lives only in the core, not content');
+  // Native rail: the web-core is a sibling key, never inside `content`.
+  const native = nativeToolMsg('body', core);
+  assert.ok(!native.content.includes('kind') && !native.content.includes('web'), 'native content carries no core framing');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// 4. ANTI-PING-PONG — live web display unchanged; 6a/6b + Phase 1 still identical.
+// ───────────────────────────────────────────────────────────────────────────
+test('anti-ping-pong: the live web tracker render is unchanged — nothing in the live path reads serializeWebOp\'s return (guards live region)', () => {
+  // A fake writer captures exactly what the live tracker renders.
+  const frames = [];
+  const writerModule = {
+    startActivity: (_id, fn) => frames.push(stripAnsi(fn(0))),
+    updateActivity: (_id, fn) => frames.push(stripAnsi(fn(0))),
+    endActivity: (_id, line) => frames.push(stripAnsi(line)),
+  };
+  const tracker = createWebActivityTracker({ writerModule });
+  tracker.start('web_search', 'коррупционные скандалы 2024');
+  tracker.end('web_search', 'ok', 300, SEARCH_CTX);
+  // The interception ALSO calls serializeWebOp — assert calling it does not alter
+  // what the tracker subsequently renders (the return value is persistence-only).
+  serializeWebOp(SEARCH_CTX, 'web_search', 300);
+  tracker.flush();
+  const committed = frames[frames.length - 1];
+  assert.match(committed, /web/);
+  assert.match(committed, /search/);
+  // The committed line is exactly the tracker's own summary — untouched by 6c-i.
+  assert.strictEqual(committed, stripAnsi(require('../lib/ui/web-activity').formatWebSummaryLine(aggregateWebOps([
+    { tag: 'web_search', query: 'коррупционные скандалы 2024', status: 200, bytes: 4096 },
+  ]), { pending: false })));
+});
+
+test('anti-ping-pong: native (6a) normal-tool round-trip and Phase 1 fresh-render bytes unchanged (guards no regression)', () => {
+  // 6a: a normal descriptor still round-trips byte-identical (the web guard does
+  // not touch the non-web path).
+  const restored = descriptorFromStored(serializeOperation(EDIT_DIFF));
+  assert.strictEqual(
+    renderOperation(restored, { mode: 'ansi' }),
+    renderOperation(EDIT_DIFF, { mode: 'ansi' }),
+    'native rail result line round-trips byte-identical',
+  );
+  // Phase 1: the canonical fresh shell line bytes are pinned (same oracle as 6b).
+  const shellOk = renderOperation(
+    buildToolOperation({ status: 'success', tag: 'shell', arg: 'npm install', attrs: { command: 'npm install' }, durationMs: 2300, meta: { exit_code: 0 } }),
+    { mode: 'ansi', phase: 'result' },
+  );
+  assert.strictEqual(
+    shellOk,
+    '  \x1b[38;5;40m✓\x1b[0m \x1b[38;5;214mshell\x1b[0m \x1b[2m·\x1b[0m \x1b[38;5;214mnpm install\x1b[0m \x1b[2m·\x1b[0m \x1b[38;5;244m2.3s\x1b[0m \x1b[2m·\x1b[0m \x1b[38;5;244mexit 0\x1b[0m',
+  );
+});

package/test/running-glyph-anim.test.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// Animated running op row (Output Refactor — Phase 3, Part 2).
+//
+// Before Phase 3 a running tool's glyph was a static dot (●, colored after
+// Phase 2.5 but not moving) and the elapsed meter only advanced as a side
+// effect of the status-bar timers firing. Phase 3 animates the running glyph:
+// the `tool` SPINNER_DEF frames in the category-tinted pending colour, with the
+// frame derived from the elapsed duration so it advances every ~100 ms as the
+// single driver repaints the row with a fresh elapsedMs. The elapsed meter
+// rides the same repaint.
+//
+// These tests exercise the render path the writer's activity region invokes:
+// renderOperation(descriptor, { phase: 'pending' }) → formatToolLine.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { SPINNER_DEFS } = require('../lib/ui/ansi');
+const { formatToolLine } = require('../lib/ui/format');
+const { renderOperation } = require('../lib/ui/render-operation');
+
+// Strip SGR so we can inspect the visible glyph/elapsed text.
+function plain(s) { return s.replace(/\x1b\[[0-9;]*m/g, ''); }
+function firstGlyph(s) { return plain(s).trimStart()[0]; }
+
+const TOOL_FRAMES = SPINNER_DEFS.tool.frames;
+
+// ---------------------------------------------------------------------------
+// The running glyph cycles the tool spinner frames as elapsed advances.
+// ---------------------------------------------------------------------------
+
+test('running glyph cycles spinner frames across ticks (elapsed-derived)', () => {
+  const base = { status: 'pending', tag: 'shell', arg: 'ls', attrs: { command: 'ls' }, category: 'shell' };
+  // Frame is floor(elapsedMs / 100) % frames.length. Sample one full cycle.
+  for (let i = 0; i < TOOL_FRAMES.length; i++) {
+    const line = formatToolLine({ ...base, durationMs: i * 100 });
+    assert.strictEqual(firstGlyph(line), TOOL_FRAMES[i], `frame ${i} glyph`);
+  }
+  // Wraps around (modulo frames.length).
+  const wrapped = formatToolLine({ ...base, durationMs: TOOL_FRAMES.length * 100 });
+  assert.strictEqual(firstGlyph(wrapped), TOOL_FRAMES[0], 'frame index wraps');
+});
+
+test('the glyph actually changes between consecutive ~100ms samples', () => {
+  const base = { status: 'pending', tag: 'shell', arg: 'ls', attrs: { command: 'ls' }, category: 'shell' };
+  const g0 = firstGlyph(formatToolLine({ ...base, durationMs: 0 }));
+  const g1 = firstGlyph(formatToolLine({ ...base, durationMs: 100 }));
+  const g2 = firstGlyph(formatToolLine({ ...base, durationMs: 200 }));
+  assert.notStrictEqual(g0, g1, 'glyph advances 0 → 100ms');
+  assert.notStrictEqual(g1, g2, 'glyph advances 100 → 200ms');
+});
+
+// ---------------------------------------------------------------------------
+// The elapsed meter advances with the duration (the frozen-timer fix).
+// ---------------------------------------------------------------------------
+
+test('the running elapsed meter advances as durationMs grows', () => {
+  const base = { status: 'pending', tag: 'shell', arg: 'ls', attrs: { command: 'ls' }, category: 'shell' };
+  const at1 = plain(formatToolLine({ ...base, durationMs: 1200 }));
+  const at3 = plain(formatToolLine({ ...base, durationMs: 3400 }));
+  assert.ok(at1.includes('1.2s'), `elapsed shows 1.2s: ${at1}`);
+  assert.ok(at3.includes('3.4s'), `elapsed shows 3.4s: ${at3}`);
+  // Pending lines trail the duration with an ellipsis.
+  assert.ok(at1.includes('1.2s…'), 'pending duration trails with …');
+});
+
+// ---------------------------------------------------------------------------
+// Blocking tools (ask_user, rendered noDuration) keep the static dot — a
+// ticking spinner would falsely imply work is happening.
+// ---------------------------------------------------------------------------
+
+test('blocking (noDuration) pending tools keep the static dot, not a spinner', () => {
+  const line = formatToolLine({
+    status: 'pending', tag: 'ask_user', arg: 'Pick one', attrs: { question: 'Pick one' },
+    category: 'tool', noDuration: true,
+  });
+  assert.strictEqual(firstGlyph(line), '●', 'frozen blocking glyph stays the pending dot');
+  assert.ok(!TOOL_FRAMES.includes(firstGlyph(line)), 'not a spinner frame');
+});
+
+// ---------------------------------------------------------------------------
+// The descriptor path (renderOperation, pending phase) animates the same way.
+// ---------------------------------------------------------------------------
+
+test('renderOperation pending phase animates the glyph via durationMs', () => {
+  const mk = (durationMs) => renderOperation(
+    {
+      status: 'pending', tag: 'read_file', target: 'a.txt', attrs: { path: 'a.txt' },
+      category: 'file', durationMs,
+    },
+    { mode: 'ansi', phase: 'pending' },
+  );
+  const g0 = firstGlyph(mk(0));
+  const g1 = firstGlyph(mk(100));
+  assert.strictEqual(g0, TOOL_FRAMES[0], 'descriptor pending → spinner frame 0 at 0ms');
+  assert.notStrictEqual(g0, g1, 'descriptor pending glyph advances with elapsed');
+});
+
+// ---------------------------------------------------------------------------
+// Single physical row: the animated running line carries no newline (Phase 4
+// owns wrap-aware multi-row; this phase must not introduce multi-row content).
+// ---------------------------------------------------------------------------
+
+test('the animated running row is a single physical line (no newline)', () => {
+  const line = formatToolLine({
+    status: 'pending', tag: 'shell', arg: 'ls', attrs: { command: 'ls' },
+    category: 'shell', durationMs: 500,
+  });
+  assert.ok(!line.includes('\n'), 'no newline in the running row');
+});

package/test/status-bar-driver.test.js

@@ -0,0 +1,93 @@
+'use strict';
+
+// Status bar ↔ single driver coordination (Output Refactor — Phase 3).
+//
+// The status bar wires the clock and spinner as two SUBSCRIBERS of one driver
+// (lib/ui/anim.js). These tests assert the coordination contract through the
+// real FullStatusBar: one coordinated repaint per tick (no flicker), the driver
+// runs while animating even when idle-paused (so a running tool's spinner keeps
+// moving), and it stops when fully idle (preserving the 5404bd0 scroll fix).
+
+const { test, mock } = require('node:test');
+const assert = require('node:assert');
+
+const { FullStatusBar } = require('../lib/ui/status-bar');
+const { TICKS_PER_SECOND, BASE_INTERVAL_MS } = require('../lib/ui/anim');
+
+const layout = { cols: 200 };
+
+// ---------------------------------------------------------------------------
+// No flicker: a frame where BOTH the clock and the spinner want a repaint
+// still produces exactly ONE repaint (one writer frame, not two competing).
+// ---------------------------------------------------------------------------
+
+test('a frame firing both clock and spinner yields a single repaint', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.update('tool', 'running');   // animating → spinner wants every tick
+
+    // Advance to exactly the 1 Hz boundary (frame === TICKS_PER_SECOND), where
+    // the clock subscriber ALSO wants a repaint. The two coalesce into one.
+    redraws = 0;
+    mock.timers.tick(BASE_INTERVAL_MS * TICKS_PER_SECOND);
+    // One repaint per base tick (spinner), and the clock-boundary tick did not
+    // double up: exactly TICKS_PER_SECOND repaints over the second, not more.
+    assert.strictEqual(redraws, TICKS_PER_SECOND, 'one coordinated repaint per tick, no doubling at the 1s boundary');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// While animating, idle-pause keeps the driver running (spinner must move) but
+// silences the clock contribution — so there's no extra 1 Hz scroll-fighting
+// tick beyond the spinner's own repaints.
+// ---------------------------------------------------------------------------
+
+test('paused-but-animating keeps the spinner running', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.update('tool', 'running');   // animating
+    bar.pause();                     // input went idle (agent working)
+
+    redraws = 0;
+    mock.timers.tick(BASE_INTERVAL_MS * 5);
+    // Driver still runs (spinner) — 5 base ticks → 5 repaints.
+    assert.strictEqual(redraws, 5, 'spinner keeps repainting while paused-but-animating');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Returning to idle while paused stops the driver outright (idle = no anim).
+// ---------------------------------------------------------------------------
+
+test('idle + paused stops the driver (no periodic repaint → scroll works)', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  try {
+    let redraws = 0;
+    const bar = new FullStatusBar(layout, () => { redraws++; });
+    bar.update('tool', 'running');
+    bar.pause();
+    // Tool finished → back to idle while still paused.
+    bar.update('idle');   // update() un-pauses + restarts driver...
+    bar.pause();          // ...and the field is still idle → re-pause stops it.
+
+    redraws = 0;
+    mock.timers.tick(BASE_INTERVAL_MS * 50);
+    assert.strictEqual(redraws, 0, 'no periodic repaint when idle + paused');
+
+    bar.destroy();
+  } finally {
+    mock.timers.reset();
+  }
+});

package/test/status-bar-resync.test.js

@@ -0,0 +1,188 @@
+'use strict';
+
+// Status-bar clock re-sync after startup — the await-ordering race fix.
+//
+// THE BUG (uncovered by the 5404bd0 idle-scroll fix): two correct-in-isolation
+// mechanisms race during startup.
+//
+//   Fact A — statusBar.update('idle') unconditionally restarts the clock
+//     (the "not-paused ⇒ clock-running" invariant).
+//   Fact B — the input field's idle→pause is a ONE-SHOT setTimeout(0): on the
+//     first event-loop yield the field goes idle, emits 'idle', and the wiring
+//     (`field.on('idle', () => sb.pause())`) stops the clock. It fires once; no
+//     further 'idle' is emitted until an active→idle transition.
+//
+//   No-await start: update('idle') runs synchronously, THEN the loop yields and
+//   the one-shot _goIdle fires last → pause() → clock stopped. ✓
+//   Resume / MCP start: an `await` (dashboardGetChat / mcpManager.connectAll)
+//   yields mid-startup, so the one-shot _goIdle fires EARLY (clock stopped),
+//   then the await resolves and update('idle') restarts the clock. The field is
+//   already idle, so no active→idle transition ever re-fires pause() → clock
+//   runs forever → the 1 Hz redraw snaps the viewport down → scroll defeated. ✗
+//
+// THE FIX (chat.js, right after the startup update('idle')):
+//     if (inputField.isIdle()) statusBar.pause();
+// It re-syncs the clock to the field's REAL idle state. These tests model the
+// exact startup wiring (create-ui.js:196-197) with the real FullStatusBar and
+// InputField, driving the field's idle state to reproduce both orderings.
+
+const { test, mock } = require('node:test');
+const assert = require('node:assert');
+
+const { FullStatusBar } = require('../lib/ui/status-bar');
+const { InputField } = require('../lib/ui/input-field');
+
+const layout = { cols: 200 };
+
+// Build a real status bar + input field wired exactly like create-ui.js, plus
+// the one-line convergence re-sync the fix adds. Returns helpers to drive the
+// orderings and to count clock redraws.
+function harness() {
+  let redraws = 0;
+  const bar = new FullStatusBar(layout, () => { redraws++; });
+  const field = new InputField(layout, { /* chatHistory stub */ }, () => {});
+  // create-ui.js:196-197 — the live wiring under test.
+  field.on('idle', () => bar.pause());
+  field.on('active', () => bar.resume());
+
+  // The startup sequence at chat.js: the final update('idle') followed by the
+  // re-sync convergence step (the fix).
+  const startupResync = () => {
+    bar.update('idle');
+    if (field.isIdle()) bar.pause();
+  };
+
+  return {
+    bar,
+    field,
+    startupResync,
+    redrawsSince(fn) { redraws = 0; fn(); return redraws; },
+    cleanup() {
+      // _goActive arms a real setTimeout(0); clear any dangling one.
+      if (field._idleTimer) { clearTimeout(field._idleTimer); field._idleTimer = null; }
+      bar.destroy();
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Resume / await-ordering: the one-shot _goIdle fires BEFORE the re-sync → the
+// re-sync must leave the clock STOPPED (the regression).
+// ---------------------------------------------------------------------------
+
+test('await-ordering (resume): re-sync stops the clock the update restarted', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // An await yielded mid-startup → the one-shot _goIdle already fired.
+    h.field._goIdle();
+    assert.ok(h.field.isIdle(), 'field is idle after the early _goIdle');
+
+    // WITHOUT the re-sync, update('idle') alone leaves the clock running —
+    // this is exactly the bug. (Measure only the periodic tick, not update()'s
+    // own synchronous repaint.)
+    h.bar.update('idle');
+    const bugTicks = h.redrawsSince(() => mock.timers.tick(3000));
+    assert.ok(bugTicks >= 3, 'update(idle) alone restarts the clock (the bug)');
+
+    // WITH the re-sync: field is already idle → pause() → clock stopped.
+    h.startupResync();
+    const fixedTicks = h.redrawsSince(() => mock.timers.tick(5000));
+    assert.strictEqual(fixedTicks, 0, 're-sync stops the clock when field is idle');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Normal no-await start: field is NOT yet idle at the re-sync point → no
+// premature pause; the existing flow (timer fires later → pause) still ends
+// clock-stopped. (Paired positive — the fix doesn't break the working path.)
+// ---------------------------------------------------------------------------
+
+test('no-await start: re-sync is a no-op, existing idle→pause still stops the clock', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // The one-shot _goIdle has NOT fired yet at the re-sync point.
+    assert.ok(!h.field.isIdle(), 'field not yet idle at re-sync');
+
+    // Re-sync runs: isIdle() false → no premature pause → clock keeps running.
+    h.startupResync();
+    const afterResync = h.redrawsSince(() => mock.timers.tick(3000));
+    assert.ok(afterResync >= 3, 'no premature pause on the no-await path');
+
+    // The one-shot _goIdle fires AFTER startup (as it always did) → pause().
+    const afterIdle = h.redrawsSince(() => { h.field._goIdle(); mock.timers.tick(5000); });
+    assert.strictEqual(afterIdle, 0, 'the later idle still stops the clock');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// MCP-start equivalence: the fix is keyed on the field's idle state, not on
+// WHICH await yielded, so a startup await from MCP connectAll converges the
+// same way as --resume. Same ordering → same stopped end state.
+// ---------------------------------------------------------------------------
+
+test('await-ordering (MCP start): re-sync also stops the clock', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // mcpManager.connectAll() yielded the loop → one-shot _goIdle fired early.
+    h.field._goIdle();
+    h.startupResync();
+    const ticks = h.redrawsSince(() => mock.timers.tick(5000));
+    assert.strictEqual(ticks, 0, 'MCP-start await-ordering ends with the clock stopped');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Type-after-resume: an active transition restarts the clock (resume()) and a
+// subsequent idle re-pauses — the normal cycle is intact post-fix.
+// ---------------------------------------------------------------------------
+
+test('type-after-resume: active restarts the clock, idle re-pauses', () => {
+  mock.timers.enable({ apis: ['setInterval'] });
+  const h = harness();
+  try {
+    // Reach the post-resume stopped state.
+    h.field._goIdle();
+    h.startupResync();
+    assert.strictEqual(h.redrawsSince(() => mock.timers.tick(3000)), 0, 'stopped after resume');
+
+    // User types → active → resume() → clock runs again.
+    const afterActive = h.redrawsSince(() => { h.field._goActive(); mock.timers.tick(3000); });
+    assert.ok(afterActive >= 3, 'typing (active) restarts the clock');
+
+    // User stops → idle → pause() → clock stops again.
+    const afterIdle = h.redrawsSince(() => { h.field._goIdle(); mock.timers.tick(5000); });
+    assert.strictEqual(afterIdle, 0, 'going idle re-pauses the clock');
+  } finally {
+    h.cleanup();
+    mock.timers.reset();
+  }
+});
+
+// ---------------------------------------------------------------------------
+// isIdle() reflects the real _goIdle/_goActive transitions.
+// ---------------------------------------------------------------------------
+
+test('isIdle() reads the true idle state across transitions', () => {
+  const h = harness();
+  try {
+    assert.strictEqual(h.field.isIdle(), false, 'starts not-idle');
+    h.field._goIdle();
+    assert.strictEqual(h.field.isIdle(), true, 'true after _goIdle');
+    h.field._goActive();
+    assert.strictEqual(h.field.isIdle(), false, 'false after _goActive');
+  } finally {
+    h.cleanup();
+  }
+});