blun-king-cli 9.1.124 → 9.1.126

package/LIESMICH.txt

@@ -125,6 +125,8 @@ Ab BLUN King 9.1.122 wird die vollständige integrierte Designrichtlinie nicht m
 
 Ab BLUN King 9.1.123 entlastet die Modellprojektion zusätzlich die Argumente älterer, bereits abgeschlossener Werkzeugaufrufe. Name, Kennung und Ergebnis bleiben erhalten; nur die wiederholte Übertragung großer alter JSON-Argumente entfällt. Unbeantwortete Werkzeugaufrufe, ungültige JSON-Argumente und die neuesten 20 Nachrichten bleiben vollständig. Der gespeicherte Rohverlauf und Exporte werden nicht verändert. In Fredriks gemessener Projektion sank der Anfrageumfang dadurch von 101.459 auf 94.026 Zeichen, also um etwa 1.859 geschätzte Token je Anfrage.
 
+Ab BLUN King 9.1.126 wird die laufzeitweite `Mistake.md` nicht mehr bei jedem Zug vollständig mitgesendet. King wählt deterministisch bis zu fünf Abschnitte aus, die zu den letzten vier Nutzernachrichten passen, und bevorzugt dabei wiederverwendbare Regeln, Bedingungen und Gegenproben. Die Auswahl ist auf 6.000 Zeichen begrenzt und ersetzt den vorherigen Hinweis, statt weitere Kopien anzusammeln. Die vollständige Datei, ihr Register, ihr Archiv und ihr Schreibweg bleiben unverändert. Dafür ist kein zusätzlicher Modell-, Einbettungs- oder Netzwerkaufruf nötig. In der aktuell gemessenen laufzeitweiten Datei sank die Modellsicht abhängig von der Anfrage von 13.470 Zeichen auf 2.921 bis 4.819 Zeichen.
+
 Verliert ein delegierter Einzelagent oder ein Mitglied eines Agentenschwarms die Provider-Verbindung, erhält es eine leere Provider-Antwort, bricht sein Stream wegen Leerlaufs ab oder meldet der Server HTTP 408/500/502/503/504, setzt BLUN King denselben Agenten anhand seines dauerhaften Verlaufs fort. Bei Einzelagenten sowie bei Schwarm-Unterbrechungen außerhalb von HTTP 429 wartet die erste Fortsetzung zwei Sekunden und die zweite fünf Sekunden; danach bleibt der ursprüngliche Fehler sichtbar. HTTP 429 behält im Schwarm seine getrennte, längere Überlastungsregel. Authentifizierungs-, Zahlungs- oder Kontingent-, Richtlinien-, Kontext-, Werkzeug- und Codefehler sowie manuelle Abbrüche lösen keine automatische Fortsetzung aus. Jeder Fortsetzungsversuch verwendet die bestehende Agenten-ID, damit bereits abgeschlossene Arbeit nicht wiederholt wird.
 
 Rein lesende Sitzungsdiagnose
@@ -226,6 +228,16 @@ Im automatisch angebundenen Telegram-Kanal werden ausschließlich /loop, /goal,
 sie in der Warteschlange. Andere Slash-Eingaben werden aus Sicherheitsgründen
 als normale Chatnachrichten behandelt.
 
+Rechner aus Telegram prüfen
+----------------------------
+Der Telegram-Befehl /status prüft die lokale Verbindung ohne Modellaufruf. Er
+zeigt den Rechnernamen, die installierte BLUN-Version, die Laufzeit der
+Telegram-Brücke, die Verbindung zur Konsole, den aktuellen Zustellweg und die
+Größe der Eingangswarteschlange. Damit bleibt der Zustand auch dann abfragbar,
+wenn die Konsole hängt oder der Modellanbieter ausgelastet ist. Die Ausgabe enthält keine
+Chat-IDs, Dateipfade, Zugangsdaten oder Nachrichteninhalte. Nicht verbundene
+Absender erhalten weiterhin nur die Kopplungsanweisung.
+
 Nachweisbare Arbeitsabläufe
 ---------------------------
 

package/README.md

@@ -131,6 +131,8 @@ Ab BLUN King 9.1.122 wird die vollständige integrierte Designrichtlinie nicht m
 
 Ab BLUN King 9.1.123 entlastet die Modellprojektion zusätzlich die Argumente älterer, bereits abgeschlossener Werkzeugaufrufe. Name, Kennung und Ergebnis bleiben erhalten; nur die wiederholte Übertragung großer alter JSON-Argumente entfällt. Unbeantwortete Werkzeugaufrufe, ungültige JSON-Argumente und die neuesten 20 Nachrichten bleiben vollständig. Der gespeicherte Rohverlauf und Exporte werden nicht verändert. In Fredriks gemessener Projektion sank der Anfrageumfang dadurch von 101.459 auf 94.026 Zeichen, also um etwa 1.859 geschätzte Token je Anfrage.
 
+Ab BLUN King 9.1.126 wird die laufzeitweite `Mistake.md` nicht mehr bei jedem Zug vollständig mitgesendet. King wählt deterministisch bis zu fünf Abschnitte aus, die zu den letzten vier Nutzernachrichten passen, und bevorzugt dabei wiederverwendbare Regeln, Bedingungen und Gegenproben. Die Auswahl ist auf 6.000 Zeichen begrenzt und ersetzt den vorherigen Hinweis, statt weitere Kopien anzusammeln. Die vollständige Datei, ihr Register, ihr Archiv und ihr Schreibweg bleiben unverändert. Dafür ist kein zusätzlicher Modell-, Einbettungs- oder Netzwerkaufruf nötig. In der aktuell gemessenen laufzeitweiten Datei sank die Modellsicht abhängig von der Anfrage von 13.470 Zeichen auf 2.921 bis 4.819 Zeichen.
+
 Ab BLUN King 9.1.99 werden auch direkt aufeinanderfolgende reine Textergebnisse als Stapel betrachtet. Enthalten sie zusammen mehr als 12.000 Zeichen, obwohl kein einzelnes Ergebnis diese Grenze überschreitet, speichert King so viele der größten geeigneten Ergebnisse wie nötig in privaten Dateien. In der Modellprojektion verbleiben lesbare Verweise. Der unveränderte Sitzungsrohverlauf bleibt vollständig erhalten. Gemischte Medienergebnisse, einzelne Ergebnisse unter 3.000 Zeichen und Stapel bis einschließlich 12.000 Zeichen bleiben unverändert. Beispiel: Bei zwei Suchergebnissen mit 7.000 und 6.000 Zeichen wird das größere Ergebnis privat gespeichert; Anfang, Ende, ausgelassene Zeichenzahl und `output_path` bleiben für den Agenten sichtbar.
 
 Ab BLUN King 9.1.100 beendet eine begrenzte Grep-Inhaltssuche ripgrep, sobald der Versatz, die angeforderten Zeilen und eine zusätzliche Vorschauzeile vollständig vorliegen. Die Vorschauzeile belegt, ob eine weitere Seite existiert, ohne vorher bis zu 10 MB einzulesen. Unbegrenzte Suchen, Trefferzählungen und nach Änderungszeit sortierte Dateilisten laufen weiterhin vollständig durch.
@@ -242,6 +244,16 @@ Im automatisch angebundenen Telegram-Kanal werden ausschließlich `/loop`,
 beschäftigt, bleiben sie in der Warteschlange. Andere Slash-Eingaben werden aus
 Sicherheitsgründen als normale Chatnachrichten behandelt.
 
+### Rechner aus Telegram prüfen
+
+Der Telegram-Befehl `/status` prüft die lokale Verbindung ohne Modellaufruf.
+Er zeigt den Rechnernamen, die installierte BLUN-Version, die Laufzeit der
+Telegram-Brücke, die Verbindung zur Konsole, den aktuellen Zustellweg und die
+Größe der Eingangswarteschlange. Damit bleibt der Zustand auch dann abfragbar,
+wenn die Konsole hängt oder der Modellanbieter ausgelastet ist. Die Ausgabe enthält keine
+Chat-IDs, Dateipfade, Zugangsdaten oder Nachrichteninhalte. Nicht verbundene
+Absender erhalten weiterhin nur die Kopplungsanweisung.
+
 Beim ersten Start werden das Telegram-Plugin und die mitgelieferten Skills
 eingerichtet. Die Anmeldung erfolgt anschließend in der
 Konsole mit `/login` über den BLUN-OAuth-Server. Das Paket erzeugt keine

package/bin/mistake-relevance-policy.cjs

