claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/broadcastCoalescer.test.cjs

@@ -1,122 +0,0 @@
-/**
- * broadcastCoalescer.test.cjs — unit tests for src/main/lib/broadcastCoalescer.cjs,
- * the trailing-edge debounce used by scheduler.cjs's broadcast().
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/broadcastCoalescer.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const { createBroadcastCoalescer } = require('../lib/broadcastCoalescer.cjs');
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-function makeCoalescer(delayMs = 200) {
-  const sent = [];
-  let counter = 0;
-  const getPayload = vi.fn(() => `state-${counter}`);
-  const send = vi.fn((payload) => sent.push(payload));
-  const coalescer = createBroadcastCoalescer({ delayMs, send, getPayload });
-  return {
-    coalescer,
-    sent,
-    send,
-    getPayload,
-    bump: () => { counter += 1; },
-  };
-}
-
-test('5 rapid schedule() calls within the window produce exactly 1 send', async () => {
-  const { coalescer, sent, bump } = makeCoalescer(200);
-
-  bump(); coalescer.schedule();
-  bump(); coalescer.schedule();
-  bump(); coalescer.schedule();
-  bump(); coalescer.schedule();
-  bump(); coalescer.schedule();
-
-  await vi.advanceTimersByTimeAsync(200);
-
-  expect(sent.length).toBe(1);
-});
-
-test('the trailing send reflects the LATEST state, not the state at the first schedule() call', async () => {
-  const { coalescer, sent, bump } = makeCoalescer(200);
-
-  bump(); // state-1
-  coalescer.schedule();
-  bump(); // state-2
-  coalescer.schedule(); // no-op — timer already armed
-  bump(); // state-3
-  coalescer.schedule(); // no-op
-
-  await vi.advanceTimersByTimeAsync(200);
-
-  expect(sent).toEqual(['state-3']);
-});
-
-test('flush() cancels the pending timer and sends immediately with the current payload', async () => {
-  const { coalescer, sent, bump } = makeCoalescer(200);
-
-  bump();
-  coalescer.schedule();
-
-  // Flush before the 200ms window elapses.
-  await vi.advanceTimersByTimeAsync(50);
-  await coalescer.flush();
-
-  expect(sent).toEqual(['state-1']);
-
-  // The window's original timer must not fire a second, stale send.
-  await vi.advanceTimersByTimeAsync(200);
-  expect(sent).toEqual(['state-1']);
-});
-
-test('a schedule() call after a quiet period still arrives (not dropped)', async () => {
-  const { coalescer, sent, bump } = makeCoalescer(200);
-
-  bump();
-  coalescer.schedule();
-  await vi.advanceTimersByTimeAsync(200);
-  expect(sent).toEqual(['state-1']);
-
-  bump();
-  coalescer.schedule();
-  await vi.advanceTimersByTimeAsync(200);
-  expect(sent).toEqual(['state-1', 'state-2']);
-});
-
-test('flush() with no pending timer still sends (no-arm case)', async () => {
-  const { coalescer, sent, bump } = makeCoalescer(200);
-  bump();
-  await coalescer.flush();
-  expect(sent).toEqual(['state-1']);
-});
-
-test('a getPayload() that throws does not wedge the coalescer — the next schedule() still sends', async () => {
-  const sent = [];
-  const send = vi.fn((payload) => sent.push(payload));
-  const getPayload = vi.fn()
-    .mockRejectedValueOnce(new Error('boom'))
-    .mockResolvedValue('state-recovered');
-  const coalescer = createBroadcastCoalescer({ delayMs: 200, send, getPayload });
-
-  coalescer.schedule();
-  await vi.advanceTimersByTimeAsync(200);
-  expect(sent).toEqual([]);
-
-  coalescer.schedule();
-  await vi.advanceTimersByTimeAsync(200);
-  expect(sent).toEqual(['state-recovered']);
-  expect(getPayload).toHaveBeenCalledTimes(2);
-});
-
-console.log('broadcastCoalescer tests: PASS');

package/src/main/__tests__/chat-cancel-terminal.test.cjs

@@ -1,120 +0,0 @@
-/**
- * chat-cancel-terminal.test.cjs — regression for the "stuck thinking" hang.
- *
- * Bug (2026-07-05): cancelling an active chat run SIGTERM'd the child, but the
- * exit handler's `if (!gotResult && !killed)` guard skipped every broadcast
- * because `killed === true`. No terminal IPC event ever reached the renderer,
- * so the chat store stayed `running:true` forever — disabled textarea, endless
- * "running…" spinner, unresponsive chat UI.
- *
- * Fix: every run emits EXACTLY ONE terminal event (complete/needs-input/error),
- * and the exit path emits a fallback `chat:run:error` when a run settled
- * without one (cancel, crash, silent exit). This test drives the REAL spawn
- * path (via SM_CLAUDE_BIN pointing at a stub process) and asserts a terminal
- * event is broadcast on cancel.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-cancel-terminal.test.cjs
- */
-
-'use strict';
-
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test, afterAll } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// A stub "claude" that ignores stdin/args and stays alive until killed —
-// mimics a long-running headless run so cancel() has something to SIGTERM.
-// Shebang + chmod makes it directly spawnable as a single executable (spawn
-// does not split a path on spaces, so SM_CLAUDE_BIN must be one binary).
-const stubPath = require('../../../tests/helpers/claudeStub.cjs').writeClaudeStub({
-  body: 'setInterval(() => {}, 1000);',
-});
-process.env.SM_CLAUDE_BIN = stubPath;
-
-const cr = require('../chatRunner.cjs');
-
-// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
-const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
-
-const tick = () => new Promise((r) => setImmediate(r));
-
-test('cancelling an ACTIVE run broadcasts a terminal event (unsticks the UI)', async () => {
-  const events = [];
-  // Fake BrowserWindow that captures every broadcast.
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T', sessionId: 'S', prompt: 'hello', cwd: scratchCwd, resume: false });
-
-  // Let the spawn happen and started event fire.
-  for (let i = 0; i < 6; i++) await tick();
-  assert.ok(
-    events.some((e) => e.channel === 'chat:run:started'),
-    'started event should fire once the run launches',
-  );
-
-  cr.cancel('T');
-
-  // Wait for SIGTERM → child exit → fallback terminal broadcast.
-  for (let i = 0; i < 40 && !events.some((e) => isTerminal(e.channel)); i++) {
-    await new Promise((r) => setTimeout(r, 25));
-  }
-
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
-  assert.equal(terminal[0].channel, 'chat:run:error', 'cancel surfaces as an error turn');
-  assert.match(terminal[0].payload.message, /cancel/i, 'message names the cancellation');
-});
-
-test('cancel() resolves only AFTER the terminal broadcast fires, not immediately on SIGTERM (PRD 718)', async () => {
-  // Order-of-events assertion (not timing-based — a real SIGTERM can be fast
-  // enough on a lightweight stub child that a fixed-delay race would flake).
-  const order = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => {
-        if (isTerminal(channel) && payload.tabId === 'T2') order.push('terminal');
-      },
-    },
-  });
-
-  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'hello', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 6; i++) await tick();
-
-  await cr.cancel('T2').then(() => order.push('resolved'));
-
-  assert.deepEqual(order, ['terminal', 'resolved'], 'cancel() resolves strictly after the terminal broadcast');
-});
-
-test('cancel() on a tab with no in-flight or waiting run resolves immediately (no-op)', async () => {
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: { isDestroyed: () => false, send: () => {} },
-  });
-  await cr.cancel('no-such-tab'); // must resolve, not hang
-});
-
-function isTerminal(channel) {
-  return (
-    channel === 'chat:run:complete' ||
-    channel === 'chat:run:needs-input' ||
-    channel === 'chat:run:error'
-  );
-}
-
-afterAll(() => {
-  try { fs.unlinkSync(stubPath); } catch { /* already gone */ }
-  delete process.env.SM_CLAUDE_BIN;
-});

package/src/main/__tests__/chat-dead-channels.test.cjs

@@ -1,63 +0,0 @@
-/**
- * chat-dead-channels.test.cjs — regression guard for the removed
- * chat:probe-context / chat:context-usage channels (PRD 897).
- *
- * These IPC channels were deliberately deleted (handler, broadcast, preload
- * and zod schema all removed) rather than left half-wired. This test walks
- * the source tree and fails if either literal string reappears anywhere
- * under src/main, src/preload, or src/renderer — such a reintroduction must
- * be wired end-to-end (handler + preload + zod schema + broadcast) or not
- * added at all.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/chat-dead-channels.test.cjs
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-import { test, expect } from 'vitest';
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
-const SCAN_DIRS = ['src/main', 'src/preload', 'src/renderer'];
-const FORBIDDEN_STRINGS = ['chat:probe-context', 'chat:context-usage'];
-const SELF_PATH = path.resolve(__filename);
-
-function walk(dir, files) {
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name === 'node_modules') continue;
-    if (entry.isSymbolicLink()) continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walk(full, files);
-    } else {
-      files.push(full);
-    }
-  }
-}
-
-test('chat:probe-context / chat:context-usage channels stay removed', () => {
-  const files = [];
-  for (const dir of SCAN_DIRS) {
-    walk(path.join(REPO_ROOT, dir), files);
-  }
-
-  const hits = [];
-  for (const file of files) {
-    if (path.resolve(file) === SELF_PATH) continue;
-    const contents = fs.readFileSync(file, 'utf8');
-    for (const needle of FORBIDDEN_STRINGS) {
-      if (contents.includes(needle)) {
-        hits.push(`${path.relative(REPO_ROOT, file)}: contains "${needle}"`);
-      }
-    }
-  }
-
-  expect(
-    hits,
-    'chat:probe-context / chat:context-usage were deliberately removed as a dead/half-wired ' +
-      'channel (PRD 897). If reintroducing this feature, wire it end-to-end (handler, preload, ' +
-      'zod schema, broadcast) in the same change — do not add just one side.\n' + hits.join('\n'),
-  ).toEqual([]);
-});

package/src/main/__tests__/chat-exit-close-race.test.cjs

@@ -1,146 +0,0 @@
-/**
- * chat-exit-close-race.test.cjs — regression for the exit/close race that
- * silently dropped a pure-text-only final turn (PRD 716).
- *
- * Bug: the terminal-event fallback was wired to `child.on('exit', ...)`
- * instead of `child.on('close', ...)`. Node only guarantees all buffered
- * stdout 'data' events have been delivered by 'close', not 'exit' — 'exit'
- * can fire before the final stdout chunk (last assistant text + terminating
- * `result` line) reaches the parent's 'data' handler. When that happened,
- * the exit fallback ran first, set the one-shot terminalSent latch, and
- * broadcast a misleading chat:run:error. The real result line then parsed
- * moments later, but emitTerminal silently no-op'd and the genuine
- * chat:run:complete was dropped.
- *
- * Fix: use `child.on('close', ...)` for the fallback so it only fires once
- * Node guarantees stdout is fully drained — a real result event that arrives
- * (even "late", right up against process exit) always wins.
- *
- * This test mocks node:child_process.spawn so it can deterministically
- * reproduce the exact race ordering (exit fires, THEN the final stdout chunk
- * arrives, THEN close fires) rather than relying on real OS/pipe timing,
- * which is not reliably reproducible from a real child process.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-exit-close-race.test.cjs
- */
-
-'use strict';
-
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test, afterAll } from 'vitest';
-const assert = require('node:assert/strict');
-const EventEmitter = require('node:events');
-const cp = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// Replace spawn BEFORE chatRunner.cjs is first required, so the module's
-// top-level `const { spawn } = require('node:child_process')` destructuring
-// captures this mock instead of the real implementation.
-const originalSpawn = cp.spawn;
-let nextChild = null;
-cp.spawn = () => {
-  const child = new EventEmitter();
-  child.stdout = new EventEmitter();
-  child.stderr = new EventEmitter();
-  child.pid = 424242;
-  child.kill = () => {};
-  nextChild = child;
-  return child;
-};
-
-const cr = require('../chatRunner.cjs');
-
-// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
-const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
-
-const tick = () => new Promise((r) => setImmediate(r));
-
-test('a final-text-only turn whose stdout chunk lands after exit still surfaces chat:run:complete', async () => {
-  nextChild = null;
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'show me a sample post', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 20 && !nextChild; i++) await tick();
-  const child = nextChild;
-  assert.ok(child, 'spawn should have been invoked');
-
-  const text = 'Here is your sample post, all in one go.';
-  const lines =
-    JSON.stringify({ type: 'assistant', message: { content: [{ type: 'text', text }] } }) +
-    '\n' +
-    JSON.stringify({ type: 'result', subtype: 'success', result: text }) +
-    '\n';
-
-  // The exact race: 'exit' fires first (process already gone from the OS's
-  // perspective), the final stdout chunk is delivered to the 'data' handler
-  // only after that, and 'close' — which Node guarantees fires after all
-  // stdout data has been delivered — fires last.
-  child.emit('exit', 0, null);
-  child.stdout.emit('data', Buffer.from(lines));
-  child.emit('close', 0, null);
-
-  await tick();
-  await tick();
-
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
-  assert.equal(
-    terminal[0].channel,
-    'chat:run:complete',
-    'the real result event must win over the generic exit-fallback error',
-  );
-  assert.equal(terminal[0].payload.finalMessage, text);
-});
-
-test('a crashed process with no result event ever emitted still fires the fallback chat:run:error', async () => {
-  nextChild = null;
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T3', sessionId: 'S3', prompt: 'anything', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 20 && !nextChild; i++) await tick();
-  const child = nextChild;
-  assert.ok(child, 'spawn should have been invoked');
-
-  // Crashes with no stdout at all — 'close' is the only event that fires.
-  child.emit('close', 1, null);
-
-  await tick();
-  await tick();
-
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event is emitted');
-  assert.equal(terminal[0].channel, 'chat:run:error', 'a crash with no result surfaces as an error turn');
-  assert.match(terminal[0].payload.message, /process exited without a result event/);
-});
-
-function isTerminal(channel) {
-  return (
-    channel === 'chat:run:complete' ||
-    channel === 'chat:run:needs-input' ||
-    channel === 'chat:run:error'
-  );
-}
-
-afterAll(() => {
-  cp.spawn = originalSpawn;
-  delete process.env.SM_CHAT_CONCURRENCY;
-});

