blun-king-cli 9.1.516 → 9.1.518

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 9.1.518 - 2026-08-31
+
+- Keeps `Read`, `Write`, `Edit`, and `Bash` available alongside `TodoList` during proactive task-list maintenance, preserving the normal recovery path for large file changes.
+- Retains automatic Todo maintenance and its bounded evidence prompt without switching the active model step to a TodoList-only tool catalogue.
+- Adds a red-to-green regression gate against the 9.1.499 catalogue change and verifies recovery-tool selection without duplicate schemas.
+
+## 9.1.517 - 2026-08-31
+
+- Keeps `Ctrl+S` and `Escape` queue controls available while an approval panel is open: `Ctrl+S` flushes all waiting messages, while `Escape` releases one waiting message before rejecting the approval when the queue is empty.
+- Observes asynchronous session cancellation in the keyboard, Telegram `/reload`, and slash-command paths, treating `session.not_found` as an already-stopped session instead of crashing the core with an unhandled rejection.
+- Adds red-to-green package gates for the raw Windows control bytes and the measured stale-session cancellation failure.
+
 ## 9.1.516 - 2026-08-31
 
 - Caps the first tool-capable turn's wait for the initial MCP catalogue at 2.5 seconds, so a cold optional desktop server can finish in the background instead of blocking Read, Bash, Grep, TodoList, Telegram, and AgentSpine.

package/LIESMICH.txt

@@ -9,11 +9,11 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.516
+  npm install -g blun-king-cli@9.1.518
 
 AgentSpine 0.10.1
 -----------------
-Version 9.1.516 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
+Version 9.1.518 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
 
 Start
 -----

package/README.md

