blun-king-cli 9.1.38 → 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:e0036ad7d958609c5cf630953c5e1b6b6ec22fda3e8c09f26e7c97767acf846b
+// 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);
@@ -258794,7 +258794,7 @@ var init_read_media = __esmMin((() => {
 //#region ../../packages/agent-core/src/tools/builtin/file/write.md?raw
 var write_default;
 var init_write$1 = __esmMin((() => {
-	write_default = "Create, append to, or replace a file entirely.\n\n- Missing parent directories are created automatically (like `mkdir(parents=True, exist_ok=True)`).\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\n- Do not create unsolicited documentation files (`*.md` write-ups, `README`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\n- Read before overwriting an existing file.\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\n- Write outputs content literally, including supplied line endings: \\n stays LF, \\r\\n stays CRLF.\n- Source files may contain at most 500 lines. Split larger implementations into focused files; append cannot bypass the limit.\n- Set `single_file_override=true` only when the latest direct user message explicitly requires one single file. The accepted override is reported visibly.\n- For non-source content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\n- Runaway generated JavaScript/TypeScript identifiers are rejected before disk I/O. Regenerate only the affected section as a smaller focused chunk.\n";
+	write_default = "Create, append to, or replace a file entirely.\n\n- Missing parent directories are created automatically (like `mkdir(parents=True, exist_ok=True)`).\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\n- Do not create unsolicited documentation files (`*.md` write-ups, `README`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\n- Read before overwriting an existing file.\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\n- Write outputs content literally, including supplied line endings: \\n stays LF, \\r\\n stays CRLF.\n- Source files may contain at most 500 lines. Split larger implementations into focused files; append cannot bypass the limit.\n- Set `single_file_override=true` only when the latest direct user message explicitly requires one single file. The accepted override is reported visibly.\n- For any new or completely replaced file with content too large for one call, use `continuation`. Keep each chunk at or below the configured limit. The default is 2,048 UTF-8 bytes, a conservative safety margin for unstable model output rather than a measured hard model limit; operators can set `BLUN_WRITE_CONTINUATION_MAX_BYTES` from 512 through 16,384. End every chunk on a complete line with `\\n`. Set the exact final `expected_lines`; include `expected_sha256` when a source hash is available. Use overwrite and `start_line=1` for the first chunk, then use append for every later chunk and copy the exact `next_start_line` returned by the previous Write result; never continue from a planned boundary. Use consecutive part numbers. The target file remains unchanged until the final line-count and optional SHA-256 checks pass. To discard an unfinished sequence, restart with part 1, overwrite, `start_line=1`, and `reset=true`.\n- Never use continuation to modify an existing file incrementally. Use Edit for incremental changes.\n- Runaway generated JavaScript/TypeScript identifiers are rejected before disk I/O. Regenerate only the affected section as a smaller focused chunk.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/generated-source-health.ts
@@ -258904,7 +258904,22 @@ var init_generated_source_health = __esmMin((() => {
 		".ts",
 		".tsx"
 	]);
-})), S_IFMT, S_IFDIR, WriteInputSchema, WriteTool;
+}));
+//#endregion
+//#region ../../packages/agent-core/src/tools/builtin/file/write.ts
+function resolveWriteContinuationChunkBytes(env = process.env) {
+	const raw = env[CONTINUATION_CHUNK_BYTES_ENV]?.trim();
+	if (raw === void 0 || raw === "") return DEFAULT_CONTINUATION_CHUNK_BYTES;
+	const parsed = Number(raw);
+	if (!Number.isSafeInteger(parsed) || parsed < MIN_CONTINUATION_CHUNK_BYTES || parsed > MAX_CONTINUATION_CHUNK_BYTES) throw new Error(`${CONTINUATION_CHUNK_BYTES_ENV} must be an integer between ${String(MIN_CONTINUATION_CHUNK_BYTES)} and ${String(MAX_CONTINUATION_CHUNK_BYTES)} bytes; received ${JSON.stringify(raw)}.`);
+	return parsed;
+}
+function countCompletedLines(content) {
+	let count = 0;
+	for (const character of content) if (character === "\n") count += 1;
+	return count;
+}
+var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool;
 var init_write = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -258918,11 +258933,24 @@ var init_write = __esmMin((() => {
 	init_lsp_diagnostics();
 	S_IFMT = 61440;
 	S_IFDIR = 16384;
+	DEFAULT_CONTINUATION_CHUNK_BYTES = 2048;
+	MIN_CONTINUATION_CHUNK_BYTES = 512;
+	MAX_CONTINUATION_CHUNK_BYTES = 16384;
+	CONTINUATION_CHUNK_BYTES_ENV = "BLUN_WRITE_CONTINUATION_MAX_BYTES";
+	WriteContinuationSchema = object({
+		part: number$1().int().positive().describe("One-based chunk number. Start with 1 and increment by exactly one."),
+		start_line: number$1().int().positive().describe("One-based line where this chunk starts. Use 1 for part 1; for every later part, copy next_start_line from the preceding tool result instead of using a planned boundary."),
+		expected_lines: number$1().int().positive().describe("Exact completed-line count expected in the final file."),
+		final: boolean$1().describe("Set true only for the last chunk, when the complete file is present."),
+		expected_sha256: string().regex(/^[0-9a-f]{64}$/i).optional().describe("Optional SHA-256 of the complete expected file for byte-for-byte verification."),
+		reset: boolean$1().optional().describe("Set true only with part 1 and overwrite to discard an unfinished staged write.")
+	});
 	WriteInputSchema = object({
 		path: string().describe("Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically."),
 		content: string().describe("Raw full file content to write exactly as provided. This does not use the Read/Edit text view."),
 		mode: _enum(["overwrite", "append"]).optional().describe("Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline."),
-		single_file_override: boolean$1().optional().describe("Set true only when the latest direct user message explicitly requires one single source file. The tool verifies that request and reports the override visibly.")
+		single_file_override: boolean$1().optional().describe("Set true only when the latest direct user message explicitly requires one single source file. The tool verifies that request and reports the override visibly."),
+		continuation: WriteContinuationSchema.optional().describe("Safe long-write protocol. Split generated files into complete-line chunks within the configured limit (2,048 UTF-8 bytes by default; operator override BLUN_WRITE_CONTINUATION_MAX_BYTES). Part 1 uses overwrite and start_line=1; later parts use append and the exact next_start_line returned by the previous call. The target file is changed only after the final line-count and optional SHA-256 checks pass.")
 	});
 	object({ 
 	/** Number of UTF-8 bytes written to disk by this call. */
@@ -258932,14 +258960,17 @@ bytesWritten: number$1().int().nonnegative() });
 		workspace;
 		history;
 		lsp;
+		maxContinuationChunkBytes;
 		name = "Write";
 		description = write_default;
 		parameters = toInputJsonSchema(WriteInputSchema);
-		constructor(kaos, workspace, history, lsp) {
+		pendingContinuations = /* @__PURE__ */ new Map();
+		constructor(kaos, workspace, history, lsp, maxContinuationChunkBytes = resolveWriteContinuationChunkBytes()) {
 			this.kaos = kaos;
 			this.workspace = workspace;
 			this.history = history;
 			this.lsp = lsp;
+			this.maxContinuationChunkBytes = maxContinuationChunkBytes;
 		}
 		resolveExecution(args) {
 			const path = resolvePathAccessPath(args.path, {
@@ -258962,10 +258993,133 @@ bytesWritten: number$1().int().nonnegative() });
 					pathClass: this.kaos.pathClass(),
 					homeDir: this.kaos.gethome()
 				}),
-				execute: () => this.execution(args, path)
+				execute: (ctx) => this.execution(args, path, ctx)
 			};
 		}
-		async execution(args, safePath) {
+		async execution(args, safePath, ctx) {
+			if (args.continuation !== void 0) return this.continueWrite(args, safePath, ctx);
+			if (this.pendingContinuations.has(safePath)) return {
+				isError: true,
+				output: `Refused to write ${args.path}: a long-write continuation is active for this path. Resume it with the next numbered continuation part. No file was written.`
+			};
+			return this.writeContent(args, safePath);
+		}
+		async continueWrite(args, safePath, ctx) {
+			const continuation = args.continuation;
+			if (continuation === void 0) throw new Error("continuation is required");
+			const mode = args.mode ?? "overwrite";
+			const chunkBytes = Buffer.byteLength(args.content, "utf8");
+			if (chunkBytes > this.maxContinuationChunkBytes) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: chunks may contain at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} UTF-8 bytes (${String(chunkBytes)} received). No content was staged and no file was written.`
+			};
+			if (args.content.length === 0 || !args.content.endsWith("\n")) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: every chunk must end on a complete line with a newline. No content was staged and no file was written.`
+			};
+			if (continuation.reset === true && (continuation.part !== 1 || mode !== "overwrite")) return {
+				isError: true,
+				output: `Refused continuation reset for ${args.path}: reset requires part 1 with mode=overwrite. No content was staged and no file was written.`
+			};
+			if (continuation.reset === true) this.pendingContinuations.delete(safePath);
+			const current = this.pendingContinuations.get(safePath);
+			const expectedPart = current === void 0 ? 1 : current.chunks.length + 1;
+			if (continuation.part !== expectedPart) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected part ${String(expectedPart)}. No content was staged and no file was written.`
+			};
+			const expectedStartLine = (current?.completedLines ?? 0) + 1;
+			if (continuation.start_line !== expectedStartLine) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected start_line ${String(expectedStartLine)} from the actually staged content, received ${String(continuation.start_line)}. No content was staged and no file was written.`
+			};
+			if (continuation.part === 1 && mode !== "overwrite" || continuation.part > 1 && mode !== "append") return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: part 1 must use overwrite and later parts must use append. No content was staged and no file was written.`
+			};
+			if (current !== void 0 && continuation.expected_lines !== current.expectedLines) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected_lines changed from ${String(current.expectedLines)} to ${String(continuation.expected_lines)}. No content was staged and no file was written.`
+			};
+			const expectedSha256 = continuation.expected_sha256?.toLowerCase();
+			if (current?.expectedSha256 !== void 0 && expectedSha256 !== void 0 && expectedSha256 !== current.expectedSha256) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected_sha256 changed between parts. No content was staged and no file was written.`
+			};
+			const chunkLines = countCompletedLines(args.content);
+			const completedBefore = current?.completedLines ?? 0;
+			const completedLines = completedBefore + chunkLines;
+			if (completedLines > continuation.expected_lines) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: it would stage ${String(completedLines)} lines, exceeding the expected ${String(continuation.expected_lines)}. No content was staged and no file was written.`
+			};
+			if (!continuation.final && completedLines === continuation.expected_lines) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: all ${String(completedLines)} expected lines are present but final is false. Retry this part with final=true. No content was staged and no file was written.`
+			};
+			if (continuation.final && completedLines !== continuation.expected_lines) return {
+				isError: true,
+				output: `Refused final continuation part ${String(continuation.part)} for ${args.path}: expected ${String(continuation.expected_lines)} lines but would have ${String(completedLines)}. No content was staged and no file was written.`
+			};
+			const startLine = completedBefore + 1;
+			const boundary = `${String(startLine)}-${String(completedLines)}`;
+			const chunks = [...current?.chunks ?? [], args.content];
+			const boundaries = [...current?.boundaries ?? [], boundary];
+			const totalBytes = (current?.bytes ?? 0) + chunkBytes;
+			const stableExpectedSha256 = current?.expectedSha256 ?? expectedSha256;
+			const staged = {
+				expectedLines: continuation.expected_lines,
+				expectedSha256: stableExpectedSha256,
+				chunks,
+				boundaries,
+				completedLines,
+				bytes: totalBytes
+			};
+			const percent = Math.floor(completedLines / continuation.expected_lines * 100);
+			ctx?.onUpdate?.({
+				kind: "progress",
+				text: `Write continuation ${String(continuation.part)}: lines ${boundary}`,
+				percent
+			});
+			if (!continuation.final) {
+				this.pendingContinuations.set(safePath, staged);
+				return { output: `Write continuation part ${String(continuation.part)} staged lines ${boundary} of ${String(continuation.expected_lines)} (${String(percent)}%, ${String(chunkBytes)} bytes). Target unchanged. Continue with mode=append, part=${String(continuation.part + 1)}, next_start_line=${String(completedLines + 1)}.` };
+			}
+			const content = chunks.join("");
+			const actualSha256 = createHash("sha256").update(content).digest("hex");
+			if (stableExpectedSha256 !== void 0 && actualSha256 !== stableExpectedSha256) return {
+				isError: true,
+				output: `Refused final continuation part ${String(continuation.part)} for ${args.path}: SHA-256 mismatch (expected ${stableExpectedSha256}, got ${actualSha256}). No file was written; the first ${String(current?.completedLines ?? 0)} staged lines remain available for retry.`
+			};
+			const result = await this.writeContent({
+				...args,
+				content,
+				mode: "overwrite",
+				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 {
+				...result,
+				output: `Write continuation complete: ${String(completedLines)} lines, ${String(totalBytes)} bytes, SHA-256 ${actualSha256}. Chunk boundaries: ${boundaries.join(", ")}. ${writeOutput}`
+			};
+		}
+		async writeContent(args, safePath, allowLargeContent = false) {
 			const mode = args.mode ?? "overwrite";
 			const degenerateIdentifier = findDegenerateGeneratedIdentifier(safePath, args.content);
 			if (degenerateIdentifier !== null) return {
@@ -258991,6 +259145,11 @@ bytesWritten: number$1().int().nonnegative() });
 				isError: true,
 				output: lineLimit.error
 			};
+			const contentBytes = Buffer.byteLength(args.content, "utf8");
+			if (!allowLargeContent && contentBytes > this.maxContinuationChunkBytes) return {
+				isError: true,
+				output: `Refused to write ${args.path}: the content is ${String(contentBytes)} UTF-8 bytes. Long generated writes must use the continuation protocol with complete-line chunks of at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} bytes. No file was written.`
+			};
 			const parentError = await this.ensureParentDirectory(safePath);
 			if (parentError !== void 0) return {
 				isError: true,
@@ -370083,7 +370242,7 @@ var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../../../node_modules/node-gyp-build/node-gyp-build.js
+//#region ../../../node_modules/node-gyp-build/node-gyp-build.js
 var require_node_gyp_build$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var fs$3 = __require("fs");
 	var path$5 = __require("path");
@@ -370239,14 +370398,14 @@ var require_node_gyp_build$1 = /* @__PURE__ */ __commonJSMin(((exports, module)
 	load.compareTuples = compareTuples;
 }));
 //#endregion
-//#region ../../../../node_modules/node-gyp-build/index.js
+//#region ../../../node_modules/node-gyp-build/index.js
 var require_node_gyp_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
 	if (typeof runtimeRequire.addon === "function") module.exports = runtimeRequire.addon.bind(runtimeRequire);
 	else module.exports = require_node_gyp_build$1();
 }));
 //#endregion
-//#region ../../../../node_modules/bufferutil/fallback.js
+//#region ../../../node_modules/bufferutil/fallback.js
 var require_fallback$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* Masks a buffer using the given mask.
@@ -370278,7 +370437,7 @@ var require_fallback$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../../../node_modules/bufferutil/index.js
+//#region ../../../node_modules/bufferutil/index.js
 var require_bufferutil = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	try {
 		module.exports = require_node_gyp_build()(__dirname);
@@ -370771,7 +370930,7 @@ var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module
 	}
 }));
 //#endregion
-//#region ../../../../node_modules/utf-8-validate/fallback.js
+//#region ../../../node_modules/utf-8-validate/fallback.js
 var require_fallback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* Checks if a given buffer contains only correct UTF-8.
@@ -370801,7 +370960,7 @@ var require_fallback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = isValidUTF8;
 }));
 //#endregion
-//#region ../../../../node_modules/utf-8-validate/index.js
+//#region ../../../node_modules/utf-8-validate/index.js
 var require_utf_8_validate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	try {
 		module.exports = require_node_gyp_build()(__dirname);
@@ -419855,6 +420014,15 @@ function isBusy(host) {
 //#endregion
 //#region src/tui/commands/loop.ts
 const LOOP_ARGUMENT_HINT = "/loop [interval] [prompt]";
+const LOOP_CREATE_FILLERS = new Set([
+	"mit",
+	"alle",
+	"jede",
+	"jeden",
+	"every",
+	"each"
+]);
+const LOOP_INTERVAL_TOKEN = /^\d+(?:m|h|d)$/i;
 function parseLoopCommand(rawArgs) {
 	const args = rawArgs.trim();
 	if (args.length === 0 || args.toLowerCase() === "status") return { kind: "status" };
@@ -419865,10 +420033,11 @@ function parseLoopCommand(rawArgs) {
 		if (action === "resume") return { kind: "resume" };
 		if (action === "stop") return { kind: "stop" };
 	}
-	const startIndex = action === "start" ? 1 : 0;
+	let startIndex = action === "start" ? 1 : 0;
+	if (LOOP_CREATE_FILLERS.has(tokens[startIndex]?.toLowerCase() ?? "")) startIndex += 1;
 	const interval = tokens[startIndex];
 	const prompt = tokens.slice(startIndex + 1).join(" ").trim();
-	if (interval === void 0 || prompt.length === 0) return { kind: "error" };
+	if (interval === void 0 || !LOOP_INTERVAL_TOKEN.test(interval) || prompt.length === 0) return { kind: "error" };
 	return {
 		kind: "create",
 		interval,
@@ -502227,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}",
@@ -502254,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}",
@@ -502281,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}",
@@ -502308,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}",
@@ -502335,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}",
@@ -502362,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
@@ -503504,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) {
@@ -503512,6 +503827,7 @@ function isManagedTelegramMissingTokenFailure(server) {
 var SessionEventHandler = class {
 	host;
 	subAgentEventHandler;
+	turnWatchdog;
 	constructor(host) {
 		this.host = host;
 		this.subAgentEventHandler = new SubAgentEventHandler(host, {
@@ -503521,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();
@@ -503540,6 +503860,7 @@ var SessionEventHandler = class {
 	queuedGoalPromotionTimer;
 	lastCompactionInstruction;
 	resetRuntimeState() {
+		this.turnWatchdog.stop();
 		this.backgroundTasks.clear();
 		this.backgroundTaskTranscriptedTerminal.clear();
 		this.subAgentEventHandler.resetRuntimeState();
@@ -503725,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;
@@ -503763,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);
@@ -503907,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();
@@ -503956,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 = {
@@ -503979,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 = {};
@@ -512661,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.38",
+  "version": "9.1.40",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {