blun-king-cli 9.1.527 → 9.1.550

package/scripts/check-resume-replay-regression.js

@@ -1,100 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
-  : path.join(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function between(start, end) {
-  const startIndex = bundle.indexOf(start);
-  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
-  const endIndex = bundle.indexOf(end, startIndex + start.length);
-  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
-  return bundle.slice(startIndex, endIndex);
-}
-
-function compileMethod(name, nextName, dependencies = {}) {
-  const source = between(`\n\t\t${name}(`, `\n\t\t${nextName}(`).trim();
-  const names = Object.keys(dependencies);
-  const values = Object.values(dependencies);
-  return Function(...names, `"use strict"; return ({${source}}).${name};`)(...values);
-}
-
-function resolveStepEventUuid(openSteps, event) {
-  if (event.stepUuid !== undefined) return event.stepUuid;
-  let latest;
-  for (const uuid of openSteps.keys()) latest = uuid;
-  return latest;
-}
-
-function resolveCompletedStepUuid(openSteps, event) {
-  if (event.uuid !== undefined) return event.uuid;
-  let latest;
-  for (const uuid of openSteps.keys()) latest = uuid;
-  return latest;
-}
-
-const recoverMissingOpenStep = compileMethod(
-  'recoverMissingOpenStep',
-  'appendLoopEvent',
-  { resolveStepEventUuid },
-);
-const appendLoopEvent = compileMethod(
-  'appendLoopEvent',
-  'appendMessage',
-  {
-    projectLoopEventForRecord: (event) => event,
-    resolveCompletedStepUuid,
-    createToolMessage: (toolCallId, content) => ({ toolCallId, content, toolCalls: [] }),
-    toolResultOutputForModel: (result) => result.output,
-    estimateTokensForMessages: () => 0,
-  },
-);
-
-const records = [];
-const warnings = [];
-const host = {
-  _history: [],
-  _tokenCount: 0,
-  tokenCountCoveredMessageCount: 0,
-  openSteps: new Map(),
-  pendingToolResultIds: new Set(),
-  agent: {
-    records: {
-      restoring: { time: Date.now() },
-      logRecord(record) { records.push(record); },
-    },
-    log: { warn(message, fields) { warnings.push({ message, fields }); } },
-  },
-  recoverMissingOpenStep,
-  pushHistory(...messages) { this._history.push(...messages); },
-  markPendingTokenEstimateDirty() {},
-  flushDeferredMessagesIfToolExchangeClosed() {},
-  closePendingToolResults() { return []; },
-};
-
-// Exact shape measured after context.apply_compaction: no step.begin survives,
-// then text, a tool call/result pair, and step.end continue the interrupted turn.
-appendLoopEvent.call(host, { type: 'content.part', part: { type: 'text', text: 'continued after compaction' } });
-appendLoopEvent.call(host, { type: 'tool.call', toolCallId: 'tool-1', name: 'Read', args: { path: 'SPEC.md' } });
-appendLoopEvent.call(host, { type: 'tool.result', toolCallId: 'tool-1', result: { output: 'ok', isError: false } });
-appendLoopEvent.call(host, { type: 'step.end', contextTokens: 100 });
-
-assert.equal(warnings.length, 1, 'one missing step must produce one bounded repair warning');
-assert.equal(warnings[0].fields.eventType, 'content.part');
-assert.equal(warnings[0].fields.restoring, true);
-assert.equal(host._history.length, 2, 'repair must retain the assistant continuation and its tool result');
-assert.deepEqual(host._history[0].content, [{ type: 'text', text: 'continued after compaction' }]);
-assert.equal(host._history[0].toolCalls.length, 1);
-assert.equal(host._history[0].toolCalls[0].id, 'tool-1');
-assert.equal(host._history[1].toolCallId, 'tool-1');
-assert.equal(host.pendingToolResultIds.size, 0);
-assert.equal(host.openSteps.size, 0);
-assert.equal(records.filter((record) => record.type === 'context.append_loop_event').length, 4);
-
-process.stdout.write('resume-replay-regression PASS\n');

package/scripts/check-session-cancel-regression.js

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
-  : path.join(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function between(start, end) {
-  const startIndex = bundle.indexOf(start);
-  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
-  const endIndex = bundle.indexOf(end, startIndex + start.length);
-  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
-  return bundle.slice(startIndex, endIndex);
-}
-
-function assertSafeCancel(source, label) {
-  assert.match(source, /\.cancel\(\)\.catch\(\(error\)\s*=>/,
-    `${label} must observe the cancellation promise`);
-  assert.match(source, /error instanceof BlunError && error\.code === ErrorCodes\.SESSION_NOT_FOUND/,
-    `${label} must treat an already-missing session as cancelled`);
-  assert.match(source, /showError\(formatErrorMessage\$2\(error\)\)/,
-    `${label} must still surface non-session errors`);
-}
-
-assertSafeCancel(
-  between('\n\tcancelCurrentStream() {', '\n\tcancelCurrentCompaction() {'),
-  'keyboard stream cancellation',
-);
-assertSafeCancel(
-  between('\n\tinjectTelegramRemoteCommand(', '\n\trunTelegramRemoteCommand('),
-  'preemptive Telegram reload cancellation',
-);
-assertSafeCancel(
-  between('\n\tenqueueSlashCommand(', '\n\tenqueueNormalUserInput('),
-  'preemptive slash-command cancellation',
-);
-
-process.stdout.write('session-cancel-regression PASS\n');

package/scripts/check-session-picker-resume-metrics-regression.js

@@ -1,97 +0,0 @@
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
-  : path.join(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-const rowsMatch = /function sessionRowsForPicker\(sessions, currentSessionId, currentSessionHasContent\) \{([\s\S]*?)\n\}/.exec(bundle);
-assert(rowsMatch, 'SESSION_PICKER_RESUME_METRICS: sessionRowsForPicker is missing');
-const sessionRowsForPicker = Function(
-  `return function sessionRowsForPicker(sessions, currentSessionId, currentSessionHasContent) {${rowsMatch[1]}\n};`,
-)();
-
-const rows = sessionRowsForPicker([{
-  id: 'session-a',
-  title: 'A',
-  lastPrompt: 'work',
-  workDir: 'C:/work',
-  updatedAt: 1,
-  metadata: {},
-  sessionDir: 'C:/state/session-a',
-}], 'other', true);
-assert.equal(rows[0].session_dir, 'C:/state/session-a');
-
-const metricsMatch = /async function readSessionResumeMetrics\(session\) \{([\s\S]*?)\n\}\nasync function enrichSessionRowsForPicker/.exec(bundle);
-assert(metricsMatch, 'SESSION_PICKER_RESUME_METRICS: readSessionResumeMetrics is missing');
-
-function buildReader({ resumeStat, wireStat, checkpoint }) {
-  return Function(
-    'join',
-    'statSessionFile',
-    'loadResumeCheckpoint',
-    'SESSION_RESUME_STALE_AFTER_MS',
-    `return async function readSessionResumeMetrics(session) {${metricsMatch[1]}\n};`,
-  )(
-    path.join,
-    async (filePath) => filePath.endsWith('resume-checkpoint.json') ? resumeStat : wireStat,
-    async () => checkpoint,
-    60_000,
-  );
-}
-
-(async () => {
-  const missing = await buildReader({ resumeStat: null, wireStat: null, checkpoint: null })({
-    session_dir: 'C:/state/session-a',
-  });
-  assert.deepEqual(missing, { status: 'missing' });
-
-  const invalid = await buildReader({
-    resumeStat: { size: 1_024, mtimeMs: 1_000 },
-    wireStat: { size: 2_048, mtimeMs: 1_000 },
-    checkpoint: { ok: false },
-  })({ session_dir: 'C:/state/session-a' });
-  assert.deepEqual(invalid, { status: 'invalid' });
-
-  const ok = await buildReader({
-    resumeStat: { size: 1_024, mtimeMs: 1_000 },
-    wireStat: { size: 2_048, mtimeMs: 1_500 },
-    checkpoint: {
-      ok: true,
-      offset: 2_048,
-      snapshot: { context: { history: [{}, {}, {}], tokenCount: 1_200 } },
-    },
-  })({ session_dir: 'C:/state/session-a' });
-  assert.deepEqual(ok, {
-    status: 'ok',
-    resumeBytes: 1_024,
-    wireBytes: 2_048,
-    messages: 3,
-    tokens: 1_200,
-  });
-
-  const stale = await buildReader({
-    resumeStat: { size: 1_024, mtimeMs: 1_000 },
-    wireStat: { size: 4_096, mtimeMs: 62_000 },
-    checkpoint: {
-      ok: true,
-      offset: 2_048,
-      snapshot: { context: { history: [{}], tokenCount: 500 } },
-    },
-  })({ session_dir: 'C:/state/session-a' });
-  assert.equal(stale.status, 'stale');
-  assert.equal(stale.wireBytes, 4_096);
-
-  const renderBlock = /const resume = session\.resume;([\s\S]*?)\n\t\treturn card;/.exec(bundle);
-  assert(renderBlock, 'SESSION_PICKER_RESUME_METRICS: resume metrics are not rendered');
-  assert.match(renderBlock[1], /formatByteSize\(resume\.resumeBytes\)/);
-  assert.match(renderBlock[1], /formatByteSize\(resume\.wireBytes\)/);
-  assert.match(renderBlock[1], /sessionPicker\.resume\.stale/);
-
-  console.log('session-picker-resume-metrics-regression PASS');
-})().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/scripts/check-session-start-hook-context-regression.js

@@ -1,228 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
-  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
-  : path.resolve(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-const renderer = bundle.match(
-  /function renderSessionStartHookResult\(results\) \{[\s\S]*?\n\}/,
-);
-const allowRenderer = bundle.match(
-  /function renderAllowHookResult\(event, results\) \{[\s\S]*?\n\}/,
-);
-const wrapperRenderer = bundle.match(
-  /function renderHookResult\(event, message\) \{[\s\S]*?\n\}/,
-);
-const messageSelector = bundle.match(
-  /function userPromptHookMessage\(result\) \{[\s\S]*?\n\}/,
-);
-const stringPredicate = bundle.match(
-  /function isNonEmptyString\$1\(value\) \{[\s\S]*?\n\}/,
-);
-const trigger = bundle.match(
-  /async triggerSessionStart\(source\) \{[\s\S]*?\n\t\t\}/,
-);
-const scheduler = bundle.match(
-  /scheduleSessionStart\(source\) \{[\s\S]*?\n\t\t\}/,
-);
-const createMain = bundle.match(
-  /async createMain\(\) \{[\s\S]*?\n\t\t\}/,
-);
-const resume = bundle.match(
-  /async resume\(\) \{[\s\S]*?\n\t\t\}/,
-);
-
-assert(renderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart renderer is missing');
-assert(allowRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: shared allow renderer is missing');
-assert(wrapperRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook wrapper renderer is missing');
-assert(messageSelector, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook message selector is missing');
-assert(stringPredicate, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook string predicate is missing');
-assert(trigger, 'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart trigger is missing');
-assert(scheduler, 'SESSION_START_HOOK_CONTEXT_REGRESSION: non-blocking SessionStart scheduler is missing');
-assert(createMain, 'SESSION_START_HOOK_CONTEXT_REGRESSION: createMain is missing');
-assert(resume, 'SESSION_START_HOOK_CONTEXT_REGRESSION: resume is missing');
-assert(
-  /renderAllowHookResult\("SessionStart", results\)/.test(renderer[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart output is not rendered',
-);
-assert(
-  /const results = await this\.hookEngine\.trigger\("SessionStart"/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart results are still discarded',
-);
-assert(
-  /renderSessionStartHookResult\(results\)/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart result does not reach the context path',
-);
-assert(
-  /appendSystemReminder\([\s\S]*variant: "session_start_hook"/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart result is not persisted as a scoped reminder',
-);
-assert(
-  /await mainAgent\.records\.flush\(\)/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: completed SessionStart reminder is not flushed',
-);
-assert(
-  /this\.scheduleSessionStart\("startup"\)/.test(createMain[0])
-    && !/await this\.triggerSessionStart\("startup"\)/.test(createMain[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: fresh-session input is still blocked by SessionStart',
-);
-assert(
-  /this\.scheduleSessionStart\("resume"\)/.test(resume[0])
-    && !/await this\.triggerSessionStart\("resume"\)/.test(resume[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: resumed-session input is still blocked by SessionStart',
-);
-assert(
-  /void this\.triggerSessionStart\(source\)\.catch\(/.test(scheduler[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart is not detached from interactive startup',
-);
-
-const packageRoot = path.resolve(__dirname, '..');
-const agentSpineRoot = path.join(packageRoot, 'agent-spine-plugin');
-const agentSpineManifest = JSON.parse(
-  fs.readFileSync(path.join(agentSpineRoot, 'blun.plugin.json'), 'utf8'),
-);
-const agentSpineCodexHooks = JSON.parse(
-  fs.readFileSync(path.join(agentSpineRoot, 'hooks', 'codex.json'), 'utf8'),
-);
-const blunSessionStart = agentSpineManifest.hooks.find(
-  (hook) => hook.event === 'SessionStart',
-);
-const codexSessionStart = agentSpineCodexHooks.hooks.SessionStart?.[0]?.hooks?.[0];
-
-assert(
-  blunSessionStart?.timeout >= 180,
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover the measured 123.6 s cold scan',
-);
-assert(
-  codexSessionStart?.timeout >= 180,
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: Codex AgentSpine SessionStart timeout must match the BLUN runtime budget',
-);
-
-const probeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-session-start-hook-'));
-try {
-  fs.mkdirSync(path.join(probeRoot, '.git'));
-  fs.writeFileSync(
-    path.join(probeRoot, 'AGENTS.md'),
-    '# SessionStart probe\n\nLoad this project instruction automatically.\n',
-  );
-  const stateRoot = path.join(probeRoot, '.agentspine-state');
-  const hookRun = spawnSync(process.execPath, [path.join(agentSpineRoot, 'src', 'hook.js')], {
-    cwd: agentSpineRoot,
-    input: JSON.stringify({
-      hook_event_name: 'SessionStart',
-      session_id: 'session-start-regression',
-      cwd: probeRoot,
-      source: 'resume',
-    }),
-    encoding: 'utf8',
-    timeout: 30_000,
-    env: {
-      ...process.env,
-      BLUN_HOME: probeRoot,
-      BLUN_PLUGIN_ROOT: agentSpineRoot,
-      AGENTSPINE_STATE_DIR: stateRoot,
-    },
-  });
-  assert(
-    hookRun.error === undefined && hookRun.status === 0,
-    `SESSION_START_HOOK_CONTEXT_REGRESSION: real AgentSpine hook failed: ${hookRun.error?.message || hookRun.stderr}`,
-  );
-  const hookOutput = JSON.parse(hookRun.stdout.trim());
-  assert(
-    hookOutput.hookSpecificOutput?.hookEventName === 'SessionStart'
-      && hookOutput.hookSpecificOutput?.message?.includes('AgentSpine'),
-    `SESSION_START_HOOK_CONTEXT_REGRESSION: real AgentSpine process output is not injectable: ${hookRun.stdout.trim()}`,
-  );
-} finally {
-  fs.rmSync(probeRoot, { recursive: true, force: true });
-}
-
-const triggerFunction = trigger[0].replace(
-  /^async triggerSessionStart/,
-  'async function triggerSessionStart',
-);
-const schedulerFunction = scheduler[0].replace(
-  /^scheduleSessionStart/,
-  'function scheduleSessionStart',
-);
-const runTrigger = Function(
-  `${wrapperRenderer[0]}\n${messageSelector[0]}\n${stringPredicate[0]}\n${allowRenderer[0]}\n${renderer[0]}\n${triggerFunction}\nreturn triggerSessionStart;`,
-)();
-const scheduleTrigger = Function(
-  `${schedulerFunction}\nreturn scheduleSessionStart;`,
-)();
-
-(async () => {
-  const reminders = [];
-  let flushes = 0;
-  const fakeSession = {
-    hookEngine: {
-      async trigger(event, args) {
-        assert(event === 'SessionStart', 'runtime probe called the wrong hook event');
-        assert(args.matcherValue === 'resume', 'runtime probe lost the reload matcher');
-        return [{ action: 'allow', message: 'AgentSpine ready: 152 sources indexed.' }];
-      },
-    },
-    requireMainAgent() {
-      return {
-        context: {
-          appendSystemReminder(text, origin) {
-            reminders.push({ text, origin });
-          },
-        },
-        records: {
-          async flush() {
-            flushes += 1;
-          },
-        },
-      };
-    },
-  };
-
-  await runTrigger.call(fakeSession, 'resume');
-  assert(reminders.length === 1, 'runtime probe did not append exactly one reminder');
-  assert(flushes === 1, 'runtime probe did not flush exactly once');
-  assert(
-    reminders[0].text.includes('<hook_result hook_event="SessionStart">')
-      && reminders[0].text.includes('AgentSpine ready: 152 sources indexed.'),
-    'runtime probe lost the AgentSpine SessionStart message',
-  );
-  assert(
-    reminders[0].origin?.kind === 'injection'
-      && reminders[0].origin?.variant === 'session_start_hook',
-    'runtime probe used the wrong reminder origin',
-  );
-
-  let detachedCompleted = false;
-  const detachedStartedAt = Date.now();
-  scheduleTrigger.call({
-    async triggerSessionStart(source) {
-      assert(source === 'startup', 'detached runtime probe lost the startup source');
-      await new Promise((resolve) => setTimeout(resolve, 75));
-      detachedCompleted = true;
-    },
-    log: { warn() {} },
-  }, 'startup');
-  assert(
-    Date.now() - detachedStartedAt < 50 && detachedCompleted === false,
-    'SessionStart scheduler still waits for the hook before returning',
-  );
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  assert(detachedCompleted, 'detached SessionStart hook did not finish in the background');
-
-  process.stdout.write('session-start-hook-context-regression PASS\n');
-})().catch((error) => {
-  process.stderr.write(`${error.stack || error.message}\n`);
-  process.exitCode = 1;
-});

package/scripts/check-shell-terminal-isolation-regression.js

@@ -1,81 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const vm = require('node:vm');
-const { spawn } = require('node:child_process');
-
-const packageRoot = path.resolve(__dirname, '..');
-const bundlePath = process.argv[2] === undefined
-  ? path.join(packageRoot, 'blun.mjs')
-  : path.resolve(process.argv[2]);
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-const source = /function buildLocalSpawnOptions\(isWindows, cwd, env\) \{[\s\S]*?\n\}/.exec(bundle)?.[0];
-
-assert(source, 'SHELL_TERMINAL_ISOLATION: buildLocalSpawnOptions is missing');
-
-const context = {};
-vm.runInNewContext(`${source}; globalThis.buildLocalSpawnOptions = buildLocalSpawnOptions;`, context);
-const buildLocalSpawnOptions = context.buildLocalSpawnOptions;
-const cwd = packageRoot;
-const env = { ...process.env, BLUN_SHELL_ISOLATION_PROBE: '1' };
-
-for (const isWindows of [false, true]) {
-  const options = buildLocalSpawnOptions(isWindows, cwd, env);
-  assert.deepEqual(Array.from(options.stdio), ['pipe', 'pipe', 'pipe']);
-  assert.equal(options.detached, true,
-    `local shell must start in a separate process group when isWindows=${String(isWindows)}`);
-  assert.equal(options.windowsHide, true);
-  assert.equal(options.cwd, cwd);
-  assert.equal(options.env, env);
-}
-
-async function runCapturedProcessProbe() {
-  const options = buildLocalSpawnOptions(process.platform === 'win32', cwd, env);
-  const child = spawn(process.execPath, [
-    '-e',
-    [
-      "process.stdin.setEncoding('utf8')",
-      "process.stdin.on('data', () => { process.exitCode = 90 })",
-      "process.stdin.on('end', () => {",
-      "  process.stdout.write('stdout-ok')",
-      "  process.stderr.write('stderr-ok')",
-      '})',
-    ].join(';'),
-  ], options);
-
-  let stdout = '';
-  let stderr = '';
-  child.stdout.setEncoding('utf8');
-  child.stderr.setEncoding('utf8');
-  child.stdout.on('data', (chunk) => { stdout += chunk; });
-  child.stderr.on('data', (chunk) => { stderr += chunk; });
-  child.stdin.end();
-
-  const exit = await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      child.kill();
-      reject(new Error('captured child did not observe stdin EOF'));
-    }, 10_000);
-    child.once('error', (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-    child.once('close', (code, signal) => {
-      clearTimeout(timer);
-      resolve({ code, signal });
-    });
-  });
-
-  assert.deepEqual(exit, { code: 0, signal: null });
-  assert.equal(stdout, 'stdout-ok');
-  assert.equal(stderr, 'stderr-ok');
-}
-
-runCapturedProcessProbe().then(() => {
-  process.stdout.write('shell-terminal-isolation-regression PASS\n');
-}).catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/scripts/check-slash-escape-regression.js

@@ -1,89 +0,0 @@
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const packageRoot = path.resolve(__dirname, '..');
-const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
-const match = /editor\.onEscape = \(autocompleteCancelled = false\) => \{([\s\S]*?)\n\t\t\};\n\t\teditor\.onShiftTab =/.exec(bundle);
-assert(match, 'SLASH_ESCAPE_REGRESSION: editor.onEscape handler is missing');
-
-const runEscape = Function('host', 'editor', 'autocompleteCancelled', match[1]);
-const ctrlSMatch = /editor\.onCtrlS = \(\) => \{([\s\S]*?)\n\t\t\};\n\t\teditor\.onCtrlB =/.exec(bundle);
-assert(ctrlSMatch, 'SLASH_ESCAPE_REGRESSION: editor.onCtrlS handler is missing');
-const runCtrlS = Function('host', 'editor', ctrlSMatch[1]);
-
-function probe(initialText, autocompleteCancelled) {
-  let text = initialText;
-  const editor = {
-    inputMode: 'prompt',
-    getText: () => text,
-    setText: (value) => { text = value; },
-  };
-  const host = {
-    cancelInFlight: undefined,
-    queueSteerInFlight: undefined,
-    state: {
-      activeDialog: null,
-      appState: {
-        isCompacting: false,
-        streamingPhase: 'idle',
-      },
-    },
-    streamingUI: { hasActiveTurn: () => false },
-    btwPanelController: { closeOrCancel: () => false },
-  };
-  const controller = {
-    pendingExit: null,
-    pendingUndoEsc: null,
-    clearPendingExit() {},
-    clearPendingUndoEsc() {},
-    armPendingUndoEsc() {},
-  };
-
-  runEscape.call(controller, host, editor, autocompleteCancelled);
-  return text;
-}
-
-assert.equal(
-  probe('/reload', true),
-  '',
-  'SLASH_ESCAPE_REGRESSION: Escape must cancel the open slash-command draft together with its menu',
-);
-assert.equal(
-  probe('ordinary draft', true),
-  'ordinary draft',
-  'SLASH_ESCAPE_REGRESSION: cancelling ordinary autocomplete must preserve the draft',
-);
-
-let flushed = null;
-const idleHost = {
-  streamingUI: { hasActiveTurn: () => false },
-  state: {
-    appState: { streamingPhase: 'idle' },
-    ui: { requestRender() {} },
-  },
-  flushQueuedMessages: (draft, mode) => { flushed = { draft, mode }; },
-  updateQueueDisplay() {},
-};
-const slashEditor = {
-  inputMode: 'prompt',
-  getText: () => '/reload',
-};
-runCtrlS(idleHost, slashEditor);
-assert.deepEqual(
-  flushed,
-  { draft: '/reload', mode: 'prompt' },
-  'SLASH_ESCAPE_REGRESSION: Ctrl+S must hand an idle slash draft to the existing queue drain',
-);
-flushed = null;
-runCtrlS(idleHost, {
-  inputMode: 'prompt',
-  getText: () => 'ordinary draft',
-});
-assert.equal(
-  flushed,
-  null,
-  'SLASH_ESCAPE_REGRESSION: the existing idle behavior for ordinary drafts must stay unchanged',
-);
-
-console.log('slash-escape-regression PASS (Escape + Ctrl+S)');