@@ -0,0 +1,152 @@
+'use strict';
+
+const DEFAULT_MAX_CHARS = 6_000;
+const DEFAULT_MAX_SECTIONS = 5;
+const RECENT_USER_MESSAGES = 4;
+const STOP_WORDS = new Set([
+  'aber', 'alle', 'alles', 'auch', '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',
+  'your', 'you', 'the', 'and', 'for', 'are', 'not', 'but', 'all', 'can',
+]);
+const REUSABLE_HEADING = /\b(rule|regel|condition|bedingung|countercheck|gegenprobe|trigger|ausloeser|auslöser)\b/iu;
+
+function normalizeText(value) {
+  return String(value || '').normalize('NFKD').replace(/\p{M}/gu, '').toLowerCase();
+}
+
+function terms(value) {
+  return [...new Set(normalizeText(value).match(/[\p{L}\p{N}_-]{3,}/gu) || [])]
+    .filter((term) => !STOP_WORDS.has(term));
+}
+
+function textFromMessage(message) {
+  if (typeof message?.content === 'string') return message.content.trim();
+  if (!Array.isArray(message?.content)) return '';
+  return message.content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text.trim())
+    .filter(Boolean)
+    .join('\n');
+}
+
+function recentUserText(history, limit = RECENT_USER_MESSAGES) {
+  if (!Array.isArray(history)) return '';
+  return history
+    .filter((message) => message?.role === 'user')
+    .map(textFromMessage)
+    .filter(Boolean)
+    .slice(-Math.max(1, Number(limit) || RECENT_USER_MESSAGES))
+    .join('\n');
+}
+
+function splitSections(source) {
+  const text = String(source || '').replace(/\r\n?/gu, '\n').trim();
+  if (!text) return [];
+  const headings = [...text.matchAll(/^#{2,3}\s+.+$/gmu)];
+  const sections = [];
+  let parent = '';
+  const preambleEnd = headings[0]?.index ?? text.length;
+  const preamble = text.slice(0, preambleEnd).trim();
+  if (preamble) {
+    const separator = preamble.indexOf('\n---');
+    const body = separator >= 0 ? preamble.slice(separator + 4).trim() : '';
+    if (body) sections.push({ heading: '# Mistake.md', parent: '', body, index: -1 });
+  }
+  headings.forEach((match, index) => {
+    const heading = match[0].trim();
+    const level = heading.startsWith('### ') ? 3 : 2;
+    if (level === 2) parent = heading;
+    const start = match.index + match[0].length;
+    const end = headings[index + 1]?.index ?? text.length;
+    sections.push({
+      heading,
+      parent: level === 3 ? parent : '',
+      body: text.slice(start, end).trim(),
+      index,
+    });
+  });
+  return sections;
+}
+
+function scoreSection(section, queryTerms) {
+  const heading = normalizeText(`${section.parent} ${section.heading}`);
+  const body = normalizeText(section.body);
+  let score = REUSABLE_HEADING.test(section.heading) ? 1 : 0;
+  for (const term of queryTerms) {
+    if (heading.includes(term)) score += 6;
+    if (body.includes(term)) score += 4;
+  }
+  return score;
+}
+
+function compactSection(section, maxChars) {
+  const title = section.parent && section.parent !== section.heading
+    ? `${section.parent}\n${section.heading}`
+    : section.heading;
+  const full = `${title}\n${section.body}`.trim();
+  if (full.length <= maxChars) return full;
+  const marker = '\n\n[section shortened deterministically]\n\n';
+  const available = Math.max(0, maxChars - marker.length);
+  const headChars = Math.ceil(available * 0.55);
+  const tailChars = Math.floor(available * 0.45);
+  return `${full.slice(0, headChars).trimEnd()}${marker}${full.slice(-tailChars).trimStart()}`;
+}
+
+function selectRelevantMistakeContent(source, query, options = {}) {
+  const maxChars = Math.max(256, Number(options.maxChars) || DEFAULT_MAX_CHARS);
+  const maxSections = Math.max(1, Number(options.maxSections) || DEFAULT_MAX_SECTIONS);
+  const sourceText = String(source || '').trim();
+  const sections = splitSections(sourceText);
+  const queryTerms = terms(query);
+  const ranked = sections.map((section) => ({
+    ...section,
+    score: scoreSection(section, queryTerms),
+  }));
+  const hasMatch = ranked.some((section) => section.score > (REUSABLE_HEADING.test(section.heading) ? 1 : 0));
+  ranked.sort((left, right) => {
+    if (hasMatch && right.score !== left.score) return right.score - left.score;
+    const rightReusable = REUSABLE_HEADING.test(right.heading) ? 1 : 0;
+    const leftReusable = REUSABLE_HEADING.test(left.heading) ? 1 : 0;
+    if (rightReusable !== leftReusable) return rightReusable - leftReusable;
+    return right.index - left.index;
+  });
+
+  const header = '# Mistake.md\n\nRelevant verified lessons for the current turn.';
+  const selected = [];
+  let remaining = maxChars - header.length - 2;
+  const perSectionMax = Math.max(
+    160,
+    Math.floor(remaining / Math.min(maxSections, 3)),
+  );
+  for (const section of ranked) {
+    if (selected.length >= maxSections || remaining < 64) break;
+    if (hasMatch && section.score === 0) continue;
+    const rendered = compactSection(section, Math.min(remaining, perSectionMax));
+    if (!rendered) continue;
+    selected.push({ ...section, rendered });
+    remaining -= rendered.length + 2;
+  }
+  if (selected.length === 0 && sections.length > 0) {
+    const fallback = sections.at(-1);
+    selected.push({ ...fallback, rendered: compactSection(fallback, remaining) });
+  }
+  selected.sort((left, right) => left.index - right.index);
+  const text = [header, ...selected.map((section) => section.rendered)].join('\n\n').slice(0, maxChars);
+  return {
+    selectedChars: text.length,
+    selectedSections: selected.length,
+    text,
+    totalChars: sourceText.length,
+    totalSections: sections.length,
+  };
+}
+
+module.exports = {
+  DEFAULT_MAX_CHARS,
+  DEFAULT_MAX_SECTIONS,
+  RECENT_USER_MESSAGES,
+  recentUserText,
+  selectRelevantMistakeContent,
+};

package/bin/telegram-remote-status-policy.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+function formatDuration(seconds) {
+  const minutes = Math.max(0, Math.floor(Number(seconds) / 60));
+  if (minutes < 60) return `${minutes} min`;
+  const hours = Math.floor(minutes / 60);
+  return `${hours} h ${minutes % 60} min`;
+}
+
+function formatBytes(bytes) {
+  const value = Math.max(0, Number(bytes) || 0);
+  if (value < 1024) return `${Math.round(value)} B`;
+  if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
+  return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function buildTelegramRemoteStatus(input) {
+  if (!input?.access?.allowFrom?.includes(String(input.senderId))) {
+    return 'Nicht verbunden. Sende eine Nachricht, um einen Verbindungscode zu erhalten.';
+  }
+
+  const username = input.username ? `@${String(input.username).replace(/^@/u, '')}` : 'verbundener Nutzer';
+  const tui = input.tuiFresh
+    ? `verbunden${Number.isInteger(input.tuiPid) ? ` (PID ${input.tuiPid})` : ''}`
+    : 'nicht verbunden';
+  const delivery = input.deliveryTarget === 'tui'
+    ? 'Konsolen-Warteschlange'
+    : 'Brücke ohne Konsole';
+  return [
+    `BLUN-Fernstatus für ${username}`,
+    `Rechner: ${input.machineName || 'unbekannt'}`,
+    `Version: ${input.version || 'unbekannt'}`,
+    `Brücke: aktiv (PID ${input.bridgePid}, ${formatDuration(input.bridgeUptimeSeconds)})`,
+    `Konsole: ${tui}`,
+    `Zustellung: ${delivery}`,
+    `Warteschlange: ${formatBytes(input.queueBytes)}`,
+    `Gemessen: ${input.capturedAt}`,
+  ].join('\n');
+}
+
+module.exports = { buildTelegramRemoteStatus, formatBytes, formatDuration };

package/blun.mjs

@@ -231442,13 +231442,16 @@ var init_mistake_md_writer = __esmMin((() => {
 * Nach jedem Turn kann der Writer neue Eintraege an Mistake.md anhaengen.
 * Der Writer laeuft NACH dem Lesen, nie waehrend (C3).
 */
-var MistakeMdInjector;
+function isMistakeMdReminder(message) {
+	return message.origin?.kind === "injection" && message.origin.variant === "mistake_md";
+}
+var MistakeMdInjector, recentUserText, selectRelevantMistakeContent;
 var init_mistake_md = __esmMin((() => {
 	init_injector();
 	init_mistake_md_writer();
+	({ recentUserText, selectRelevantMistakeContent } = createRequire(import.meta.url)("./bin/mistake-relevance-policy.cjs"));
 	MistakeMdInjector = class extends DynamicInjector {
 		injectionVariant = "mistake_md";
-		lastHash = null;
 		reserveChecked = false;
 		mistakeDir;
 		mistakeFile;
@@ -231459,12 +231462,24 @@ var init_mistake_md = __esmMin((() => {
 		}
 		onContextClear() {
 			super.onContextClear();
-			this.lastHash = null;
 			this.reserveChecked = false;
 		}
-		onContextCompacted() {
-			super.onContextCompacted();
-			this.lastHash = null;
+		async inject() {
+			const injection = await this.getInjection();
+			const existing = this.agent.context.history.filter(isMistakeMdReminder);
+			if (!injection) {
+				if (existing.length > 0) this.agent.context.removeSystemRemindersMatching(isMistakeMdReminder);
+				return;
+			}
+			const expected = wrapSystemReminder(injection);
+			if (existing.length === 1 && reminderText(existing[0]) === expected) return;
+			this.agent.context.removeSystemRemindersMatching(isMistakeMdReminder);
+			this.injectedAt = this.agent.context.history.length;
+			this.lastInjection = injection;
+			this.agent.context.appendSystemReminder(injection, {
+				kind: "injection",
+				variant: this.injectionVariant
+			});
 		}
 		async getInjection() {
 			try {
@@ -231477,16 +231492,16 @@ var init_mistake_md = __esmMin((() => {
 					}
 					const trimmed = content.trim();
 					if (trimmed.length === 0) return void 0;
-					const hash = createHash("sha256").update(trimmed).digest("hex");
-					if (hash === this.lastHash) return void 0;
-					this.lastHash = hash;
+					const query = recentUserText(this.agent.context.history);
+					const selected = selectRelevantMistakeContent(trimmed, query);
+					if (!selected.text) return void 0;
 					let prefix = "";
 					if (!this.reserveChecked) {
 						this.reserveChecked = true;
 						const reserveWarning = await checkReserve(this.mistakeDir);
 						if (reserveWarning) prefix = `<!-- D2a: ${reserveWarning} -->\n\n`;
 					}
-					return prefix + trimmed;
+					return prefix + selected.text;
 				});
 			} catch {
 				return;

package/package.json

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

package/telegram-plugin/dist/bridge.mjs

@@ -5,6 +5,9 @@ import { randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
+import { hostname } from "node:os";
+import remoteStatusPolicy from "../../bin/telegram-remote-status-policy.cjs";
+const { buildTelegramRemoteStatus } = remoteStatusPolicy;
 //#region ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -4451,7 +4454,7 @@ async function pollWithBackoff(bot, isShuttingDown, onStarted) {
 				},
 				{
 					command: "status",
-					description: "Check your pairing status"
+					description: "Check machine and delivery status"
 				}
 			], { scope: { type: "all_private_chats" } }).catch(() => {});
 		} });
@@ -4672,8 +4675,32 @@ bot.command("status", async (ctx) => {
 	if (gated === null) return;
 	const { access, senderId } = gated;
 	if (access.allowFrom.includes(senderId)) {
-		const name = ctx.from?.username !== void 0 ? `@${ctx.from.username}` : senderId;
-		await ctx.reply(`Paired as ${name}.`);
+		let version = "unbekannt";
+		let tuiPid;
+		let queueBytes = 0;
+		try {
+			version = JSON.parse(readFileSync(join(dirname(KING_ENTRY), "package.json"), "utf8")).version ?? version;
+		} catch {}
+		try {
+			tuiPid = parseInt(readFileSync(tuiPidFile(), "utf8"), 10);
+		} catch {}
+		try {
+			queueBytes = statSync(tuiInboundQueueFile()).size;
+		} catch {}
+		await ctx.reply(buildTelegramRemoteStatus({
+			access,
+			bridgePid: process.pid,
+			bridgeUptimeSeconds: process.uptime(),
+			capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			deliveryTarget: deliveryTarget(),
+			machineName: hostname(),
+			queueBytes,
+			senderId,
+			tuiFresh: isTuiLeaseFresh(),
+			tuiPid: Number.isInteger(tuiPid) ? tuiPid : void 0,
+			username: ctx.from?.username,
+			version
+		}));
 		return;
 	}
 	for (const [code, pending] of Object.entries(access.pending)) if (pending.senderId === senderId) {