@semalt-ai/code 1.19.0 → 1.20.1

package/test/narration-ordering.test.js

@@ -0,0 +1,309 @@
+'use strict';
+
+// Activity-group ordering vs assistant narration (Option b — "fix: flush activity
+// groups before content-bearing narration for correct ordering").
+//
+// THE BUG: assistant narration commits to immutable scrollback immediately
+// (streamed token-by-token via streamToken, finalized via finalizeLastMessage),
+// while an open file/web activity group lives in the redrawable activity region
+// BELOW scrollback and only commits at a later boundary. When narration was
+// INTERMEDIATE (a tool follows), the old terminal-only flush gate was skipped, so
+// the narration committed ABOVE the still-open group and the group flushed later,
+// landing BELOW the conclusion it was based on (the "list ×3 below 'directory
+// almost empty'" screenshot).
+//
+// THE FIX (Option b): flush the open group BEFORE any content-bearing narration.
+//   • Streamed path  — flush at streaming-START (onToken, before the first
+//     content-bearing token commits the "▸ AI-agent" header + line to scrollback).
+//   • Finalize path  — flush at onAssistantMessage on terminal OR content-bearing
+//     narration (backstop for the non-streamed path).
+//   • Silent runs (empty/whitespace-only interim narration) still fully collapse.
+//
+// Tests drive the REAL createTurnHandler callbacks (same harness shape as
+// permission-flush.test.js / file-activity.test.js), recording every committed
+// scrollback line and every narration line in ONE ordered log so ordering can be
+// asserted directly.
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+process.stdout.isTTY = true;
+delete process.env.NO_COLOR;
+
+const { stripAnsi } = require('../lib/ui/utils');
+const { createTurnHandler } = require('../lib/commands/chat-turn');
+
+// ── Live harness ──────────────────────────────────────────────────────────────
+// `turnOpts` becomes ctx.opts. Pass { showThink: true } to disable the
+// implicit-think buffering gate so onToken streams tokens straight to
+// chatHistory.streamToken (exercising the streamed-narration path).
+function harness(turnOpts) {
+  const events = [];
+  // streaming flag mirrors chat-history's _streamActive: set on the first
+  // streamToken, cleared on clear/finalize. isStreaming() drives the
+  // streaming-start flush gate in onToken.
+  let streaming = false;
+
+  const writerModule = {
+    startActivity() {}, updateActivity() {},
+    endActivity(id, line) {
+      for (const raw of String(line == null ? '' : line).split('\n')) {
+        if (raw === '') continue;
+        events.push({ kind: 'commit', line: stripAnsi(raw) });
+      }
+    },
+    scrollback(line) { events.push({ kind: 'scrollback', line: stripAnsi(String(line)) }); },
+  };
+  const chatHistory = {
+    addMessage(m) { if (m && m.isError) events.push({ kind: 'error', output: m.output }); },
+    streamToken(t) {
+      if (!t) return;
+      // Mirror the real per-line commit: the header on the first token, then the
+      // token text as a committed narration line. (We don't need byte-fidelity —
+      // only that a narration line lands in the ordered log when the model speaks.)
+      if (!streaming) { streaming = true; events.push({ kind: 'narration', line: '▸ AI-agent' }); }
+      events.push({ kind: 'narration', line: t });
+    },
+    isStreaming() { return streaming; },
+    clearStreamingContent() { streaming = false; },
+    deferToolOutput() {}, commitDeferredDetail() {},
+    finalizeLastMessage(content) {
+      streaming = false;
+      if (content && content.trim()) events.push({ kind: 'answer', content });
+    },
+  };
+  const statusBar = { update() {}, onToken() {}, addPendingTokens() {}, updateMetrics() {}, setCost() {} };
+  const inputField = { on() {}, removeListener() {}, releaseNavigation() {}, setDisabled() {} };
+
+  let scenario = async () => {};
+  const runAgentLoop = async (messages, model, maxIter, limit, loopOpts) => {
+    await scenario(loopOpts.callbacks);
+    return { messages, metrics: { turns: [] }, withheldActions: [] };
+  };
+
+  const ctx = {
+    inputField, statusBar, chatHistory, writerModule, runAgentLoop,
+    getConfig: () => ({ auth_token: 'tok', max_iterations: 50, show_cost: false, system_prompt_mode: 'system_role' }),
+    approxTokens: () => 0,
+    resolveCommand: () => null,
+    opts: turnOpts || {},
+    TAG_REGISTRY: {},
+    collapseListMsg() {}, handlePendingSelection() {}, showPendingStep() {},
+    activateNavCapture() {}, finalizeListMsg() {},
+    createChatIfNeeded: async () => {}, saveTurnToDashboard: async () => {}, saveSession() {},
+    messages: [], currentModel: 'm', debugMode: false, pendingImages: [],
+    chatSync: async () => '', resolvedSystemPrompt: '', resolvedTokenLimit: null, planMode: false,
+  };
+
+  const handler = createTurnHandler(ctx, {});
+  return { events, handler, setScenario: (fn) => { scenario = fn; } };
+}
+
+// One fully-successful groupable file op (read / list_dir).
+function fileOp(cb, tag, path) {
+  cb.onToolStart(tag, path, { id: `${tag}-${path}`, attrs: { path } });
+  cb.onToolEnd(tag, 'contents', 5, { id: `${tag}-${path}`, attrs: { path }, meta: { bytes: 10 }, error: null });
+}
+
+// One fully-successful web op (http_get) — leaves the web group OPEN.
+function webOp(cb, url) {
+  cb.onToolStart('http_get', url, { id: `g-${url}`, attrs: { url } });
+  cb.onToolEnd('http_get', {}, 120, { id: `g-${url}`, attrs: { url }, meta: { status_code: 200, bytes: 1000 }, error: null });
+}
+
+const commits = (events) => events.filter((e) => e.kind === 'commit');
+const fileSummaries = (events) => commits(events).filter((e) => /file .* explored ×\d+/.test(e.line));
+const webSummaries = (events) => commits(events).filter((e) => / web /.test(e.line) && /source/.test(e.line));
+
+// ───────────────────────────────────────────────────────────────────────────
+// (a) The SCREENSHOT scenario: a group of list/read ops, then a content-bearing
+//     INTERMEDIATE narration (the conclusion based on them), then a non-groupable
+//     tool (write_file). The group must commit ABOVE the narration.
+// ───────────────────────────────────────────────────────────────────────────
+test('(a) group of list ops → intermediate conclusion narration → write_file: group commits ABOVE the narration', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    cb.onAssistantMessage('');                                   // empty pre-tool narration — must NOT flush
+    fileOp(cb, 'list_dir', '/proj');
+    fileOp(cb, 'list_dir', '/proj/src');
+    fileOp(cb, 'list_dir', '/proj/test');
+    // The conclusion drawn FROM the listings — content-bearing, intermediate (a
+    // tool follows). This is what must NOT sit above the listings it summarizes.
+    cb.onAssistantMessage('The directory is almost empty.', { terminal: false });
+    // A non-groupable effectful tool follows.
+    cb.onToolStart('write_file', '/proj/new.js', { id: 'w1', attrs: { path: '/proj/new.js' } });
+    cb.onToolEnd('write_file', 'ok', 4, { id: 'w1', attrs: { path: '/proj/new.js' }, meta: { bytes: 3 }, error: null });
+    cb.onAssistantMessage('Done.', { terminal: true });
+  });
+  await h.handler('list a few dirs, conclude, then write');
+
+  const s = fileSummaries(h.events);
+  assert.strictEqual(s.length, 1, 'the three listings collapse to one summary');
+  assert.match(s[0].line, /explored ×3/);
+
+  const iGroup = h.events.findIndex((e) => e.kind === 'commit' && /explored ×3/.test(e.line));
+  const iNarration = h.events.findIndex((e) => e.kind === 'answer' && e.content === 'The directory is almost empty.');
+  assert.ok(iGroup >= 0 && iNarration >= 0, 'both group and narration present');
+  assert.ok(iGroup < iNarration, 'the explored ×3 group commits ABOVE the conclusion narration (the screenshot fix)');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// (b) SILENT multi-read run — only empty interim narration. Still ONE summary.
+// ───────────────────────────────────────────────────────────────────────────
+test('(b) silent multi-read run (empty interim narration) still collapses to ONE explored ×N', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    cb.onAssistantMessage('');
+    fileOp(cb, 'read', '/a.js');
+    fileOp(cb, 'read', '/b.js');
+    cb.onAssistantMessage('', { terminal: false });   // silent intermediate — must NOT flush
+    fileOp(cb, 'read', '/c.js');
+    fileOp(cb, 'read', '/d.js');
+    cb.onAssistantMessage('', { terminal: false });   // silent intermediate — must NOT flush
+    fileOp(cb, 'read', '/e.js');
+    cb.onAssistantMessage('Read everything.', { terminal: true });
+  });
+  await h.handler('silent multi-read run');
+
+  const s = fileSummaries(h.events);
+  assert.strictEqual(s.length, 1, 'a silent run collapses to exactly ONE summary across all iterations');
+  assert.match(s[0].line, /explored ×5/, 'all five reads counted — empty interim narration did not split the group');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// (c) CHATTY run — content-bearing narration between reads. Fragments into
+//     correctly-ordered sub-groups, each ABOVE its narration.
+// ───────────────────────────────────────────────────────────────────────────
+test('(c) chatty run: content-bearing interim narration fragments into correctly-ordered sub-groups', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    cb.onAssistantMessage('');
+    fileOp(cb, 'read', '/a.js');
+    fileOp(cb, 'read', '/b.js');
+    fileOp(cb, 'read', '/c.js');
+    cb.onAssistantMessage('First batch looks fine.', { terminal: false });  // flushes group #1
+    fileOp(cb, 'read', '/d.js');
+    fileOp(cb, 'read', '/e.js');
+    fileOp(cb, 'read', '/f.js');
+    cb.onAssistantMessage('Second batch too.', { terminal: true });         // flushes group #2
+  });
+  await h.handler('chatty multi-read run');
+
+  const s = fileSummaries(h.events);
+  assert.strictEqual(s.length, 2, 'two content-bearing narrations → two fragments');
+  assert.ok(s.every((e) => /explored ×3/.test(e.line)), 'each fragment is explored ×3');
+
+  const iSum1 = h.events.findIndex((e) => e.kind === 'commit' && /explored ×3/.test(e.line));
+  const iNarr1 = h.events.findIndex((e) => e.kind === 'answer' && e.content === 'First batch looks fine.');
+  const iSum2 = h.events.findIndex((e, idx) => idx > iSum1 && e.kind === 'commit' && /explored ×3/.test(e.line));
+  const iNarr2 = h.events.findIndex((e) => e.kind === 'answer' && e.content === 'Second batch too.');
+  assert.ok(iSum1 < iNarr1, 'fragment #1 above its narration');
+  assert.ok(iNarr1 < iSum2, 'fragment #2 starts after narration #1');
+  assert.ok(iSum2 < iNarr2, 'fragment #2 above its narration');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// (d) STREAMED narration (token path) — the group must commit ABOVE the first
+//     streamed narration line. This is the load-bearing case: streamToken commits
+//     the header + line to scrollback BEFORE onAssistantMessage, so the flush must
+//     happen at streaming-START (onToken), not at onAssistantMessage.
+//     showThink:true disables the implicit-think buffer so onToken streams live.
+// ───────────────────────────────────────────────────────────────────────────
+test('(d) streamed content-bearing narration: group commits ABOVE the first narration line', async () => {
+  const h = harness({ showThink: true });
+  h.setScenario(async (cb) => {
+    fileOp(cb, 'list_dir', '/proj');
+    fileOp(cb, 'list_dir', '/proj/src');
+    fileOp(cb, 'list_dir', '/proj/test');
+    // Narration STREAMS in token-by-token (what really happens). The very first
+    // content token must flush the open group first.
+    for (const tok of ['The ', 'directory ', 'is ', 'almost ', 'empty.', '\n']) cb.onToken(tok);
+    cb.onAssistantMessage('The directory is almost empty.', { terminal: true });
+  });
+  await h.handler('stream a conclusion after listing');
+
+  const s = fileSummaries(h.events);
+  assert.strictEqual(s.length, 1, 'one summary');
+  assert.match(s[0].line, /explored ×3/);
+
+  const iGroup = h.events.findIndex((e) => e.kind === 'commit' && /explored ×3/.test(e.line));
+  const iFirstNarration = h.events.findIndex((e) => e.kind === 'narration');
+  assert.ok(iGroup >= 0 && iFirstNarration >= 0, 'group and streamed narration both present');
+  assert.ok(iGroup < iFirstNarration, 'the group commits ABOVE the FIRST streamed narration line (streaming-start flush)');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// (e) DOUBLE-FLUSH idempotency — the streaming-start flush, then the
+//     onAssistantMessage flush, then the turn-end finally flush all call flush();
+//     the group commits EXACTLY once.
+// ───────────────────────────────────────────────────────────────────────────
+test('(e) double-flush idempotency: streaming-start + onAssistantMessage + finally → exactly one commit', async () => {
+  const h = harness({ showThink: true });
+  h.setScenario(async (cb) => {
+    fileOp(cb, 'read', '/a.js');
+    fileOp(cb, 'read', '/b.js');
+    fileOp(cb, 'read', '/c.js');
+    for (const tok of ['All ', 'good.', '\n']) cb.onToken(tok);   // flush #1 (streaming-start)
+    cb.onAssistantMessage('All good.', { terminal: true });        // flush #2 (no-op) + finally flush (no-op)
+  });
+  await h.handler('one group, many flush opportunities');
+
+  const s = fileSummaries(h.events);
+  assert.strictEqual(s.length, 1, 'the group committed EXACTLY once despite multiple flush() calls');
+  assert.match(s[0].line, /explored ×3/);
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// (f) WEB group parity — the open web group also flushes before content-bearing
+//     narration, symmetrically with the file group.
+// ───────────────────────────────────────────────────────────────────────────
+test('(f) web group flushes before content-bearing narration (symmetry with the file group)', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    cb.onAssistantMessage('');
+    webOp(cb, 'https://a.example');
+    webOp(cb, 'https://b.example');
+    // Content-bearing intermediate narration must flush the web group above it.
+    cb.onAssistantMessage('Both pages confirm the API shape.', { terminal: false });
+    cb.onToolStart('write_file', '/notes.md', { id: 'w1', attrs: { path: '/notes.md' } });
+    cb.onToolEnd('write_file', 'ok', 4, { id: 'w1', attrs: { path: '/notes.md' }, meta: { bytes: 3 }, error: null });
+    cb.onAssistantMessage('Done.', { terminal: true });
+  });
+  await h.handler('fetch two pages, conclude, then write');
+
+  const w = webSummaries(h.events);
+  assert.strictEqual(w.length, 1, 'the two fetches collapse to one web summary');
+  const iWeb = h.events.findIndex((e) => e.kind === 'commit' && / web /.test(e.line) && /source/.test(e.line));
+  const iNarration = h.events.findIndex((e) => e.kind === 'answer' && e.content === 'Both pages confirm the API shape.');
+  assert.ok(iWeb >= 0 && iNarration >= 0, 'web summary and narration present');
+  assert.ok(iWeb < iNarration, 'the web summary commits ABOVE the content-bearing narration');
+});
+
+// ───────────────────────────────────────────────────────────────────────────
+// (g) WHITESPACE-only interim narration does NOT flush (silent collapse preserved
+//     even when pure streaming artifacts arrive between reads).
+// ───────────────────────────────────────────────────────────────────────────
+test('(g) whitespace-only interim narration does NOT flush — silent collapse preserved', async () => {
+  const h = harness({ showThink: true });
+  let commitsAfterWhitespace = -1;
+  h.setScenario(async (cb) => {
+    fileOp(cb, 'read', '/a.js');
+    fileOp(cb, 'read', '/b.js');
+    // Pure streaming artifacts between reads — whitespace tokens + a whitespace
+    // finalize. NONE of these may flush the open group (token.trim() is empty so
+    // the streaming-start gate is skipped; the onAssistantMessage gate sees no
+    // content). The group stays open and uncommitted.
+    cb.onToken('   ');
+    cb.onToken('\n');
+    cb.onAssistantMessage('   ', { terminal: false });
+    commitsAfterWhitespace = commits(h.events).length;   // snapshot: must be 0 — nothing flushed
+    fileOp(cb, 'read', '/c.js');
+    cb.onAssistantMessage('Read all three.', { terminal: true });   // terminal → the single flush
+  });
+  await h.handler('whitespace artifacts between reads');
+
+  assert.strictEqual(commitsAfterWhitespace, 0, 'whitespace interim narration committed NOTHING — the group was not flushed');
+  const s = fileSummaries(h.events);
+  assert.strictEqual(s.length, 1, 'whitespace interim narration did NOT split the group');
+  assert.match(s[0].line, /explored ×3/, 'all three reads collapsed into ONE summary');
+});

package/test/native-dispatch.test.js

@@ -354,3 +354,56 @@ test('native plan mode OFF (approval): the same native mutating tool executes',
     await mock.close();
   }
 });
