blun-king-cli 9.1.519 → 9.1.520

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # 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.

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.519
+  npm install -g blun-king-cli@9.1.520
 
 AgentSpine 0.10.1
 -----------------

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.519
+npm install -g blun-king-cli@9.1.520
 ```
 
 ## AgentSpine 0.10.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.519",
+  "version": "9.1.520",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {

package/scripts/check-session-start-hook-context-regression.js

@@ -2,7 +2,9 @@
 '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)
@@ -59,6 +61,67 @@ assert(
   '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',

package/bin/tool-result-offload-policy.cjs.vor-historical-preview-20260831-210300

@@ -1,317 +0,0 @@
-'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,
-};