blun-king-cli 9.1.536 → 9.1.561

package/scripts/check-queue-controls-regression.js

@@ -1,189 +0,0 @@
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const path = require('node:path');
-const { enqueueTelegramAddressed } = require('../bin/telegram-addressed-priority.cjs');
-const { enqueueTelegramBotPriority } = require('../bin/telegram-bot-priority.cjs');
-const { enqueueTelegramDirect } = require('../bin/telegram-direct-focus-policy.cjs');
-const { enqueueTelegramUrgent } = require('../bin/telegram-urgent-policy.cjs');
-
-const bundle = fs.readFileSync(path.join(__dirname, '..', 'blun.mjs'), '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 method(name, nextName) {
-  const source = between(`\n\t${name}(`, `\n\t${nextName}(`).trim();
-  return Function(`"use strict"; return ({${source}}).${name};`)();
-}
-
-const ctrlS = between('\n\t\teditor.onCtrlS = () => {', '\n\t\teditor.onCtrlB =');
-assert.match(ctrlS, /host\.flushQueuedMessages\(/);
-assert.doesNotMatch(ctrlS, /toggleTodoPanelExpansion|shortcut_todo_expand/);
-
-const escape = between('\n\t\teditor.onEscape =', '\n\t\teditor.onShiftTab =');
-const releaseIndex = escape.indexOf('host.releaseNextQueuedMessage()');
-const cancelIndex = escape.indexOf('host.markCurrentRunCancelledByUser()');
-assert.ok(releaseIndex >= 0, 'Escape must release queued work');
-assert.ok(cancelIndex > releaseIndex, 'Escape must release queued work before cancelling the run');
-
-const releaseNextQueuedMessage = method('releaseNextQueuedMessage', 'markCurrentRunCancelledByUser');
-const releaseHost = {
-  queueSteerInFlight: undefined,
-  queueFlushBatchRemaining: 0,
-  state: {
-    queuedMessages: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
-    ui: { requestRender() {} },
-  },
-  steerQueueFlushPrefixCalls: 0,
-  updateQueueDisplayCalls: 0,
-  steerQueueFlushPrefix() { this.steerQueueFlushPrefixCalls += 1; },
-  updateQueueDisplay() { this.updateQueueDisplayCalls += 1; },
-};
-
-assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
-assert.equal(releaseHost.queueFlushBatchRemaining, 1);
-assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
-assert.equal(releaseHost.queueFlushBatchRemaining, 2);
-assert.equal(releaseNextQueuedMessage.call(releaseHost), true);
-assert.equal(releaseHost.queueFlushBatchRemaining, 3);
-assert.equal(releaseNextQueuedMessage.call(releaseHost), false);
-assert.equal(releaseHost.queueFlushBatchRemaining, 3);
-assert.equal(releaseHost.steerQueueFlushPrefixCalls, 3);
-
-const flushQueuedMessages = method('flushQueuedMessages', 'steerQueueFlushPrefix');
-const flushHost = {
-  queueSteerInFlight: { items: [{ text: 'already accepted' }] },
-  queueFlushBatchRemaining: 0,
-  state: {
-    queuedMessages: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
-    editor: { setText() {}, inputMode: 'prompt' },
-  },
-  steerQueueFlushPrefixCalls: 0,
-  scheduleQueueDrainCalls: 0,
-  steerQueueFlushPrefix() { this.steerQueueFlushPrefixCalls += 1; },
-  scheduleQueueDrain() { this.scheduleQueueDrainCalls += 1; },
-};
-
-flushQueuedMessages.call(flushHost, '', 'prompt');
-assert.equal(flushHost.queueFlushBatchRemaining, 4);
-assert.equal(flushHost.steerQueueFlushPrefixCalls, 1);
-assert.equal(flushHost.scheduleQueueDrainCalls, 1);
-
-const commitQueuedSteer = method('commitQueuedSteer', 'recoverRejectedActiveSteer');
-let commits = 0;
-const inFlight = {
-  items: [{ text: 'telegram message' }],
-  confirmationTimer: undefined,
-  onCommit() { commits += 1; },
-};
-const commitHost = {
-  queueSteerInFlight: inFlight,
-  updateQueueDisplay() {},
-  state: { ui: { requestRender() {} } },
-  steerQueueFlushPrefix() {},
-  scheduleQueueDrain() {},
-};
-
-commitQueuedSteer.call(commitHost, inFlight);
-commitQueuedSteer.call(commitHost, inFlight);
-assert.equal(commits, 1);
-assert.equal(commitHost.queueSteerInFlight, undefined);
-
-const acceptQueuedSteer = method('acceptQueuedSteer', 'commitQueuedSteerIfReady');
-let acceptedCommits = 0;
-const acceptedInFlight = {
-  items: [{ channelDeliveryTrace: { messageId: '63508' } }],
-  accepted: false,
-  stepStarted: false,
-  turnEnded: false,
-  onCommit() { acceptedCommits += 1; },
-};
-const acceptedHost = {
-  queueSteerInFlight: acceptedInFlight,
-  traced: [],
-  traceTelegramDelivery(event) { this.traced.push(event); },
-  commitQueuedSteer(item) {
-    assert.equal(item, acceptedInFlight);
-    if (this.queueSteerInFlight !== item) return;
-    this.queueSteerInFlight = undefined;
-    item.onCommit();
-  },
-};
-
-assert.equal(acceptQueuedSteer.call(acceptedHost, acceptedInFlight, {
-  accepted: true,
-  duplicate: false,
-  turnId: 77,
-}, true), true);
-assert.equal(acceptedCommits, 1, 'durably accepted steer must commit before a delayed step event');
-assert.equal(acceptedHost.queueSteerInFlight, undefined);
-assert.equal(acceptedHost.traced.length, 1);
-assert.equal(acceptedHost.traced[0].stage, 'accepted');
-
-const recoverRejectedActiveSteer = method('recoverRejectedActiveSteer', 'quarantineQueuedSteer');
-let restored = 0;
-const rejectedInFlight = {
-  items: [{ text: 'keep me queued', channelDeliveryFailures: 2 }],
-  onRestore() { restored += 1; },
-};
-const rejectedHost = {
-  queueSteerInFlight: rejectedInFlight,
-  state: { queuedMessages: [], ui: { requestRender() {} } },
-  traced: [],
-  traceTelegramDelivery(event) { this.traced.push(event); },
-  updateQueueDisplay() {},
-  streamingUI: { hasActiveTurn() { return true; } },
-};
-
-assert.equal(recoverRejectedActiveSteer.call(rejectedHost, rejectedInFlight), false);
-assert.equal(restored, 1);
-assert.equal(rejectedHost.state.queuedMessages.length, 1, 'rejected steer must remain queued');
-assert.equal(rejectedHost.state.queuedMessages[0].text, 'keep me queued');
-assert.equal('channelDeliveryFailures' in rejectedHost.state.queuedMessages[0], false);
-
-const channelDelivery = between('\n\tasync deliverQueuedChannelHead() {', '\n\tinstallChannelReplyGuard(');
-assert.match(
-  channelDelivery,
-  /if \(!result\.accepted\) return this\.recoverRejectedActiveSteer\(inFlight\);[\s\S]*return this\.acceptQueuedSteer\(inFlight, result, true\);/,
-  'channel delivery must commit a durably accepted active steer',
-);
-assert.doesNotMatch(
-  channelDelivery,
-  /channel steer confirmation timed out|CHANNEL_STEER_CONFIRM_TIMEOUT_MS/,
-  'durably accepted channel messages must not be restored by a wall-clock timeout',
-);
-
-const ctrlSDelivery = between('\n\tsteerQueueFlushPrefix() {', '\n\tdrainOneQueuedMessage() {');
-assert.match(
-  ctrlSDelivery,
-  /if \(!result\.accepted\) this\.recoverRejectedActiveSteer\(inFlight\);[\s\S]*else this\.acceptQueuedSteer\(inFlight, result\);/,
-  'Ctrl+S delivery must use the same durable acceptance rule',
-);
-
-const priorityQueue = [{ id: 'normal-a' }, { id: 'normal-b' }];
-enqueueTelegramBotPriority(priorityQueue, { id: 'bot-a', channelBotPriority: true });
-enqueueTelegramBotPriority(priorityQueue, { id: 'bot-b', channelBotPriority: true });
-enqueueTelegramAddressed(priorityQueue, { id: 'addressed-a', channelAddressed: true });
-enqueueTelegramAddressed(priorityQueue, { id: 'addressed-b', channelAddressed: true });
-enqueueTelegramDirect(priorityQueue, { id: 'direct-a', channelDirect: true });
-enqueueTelegramDirect(priorityQueue, { id: 'direct-b', channelDirect: true });
-enqueueTelegramUrgent(priorityQueue, { id: 'urgent-a', channelUrgent: true });
-enqueueTelegramUrgent(priorityQueue, { id: 'urgent-b', channelUrgent: true });
-assert.deepEqual(
-  priorityQueue.map((item) => item.id),
-  [
-    'urgent-a', 'urgent-b',
-    'direct-a', 'direct-b',
-    'addressed-a', 'addressed-b',
-    'bot-a', 'bot-b',
-    'normal-a', 'normal-b',
-  ],
-  'Telegram queue priority must be urgent, direct, addressed, bot, normal with stable FIFO inside each class',
-);
-
-console.log('queue controls regression: PASS');

package/scripts/check-release-metadata.js

@@ -1,103 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const DEFAULT_MANIFEST_URL = 'https://chat.blun.ai/blun-code-version.json';
-const DEFAULT_DOCS_URL = 'https://docs.blun.ai/changelog.html';
-const DEFAULT_REGISTRY_URL = 'https://registry.npmjs.org';
-const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-function readUtf8(filePath) {
-  return fs.readFileSync(filePath, 'utf8');
-}
-
-function firstChangelogVersion(changelog) {
-  return /^##\s+(\d+\.\d+\.\d+)\b/mu.exec(changelog)?.[1] || null;
-}
-
-function checkLocalReleaseMetadata(root = path.resolve(__dirname, '..')) {
-  const packageJson = JSON.parse(readUtf8(path.join(root, 'package.json')));
-  const version = String(packageJson.version || '');
-  const packageName = String(packageJson.name || '');
-  assert(/^\d+\.\d+\.\d+$/u.test(version), 'RELEASE_VERSION_INVALID');
-  assert(packageName.length > 0, 'RELEASE_PACKAGE_NAME_MISSING');
-
-  const changelogVersion = firstChangelogVersion(readUtf8(path.join(root, 'CHANGELOG.md')));
-  assert(changelogVersion === version, `CHANGELOG_VERSION_MISMATCH:${changelogVersion || 'missing'}!=${version}`);
-
-  const installNeedle = `${packageName}@${version}`;
-  for (const fileName of ['README.md', 'LIESMICH.txt']) {
-    assert(readUtf8(path.join(root, fileName)).includes(installNeedle), `INSTALL_VERSION_MISMATCH:${fileName}`);
-  }
-  return { packageName, version };
-}
-
-async function fetchLimited(url, kind) {
-  const response = await fetch(url, {
-    headers: { accept: kind === 'json' ? 'application/json' : 'text/html' },
-    redirect: 'follow',
-    signal: AbortSignal.timeout(15_000),
-  });
-  assert(response.ok, `RELEASE_FETCH_FAILED:${response.status}:${url}`);
-  const declaredLength = Number(response.headers.get('content-length'));
-  assert(!Number.isFinite(declaredLength) || declaredLength <= MAX_RESPONSE_BYTES, `RELEASE_RESPONSE_TOO_LARGE:${url}`);
-  const body = await response.text();
-  assert(Buffer.byteLength(body, 'utf8') <= MAX_RESPONSE_BYTES, `RELEASE_RESPONSE_TOO_LARGE:${url}`);
-  return kind === 'json' ? JSON.parse(body) : body;
-}
-
-async function checkExternalReleaseMetadata(local, options = {}) {
-  const cacheBust = `cb=${Date.now()}`;
-  const registryUrl = options.registryUrl || DEFAULT_REGISTRY_URL;
-  const manifestUrl = `${options.manifestUrl || DEFAULT_MANIFEST_URL}?${cacheBust}`;
-  const docsUrl = `${options.docsUrl || DEFAULT_DOCS_URL}?${cacheBust}`;
-  const encodedName = encodeURIComponent(local.packageName);
-  const [tags, metadata, manifest, docs] = await Promise.all([
-    fetchLimited(`${registryUrl}/-/package/${encodedName}/dist-tags`, 'json'),
-    fetchLimited(`${registryUrl}/${encodedName}/${local.version}`, 'json'),
-    fetchLimited(manifestUrl, 'json'),
-    fetchLimited(docsUrl, 'html'),
-  ]);
-
-  assert(tags.latest === local.version, `NPM_LATEST_MISMATCH:${tags.latest || 'missing'}!=${local.version}`);
-  assert(metadata.version === local.version, `NPM_VERSION_MISMATCH:${metadata.version || 'missing'}!=${local.version}`);
-  assert(manifest.name === local.packageName, `MANIFEST_PACKAGE_MISMATCH:${manifest.name || 'missing'}!=${local.packageName}`);
-  assert(manifest.latest === local.version, `MANIFEST_VERSION_MISMATCH:${manifest.latest || 'missing'}!=${local.version}`);
-  assert(typeof metadata.dist?.integrity === 'string' && metadata.dist.integrity.length > 0, 'NPM_INTEGRITY_MISSING');
-  assert(manifest.integrity === metadata.dist.integrity, 'MANIFEST_INTEGRITY_MISMATCH');
-  assert(docs.includes(`<title>BLUN King ${local.version} `), `PUBLIC_CHANGELOG_VERSION_MISMATCH:${local.version}`);
-  return { ...local, integrity: metadata.dist.integrity };
-}
-
-function parseArgs(argv) {
-  const external = argv.includes('--external');
-  const rootArg = argv.find((arg) => arg.startsWith('--root='));
-  return { external, root: rootArg ? path.resolve(rootArg.slice('--root='.length)) : undefined };
-}
-
-async function main(argv = process.argv.slice(2)) {
-  const options = parseArgs(argv);
-  const local = checkLocalReleaseMetadata(options.root);
-  const result = options.external ? await checkExternalReleaseMetadata(local) : local;
-  process.stdout.write(`release-metadata PASS ${JSON.stringify(result)}\n`);
-  return result;
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    process.stderr.write(`release-metadata BLOCK ${error.message}\n`);
-    process.exitCode = 1;
-  });
-}
-
-module.exports = {
-  checkExternalReleaseMetadata,
-  checkLocalReleaseMetadata,
-  firstChangelogVersion,
-  main,
-};

