blun-king-cli 9.1.199 → 9.1.201

package/bin/context-insight-policy.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+function finiteNonNegative(value) {
+  return Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+
+function buildContextInsight(input = {}) {
+  const projectedTokens = finiteNonNegative(input.projectedTokenCount);
+  const maxTokens = finiteNonNegative(input.effectiveMaxContextTokens);
+  const conversationTokens = finiteNonNegative(input.conversationTokens);
+  const toolSchemaTokens = finiteNonNegative(input.toolSchemaTokens);
+  const compactionBudgetTokens = Math.min(
+    maxTokens,
+    finiteNonNegative(input.compactionBudgetTokens),
+  );
+  const freeTokens = Math.max(0, maxTokens - projectedTokens);
+  const ratio = maxTokens > 0
+    ? Math.min(1, projectedTokens / maxTokens)
+    : 0;
+
+  return {
+    projectedTokens,
+    maxTokens,
+    conversationTokens,
+    toolSchemaTokens,
+    compactionBudgetTokens,
+    freeTokens,
+    ratio,
+  };
+}
+
+module.exports = {
+  buildContextInsight,
+};

package/bin/error-memory-performance-policy.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const ERROR_MEMORY_MAX_CHARS = 2_800;
+
+function buildCompactErrorMemoryReminder(patterns) {
+  const lines = [
+    '<error-memory-check>',
+    'Vor Abschluss jede Regel pruefen; Verletzungen korrigieren oder offen benennen.',
+  ];
+
+  for (const pattern of patterns) {
+    const check = pattern.check ? ` | Pruefung: ${pattern.check}` : '';
+    lines.push(`${pattern.number}. ${pattern.rule}${check}`);
+  }
+
+  lines.push(
+    'Arbeitsweise: 3-7 sichtbare Schritte; Werkzeuge proaktiv; nach zwei gleichen Fehlern Ansatz wechseln; Schritte erst nach echtem Nachweis abschliessen; nach Zielerreichung stoppen; Teilerfolg oder Scheitern mit Grund und naechstem Schritt offen melden.',
+    '</error-memory-check>',
+  );
+  return lines.join('\n');
+}
+
+function compactLegacyErrorMemoryReminder(text) {
+  const source = String(text);
+  if (!source.includes('<error-memory-check>') || !source.includes('  Regel: ')) return source;
+
+  const lines = source.split(/\r?\n/u);
+  const patterns = [];
+  for (let index = 0; index + 1 < lines.length; index += 1) {
+    const title = lines[index].match(/^\s*(\d+)\.\s+(.+)$/u);
+    const rule = lines[index + 1].match(/^\s*Regel:\s*(.+)$/u);
+    if (!title || !rule) continue;
+    const check = lines[index + 2]?.match(/^\s*Pruefung:\s*(.+)$/u);
+    patterns.push({
+      number: Number(title[1]),
+      title: title[2],
+      rule: rule[1],
+      check: check?.[1],
+    });
+  }
+  return patterns.length > 0 ? buildCompactErrorMemoryReminder(patterns) : source;
+}
+
+module.exports = {
+  ERROR_MEMORY_MAX_CHARS,
+  buildCompactErrorMemoryReminder,
+  compactLegacyErrorMemoryReminder,
+};

package/bin/repeated-injection-projection.cjs

@@ -1,6 +1,10 @@
 'use strict';
 
-const LATEST_ONLY_INJECTION_VARIANTS = new Set(['mistake_md']);
+const {
+  compactLegacyErrorMemoryReminder,
+} = require('./error-memory-performance-policy.cjs');
+
+const LATEST_ONLY_INJECTION_VARIANTS = new Set(['error-memory', 'mistake_md']);
 
 function repeatedInjectionKey(message) {
   if (message?.role !== 'user') return null;
@@ -34,7 +38,15 @@ function dedupeRepeatedInjections(history) {
     }
     if (seenTexts.has(key.text)) continue;
     seenTexts.add(key.text);
-    kept.push(message);
+    if (key.variant === 'error-memory') {
+      const compactText = compactLegacyErrorMemoryReminder(key.text);
+      kept.push(compactText === key.text ? message : {
+        ...message,
+        content: [{ ...message.content[0], text: compactText }],
+      });
+    } else {
+      kept.push(message);
+    }
   }
 
   kept.reverse();

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

@@ -2,6 +2,7 @@
 
 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;
@@ -171,6 +172,7 @@ module.exports = {
   TOOL_RESULT_HISTORICAL_SUCCESS_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,

package/blun.mjs

@@ -79224,6 +79224,10 @@ var init_injector = __esmMin((() => {
 //#endregion
 //#region ../../packages/agent-core/src/agent/injection/error-memory.ts
 function buildErrorMemoryReminder(patterns) {
+	try {
+		const { buildCompactErrorMemoryReminder } = createRequire(import.meta.url)("./bin/error-memory-performance-policy.cjs");
+		return buildCompactErrorMemoryReminder(patterns);
+	} catch {}
 	const lines = [];
 	lines.push("<error-memory-check>");
 	lines.push("");
@@ -260377,7 +260381,7 @@ function renderPersistedToolResult(toolName, toolCallId, text, outputPath, toolT
 		`output_size_chars: ${String(text.length)}`,
 		`output_size_bytes: ${String(Buffer.byteLength(text, "utf8"))}`,
 		`output_path: ${outputPath}`,
-		"next_step: Use Read with output_path to page through the full output."
+		`next_step: Use Read with output_path using n_lines <= ${String(TOOL_RESULT_RECOVERY_PAGE_LINES)}; advance line_offset between calls.`
 	];
 	lines.push("", "[preview: head and tail]", createToolResultPreview(text));
 	return lines.join("\n");
@@ -260392,7 +260396,7 @@ function renderReadSourceReference(toolName, toolCallId, text, outputPath) {
 		`output_size_chars: ${String(text.length)}`,
 		`output_size_bytes: ${String(Buffer.byteLength(text, "utf8"))}`,
 		`output_path: ${outputPath}`,
-		"next_step: Use Read with output_path to page through the source file."
+		`next_step: Use Read with output_path using n_lines <= ${String(TOOL_RESULT_RECOVERY_PAGE_LINES)}; advance line_offset between calls.`
 	];
 	lines.push("", "[preview: head and tail]", createToolResultPreview(text));
 	return lines.join("\n");
@@ -260437,19 +260441,20 @@ function renderHistoricalToolResultReference(toolName, toolCallId, text, outputP
 		`output_size_chars: ${String(text.length)}`,
 		`output_size_bytes: ${String(Buffer.byteLength(text, "utf8"))}`,
 		`output_path: ${outputPath}`,
-		"next_step: Use Read with output_path if the full result is needed again."
+		`next_step: Use Read with output_path using n_lines <= ${String(TOOL_RESULT_RECOVERY_PAGE_LINES)}; advance line_offset between calls.`
 	].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_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, selectToolResultBatchOffloads, selectHistoricalToolResultOffloads, buildToolResultOffloadTelemetry;
+var TOOL_RESULT_MAX_CHARS, TOOL_RESULT_PREVIEW_CHARS, TOOL_RESULT_RECOVERY_PAGE_LINES, TOOL_RESULT_OFFLOAD_MARKER, TOOL_RESULT_HISTORICAL_KEEP_RECENT_MESSAGES, shouldOffloadToolResult, createToolResultPreview, compactPersistedToolResultReference, compactHistoricalSuccessfulToolResults, 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_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;
 	shouldOffloadToolResult = toolResultOffloadPolicy.shouldOffloadToolResult;
@@ -403025,11 +403030,18 @@ const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
 	},
 	{
 		name: "usage",
-		aliases: ["context"],
+		aliases: [],
 		descriptionKey: "command.usage.description",
 		priority: 60,
 		availability: "always"
 	},
+	{
+		name: "context",
+		aliases: [],
+		descriptionKey: "usage.context.title",
+		priority: 65,
+		availability: "always"
+	},
 	{
 		name: "status",
 		aliases: [],
@@ -416768,6 +416780,7 @@ function buildManagedUsageReportLines(options) {
 }
 var { buildApprovalRejectionStop } = createRequire(import.meta.url)("./bin/approval-rejection-stop.cjs");
 var { reconcileContextBudget } = createRequire(import.meta.url)("./bin/context-budget-ledger.cjs");
+var { buildContextInsight } = createRequire(import.meta.url)("./bin/context-insight-policy.cjs");
 function buildUsageReportLines(options) {
 	const accent = (text) => currentTheme.boldFg("primary", text);
 	const value = (text) => currentTheme.fg("text", text);
@@ -417812,6 +417825,29 @@ function managedUsageErrorCode(error) {
 	}
 	return record.status === 401 || record.status === 403 ? "unauthenticated" : "unavailable";
 }
+function buildContextInsightLines(insight) {
+	const value = (text) => currentTheme.fg("text", text);
+	const muted = (text) => currentTheme.fg("textDim", text);
+	const severityColor = (ratio) => ratio >= 0.9 ? "error" : ratio >= 0.75 ? "warning" : "success";
+	const locale = getCurrentUiLocale();
+	const bar = renderProgressBar(insight.ratio, 20);
+	const barColoured = currentTheme.fg(severityColor(insight.ratio), bar);
+	const percentage = `${(insight.ratio * 100).toFixed(1)}%`;
+	const lines = [
+		`  ${barColoured}  ${value(percentage.padStart(6, " "))}  ${muted(`(${formatExactTokenCount(insight.projectedTokens, locale)} / ${formatExactTokenCount(insight.maxTokens, locale)})`)}`,
+		`  ${muted(`${uiText("export.conversation")}:`)} ${value(formatExactTokenCount(insight.conversationTokens, locale))}`,
+		`  ${muted(`${uiText("mcp.capability.tools")}:`)} ${value(formatExactTokenCount(insight.toolSchemaTokens, locale))}`,
+		`  ${muted(`${uiText("command.compact.description")}:`)} ${value(formatExactTokenCount(insight.compactionBudgetTokens, locale))}`,
+		`  ${muted(uiText("usage.plan.metric.remaining", { count: formatExactTokenCount(insight.freeTokens, locale) }))}`
+	];
+	return lines;
+}
+async function showContextInsight(host) {
+	const insight = buildContextInsight(await host.requireSession().getContext());
+	const panel = new UsagePanelComponent(() => buildContextInsightLines(insight), "primary", uiText("usage.context.title"));
+	host.state.transcriptContainer.addChild(panel);
+	host.state.ui.requestRender();
+}
 async function showUsage(host) {
 	const [sessionUsage, managedUsage, runtimeStatus] = await Promise.all([
 		loadSessionUsageReport(host),
@@ -495021,6 +495057,9 @@ async function handleBuiltInSlashCommand(host, name, args) {
 		case "premortem":
 			await handlePremortemCommand(host, args);
 			return;
+		case "context":
+			await showContextInsight(host);
+			return;
 		case "usage":
 			await showUsage(host);
 			return;

package/package.json

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