blun-king-cli 9.1.536 → 9.1.550

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

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