package/scripts/check-reload-agent-spine-regression.js

@@ -1,76 +0,0 @@
-'use strict';
-
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const rootArg = process.argv.find((value) => value.startsWith('--root='));
-const packageRoot = rootArg ? path.resolve(rootArg.slice('--root='.length)) : path.resolve(__dirname, '..');
-const bundle = fs.readFileSync(path.join(packageRoot, 'blun.mjs'), 'utf8');
-const reloadStart = bundle.indexOf('async reloadSession(input) {');
-const bootstrapCall = bundle.indexOf('installBundledAgentSpineForReload({ blunDir: this.homeDir });', reloadStart);
-const pluginReload = bundle.indexOf('await this.reloadPlugins({});', reloadStart);
-
-assert.notEqual(reloadStart, -1, 'reloadSession must exist');
-assert.ok(
-  bootstrapCall > reloadStart && bootstrapCall < pluginReload,
-  '/reload must materialize bundled AgentSpine before reloading the plugin catalogue',
-);
-
-const helperPath = path.join(packageRoot, 'bin', 'reload-plugin-bootstrap.cjs');
-assert.ok(fs.existsSync(helperPath), 'reload plugin bootstrap helper must be packaged');
-const { installBundledAgentSpineForReload } = require(helperPath);
-
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-reload-agent-spine-'));
-const profile = path.join(root, 'profile');
-const pluginsDir = path.join(profile, 'plugins');
-const installedFile = path.join(pluginsDir, 'installed.json');
-const unrelatedRoot = path.join(root, 'unrelated-plugin');
-fs.mkdirSync(pluginsDir, { recursive: true });
-fs.mkdirSync(unrelatedRoot, { recursive: true });
-fs.writeFileSync(installedFile, `${JSON.stringify({
-  version: 1,
-  plugins: [{
-    id: 'unrelated',
-    root: unrelatedRoot,
-    source: 'local-path',
-    enabled: false,
-    capabilities: {},
-  }],
-}, null, 2)}\n`);
-
-try {
-  const first = installBundledAgentSpineForReload({
-    packageRoot,
-    blunDir: profile,
-    now: '2026-09-01T00:00:00.000Z',
-  });
-  const installed = JSON.parse(fs.readFileSync(installedFile, 'utf8'));
-  const agentSpine = installed.plugins.find((plugin) => plugin.id === 'agent-spine');
-  const unrelated = installed.plugins.find((plugin) => plugin.id === 'unrelated');
-
-  assert.ok(agentSpine, 'reload bootstrap must add bundled AgentSpine');
-  assert.equal(agentSpine.root, first.pluginRoot);
-  assert.equal(agentSpine.enabled, true);
-  assert.equal(agentSpine.capabilities.mcpServers['agent-spine'].enabled, true);
-  assert.equal(unrelated.root, unrelatedRoot, 'reload bootstrap must preserve unrelated plugins');
-  assert.equal(unrelated.enabled, false, 'reload bootstrap must preserve unrelated plugin state');
-  assert.equal(
-    fs.readFileSync(path.join(agentSpine.root, 'package.json'), 'utf8'),
-    fs.readFileSync(path.join(packageRoot, 'agent-spine-plugin', 'package.json'), 'utf8'),
-    'managed AgentSpine must come from the current package bundle',
-  );
-
-  const beforeSecondRun = fs.readFileSync(installedFile, 'utf8');
-  const second = installBundledAgentSpineForReload({
-    packageRoot,
-    blunDir: profile,
-    now: '2026-09-01T00:01:00.000Z',
-  });
-  assert.equal(second.reused, true, 'an unchanged bundle must be reused');
-  assert.equal(fs.readFileSync(installedFile, 'utf8'), beforeSecondRun, 'idempotent reload must not rewrite installed.json');
-  process.stdout.write('Reload AgentSpine regression gate: PASS\n');
-} finally {
-  fs.rmSync(root, { recursive: true, force: true });
-}

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

@@ -1,102 +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 { isWireOnlyProgrammaticEvent } = require('../bin/programmatic-context-isolation.cjs');
-
-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,
-    isWireOnlyProgrammaticEvent,
-    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;
-});