package/src/main/__tests__/chat-mcp-consent-notice.test.cjs

@@ -1,139 +0,0 @@
-/**
- * chat-mcp-consent-notice.test.cjs — regression for the headless MCP-consent
- * hang: a chat run with stdin closed can never answer an MCP server's own
- * interactive consent flow (e.g. `/design consent`). This drives the real
- * stdout parser with a synthetic stream-json `tool_result` denial line and
- * asserts a `chat:run:notice` event is broadcast — informational, not a
- * terminal event.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/chat-mcp-consent-notice.test.cjs
- */
-
-'use strict';
-
-delete process.env.SM_CHAT_CONCURRENCY;
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
-const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
-const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
-
-function writeStub(lines) {
-  const body = lines.map((l) => `process.stdout.write(${JSON.stringify(JSON.stringify(l))} + "\\n");`).join('\n');
-  return claudeStub.writeClaudeStub({ body: `${body}\nprocess.exit(0);` });
-}
-
-function isTerminal(channel) {
-  return (
-    channel === 'chat:run:complete' ||
-    channel === 'chat:run:needs-input' ||
-    channel === 'chat:run:error'
-  );
-}
-
-test('MCP consent denial in a tool_result surfaces a chat:run:notice event', async () => {
-  const stubPath = writeStub([
-    {
-      type: 'user',
-      message: {
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'toolu_1',
-            is_error: true,
-            content: [
-              {
-                type: 'text',
-                text:
-                  "Claude Design: write_files The user hasn't granted this — run /design consent " +
-                  "to grant it (it can't be approved automatically in this permission mode).",
-              },
-            ],
-          },
-        ],
-      },
-    },
-    { type: 'result', subtype: 'success', result: 'done anyway' },
-  ]);
-  process.env.SM_CLAUDE_BIN = stubPath;
-  delete require.cache[require.resolve('../chatRunner.cjs')];
-  const cr = require('../chatRunner.cjs');
-
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T-notice', sessionId: 'S-notice', prompt: 'do a design thing', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 60 && !events.some((e) => isTerminal(e.channel)); i++) {
-    await new Promise((r) => setTimeout(r, 25));
-  }
-
-  const notice = events.find((e) => e.channel === 'chat:run:notice');
-  assert.ok(notice, 'chat:run:notice should be broadcast');
-  assert.match(notice.payload.message, /consent/i, 'message mentions consent');
-  assert.match(notice.payload.message, /terminal/i, 'message mentions the raw terminal session');
-
-  // Notice is informational, not terminal — the normal result still fires.
-  const terminal = events.filter((e) => isTerminal(e.channel));
-  assert.equal(terminal.length, 1, 'exactly one terminal event still fires');
-  assert.equal(terminal[0].channel, 'chat:run:complete');
-
-  try { fs.unlinkSync(stubPath); } catch { /* already gone */ }
-  delete process.env.SM_CLAUDE_BIN;
-});
-
-test('a normal tool_result with no consent marker does not fire chat:run:notice', async () => {
-  const stubPath = writeStub([
-    {
-      type: 'user',
-      message: {
-        content: [
-          {
-            type: 'tool_result',
-            tool_use_id: 'toolu_2',
-            is_error: false,
-            content: [{ type: 'text', text: 'Wrote 3 files successfully.' }],
-          },
-        ],
-      },
-    },
-    { type: 'result', subtype: 'success', result: 'all good' },
-  ]);
-  process.env.SM_CLAUDE_BIN = stubPath;
-  delete require.cache[require.resolve('../chatRunner.cjs')];
-  const cr = require('../chatRunner.cjs');
-
-  const events = [];
-  cr.attachWindow({
-    isDestroyed: () => false,
-    webContents: {
-      isDestroyed: () => false,
-      send: (channel, payload) => events.push({ channel, payload }),
-    },
-  });
-
-  cr.run({ tabId: 'T-clean', sessionId: 'S-clean', prompt: 'do a normal thing', cwd: scratchCwd, resume: false });
-
-  for (let i = 0; i < 60 && !events.some((e) => isTerminal(e.channel)); i++) {
-    await new Promise((r) => setTimeout(r, 25));
-  }
-
-  assert.ok(
-    !events.some((e) => e.channel === 'chat:run:notice'),
-    'no chat:run:notice should fire for a clean tool_result (no false positive)',
-  );
-
-  try { fs.unlinkSync(stubPath); } catch { /* already gone */ }
-  delete process.env.SM_CLAUDE_BIN;
-});

