blun-king-cli 9.1.527 → 9.1.550

package/scripts/check-copy-command-regression.js

@@ -1,74 +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 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');
-
-function extractFunction(name) {
-  const start = bundle.indexOf(`function ${name}(`);
-  assert.notEqual(start, -1, `${name} must exist`);
-  const open = bundle.indexOf('{', start);
-  let depth = 0;
-  for (let index = open; index < bundle.length; index += 1) {
-    if (bundle[index] === '{') depth += 1;
-    if (bundle[index] === '}') depth -= 1;
-    if (depth === 0) return bundle.slice(start, index + 1);
-  }
-  assert.fail(`${name} must have a complete function body`);
-}
-
-assert.match(
-  bundle,
-  /name:\s*"copy"[\s\S]{0,180}descriptionKey:\s*"command\.copy\.description"[\s\S]{0,180}availability:\s*"always"/,
-  '/copy must be registered and available while a turn is running',
-);
-assert.match(bundle, /case "copy":\s*await handleCopyCommand\(host\);\s*return;/, '/copy must dispatch to its handler');
-assert.match(bundle, /await copyTextToClipboard\(text\);/, '/copy must use the existing cross-platform clipboard helper');
-
-const selectorSource = extractFunction('findLatestAssistantResponse');
-const findLatestAssistantResponse = vm.runInNewContext(`(${selectorSource})`);
-assert.equal(
-  findLatestAssistantResponse([
-    { kind: 'assistant', content: '  previous answer  ' },
-    { kind: 'user', content: 'question' },
-    { kind: 'assistant', content: '   ' },
-  ]),
-  '  previous answer  ',
-  'the selector must ignore user and empty assistant entries while preserving response bytes',
-);
-assert.equal(findLatestAssistantResponse([{ kind: 'user', content: 'question' }]), undefined);
-
-const requiredUiStrings = [
-  'Copy the latest assistant response to the clipboard.',
-  'Copied the latest response to the clipboard.',
-  'There is no response to copy yet.',
-  'Could not copy the latest response: {error}',
-  'Neueste Assistentenantwort in die Zwischenablage übernehmen.',
-  'Die neueste Antwort wurde in die Zwischenablage übernommen.',
-  'Es ist noch keine Antwort zum Kopieren verfügbar.',
-  'Die neueste Antwort konnte nicht kopiert werden: {error}',
-  'Copiar la respuesta más reciente del asistente al portapapeles.',
-  'La respuesta más reciente se copió al portapapeles.',
-  'Todavía no hay ninguna respuesta que copiar.',
-  'No se pudo copiar la respuesta más reciente: {error}',
-  'Copier la réponse la plus récente de l’assistant dans le presse-papiers.',
-  'La réponse la plus récente a été copiée dans le presse-papiers.',
-  'Aucune réponse à copier pour le moment.',
-  'Impossible de copier la réponse la plus récente : {error}',
-  'Kopiera assistentens senaste svar till urklipp.',
-  'Det senaste svaret kopierades till urklipp.',
-  'Det finns inget svar att kopiera ännu.',
-  'Det gick inte att kopiera det senaste svaret: {error}',
-  'Zkopírovat nejnovější odpověď asistenta do schránky.',
-  'Nejnovější odpověď byla zkopírována do schránky.',
-  'Zatím není k dispozici žádná odpověď ke zkopírování.',
-  'Nejnovější odpověď se nepodařilo zkopírovat: {error}',
-];
-for (const text of requiredUiStrings) assert.ok(bundle.includes(text), `missing released UI text: ${text}`);
-
-process.stdout.write('Copy command regression gate: PASS\n');