+
+// ---------------------------------------------------------------------------
+// 7. P1 — native rail does NOT run textual command heuristics. A finish=stop
+//    turn whose prose contains an illustrative ```bash block (no tool tag) must
+//    yield ZERO tool calls (the incident: a hung `su nobody` + placeholder
+//    examples were executed). EXPLICIT tool tags still dispatch on the native
+//    rail. (test-model has no profile → isNativeToolsActive defaults true, the
+//    same native-rail assumption the structured tests above rely on.)
+// ---------------------------------------------------------------------------
+
+test('P1 native rail: illustrative ```bash block in a final answer is NOT executed (heuristic skipped)', async () => {
+  const mock = await startMockLLM();
+  // Single stop-turn: prose with a fenced example, no tool tag. On the native
+  // rail the bare-fence heuristic is suppressed → zero tool calls → final answer.
+  mock.replyWith('To drop privileges you could run:\n```bash\nsu nobody\necho "$SECRET_TOKEN"\n```\nBut do not run that here.');
+  try {
+    const { runner, asks } = buildRunner(mock.base);
+    const { ev, cb } = collector();
+    const messages = [{ role: 'user', content: 'how do I drop privileges?' }];
+    const { metrics } = await runner.runAgentLoop(messages, 'test-model', 5, null, { callbacks: cb });
+
+    assert.strictEqual(ev.tools.length, 0, 'NO shell command extracted/executed from the illustrative fence');
+    assert.deepStrictEqual(asks, [], 'no permission gate consulted — nothing dispatched');
+    assert.strictEqual(metrics.turns.length, 1, 'single turn — treated as a completed text answer');
+    assert.ok(messages.some((m) => m.role === 'assistant' && /su nobody/.test(m.content)),
+      'the prose (including the example) is recorded as the final answer, not run');
+    assert.strictEqual(mock.pending(), 0, 'loop ended on the first reply (no tool round-trip)');
+  } finally {
+    await mock.close();
+  }
+});
+
+test('P1 native rail: an EXPLICIT <shell> tag in content STILL dispatches and executes', async () => {
+  const mock = await startMockLLM();
+  mock.replyWith('<shell>echo NATIVE_XML_TAG_OUT</shell>');
+  mock.replyWith('Ran it.');
+  try {
+    const { runner, asks } = buildRunner(mock.base);
+    const { ev, cb } = collector();
+    const messages = [{ role: 'user', content: 'run echo' }];
+    const { metrics } = await runner.runAgentLoop(messages, 'test-model', 5, null, { callbacks: cb });
+
+    assert.strictEqual(ev.tools.length, 1, 'explicit tag dispatched on the native rail');
+    assert.strictEqual(ev.tools[0].tag, 'shell');
+    assert.deepStrictEqual(asks, [{ actionType: 'shell', tag: 'exec' }], 'shell gate fired for the explicit tag');
+    const toolResult = messages.find((m) => m.role === 'user' && /Tool execution results/.test(m.content));
+    assert.ok(toolResult && /NATIVE_XML_TAG_OUT/.test(toolResult.content), 'command stdout flowed back');
+    assert.strictEqual(metrics.turns.length, 2, 'tool turn + final turn');
+    assert.ok(messages.some((m) => m.role === 'assistant' && m.content === 'Ran it.'));
+  } finally {
+    await mock.close();
+  }
+});