package/src/main/__tests__/chat-preamble-anchors.test.cjs

@@ -1,100 +0,0 @@
-/**
- * chat-preamble-anchors.test.cjs — drift guard between chatRunner's injected
- * instruction blocks and the renderer's splitter that hides them.
- *
- * `src/renderer/lib/promptPreamble.ts` anchors each block on its FIRST and
- * LAST sentence only, because it cannot import this main-process .cjs. That
- * indirection is safe ONLY while those anchors still bracket the real text —
- * so this test composes the exact `fullPrompt` chatRunner builds and asserts
- * the splitter recovers the human's words exactly. Reword either block's
- * opening or closing sentence and this fails here, loudly, instead of the
- * boilerplate silently reappearing in every user bubble.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/chat-preamble-anchors.test.cjs
- */
-
-'use strict';
-
-const path = require('path');
-
-import { test, expect } from 'vitest';
-
-const { STOP_SIGNAL_INSTRUCTION, CHAT_MODE_TRUTH_INSTRUCTION } = require('../chatRunner.cjs');
-
-const HUMAN = 'Review the Alpaca limits and report back what we can trade for free.';
-
-async function loadSplitter() {
-  const mod = await import(
-    /* @vite-ignore */ path.resolve(__dirname, '..', '..', 'renderer', 'lib', 'promptPreamble.ts')
-  );
-  return mod;
-}
-
-test('the real fullPrompt splits back into exactly the human’s words', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  // Mirrors chatRunner's own composition at its `-p` call site.
-  const fullPrompt = STOP_SIGNAL_INSTRUCTION + CHAT_MODE_TRUTH_INSTRUCTION + HUMAN;
-
-  const split = splitInjectedPreamble(fullPrompt);
-  expect(split.body).toBe(HUMAN);
-  expect(split.blockKeys).toEqual(['stop-signal', 'chat-mode-truth']);
-  expect(split.preamble).toBeTruthy();
-  // Nothing is invented or lost: preamble + body reconstitute the input.
-  expect(split.preamble.length + split.body.length).toBeLessThanOrEqual(fullPrompt.length);
-  expect(fullPrompt.startsWith(split.preamble)).toBe(true);
-  expect(fullPrompt.endsWith(split.body)).toBe(true);
-});
-
-test('each block strips independently, so one being absent still works', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-
-  const onlyStop = splitInjectedPreamble(STOP_SIGNAL_INSTRUCTION + HUMAN);
-  expect(onlyStop.body).toBe(HUMAN);
-  expect(onlyStop.blockKeys).toEqual(['stop-signal']);
-
-  const onlyTruth = splitInjectedPreamble(CHAT_MODE_TRUTH_INSTRUCTION + HUMAN);
-  expect(onlyTruth.body).toBe(HUMAN);
-  expect(onlyTruth.blockKeys).toEqual(['chat-mode-truth']);
-});
-
-test('a prompt with no injected blocks is returned untouched', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const split = splitInjectedPreamble(HUMAN);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(HUMAN);
-  expect(split.blockKeys).toEqual([]);
-});
-
-test('EDGE: a boilerplate-only prompt is NOT stripped to an empty bubble', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const onlyBoilerplate = STOP_SIGNAL_INSTRUCTION + CHAT_MODE_TRUTH_INSTRUCTION;
-  const split = splitInjectedPreamble(onlyBoilerplate);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(onlyBoilerplate);
-});
-
-test('EDGE: a truncated block (opening present, closing missing) is left fully intact', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  // Simulates a reworded/cut-off block: better to over-show boilerplate than
-  // to guess at a boundary and eat the human's words.
-  const truncated = `${STOP_SIGNAL_INSTRUCTION.slice(0, 120)}\n\n${HUMAN}`;
-  const split = splitInjectedPreamble(truncated);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(truncated);
-});
-
-test('the two blocks strip in either order', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const reversed = CHAT_MODE_TRUTH_INSTRUCTION + STOP_SIGNAL_INSTRUCTION + HUMAN;
-  const split = splitInjectedPreamble(reversed);
-  expect(split.body).toBe(HUMAN);
-  expect(split.blockKeys).toEqual(['chat-mode-truth', 'stop-signal']);
-});
-
-test('EDGE: boilerplate quoted inside the human’s own message is never stripped', async () => {
-  const { splitInjectedPreamble } = await loadSplitter();
-  const quoting = `Why does chat prepend this?\n\n${STOP_SIGNAL_INSTRUCTION}`;
-  const split = splitInjectedPreamble(quoting);
-  expect(split.preamble).toBe(null);
-  expect(split.body).toBe(quoting);
-});