blun-king-cli 9.1.125 → 9.1.127

package/LIESMICH.txt

@@ -113,6 +113,8 @@ Version 9.1.106 erlaubt Agentenprofilen, Werkzeuge namentlich auszuschließen. K
 
 Version 9.1.109 hält nur noch die neun Werkzeuge dauerhaft in der Modellanfrage, auf die mehr als 98 Prozent von Fredriks 3.183 gemessenen Werkzeugaufrufen entfielen. Alle übrigen Werkzeuge bleiben über `ToolSearch` auffindbar und nach dem ersten Laden für den Rest der Sitzung verfügbar. Dadurch sinkt die Schemalast bei jedem normalen Modellschritt, ohne ein Werkzeug zu entfernen oder den Schnellweg für Telegram-Antworten und ausstehende Medienergebnisse zu verändern.
 
+Version 9.1.127 verkürzt zusätzlich den wiederholten `ToolSearch`-Katalog. Eindeutige zurückgestellte Werkzeuge erscheinen dort nur noch mit ihrem kurzen Selektor; nur bei gleichnamigen Werkzeugen bleibt der vollständige Name stehen. Suche, exakte Auswahl, Telegram-Anhänge und bereits geladene Werkzeuge funktionieren unverändert. Dadurch kennt King weiterhin alle verfügbaren Werkzeuge, sendet aber die langen MCP-Namensräume nicht mehr bei jedem Modellschritt erneut.
+
 Ab BLUN King 9.1.118 bleibt der Sitzungszeitstempel im Systemprompt während einer laufenden Sitzung unverändert. Das erneute Einlesen von Verzeichnisübersicht, AGENTS.md-Dateien, Zusatzverzeichnissen und Skillinformationen kann den Prompt weiterhin ändern, wenn sich die jeweiligen Quellen tatsächlich verändert haben. Bleiben diese Quellen gleich, entwertet die Aktualisierung nach einer Verdichtung den Präfix-Cache des Anbieters nicht mehr allein durch einen neuen Zeitstempel. In Fredriks gemessener Sitzung unterschieden sich die beiden letzten Systemprompts mit jeweils 68.631 Zeichen nur in der Zeitangabe, und zwar erst nach einem gemeinsamen Präfix von 27.111 Zeichen. Der geänderte Zeitstempel verhinderte damit die Wiederverwendung der übrigen 41.512 unveränderten Zeichen aus dem Präfix-Cache.
 
 Ab BLUN King 9.1.119 enthält der bei jedem Modellschritt erneut gesendete Prompt nur noch eine kleine Auswahl häufig benötigter Skills. Alle übrigen registrierten Skills bleiben verfügbar und lassen sich über das Skill-Werkzeug anhand ihres Namens oder Zwecks suchen; der ausgewählte Skill wird anschließend bei Bedarf geladen. Dadurch sinkt die wiederholt übertragene Promptlast, ohne Skills zu löschen oder die vollständige Ansicht unter `/skills` einzuschränken.
@@ -125,6 +127,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

@@ -119,6 +119,8 @@ Version 9.1.106 erlaubt Agentenprofilen, Werkzeuge namentlich auszuschließen. K
 
 Version 9.1.109 hält nur noch die neun Werkzeuge dauerhaft in der Modellanfrage, auf die mehr als 98 Prozent von Fredriks 3.183 gemessenen Werkzeugaufrufen entfielen. Alle übrigen Werkzeuge bleiben über `ToolSearch` auffindbar und nach dem ersten Laden für den Rest der Sitzung verfügbar. Dadurch sinkt die Schemalast bei jedem normalen Modellschritt, ohne ein Werkzeug zu entfernen oder den Schnellweg für Telegram-Antworten und ausstehende Medienergebnisse zu verändern.
 