package/scripts/check-historical-tool-result-preview-regression.js

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-'use 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.resolve(__dirname, '..', 'blun.mjs');
-const bundle = fs.readFileSync(bundlePath, 'utf8');
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message);
-}
-
-const rendererMatch = bundle.match(
-  /function renderHistoricalToolResultReference\(toolName, toolCallId, text, outputPath, storageMode\) \{[\s\S]*?\n\}/,
-);
-assert(rendererMatch, 'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: renderer is missing');
-const policy = require('../bin/tool-result-offload-policy.cjs');
-
-const renderHistoricalToolResultReference = Function(
-  'Buffer',
-  'TOOL_RESULT_OFFLOAD_MARKER',
-  'TOOL_RESULT_RECOVERY_PAGE_LINES',
-  'TOOL_RESULT_HISTORICAL_PREVIEW_CHARS',
-  'readContinuationLineOffset',
-  'createToolResultPreview',
-  `return (${rendererMatch[0]});`,
-)(
-  Buffer,
-  '[Tool result offloaded]',
-  20,
-  policy.TOOL_RESULT_HISTORICAL_PREVIEW_CHARS,
-  () => undefined,
-  (text, maxChars) => `${text.slice(0, maxChars / 2)}\n[preview omitted]\n${text.slice(-maxChars / 2)}`,
-);
-
-const text = `HEAD-${'a'.repeat(900)}-TAIL`;
-const rendered = renderHistoricalToolResultReference(
-  'Bash',
-  'call-preview',
-  text,
-  'C:/archive/call-preview.txt',
-  'private_archive',
-);
-
-assert(
-  rendered.includes('[preview: head and tail]'),
-  'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: historical offload has no preview marker',
-);
-assert(
-  rendered.includes('HEAD-') && rendered.includes('-TAIL'),
-  'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: historical offload does not preserve both ends',
-);
-assert(
-  rendered.includes('output_path: C:/archive/call-preview.txt'),
-  'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: recovery path was lost',
-);
-const compacted = policy.compactPersistedToolResultReference([
-  { type: 'text', text: rendered },
-]);
-const compactedText = compacted[0].text;
-assert(
-  compactedText.includes('[preview: head and tail]'),
-  'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: context compaction removed the preview',
-);
-assert(
-  compactedText.includes('HEAD-') && compactedText.includes('-TAIL'),
-  'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: compact preview lost an endpoint',
-);
-assert(
-  compactedText.length < rendered.length,
-  'HISTORICAL_TOOL_RESULT_PREVIEW_REGRESSION: compact preview is not bounded',
-);
-
-process.stdout.write('historical-tool-result-preview-regression PASS\n');

package/scripts/check-mcp-startup-wait-budget.js

@@ -1,48 +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 bundlePath = path.resolve(__dirname, '..', 'blun.mjs');
-const source = fs.readFileSync(bundlePath, 'utf8');
-const match = source.match(
-  /async function blunWaitForInitialMcpBudget\(mcp, signal\) \{[\s\S]*?\n\}/u,
-);
-assert.ok(match, 'the bundle must contain the bounded initial MCP wait helper');
-assert.match(
-  source,
-  /await blunWaitForInitialMcpBudget\(this\.agent\.mcp, signal\)/u,
-  'tool-capable turns must use the bounded initial MCP wait helper',
-);
-
-const context = vm.createContext({ setTimeout });
-vm.runInContext(`${match[0]}; globalThis.waitForInitialMcp = blunWaitForInitialMcpBudget;`, context);
-
-let initialLoadFinished = false;
-const mcp = {
-  waitForInitialLoad() {
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        initialLoadFinished = true;
-        resolve();
-      }, 20_000);
-      timer.unref();
-    });
-  },
-};
-
-(async () => {
-  const startedAt = performance.now();
-  await context.waitForInitialMcp(mcp, undefined);
-  const elapsedMs = performance.now() - startedAt;
-
-  assert.ok(elapsedMs >= 2_300, `wait budget returned too early: ${elapsedMs} ms`);
-  assert.ok(elapsedMs < 3_200, `slow optional MCP blocked the turn: ${elapsedMs} ms`);
-  assert.equal(initialLoadFinished, false, 'the slow MCP must continue loading in the background');
-  process.stdout.write(`MCP startup wait regression: PASS (${Math.round(elapsedMs)} ms)\n`);
-})().catch((error) => {
-  process.stderr.write(`${error.stack || error}\n`);
-  process.exitCode = 1;
-});

package/scripts/check-package-regression.js

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const crypto = require('node:crypto');
-const path = require('node:path');
-const {
-  comparePackagePaths,
-  listTarGzPaths,
-} = require('../bin/package-regression-policy.cjs');
-
-const [, , previousTarball, currentTarball, allowlistPath = path.join(__dirname, '..', 'release-planned-removals.json')] = process.argv;
-if (!previousTarball || !currentTarball) {
-  console.error('Usage: node scripts/check-package-regression.js <previous.tgz> <current.tgz> [planned-removals.json]');
-  process.exit(2);
-}
-
-const planned = JSON.parse(fs.readFileSync(allowlistPath, 'utf8'));
-const comparison = comparePackagePaths(
-  listTarGzPaths(previousTarball),
-  listTarGzPaths(currentTarball),
-  planned,
-);
-const sha256 = (filePath) => crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
-const result = {
-  ok: comparison.unexpectedRemovals.length === 0,
-  previous: { path: path.resolve(previousTarball), sha256: sha256(previousTarball) },
-  current: { path: path.resolve(currentTarball), sha256: sha256(currentTarball) },
-  checkedStablePaths: comparison.checkedStablePaths,
-  currentStablePaths: comparison.currentStablePaths,
-  removedCount: comparison.unexpectedRemovals.length,
-  unexpectedRemovals: comparison.unexpectedRemovals,
-};
-if (!result.ok) {
-  console.error(JSON.stringify(result, null, 2));
-  process.exit(1);
-}
-console.log(JSON.stringify(result, null, 2));

package/scripts/check-plugin-startup-regression.js

@@ -1,53 +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 { installManagedAgentSpinePlugin } = require('../bin/plugin-bootstrap');
-
-const root = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-plugin-startup-'));
-const packageRoot = path.join(root, 'package');
-const sourceRoot = path.join(packageRoot, 'agent-spine-plugin');
-const profileA = path.join(root, 'profiles', 'a');
-const profileB = path.join(root, 'profiles', 'b');
-
-fs.mkdirSync(path.join(sourceRoot, 'src'), { recursive: true });
-fs.writeFileSync(path.join(sourceRoot, 'package.json'), '{"name":"agent-spine"}\n');
-fs.writeFileSync(path.join(sourceRoot, 'src', 'mcp.js'), 'export const ready = true;\n');
-
-const originalReadFileSync = fs.readFileSync;
-let sourceReads = 0;
-fs.readFileSync = function countedReadFileSync(filePath, ...args) {
-  const absolutePath = path.resolve(String(filePath));
-  if (absolutePath === sourceRoot || absolutePath.startsWith(`${sourceRoot}${path.sep}`)) {
-    sourceReads += 1;
-  }
-  return originalReadFileSync.call(this, filePath, ...args);
-};
-
-try {
-  const first = installManagedAgentSpinePlugin({ packageRoot, blunDir: profileA });
-  installManagedAgentSpinePlugin({ packageRoot, blunDir: profileA });
-  installManagedAgentSpinePlugin({ packageRoot, blunDir: profileB });
-  installManagedAgentSpinePlugin({ packageRoot, blunDir: profileB });
-
-  assert.equal(
-    sourceReads,
-    2,
-    'one launcher process must read each managed source file only once',
-  );
-
-  fs.writeFileSync(path.join(first.pluginRoot, 'src', 'mcp.js'), 'tampered\n');
-  assert.throws(
-    () => installManagedAgentSpinePlugin({ packageRoot, blunDir: profileA }),
-    /digest mismatch/,
-    'source caching must not weaken installed-tree verification',
-  );
-
-  process.stdout.write('Plugin startup regression gate: PASS\n');
-} finally {
-  fs.readFileSync = originalReadFileSync;
-  fs.rmSync(root, { recursive: true, force: true });
-}

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 });
-}