package/test/native-live-narration.test.js

@@ -0,0 +1,254 @@
+'use strict';
+
+// Live token-by-token narration on the NATIVE tool-call rail, gated by a safety
+// signal so implicit reasoning is NEVER streamed (leaked).
+//
+// These tests drive the REAL createTurnHandler callbacks (chat-turn.js) wired to
+// the REAL ChatHistory (chat-history.js, with _commit captured), simulating the
+// per-iteration callback order agent.js + api.js produce:
+//
+//   onRequestSent()                      reset gate + safety signals
+//   onReasoningStart()                   (only when delta.reasoning_content seen)
+//   onStreamStart(nativeRail, inlineR)   first content token — rail + flag (signal b)
+//   onToken(t) …                         each delta.content token
+//   onAssistantMessage(clean,{terminal}) finalize the turn
+//
+// The gate (chat-turn.js onToken) opens eagerly ONLY when nativeRail AND
+// (reasoningSeen OR inline_reasoning:false). Otherwise it keeps the buffered-
+// until-boundary behavior (the no-leak fallback, also the entire XML-rail path).
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+
+const { createTurnHandler } = require('../lib/commands/chat-turn');
+const { ChatHistory } = require('../lib/ui/chat-history');
+const { stripAnsi } = require('../lib/ui/utils');
+const { normalizeConfig } = require('../lib/config');
+
+// ---------------------------------------------------------------------------
+// Config: inline_reasoning (signal b) normalizes to an explicit boolean only.
+// ---------------------------------------------------------------------------
+test('inline_reasoning persists only as an explicit boolean on a models[] profile', () => {
+  const base = { api_base: 'http://x', api_key: 'k', model: 'm' };
+  const norm = (extra) => normalizeConfig({ models: [{ ...base, ...extra }] }).models[0];
+
+  assert.strictEqual('inline_reasoning' in norm({}), false, 'unset by default → assume might inline (safe)');
+  assert.strictEqual(norm({ inline_reasoning: false }).inline_reasoning, false, 'explicit false persists');
+  assert.strictEqual(norm({ inline_reasoning: true }).inline_reasoning, true, 'explicit true persists');
+  // Non-boolean junk is dropped (stays unset → safe default), never coerced.
+  assert.strictEqual('inline_reasoning' in norm({ inline_reasoning: 'false' }), false, 'string is dropped, not coerced');
+  assert.strictEqual('inline_reasoning' in norm({ inline_reasoning: 0 }), false, 'number is dropped, not coerced');
+});
+
+// Build a harness around the REAL createTurnHandler + REAL ChatHistory.
+// `streamed`  — tokens the gate passed live to chatHistory.streamToken.
+// `committed` — everything that reached scrollback (via the captured _commit).
+// `statuses`  — statusBar.update (state,label) pairs, to assert the transition.
+function harness(opts = {}) {
+  const streamed = [];
+  const committed = [];
+  const statuses = [];
+
+  const chatHistory = new ChatHistory();
+  chatHistory._commit = (t) => committed.push(t);
+  chatHistory._setDetail = () => {};
+  chatHistory._commitDetail = (t) => { if (t) committed.push(t); };
+  const origStream = chatHistory.streamToken.bind(chatHistory);
+  chatHistory.streamToken = (t) => { streamed.push(t); origStream(t); };
+
+  const statusBar = {
+    update: (state, label) => statuses.push([state, label]),
+    onToken() {}, addPendingTokens() {}, updateMetrics() {}, setCost() {},
+  };
+  const inputField = {
+    on() {}, removeListener() {}, releaseNavigation() {}, setDisabled() {},
+  };
+  const writerModule = {
+    startActivity() {}, updateActivity() {}, endActivity() {}, scrollback() {},
+  };
+
+  let scenario = async () => {};
+  const runAgentLoop = async (messages, model, maxIter, limit, loopOpts) => {
+    await scenario(loopOpts.callbacks);
+    return { messages, metrics: { turns: [] }, withheldActions: [] };
+  };
+
+  const ctx = {
+    inputField, statusBar, chatHistory, writerModule, runAgentLoop,
+    getConfig: () => ({ auth_token: 'tok', max_iterations: 50, show_cost: false, system_prompt_mode: 'system_role' }),
+    approxTokens: () => 0,
+    resolveCommand: () => null,
+    opts: { showThink: !!opts.showThink },
+    TAG_REGISTRY: {},
+    collapseListMsg() {}, handlePendingSelection() {}, showPendingStep() {},
+    activateNavCapture() {}, finalizeListMsg() {},
+    createChatIfNeeded: async () => {}, saveTurnToDashboard: async () => {}, saveSession() {},
+    messages: [], currentModel: 'm', debugMode: false, pendingImages: [],
+    chatSync: async () => '', resolvedSystemPrompt: '', resolvedTokenLimit: null, planMode: false,
+  };
+
+  const handler = createTurnHandler(ctx, {});
+  return { streamed, committed, statuses, handler, setScenario: (fn) => { scenario = fn; } };
+}
+
+// Simulate one streaming iteration in the exact callback order agent.js drives.
+function iteration(cb, { native, inlineReasoning, reasoningSeen, tokens, finalContent }) {
+  cb.onRequestSent();
+  if (reasoningSeen) cb.onReasoningStart();      // api.js wrappedOnReasoning (signal a)
+  cb.onStreamStart(native, inlineReasoning);     // first content token (rail + signal b)
+  for (const t of tokens) cb.onToken(t);
+  cb.onAssistantMessage(finalContent, { terminal: true });
+}
+
+function committedText(committed) { return stripAnsi(committed.join('')); }
+function countHeaders(committed) {
+  return (committedText(committed).match(/▸ AI-agent/g) || []).length;
+}
+
+// ---------------------------------------------------------------------------
+// Case 1 — native rail + reasoning_content seen → narration streams LIVE
+// ---------------------------------------------------------------------------
+test('native rail + reasoning_content seen: narration streams live (gate opens before finalize)', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    iteration(cb, {
+      native: true, inlineReasoning: undefined, reasoningSeen: true,
+      tokens: ['Hello', ' world'], finalContent: 'Hello world',
+    });
+  });
+  await h.handler('hi');
+
+  assert.deepStrictEqual(h.streamed, ['Hello', ' world'], 'both narration tokens streamed live');
+  // Status bar transitioned to streaming on eager-open (not stuck on Thinking).
+  assert.ok(h.statuses.some(([s, l]) => s === 'streaming' && l === 'Streaming response'),
+    'status bar transitions to streaming on eager-open');
+});
+
+// ---------------------------------------------------------------------------
+// Case 2 — native rail + inline_reasoning:false → narration streams from token 1
+// ---------------------------------------------------------------------------
+test('native rail + inline_reasoning:false: narration streams live from token 1', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    iteration(cb, {
+      native: true, inlineReasoning: false, reasoningSeen: false,
+      tokens: ['The', ' answer'], finalContent: 'The answer',
+    });
+  });
+  await h.handler('hi');
+
+  assert.deepStrictEqual(h.streamed, ['The', ' answer'], 'streams live from the first token, no reasoning_content needed');
+  assert.ok(h.statuses.some(([s, l]) => s === 'streaming' && l === 'Streaming response'),
+    'status bar transitions to streaming on eager-open');
+});
+
+// ---------------------------------------------------------------------------
+// Case 3 — native rail, NO signal, bare-text-then-orphan-</think>:
+//          reasoning stays HIDDEN (no leak); narration after </think> streams.
+// ---------------------------------------------------------------------------
+test('native rail + NO signal + implicit think: reasoning hidden, post-</think> narration streams', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    iteration(cb, {
+      native: true, inlineReasoning: undefined, reasoningSeen: false,
+      tokens: ['Let', ' me', ' think', '</think>', 'The answer', ' is 42'],
+      finalContent: 'The answer is 42',
+    });
+  });
+  await h.handler('hi');
+
+  // The bare reasoning tokens were buffered+discarded — never streamed, never committed.
+  assert.deepStrictEqual(h.streamed, ['The answer', ' is 42'], 'only post-</think> narration streams');
+  const text = committedText(h.committed);
+  for (const leak of ['Let', 'me', 'think']) {
+    assert.ok(!text.includes(leak), `reasoning token ${JSON.stringify(leak)} must NOT reach scrollback (no leak)`);
+  }
+  assert.ok(text.includes('The answer is 42'), 'narration is rendered');
+});
+
+// ---------------------------------------------------------------------------
+// Case 4 — XML rail (nativeRail false): identical to old behavior even WITH
+//          reasoning_content seen. The eager-open guard excludes the XML rail.
+// ---------------------------------------------------------------------------
+test('XML rail: buffered-until-</think> behavior unchanged even with reasoning seen (regression guard)', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    iteration(cb, {
+      native: false, inlineReasoning: false, reasoningSeen: true,
+      tokens: ['secret', ' reasoning', '</think>', 'visible answer'],
+      finalContent: 'visible answer',
+    });
+  });
+  await h.handler('hi');
+
+  assert.deepStrictEqual(h.streamed, ['visible answer'], 'XML rail buffers leading text despite signals');
+  const text = committedText(h.committed);
+  assert.ok(!text.includes('secret'), 'XML rail does not leak buffered reasoning');
+  assert.ok(text.includes('visible answer'), 'XML rail narration after </think> still renders');
+});
+
+// ---------------------------------------------------------------------------
+// Case 5 — finalize after a live stream does NOT double-print (one AI header).
+// ---------------------------------------------------------------------------
+test('finalize after live stream: no double-print (single AI bubble, no _buildAI re-synthesis)', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    iteration(cb, {
+      native: true, inlineReasoning: false, reasoningSeen: false,
+      tokens: ['unique-token-α'], finalContent: 'unique-token-α',
+    });
+  });
+  await h.handler('hi');
+
+  const text = committedText(h.committed);
+  assert.strictEqual(countHeaders(h.committed), 1, 'exactly one ▸ AI-agent header (no re-synthesized bubble)');
+  assert.strictEqual((text.match(/unique-token-α/g) || []).length, 1, 'narration committed exactly once');
+});
+
+// ---------------------------------------------------------------------------
+// Case 6 (P2 regression) — native rail, reasoning_content seen (eager-open),
+// content carries a STRAY inline </think>. MiniMax emits reasoning via BOTH
+// reasoning_content AND an orphan </think> terminator in content; the
+// StreamParser passes that orphan tag through verbatim (its `/think` form is not
+// a TAG_REGISTRY key). The eager-open path must DROP it (not stream it) while the
+// surrounding narration streams live. Regression from 938f583: the eager-open
+// fell through to streamToken and skipped the orphan-drop guard for every token.
+// (f) The committed scrollback — what persists/replays — stays clean too.
+// ---------------------------------------------------------------------------
+test('native rail + reasoning_content + inline orphan </think>: stray tag dropped, narration streams (P2)', async () => {
+  const h = harness();
+  h.setScenario(async (cb) => {
+    iteration(cb, {
+      native: true, inlineReasoning: undefined, reasoningSeen: true,
+      tokens: ['Here', ' is', '</think>', ' the answer'],
+      finalContent: 'Here is the answer',
+    });
+  });
+  await h.handler('hi');
+
+  assert.deepStrictEqual(h.streamed, ['Here', ' is', ' the answer'],
+    'orphan </think> dropped from the live stream; surrounding narration streamed live');
+  const text = committedText(h.committed);
+  assert.ok(!text.includes('</think>'), 'the stray </think> never reaches scrollback (live + persisted clean)');
+  assert.ok(text.includes('Here is the answer'), 'narration is rendered');
+});
+
+// Every closing reasoning tag the StreamParser emits raw must drop on the
+// eager-open path — for the WHOLE stream, not just the first token. The set
+// matches the registered visual tags (think/reasoning/reflection/plan); their
+// `/tag` closing form is never a TAG_REGISTRY key, so all stream verbatim.
+test('native rail eager-open: orphan think/reasoning/reflection/plan close tags all dropped (P2)', async () => {
+  for (const tag of ['think', 'reasoning', 'reflection', 'plan']) {
+    const h = harness();
+    h.setScenario(async (cb) => {
+      iteration(cb, {
+        native: true, inlineReasoning: false, reasoningSeen: false,
+        tokens: ['ok ', `</${tag}>`, 'done'],
+        finalContent: 'ok done',
+      });
+    });
+    await h.handler('hi');
+    assert.deepStrictEqual(h.streamed, ['ok ', 'done'], `</${tag}> dropped on the eager-open path`);
+    assert.ok(!committedText(h.committed).includes(`</${tag}>`), `</${tag}> never committed`);
+  }
+});