blun-king-cli 9.1.422 → 9.1.424

package/bin/launcher-runtime.js

@@ -29,6 +29,7 @@ const { CORE_LOADED_MESSAGE } = require('./core-bootstrap');
 const { prepareManagedNodeRuntime } = require('./node-runtime');
 const { repairConfiguredNativeModules } = require('./native-module-repair');
 const { startMnemoConnectHeartbeat } = require('./mnemo-connect-heartbeat.cjs');
+const { recordRuntimeExit } = require('./runtime-exit-ledger.cjs');
 const { acquireSharedRuntimeLease } = require('./update-lease');
 const { runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
@@ -218,8 +219,35 @@ async function superviseProtectedCore(args, env, cwd, releaseLauncherLeases, opt
   const loaded = await core.loaded;
   if (loaded) await releaseLauncherLeases();
   const result = await core.completed;
-  if (result.error) throw result.error;
-  return exitCodeForChild(result, loaded);
+  if (result.error) {
+    recordRuntimeExit({
+      homeDir: env.BLUN_HOME,
+      source: 'launcher',
+      kind: 'child-error',
+      exitCode: 1,
+      phase: loaded ? 'runtime' : 'startup',
+      cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION,
+      profile: env.BLUN_PROFILE,
+      loaded,
+      childPid: core.child?.pid,
+      error: result.error,
+    });
+    throw result.error;
+  }
+  const exitCode = exitCodeForChild(result, loaded);
+  recordRuntimeExit({
+    homeDir: env.BLUN_HOME,
+    source: 'launcher',
+    kind: 'child-exit',
+    exitCode,
+    signal: result.signal,
+    phase: loaded ? 'runtime' : 'startup',
+    cliVersion: env.BLUN_PUBLIC_PACKAGE_VERSION,
+    profile: env.BLUN_PROFILE,
+    loaded,
+    childPid: core.child?.pid,
+  });
+  return exitCode;
 }
 
 function installTelegramForProfile(packageRoot, blunDir) {

package/bin/mistake-relevance-policy.cjs

@@ -14,7 +14,8 @@ const NON_ACTIONABLE_USER_ORIGINS = new Set([
   'skill_activation',
 ]);
 const STOP_WORDS = new Set([
-  'aber', 'alle', 'alles', 'auch', 'eine', 'einem', 'einen', 'einer', 'eines',
+  'aber', 'alle', 'alles', 'auch', 'das', 'dem', 'den', 'der', 'des', 'die',
+  'ein', 'eine', 'einem', 'einen', 'einer', 'eines',
   'fuer', 'haben', 'hier', 'immer', 'jetzt', 'kann', 'machen', 'mehr', 'mich',
   'nicht', 'noch', 'oder', 'sein', 'sind', 'soll', 'und', 'uns', 'von', 'was',
   'wenn', 'werden', 'wie', 'with', 'that', 'this', 'from', 'have', 'into',
@@ -22,8 +23,36 @@ const STOP_WORDS = new Set([
 ]);
 const REUSABLE_HEADING = /\b(rule|regel|condition|bedingung|countercheck|gegenprobe|trigger|ausloeser|auslöser)\b/iu;
 
+const SEMANTIC_SIGNAL_RULES = Object.freeze([
+  ['problem:reliability', /\b(?:error|failure|failed|broken|crash(?:ed)?|timeout|unavailable|corrupt(?:ed)?|dropped|missing|lost|fehler|scheiter\w*|absturz|ausfall|kaputt|defekt|fehlend|verloren|unerreichbar|abbruch)\b/iu],
+  ['problem:delivery', /\b(?:deliver\w*|receiv\w*|message\w*|repl(?:y|ies)|inbox|outbox|send(?:ing|s|t)?|consum\w*|zustell\w*|empfang\w*|nachricht\w*|meldung\w*|senden|bekomm\w*|antwort\w*)\b/iu],
+  ['problem:stagnation', /\b(?:loop\w*|repeat\w*|stuck|hang(?:ing)?|freeze|frozen|idle|no progress|stop(?:s|ped)? consuming|schleife\w*|wiederhol\w*|hang\w*|stillstand|leerlauf|kein fortschritt|taub)\b/iu],
+  ['problem:performance', /\b(?:slow|latency|bottleneck|throughput|memory pressure|cpu|vram|langsam\w*|latenz|durchsatz|engpass|speicherdruck)\b/iu],
+  ['problem:protocol', /\b(?:schema|contract|payload|protocol|format|version mismatch|manifest mismatch|vertrag|protokoll|versionskonflikt)\b/iu],
+  ['problem:capability', /\b(?:capabilit\w*|missing tool|not available|unsupported|fahigkeit\w*|werkzeug fehlt|nicht verfugbar)\b/iu],
+  ['area:orchestration', /\b(?:agent\w*|worker\w*|queue\w*|checkpoint\w*|heartbeat\w*|delegat\w*|owner\w*|responsib\w*|task\w*|turn\w*|busy|group\w*|channel\w*|arbeiter\w*|warteschlange\w*|prufpunkt\w*|herzschlag\w*|zustandig\w*|auftrag\w*|zug\w*|beschaftigt|gruppe\w*|gruppen\w*|kanal\w*)\b/iu],
+  ['area:memory', /\b(?:memory|recall|remember\w*|context|history|resume|checkpoint|mnemo|gedachtnis|erinner\w*|kontext|verlauf|wiederaufnahme)\b/iu],
+  ['area:release', /\b(?:release\w*|rollout\w*|update\w*|updater\w*|npm|package\w*|manifest\w*|version\w*|veroffentlich\w*|paket\w*|integrity|integritat)\b/iu],
+  ['area:media', /\b(?:image\w*|video\w*|audio\w*|portrait\w*|render\w*|pixel\w*|media|bild\w*|foto\w*|gesicht\w*|stimme\w*)\b/iu],
+  ['risk:validation', /\b(?:verif\w*|validat\w*|test\w*|check\w*|gate\w*|rollback\w*|canary|proof|evidence|sha(?:256|512)?|measur\w*|inspect\w*|(?:ge)?pruf\w*|gegenprobe\w*|beleg\w*|evidenz\w*|mess\w*|kontroll\w*)\b/iu],
+  ['action:repair', /\b(?:fix\w*|repair\w*|restore\w*|recover\w*|reparier\w*|beheb\w*|wiederherstell\w*)\b/iu],
+  ['action:investigate', /\b(?:inspect\w*|diagnos\w*|measure\w*|trace\w*|check\w*|(?:ge)?pruf\w*|mess\w*|untersuch\w*)\b/iu],
+]);
+
 function normalizeText(value) {
-  return String(value || '').normalize('NFKD').replace(/\p{M}/gu, '').toLowerCase();
+  return String(value || '')
+    .normalize('NFKD')
+    .replace(/\p{M}/gu, '')
+    .replace(/\u00df/gu, 'ss')
+    .toLowerCase();
+}
+
+function semanticSignalTags(value) {
+  const normalized = normalizeText(value);
+  if (!normalized) return [];
+  return SEMANTIC_SIGNAL_RULES
+    .filter(([, pattern]) => pattern.test(normalized))
+    .map(([tag]) => tag);
 }
 
 function terms(value) {
@@ -100,15 +129,25 @@ function isReusableSection(section) {
   return REUSABLE_HEADING.test(`${section.heading}\n${section.body}`);
 }
 
-function scoreSection(section, queryTerms) {
+function scoreSection(section, queryTerms, queryTags) {
   const heading = normalizeText(`${section.parent} ${section.heading}`);
   const body = normalizeText(section.body);
   let score = isReusableSection(section) ? 1 : 0;
+  let lexicalMatches = 0;
   for (const term of queryTerms) {
-    if (heading.includes(term)) score += 6;
-    if (body.includes(term)) score += 4;
+    if (heading.includes(term)) {
+      score += 6;
+      lexicalMatches += 1;
+    }
+    if (body.includes(term)) {
+      score += 4;
+      lexicalMatches += 1;
+    }
   }
-  return score;
+  const sectionTags = new Set(semanticSignalTags(`${heading}\n${body}`));
+  const semanticMatches = queryTags.filter((tag) => sectionTags.has(tag));
+  score += semanticMatches.length * 2;
+  return { lexicalMatches, score, semanticMatches };
 }
 
 function compactSection(section, maxChars) {
@@ -144,16 +183,24 @@ function selectRelevantMistakeSources(sources, query, options = {}) {
     }))
   ));
   const queryTerms = terms(query);
+  const queryTags = semanticSignalTags(query);
   const ranked = sections.map((section) => {
     const reusable = isReusableSection(section);
-    const score = scoreSection(section, queryTerms);
+    const { lexicalMatches, score, semanticMatches } = scoreSection(section, queryTerms, queryTags);
     return {
       ...section,
-      matched: score > (reusable ? 1 : 0),
+      lexicalMatches,
       reusable,
       score,
+      semanticMatches,
     };
   });
+  const hasLexicalMatch = ranked.some((section) => section.lexicalMatches > 0);
+  for (const section of ranked) {
+    section.matched = hasLexicalMatch
+      ? section.lexicalMatches > 0
+      : section.semanticMatches.length > 0;
+  }
   const hasMatch = ranked.some((section) => section.matched);
   ranked.sort((left, right) => {
     if (hasMatch && right.score !== left.score) return right.score - left.score;
@@ -188,6 +235,11 @@ function selectRelevantMistakeSources(sources, query, options = {}) {
   selected.sort((left, right) => left.ordinal - right.ordinal);
   const text = [header, ...selected.map((section) => section.rendered)].join('\n\n').slice(0, maxChars);
   return {
+    selected: selected.map((section) => ({
+      heading: section.heading,
+      reference: normalizedSources[section.sourceIndex]?.reference || '',
+      semanticMatches: section.semanticMatches || [],
+    })),
     selectedChars: text.length,
     selectedSections: selected.length,
     text,
@@ -209,6 +261,7 @@ module.exports = {
   RECENT_USER_MESSAGES,
   isLowInformationMistakeTurn,
   recentUserText,
+  semanticSignalTags,
   selectRelevantMistakeContent,
   selectRelevantMistakeSources,
 };

package/bin/runtime-exit-ledger.cjs

@@ -0,0 +1,143 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const DEFAULT_MAX_BYTES = 1024 * 1024;
+const DEFAULT_RETAIN_BYTES = 512 * 1024;
+const MAX_MESSAGE_CHARS = 2048;
+const MAX_STACK_CHARS = 8192;
+const MAX_DETAIL_CHARS = 2048;
+
+function runtimeExitLedgerPath(homeDir) {
+  return path.join(homeDir, 'diagnostics', 'runtime-exits.jsonl');
+}
+
+function replaceAllLiteral(value, needle, replacement) {
+  if (!needle) return value;
+  const lowerValue = process.platform === 'win32' ? value.toLowerCase() : value;
+  const lowerNeedle = process.platform === 'win32' ? needle.toLowerCase() : needle;
+  let result = '';
+  let cursor = 0;
+  for (;;) {
+    const index = lowerValue.indexOf(lowerNeedle, cursor);
+    if (index === -1) return `${result}${value.slice(cursor)}`;
+    result += `${value.slice(cursor, index)}${replacement}`;
+    cursor = index + needle.length;
+  }
+}
+
+function sanitizeExitText(input, maxChars = MAX_DETAIL_CHARS) {
+  let value = String(input ?? '');
+  const homes = new Set([
+    os.homedir(),
+    process.env.USERPROFILE,
+    process.env.HOME,
+  ].filter((entry) => typeof entry === 'string' && entry.length > 2));
+  for (const home of homes) {
+    value = replaceAllLiteral(value, path.normalize(home), '$HOME');
+    value = replaceAllLiteral(value, home.replaceAll('\\', '/'), '$HOME');
+  }
+  value = value
+    .replace(/[A-Za-z]:\\Users\\[^\\\s"']+/giu, '$HOME')
+    .replace(/\/home\/[^/\s"']+/gu, '$HOME')
+    .replace(/(Authorization\s*:\s*Bearer\s+)[^\s,;]+/giu, '$1<redacted>')
+    .replace(/\bsk-[A-Za-z0-9_-]{10,}\b/gu, '<redacted>')
+    .replace(/\b\d{6,}:[A-Za-z0-9_-]{20,}\b/gu, '<redacted>')
+    .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|secret|password)\s*[=:]\s*)[^\s,;}]+/giu, '$1<redacted>')
+    .replace(/(https?:\/\/[^\s/:@]+:)[^\s/@]+@/giu, '$1<redacted>@');
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...[truncated]`;
+}
+
+function normalizedError(error) {
+  if (error === undefined || error === null) return undefined;
+  if (error instanceof Error) {
+    return {
+      name: sanitizeExitText(error.name || error.constructor?.name || 'Error', 160),
+      message: sanitizeExitText(error.message || String(error), MAX_MESSAGE_CHARS),
+      stack: sanitizeExitText(error.stack || '', MAX_STACK_CHARS),
+    };
+  }
+  return {
+    name: typeof error === 'object' && typeof error.name === 'string'
+      ? sanitizeExitText(error.name, 160)
+      : 'NonErrorRejection',
+    message: sanitizeExitText(error, MAX_MESSAGE_CHARS),
+  };
+}
+
+function finiteInteger(value) {
+  return Number.isInteger(value) ? value : undefined;
+}
+
+function buildRuntimeExitRecord(input) {
+  const now = typeof input.now === 'function' ? input.now() : new Date();
+  const record = {
+    schemaVersion: 1,
+    ts: (now instanceof Date ? now : new Date(now)).toISOString(),
+    source: sanitizeExitText(input.source || 'unknown', 80),
+    kind: sanitizeExitText(input.kind || 'unknown', 120),
+    exitCode: finiteInteger(input.exitCode),
+    signal: input.signal ? sanitizeExitText(input.signal, 40) : undefined,
+    phase: input.phase ? sanitizeExitText(input.phase, 80) : undefined,
+    cliVersion: input.cliVersion ? sanitizeExitText(input.cliVersion, 80) : undefined,
+    profile: input.profile ? sanitizeExitText(input.profile, 120) : undefined,
+    sessionId: input.sessionId ? sanitizeExitText(input.sessionId, 240) : undefined,
+    pid: finiteInteger(input.pid ?? process.pid),
+    ppid: finiteInteger(input.ppid ?? process.ppid),
+    childPid: finiteInteger(input.childPid),
+    loaded: typeof input.loaded === 'boolean' ? input.loaded : undefined,
+    detail: input.detail ? sanitizeExitText(input.detail, MAX_DETAIL_CHARS) : undefined,
+    error: normalizedError(input.error),
+  };
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== undefined && value !== ''));
+}
+
+function trimLedger(filePath, maxBytes, retainBytes, incomingBytes) {
+  let size;
+  try {
+    size = fs.statSync(filePath).size;
+  } catch {
+    return;
+  }
+  if (size + incomingBytes <= maxBytes) return;
+  const contents = fs.readFileSync(filePath);
+  const keepFrom = Math.max(0, contents.length - Math.min(retainBytes, maxBytes - incomingBytes));
+  let lineStart = keepFrom;
+  if (lineStart > 0) {
+    const nextNewline = contents.indexOf(0x0a, lineStart);
+    lineStart = nextNewline === -1 ? contents.length : nextNewline + 1;
+  }
+  fs.writeFileSync(filePath, contents.subarray(lineStart), { mode: 0o600 });
+}
+
+function recordRuntimeExit(input = {}) {
+  try {
+    const homeDir = typeof input.homeDir === 'string' ? input.homeDir.trim() : '';
+    if (!homeDir) return false;
+    const filePath = runtimeExitLedgerPath(homeDir);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const line = `${JSON.stringify(buildRuntimeExitRecord(input))}\n`;
+    const incomingBytes = Buffer.byteLength(line);
+    const maxBytes = Math.max(1024, finiteInteger(input.maxBytes) ?? DEFAULT_MAX_BYTES);
+    const retainBytes = Math.max(0, finiteInteger(input.retainBytes) ?? DEFAULT_RETAIN_BYTES);
+    trimLedger(filePath, maxBytes, retainBytes, incomingBytes);
+    fs.appendFileSync(filePath, line, { encoding: 'utf8', mode: 0o600 });
+    try {
+      fs.chmodSync(filePath, 0o600);
+    } catch {}
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_RETAIN_BYTES,
+  buildRuntimeExitRecord,
+  recordRuntimeExit,
+  runtimeExitLedgerPath,
+  sanitizeExitText,
+};

package/blun.mjs

@@ -8,6 +8,7 @@ import { createRequire } from "node:module";
 import telegramConsoleStatusPolicy from "./bin/telegram-console-status-policy.cjs";
 import cognitiveGoalAutostartPolicy from "./bin/cognitive-goal-autostart-policy.cjs";
 import cognitiveGoalTimeTriggerController from "./bin/cognitive-goal-time-trigger-controller.cjs";
+import runtimeExitLedger from "./bin/runtime-exit-ledger.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs$16 from "node:fs";
 import Kt, { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -40,6 +41,7 @@ import { pipeline as pipeline$1 } from "node:stream/promises";
 const { writeTelegramConsoleStatus } = telegramConsoleStatusPolicy;
 const { goalAutostartDecision, goalContinuationDecision } = cognitiveGoalAutostartPolicy;
 const { GoalTimeTriggerController } = cognitiveGoalTimeTriggerController;
+const { recordRuntimeExit } = runtimeExitLedger;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -516808,6 +516810,17 @@ var BlunTUI = class {
 		if (process.platform !== "win32") signals.push("SIGHUP");
 		for (const signal of signals) {
 			const handler = () => {
+				recordRuntimeExit({
+					homeDir: process.env["BLUN_HOME"],
+					source: "core",
+					kind: "signal",
+					exitCode: signal === "SIGTERM" ? 143 : 129,
+					signal,
+					phase: "runtime",
+					cliVersion: process.env["BLUN_PUBLIC_PACKAGE_VERSION"],
+					profile: process.env["BLUN_PROFILE"],
+					sessionId: this.getCurrentSessionId()
+				});
 				if (signal === "SIGHUP") {
 					this.emergencyTerminalExit();
 					return;
@@ -516824,7 +516837,20 @@ var BlunTUI = class {
 			});
 		}
 		const terminalErrorHandler = (error) => {
-			if (isDeadTerminalError(error)) this.emergencyTerminalExit();
+			if (isDeadTerminalError(error)) {
+				recordRuntimeExit({
+					homeDir: process.env["BLUN_HOME"],
+					source: "core",
+					kind: "dead-terminal",
+					exitCode: 129,
+					phase: "runtime",
+					cliVersion: process.env["BLUN_PUBLIC_PACKAGE_VERSION"],
+					profile: process.env["BLUN_PROFILE"],
+					sessionId: this.getCurrentSessionId(),
+					error
+				});
+				this.emergencyTerminalExit();
+			}
 		};
 		process.stdout.on("error", terminalErrorHandler);
 		process.stderr.on("error", terminalErrorHandler);
@@ -519588,6 +519614,15 @@ async function runShell(opts, version) {
 	const trackLifecycle = (event, properties) => {
 		trackLifecycleForSession(tui.getCurrentSessionId(), event, properties);
 	};
+	const recordShellExit = (entry) => recordRuntimeExit({
+		homeDir: process.env["BLUN_HOME"] ?? telemetryBootstrap.homeDir,
+		source: "core",
+		phase: "runtime",
+		cliVersion: version,
+		profile: process.env["BLUN_PROFILE"],
+		sessionId: tui.getCurrentSessionId(),
+		...entry
+	});
 	let savedStty;
 	try {
 		const saved = execSync("stty -g", {
@@ -519621,12 +519656,22 @@ async function runShell(opts, version) {
 		process.exit(exitCode);
 	};
 	const onUncaughtException = (error) => {
+		recordShellExit({
+			kind: "uncaught-exception",
+			exitCode: 1,
+			error
+		});
 		try {
 			log.error("uncaughtException, restoring terminal and exiting", { error: String(error) });
 		} catch {}
 		emergencyExit(1);
 	};
 	const onUnhandledRejection = (reason) => {
+		recordShellExit({
+			kind: "unhandled-rejection",
+			exitCode: 1,
+			error: reason
+		});
 		try {
 			log.error("unhandledRejection, restoring terminal and exiting", { reason: String(reason) });
 		} catch {}
@@ -519641,6 +519686,10 @@ async function runShell(opts, version) {
 	tui.onExit = async (exitCode = 0) => {
 		const sessionId = tui.getCurrentSessionId();
 		const hasContent = tui.hasSessionContent();
+		recordShellExit({
+			kind: "normal-exit",
+			exitCode
+		});
 		setCrashPhase("shutdown");
 		trackLifecycle("exit", { duration_ms: Date.now() - startedAt });
 		await shutdownTelemetry({ timeoutMs: CLI_SHUTDOWN_TIMEOUT_MS });
@@ -519671,6 +519720,12 @@ async function runShell(opts, version) {
 			...tui.getStartupPhaseMs()
 		});
 	} catch (error) {
+		recordShellExit({
+			kind: "startup-failure",
+			exitCode: 1,
+			phase: "startup",
+			error
+		});
 		removeCrashHandlers();
 		setCrashPhase("shutdown");
 		trackLifecycle("exit", { duration_ms: Date.now() - startedAt });

package/package.json

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