blun-king-cli 9.1.518 → 9.1.520

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 9.1.520 - 2026-08-31
+
+- Gives AgentSpine's `SessionStart` hook a 60-second cold-project budget, so startup and `/reload` can persist the automatic briefing even when the measured source scan exceeds the former 15-second limit.
+- Keeps prompt, tool, compact, stop, and subagent hook budgets unchanged; only the full SessionStart briefing receives the larger allowance.
+- Extends the SessionStart regression with the packaged AgentSpine manifests and a real hook-process output probe instead of relying only on a simulated result.
+
+## 9.1.519 - 2026-08-31
+
+- Persists successful `SessionStart` hook output before startup or reload returns, so AgentSpine readiness reaches the resumed model context automatically instead of waiting for the first user prompt.
+- Keeps a bounded head-and-tail preview in historical offloaded tool-result references, preserving recovery anchors without restoring the full result to every model request.
+- Adds red-to-green runtime regressions for SessionStart context delivery and historical preview retention while preserving the 9.1.518 Todo recovery catalogue.
+
 ## 9.1.518 - 2026-08-31
 
 - Keeps `Read`, `Write`, `Edit`, and `Bash` available alongside `TodoList` during proactive task-list maintenance, preserving the normal recovery path for large file changes.

package/LIESMICH.txt

@@ -9,11 +9,11 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.518
+  npm install -g blun-king-cli@9.1.520
 
 AgentSpine 0.10.1
 -----------------
-Version 9.1.518 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
+Version 9.1.519 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
 
 Start
 -----

package/README.md

