blun-king-cli 9.1.523 → 9.1.526

package/blun.mjs

@@ -316411,7 +316411,7 @@ function buildLocalSpawnOptions(isWindows, cwd, env) {
 			"pipe",
 			"pipe"
 		],
-		detached: !isWindows,
+		detached: true,
 		windowsHide: true
 	};
 }
@@ -317353,6 +317353,7 @@ var init_core_impl = __esmMin((() => {
 			if (active?.hasActiveTurn === true) throw new BlunError(ErrorCodes.TURN_AGENT_BUSY, `Session "${summary.id}" cannot be reloaded while a turn is running`, { details: { sessionId: summary.id } });
 			this.reloadProviderManager();
 			this.clearRuntimeCache();
+			createRequire(import.meta.url)("./bin/reload-plugin-bootstrap.cjs").installBundledAgentSpineForReload({ blunDir: this.homeDir });
 			await this.reloadPlugins({});
 			if (active !== void 0) {
 				await active.closeForReload();
@@ -424165,7 +424166,8 @@ async function handleLoopCommand(host, args) {
 				host.setAppState?.({ loop });
 				host.track("loop_start", { interval: loop.interval });
 				host.showStatus(`/loop ${loop.status}`);
-				if (isStreaming(host) || host.state.appState.isCompacting) host.enqueueNormalUserInput(loop.prompt);
+				if (host.telegramRemoteCommandContext !== void 0) host.sendNormalUserInput(loop.prompt);
+				else if (isStreaming(host) || host.state.appState.isCompacting) host.enqueueNormalUserInput(loop.prompt);
 				else host.sendNormalUserInput(loop.prompt);
 				return;
 			}
@@ -500660,6 +500662,10 @@ registerUiCatalogFragment({
 		"sessionPicker.time.daysAgo": "{count}d ago",
 		"sessionPicker.current": "current",
 		"sessionPicker.imported": "imported",
+		"sessionPicker.resume.metrics": "Resume {resumeSize} · {messages} messages · {tokens} tokens · Wire {wireSize}",
+		"sessionPicker.resume.missing": "checkpoint missing",
+		"sessionPicker.resume.stale": "checkpoint stale",
+		"sessionPicker.resume.invalid": "checkpoint invalid",
 		"sessionPicker.footer.matches": "Showing {from}-{to} of {loaded} loaded / {matches} matches",
 		"sessionPicker.footer.sessions": "Showing {from}-{to} of {count} sessions",
 		"sessionPicker.footer.loadedSessions": "Showing {from}-{to} of {loaded} loaded / {total} sessions"
@@ -500684,6 +500690,10 @@ registerUiCatalogFragment({
 		"sessionPicker.time.daysAgo": "vor {count} T.",
 		"sessionPicker.current": "aktuell",
 		"sessionPicker.imported": "importiert",
+		"sessionPicker.resume.metrics": "Resume {resumeSize} · {messages} Nachrichten · {tokens} Tokens · Wire {wireSize}",
+		"sessionPicker.resume.missing": "Checkpoint fehlt",
+		"sessionPicker.resume.stale": "Checkpoint veraltet",
+		"sessionPicker.resume.invalid": "Checkpoint ungültig",
 		"sessionPicker.footer.matches": "Anzeige {from}-{to} · {loaded} geladen · {matches} Treffer",
 		"sessionPicker.footer.sessions": "Anzeige {from}-{to} von {count} Sitzungen",
 		"sessionPicker.footer.loadedSessions": "Anzeige {from}-{to} · {loaded} von {total} Sitzungen geladen"
@@ -500708,6 +500718,10 @@ registerUiCatalogFragment({
 		"sessionPicker.time.daysAgo": "hace {count} d",
 		"sessionPicker.current": "actual",
 		"sessionPicker.imported": "importada",
+		"sessionPicker.resume.metrics": "Reanudación {resumeSize} · {messages} mensajes · {tokens} tokens · Wire {wireSize}",
+		"sessionPicker.resume.missing": "Falta el punto de reanudación",
+		"sessionPicker.resume.stale": "Punto de reanudación desactualizado",
+		"sessionPicker.resume.invalid": "Punto de reanudación no válido",
 		"sessionPicker.footer.matches": "Mostrando {from}-{to} · {loaded} cargadas · {matches} coincidencias",
 		"sessionPicker.footer.sessions": "Mostrando {from}-{to} de {count} sesiones",
 		"sessionPicker.footer.loadedSessions": "Mostrando {from}-{to} · {loaded} de {total} sesiones cargadas"
@@ -500732,6 +500746,10 @@ registerUiCatalogFragment({
 		"sessionPicker.time.daysAgo": "il y a {count} j",
 		"sessionPicker.current": "actuelle",
 		"sessionPicker.imported": "importée",
+		"sessionPicker.resume.metrics": "Reprise {resumeSize} · {messages} messages · {tokens} tokens · Wire {wireSize}",
+		"sessionPicker.resume.missing": "Point de reprise manquant",
+		"sessionPicker.resume.stale": "Point de reprise obsolète",
+		"sessionPicker.resume.invalid": "Point de reprise non valide",
 		"sessionPicker.footer.matches": "Affichage de {from}-{to} · {loaded} chargées · {matches} résultats",
 		"sessionPicker.footer.sessions": "Affichage de {from}-{to} sur {count} sessions",
 		"sessionPicker.footer.loadedSessions": "Affichage de {from}-{to} · {loaded} sessions chargées sur {total}"
@@ -500756,6 +500774,10 @@ registerUiCatalogFragment({
 		"sessionPicker.time.daysAgo": "för {count} d sedan",
 		"sessionPicker.current": "aktuell",
 		"sessionPicker.imported": "importerad",
+		"sessionPicker.resume.metrics": "Återupptagning {resumeSize} · {messages} meddelanden · {tokens} token · Wire {wireSize}",
+		"sessionPicker.resume.missing": "Återupptagningspunkt saknas",
+		"sessionPicker.resume.stale": "Återupptagningspunkt är inaktuell",
+		"sessionPicker.resume.invalid": "Ogiltig återupptagningspunkt",
 		"sessionPicker.footer.matches": "Visar {from}-{to} · {loaded} inlästa · {matches} träffar",
 		"sessionPicker.footer.sessions": "Visar {from}-{to} av {count} sessioner",
 		"sessionPicker.footer.loadedSessions": "Visar {from}-{to} · {loaded} av {total} sessioner inlästa"
@@ -500780,6 +500802,10 @@ registerUiCatalogFragment({
 		"sessionPicker.time.daysAgo": "před {count} d",
 		"sessionPicker.current": "aktuální",
 		"sessionPicker.imported": "importováno",
+		"sessionPicker.resume.metrics": "Obnovení {resumeSize} · {messages} zpráv · {tokens} tokenů · Wire {wireSize}",
+		"sessionPicker.resume.missing": "Bod obnovení chybí",
+		"sessionPicker.resume.stale": "Bod obnovení je zastaralý",
+		"sessionPicker.resume.invalid": "Neplatný bod obnovení",
 		"sessionPicker.footer.matches": "Zobrazeno {from}–{to}; načteno {loaded}, shod {matches}",
 		"sessionPicker.footer.sessions": "Zobrazeno {from}–{to} z {count} relací",
 		"sessionPicker.footer.loadedSessions": "Zobrazeno {from}–{to}; načteno {loaded} z {total} relací"
@@ -501034,6 +501060,21 @@ var SessionPickerComponent = class extends Container {
 			const promptLine = indent + currentTheme.fg("textDim", promptMarker + promptText);
 			card.push(promptLine);
 		}
+		const resume = session.resume;
+		if (resume !== void 0) {
+			if (resume.status === "missing") card.push(indent + currentTheme.fg("warning", uiText("sessionPicker.resume.missing")));
+			else if (resume.status === "invalid") card.push(indent + currentTheme.fg("error", uiText("sessionPicker.resume.invalid")));
+			else {
+				const metrics = uiText("sessionPicker.resume.metrics", {
+					resumeSize: formatByteSize(resume.resumeBytes),
+					messages: resume.messages.toLocaleString(getCurrentUiLocale()),
+					tokens: formatLiveTokenCount(resume.tokens),
+					wireSize: formatByteSize(resume.wireBytes)
+				});
+				const suffix = resume.status === "stale" ? ` · ${uiText("sessionPicker.resume.stale")}` : "";
+				card.push(indent + currentTheme.fg(resume.status === "stale" ? "warning" : "textMuted", truncateToWidth(metrics + suffix, Math.max(8, width - indentWidth), ELLIPSIS$4)));
+			}
+		}
 		return card;
 	}
 };
@@ -516682,9 +516723,56 @@ function sessionRowsForPicker(sessions, currentSessionId, currentSessionHasConte
 		last_prompt: session.lastPrompt ?? null,
 		work_dir: session.workDir,
 		updated_at: session.updatedAt ?? session.createdAt ?? 0,
-		metadata: session.metadata
+		metadata: session.metadata,
+		session_dir: session.sessionDir
 	}));
 }
+const SESSION_RESUME_METRICS_CONCURRENCY = 8;
+const SESSION_RESUME_STALE_AFTER_MS = 6e4;
+async function statSessionFile(filePath) {
+	try {
+		return await stat(filePath);
+	} catch {
+		return null;
+	}
+}
+async function readSessionResumeMetrics(session) {
+	if (typeof session.session_dir !== "string" || session.session_dir.length === 0) return { status: "missing" };
+	const agentDir = join(session.session_dir, "agents", "main");
+	const wirePath = join(agentDir, "wire.jsonl");
+	const checkpointPath = join(agentDir, "resume-checkpoint.json");
+	const [resumeStat, wireStat] = await Promise.all([
+		statSessionFile(checkpointPath),
+		statSessionFile(wirePath)
+	]);
+	if (resumeStat === null) return { status: "missing" };
+	if (wireStat === null) return { status: "invalid" };
+	const checkpoint = await loadResumeCheckpoint({ wirePath }).catch(() => ({ ok: false }));
+	if (!checkpoint.ok) return { status: "invalid" };
+	const context = checkpoint.snapshot?.context;
+	const messages = Array.isArray(context?.history) ? context.history.length : Number.isSafeInteger(context?.tokenCountCoveredMessageCount) ? context.tokenCountCoveredMessageCount : 0;
+	const tokens = Number.isSafeInteger(context?.tokenCount) ? context.tokenCount : 0;
+	const stale = wireStat.size > checkpoint.offset && wireStat.mtimeMs - resumeStat.mtimeMs > SESSION_RESUME_STALE_AFTER_MS;
+	return {
+		status: stale ? "stale" : "ok",
+		resumeBytes: resumeStat.size,
+		wireBytes: wireStat.size,
+		messages,
+		tokens
+	};
+}
+async function enrichSessionRowsForPicker(rows) {
+	let nextIndex = 0;
+	const workerCount = Math.min(SESSION_RESUME_METRICS_CONCURRENCY, rows.length);
+	await Promise.all(Array.from({ length: workerCount }, async () => {
+		while (nextIndex < rows.length) {
+			const index = nextIndex++;
+			const row = rows[index];
+			if (row !== void 0) row.resume = await readSessionResumeMetrics(row);
+		}
+	}));
+	return rows;
+}
 //#endregion
 //#region src/tui/utils/startup.ts
 function combineStartupNotice(existing, next) {
@@ -519889,7 +519977,7 @@ var BlunTUI = class {
 		this.state.sessionsScope = scope;
 		try {
 			const sessions = scope === "all" ? await this.harness.listSessions({}) : await this.harness.listSessions({ workDir: this.state.appState.workDir });
-			this.state.sessions = sessionRowsForPicker(sessions, this.state.appState.sessionId, this.hasSessionContent());
+			this.state.sessions = await enrichSessionRowsForPicker(sessionRowsForPicker(sessions, this.state.appState.sessionId, this.hasSessionContent()));
 		} catch {} finally {
 			this.state.loadingSessions = false;
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.523",
+  "version": "9.1.526",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
-    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js && node scripts/check-todo-recovery-catalog-regression.js && node scripts/check-historical-tool-result-preview-regression.js && node scripts/check-session-start-hook-context-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-approval-queue-shortcuts-regression.js && node scripts/check-approval-observability-regression.js && node scripts/check-slash-escape-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-session-cancel-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
+    "prepack": "node scripts/check-release-metadata.js && node scripts/check-shell-terminal-isolation-regression.js && node scripts/check-todo-loop-regression.js && node scripts/check-telegram-loop-exactly-once-regression.js && node scripts/check-session-picker-resume-metrics-regression.js && node scripts/check-bundled-agent-spine-regression.js && node scripts/check-reload-agent-spine-regression.js && node scripts/check-todo-recovery-catalog-regression.js && node scripts/check-historical-tool-result-preview-regression.js && node scripts/check-session-start-hook-context-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-approval-queue-shortcuts-regression.js && node scripts/check-approval-observability-regression.js && node scripts/check-slash-escape-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-session-cancel-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
     "release:verify": "node scripts/check-release-metadata.js --external",
     "postinstall": "node scripts/fix-node-pty-perms.js"
   },
@@ -38,6 +38,8 @@
     "scripts/check-package-regression.js",
     "scripts/check-active-profile-plugin-startup.js",
     "scripts/check-approval-queue-shortcuts-regression.js",
+    "scripts/check-bundled-agent-spine-regression.js",
+    "scripts/check-reload-agent-spine-regression.js",
     "scripts/check-approval-observability-regression.js",
     "scripts/check-slash-escape-regression.js",
     "scripts/check-mcp-startup-wait-budget.js",
@@ -46,9 +48,12 @@
     "scripts/check-telegram-bridge-watchdog.js",
     "scripts/check-resume-replay-regression.js",
     "scripts/check-session-cancel-regression.js",
+    "scripts/check-shell-terminal-isolation-regression.js",
+    "scripts/check-session-picker-resume-metrics-regression.js",
     "scripts/check-release-metadata.js",
     "scripts/check-historical-tool-result-preview-regression.js",
     "scripts/check-session-start-hook-context-regression.js",
+    "scripts/check-telegram-loop-exactly-once-regression.js",
     "scripts/check-todo-recovery-catalog-regression.js",
     "scripts/check-todo-loop-regression.js",
     "scripts/fix-node-pty-perms.js",

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

@@ -0,0 +1,48 @@
+const assert = require('node:assert/strict');
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const expectedVersion = '0.11.4';
+const pluginRoot = process.env.BLUN_AGENT_SPINE_ROOT_UNDER_TEST
+  ? path.resolve(process.env.BLUN_AGENT_SPINE_ROOT_UNDER_TEST)
+  : path.resolve(__dirname, '..', 'agent-spine-plugin');
+
+function readJson(relativePath) {
+  return JSON.parse(fs.readFileSync(path.join(pluginRoot, relativePath), 'utf8'));
+}
+
+for (const relativePath of [
+  'package.json',
+  'hooks/version.json',
+  '.claude-plugin/plugin.json',
+  '.codex-plugin/plugin.json',
+  'blun.plugin.json',
+]) {
+  assert.equal(
+    readJson(relativePath).version,
+    expectedVersion,
+    `BUNDLED_AGENT_SPINE_REGRESSION: ${relativePath} must declare ${expectedVersion}`,
+  );
+}
+
+const runtimeVersion = execFileSync(
+  process.execPath,
+  [path.join(pluginRoot, 'bin', 'agentspine.js'), '--version'],
+  { encoding: 'utf8' },
+).trim();
+assert.equal(
+  runtimeVersion,
+  expectedVersion,
+  'BUNDLED_AGENT_SPINE_REGRESSION: packaged runtime version is stale',
+);
+
+for (const relativePath of ['CONTRIBUTING.md', 'SECURITY.md']) {
+  assert.equal(
+    fs.existsSync(path.join(pluginRoot, relativePath)),
+    true,
+    `BUNDLED_AGENT_SPINE_REGRESSION: README link target ${relativePath} is missing`,
+  );
+}
+
+console.log(`bundled-agent-spine-regression PASS (${expectedVersion})`);

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

@@ -0,0 +1,76 @@
+'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-session-picker-resume-metrics-regression.js

@@ -0,0 +1,97 @@
+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-shell-terminal-isolation-regression.js

@@ -0,0 +1,81 @@
+'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-telegram-loop-exactly-once-regression.js

@@ -0,0 +1,71 @@
+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 match = /async function handleLoopCommand\(host, args\) \{([\s\S]*?)\n\}\nfunction hasRunnableSession/.exec(bundle);
+assert(match, 'TELEGRAM_LOOP_EXACTLY_ONCE: handleLoopCommand is missing');
+
+const handleLoopCommand = Function(
+  'parseLoopCommand',
+  'hasRunnableSession',
+  'llmNotSetMessage',
+  'isStreaming',
+  `return async function handleLoopCommand(host, args) {${match[1]}\n};`,
+)(
+  () => ({ kind: 'create', interval: '*/5 * * * *', prompt: 'work once' }),
+  () => true,
+  () => 'missing model',
+  (host) => host.streaming,
+);
+
+function createHost({ telegram = false, streaming = true } = {}) {
+  const calls = { send: [], enqueue: [] };
+  const session = {
+    async createLoop({ interval, prompt }) {
+      return { interval, prompt, status: 'active' };
+    },
+  };
+  const host = {
+    streaming,
+    session,
+    telegramRemoteCommandContext: telegram ? { item: { telegramCommandName: 'loop' } } : undefined,
+    state: { appState: { isCompacting: false, model: 'blun/king' } },
+    requireSession() { return session; },
+    setAppState() {},
+    track() {},
+    showStatus() {},
+    showError(message) { throw new Error(message); },
+    sendNormalUserInput(text) { calls.send.push(text); },
+    enqueueNormalUserInput(text) { calls.enqueue.push(text); },
+  };
+  return { host, calls };
+}
+
+(async () => {
+  const telegram = createHost({ telegram: true, streaming: true });
+  await handleLoopCommand(telegram.host, '5 min work once');
+  assert.deepEqual(telegram.calls.send, ['work once']);
+  assert.deepEqual(
+    telegram.calls.enqueue,
+    [],
+    'TELEGRAM_LOOP_EXACTLY_ONCE: Telegram loop payload must not survive in the normal queue',
+  );
+
+  const local = createHost({ telegram: false, streaming: true });
+  await handleLoopCommand(local.host, '5 min work once');
+  assert.deepEqual(local.calls.send, []);
+  assert.deepEqual(
+    local.calls.enqueue,
+    ['work once'],
+    'TELEGRAM_LOOP_EXACTLY_ONCE: local busy-loop behavior must stay queued',
+  );
+
+  console.log('telegram-loop-exactly-once-regression PASS');
+})().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});