blun-king-cli 9.1.518 → 9.1.519

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 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.519
 
 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.519
 ```
 
 ## 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/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/bin/tool-result-offload-policy.cjs.vor-historical-preview-20260831-210300

@@ -0,0 +1,317 @@
+'use strict';
+
+const TOOL_RESULT_MAX_CHARS = 12_000;
+const TOOL_RESULT_PREVIEW_CHARS = 2_000;
+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;
+const TOOL_RESULT_BATCH_MIN_ITEM_CHARS = 3_000;
+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_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]';
+const READ_CONTINUATION_LINE_OFFSET_RE = /^Continue reading with line_offset=(\d+)\. Do not assume you have reached the end of the file\.$/mu;
+
+function shouldOffloadToolResult(textLength) {
+  return Number.isFinite(textLength) && textLength > TOOL_RESULT_MAX_CHARS;
+}
+
+function shouldKeepFreshToolResult(toolName) {
+  return toolName === 'Read';
+}
+
+function createToolResultPreview(text) {
+  if (text.length <= TOOL_RESULT_PREVIEW_CHARS) return text;
+
+  const headChars = Math.ceil(TOOL_RESULT_PREVIEW_CHARS / 2);
+  const tailChars = TOOL_RESULT_PREVIEW_CHARS - headChars;
+  const omittedChars = text.length - headChars - tailChars;
+  return `${text.slice(0, headChars)}\n\n[... ${String(omittedChars)} characters omitted ...]\n\n${text.slice(-tailChars)}`;
+}
+
+function readContinuationLineOffset(text) {
+  if (typeof text !== 'string') return undefined;
+  const value = Number(text.match(READ_CONTINUATION_LINE_OFFSET_RE)?.[1]);
+  return Number.isSafeInteger(value) && value >= 1 ? value : undefined;
+}
+
+function isPersistedToolResultReference(content) {
+  if (!Array.isArray(content)) return false;
+
+  return content.some((part) => {
+    if (part?.type !== 'text' || typeof part.text !== 'string') return false;
+    if (!part.text.includes('\noutput_path: ')) return false;
+    return part.text.startsWith(`${TOOL_RESULT_OFFLOAD_MARKER}\n`)
+      || /^Tool output exceeded \d+ characters; showing a preview only\.\n/u.test(part.text);
+  });
+}
+
+function freshToolResultIds(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return new Set();
+
+  let assistantIndex = -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (messages[index]?.role !== 'assistant') continue;
+    assistantIndex = index;
+    break;
+  }
+  if (assistantIndex < 0 || !Array.isArray(messages[assistantIndex].toolCalls)) return new Set();
+
+  const requestedIds = new Set(messages[assistantIndex].toolCalls
+    .map((call) => call?.id ?? call?.toolCallId)
+    .filter((id) => typeof id === 'string' && id.length > 0));
+  if (requestedIds.size === 0) return new Set();
+
+  const resultIds = new Set();
+  for (let index = assistantIndex + 1; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message?.role === 'tool' && requestedIds.has(message.toolCallId)) {
+      resultIds.add(message.toolCallId);
+    }
+  }
+  return resultIds;
+}
+
+function compactPersistedToolResultReference(content) {
+  if (!isPersistedToolResultReference(content)) return content;
+
+  let changed = false;
+  const compacted = content.map((part) => {
+    if (part?.type !== 'text' || typeof part.text !== 'string') return part;
+    const previewIndex = part.text.indexOf('\n[preview: head and tail]\n');
+    const referenceText = previewIndex < 0
+      ? part.text
+      : part.text.slice(0, previewIndex).trimEnd();
+    if (!referenceText.startsWith(`${TOOL_RESULT_OFFLOAD_MARKER}\n`)) {
+      if (referenceText === part.text) return part;
+      changed = true;
+      return { ...part, text: referenceText };
+    }
+
+    const lines = referenceText.split(/\r?\n/u);
+    const outputPath = lines.find((line) => line.startsWith('output_path: '));
+    if (outputPath === undefined) return part;
+    const recoveryLines = [TOOL_RESULT_OFFLOAD_MARKER];
+    for (const prefix of ['tool_name: ', 'output_size_chars: ', 'next_line_offset: ']) {
+      const line = lines.find((candidate) => candidate.startsWith(prefix));
+      if (line !== undefined) recoveryLines.push(line);
+    }
+    if (recoveryLines.some((line) => line.startsWith('next_line_offset: '))) {
+      const nextStep = lines.find((line) => line.startsWith('next_step: '));
+      if (nextStep !== undefined) recoveryLines.push(nextStep);
+    }
+    recoveryLines.push(outputPath);
+    const text = recoveryLines.join('\n');
+    if (text === part.text) return part;
+    changed = true;
+    return {
+      ...part,
+      text,
+    };
+  });
+
+  return changed ? compacted : content;
+}
+
+function compactHistoricalSuccessfulToolResults(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+
+  const recentStart = Math.max(0, messages.length - TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES);
+  const freshIds = freshToolResultIds(messages);
+  let changed = false;
+  const projected = messages.map((message, index) => {
+    if (
+      index >= recentStart
+      || message?.role !== 'tool'
+      || freshIds.has(message.toolCallId)
+      || message.isError === true
+      || !Array.isArray(message.content)
+      || isPersistedToolResultReference(message.content)
+      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
+    ) return message;
+
+    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
+    if (textChars <= TOOL_RESULT_HISTORICAL_SUCCESS_MARKER.length) return message;
+    changed = true;
+    return {
+      ...message,
+      content: [{ type: 'text', text: TOOL_RESULT_HISTORICAL_SUCCESS_MARKER }],
+    };
+  });
+
+  return changed ? projected : messages;
+}
+
+function toolCallSignaturesById(messages) {
+  const signatures = new Map();
+
+  for (const message of messages) {
+    if (!Array.isArray(message?.toolCalls)) continue;
+    for (const call of message.toolCalls) {
+      const id = call?.id ?? call?.toolCallId;
+      if (typeof id !== 'string' || typeof call?.name !== 'string') continue;
+      const args = typeof call.arguments === 'string'
+        ? call.arguments
+        : JSON.stringify(call.arguments ?? null);
+      signatures.set(id, `${call.name}\n${args}`);
+    }
+  }
+
+  return signatures;
+}
+
+function repeatedToolResultReference(newestToolCallId) {
+  return [
+    TOOL_RESULT_REPEAT_MARKER,
+    `same_as_tool_call_id: ${newestToolCallId}`,
+    'reason: identical successful result for the same tool call arguments',
+  ].join('\n');
+}
+
+function dedupeRepeatedSuccessfulToolResults(sourceMessages, projectedMessages = sourceMessages) {
+  if (
+    !Array.isArray(sourceMessages)
+    || !Array.isArray(projectedMessages)
+    || sourceMessages.length === 0
+    || sourceMessages.length !== projectedMessages.length
+  ) return projectedMessages;
+
+  const callSignatures = toolCallSignaturesById(sourceMessages);
+  const seenResultsByCall = new Map();
+  let changed = false;
+  const projected = projectedMessages.slice();
+
+  for (let index = sourceMessages.length - 1; index >= 0; index -= 1) {
+    const message = sourceMessages[index];
+    const toolCallId = message?.toolCallId;
+    if (
+      message?.role !== 'tool'
+      || message.isError === true
+      || typeof toolCallId !== 'string'
+      || !Array.isArray(message.content)
+      || message.content.length === 0
+      || isPersistedToolResultReference(message.content)
+      || !message.content.every((part) => part?.type === 'text' && typeof part.text === 'string')
+    ) continue;
+
+    const callSignature = callSignatures.get(toolCallId);
+    if (callSignature === undefined) continue;
+    const resultShape = message.content.length;
+    const resultSignature = resultShape === 1
+      ? message.content[0].text
+      : JSON.stringify(message.content.map((part) => part.text));
+    let seenResults = seenResultsByCall.get(callSignature);
+    if (seenResults === undefined) {
+      seenResults = new Map();
+      seenResultsByCall.set(callSignature, seenResults);
+    }
+    let seenResultsForShape = seenResults.get(resultShape);
+    if (seenResultsForShape === undefined) {
+      seenResultsForShape = new Map();
+      seenResults.set(resultShape, seenResultsForShape);
+    }
+    const newest = seenResultsForShape.get(resultSignature);
+    if (newest === undefined) {
+      seenResultsForShape.set(resultSignature, { toolCallId, index });
+      continue;
+    }
+
+    const reference = repeatedToolResultReference(newest.toolCallId);
+    const textChars = message.content.reduce((total, part) => total + part.text.length, 0);
+    const projectedMessage = projected[index];
+    if (
+      reference.length >= textChars
+      || projectedMessage?.role !== 'tool'
+      || projectedMessage.toolCallId !== toolCallId
+    ) continue;
+    projected[index] = {
+      ...projectedMessage,
+      content: [{ type: 'text', text: reference }],
+    };
+    projected[newest.index] = {
+      ...projected[newest.index],
+      content: sourceMessages[newest.index].content,
+    };
+    changed = true;
+  }
+
+  return changed ? projected : projectedMessages;
+}
+
+function selectToolResultBatchOffloads(textLengths) {
+  if (!Array.isArray(textLengths) || textLengths.length < 2) return [];
+
+  const normalized = textLengths.map((length) => (
+    Number.isFinite(length) && length > 0 ? Math.floor(length) : 0
+  ));
+  const totalChars = normalized.reduce((total, length) => total + length, 0);
+  if (totalChars <= TOOL_RESULT_BATCH_MAX_CHARS) return [];
+
+  let projectedChars = totalChars;
+  const selected = [];
+  const candidates = normalized
+    .map((length, index) => ({ index, length }))
+    .filter(({ length }) => (
+      length >= TOOL_RESULT_BATCH_MIN_ITEM_CHARS
+      && length <= TOOL_RESULT_MAX_CHARS
+      && length > TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS
+    ))
+    .sort((left, right) => right.length - left.length || left.index - right.index);
+
+  for (const candidate of candidates) {
+    if (projectedChars <= TOOL_RESULT_BATCH_MAX_CHARS) break;
+    projectedChars -= candidate.length - TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS;
+    selected.push(candidate.index);
+  }
+
+  return projectedChars <= TOOL_RESULT_BATCH_MAX_CHARS
+    ? selected.sort((left, right) => left - right)
+    : [];
+}
+
+function selectHistoricalToolResultOffloads(textLengths) {
+  if (!Array.isArray(textLengths) || textLengths.length === 0) return [];
+
+  const normalized = textLengths.map((length) => (
+    Number.isFinite(length) && length > 0 ? Math.floor(length) : 0
+  ));
+  return normalized
+    .map((length, index) => ({ index, length }))
+    .filter(({ length }) => (
+      length >= TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS
+      && length > TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS
+    ))
+    .map(({ index }) => index);
+}
+
+module.exports = {
+  TOOL_RESULT_BATCH_MAX_CHARS,
+  TOOL_RESULT_BATCH_MIN_ITEM_CHARS,
+  TOOL_RESULT_BATCH_REPLACEMENT_BUDGET_CHARS,
+  TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES,
+  TOOL_RESULT_HISTORICAL_MAX_CHARS,
+  TOOL_RESULT_HISTORICAL_MIN_ITEM_CHARS,
+  TOOL_RESULT_HISTORICAL_REPLACEMENT_BUDGET_CHARS,
+  TOOL_RESULT_HISTORICAL_SUCCESS_MARKER,
+  TOOL_RESULT_REPEAT_MARKER,
+  TOOL_RESULT_MAX_CHARS,
+  TOOL_RESULT_PREVIEW_CHARS,
+  TOOL_RESULT_RECOVERY_PAGE_LINES,
+  TOOL_RESULT_OFFLOAD_MARKER,
+  TOOL_RESULT_SUCCESS_KEEP_RECENT_MESSAGES,
+  compactHistoricalSuccessfulToolResults,
+  compactPersistedToolResultReference,
+  createToolResultPreview,
+  dedupeRepeatedSuccessfulToolResults,
+  freshToolResultIds,
+  isPersistedToolResultReference,
+  readContinuationLineOffset,
+  selectHistoricalToolResultOffloads,
+  selectToolResultBatchOffloads,
+  shouldKeepFreshToolResult,
+  shouldOffloadToolResult,
+};

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.519",
   "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,115 @@
+#!/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 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 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;
+});