@@ -9,12 +9,12 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.516
+npm install -g blun-king-cli@9.1.518
 ```
 
 ## AgentSpine 0.10.1
 
-Version 9.1.516 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
+Version 9.1.518 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
 
 ## Reproduzierbares Staging und Packen
 

package/blun.mjs

@@ -262877,11 +262877,12 @@ var init_turn = __esmMin((() => {
 											mode: todoMaintenanceMode,
 											workCallsSinceRefresh: this.agent.goalTodoPolicyState?.workCallsSinceRefresh ?? 0
 									});
+									const todoMaintenanceTools = goalTodoMaintenanceTools(eligibleTools, selectedTools);
 									const todoSystemPrompt = buildGoalTodoMaintenanceSystemPrompt(this.agent, todoMaintenanceMode);
 									const todoMessages = buildGoalTodoMaintenanceMessages(this.agent, todoMaintenanceMode);
 									return {
 										llm: this.agent.llmForTurn("low", todoSystemPrompt),
-										tools: [todoTool],
+										tools: todoMaintenanceTools,
 										buildMessages: () => todoMessages,
 										buildMessagesStrict: () => todoMessages
 									};
@@ -423347,6 +423348,13 @@ const IDEA_CONTRACT_MARKER = "Work as a self-directing employee:";
 const IDEA_ALLOWED_CHANNELS = Object.freeze([]);
 const GOAL_TODO_REFRESH_WORK_CALL_LIMIT = 8;
 const GOAL_TODO_EVIDENCE_LIMIT = 8;
+const TODO_MAINTENANCE_RECOVERY_TOOL_NAMES = new Set([
+	"TodoList",
+	"Read",
+	"Write",
+	"Edit",
+	"Bash"
+]);
 const IDEA_TERMINAL_TODO_STATUSES = Object.freeze([
 	"done",
 	"blocked",
@@ -423425,6 +423433,14 @@ function goalTodoMaintenanceMode(agent) {
 	progress.refreshRequired = true;
 	return "refresh";
 }
+function goalTodoMaintenanceTools(eligibleTools, selectedTools) {
+	const seen = new Set();
+	return [...selectedTools, ...eligibleTools.filter((tool) => TODO_MAINTENANCE_RECOVERY_TOOL_NAMES.has(tool.name))].filter((tool) => {
+		if (seen.has(tool.name)) return false;
+		seen.add(tool.name);
+		return true;
+	});
+}
 function buildGoalTodoMaintenanceSystemPrompt(agent, mode) {
 	const todos = ideaTodos(agent);
 	const visibleTodoList = todos.length === 0 ? "The visible TodoList is empty." : ["Current visible TodoList:", ...todos.map((todo) => `- [${String(todo?.status ?? "pending")}] ${String(todo?.title ?? "").trim()}`)].join("\n");
@@ -499199,12 +499215,16 @@ var ApprovalPanelComponent = class extends Container {
 	request;
 	onToggleToolOutput;
 	onOpenPreview;
-	constructor(request, onResponse, onToggleToolOutput, onOpenPreview) {
+	onCtrlS;
+	onEscape;
+	constructor(request, onResponse, onToggleToolOutput, onOpenPreview, onCtrlS, onEscape) {
 		super();
 		this.request = request;
 		this.onResponse = onResponse;
 		this.onToggleToolOutput = onToggleToolOutput;
 		this.onOpenPreview = onOpenPreview;
+		this.onCtrlS = onCtrlS;
+		this.onEscape = onEscape;
 		this.feedbackInput.onSubmit = (value) => {
 			this.submit(this.selectedIndex, value);
 		};
@@ -499231,7 +499251,16 @@ var ApprovalPanelComponent = class extends Container {
 		} else this.submit(index);
 	}
 	handleInput(data) {
-		if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrl("d"))) {
+		if (matchesKey(data, Key.escape)) {
+			if (this.onEscape?.() === true) return;
+			this.onResponse({ response: "rejected" });
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("s"))) {
+			this.onCtrlS?.();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrl("d"))) {
 			this.onResponse({ response: "rejected" });
 			return;
 		}
@@ -505987,7 +506016,10 @@ var EditorKeyboardController = class {
 	}
 	cancelCurrentStream() {
 		this.host.cancelRunningShellCommand();
-		this.host.session?.cancel();
+		this.host.session?.cancel().catch((error) => {
+			if (error instanceof BlunError && error.code === ErrorCodes.SESSION_NOT_FOUND) return;
+			this.host.showError(formatErrorMessage$2(error));
+		});
 	}
 	cancelCurrentCompaction() {
 		const session = this.host.session;
@@ -518883,7 +518915,10 @@ var BlunTUI = class {
 		const activeTurn = this.streamingUI?.hasActiveTurn?.() === true || typeof phase === "string" && phase !== "idle" || this.state.appState.isCompacting === true;
 		if (command.name === "reload" && activeTurn && !this.queueCommandRunning) {
 			this.state.queuedMessages.unshift(item);
-			this.session?.cancel();
+			this.session?.cancel().catch((error) => {
+				if (error instanceof BlunError && error.code === ErrorCodes.SESSION_NOT_FOUND) return;
+				this.showError(formatErrorMessage$2(error));
+			});
 			this.traceTelegramDelivery?.({ stage: "queued", ...deliveryTrace, route: "channel_command", priority: "preemptive", queueDepth: this.state.queuedMessages.length });
 			this.track("input_queue", { kind: "channel-command-preemptive" });
 			this.updateQueueDisplay();
@@ -519396,7 +519431,10 @@ var BlunTUI = class {
 		if (activeTurn) {
 			this.state.queuedMessages.unshift(item);
 			this.preserveQueueAcrossSessionReset = true;
-			this.session?.cancel();
+			this.session?.cancel().catch((error) => {
+				if (error instanceof BlunError && error.code === ErrorCodes.SESSION_NOT_FOUND) return;
+				this.showError(formatErrorMessage$2(error));
+			});
 			this.track("input_queue", { kind: "command-preemptive" });
 			this.updateQueueDisplay();
 			this.state.ui.requestRender();
@@ -520896,6 +520934,12 @@ var BlunTUI = class {
 			this.toggleToolOutputExpansion();
 		}, (block) => {
 			this.openApprovalPreview(panel, block);
+		}, () => {
+			this.flushQueuedMessages(this.state.editor.getText().trim(), this.state.editor.inputMode);
+			this.updateQueueDisplay();
+			this.state.ui.requestRender();
+		}, () => {
+			return this.releaseNextQueuedMessage();
 		});
 		this.activeApprovalPanel = panel;
 		this.mountEditorReplacement(panel);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.516",
+  "version": "9.1.518",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "test": "node --test test/*.test.js",
-    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
+    "prepack": "node scripts/check-release-metadata.js && node scripts/check-todo-loop-regression.js && node scripts/check-todo-recovery-catalog-regression.js && node scripts/check-queue-controls-regression.js && node scripts/check-approval-queue-shortcuts-regression.js && node scripts/check-telegram-bridge-watchdog.js && node scripts/check-resume-replay-regression.js && node scripts/check-session-cancel-regression.js && node scripts/check-plugin-startup-regression.js && node scripts/check-active-profile-plugin-startup.js && node scripts/check-mcp-startup-wait-budget.js",
     "release:verify": "node scripts/check-release-metadata.js --external",
     "postinstall": "node scripts/fix-node-pty-perms.js"
   },
@@ -37,12 +37,15 @@
     "release-planned-removals.json",
     "scripts/check-package-regression.js",
     "scripts/check-active-profile-plugin-startup.js",
+    "scripts/check-approval-queue-shortcuts-regression.js",
     "scripts/check-mcp-startup-wait-budget.js",
     "scripts/check-plugin-startup-regression.js",
     "scripts/check-queue-controls-regression.js",
     "scripts/check-telegram-bridge-watchdog.js",
     "scripts/check-resume-replay-regression.js",
+    "scripts/check-session-cancel-regression.js",
     "scripts/check-release-metadata.js",
+    "scripts/check-todo-recovery-catalog-regression.js",
     "scripts/check-todo-loop-regression.js",
     "scripts/fix-node-pty-perms.js",
     "standard-skills/",

package/scripts/check-approval-queue-shortcuts-regression.js

@@ -0,0 +1,65 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  || path.join(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+
+function between(start, end, from = 0) {
+  const startIndex = bundle.indexOf(start, from);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+const panelStart = bundle.indexOf('var ApprovalPanelComponent = class extends Container {');
+assert.notEqual(panelStart, -1, 'ApprovalPanelComponent must exist');
+const handleSource = between('\n\thandleInput(data) {', '\n\trender(width) {', panelStart).trim();
+
+const Key = {
+  escape: 'escape',
+  ctrl(key) { return `ctrl+${key}`; },
+};
+const matchesKey = (data, expected) => {
+  if (expected === 'escape') return data === '\x1b';
+  if (expected === 'ctrl+s') return data === '\x13';
+  return data === expected;
+};
+const handleInput = Function(
+  'matchesKey',
+  'Key',
+  `"use strict"; return ({${handleSource}}).handleInput;`,
+)(matchesKey, Key);
+
+let responses = 0;
+let flushed = 0;
+let released = 0;
+const panel = {
+  choiceCount() { return 0; },
+  onResponse(response) {
+    responses += 1;
+    assert.equal(response.response, 'rejected');
+  },
+  onCtrlS() { flushed += 1; },
+  onEscape() { released += 1; return true; },
+};
+
+handleInput.call(panel, '\x13');
+assert.equal(flushed, 1, 'Ctrl+S must reach the global queue flush while approval is open');
+assert.equal(responses, 0);
+
+handleInput.call(panel, '\x1b');
+assert.equal(released, 1, 'Escape must first release one queued message while approval is open');
+assert.equal(responses, 0, 'a released queued message must not reject the approval');
+
+panel.onEscape = () => false;
+handleInput.call(panel, '\x1b');
+assert.equal(responses, 1, 'Escape must reject the approval when no queued message waits');
+
+const showApprovalPanel = between('\n\tshowApprovalPanel(payload) {', '\n\thideApprovalPanel() {');
+assert.match(showApprovalPanel, /this\.flushQueuedMessages\(this\.state\.editor\.getText\(\)\.trim\(\), this\.state\.editor\.inputMode\)/);
+assert.match(showApprovalPanel, /return this\.releaseNextQueuedMessage\(\)/);
+
+console.log('approval queue shortcuts regression: PASS');

package/scripts/check-session-cancel-regression.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.join(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+
+function between(start, end) {
+  const startIndex = bundle.indexOf(start);
+  assert.notEqual(startIndex, -1, `missing bundle marker: ${start}`);
+  const endIndex = bundle.indexOf(end, startIndex + start.length);
+  assert.notEqual(endIndex, -1, `missing bundle marker: ${end}`);
+  return bundle.slice(startIndex, endIndex);
+}
+
+function assertSafeCancel(source, label) {
+  assert.match(source, /\.cancel\(\)\.catch\(\(error\)\s*=>/,
+    `${label} must observe the cancellation promise`);
+  assert.match(source, /error instanceof BlunError && error\.code === ErrorCodes\.SESSION_NOT_FOUND/,
+    `${label} must treat an already-missing session as cancelled`);
+  assert.match(source, /showError\(formatErrorMessage\$2\(error\)\)/,
+    `${label} must still surface non-session errors`);
+}
+
+assertSafeCancel(
+  between('\n\tcancelCurrentStream() {', '\n\tcancelCurrentCompaction() {'),
+  'keyboard stream cancellation',
+);
+assertSafeCancel(
+  between('\n\tinjectTelegramRemoteCommand(', '\n\trunTelegramRemoteCommand('),
+  'preemptive Telegram reload cancellation',
+);
+assertSafeCancel(
+  between('\n\tenqueueSlashCommand(', '\n\tenqueueNormalUserInput('),
+  'preemptive slash-command cancellation',
+);
+
+process.stdout.write('session-cancel-regression PASS\n');

package/scripts/check-todo-recovery-catalog-regression.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const bundlePath = process.env.BLUN_BUNDLE_UNDER_TEST
+  ? path.resolve(process.env.BLUN_BUNDLE_UNDER_TEST)
+  : path.resolve(__dirname, '..', 'blun.mjs');
+const bundle = fs.readFileSync(bundlePath, 'utf8');
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+const namesMatch = bundle.match(
+  /const TODO_MAINTENANCE_RECOVERY_TOOL_NAMES = new Set\(\[([\s\S]*?)\]\);/,
+);
+const functionMatch = bundle.match(
+  /function goalTodoMaintenanceTools\(eligibleTools, selectedTools\) \{[\s\S]*?\n\}/,
+);
+
+assert(
+  !/proactive TodoList maintenance step[\s\S]{0,900}tools:\s*\[todoTool\]/.test(bundle),
+  'TODO_RECOVERY_CATALOG_REGRESSION: proactive maintenance still switches to TodoList-only',
+);
+assert(namesMatch, 'TODO_RECOVERY_CATALOG_REGRESSION: recovery tool names are missing');
+assert(functionMatch, 'TODO_RECOVERY_CATALOG_REGRESSION: recovery catalogue selector is missing');
+assert(
+  /proactive TodoList maintenance step[\s\S]{0,1100}tools:\s*todoMaintenanceTools/.test(bundle),
+  'TODO_RECOVERY_CATALOG_REGRESSION: proactive maintenance is not wired to the recovery catalogue',
+);
+
+const selectMaintenanceTools = Function(
+  `const TODO_MAINTENANCE_RECOVERY_TOOL_NAMES = new Set([${namesMatch[1]}]); return (${functionMatch[0]});`,
+)();
+const tools = ['TodoList', 'Read', 'Write', 'Edit', 'Bash', 'WebSearch'].map((name) => ({ name }));
+const selected = [tools[5], tools[1]];
+const actual = selectMaintenanceTools(tools, selected).map((tool) => tool.name);
+
+assert(
+  actual.join(',') === 'WebSearch,Read,TodoList,Write,Edit,Bash',
+  `TODO_RECOVERY_CATALOG_REGRESSION: unexpected catalogue ${actual.join(',')}`,
+);
+assert(
+  new Set(actual).size === actual.length,
+  'TODO_RECOVERY_CATALOG_REGRESSION: recovery catalogue contains duplicates',
+);
+
+process.stdout.write('todo-recovery-catalog-regression PASS\n');

package/README.md.vor-91515-20260831-064010

@@ -1,821 +0,0 @@
-# blun-king-cli — npm-Distribution
-
-Dieses Verzeichnis ist das Gerüst des öffentlichen npm-Pakets `blun-king-cli`
-(Erstveröffentlichung 8.0.0, 06.07.2026, Account `blunking`).
-
-## Installation
-
-Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
-installiert:
-
-```powershell
-npm install -g blun-king-cli@9.1.514
-```
-
-## AgentSpine 0.10.1
-
-Version 9.1.514 enthält weiterhin AgentSpine 0.10.1 als inhaltsadressierte Pluginfassung. Der Preflight prüft jede aktive Host-Anweisungsdatei weiterhin race-sicher und bindet SHA-256 sowie Dateiidentität an den Zug, dupliziert den bereits vom Host geladenen Volltext aber nicht im Laufzeitkontext. Die reale Probe mit einer 15.519 Byte großen `CLAUDE.md` blieb dadurch bei 5.667 injizierten Byte. Der Stand enthält außerdem den selbstheilenden Persona- und Beziehungsgraphen, die begrenzte Telegram-Mnemo-Abfrage und eine sichtbare Fünf-Sekunden-Grenze für lokale Beziehungsabfragen.
-
-## Reproduzierbares Staging und Packen
-
-Der Schritt baut nichts, installiert nichts und veröffentlicht nichts. Vorher müssen
-`apps/blun-king/dist/main.mjs`, `dist-web`, die Darwin- und Windows-Natives sowie
-`plugins/telegram/dist` bereits frisch gebaut sein.
-
-Das Staging landet standardmäßig
-unter `.stage/package`, das Tarball unter `.stage/artifacts`.
-`BLUN_NPM_STAGE_DIR` und `BLUN_NPM_ARTIFACT_DIR` können beide Ziele überschreiben;
-beim direkten Skriptaufruf stehen zusätzlich `--output` und `--artifacts` bereit.
-
-Der Schritt validiert alle Pflichtartefakte vor dem Leeren des alten Stagings. Er
-kopiert nur die Paket-Hülle, `blun.mjs`, `dist-web`, `native`, Telegrams
-`dist`/Manifest/Commands und die Repo-Skills.
-
-## Startmodi
-
-`blun` startet die lokale Konsole, ohne Telegram automatisch anzubinden. `king`
-startet dieselbe Konsole und bindet den eingerichteten Telegram-Kanal automatisch
-an. Version, Konto, Modell und Befehle sind ansonsten identisch. Der Unterschied
-gilt nur für den laufenden Prozess; die gespeicherte
-Plugin-Konfiguration wird nicht umgeschrieben.
-
-`king` und `king -c` prüfen beim interaktiven Start, ob eine neuere Version
-vorliegt. Automatische Updates sind standardmäßig aktiv und installieren den
-geprüften Zielstand ohne zusätzliche Bestätigung. Danach endet `king`; `king -c`
-setzt die letzte Sitzung mit der neuen Version fort. Mit
-`[upgrade].auto_install = false` in `tui.toml` erscheint stattdessen der sichtbare
-Auswahldialog. Start- und Update-Meldungen sind bei einer neuen Installation
-standardmäßig Englisch; eine ausdrücklich gewählte Sprache bleibt erhalten.
-
-Telegram-Chats werden ohne manuell eingegebene IDs verbunden. In der Konsole
-erzeugt `/telegram:access connect` einen einmaligen Code. `/connect CODE` im
-gewünschten privaten Chat oder in einer Gruppe speichert Chat und Absender
-intern; der Code verfällt nach zehn Minuten und ist nur einmal verwendbar.
-
-## Standard-MCPs und Eingabesteuerung
-
-Beim Start richtet BLUN King `agent-browser`, `blun-language-guard` und unter
-Windows `windows-mcp` automatisch ein und aktiviert erkannte
-Standardkonfigurationen. Context7 wird eingerichtet, bleibt aber standardmäßig
-deaktiviert, weil sein Start hängen bleiben kann. Mit
-`blun tools enable context7` lässt es sich ausdrücklich aktivieren. Eigene,
-abweichende MCP-Befehle bleiben unverändert. `/mcp` zeigt den Betriebszustand
-ohne internen Konfigurationspfad; in der Detailansicht bleibt der Pfad für die
-Fehlersuche verfügbar.
-
-Beispiele:
-
-```text
-/mcp
-blun tools list
-blun tools enable context7
-```
-
-Telegram-Nachrichten werden in Eingangsreihenfolge verarbeitet. Trifft eine
-Nachricht im Leerlauf oder während eines aktiven Laufs ein, merkt die
-Warteschlange sie selbstständig für den nächsten sicheren Übergabepunkt vor.
-Eine User-Nachricht wartet nicht auf einen Tastendruck. Private Nachrichten
-bleiben vor Gruppenverkehr priorisiert. Strg+S gibt einen vorhandenen Rückstand
-sofort vollständig und genau einmal frei. Jeder Druck auf Esc gibt genau eine
-weitere wartende Nachricht frei; erst bei leerer Warteschlange bricht Esc den
-aktuellen Lauf ab. Die Warteschlange wird dabei nicht gelöscht. Strg+C bricht
-den aktiven Zug direkt ab, ohne den geschriebenen Entwurf zu löschen.
-Telegram-Nachrichten, die bei bereits aktivem Kernzug eintreffen, werden ohne
-konkurrierenden Start zurückgewiesen und bleiben an der Spitze der
-FIFO-Warteschlange. Für diesen normalen Wartestatus erscheint kein
-`turn.agent_busy`-Fehler.
-
-Version 9.1.508 hält TodoList-Marker auch in Terminals mit reduziertem
-Farbumfang sichtbar und verlangt schon bei der ersten mehrstufigen Liste genau
-einen aktiven Punkt. Freigegebene Telegram-Nachrichten aus Gruppe und DM werden
-asynchron, dedupliziert und wiederholbar in Mnemos begrenzten Transcript-Speicher
-übernommen; Loop-Ticks und `/loop`-Steuerbefehle bleiben ausgeschlossen.
-AgentSpine verbindet die Abfrage nur bei Bedarf mit dem engsten Chat-, Themen-
-und Zeitbezug, statt den gesamten Telegram-Verlauf in den Prompt zu laden.
-
-Version 9.1.507 fordert das Modell im Read-Werkzeug ausdrücklich dazu auf,
-voneinander unabhängige Datei- und Bereichslesungen in einer Modellantwort zu
-bündeln. Dadurch entfallen vermeidbare Modellrunden, ohne Ausführung,
-Seitennavigation, Berechtigungen oder Ergebnisbehandlung des Werkzeugs zu ändern.
-
-Version 9.1.506 entfernt erledigte TodoList-Punkte sofort aus der sichtbaren
-TUI und verwendet fuer den automatischen Wartungszug einen eigenstaendigen,
-546 Zeichen langen Systemprompt statt des rund 19.000 Zeichen langen
-Arbeits-Systemprompts. Der nachfolgende Arbeitsschritt behaelt weiterhin den
-vollstaendigen Prompt und Werkzeugkatalog.
-
-Version 9.1.504 startet eine automatisch eingereihte Telegram-Nachricht im
-Leerlauf als neuen Modellzug. Sie wartet damit nicht mehr auf einen bereits
-laufenden Zug, der im Leerlauf definitionsgemäß nie entstehen kann.
-
-Version 9.1.503 ergänzt die isolierte Wartungsnachricht um das vom Anbieterpfad
-erwartete leere `toolCalls`-Feld. Dadurch erreicht der Wartungsschritt das Modell,
-statt in der Nachrichten-Normalisierung mit einem TypeError abzubrechen.
-
-Version 9.1.502 führt die automatische Todo-Pflege in einem isolierten
-TodoList-Schritt ohne alte Datei-, Shell- oder MCP-Aufrufe aus. Erledigte Punkte
-werden unmittelbar aus der sichtbaren und gespeicherten Liste entfernt; offene,
-blockierte und wartende Arbeit bleibt erhalten. Dadurch wächst die Liste nicht
-endlos und die Pflege erzeugt keinen roten `Tool not found`-Umweg.
-
-Version 9.1.501 stellt nach der automatischen Todo-Pflege den normalen
-Werkzeugkatalog wieder her. Dadurch bleiben Read, Bash und die weiteren fuer den
-Arbeitszug ausgewaehlten Werkzeuge nach dem TodoList-Schritt verfuegbar.
-
-Version 9.1.500 ist die Golden Release fuer Windows, Linux und macOS. Sie traegt
-den vollstaendigen Funktionsstand von 9.1.499 unveraendert und wird im
-oeffentlichen Changelog mit einer eigenen goldenen Ueberschrift gekennzeichnet.
-
-Version 9.1.499 ersetzt Bild-, Audio- und Videodaten außerhalb der neuesten zwölf
-Gesprächsnachrichten ausschließlich in der wiederholten Modellprojektion durch
-kurze Verweise. Aktuelle Medien, Nachrichtentext und vollständiger Sitzungsrohverlauf
-bleiben unverändert. In Fredriks gemessenem Wiederaufnahme-Checkpoint spart der
-Schnitt 85.748 Zeichen beziehungsweise rund 21.437 geschätzte Eingabetoken je
-weiterem Werkzeugschritt.
-
-Faellige Todo-Pflege laeuft in 9.1.499 vor dem naechsten Sachwerkzeug als eigener
-kleiner Modellschritt. In diesem Schritt bietet die Laufzeit ausschliesslich
-`TodoList` an; erst nach einer gueltigen Aktualisierung werden Datei-, Such- und
-Shell-Werkzeuge wieder freigegeben. Dadurch entsteht im normalen Ablauf kein
-roter Zwischenfehler. Frische Benutzernachrichten behalten Vorrang.
-
-Version 9.1.498 zeigt in `/usage` die gemessene Prompt-Cache-Trefferquote sowie
-gelesene und geschriebene Cache-Token je Modell. `/tokens` ist ein kurzer Alias
-fuer die bereits vorhandene detaillierte Kontextdiagnose; `/offload` ruft die
-vorhandene archivierende Kontextverdichtung auf. Unterschiedliche autorisierte
-Botnachrichten werden nicht mehr durch ein starres 15-Sekunden-Fenster verworfen.
-Nach einer vollständigen Verdichtung bleibt die exakte Todo-Liste erhalten. Ein
-einmaliger Wiederherstellungshinweis verlangt bei unsicheren Pfaden, Befehlen,
-Hashes oder Anforderungen zuerst das Lesen des archivierten Verlaufs, bevor eine
-breite Dateisuche oder ein Neubeginn zulässig ist.
-Erledigte Todo-Schritte bleiben als Nachweis erhalten. Neue widersprüchliche
-Erkenntnisse werden als eigener laufender Schritt mit Begründung ergänzt, statt
-einen bereits belegten Abschluss still zurückzustufen oder zu entfernen.
-Wiederkehrende Session-Loops warten außerdem, solange die gepflegte Todo-Liste
-noch laufende oder ausstehende Arbeit enthält. Verpasste Intervalle werden bis
-zum echten Leerlauf zusammengefasst; andere geplante Erinnerungen bleiben davon
-unberührt.
-
-Version 9.1.497 priorisiert Telegram-Botnachrichten aus gemeinsamen Gruppen
-hinter privaten und ausdrücklich adressierten Nachrichten, aber vor normalem
-Kontext. Die Priorisierung erzwingt keine Antwort. Eine angenommene
-Telegram-Nachricht verschwindet jetzt aus der sichtbaren Queue, sobald ihr
-eingespielter Modellschritt wirklich beginnt. Fällige Telegram-Antworten und
-Nachrichtenbearbeitungen dürfen außerdem die Todo-Pflege passieren; der nächste
-normale Arbeitsschritt bleibt bis zur wahrheitsgemäßen Aktualisierung blockiert.
-
-Version 9.1.496 stellt Telegram-Nutzernachrichten automatisch einzeln zu, ohne
-die automatische Zustellung an den manuellen Strg+S-/Escape-Zähler zu koppeln.
-Nach Annahme oder Antwort wird nur die exakt verarbeitete Nachrichten-ID aus der
-sichtbaren Queue entfernt; spätere Meldungen desselben Chats bleiben erhalten.
-Vorhandene Todo-Listen bleiben auch ohne aktives Ziel verbindlich und müssen nach
-längerer Arbeit belegbaren Fortschritt zeigen. Erfolgreiche interne Hook-Ausgaben
-bleiben unsichtbar, blockierende Hook-Fehler werden weiterhin angezeigt.
-
-Version 9.1.495 startet jedes neue Ziel mit einer frischen sichtbaren Todo-Liste,
-erzwingt regelmäßige wahrheitsgemäße Fortschrittsstände und quittiert normale
-Telegram-Nachrichten erst am Zugende. Dadurch bleiben sie nach einem Neustart
-wiederholbar, bis ihre Verarbeitung wirklich abgeschlossen ist. Erfolgreich
-beantwortete Gruppenmeldungen verschwinden sofort aus der sichtbaren Queue.
-Zusätzliche Regressionstests prüfen Strg+S und Strg+T als echte Terminalsequenzen,
-auch bei aktiver Feststelltaste.
-
-Version 9.1.494 trennt die Tastenkürzel wieder eindeutig: Strg+S steuert nur
-den Queue-Rückstand, Strg+T nur die Todo-Liste. Version 9.1.493 stellt die
-automatische Zustellung von User-Nachrichten auch
-für Telegram-Gruppen wieder her. Version 9.1.492 schützt Veröffentlichungen
-zusätzlich mit einer verpflichtenden
-Metadatenprüfung. Packen und Veröffentlichen brechen ab, wenn Paketversion,
-erster Changelog-Eintrag oder Installationshinweise auseinanderlaufen. Die
-abschließende externe Prüfung vergleicht npm, Paketintegrität, öffentliches
-Update-Manifest und öffentliche Changelog-Seite.
-
-Version 9.1.491 stellt außerdem die interne Todo-Liste wieder her. Deutsche
-Aufgabenlisten-Befehle wählen wieder TodoList statt der getrennten TaskList für
-Hintergrundprozesse. Lesen, Ersetzen, Aktualisieren und Leeren funktionieren in
-derselben Sitzung; eine vollständig erledigte Liste wird aus der Anzeige
-entfernt. AgentSpine wird beim Start in allen vorhandenen lokalen Profilen
-installiert und aktiviert. Bilder laufen vorrangig über den verwalteten
-BLUN-Bildlesedienst auf der RTX-Infrastruktur; ein lokaler experimenteller
-Leser ist nur noch ein Fallback, wenn kein verwalteter Mediadienst existiert.
-
-Ab BLUN King 9.1.416 bleiben alle Ergebnisse des jüngsten Werkzeugaufrufs bis
-zur nächsten Assistentenantwort vollständig im Modellkontext. Das gilt auch für
-große parallele Read-, Grep- und Bash-Aufrufe sowie für nachträglich
-eingespielte Telegram- oder Steuerungsnachrichten. Offloader, historische
-Bereinigung und Mikrokompaktierung verwenden dafür dieselbe semantische Grenze.
-Erst nach der nachweislichen Auswertung darf ein Ergebnis archiviert oder
-gekürzt werden.
-
-Ab BLUN King 9.1.417 schneiden automatische Telegram-Rückfallantworten Texte
-nicht mehr bei 4.096 Zeichen ab. Längere Antworten werden in
-aufeinanderfolgenden Nachrichten vollständig zugestellt; dabei bleiben jedes
-Zeichen und jedes Unicode-Surrogatpaar erhalten. Im Ausgangsprotokoll stehen
-sämtliche zurückgegebenen Nachrichten-IDs zusammen mit dem vollständigen Text.
-Schlägt ein Teil fehl, endet die Zustellung an dieser Stelle, statt die Antwort
-fälschlich als vollständig zu melden.
-
-Ab BLUN King 9.1.418 übernimmt der Identitätsgraph die von Telegram bestätigte
-Unterscheidung zwischen Menschen und Bots. Bereits vorhandene
-Telegram-Kontakte, die mangels dieses Merkmals als Menschen angelegt wurden,
-werden bei der nächsten eindeutig als Bot bestätigten Nachricht einmalig als
-Agent korrigiert. Alle Rollen, Zuständigkeiten, Beziehungsnotizen und sonstigen
-Felder bleiben unverändert. Ein Agent wird niemals zu einer Person
-zurückgestuft; Namen oder Benutzernamen dienen nicht als Beweis.
-
-`Strg+C` und `Esc` brechen einen aktiven Zug zuverlässig ab, ohne den bereits
-geschriebenen Entwurf zu löschen. Das gilt auch bei Autovervollständigung,
-Geistervorschlägen, Bash-Eingabe und einer noch offenen Mehrzeileneingabe.
-
-Ab BLUN King 9.1.419 setzt eine natürlich fortgesetzte Sitzung ein bereits
-aktives Ziel selbstständig fort, wenn dessen gespeicherter nächster Auslöser
-ausdrücklich sofort gilt und Auto- oder God-Modus aktiv ist. Die Fortsetzung
-erscheint nicht als erfundene Benutzernachricht und wird pro Sitzung nur einmal
-angestoßen. Wartende, pausierte und blockierte Ziele sowie manuelle
-Berechtigungsmodi starten weiterhin nicht selbstständig.
-
-Ab BLUN King 9.1.420 beendet ein aktives Ziel mit dauerhaftem
-Warte-Checkpoint die autonome Fortsetzung nach dem aktuellen Zug, ohne das Ziel
-zu verwerfen. Externe, zeitliche, abhängige und nutzerabhängige Auslöser
-erzeugen dadurch keine leeren Folgezüge. Beim nächsten Ereignis wird der
-gespeicherte Auslöser erneut eingeordnet. Sofortige Ziele und ältere Ziele ohne
-Checkpoint laufen unverändert weiter.
-
-Ab BLUN King 9.1.421 muss ein wartendes Ziel mit Zeit-Trigger einen genauen
-`dueAt`-Zeitpunkt speichern. Der Zeitpunkt wird auf UTC normalisiert. Bei einem
-natürlichen Sitzungsstart im Auto- oder God-Modus wartet das Ziel vor diesem
-Zeitpunkt weiter und startet, sobald der Zeitpunkt erreicht oder überschritten
-ist. Der erste Fortsetzungszug erhält die gespeicherte Fälligkeit als
-ausdrücklichen Trigger-Beleg. Andere Trigger-Arten dürfen kein `dueAt`
-enthalten. Ein Laufzeit-Wecker für eine durchgehend geöffnete Sitzung ist in
-diesem Release noch nicht enthalten.
-
-Ab BLUN King 9.1.422 überwacht auch eine durchgehend geöffnete, untätige Sitzung ihren gespeicherten Zeit-Trigger. Sobald `dueAt` erreicht oder überschritten ist, fügt der Auto- oder God-Modus genau eine verborgene Fortsetzung in dieselbe Sitzung ein. Wird der Zeitpunkt während einer laufenden Antwort, Verdichtung, wartenden Nachricht, eines Befehls oder Dialogs fällig, wartet die Fortsetzung bis zum Leerlauf. Unmittelbar vor dem Start liest King Ziel, Checkpoint-Revision, Fälligkeit, Berechtigungsmodus und Sitzung erneut; ein geänderter oder veralteter Trigger kann deshalb nicht auslösen. Stoppen, Notausgang, Entladen und Wechseln der Sitzung entsorgen den Timer. Im manuellen Modus erfolgt kein selbstständiger Start.
-
-## Zuverlässiger King-Start
-
-Bei einer vom Server ausdrücklich als wiederholbar gekennzeichneten
-Überlastung (`HTTP 429`, `x-should-retry: true`) wartet BLUN King entsprechend
-`Retry-After` und sendet dieselbe Anfrage höchstens zweimal erneut. Andere
-Fehler und dauerhaft überlastete Server bleiben klar begrenzt und sichtbar.
-
-Der Windows-Hilfsprozess für private Pfade übernimmt `TEMP` und `TMP` aus der
-Benutzersitzung. Dadurch kann der C#-Compiler für die ACL-Prüfung auch unter
-einem normalen Benutzerkonto arbeiten. Scheitert der Unterprozess, nennt die
-Fehlermeldung jetzt dessen tatsächliche Ursache.
-
-Ein bereits laufender Telegram-Prozess blockiert Aktualisierungen nicht mehr.
-Unveränderte Plugin-Dateien werden wiederverwendet; geänderte Dateien werden in
-einem inhaltsadressierten Verzeichnis daneben installiert. Der neue Prozess
-verwendet den neuen Pfad, während der bisherige Prozess seinen geladenen Stand
-geordnet beenden kann.
-
-Beim Fortsetzen mit `--continue` oder `--session` wird der Arbeitsbereich der
-bestehenden Sitzung direkt verwendet. Die Ordnerauswahl bleibt neuen Starts
-vorbehalten und kann eine Fortsetzung daher nicht mehr vorzeitig beenden.
-
-## Schnellstart
-
-Beim Starten oder Fortsetzen einer Sitzung werden die Skill-Verzeichnisse
-parallel geprüft und eingelesen. Die Skills werden weiterhin in der
-ursprünglichen, festen Reihenfolge registriert; Priorität und Verhalten bei
-doppelten Namen bleiben unverändert.
-
-## Kontextentlastung bei langen Sitzungen
-
-King bewahrt den vollständigen Verlauf weiterhin im Sitzungs-Wire auf. Bei 75 Prozent der wirksamen Verdichtungsgrenze ersetzt die Modellprojektion ältere große Werkzeugergebnisse sowie große Argumente abgeschlossener Werkzeugaufrufe durch kurze Platzhalter. Die Druckmessung verwendet die frühere Grenze aus Modellfenster und Vollverdichtungsbudget; bei einem Modellfenster von 1.048.576 Token und einer Vollverdichtung bei 256.000 Token liegt der Mikrodruckpunkt daher bei 192.000 Token. Werkzeugargumente werden nur entlastet, wenn ein zugehöriges Werkzeugergebnis vorliegt und die gespeicherten Argumente gültiges JSON sind. Die letzten 20 Nachrichten bleiben unverändert. Solange der Prefix-Cache warm ist, wird der Schnitt höchstens nach jeweils 20 weiteren Nachrichten verschoben. Nach einer Stunde ohne Modellantwort darf er sofort nachziehen.
-
-Dabei werden keine gespeicherten Nachrichten geändert oder gelöscht. Fortsetzen, Exportieren und die sichtbare Historie behalten die ursprünglichen Werkzeugergebnisse und Werkzeugargumente. Das Telemetrieereignis `micro_compaction_finished` nennt den Auslöser, den Schnitt, die verwendete Druckgrenze, das Modellfenster und die geschätzte Tokenzahl vor und nach der Entlastung. Außerdem zählt es getrennt, wie viele Werkzeugergebnisse und Werkzeugargumente entlastet wurden. Der Sitzungsinspektor summiert zusätzlich die eingesparten Argument-Token, ohne Inhalte offenzulegen. Beispiel: Ein früherer `Write`-Aufruf mit einem vollständigen Dateiinhalt bleibt im Wire erhalten; die Modellprojektion trägt nur noch einen Platzhalter, sobald für diesen `Write`-Aufruf ein zugehöriges Ergebnis vorliegt.
-
-Ab BLUN King 9.1.98 kann King einen abgeschlossenen Arbeitsabschnitt verdichten, bevor die harte automatische Grenze erreicht ist. Unterhalb der halben Vollverdichtungsgrenze bleibt `CompactConversation` vollständig aus dem Modellprompt. Ab 128.000 geschätzten Token im Standardmodellfenster wird es für den nächsten Modellschritt verfügbar. Die Verdichtung beginnt erst nach Abschluss des aktuellen Werkzeugschritts, öffnet keinen konkurrierenden Zug und lässt den ursprünglichen Verlauf bei einem Fehlschlag unverändert.
-
-## Große Werkzeugausgaben und isolierte Teilagenten
-
-Große textbasierte Werkzeugergebnisse bleiben nicht mehr vollständig im Modellkontext. Ab 12.001 Zeichen speichert BLUN King das vollständige Ergebnis in einer privaten Datei im Sitzungsordner `tool-results`. Im Modellkontext verbleiben die ersten 1.000 und die letzten 1.000 Zeichen, die genaue Zahl der ausgelassenen Zeichen und der `output_path`. Der Agent kann das vollständige Ergebnis anschließend mit `Read` seitenweise über diesen Pfad lesen. Ergebnisse bis einschließlich 12.000 Zeichen, gemischte Medienergebnisse und bereits gekürzte Ergebnisse bleiben unverändert. Auch eine spätere Mikroverdichtung bewahrt den Dateiverweis. Beispiel: Bei einem Suchergebnis mit 30.000 Zeichen sehen folgende Modellanfragen den Anfang und das abschließende Ergebnis oder den Fehler; der vollständige Text bleibt lokal verfügbar.
-
-Version 9.1.104 lässt Shell-Befehle im Vordergrund auch bei sehr großen Ausgaben bis zum regulären Ende laufen. King schreibt bis zu 16 MiB fortlaufend in das private Aufgabenprotokoll, verwirft darüber hinausgehende Ausgaben und meldet den tatsächlichen Exit-Code, statt den Prozess wegen der Ausgabemenge zu beenden. Kleine Ausgaben, Hintergrundaufgaben, Zeitgrenzen und manuelle Abbrüche bleiben unverändert.
-
-Version 9.1.105 ergänzt `TaskUpdate` für laufende Hintergrundagenten. King übergibt zusätzliche Anweisungen am nächsten sicheren Modellschritt an denselben aktiven Agenten, ohne ihn zu stoppen oder einen weiteren Agenten zu starten. Unbekannte und bereits beendete Aufgaben, Shell-Aufgaben sowie Agenten, die keine Aktualisierung mehr annehmen, werden unverändert abgewiesen.
-
-Version 9.1.106 erlaubt Agentenprofilen, Werkzeuge namentlich auszuschließen. King wendet diese Ausschlüsse erst an, nachdem dauerhaft geladene, dynamisch nachgeladene und MCP-Werkzeuge zusammengestellt wurden. Die Standardprofile `coder`, `explore` und `plan` können über Telegram weder antworten noch reagieren, Nachrichten bearbeiten oder Anhänge herunterladen; der Hauptagent bleibt unverändert. So senden delegierte Agenten keine Nachrichten am Hauptagenten vorbei, und ihre Modellanfragen enthalten weniger Werkzeugschemas. Nicht gefundene, namentlich angegebene Werkzeuge werden sichtbar gemeldet.
-
-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.
-
-Version 9.1.128 begrenzt außerdem den dauerhaften Cache nachgeladener Werkzeug-Schemas auf die zwölf zuletzt ausgewählten Werkzeuge. Ein erneut ausgewähltes Werkzeug rückt ans Ende und bleibt erhalten; nur die ältesten, lange nicht verwendeten Schemas fallen aus der nächsten Modellanfrage und sind weiterhin sofort über `ToolSearch` auffindbar. Werkzeuge des laufenden Schritts bleiben vollständig verfügbar. Dadurch kann die Schemalast auch in sehr langen Sitzungen nicht ungebremst anwachsen.
-
-Version 9.1.129 entfernt in langen Sitzungen außerdem die Vorschautexte aus älteren, bereits ausgelagerten Werkzeugergebnissen. Im aktuellen Arbeitsfenster bleiben die letzten 20 Nachrichten vollständig lesbar; ältere Verweise behalten Pfad und Größenangaben, während der vollständige Inhalt unverändert in der Originaldatei oder im privaten Archiv liegt. In Fredriks aktuellem Verlauf spart das pro Anfrage zusätzlich 8.258 Zeichen, also rund 2.065 Token.
-
-Ab BLUN King 9.1.130 verdichtet die Modellprojektion zusätzlich die erläuternden Texte älterer, abgeschlossener Werkzeugschritte. Werkzeugnamen, Kennungen, Argumente, Ergebnisse, nicht textbasierte Inhalte und die letzten 20 Nachrichten bleiben unverändert; ausstehende Werkzeugaufrufe werden niemals verdichtet. Auch der gespeicherte Rohverlauf und Exporte bleiben vollständig. In Fredriks aktueller Sitzung verkleinert dies jede weitere Modellanfrage um zusätzliche 15.011 Zeichen, also um etwa 3.753 geschätzte Token.
-
-Ab BLUN King 9.1.132 wird der schlanke Basissystemprompt nach der generierten Initialisierung des Standardprofils wiederhergestellt. Zuvor überschrieb der Initialisierer den vorhandenen Prompt mit 4.850 Zeichen durch einen eingebetteten älteren Prompt mit 23.109 Zeichen. Der zur Laufzeit verwendete Prompt bleibt nun tatsächlich bei 4.850 Zeichen. Das spart pro Modellanfrage 18.259 Zeichen, also etwa 4.565 geschätzte Token. Anweisungen oder Werkzeuge werden nicht entfernt; die Änderung korrigiert ausschließlich die Initialisierungsreihenfolge.
-
-Ab BLUN King 9.1.133 werden die projektlokale und die gemeinsame `Mistake.md` nicht mehr als zwei getrennte Promptblöcke gesendet. King wählt aus beiden Quellen höchstens fünf relevante vollständige Einträge innerhalb eines gemeinsamen Budgets von 6.000 Zeichen aus. Die vollständigen Dateien, Writer, Archive, Register, der Rohverlauf und Exporte bleiben unverändert. Die Auswahl erfolgt lokal und deterministisch und benötigt keinen zusätzlichen Modell-, Embedding- oder Netzwerkaufruf. Mit Fredriks aktuellen Dateien sinkt die wiederholte Modellsicht um 12.917 bis 16.811 Zeichen, also um etwa 3.230 bis 4.203 geschätzte Token pro Anfrage.
-
-Ab BLUN King 9.1.134 begrenzt die Modellprojektion nicht adressierte Telegram-Gruppennachrichten auf eine nachvollziehbare Vorschau von 2.000 Zeichen. Anfang und Ende bleiben erhalten, eine Markierung nennt die ursprüngliche Länge. Direkt an den Agenten gerichtete Nachrichten, die sichtbare Telegram-Historie, der Rohverlauf und Exporte bleiben vollständig. In Fredriks realem Verlauf betraf die Grenze 211 von 517 verschiedenen mitgelesenen Gruppenmeldungen und hätte 102.466 wiederholt übertragene Zeichen eingespart, also rund 25.617 geschätzte Token über die gemessenen Modellanfragen.
-
-Ab BLUN King 9.1.137 schützt die Modellprojektion nur noch die zwölf neuesten Nachrichten vollständig vor der Auslagerung älterer Werkzeugausgaben. Große Ergebnisse bleiben im Rohverlauf und in der ursprünglichen Datei oder im privaten Archiv vollständig erhalten; die Modellprojektion behält einen lesbaren Verweis. In Fredriks gemessenem Verlauf werden dadurch mindestens 9.289 weitere Zeichen, also etwa 2.322 geschätzte Token, pro Modellanfrage vermieden.
-
-Ab BLUN King 9.1.138 enthält die Modellprojektion von jedem wiederkehrenden Cron-Auftrag nur noch den neuesten ausstehenden Weckhinweis. Einmalige Erinnerungen, unterschiedliche Aufträge sowie fehlerhafte oder nicht eindeutig zugeordnete Nachrichten bleiben unverändert. Der vollständige Sitzungs-Wire bleibt erhalten. In Fredriks aktueller Sitzung entfallen dadurch bei jeder Anfrage 12.012 Zeichen, also rund 3.003 geschätzte Token.
-
-Ab BLUN King 9.1.139 begrenzt die Modellprojektion ältere, nicht adressierte Telegram-Kanalteile auf 500 Zeichen pro Nachricht. Die neueste Nutzernachricht, adressierte Kanalteile, Anhänge und der vollständige Sitzungs-Wire bleiben unverändert. In Fredriks aktueller Sitzung entfallen dadurch bei jeder Anfrage 9.389 Zeichen, also rund 2.348 geschätzte Token.
-
-Ab BLUN King 9.1.140 begrenzt die relevanzbasierte Mistake-Erinnerung den zusätzlich eingeblendeten Regelkontext standardmäßig auf 4.000 Zeichen. Die vollständigen Mistake-Dateien und der Sitzungs-Wire bleiben unverändert; nur die Modellprojektion erhält die engere Auswahl. In Fredriks gemessenem Lauf sinkt der Hinweis dadurch von 6.037 auf höchstens 4.000 Zeichen. Das spart mindestens 2.037 Zeichen beziehungsweise rund 509 geschätzte Token pro Anfrage.
-
-Ab BLUN King 9.1.141 entfernt die Modellprojektion die Argumente älterer, abgeschlossener Werkzeugaufrufe bereits ab 32 geschätzten Token. Für Werkzeugergebnisse gilt weiterhin die bisherige Schwelle. Die 20 neuesten Nachrichten, noch nicht abgeschlossene Aufrufe, fehlerhaftes JSON und der Sitzungsrohverlauf bleiben unverändert. In Fredriks aktueller Sitzung sinkt die Projektion dadurch pro Modellanfrage um weitere 10.544 Zeichen beziehungsweise rund 2.636 geschätzte Token.
-
-Ab BLUN King 9.1.142 behält die Modellprojektion von älteren, nicht adressierten Telegram-Kanalteilen statt 500 nur noch eine 250 Zeichen lange Vorschau mit Anfang und Ende. Adressierte Kanalteile, die neueste Nutzernachricht, Anhänge, fehlerhaftes Kanal-Markup, Rohverlauf und Exporte bleiben unverändert. In Fredriks aktueller Sitzung spart das pro Modellanfrage weitere 9.221 Zeichen beziehungsweise rund 2.305 geschätzte Token.
-
-Ab BLUN King 9.1.143 entfernt die Modellprojektion bei älteren Nachrichten den wiederholten Telegram-Plugin-Transporthinweis, nachdem die Nachricht in den Verlauf übernommen wurde. Der Kanalinhalt sowie sämtliche Angaben zu Absender, Chat, Nachricht, Zeitstempel, Anhängen und Adressierung bleiben vollständig erhalten. Die neueste Nutzernachricht und der fortlaufend ergänzte Sitzungs-Wire bleiben unverändert. In Fredriks aktueller Sitzung entfallen dadurch bei jeder Modellanfrage 2.890 Zeichen beziehungsweise rund 723 geschätzte Token.
-
-Ab BLUN King 9.1.144 begrenzt die Modellprojektion adressierte Telegram-Abschnitte außerhalb der neuesten 20 Nachrichten auf eine 1.000 Zeichen lange Vorschau mit Anfang und Ende. Die neuesten 20 Nachrichten, die neueste Nutzernachricht, Abschnitte an der exakten Grenze, Anhänge, Kanalmetadaten, Rohverlauf und Exporte bleiben unverändert. In Fredriks vermessener Sitzung entfallen dadurch bei jeder Modellanfrage 34.435 Zeichen beziehungsweise rund 8.609 geschätzte Token.
-
-Ab BLUN King 9.1.145 wird ein unterbrochener Anbieterstream automatisch wiederholt, wenn bis dahin ausschließlich interne Denkausgabe eingetroffen ist. Sichtbarer Text und Werkzeugaufrufe verhindern weiterhin eine automatische Wiederholung. Adaptive Folgeschritte mit niedriger Denkstufe verwenden ein Ausgabebudget von 8.192 Token; erste, komplexe und fehlgeschlagene Schritte behalten das konfigurierte Budget, und eine Wiederholung nach Erreichen der Längengrenze kann es vergrößern. Beim Fortsetzen einer Sitzung erscheint der aktuelle Telegram-Plugin-Transporthinweis nicht mehr als roher Chattext.
-
-Ab BLUN King 9.1.146 werden ältere, bereits ausgelagerte Werkzeugergebnisse in der Modellprojektion auf die für die Wiederherstellung nötigen Angaben begrenzt: Werkzeugname, Zeichenzahl und Dateipfad. Der vollständige Inhalt bleibt unverändert auf der Festplatte, der Rohverlauf wird nicht verändert, und die neuesten zwölf Nachrichten behalten ihre ausführlichen Hinweise. In Fredriks vermessenem Verlauf reduziert das die wiederholte Modelleingabe um 26.779 Zeichen beziehungsweise rund 6.695 geschätzte Token pro Anfrage.
-
-Ab BLUN King 9.1.147 schützt die Mikroverdichtung die neuesten zwölf Nachrichten vollständig statt der neuesten zwanzig und verwendet damit dasselbe Wiederherstellungsfenster wie die bestehende Auslagerung von Werkzeugergebnissen. Ältere abgeschlossene Werkzeugargumente und geeignete Werkzeugergebnisse werden nur in der Modellprojektion verkleinert; Rohverlauf und Wiederherstellungspfade bleiben unverändert. In Fredriks vermessenem Verlauf spart das weitere 560 Zeichen beziehungsweise rund 140 geschätzte Token pro Anfrage.
-
-Ab BLUN King 9.1.148 werden auch im neuesten gemischten Telegram-Paket die ausdrücklich mit addressed=false markierten Kanalabschnitte verkleinert. Adressierte Abschnitte, Medien, Rohverlauf und Exporte bleiben unverändert. In Fredriks vermessenem Verlauf sinken elf nicht adressierte Abschnitte von 22.691 auf 2.750 Zeichen; das spart 19.941 Zeichen beziehungsweise rund 4.986 geschätzte Token pro wiederholter Anfrage.
-
-Ab BLUN King 9.1.156 wiederholen gespeicherte Verweise auf Nutzernachrichten außerhalb der neuesten 20 Nachrichten ihre Vorschau mit Anfang und Ende nicht mehr bei jeder Modellanfrage. Wiederherstellungsmarkierung, Größenangaben, lesbarer Dateipfad, die neuesten 20 Nachrichten, Medien, Rohverlauf, vollständig gespeicherte Datei und Exporte bleiben unverändert. In Fredriks stabil vermessenem Schnappschuss werden fünf historische Verweise verkleinert und die Modellprojektion sinkt von 99.143 auf 96.001 Zeichen. Das spart weitere 3.142 Zeichen beziehungsweise rund 786 geschätzte Eingabetoken pro gleich aufgebauter Anfrage.
-
-Ab BLUN King 9.1.155 werden gespeicherte Verweise auf Nutzernachrichten wiederhergestellt, bevor Textprojektionen den Hash der ursprünglichen Nachricht verändern können. Bestehende Auslagerungen bleiben dadurch wirksam, statt unbemerkt auf die projizierte vollständige Nachricht zurückzufallen. Rohverlauf, wiederlesbare Dateiverweise, die neuesten 20 Nachrichten, Medien und Exporte bleiben unverändert. In Fredriks stabil vermessenem Schnappschuss sinkt die Modellprojektion von 105.810 auf 99.143 Zeichen. Das spart weitere 6.667 Zeichen beziehungsweise rund 1.667 geschätzte Eingabetoken pro gleich aufgebauter Anfrage.
-
-Ab BLUN King 9.1.154 werden adressierte Telegram-Kanalabschnitte außerhalb der neuesten 20 Nachrichten auf eine 500 statt 1.000 Zeichen lange Vorschau mit Anfang und Ende begrenzt. Vollständige Kanalmetadaten, Anfang und Ende des Nachrichteninhalts, die neuesten 20 Nachrichten, Anhänge, Rohverlauf und Exporte bleiben unverändert. In Fredriks stabil vermessenem Schnappschuss werden sieben zusätzliche historische adressierte Abschnitte verkleinert. Das spart 3.500 Zeichen beziehungsweise rund 875 geschätzte Token pro wiederholter Anfrage.
-
-Ab BLUN King 9.1.153 bewahrt die Projektion historischer Telegram-Kontexte die vollständigen Kanalmetadaten und den schließenden Kanal-Tag. Gekürzt wird ausschließlich der Nachrichteninhalt. Selbst bei realen, 161 Zeichen langen Telegram-Metadaten bleibt die Struktur innerhalb des 250-Zeichen-Budgets gültig. Die Projektion ist idempotent, nachfolgende adressierte Kanäle bleiben unverändert, und ein Kanalumschlag, der bereits ohne Inhalt das Budget überschreitet, wird unverändert durchgereicht.
-
-Ab BLUN King 9.1.152 verlassen Argumente abgeschlossener Werkzeugaufrufe die aktive Modellprojektion nach vier statt nach acht neueren Nachrichten. Der rohe Sitzungsverlauf, unbeantwortete oder fehlerhaft formatierte Aufrufe, Medien, Werkzeugergebnisse und die neuesten vier Nachrichten bleiben unverändert. In Fredriks frisch vermessenem Sitzungsschnappschuss werden zwei zusätzliche abgeschlossene Aufrufe verdichtet; gegenüber 9.1.151 spart das weitere 244 Zeichen beziehungsweise rund 61 geschätzte Token pro wiederholter Anfrage.
-
-Ab BLUN King 9.1.151 verlassen Argumente abgeschlossener Werkzeugaufrufe die aktive Modellprojektion nach acht statt nach zwölf neueren Nachrichten. Der rohe Sitzungsverlauf, unbeantwortete oder fehlerhaft formatierte Aufrufe, Medien, Werkzeugergebnisse und die neuesten acht Nachrichten bleiben unverändert. In Fredriks vermessenem Sitzungsschnappschuss werden drei zusätzliche abgeschlossene Aufrufe verdichtet; gegenüber 9.1.150 spart das weitere 317 Zeichen beziehungsweise rund 80 geschätzte Token pro wiederholter Anfrage.
-
-Ab BLUN King 9.1.150 schützt die historische Auslagerung von Werkzeugergebnissen die neuesten vier Nachrichten vollständig statt der neuesten acht. Ältere geeignete Werkzeugergebnisse behalten einen kompakten, 600 Zeichen langen Wiederherstellungshinweis und ihren Quellpfad; Rohverlauf, vollständig gespeicherte Ausgaben, Medien und die neuesten vier Nachrichten bleiben unverändert. In Fredriks vermessenem Sitzungsschnappschuss lagert das Vier-Nachrichten-Fenster neun zusätzliche historische Ergebnisse aus und spart gegenüber 9.1.149 weitere 6.683 Zeichen beziehungsweise rund 1.671 geschätzte Token pro wiederholter Anfrage.
-
-Ab BLUN King 9.1.149 schützt die historische Auslagerung von Werkzeugergebnissen die neuesten acht Nachrichten vollständig statt der neuesten zwölf. Ältere geeignete Werkzeugergebnisse behalten einen kompakten, 600 Zeichen langen Wiederherstellungshinweis und ihren Quellpfad; Rohverlauf, vollständig gespeicherte Ausgaben, Medien und die neuesten acht Nachrichten bleiben unverändert. In Fredriks vermessenem Sitzungsschnappschuss sinken drei Ergebnisse von 4.679 auf 1.800 Zeichen; das spart weitere 2.879 Zeichen beziehungsweise rund 720 geschätzte Token pro wiederholter Anfrage.
-
-Ab BLUN King 9.1.136 behält die Modellprojektion nur noch den neuesten dynamischen `Mistake.md`-Hinweis. Ältere, zugbezogene Auswahlen bleiben im Sitzungsrohverlauf und in Exporten erhalten, werden nach einer neueren Auswahl aber nicht mehr erneut an das Modell gesendet. Andere geänderte Hinweise bleiben unberührt. In Fredriks aktueller Sitzung lagen fünf `Mistake.md`-Auswahlen vor; das Entfernen der vier überholten Kopien spart pro Modellanfrage 24.143 Zeichen, also etwa 6.036 geschätzte Token.
-
-Ab BLUN King 9.1.131 entfernt die Modellprojektion zwei ältere Regelkopien aus dem Systemprompt, sobald gleichwertige Regeln im Conduct-Abschnitt vorhanden sind. Betroffen sind ausschließlich die doppelten Hinweise zu Ehrlichkeit und Zugangsdaten; die vollständigen Conduct-Regeln und alle übrigen Prompt-Abschnitte bleiben unverändert. In der ausgelieferten Standardvorlage sinkt der wiederholt gesendete Prompt dadurch um 1.010 Zeichen, also um etwa 253 geschätzte Token pro Modellanfrage. Fehlt eines der Conduct-Gegenstücke, bleibt die entsprechende ältere Regel unverändert erhalten.
-
-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.
-
-Ab BLUN King 9.1.120 lagert die Konsole auch große ältere Assistentenantworten aus dem aktiven Modellkontext in private Sitzungsdateien aus. Der vollständige Gesprächsverlauf bleibt erhalten; im Modellkontext verbleiben eine begrenzte Vorschau und der Dateipfad. Die 20 neuesten Nachrichten sowie Assistentenantworten mit Werkzeugaufrufen bleiben unverändert, damit laufende Arbeit und Aufrufketten vollständig verfügbar sind.
-
-Ab BLUN King 9.1.121 begrenzt die Modellprojektion auch die Gesamtgröße älterer, mittelgroßer Werkzeugergebnisse, die ausschließlich Text enthalten. Überschreiten Werkzeugergebnisse außerhalb der letzten 20 Nachrichten zusammen 12.000 Zeichen, archiviert King so viele der größten geeigneten Ergebnisse wie nötig und behält nur kompakte, lesbare Dateiverweise im Modellkontext. Der nur ergänzte Rohverlauf und die vollständigen Ergebnisse bleiben unverändert. Gemischte Medienergebnisse und die letzten 20 Nachrichten werden nicht angetastet. In einer gemessenen Sitzung von Fredrik wählte dieser Schnitt 12 ältere Ergebnisse aus und verringerte die projizierte alte Werkzeugausgabe um mindestens 63.444 Zeichen, also um etwa 15.861 geschätzte Token.
-
-Ab BLUN King 9.1.122 wird die vollständige integrierte Designrichtlinie nicht mehr bei jeder Modellanfrage mitgesendet. Nicht visuelle Arbeit erhält nur noch einen kompakten Aktivierungsvertrag. Vor Arbeiten an Benutzeroberflächen, Frontends, visueller Gestaltung, Interaktionen, Design oder Barrierefreiheit lädt King die vollständige Richtlinie über das Skill-Werkzeug; vom Nutzer ausgewählte Design-Skills bleiben zusätzlich verfügbar. Auch bestehende Sitzungen profitieren davon, ohne dass ihr nur ergänzter Rohverlauf umgeschrieben wird, denn verkürzt wird ausschließlich die Modellprojektion. Die Auslagerung älterer reiner Textausgaben von Werkzeugen erzielt nun außerdem die bestmögliche Entlastung, wenn allein die ausgenommenen kleinen Ergebnisse bereits über dem Ziel von 12.000 Zeichen liegen, statt in diesem Fall die gesamte Entlastung abzubrechen. In Fredriks aktuell vermessener Sitzung wurden 14 ältere Werkzeugergebnisse ausgewählt; die projizierte alte Werkzeugausgabe sank dadurch von 77.342 auf 12.418 Zeichen. Zusammen mit der bedarfsgeladenen Designrichtlinie sowie den bestehenden Auslagerungen von Nutzer- und Assistentennachrichten sank die gemessene Projektion von 322.780 Rohzeichen auf 109.656 Zeichen, also auf etwa 27.414 geschätzte Token. Die neuesten 20 Nachrichten, gemischte Medien, der Rohverlauf, Exporte und die vollständige bedarfsgeladene Designrichtlinie bleiben unverändert.
-
-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.
-
-Große Dateien werden weiterhin seitenweise gelesen. Erreicht `Read` seine interne Grenze von 1.000 Zeilen und enthält die Datei weitere Zeilen, nennt das Ergebnis jetzt den exakten nächsten `line_offset`. Beispiel: Ein Lesevorgang ab Zeile 2001 wird mit `line_offset=3001` fortgesetzt. Am Dateiende und bei einem bewusst kleineren Leseausschnitt erscheint kein Fortsetzungshinweis. Dadurch zieht der Agent keine Schlüsse aus einem unvollständigen Ausschnitt und liest die Datei nicht erneut ab der ersten Zeile.
-
-Das Telemetrieereignis `tool_result_offloaded` enthält ausschließlich `tool_name`, `output_size_chars`, `output_size_bytes` und `preview_size_chars`. Es enthält weder den Inhalt noch den Speicherpfad. Beispiel: Eine Ausgabe mit 80.000 Zeichen erzeugt eine Vorschau mit 2.000 Zeichen; die Telemetrie zeigt die Größenersparnis, ohne Nutzdaten zu protokollieren.
-
-Das Telemetrieereignis `tool_result_batch_offloaded` meldet ausschließlich die Zahl der Ergebnisse sowie die Zeichenzahlen vor und nach der Entlastung und die eingesparte Zeichenzahl. Es enthält weder Ergebnisinhalte noch Speicherpfade.
-
-Reguläre `Agent`-Teilaufgaben verwenden eine eigene `ContextMemory` und eine eigene `wire.jsonl` in einem getrennten Agentenverzeichnis. Der Hauptagent erhält nur die Ergebniszusammenfassung, sodass lange Teilaufgaben nicht den Hauptverlauf füllen. `TodoList` speichert Pläne weiterhin maschinenlesbar im Sitzungs-Wire; `blun handoff` übergibt sie zusammen mit prüfbaren Hashes zwischen CLI, Desktop und Web.
-
-## Rein lesende Sitzungsdiagnose
-
-Der mitgelieferte Standardskill `blun-session-inspector` untersucht den nur ergänzten Sitzungs-Wire und die zugehörigen Telemetriedateien, ohne eine Sitzung zu verändern. Er meldet Modellschritte, Werkzeugaufrufe, Zähler zum Tokenverbrauch, Voll- und Mikroverdichtungen, fehlgeschlagene Verdichtungen sowie ausgelagerte Werkzeugergebnisse. Prompts, Systemanweisungen, Werkzeugargumente, Werkzeugergebnisse, private Pfade und verborgenes Denken erscheinen nicht in der Standardausgabe.
-
-Zusätzlich liest der Inspektor das sitzungseigene BLUN-Protokoll und meldet, wie viele Werkzeugschemata verfügbar, ausgewählt und zurückgestellt waren, wie viele geschätzte Schema-Token vermieden wurden und warum die Werkzeugmenge reduziert wurde. Andere Protokollinhalte werden weder ausgegeben noch ausgewertet.
-
-Beispiele:
-
-```text
-node "$SKILL_DIR/scripts/inspect-session.cjs" --list 20
-node "$SKILL_DIR/scripts/inspect-session.cjs" SESSION_ID
-```
-
-Ein eindeutiger Präfix der Sitzungs-ID genügt. `--profile NAME` wählt ein anderes Profil. `--include-metadata` zeigt zusätzlich Arbeits- und Sitzungsverzeichnis und sollte nur verwendet werden, wenn diese Pfade wirklich gebraucht werden. Der Inspektor setzt eine Sitzung niemals fort, lädt sie nicht neu, verdichtet sie nicht und löscht sie nicht.
-
-## Zug-Wächter
-
-Läuft ein Zug 20 Minuten ohne neues Werkzeugergebnis, meldet die Konsole den
-Stand auch im verbundenen Telegram-Kanal. Fünf aufeinanderfolgende identische
-fehlgeschlagene Werkzeugaufrufe beenden den Zug mit einer Fehlermeldung.
-
-Die Grenzwerte lassen sich vor dem Start mit
-`BLUN_TURN_WATCHDOG_IDLE_MINUTES` und
-`BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS` ändern.
-
-## Befehle und Loops während eines laufenden Zugs
-
-Slash-Befehle, die einen freien Agenten benötigen, werden während eines
-laufenden Zugs in ihrer Eingabereihenfolge vorgemerkt und danach ausgeführt.
-Status-, Stopp- und andere sichere Steuerbefehle bleiben sofort verfügbar.
-
-Ein neuer `/loop` ersetzt den bisherigen Loop derselben Sitzung. Dabei bleibt
-genau ein gespeicherter Loop aktiv; der neue Auftrag, das neue Intervall und
-der neue Startzeitpunkt gelten vollständig. `/loop stop`, `/loop pause` und
-`/loop status` wirken auch dann sofort, wenn der Agent gerade arbeitet.
-
-Wird ein neuer `/loop` während eines laufenden Zugs aktiviert, wird sein erster
-Auftrag hinter dem aktuellen Zug eingereiht. Er startet danach automatisch; es
-entsteht weder ein zweiter paralleler Zug noch der Fehler `turn.agent_busy`.
-
-Beispiel: `/loop 5min Prüfe den Teststand und arbeite am nächsten offenen Punkt
-weiter.` führt den ersten Lauf direkt nach dem aktuellen Zug aus und danach alle
-fünf Minuten.
-
-Eine fällige Wiederholung wird als autonomer Aufwecker eingespeist und nicht
-als neue Nutzernachricht behandelt. Die Statuszeile zeigt den nächsten
-Aufweckzeitpunkt laufend an. Beim Fortsetzen derselben Sitzung wird der
-gespeicherte Loop samt Zeitplan wieder geladen; `/new` beginnt dagegen bewusst
-ohne den Loop der vorherigen Sitzung.
-
-## Eigenständige Ideenarbeit und Telegram-Befehle
-
-`/idea <Ziel>` startet einen eigenständigen Arbeitsmodus. Der Agent zeigt zuerst
-einen auftragsspezifischen Aufgabenplan, recherchiert selbstständig, setzt sichere
-lokale Schritte um und fragt gezielt nach, wenn eine Entscheidung oder ein Zugang
-fehlt. Blockierte, auf Freigabe wartende und abgebrochene Schritte bleiben mit
-ihrem tatsächlichen Zustand sichtbar.
-
-Der erste Werkzeugaufruf muss den sichtbaren Plan setzen. Ausgehende Aktionen
-werden zusätzlich pro Werkzeugaufruf geprüft und bei fehlender Kanal- oder
-Zugangsfreigabe angehalten.
-
-`/chancenradar <Ziel>` startet einen eigenen Modus zur Chancensuche. Der Agent
-durchsucht aktuelle öffentliche Quellen, Foren und Communitys nach echten
-Problemen und bestehenden Lösungsansätzen, trennt Belege von Schlussfolgerungen,
-bewertet Chancen nach Wirkung, Passung, Aufwand und Verlässlichkeit und setzt den
-besten sicheren lokalen nächsten Schritt um. Der sichtbare Aufgabenplan und alle
-Freigabegrenzen von `/idea` gelten weiterhin. Der Befehl funktioniert auch über
-Telegram.
-
-`/curiosity <Nische>` startet eine begrenzte, rein lesende Marktrecherche;
-`/scout` ist ein Alias. Der Agent prüft höchstens zwölf Quellseiten, trennt
-Belege, Schlussfolgerungen und Unbekanntes und liefert bis zu drei belegte
-Chancen mit Gegenbeleg, Abbruchkriterium und einem direkt nutzbaren
-`/idea`-Auftrag. Ohne Nische fragt er zuerst genau einmal nach. Schwache Belege
-ergeben weniger Treffer oder `no_action`, niemals aufgefüllte Vorschläge.
-
-Der sichtbare Verlauf behält standardmäßig die vollständige laufende und
-wiederhergestellte Sitzung. Das Mausrad kann den Verlauf direkt beim ersten Zug
-öffnen; Editor und Fußzeile bleiben dabei fest sichtbar.
-
-## Venture Flywheel: geprüfte Phase-0-Verträge
-
-Der mitgelieferte Standardskill `venture-flywheel` stellt reine, deterministische
-Verträge für Projektidentität, Repository-Trust, Capability-Entscheidungen,
-versionierte Laufzustände und hash-verkettete Prüfereignisse bereit. Phase 0
-führt selbst keine Befehle, Netzwerkzugriffe oder Deployments aus.
-
-Ein vollständiges CommonJS-Beispiel für alle sieben öffentlichen Funktionen
-liegt unter
-`standard-skills/venture-flywheel/references/BEISPIELE-phase0.md`. Es zeigt
-unter anderem, warum `sandbox.execute` im Repository abgewiesen, in einem
-isolierten Worktree aber erlaubt wird und wie eine Ereigniskette geprüft wird.
-
-Im automatisch angebundenen Telegram-Kanal werden ausschließlich `/loop`,
-`/goal`, `/idea`, `/chancenradar`, `/curiosity`, `/scout` und `/befehle` als Befehle ausgeführt. Ist der Agent
-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 und Laufzeit der Konsole, den aktuellen
-Zustellweg, den Konsolen-Herzschlag, den letzten Warteschlangen-Fortschritt sowie
-den aktuellen Arbeitsschritt. Die Warteschlange wird als tatsächlich ungelesener
-Anteil und Gesamtgröße gemessen; ein Prüfpunkt wird nur für exakt dieselbe
-Warteschlangendatei akzeptiert. 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, Nachrichteninhalte oder
-vollständigen Aufgabenlisten. 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
-statische Anbieter- oder API-Key-Konfiguration.
-
-## Nachweisbare Arbeitsabläufe
-
-Version 9.1.0 enthält sieben zusätzliche, getrennt nutzbare Befehlsgruppen:
-
-- `proof` belegt Prüfungen und Artefakte mit SHA-256.
-- `brief` erstellt einen versionierten Projektauftrag.
-- `handoff` übergibt eine Sitzung zwischen CLI, Desktop und Web.
-- `replay` erzeugt einen bereinigten Arbeitsverlauf.
-- `guard` prüft Belegintegrität und aktuelle Artefakte.
-- `demo` erzeugt eine bereinigte statische Projektdemo.
-- `workspace` verwaltet isolierte Git-Arbeitsbereiche.
-
-Sie stehen unter `blun` und `king` identisch zur Verfügung.
-
-## Gemeinsamer kognitiver Speicherkern (optional)
-
-Ohne zusätzliche Konfiguration bleibt der bisherige lokale SQLite-Speicher
-aktiv. Betreiber können einen gemeinsamen, portalneutralen Speicherkern
-ausdrücklich über `BLUN_COGNITIVE_MEMORY_ADAPTER_MODULE` wählen. Der Wert muss
-auf eine absolute, kanonische CommonJS-Datei zeigen.
-
-Das Modul exportiert synchron `createCognitiveMemoryAdapter(context)` und
-liefert einen Adapter mit Vertragsversion 6. Relative Pfade, symbolische
-Verknüpfungen, asynchrone Fabriken und abweichende Vertragsversionen werden
-geschlossen abgewiesen. Der Adapter erhält nur die Vertragsversion, das
-Profilverzeichnis sowie Mandanten-, Agenten- und Anzeigenamen. Zugangsdaten
-werden nicht übergeben.
-
-Damit kann derselbe geprüfte Ereignisstrom über CLI und Portale hinweg gelesen,
-korrigiert und zurückgezogen werden. Ohne den optionalen Anbieter entstehen
-keine neuen Netzwerkzugriffe und keine Verhaltensänderung.
-
-## Medienerzeugung
-
-Für Medienaufträge bleiben `GenerateImage`, `GenerateVideo`, `GenerateSpeech` und
-`GetMedia` unmittelbar verfügbar. Die erweiterten Medienwerkzeuge
-`UnderstandImage`, `UnderstandVideo`, `DubVideo` und `LipSyncMedia` sind zusätzlich
-über `ToolSearch` auffindbar und werden nur bei Bedarf geladen. Dadurch kann King
-Bilder und Videos verstehen, Videos vertonen oder Lippenbewegungen synchronisieren,
-ohne diese Werkzeugschemata bei jeder normalen Textanfrage mitzuschicken. Nutzer
-müssen weder Werkzeugnamen noch Modell-Prompts kennen. Eine normale Anweisung wie
-„Erzeuge ein realistisches Produktbild einer schwarzen Armbanduhr auf weißem
-Marmor“ oder „Animiere das letzte Bild als ruhige Kamerafahrt von sechs Sekunden“
-genügt. King wählt den passenden Medienweg und kann das asynchrone Ergebnis mit
-`GetMedia` abrufen.
-
-Ein angenommener Medienauftrag bleibt über Verdichtungen und schnelle
-Folgeturns hinweg gespeichert. Solange er offen ist, bleibt `GetMedia`
-verfügbar; King prüft den tatsächlichen Status, statt fälschlich zu behaupten,
-die Medienerzeugung sei nicht verfügbar.
-
-## Passende Werkzeuge ohne Such-Zwischenschritt
-
-Ab BLUN King 9.1.396 vergleicht King die aktuelle Anfrage mit den bereits
-registrierten Werkzeugbeschreibungen. Bei eindeutiger Übereinstimmung lädt er
-für diesen Zug höchstens zwei passende, sonst zurückgestellte Schemata direkt.
-Name, Beschreibung, Parameterhinweise und Beispiele dürfen zur Auswahl
-beitragen; frühere Nachrichten außerhalb des aktuellen Telegram-Kanalblocks
-zählen nicht als neue Absicht.
-
-`ToolSearch` bleibt für unklare, unbekannte und mehrdeutige Anfragen vollständig
-verfügbar. Eine automatische Auswahl wird nicht dauerhaft gespeichert und
-vergrößert den residenten Werkzeugsatz nicht. Dadurch kann eine natürliche
-Anweisung wie „Zeig mir den letzten Telegram-Verlauf“ das passende Werkzeug im
-selben Modellschritt erhalten, während Begrüßungen und fachfremde Anfragen keine
-zusätzlichen Schemata laden.
-
-## Begrenztes Ranking bei großen Eingaben
-
-Ab BLUN King 9.1.403 bewertet die automatische Werkzeugauswahl pro aktueller
-Anfrage höchstens 1.000 Zeichen. Eingebettete Inhalte aus
-`<attached_documents>`, `<attachment_content>`, `<document_content>` und
-`<file_content>` werden vor dem Ranking vollständig entfernt. Damit können
-große Anhänge weder die Auswahl unnötig verteuern noch anhand ihres Inhalts ein
-fachfremdes Werkzeug vorladen.
-
-## Ruhige Konfigurationsaktualisierung
-
-Ab BLUN King 9.1.404 ersetzt eine Konfigurationsaktualisierung die private
-`config.toml` nur noch, wenn sich ihre serialisierten Bytes tatsächlich ändern.
-Bei identischem Inhalt bleiben Dateidentität und Änderungszeit erhalten; die
-Prüfung und Härtung der privaten Dateirechte läuft trotzdem weiter. Echte
-Änderungen verwenden unverändert den crash-sicheren atomaren Schreibweg.
-
-## Verlässliche Beziehungskontinuität
-
-Ab BLUN King 9.1.406 wird ein erneut zugestelltes privates Telegram-Ereignis
-mit demselben Zeitstempel und Text nur einmal gespeichert. Eine tatsächlich
-später wiederholte Aussage bleibt dagegen Teil des Verlaufs.
-
-Natürliche ausdrückliche Hinweise wie „Dieter ist dein Boss, bitte merken“
-werden auch dann erkannt, wenn die Bitte um Erinnerung am Ende steht. Sie
-gelangen als Referenzdaten in einen begrenzten, nur ergänzbaren
-Beziehungskontext. Sie erteilen oder ändern niemals Berechtigungen;
-Gruppeninhalte, Geheimnisse und Zugriffsaussagen bleiben ausgeschlossen.
-
-Ab BLUN King 9.1.408 speichert ein ausdrücklich zu merkendes privates
-Beziehungsdetail zunächst als unsichere Beobachtung im versionierten
-Cognitive-Memory-Adapter. Erst eine zweite, unabhängige identische Aussage
-bestätigt es; der nächste private Turn lädt den bestätigten Eintrag. Wiederholte
-Ereignisse bleiben idempotent, Gruppen sehen ihn nie, und gespeicherte Aussagen
-können keine Berechtigungen erteilen. Ist ein konfigurierter Memory-Anbieter
-nicht verfügbar, wird keine lokale Schatten-Memory angelegt.
-
-## Stabiler Telegram-Reply-Weg
-
-Ab BLUN King 9.1.407 kann der Duplikatschutz des Telegram-Reply-Werkzeugs das
-aktuelle Eingangsprotokoll wieder direkt lesen. Normale Antworten scheitern
-dadurch nicht mehr an einem fehlenden Laufzeitimport; der getrennte
-Bridge-Fallback bleibt nur die Absicherung und nicht der unbeabsichtigte
-Hauptweg.
-
-Ab BLUN King 9.1.409 verwenden Reply-Werkzeug und TUI-Fallback dasselbe
-Telegram-Kanalverzeichnis. Ein profilspezifisches `BLUN_HOME` erzeugt dadurch
-keinen zweiten Eingangs- oder Ausgangsverlauf mehr. Ein ausdrücklich gesetztes
-`BLUN_TELEGRAM_STATE_DIR` bleibt maßgeblich; ohne diese Einstellung verwenden
-beide Wege `~/.blun/channels/telegram`.
-
-Ab BLUN King 9.1.410 begrenzen private Telegram-Gedächtnisbefehle
-Beziehungsdaten auf die jeweilige Person. `/memory focus` blendet Beziehungen
-anderer Personen aus, lässt aber nicht personenbezogenen Kontext sichtbar.
-Korrekturen und Löschungen können keine Beziehung einer anderen Person mehr
-treffen; die lokale Operator-Ansicht bleibt vollständig.
-
-Ab BLUN King 9.1.411 können nicht triviale oder unbekannte Aufgaben einen
-begrenzten Problemrahmen im dauerhaften Aktions-Checkpoint speichern. Er hält
-das Erfolgskriterium, Wissenslücken, bis zu fünf Handlungsoptionen, die gewählte
-Aktion samt Begründung, die vorgesehene Unterstützung, das Risiko und den
-Rückweg fest. Die gewählte Aktion muss einer der gespeicherten Optionen
-entsprechen. Der Rahmen bleibt beim Fortsetzen und nach einem Neustart erhalten,
-beschreibt aber ausschließlich den Arbeitsstand und kann niemals Berechtigungen
-erteilen.
-
-Ab BLUN King 9.1.412 beginnt jedes vom Modell angelegte dauerhafte Ziel atomar
-mit Revision 1 und einem vollständigen, begrenzten Problemrahmen im
-Aktions-Checkpoint. Der Rahmen bleibt dadurch sofort erhalten und hängt nicht
-mehr von einem späteren `UpdateGoal`-Aufruf ab. Im God Mode und im automatischen
-Modus läuft ein bereits autorisierter Zielstart ohne zweite Bestätigung weiter;
-im manuellen Modus bleibt die bestehende Freigabe erhalten. Authentifizierte,
-nicht triviale Mehrschrittaufgaben mit überprüfbarem Endzustand dürfen das
-dauerhafte Ziel auch unter einer bereits geltenden Anweisung zum autonomen
-Weiterarbeiten nutzen. Begrüßungen, gewöhnliche Einzelschrittanfragen und vage
-Aufgaben erzeugen weiterhin kein Ziel. Der Problemrahmen bleibt beschreibender
-Arbeitsstand und erteilt niemals Berechtigungen.
-
-Ab BLUN King 9.1.413 werden Antworten aus Telegram-Zügen nicht mehr als fertig
-versendet, wenn der letzte Modellschritt am Ausgabelimit `max_tokens` endete.
-Der unvollständige Entwurf bleibt ausschließlich im Sitzungskontext. King
-erstellt daraus automatisch eine kurze, vollständige Antwort und sendet erst
-diese. Bereits über das Reply-Werkzeug zugestellte Antworten werden dabei nicht
-wiederholt. Die Fortsetzung ist auf drei Versuche begrenzt; danach wird niemals
-ein abgeschnittener Text als Ergebnis ausgegeben.
-
-Ab BLUN King 9.1.414 trägt jeder neue dauerhafte Aktions-Checkpoint zusätzlich
-den genauen Auslöser für seinen nächsten Schritt. Außerhalb einer Wartephase
-muss dieser Auslöser „sofort“ sein. Eine Wartephase benennt stattdessen ein
-äußeres Ereignis, einen Zeitpunkt, eine Abhängigkeit oder eine ausstehende
-Nutzerentscheidung. Auslöser und Bedingung bleiben bei Fortsetzung und Neustart
-erhalten, ohne Berechtigungen zu erteilen. Bereits gespeicherte ältere
-Checkpoints bleiben lesbar.
-
-Ab BLUN King 9.1.415 übernimmt der sitzungsübergreifende Arbeitsfokus den
-gespeicherten Auslöser vollständig. Die nächste Aktion und die Bedingung, unter
-der sie ausgeführt werden darf, bleiben getrennt sichtbar. Dadurch erscheint
-eine Wartephase nach einem Neustart oder Kontextwechsel nicht mehr als sofortiger
-Arbeitsauftrag. Art und Bedingung des Auslösers verändern außerdem die Identität
-des dauerhaften Fokuszustands; fehlerhafte oder zur Phase widersprüchliche
-Auslöser werden verworfen. Ältere Checkpoints ohne ausdrücklichen Auslöser
-behalten ihr bisheriges Verhalten.
-
-Der eigentliche Anhang und die vollständige Nutzernachricht bleiben für den Zug
-unverändert verfügbar. Die Begrenzung betrifft ausschließlich die kleine
-lexikalische Vorauswahl von höchstens zwei Werkzeugschemas; ToolSearch und alle
-explizit benötigten Medien- und Anhangswerkzeuge bleiben erhalten.
-
-## Abschlussbedingungen mit Laufzeitbeleg
-
-Ab BLUN King 9.1.397 kann ein autonomes Ziel mit ausdrücklich gesetzter
-Abschlussbedingung nicht mehr allein aufgrund einer Textbehauptung als fertig
-markiert werden. Vor dem Abschluss muss ein aktueller Prüf-Checkpoint vorliegen,
-der auf mindestens einem erfolgreichen Laufzeitwerkzeug beruht und als verifiziert
-eingestuft ist. Fehlt dieser Beleg, bleibt das Ziel aktiv und King erhält eine
-konkrete Nachbesserung statt einer falschen Fertigmeldung. Ziele ohne ausdrücklich
-gesetzte Abschlussbedingung behalten ihr bisheriges Verhalten.
-
-## Projektbezogenes Lernen ohne Übersprechen
-
-Ab BLUN King 9.1.399 bleiben bestätigte Rot-zu-Grün-Lernkandidaten innerhalb
-des Git-Projekts, in dem sie entstanden sind. Zwei Arbeitskopien desselben
-Remote-Repositories teilen denselben anonymisierten Projekt-Schlüssel; andere
-Repositories erhalten getrennte Lernspeicher. Lokale Git-Projekte ohne Remote
-werden anhand ihres Repository-Wurzelpfads getrennt.
-
-Weder Remote-Adresse noch lokaler Projektpfad werden im Lernkandidaten
-gespeichert. Außerhalb eines Git-Projekts bleibt der bisherige globale
-Profilspeicher erhalten. Damit kann eine gemessene Projektregel später wieder
-aufgerufen werden, ohne als vermeintlich allgemeine Regel in fachfremde Projekte
-zu gelangen.
-
-## Sofort sichtbarer Antwortbeginn
-
-Ab BLUN King 9.1.401 rendert die TUI das erste Textfragment eines neuen Zuges
-oder eines neuen Antwortabschnitts sofort. Es wartet nicht mehr auf den ersten
-Intervall-Timer und übernimmt auch keinen Render-Zeitstempel aus dem vorherigen
-Zug. Dadurch erscheint der Antwortbeginn ohne vermeidbare Pause in der Konsole.
-
-Weitere Text-, Denk- und Werkzeugfragmente bleiben adaptiv gebündelt. Kurze
-Ausgaben behalten ihren schnellen Takt; bei langen Ausgaben wächst das Intervall
-weiterhin stufenweise, damit vollständige Neurenderings die TUI nicht ausbremsen.
-
-## Bereinigung alter Verdichtungsarchive beim Start
-
-Ab BLUN King 9.1.402 beginnt beim Start einmalig eine Hintergrundbereinigung
-für private Verdichtungsarchive unter `~/.blun/conversation-history/`. Dateien,
-deren Aufbewahrungsfrist abgelaufen ist, werden damit auch dann entfernt, wenn
-anschließend keine neue Vollverdichtung stattfindet.
-
-Die Bereinigung wird nicht abgewartet und kann den Start weder verzögern noch
-verhindern. Sie bleibt auf reguläre `compaction-*.md`-Dateien direkt im
-Archivverzeichnis begrenzt. Fehler werden protokolliert und fallen weich
-zurück; Sitzungs-Wire, andere Dateien und laufende Antworten bleiben
-unverändert. `BLUN_COMPACTION_HISTORY_RETENTION_DAYS=0` schaltet die
-Bereinigung weiterhin vollständig ab.
-
-## Reaktionsfähige Wiederaufnahme großer Sitzungen
-
-Ab BLUN King 9.1.400 spielt die TUI gespeicherte Sitzungsverläufe weiterhin
-vollständig ab, gibt bei großen Wiederaufnahmen aber nach jeweils 30 Datensätzen
-kurz an die Node-Ereignisschleife ab. Dadurch können Anzeige, Eingabe und
-Zustandsleiste während des Wiederaufbaus reagieren, statt bis zum letzten
-Verlaufseintrag zu warten.
-
-Es werden keine Datensätze gekürzt, übersprungen oder aus dem gespeicherten
-Verlauf entfernt. Nach dem letzten Datensatz erfolgt keine unnötige zusätzliche
-Unterbrechung; kleine Sitzungen behalten damit praktisch ihr bisheriges
-Startverhalten.
-
-## Keine doppelte Telegram-Antwort ohne neue Nachricht
-
-Ab BLUN King 9.1.398 prüft jeder Text-Ausgangspfad vor dem Senden die jüngste
-erfolgreiche Telegram-Antwort und den jüngsten Eingang desselben Chats. Solange
-danach keine neue Nutzernachricht eingetroffen ist, wird eine wortgleiche oder
-nahezu gleiche Wiederholung nicht erneut gesendet. Das gilt gleichermaßen für
-den Telegram-Werkzeugpfad und beide automatischen Rückfallpfade.
-
-Nach einer neuen Nutzernachricht ist dieselbe Antwort wieder zulässig. Andere
-Ergebnisse und Datei-Anhänge bleiben unverändert. Die Prüfung liest nur begrenzte
-Endbereiche der Ein- und Ausgangsprotokolle und fällt bei fehlendem Beleg offen
-zurück, damit Telegram nicht wegen einer beschädigten Protokollzeile blockiert.
-
-Angehängte Bilder werden weiterhin mit `ReadMediaFile` gelesen. Bild-, Video-
-und Spracherzeugung laufen asynchron, sodass die Konsole während der Verarbeitung
-nutzbar bleibt. `GenerateVideo` kann außerdem einen abgeschlossenen Bildauftrag
-oder eine lokale PNG- beziehungsweise JPEG-Datei animieren.
-
-Die Medienleiste erscheint nur bei aktiven Medienaufträgen. Sie zeigt
-Warteschlangenplatz, Produktionsphase und Laufzeit sowie nur tatsächlich vom
-Anbieter gemeldete Prozentwerte, Schritte, Frames, FPS, Audiolänge, Restzeit,
-Auflösung, Wellenform und Vorschauen. Bei Bild-zu-Video erscheint das lokale
-Ausgangsbild sofort als Vorschau. Tatsächlich gemeldete Phasen bleiben erhalten,
-sodass auch kurze Schritte wie Rendern und Speichern in der Produktionskette
-sichtbar sind. Aktualisierte Vorschaubilder werden erneuert; Medienpfade und
-Webadressen sind als Terminalverweise anklickbar.
-
-## Gestufte Verdichtung für große Sitzungen
-
-Eine Vollverdichtung verwendet jetzt pro Zusammenfassungsstufe höchstens 64.000 geschätzte Eingabe-Token als Zielwert. Die feste Sicherheitsgrenze des aktiven Modells bleibt unverändert. King teilt den älteren Verlauf an gültigen Nachrichtengrenzen, fasst jeden chronologischen Abschnitt zusammen und übernimmt diese Zusammenfassung in die nächste Stufe. Dabei wird kein noch nicht zusammengefasster Verlauf verworfen. Ist eine einzelne unteilbare Nachricht größer als der Stufenzielwert, bleibt die bestehende feste Sicherheitsgrenze der Rückfallweg.
-
-Beispiel: Ein auf 256.000 Token geschätzter Verdichtungsauftrag wird in mehreren kleineren Stufen verarbeitet, statt als eine einzige große Anbieteranfrage. Die genaue Stufenzahl hängt von den Nachrichtengrenzen und den erzeugten Zwischenzusammenfassungen ab. Der Protokolleintrag `compaction stage request` nennt `targetInputTokens`; das Telemetrieereignis `compaction_finished` nennt `stage_count`. Das private Verlaufsarchiv und der ursprüngliche Sitzungs-Wire bleiben vollständig.
-
-## Wiederauffindbarer Verdichtungsverlauf
-
-Bevor eine erfolgreiche Vollverdichtung ältere Nachrichten ersetzt, schreibt King den verdrängten Verlauf in ein privates Markdown-Archiv unter `~/.blun/conversation-history/`. Die Verdichtungszusammenfassung enthält den genauen `history_path`, sodass der Agent mit `Read` Einzelheiten wiederfinden kann, die nicht in der Zusammenfassung stehen.
-
-Eingebettete Bild-, Audio- und Videodaten werden im Archiv nicht doppelt gespeichert. Der ursprüngliche Sitzungs-Wire bleibt maßgeblich. Kann das Archiv nicht geschrieben werden, protokolliert King `compaction_history_archive_failed` und lässt den normalen Verdichtungsweg verfügbar; ein Archivfehler löscht niemals den gespeicherten Sitzungsverlauf.
-
-## Dauerhafte Checkpoints zwischen Arbeitsschritten
-
-Bevor King den nächsten Modellschritt beginnt, schreibt er alle vorangegangenen Wire-Einträge dauerhaft auf den Datenträger. Nach dem Ende eines Zuges erfolgt eine weitere vollständige Sicherung, bevor der zugehörige Worker abgeschlossen wird. Das schließt beendete Modell- und Werkzeugschritte ein. Eine fortgesetzte Sitzung beginnt dadurch beim letzten abgeschlossenen Schritt und ist nicht auf noch ungesicherte Einträge im Arbeitsspeicher angewiesen.
-
-Beispiel: Wenn der Anbieter oder das Terminal nach einem abgeschlossenen Werkzeugaufruf, aber vor der nächsten Modellantwort ausfällt, kann die Sitzung neu gestartet oder fortgesetzt werden. Der vorangegangene Werkzeugeintrag wurde vor der nächsten Anfrage an den Anbieter in `wire.jsonl` synchronisiert und wird beim Fortsetzen wieder eingelesen. Der Checkpoint verkürzt keine Prompts und ersetzt nicht die wiederauffindbaren Verdichtungsarchive; er schützt die Übergabe zwischen zwei Arbeitsschritten.
-
-## Schlanker Basissystemprompt
-
-Der dauerhaft geladene Basissystemprompt umfasst jetzt 4.850 statt 23.109
-Zeichen. Identität, Persona und Seele, Antwortsprache, Arbeits- und
-Berechtigungsgrenzen, Verdichtungsübergabe, Betriebssystem und Shell,
-Arbeitsordner, `AGENTS.md` sowie das schrittweise Nachladen von Skills bleiben
-erhalten. Wiederholte Regeln, die bereits in diesen eingespeisten Blöcken oder
-in den einzelnen Werkzeugschemas stehen, werden nicht erneut mitgesendet.
-
-Beispiel: Beim Sitzungsstart erhält King weiterhin die ausgewählte Persona und
-Seele, die Sprache des Nutzers, den aktuellen Arbeitsordner, geltende
-`AGENTS.md`-Anweisungen und die kompakte Skill-Liste. Lediglich doppelte
-Dauerhinweise entfallen. Das spart rund 4.565 geschätzte Prompt-Token je
-vollständiger Anfrage, ohne Gesprächsverlauf oder Werkzeugergebnisse zu kürzen.
-
-## Korrigierte Markenfarben in der Fußzeile
-
-Das kompakte BLUN-Zeichen unter der Eingabe zeigt die Markenfarben wieder in
-der richtigen Reihenfolge: Der Statuspunkt und `UN` verwenden die Primärfarbe,
-`BL` bleibt weiß. Die Korrektur betrifft nur die Darstellung; Statuswerte,
-Profilname und Persona bleiben unverändert.
-
-## Einheitliche verwaltete Node-Laufzeit
-
-Startet BLUN unter Windows oder macOS mit einer Node.js-Version vor 24.15.0,
-richtet es eine private unterstützte Laufzeit ein und startet damit neu. Ab
-BLUN King 9.1.135 steht das Verzeichnis dieser verwalteten Laufzeit auch im
-`PATH` des Ersatzprozesses und aller untergeordneten Werkzeuge an erster Stelle.
-
-Dadurch verwenden vom Agenten gestartete Befehle wie `node` und `npm` dieselbe
-unterstützte Laufzeit wie die TUI, statt auf eine ältere Systeminstallation
-zurückzufallen. Die globale Node-Installation des Systems wird nicht verändert.
-OAuth, gespeicherte Anmeldedaten, Sitzungen und der Updatestatus bleiben
-unverändert.