+Version 9.1.127 verkürzt zusätzlich den wiederholten `ToolSearch`-Katalog. Eindeutige zurückgestellte Werkzeuge erscheinen dort nur noch mit ihrem kurzen Selektor; nur bei gleichnamigen Werkzeugen bleibt der vollständige Name stehen. Suche, exakte Auswahl, Telegram-Anhänge und bereits geladene Werkzeuge funktionieren unverändert. Dadurch kennt King weiterhin alle verfügbaren Werkzeuge, sendet aber die langen MCP-Namensräume nicht mehr bei jedem Modellschritt erneut.
+
 Ab BLUN King 9.1.118 bleibt der Sitzungszeitstempel im Systemprompt während einer laufenden Sitzung unverändert. Das erneute Einlesen von Verzeichnisübersicht, AGENTS.md-Dateien, Zusatzverzeichnissen und Skillinformationen kann den Prompt weiterhin ändern, wenn sich die jeweiligen Quellen tatsächlich verändert haben. Bleiben diese Quellen gleich, entwertet die Aktualisierung nach einer Verdichtung den Präfix-Cache des Anbieters nicht mehr allein durch einen neuen Zeitstempel. In Fredriks gemessener Sitzung unterschieden sich die beiden letzten Systemprompts mit jeweils 68.631 Zeichen nur in der Zeitangabe, und zwar erst nach einem gemeinsamen Präfix von 27.111 Zeichen. Der geänderte Zeitstempel verhinderte damit die Wiederverwendung der übrigen 41.512 unveränderten Zeichen aus dem Präfix-Cache.
 
 Ab BLUN King 9.1.119 enthält der bei jedem Modellschritt erneut gesendete Prompt nur noch eine kleine Auswahl häufig benötigter Skills. Alle übrigen registrierten Skills bleiben verfügbar und lassen sich über das Skill-Werkzeug anhand ihres Namens oder Zwecks suchen; der ausgewählte Skill wird anschließend bei Bedarf geladen. Dadurch sinkt die wiederholt übertragene Promptlast, ohne Skills zu löschen oder die vollständige Ansicht unter `/skills` einzuschränken.
@@ -131,6 +133,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/bin/turn-tool-performance-policy.cjs

@@ -27,6 +27,15 @@ function deferredToolNames(tools) {
     .filter(Boolean))].sort((left, right) => left.localeCompare(right));
 }
 
+function deferredToolCatalog(tools) {
+  const names = deferredToolNames(tools);
+  const leaves = names.map((name) => name.split(/__|:/).at(-1) || name);
+  const leafCounts = new Map();
+  for (const leaf of leaves) leafCounts.set(leaf, (leafCounts.get(leaf) || 0) + 1);
+  return names.map((name, index) => leafCounts.get(leaves[index]) === 1 ? leaves[index] : name)
+    .sort((left, right) => left.localeCompare(right));
+}
+
 function searchDeferredTools(tools, query) {
   const normalized = String(query || '').trim().toLowerCase();
   if (!normalized) return [];
@@ -64,7 +73,7 @@ function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames
     const name = String(tool?.name || '').trim();
     if (name && !available.has(name)) available.set(name, tool);
   }
-  const names = deferredToolNames([...available.values()]);
+  const catalog = deferredToolCatalog([...available.values()]);
 
   return {
     name: DEFERRED_TOOL_LOADER_NAME,
@@ -72,7 +81,7 @@ function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames
       'Find and load deferred tool schemas into this running session.',
       'Use select:leaf_name for one known tool, plain keywords to search, or +word to require that word in the tool name.',
       'Loaded tools are available in the next step and remain loaded for this session.',
-      `Available deferred tool names: ${names.join(', ')}`,
+      `Available deferred selectors: ${catalog.join(', ')}`,
     ].join('\n'),
     parameters: {
       type: 'object',
@@ -139,6 +148,7 @@ module.exports = {
   TOOL_SCHEMA_BUDGET_RATIO,
   TOOL_SCHEMA_MAX_TOKENS,
   createDeferredToolLoader,
+  deferredToolCatalog,
   deferredToolNames,
   toolSchemaBudgetTokens,
 };

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