blun-king-cli 9.1.39 → 9.1.40

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.36
+  npm install -g blun-king-cli@9.1.40
 
 Start
 -----
@@ -20,6 +20,17 @@ Start
 Beide Startbefehle verwenden dieselbe Version, dasselbe Konto, dasselbe Modell
 und dieselben Befehle.
 
+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 über diese Umgebungsvariablen ändern:
+
+  BLUN_TURN_WATCHDOG_IDLE_MINUTES
+  BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS
+
 Nachweisbare Arbeitsabläufe
 ---------------------------
 

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.36
+npm install -g blun-king-cli@9.1.40
 ```
 
 ## Reproduzierbares Staging und Packen
@@ -35,6 +35,16 @@ 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.
 
+## 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.
+
 Beim ersten Start werden das Telegram-Plugin und die mitgelieferten Skills
 eingerichtet. Die Anmeldung erfolgt anschließend in der
 Konsole mit `/login` über den BLUN-OAuth-Server. Das Paket erzeugt keine

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:100000256c8742e28ac1b44fd85c258bacd68037bbbe180b9d79717e466d1d89
+// BLUN_BUILD_INPUT_SHA256:8bb145d6572cc54a356af3540ba025543ec8c802f66e02a12df23fcd2fcc2bc0
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -259098,6 +259098,20 @@ bytesWritten: number$1().int().nonnegative() });
 				continuation: void 0
 			}, safePath, true);
 			if (result.isError === true) return result;
+			let persistedSha256;
+			try {
+				const persistedContent = await this.kaos.readText(safePath);
+				persistedSha256 = createHash("sha256").update(persistedContent).digest("hex");
+			} catch (error) {
+				return {
+					isError: true,
+					output: `Write continuation wrote ${args.path}, but could not verify the persisted bytes: ${error instanceof Error ? error.message : String(error)}. Inspect the target before continuing.`
+				};
+			}
+			if (persistedSha256 !== actualSha256) return {
+				isError: true,
+				output: `Write continuation integrity failure for ${args.path}: staged SHA-256 ${actualSha256}, persisted SHA-256 ${persistedSha256}. The target may be incomplete; inspect it before continuing.`
+			};
 			this.pendingContinuations.delete(safePath);
 			const writeOutput = typeof result.output === "string" ? result.output : "Write completed.";
 			return {
@@ -502382,7 +502396,9 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.needsAuth": "MCP server \"{name}\" needs OAuth — run /mcp-config login {name}",
 		"sessionEvent.mcp.disabled": "MCP server \"{name}\" disabled",
 		"sessionEvent.mcp.connecting": "MCP server \"{name}\" connecting…",
-		"sessionEvent.skill.activated": "Activated skill: {skillName}"
+		"sessionEvent.skill.activated": "Activated skill: {skillName}",
+		"sessionEvent.watchdog.idle": "Turn running for {minutes} min; last tool: {tool}; repeated failures: {repetitions}.",
+		"sessionEvent.watchdog.aborted": "Turn stopped after {repetitions} repeated failed calls to {tool}."
 	},
 	de: {
 		"sessionEvent.error.mcpSync": "Der MCP-Serverstatus konnte nicht synchronisiert werden: {error}",
@@ -502409,7 +502425,9 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.needsAuth": "MCP-Server „{name}“ benötigt OAuth — /mcp-config login {name} ausführen",
 		"sessionEvent.mcp.disabled": "MCP-Server „{name}“ deaktiviert",
 		"sessionEvent.mcp.connecting": "MCP-Server „{name}“ wird verbunden…",
-		"sessionEvent.skill.activated": "Skill aktiviert: {skillName}"
+		"sessionEvent.skill.activated": "Skill aktiviert: {skillName}",
+		"sessionEvent.watchdog.idle": "Zug läuft seit {minutes} Min.; letztes Werkzeug: {tool}; wiederholte Fehler: {repetitions}.",
+		"sessionEvent.watchdog.aborted": "Zug nach {repetitions} wiederholten fehlgeschlagenen Aufrufen von {tool} beendet."
 	},
 	es: {
 		"sessionEvent.error.mcpSync": "No se pudo sincronizar el estado de los servidores MCP: {error}",
@@ -502436,7 +502454,9 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.needsAuth": "El servidor MCP «{name}» requiere OAuth; ejecuta /mcp-config login {name}",
 		"sessionEvent.mcp.disabled": "Servidor MCP «{name}» desactivado",
 		"sessionEvent.mcp.connecting": "Conectando el servidor MCP «{name}»…",
-		"sessionEvent.skill.activated": "Skill activado: {skillName}"
+		"sessionEvent.skill.activated": "Skill activado: {skillName}",
+		"sessionEvent.watchdog.idle": "El turno lleva {minutes} min en curso; última herramienta: {tool}; fallos repetidos: {repetitions}.",
+		"sessionEvent.watchdog.aborted": "Turno detenido tras {repetitions} llamadas fallidas repetidas a {tool}."
 	},
 	fr: {
 		"sessionEvent.error.mcpSync": "Impossible de synchroniser l’état des serveurs MCP : {error}",
@@ -502463,7 +502483,9 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.needsAuth": "Le serveur MCP « {name} » requiert OAuth — exécutez /mcp-config login {name}",
 		"sessionEvent.mcp.disabled": "Serveur MCP « {name} » désactivé",
 		"sessionEvent.mcp.connecting": "Connexion du serveur MCP « {name} »…",
-		"sessionEvent.skill.activated": "Skill activé : {skillName}"
+		"sessionEvent.skill.activated": "Skill activé : {skillName}",
+		"sessionEvent.watchdog.idle": "Tour en cours depuis {minutes} min ; dernier outil : {tool} ; échecs répétés : {repetitions}.",
+		"sessionEvent.watchdog.aborted": "Tour arrêté après {repetitions} appels répétés ayant échoué pour l'outil {tool}."
 	},
 	sv: {
 		"sessionEvent.error.mcpSync": "Det gick inte att synkronisera MCP-serverstatus: {error}",
@@ -502490,7 +502512,9 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.needsAuth": "MCP-servern ”{name}” behöver OAuth – kör /mcp-config login {name}",
 		"sessionEvent.mcp.disabled": "MCP-servern ”{name}” är inaktiverad",
 		"sessionEvent.mcp.connecting": "Ansluter MCP-servern ”{name}”…",
-		"sessionEvent.skill.activated": "Skill aktiverad: {skillName}"
+		"sessionEvent.skill.activated": "Skill aktiverad: {skillName}",
+		"sessionEvent.watchdog.idle": "Körningen har pågått i {minutes} min. Senaste verktyg: {tool}. Upprepade fel: {repetitions}.",
+		"sessionEvent.watchdog.aborted": "Körningen stoppades efter {repetitions} upprepade misslyckade anrop till {tool}."
 	},
 	cs: {
 		"sessionEvent.error.mcpSync": "Selhala synchronizace stavu serveru MCP: {error}",
@@ -502517,7 +502541,9 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.needsAuth": "Server MCP \"{name}\" vyžaduje přihlášení přes OAuth — spusťte /mcp-config login {name}",
 		"sessionEvent.mcp.disabled": "Server MCP \"{name}\" zakázán",
 		"sessionEvent.mcp.connecting": "Server MCP \"{name}\" se připojuje…",
-		"sessionEvent.skill.activated": "Aktivována dovednost: {skillName}"
+		"sessionEvent.skill.activated": "Aktivována dovednost: {skillName}",
+		"sessionEvent.watchdog.idle": "Kolo běží {minutes} min; poslední nástroj: {tool}; opakovaná selhání: {repetitions}.",
+		"sessionEvent.watchdog.aborted": "Kolo bylo zastaveno po {repetitions} opakovaných neúspěšných voláních nástroje {tool}."
 	}
 });
 //#endregion
@@ -503659,6 +503685,140 @@ function isUserCancelledSubagentError(error) {
 	}
 }
 //#endregion
+//#region src/tui/controllers/turn-watchdog.ts
+const DEFAULT_IDLE_MINUTES = 20;
+const DEFAULT_MAX_FAILED_REPETITIONS = 5;
+const MIN_IDLE_MINUTES = 1;
+const MAX_IDLE_MINUTES = 1440;
+const MIN_FAILED_REPETITIONS = 2;
+const MAX_FAILED_REPETITIONS = 100;
+const TURN_WATCHDOG_IDLE_MINUTES_ENV = "BLUN_TURN_WATCHDOG_IDLE_MINUTES";
+const TURN_WATCHDOG_MAX_FAILED_REPETITIONS_ENV = "BLUN_TURN_WATCHDOG_MAX_FAILED_REPETITIONS";
+function resolveTurnWatchdogConfig(env = process.env) {
+	const idleMinutes = parseBoundedInteger(env[TURN_WATCHDOG_IDLE_MINUTES_ENV], DEFAULT_IDLE_MINUTES, MIN_IDLE_MINUTES, MAX_IDLE_MINUTES);
+	const maxFailedRepetitions = parseBoundedInteger(env[TURN_WATCHDOG_MAX_FAILED_REPETITIONS_ENV], DEFAULT_MAX_FAILED_REPETITIONS, MIN_FAILED_REPETITIONS, MAX_FAILED_REPETITIONS);
+	return {
+		idleMs: idleMinutes * 6e4,
+		maxFailedRepetitions
+	};
+}
+var TurnWatchdogController = class {
+	config;
+	now;
+	setTimer;
+	clearTimer;
+	onIdle;
+	onAbort;
+	toolCalls = /* @__PURE__ */ new Map();
+	active = false;
+	startedAtMs = 0;
+	lastProgressAtMs = 0;
+	lastToolName = "none";
+	lastFailedKey;
+	failedRepetitions = 0;
+	idleReportedForProgressAtMs;
+	timer;
+	constructor(options) {
+		this.config = options.config ?? resolveTurnWatchdogConfig();
+		this.now = options.now ?? Date.now;
+		this.setTimer = options.setTimer ?? setTimeout;
+		this.clearTimer = options.clearTimer ?? clearTimeout;
+		this.onIdle = options.onIdle;
+		this.onAbort = options.onAbort;
+	}
+	start() {
+		this.stop();
+		const now = this.now();
+		this.active = true;
+		this.startedAtMs = now;
+		this.lastProgressAtMs = now;
+		this.lastToolName = "none";
+		this.lastFailedKey = void 0;
+		this.failedRepetitions = 0;
+		this.idleReportedForProgressAtMs = void 0;
+		this.scheduleIdleCheck();
+	}
+	stop() {
+		this.active = false;
+		this.toolCalls.clear();
+		if (this.timer !== void 0) {
+			this.clearTimer(this.timer);
+			this.timer = void 0;
+		}
+	}
+	recordToolCall(toolCallId, name, args) {
+		if (!this.active) return;
+		this.lastToolName = name;
+		this.toolCalls.set(toolCallId, {
+			name,
+			key: `${name}\0${canonicalJson(args)}`
+		});
+	}
+	recordToolResult(toolCallId, isError) {
+		if (!this.active) return;
+		const toolCall = this.toolCalls.get(toolCallId);
+		this.toolCalls.delete(toolCallId);
+		if (toolCall !== void 0) this.lastToolName = toolCall.name;
+		this.lastProgressAtMs = this.now();
+		this.idleReportedForProgressAtMs = void 0;
+		this.scheduleIdleCheck();
+		if (!isError || toolCall === void 0) {
+			this.lastFailedKey = void 0;
+			this.failedRepetitions = 0;
+			return;
+		}
+		if (toolCall.key === this.lastFailedKey) this.failedRepetitions += 1;
+		else {
+			this.lastFailedKey = toolCall.key;
+			this.failedRepetitions = 1;
+		}
+		if (this.failedRepetitions < this.config.maxFailedRepetitions) return;
+		const snapshot = this.snapshot();
+		this.stop();
+		this.onAbort(snapshot);
+	}
+	scheduleIdleCheck() {
+		if (!this.active) return;
+		if (this.timer !== void 0) this.clearTimer(this.timer);
+		const remaining = Math.max(0, this.config.idleMs - (this.now() - this.lastProgressAtMs));
+		this.timer = this.setTimer(() => {
+			this.timer = void 0;
+			this.checkIdle();
+		}, remaining);
+	}
+	checkIdle() {
+		if (!this.active) return;
+		if (this.now() - this.lastProgressAtMs >= this.config.idleMs && this.idleReportedForProgressAtMs !== this.lastProgressAtMs) {
+			this.idleReportedForProgressAtMs = this.lastProgressAtMs;
+			this.onIdle(this.snapshot());
+			return;
+		}
+		this.scheduleIdleCheck();
+	}
+	snapshot() {
+		return {
+			elapsedMinutes: Math.max(1, Math.floor((this.now() - this.startedAtMs) / 6e4)),
+			lastToolName: this.lastToolName,
+			failedRepetitions: this.failedRepetitions
+		};
+	}
+};
+function parseBoundedInteger(raw, fallback, minimum, maximum) {
+	if (raw === void 0 || raw.trim() === "") return fallback;
+	const value = Number(raw);
+	return Number.isSafeInteger(value) && value >= minimum && value <= maximum ? value : fallback;
+}
+function canonicalJson(value) {
+	const normalized = normalizeJson(value);
+	return JSON.stringify(normalized) ?? "undefined";
+}
+function normalizeJson(value) {
+	if (Array.isArray(value)) return value.map(normalizeJson);
+	if (value === null || typeof value !== "object") return value;
+	const record = value;
+	return Object.fromEntries(Object.keys(record).toSorted().map((key) => [key, normalizeJson(record[key])]));
+}
+//#endregion
 //#region src/tui/controllers/session-event-handler.ts
 const MANAGED_TELEGRAM_MCP_SERVER = "plugin-telegram:telegram";
 function isManagedTelegramMissingTokenFailure(server) {
@@ -503667,6 +503827,7 @@ function isManagedTelegramMissingTokenFailure(server) {
 var SessionEventHandler = class {
 	host;
 	subAgentEventHandler;
+	turnWatchdog;
 	constructor(host) {
 		this.host = host;
 		this.subAgentEventHandler = new SubAgentEventHandler(host, {
@@ -503676,6 +503837,10 @@ var SessionEventHandler = class {
 				this.syncBackgroundTaskBadge();
 			}
 		});
+		this.turnWatchdog = new TurnWatchdogController({
+			onIdle: (snapshot) => this.reportWatchdogIdle(snapshot),
+			onAbort: (snapshot) => this.abortWatchdogLoop(snapshot)
+		});
 	}
 	backgroundTasks = /* @__PURE__ */ new Map();
 	backgroundTaskTranscriptedTerminal = /* @__PURE__ */ new Set();
@@ -503695,6 +503860,7 @@ var SessionEventHandler = class {
 	queuedGoalPromotionTimer;
 	lastCompactionInstruction;
 	resetRuntimeState() {
+		this.turnWatchdog.stop();
 		this.backgroundTasks.clear();
 		this.backgroundTaskTranscriptedTerminal.clear();
 		this.subAgentEventHandler.resetRuntimeState();
@@ -503880,6 +504046,7 @@ var SessionEventHandler = class {
 		this.mcpServerStatusSpinners.clear();
 	}
 	handleTurnBegin(event) {
+		this.turnWatchdog.start();
 		const sessionId = this.host.session?.id;
 		if (sessionId !== void 0) bindPersonalMemoryRememberIntentTurn(sessionId, event.turnId);
 		this.currentTurnHasAssistantText = false;
@@ -503918,6 +504085,7 @@ var SessionEventHandler = class {
 		});
 	}
 	handleTurnEnd(event, sendQueued) {
+		this.turnWatchdog.stop();
 		this.host.restoreQueuedSteerAtTurnEnd(event.turnId);
 		const sessionId = this.host.session?.id;
 		if (sessionId !== void 0) finishPersonalMemoryRememberIntentTurn(sessionId, event.turnId);
@@ -504062,6 +504230,7 @@ var SessionEventHandler = class {
 		});
 	}
 	handleToolCall(event) {
+		this.turnWatchdog.recordToolCall(event.toolCallId, event.name, event.args);
 		const { streamingUI } = this.host;
 		streamingUI.flushNow();
 		const { turnId, step } = streamingUI.getTurnContext();
@@ -504111,6 +504280,7 @@ var SessionEventHandler = class {
 		if (event.update.kind === "stdout" || event.update.kind === "stderr") tc.appendLiveOutput(text);
 	}
 	handleToolResult(event) {
+		this.turnWatchdog.recordToolResult(event.toolCallId, event.isError === true);
 		const { streamingUI } = this.host;
 		streamingUI.flushNow();
 		const resultData = {
@@ -504134,6 +504304,26 @@ var SessionEventHandler = class {
 		}
 		this.host.patchLivePane({ mode: "waiting" });
 	}
+	reportWatchdogIdle(snapshot) {
+		const message = uiText("sessionEvent.watchdog.idle", {
+			minutes: snapshot.elapsedMinutes,
+			tool: snapshot.lastToolName,
+			repetitions: snapshot.failedRepetitions
+		});
+		this.host.showStatus(message, "warning");
+		this.host.sendChannelTurnStatus?.(message);
+	}
+	abortWatchdogLoop(snapshot) {
+		const message = uiText("sessionEvent.watchdog.aborted", {
+			tool: snapshot.lastToolName,
+			repetitions: snapshot.failedRepetitions
+		});
+		this.host.showError(message);
+		this.host.sendChannelTurnStatus?.(message);
+		this.host.session?.cancel().catch((error) => {
+			this.host.showError(formatErrorMessage$2(error));
+		});
+	}
 	handleStatusUpdate(event) {
 		const shouldRenderSwarmEnded = event.swarmMode === false && this.host.state.appState.swarmMode && this.host.state.appState.swarmModeEntry === "task";
 		const patch = {};
@@ -512816,6 +513006,13 @@ var BlunTUI = class {
 			this.showError(uiText("blunTui.session.sendFailed", { error: "Telegram media" }));
 		});
 	}
+	sendChannelTurnStatus(message) {
+		const guard = this.pendingChannelReplyGuard;
+		if (guard === void 0) return;
+		sendReplyFallback(guard.chatId, message, guard.contextOnly).then((sent) => {
+			if (sent && this.pendingChannelReplyGuard === guard) guard.outboxMarker = outboxMarker();
+		});
+	}
 	runChannelReplyFallback(reason) {
 		const guard = this.pendingChannelReplyGuard;
 		if (guard === void 0) return;

package/package.json

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