blun-king-cli 9.1.125 → 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

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.

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/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.125",
+  "version": "9.1.126",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {