blun-king-cli 9.1.520 → 9.1.525

package/blun.mjs

@@ -234150,6 +234150,15 @@ var init_permission = __esmMin((() => {
 			let requestedApproval = false;
 			if (this.agent.rpc?.requestApproval) {
 				requestedApproval = true;
+				this.agent.records.logRecord({
+					type: "permission.approval_requested",
+					turnId: Number(context.turnId),
+					toolCallId: id,
+					toolName: name,
+					action,
+					display,
+					policyName: policyName ?? null
+				});
 				this.agent.hooks?.fireAndForgetTrigger?.("PermissionRequest", {
 					matcherValue: name,
 					inputData: {
@@ -297952,7 +297961,7 @@ var init_session$1 = __esmMin((() => {
 			const { agent } = await this.createAgent({ type: "main" }, { profile: DEFAULT_AGENT_PROFILES["agent"] });
 			const mc = this.options.missionContract;
 			if (mc && Array.isArray(mc.acceptanceCriteria) && mc.acceptanceCriteria.length > 0) await agent.injection.setMissionContract(mc);
-			await this.triggerSessionStart("startup");
+			this.scheduleSessionStart("startup");
 			return agent;
 		}
 		async resume() {
@@ -297965,7 +297974,7 @@ var init_session$1 = __esmMin((() => {
 			const profile = DEFAULT_AGENT_PROFILES["agent"];
 			if (main !== void 0 && profile !== void 0 && main.config.systemPrompt === "") await this.bootstrapAgentProfile(main, profile);
 			if (main !== void 0) this.ensureBaselineSkill(main);
-			await this.triggerSessionStart("resume");
+			this.scheduleSessionStart("resume");
 			return { warning };
 		}
 		async close() {
@@ -298500,6 +298509,11 @@ var init_session$1 = __esmMin((() => {
 			if (agent === void 0) throw new BlunError(ErrorCodes.AGENT_NOT_FOUND, "Main agent was not found");
 			return agent;
 		}
+		scheduleSessionStart(source) {
+			void this.triggerSessionStart(source).catch((error) => {
+				this.log.warn("session start hook failed", { source, error });
+			});
+		}
 		async triggerSessionStart(source) {
 			const results = await this.hookEngine.trigger("SessionStart", {
 				matcherValue: source,
@@ -316397,7 +316411,7 @@ function buildLocalSpawnOptions(isWindows, cwd, env) {
 			"pipe",
 			"pipe"
 		],
-		detached: !isWindows,
+		detached: true,
 		windowsHide: true
 	};
 }
@@ -424151,7 +424165,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;
 			}
@@ -500646,6 +500661,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"
@@ -500670,6 +500689,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"
@@ -500694,6 +500717,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"
@@ -500718,6 +500745,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}"
@@ -500742,6 +500773,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"
@@ -500766,6 +500801,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í"
@@ -501020,6 +501059,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;
 	}
 };
@@ -505909,6 +505963,7 @@ var EditorKeyboardController = class {
 				return;
 			}
 			if (autocompleteCancelled) {
+				if (editor.inputMode === "prompt" && editor.getText().trimStart().startsWith("/")) editor.setText("");
 				this.clearPendingUndoEsc();
 				return;
 			}
@@ -505949,8 +506004,9 @@ var EditorKeyboardController = class {
 			return true;
 		};
 		editor.onCtrlS = () => {
-			if (!host.streamingUI.hasActiveTurn() && host.state.appState.streamingPhase === "idle") return;
-			host.flushQueuedMessages(editor.getText().trim(), editor.inputMode);
+			const draft = editor.getText().trim();
+			if (!host.streamingUI.hasActiveTurn() && host.state.appState.streamingPhase === "idle" && !draft.trimStart().startsWith("/")) return;
+			host.flushQueuedMessages(draft, editor.inputMode);
 			host.updateQueueDisplay();
 			host.state.ui.requestRender();
 		};
@@ -516666,9 +516722,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) {
@@ -519873,7 +519976,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.520",
+  "version": "9.1.525",
   "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-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-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,15 +38,21 @@
     "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-approval-observability-regression.js",
+    "scripts/check-slash-escape-regression.js",
     "scripts/check-mcp-startup-wait-budget.js",
     "scripts/check-plugin-startup-regression.js",
     "scripts/check-queue-controls-regression.js",
     "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-approval-observability-regression.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.join(packageRoot, 'blun.mjs');
+const relayPath = process.env.BLUN_APPROVAL_RELAY_UNDER_TEST
+  ? path.resolve(process.env.BLUN_APPROVAL_RELAY_UNDER_TEST)
+  : path.join(packageRoot, 'bin', 'telegram-approval-relay.cjs');
+const pluginRelayPath = process.env.BLUN_PLUGIN_APPROVAL_RELAY_UNDER_TEST
+  ? path.resolve(process.env.BLUN_PLUGIN_APPROVAL_RELAY_UNDER_TEST)
+  : path.join(packageRoot, 'telegram-plugin', 'bin', 'telegram-approval-relay.cjs');
+
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+const requestToolApproval = bundle.match(
+  /async requestToolApproval\(context, result, policyName\) \{[\s\S]*?\n\t\t\}/,
+);
+assert(requestToolApproval, 'APPROVAL_OBSERVABILITY_REGRESSION: requestToolApproval is missing');
+assert.match(
+  requestToolApproval[0],
+  /this\.agent\.records\.logRecord\(\{[\s\S]*?type: "permission\.approval_requested"[\s\S]*?toolCallId: id[\s\S]*?toolName: name/,
+  'APPROVAL_OBSERVABILITY_REGRESSION: opening an approval is invisible in the wire',
+);
+assert(
+  requestToolApproval[0].indexOf('type: "permission.approval_requested"')
+    < requestToolApproval[0].indexOf('await this.agent.rpc.requestApproval'),
+  'APPROVAL_OBSERVABILITY_REGRESSION: approval wire event is emitted too late',
+);
+
+const ApprovalProbe = Function(`return class ApprovalProbe {${requestToolApproval[0]}};`)();
+const wireRecords = [];
+const probe = new ApprovalProbe();
+probe.agent = {
+  records: { logRecord(record) { wireRecords.push(record); } },
+  rpc: { async requestApproval() { return { decision: 'approved' }; } },
+  hooks: { fireAndForgetTrigger() {} },
+  telemetry: { track() {} },
+};
+probe.recordApprovalResult = () => {};
+probe.permissionPolicyResolutionToPrepare = () => undefined;
+probe.formatApprovalRejectionMessage = () => '';
+
+const approvalRun = probe.requestToolApproval({
+  signal: new AbortController().signal,
+  turnId: 7,
+  toolCall: { id: 'tool-7', name: 'Bash' },
+  execution: {
+    description: 'Run command',
+    display: { kind: 'command', command: 'echo ok' },
+  },
+  args: { command: 'echo ok' },
+}, {}, 'manual-approval');
+assert.equal(wireRecords.length, 1, 'approval request must be written before awaiting a response');
+assert.deepEqual(
+  wireRecords[0],
+  {
+    type: 'permission.approval_requested',
+    turnId: 7,
+    toolCallId: 'tool-7',
+    toolName: 'Bash',
+    action: 'Run command',
+    display: { kind: 'command', command: 'echo ok' },
+    policyName: 'manual-approval',
+  },
+  'approval wire record lost identifying fields',
+);
+
+function checkRelay(modulePath, label) {
+  delete require.cache[require.resolve(modulePath)];
+  const { resolveTelegramApprovalTarget } = require(modulePath);
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602', '-1003927574737']),
+    '1605241602',
+    `${label}: one authorized private chat must be selected even when groups are also allowed`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['0', '-1003927574737']),
+    null,
+    `${label}: zero is not a positive private Telegram chat ID`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602', '8711923962', '-1003927574737']),
+    null,
+    `${label}: multiple authorized private chats must remain fail-closed`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602', '8711923962'], '8711923962'),
+    '8711923962',
+    `${label}: an explicitly configured authorized chat must win`,
+  );
+  assert.equal(
+    resolveTelegramApprovalTarget(['1605241602'], '-1003927574737'),
+    null,
+    `${label}: an unauthorized configured chat must be rejected`,
+  );
+}
+
+checkRelay(relayPath, 'package relay');
+checkRelay(pluginRelayPath, 'plugin relay');
+
+approvalRun.then(() => {
+  process.stdout.write('approval-observability-regression PASS\n');
+}).catch((error) => {
+  process.stderr.write(`${error.stack || error.message}\n`);
+  process.exitCode = 1;
+});

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-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-session-start-hook-context-regression.js

@@ -33,6 +33,15 @@ const stringPredicate = bundle.match(
 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');
@@ -40,6 +49,9 @@ assert(wrapperRenderer, 'SESSION_START_HOOK_CONTEXT_REGRESSION: hook wrapper ren
 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',
@@ -58,7 +70,21 @@ assert(
 );
 assert(
   /await mainAgent\.records\.flush\(\)/.test(trigger[0]),
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: SessionStart reminder is not flushed before reload returns',
+  '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, '..');
@@ -75,11 +101,11 @@ const blunSessionStart = agentSpineManifest.hooks.find(
 const codexSessionStart = agentSpineCodexHooks.hooks.SessionStart?.[0]?.hooks?.[0];
 
 assert(
-  blunSessionStart?.timeout >= 60,
-  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover a cold project scan',
+  blunSessionStart?.timeout >= 180,
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover the measured 123.6 s cold scan',
 );
 assert(
-  codexSessionStart?.timeout >= 60,
+  codexSessionStart?.timeout >= 180,
   'SESSION_START_HOOK_CONTEXT_REGRESSION: Codex AgentSpine SessionStart timeout must match the BLUN runtime budget',
 );
 
@@ -126,9 +152,16 @@ 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 = [];
@@ -171,6 +204,23 @@ const runTrigger = Function(
     '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`);