blun-king-cli 9.1.45 → 9.1.47

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.45
+  npm install -g blun-king-cli@9.1.47
 
 Start
 -----

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.45
+npm install -g blun-king-cli@9.1.47
 ```
 
 ## Reproduzierbares Staging und Packen

package/blun.mjs

@@ -75557,6 +75557,9 @@ var init_full = __esmMin((() => {
 					const estimatedProgressPercent = estimateCompactionProgressPercent(stage, estimatedStageCount);
 					const windowUsagePercent = estimateCompactionWindowUsagePercent(estimatedCompactionRequestTokens, compactionRequestLimit);
 					this.agent.log.info("compaction stage request", {
+						requestPurpose: "compaction",
+						toolSuppressionReason: "compaction_summary",
+						selectedToolCount: compactionTools.length,
 						source: data.source,
 						stage,
 						estimatedStageCount,
@@ -76582,6 +76585,24 @@ var init_jitter = __esmMin((() => {
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/cron/scheduler.ts
+function sessionLoopIntervalMs(task) {
+	if (task.owner !== "session-loop" || typeof task.loopInterval !== "string") return null;
+	if (task.loopInterval === "auto") return 15 * 6e4;
+	const match = /^([1-9]\d*)(m|h|d)$/i.exec(task.loopInterval);
+	if (match === null) return null;
+	const amount = Number(match[1]);
+	const unit = match[2]?.toLowerCase();
+	const multiplier = unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+	const intervalMs = amount * multiplier;
+	return Number.isSafeInteger(intervalMs) ? intervalMs : null;
+}
+function countSessionLoopCoalesced(intervalMs, firstFireMs, nowMs) {
+	const count = Math.max(1, Math.min(MAX_COALESCE_ITERATIONS, Math.floor((nowMs - firstFireMs) / intervalMs) + 1));
+	return {
+		count,
+		lastDueMs: firstFireMs + (count - 1) * intervalMs
+	};
+}
 function createCronScheduler(opts) {
 	const { clocks, source, onFire, isIdle, isKilled, removeOneShot, onAdvanceCursor, pollIntervalMs } = opts;
 	const parsedCache = /* @__PURE__ */ new Map();
@@ -76605,6 +76626,8 @@ function createCronScheduler(opts) {
 	* the search budget (legal-but-never-fires expression).
 	*/
 	function computeJitteredNext(task, parsed, baseMs) {
+		const intervalMs = sessionLoopIntervalMs(task);
+		if (intervalMs !== null) return baseMs + intervalMs;
 		const ideal = computeNextCronRun(parsed, baseMs);
 		if (ideal === null) return null;
 		if (task.recurring === false) return oneShotJitteredNextCronRunMs(task, ideal);
@@ -76668,11 +76691,12 @@ function createCronScheduler(opts) {
 				const nextFireAt = computeJitteredNext(task, parsed, baseFromMs);
 				if (nextFireAt === null) continue;
 				if (now < nextFireAt) continue;
-				const ideal = computeNextCronRun(parsed, baseFromMs);
+				const intervalMs = sessionLoopIntervalMs(task);
+				const ideal = intervalMs === null ? computeNextCronRun(parsed, baseFromMs) : nextFireAt;
 				let coalescedCount = 1;
 				let lastDueMs = null;
 				if (task.recurring !== false && ideal !== null) {
-					const result = countCoalesced(task, parsed, ideal, now);
+					const result = intervalMs === null ? countCoalesced(task, parsed, ideal, now) : countSessionLoopCoalesced(intervalMs, ideal, now);
 					coalescedCount = Math.max(1, result.count);
 					lastDueMs = result.lastDueMs;
 				}
@@ -77632,6 +77656,10 @@ var init_cron_create = __esmMin((() => {
 //#endregion
 //#region ../../packages/agent-core/src/agent/session-loop.ts
 function parseLoopInterval(rawInterval) {
+	if (rawInterval.trim().toLowerCase() === "auto") return {
+		interval: "auto",
+		cron: "* * * * *"
+	};
 	const match = LOOP_INTERVAL_PATTERN.exec(rawInterval.trim());
 	if (match === null) throw invalidLoopInterval(rawInterval);
 	const amount = Number(match[1]);
@@ -77639,25 +77667,13 @@ function parseLoopInterval(rawInterval) {
 	if (!Number.isSafeInteger(amount)) throw invalidLoopInterval(rawInterval);
 	const totalMinutes = unit === "m" ? amount : unit === "h" ? amount * 60 : amount * 1440;
 	if (!Number.isSafeInteger(totalMinutes)) throw invalidLoopInterval(rawInterval);
-	if (totalMinutes === 1440) return {
-		interval: "1d",
-		cron: "0 0 * * *"
-	};
-	if (totalMinutes < 60 && 60 % totalMinutes === 0) return {
-		interval: `${String(totalMinutes)}m`,
-		cron: totalMinutes === 1 ? "* * * * *" : `*/${String(totalMinutes)} * * * *`
+	return {
+		interval: `${String(amount)}${unit}`,
+		cron: "* * * * *"
 	};
-	if (totalMinutes < 1440 && totalMinutes % 60 === 0) {
-		const hours = totalMinutes / 60;
-		if (24 % hours === 0) return {
-			interval: `${String(hours)}h`,
-			cron: hours === 1 ? "0 * * * *" : `0 */${String(hours)} * * *`
-		};
-	}
-	throw invalidLoopInterval(rawInterval);
 }
 function invalidLoopInterval(rawInterval) {
-	return new BlunError(ErrorCodes.LOOP_INTERVAL_INVALID, `Invalid loop interval ${JSON.stringify(rawInterval)}; use an exact cron cadence such as 1m, 5m, 15m, 1h, 6h, or 1d`);
+	return new BlunError(ErrorCodes.LOOP_INTERVAL_INVALID, `Invalid loop interval ${JSON.stringify(rawInterval)}`);
 }
 var MAX_LOOP_PROMPT_BYTES, LOOP_INTERVAL_PATTERN, SessionLoopMode;
 var init_session_loop = __esmMin((() => {
@@ -259739,6 +259755,12 @@ function blunSelectTurnTools(tools, maxContextTokens) {
 	const lean = tools.filter((tool) => BLUN_LEAN_TOOL_NAMES.has(tool.name) || BLUN_LEAN_KEEP_RE.test(tool.name));
 	return lean.length > 0 ? lean : tools;
 }
+function blunToolSuppressionReason(turnNeedsTools, eligibleTools, selectedTools) {
+	if (!turnNeedsTools) return "greeting_optimization";
+	if (eligibleTools.length === 0) return "no_eligible_tools";
+	if (selectedTools.length < eligibleTools.length) return "context_budget_lean_set";
+	return "none";
+}
 function isGoalOutcomeReminderOrigin(origin) {
 	return origin?.kind === "system_trigger" && (origin.name === "goal_completion" || origin.name === "goal_blocked");
 }
@@ -260553,6 +260575,13 @@ var init_turn = __esmMin((() => {
 				try {
 					const eligibleTools = blunToolsForOrigin(this.agent.injection.filterPersonalMemoryToolsForTurn(turnId, input, origin, this.agent.tools.loopTools), origin);
 					const selectedTools = turnNeedsTools ? blunSelectTurnTools(eligibleTools, this.agent.config.modelCapabilities?.max_context_tokens) : [];
+					const toolSuppressionReason = blunToolSuppressionReason(turnNeedsTools, eligibleTools, selectedTools);
+					this.agent.log.info("turn request tools", {
+						requestPurpose: "conversation",
+						toolSuppressionReason,
+						eligibleToolCount: eligibleTools.length,
+						selectedToolCount: selectedTools.length
+					});
 					return (await runTurn({
 						turnId: String(turnId),
 						signal,
@@ -401109,7 +401138,8 @@ const BUILTIN_SLASH_COMMAND_DEFINITIONS = [
 		aliases: [],
 		descriptionKey: "command.loop.description",
 		priority: 80,
-		argumentHint: "[interval] [prompt]",
+		argumentHint: "<natürlicher Auftrag>",
+		liveArgumentHint: loopInputHint,
 		availability: (args) => {
 			const trimmed = args.trim();
 			if (trimmed === "") return "always";
@@ -420058,7 +420088,8 @@ function isBusy(host) {
 }
 //#endregion
 //#region src/tui/commands/loop.ts
-const LOOP_ARGUMENT_HINT = "/loop [interval] [prompt]";
+const LOOP_ARGUMENT_HINT = "/loop <natürlicher Auftrag> · Zeitangaben dürfen überall stehen";
+const DEFAULT_LOOP_INTERVAL = "auto";
 const LOOP_CREATE_FILLERS = new Set([
 	"mit",
 	"alle",
@@ -420068,6 +420099,77 @@ const LOOP_CREATE_FILLERS = new Set([
 	"each"
 ]);
 const LOOP_INTERVAL_TOKEN = /^\d+(?:m|h|d)$/i;
+const LOOP_NATURAL_INTERVAL = /\b(?:alle|jede(?:n|r|s)?|every|each)\s+(\d+)\s*(min(?:ute)?n?|minutes?|stunden?|hours?|tage?|days?)\b/iu;
+const LOOP_NATURAL_HALF_HOUR = /\b(?:alle|jede(?:n|r|s)?|every|each)\s+(?:halbe|half(?:\s+an)?)\s+(?:stunde|hour)\b/iu;
+const LOOP_NATURAL_SINGLE_INTERVAL = /\b(?:jede(?:n|r|s)?|every|each)\s+(minute|stunde|hour|tag|day)\b/iu;
+const LOOP_NATURAL_ADVERB_INTERVAL = /\b(stündlich|stuendlich|hourly|täglich|taeglich|daily)\b/iu;
+const LOOP_SELF_CONTROLLED = /\b(?:selbst\s+entscheiden|selbstgesteuert)\b/iu;
+function naturalLoopIntervalMatch(args) {
+	const numeric = LOOP_NATURAL_INTERVAL.exec(args);
+	if (numeric !== null) {
+		const amount = numeric[1];
+		const unit = numeric[2]?.toLowerCase() ?? "";
+		const suffix = unit.startsWith("stund") || unit.startsWith("hour") ? "h" : unit.startsWith("tag") || unit.startsWith("day") ? "d" : "m";
+		return {
+			match: numeric,
+			interval: `${amount}${suffix}`
+		};
+	}
+	const halfHour = LOOP_NATURAL_HALF_HOUR.exec(args);
+	if (halfHour !== null) return {
+		match: halfHour,
+		interval: "30m"
+	};
+	const single = LOOP_NATURAL_SINGLE_INTERVAL.exec(args);
+	if (single !== null) {
+		const unit = single[1]?.toLowerCase() ?? "";
+		return {
+			match: single,
+			interval: unit === "minute" ? "1m" : unit === "tag" || unit === "day" ? "1d" : "1h"
+		};
+	}
+	const adverb = LOOP_NATURAL_ADVERB_INTERVAL.exec(args);
+	if (adverb !== null) {
+		const unit = adverb[1]?.toLowerCase() ?? "";
+		return {
+			match: adverb,
+			interval: unit === "täglich" || unit === "taeglich" || unit === "daily" ? "1d" : "1h"
+		};
+	}
+	return null;
+}
+function parseNaturalLoopInterval(args) {
+	const parsed = naturalLoopIntervalMatch(args);
+	if (parsed === null) return null;
+	const { match, interval } = parsed;
+	const prompt = `${args.slice(0, match.index)} ${args.slice(match.index + match[0].length)}`.replace(/\s+/gu, " ").trim();
+	if (prompt.length === 0) return { kind: "error" };
+	return {
+		kind: "create",
+		interval,
+		prompt
+	};
+}
+function naturalLoopIntervalText(interval) {
+	if (interval === "auto") return "Selbstgesteuert";
+	const match = /^([1-9]\d*)(m|h|d)$/i.exec(interval);
+	if (match === null) return "";
+	const amount = Number(match[1]);
+	const unit = match[2]?.toLowerCase();
+	if (unit === "m") return `Erkannt: alle ${String(amount)} ${amount === 1 ? "Minute" : "Minuten"}`;
+	if (unit === "h") return `Erkannt: alle ${String(amount)} ${amount === 1 ? "Stunde" : "Stunden"}`;
+	return `Erkannt: alle ${String(amount)} ${amount === 1 ? "Tag" : "Tage"}`;
+}
+function loopInputHint(rawArgs) {
+	const args = rawArgs.trim();
+	if (args.length === 0) return "Natürlichen Auftrag eingeben; Zeitangaben dürfen überall stehen";
+	if (/^(?:status|pause|paused|resume|stop)$/i.test(args)) return "";
+	const natural = naturalLoopIntervalMatch(args);
+	if (natural !== null) return naturalLoopIntervalText(natural.interval);
+	const explicit = /^(?:start\s+)?([1-9]\d*(?:m|h|d))\b/i.exec(args);
+	if (explicit?.[1] !== void 0) return naturalLoopIntervalText(explicit[1].toLowerCase());
+	return "Selbstgesteuert";
+}
 function parseLoopCommand(rawArgs) {
 	const args = rawArgs.trim();
 	if (args.length === 0 || args.toLowerCase() === "status") return { kind: "status" };
@@ -420079,13 +420181,35 @@ function parseLoopCommand(rawArgs) {
 		if (action === "stop") return { kind: "stop" };
 	}
 	let startIndex = action === "start" ? 1 : 0;
+	const createArgs = tokens.slice(startIndex).join(" ");
+	const natural = parseNaturalLoopInterval(createArgs);
+	if (natural !== null) return natural;
+	const selfControlled = LOOP_SELF_CONTROLLED.exec(createArgs);
+	if (selfControlled !== null) {
+		const prompt = `${createArgs.slice(0, selfControlled.index)} ${createArgs.slice(selfControlled.index + selfControlled[0].length)}`.replace(/\s+/gu, " ").trim();
+		if (prompt.length === 0) return { kind: "error" };
+		return {
+			kind: "create",
+			interval: "auto",
+			prompt
+		};
+	}
 	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 || !LOOP_INTERVAL_TOKEN.test(interval) || prompt.length === 0) return { kind: "error" };
+	if (interval !== void 0 && LOOP_INTERVAL_TOKEN.test(interval)) {
+		const prompt = tokens.slice(startIndex + 1).join(" ").trim();
+		if (prompt.length === 0) return { kind: "error" };
+		return {
+			kind: "create",
+			interval,
+			prompt
+		};
+	}
+	const prompt = tokens.slice(startIndex).join(" ").trim();
+	if (prompt.length === 0) return { kind: "error" };
 	return {
 		kind: "create",
-		interval,
+		interval: DEFAULT_LOOP_INTERVAL,
 		prompt
 	};
 }
@@ -501930,6 +502054,9 @@ var PersonalMemoryController = class {
 };
 //#endregion
 //#region src/tui/constant/scrollback.ts
+function shouldEnableScrollbackMouseTracking(buffer) {
+	return buffer !== void 0 && buffer.isActive();
+}
 const ENABLE_SCROLLBACK_MOUSE_TRACKING = "\x1B[?1000h\x1B[?1006h";
 const DISABLE_SCROLLBACK_MOUSE_TRACKING = "\x1B[?1000l\x1B[?1006l";
 //#endregion
@@ -502286,7 +502413,7 @@ var BottomPinnedTUI = class extends TUI {
 			}
 			const buffer = this.scrollbackBuffer;
 			buffer?.updateSnapshot(clipped, scrollViewportRows);
-			this.setMouseTracking(buffer !== void 0 && buffer.totalLines > 0);
+			this.setMouseTracking(shouldEnableScrollbackMouseTracking(buffer));
 			if (buffer !== void 0 && buffer.isActive() && terminalRows > 0) {
 				const pinnedLines = [];
 				for (let i = chromeAt; i < blocks.length; i++) {
@@ -510056,8 +510183,10 @@ var CustomEditor = class extends Editor {
 	consumingPaste = false;
 	consumeBuffer = "";
 	argumentHints = /* @__PURE__ */ new Map();
-	setArgumentHints(hints) {
+	argumentHintResolvers = /* @__PURE__ */ new Map();
+	setArgumentHints(hints, resolvers = /* @__PURE__ */ new Map()) {
 		this.argumentHints = hints;
+		this.argumentHintResolvers = resolvers;
 	}
 	constructor(tui, options = {}) {
 		const theme = createEditorTheme();
@@ -510151,12 +510280,18 @@ var CustomEditor = class extends Editor {
 	computeArgumentHint() {
 		if (this.inputMode === "bash") return void 0;
 		const text = this.getText();
-		const match = /^\/(\S+)( ?)$/.exec(text);
+		const match = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(text);
 		if (match === null) return void 0;
 		const cmd = match[1];
-		const trailingSpace = match[2] ?? "";
+		const args = match[2] ?? "";
+		const trailingSpace = text.endsWith(" ") ? " " : "";
 		if (cmd === void 0) return void 0;
 		if (this.hasAutocompleteActivity() && trailingSpace.length === 0) return void 0;
+		const resolver = this.argumentHintResolvers.get(cmd);
+		if (resolver !== void 0) {
+			const resolved = resolver(args);
+			if (resolved.length > 0) return args.length > 0 ? ` · ${resolved}` : ` ${resolved}`;
+		}
 		const hint = this.argumentHints.get(cmd);
 		if (hint === void 0) return void 0;
 		const { line, col } = this.getCursor();
@@ -512061,20 +512196,26 @@ var BlunTUI = class {
 				aliases: cmd.aliases,
 				description: cmd.description,
 				...cmd.argumentHint !== void 0 ? { argumentHint: cmd.argumentHint } : {},
+				...cmd.liveArgumentHint !== void 0 ? { liveArgumentHint: cmd.liveArgumentHint } : {},
 				...completer !== void 0 ? { getArgumentCompletions: (prefix) => completer(prefix) } : {}
 			};
 		});
 		const provider = new FileMentionProvider(slashCommands, this.state.appState.workDir, this.fdPath, this.state.appState.additionalDirs, () => this.state.appState.inputMode, this.mentionFileSearch);
 		this.state.editor.setAutocompleteProvider(provider);
 		const argumentHints = /* @__PURE__ */ new Map();
+		const argumentHintResolvers = /* @__PURE__ */ new Map();
 		for (const cmd of slashCommands) {
 			if (cmd.argumentHint === void 0) continue;
 			const visibleHint = cmd.description?.trim();
 			if (visibleHint === void 0 || visibleHint.length === 0) continue;
 			argumentHints.set(cmd.name, visibleHint);
 			for (const alias of cmd.aliases ?? []) argumentHints.set(alias, visibleHint);
+			if (cmd.liveArgumentHint !== void 0) {
+				argumentHintResolvers.set(cmd.name, cmd.liveArgumentHint);
+				for (const alias of cmd.aliases ?? []) argumentHintResolvers.set(alias, cmd.liveArgumentHint);
+			}
 		}
-		this.state.editor.setArgumentHints(argumentHints);
+		this.state.editor.setArgumentHints(argumentHints, argumentHintResolvers);
 	}
 	refreshSlashCommandAutocomplete() {
 		this.setupAutocomplete();
@@ -514681,16 +514822,44 @@ function readTelegramUpdateRecipients(stateDir = defaultTelegramStateDir()) {
 		return [];
 	}
 }
+function claimTelegramUpdateNotice(version, chatId, receiptDir = join(homedir(), ".blun", "updates", "telegram-notices")) {
+	const safeVersion = version.trim().replace(/[^0-9A-Za-z._-]/gu, "_").slice(0, 64);
+	if (safeVersion.length === 0 || !TELEGRAM_DM_ID.test(chatId)) return null;
+	const receiptPath = join(receiptDir, `${safeVersion}-${chatId}.sent`);
+	try {
+		mkdirSync(receiptDir, {
+			recursive: true,
+			mode: 448
+		});
+		writeFileSync(receiptPath, `${(/* @__PURE__ */ new Date()).toISOString()}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		return receiptPath;
+	} catch {
+		return null;
+	}
+}
 async function sendTelegramUpdateNotice(text, options = {}) {
 	const stateDir = options.stateDir ?? defaultTelegramStateDir();
 	const configured = hasConfiguredToken(stateDir);
 	const recipients = configured ? readTelegramUpdateRecipients(stateDir) : [];
 	const send = options.send ?? ((chatId, message) => sendReplyFallback(chatId, message));
 	let sent = 0;
-	for (const chatId of recipients) if (await send(chatId, text).catch(() => false)) sent += 1;
+	let attempted = 0;
+	for (const chatId of recipients) {
+		const receiptPath = options.version === void 0 ? void 0 : claimTelegramUpdateNotice(options.version, chatId, options.receiptDir);
+		if (options.version !== void 0 && receiptPath === null) continue;
+		attempted += 1;
+		if (await send(chatId, text).catch(() => false)) sent += 1;
+		else if (receiptPath !== void 0) try {
+			unlinkSync(receiptPath);
+		} catch {}
+	}
 	return {
 		configured,
-		attempted: recipients.length,
+		attempted,
 		sent
 	};
 }
@@ -514843,7 +515012,7 @@ async function runShell(opts, version, updateStartupNotice) {
 		workDir,
 		startupNotice: configWarning,
 		onStartupNoticeShown: updateStartupNotice === void 0 || updateNoticeText === void 0 ? void 0 : async () => {
-			const delivery = await sendTelegramUpdateNotice(updateNoticeText);
+			const delivery = await sendTelegramUpdateNotice(updateNoticeText, { version: updateStartupNotice.details.version });
 			if (!delivery.configured || delivery.attempted === 0 || delivery.sent === delivery.attempted) await updateStartupNotice.acknowledge();
 		}
 	});

package/package.json

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