@@ -9,12 +9,12 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.518
+npm install -g blun-king-cli@9.1.520
 ```
 
 ## AgentSpine 0.10.1
 
-Version 9.1.518 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
+Version 9.1.519 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
 
 ## Reproduzierbares Staging und Packen
 

package/agent-spine-plugin/blun.plugin.json

@@ -15,7 +15,7 @@
     }
   },
   "hooks": [
-    { "event": "SessionStart", "command": "node \"./src/hook.js\"", "timeout": 15 },
+    { "event": "SessionStart", "command": "node \"./src/hook.js\"", "timeout": 60 },
     { "event": "UserPromptSubmit", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "PreToolUse", "matcher": "Edit|Write|apply_patch|Bash|exec_command", "command": "node \"./src/hook.js\"", "timeout": 15 },
     { "event": "PostToolUse", "command": "node \"./src/hook.js\"", "timeout": 15 },

package/agent-spine-plugin/hooks/codex.json

@@ -4,7 +4,7 @@
     "SessionStart": [
       {
         "matcher": "startup|resume|clear|compact",
-        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 15 }]
+        "hooks": [{ "type": "command", "command": "node \"${PLUGIN_ROOT}/src/hook.js\"", "timeout": 60 }]
       }
     ],
     "UserPromptSubmit": [

package/bin/tool-result-offload-policy.cjs

@@ -2,6 +2,8 @@
 
 const TOOL_RESULT_MAX_CHARS = 12_000;
 const TOOL_RESULT_PREVIEW_CHARS = 2_000;
+const TOOL_RESULT_HISTORICAL_PREVIEW_CHARS = 400;
+const TOOL_RESULT_COMPACT_PREVIEW_CHARS = 240;
 const TOOL_RESULT_RECOVERY_PAGE_LINES = 20;
 const TOOL_RESULT_OFFLOAD_MARKER = '[Tool result offloaded]';
 const TOOL_RESULT_BATCH_MAX_CHARS = TOOL_RESULT_MAX_CHARS;
@@ -10,7 +12,7 @@ const TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS = 2_500;
 const TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES = 4;
 const TOOL_RESULT_HISTORICAL_MAX_CHARS = TOOL_RESULT_BATCH_MAX_CHARS;
 const TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS = 600;
-const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 600;
+const TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS = 1_000;
 const TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES = 12;
 const TOOL_RESULT_HISTORICAL_SUCCESS_MARKER = '[Old tool result content cleared]';
 const TOOL_RESULT_REPEAT_MARKER = '[Repeated tool result omitted]';
@@ -24,11 +26,11 @@ function shouldKeepFreshToolResult(toolName) {
   return toolName === 'Read';
 }
 
-function createToolResultPreview(text) {
-  if (text.length <= TOOL_RESULT_PREVIEW_CHARS) return text;
+function createToolResultPreview(text, maxChars = TOOL_RESULT_PREVIEW_CHARS) {
+  if (text.length <= maxChars) return text;
 
-  const headChars = Math.ceil(TOOL_RESULT_PREVIEW_CHARS / 2);
-  const tailChars = TOOL_RESULT_PREVIEW_CHARS - headChars;
+  const headChars = Math.ceil(maxChars / 2);
+  const tailChars = maxChars - headChars;
   const omittedChars = text.length - headChars - tailChars;
   return `${text.slice(0, headChars)}\n\n[... ${String(omittedChars)} characters omitted ...]\n\n${text.slice(-tailChars)}`;
 }
@@ -105,6 +107,14 @@ function compactPersistedToolResultReference(content) {
       if (nextStep !== undefined) recoveryLines.push(nextStep);
     }
     recoveryLines.push(outputPath);
+    if (previewIndex >= 0) {
+      const preview = part.text.slice(previewIndex + '\n[preview: head and tail]\n'.length);
+      recoveryLines.push(
+        '',
+        '[preview: head and tail]',
+        createToolResultPreview(preview, TOOL_RESULT_COMPACT_PREVIEW_CHARS),
+      );
+    }
     const text = recoveryLines.join('\n');
     if (text === part.text) return part;
     changed = true;
@@ -295,7 +305,9 @@ module.exports = {
   TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES,
   TOOL_RESULT_HISTORICAL_MAX_CHARS,
   TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS,
+  TOOL_RESULT_HISTORICAL_PREVIEW_CHARS,
   TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS,
+  TOOL_RESULT_COMPACT_PREVIEW_CHARS,
   TOOL_RESULT_HISTORICAL_SUCCESS_MARKER,
   TOOL_RESULT_REPEAT_MARKER,
   TOOL_RESULT_MAX_CHARS,

package/blun.mjs

@@ -231005,15 +231005,21 @@ var init_engine = __esmMin((() => {
 function renderHookResult(event, message) {
 	return `<hook_result hook_event="${event}">\n${message}\n</hook_result>`;
 }
-function renderUserPromptHookResult(results) {
+function renderAllowHookResult(event, results) {
 	const messages = results?.filter((result) => result.action !== "block")?.map(userPromptHookMessage).filter(isNonEmptyString$1) ?? [];
 	if (messages.length === 0) return void 0;
 	return {
-		event: "UserPromptSubmit",
+		event,
 		message: messages.join("\n\n"),
-		text: messages.map((message) => renderHookResult("UserPromptSubmit", message)).join("\n")
+		text: messages.map((message) => renderHookResult(event, message)).join("\n")
 	};
 }
+function renderUserPromptHookResult(results) {
+	return renderAllowHookResult("UserPromptSubmit", results);
+}
+function renderSessionStartHookResult(results) {
+	return renderAllowHookResult("SessionStart", results);
+}
 function renderUserPromptHookBlockResult(results) {
 	const block = results?.find((result) => result.action === "block");
 	if (block === void 0) return void 0;
@@ -261128,7 +261134,7 @@ async function persistHistoricalToolResultForModel(options, knownText) {
 }
 function renderHistoricalToolResultReference(toolName, toolCallId, text, outputPath, storageMode) {
 	const nextLineOffset = toolName === "Read" ? readContinuationLineOffset(text) : void 0;
-	return [
+	const lines = [
 		TOOL_RESULT_OFFLOAD_MARKER,
 		"An older tool result was archived to keep the active context fast.",
 		`storage_mode: ${storageMode}`,
@@ -261139,18 +261145,21 @@ function renderHistoricalToolResultReference(toolName, toolCallId, text, outputP
 		...(nextLineOffset === void 0 ? [] : [`next_line_offset: ${String(nextLineOffset)}`]),
 		`output_path: ${outputPath}`,
 		nextLineOffset === void 0 ? `next_step: Use Read with output_path using n_lines <= ${String(TOOL_RESULT_RECOVERY_PAGE_LINES)}; advance line_offset between calls.` : `next_step: Continue the original Read with line_offset=${String(nextLineOffset)}; do not restart at the beginning.`
-	].join("\n");
+	];
+	lines.push("", "[preview: head and tail]", createToolResultPreview(text, TOOL_RESULT_HISTORICAL_PREVIEW_CHARS));
+	return lines.join("\n");
 }
 function safeToolResultFileStem(toolName, toolCallId) {
 	return `${toolName}-${toolCallId}`.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 80) || "tool-result";
 }
-var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldKeepFreshToolResult, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, dedupeRepeatedSuccessfulToolResults, readContinuationLineOffset, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
+var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_HISTORICAL_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldKeepFreshToolResult, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, dedupeRepeatedSuccessfulToolResults, readContinuationLineOffset, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
 var init_tool_result_budget = __esmMin((() => {
 	init_dist$6();
 	const toolResultOffloadPolicy = createRequire(import.meta.url)("./bin/tool-result-offload-policy.cjs");
 	({ buildToolResultOffloadTelemetry } = createRequire(import.meta.url)("./bin/tool-result-offload-telemetry.cjs"));
 	TOOL_RESULT_MAX_CHARS = toolResultOffloadPolicy.TOOL_RESULT_MAX_CHARS;
 	TOOL_RESULT_PREVIEW_CHARS = toolResultOffloadPolicy.TOOL_RESULT_PREVIEW_CHARS;
+	TOOL_RESULT_HISTORICAL_PREVIEW_CHARS = toolResultOffloadPolicy.TOOL_RESULT_HISTORICAL_PREVIEW_CHARS;
 	TOOL_RESULT_RECOVERY_PAGE_LINES = toolResultOffloadPolicy.TOOL_RESULT_RECOVERY_PAGE_LINES;
 	TOOL_RESULT_OFFLOAD_MARKER = toolResultOffloadPolicy.TOOL_RESULT_OFFLOAD_MARKER;
 	TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES = toolResultOffloadPolicy.TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES;
@@ -298492,10 +298501,18 @@ var init_session$1 = __esmMin((() => {
 			return agent;
 		}
 		async triggerSessionStart(source) {
-			await this.hookEngine.trigger("SessionStart", {
+			const results = await this.hookEngine.trigger("SessionStart", {
 				matcherValue: source,
 				inputData: { source }
 			});
+			const hookResult = renderSessionStartHookResult(results);
+			if (hookResult === void 0) return;
+			const mainAgent = this.requireMainAgent();
+			mainAgent.context.appendSystemReminder(`${hookResult.text}\n\nThis supersedes any earlier SessionStart hook result in this session.`, {
+				kind: "injection",
+				variant: "session_start_hook"
+			});
+			await mainAgent.records.flush();
 		}
 		async triggerSessionEnd(reason) {
 			await this.hookEngine.trigger("SessionEnd", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.518",
+  "version": "9.1.520",
   "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-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-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",
     "release:verify": "node scripts/check-release-metadata.js --external",
     "postinstall": "node scripts/fix-node-pty-perms.js"
   },
@@ -45,6 +45,8 @@
     "scripts/check-resume-replay-regression.js",
     "scripts/check-session-cancel-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-todo-recovery-catalog-regression.js",
     "scripts/check-todo-loop-regression.js",
     "scripts/fix-node-pty-perms.js",

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

@@ -0,0 +1,77 @@
+#!/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-session-start-hook-context-regression.js

@@ -0,0 +1,178 @@
+#!/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\}/,
+);
+
+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(
+  /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: SessionStart reminder is not flushed before reload returns',
+);
+
+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 >= 60,
+  'SESSION_START_HOOK_CONTEXT_REGRESSION: BLUN AgentSpine SessionStart timeout must cover a cold project scan',
+);
+assert(
+  codexSessionStart?.timeout >= 60,
+  '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 runTrigger = Function(
+  `${wrapperRenderer[0]}\n${messageSelector[0]}\n${stringPredicate[0]}\n${allowRenderer[0]}\n${renderer[0]}\n${triggerFunction}\nreturn triggerSessionStart;`,
+)();
+
+(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',
+  );
+
+  process.stdout.write('session-start-hook-context-regression PASS\n');
+})().catch((error) => {
+  process.stderr.write(`${error.stack || error.message}\n`);
+  process.exitCode = 1;
+});