blun-king-cli 9.1.193 → 9.1.195

package/bin/launcher-runtime.js

@@ -256,11 +256,23 @@ async function waitForRuntimeReady(core, timeoutMs = RUNTIME_READY_TIMEOUT_MS) {
   }
 }
 
+function resolveHandoffCwd(candidate, fallback) {
+  if (typeof candidate !== 'string' || candidate.trim().length === 0 || !path.isAbsolute(candidate)) {
+    return fallback;
+  }
+  try {
+    return fs.statSync(candidate).isDirectory() ? path.resolve(candidate) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
 async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {}) {
   const packageRoot = path.resolve(options.packageRoot || PKG);
   let preparedTarget;
   let handoffSessionId;
   let handoffMode;
+  let handoffCwd = cwd;
   let updateStarted = false;
   let runtimeReady = false;
   let runningUpdatePollTimer;
@@ -273,6 +285,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       runningUpdateMode = persistedMode;
       handoffSessionId = undefined;
       handoffMode = undefined;
+      handoffCwd = cwd;
     }
   };
   const clearRunningUpdatePoll = () => {
@@ -337,6 +350,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       runningUpdateMode = normalizeRunningUpdateMode(message.mode);
       handoffSessionId = undefined;
       handoffMode = undefined;
+      handoffCwd = cwd;
       clearRunningUpdatePoll();
       if (automaticMode()) {
         if (preparedTarget !== undefined) announcePrepared(child);
@@ -353,6 +367,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       && automaticMode()) {
       handoffSessionId = message.sessionId;
       handoffMode = runningUpdateMode;
+      handoffCwd = resolveHandoffCwd(message.cwd, cwd);
     }
   };
   const spawnCore = options.spawnProtectedCore || spawnProtectedCore;
@@ -394,7 +409,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       probeTarget: options.probeRunningUpdate || (() => true),
       stopOld: async () => {},
       startCore: async ({ packageRoot: nextRoot, args: nextArgs }) => {
-        const nextCore = spawnCore(nextArgs, env, cwd, { packageRoot: nextRoot });
+        const nextCore = spawnCore(nextArgs, env, handoffCwd, { packageRoot: nextRoot });
         const nextLoaded = await nextCore.loaded;
         const ready = nextLoaded && await waitForRuntimeReady(nextCore, options.readyTimeoutMs);
         if (!ready) {
@@ -408,7 +423,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     const resumed = handoff.core;
     if (resumed === undefined || resumed.ready !== true) return 1;
     const resumedArgs = handoffArgsForMode(args, handoffMode, handoffSessionId);
-    return superviseProtectedCore(resumedArgs, env, cwd, async () => {}, {
+    return superviseProtectedCore(resumedArgs, env, handoffCwd, async () => {}, {
       ...options,
       existingCore: resumed,
       packageRoot: handoff.runtime.packageRoot,
@@ -745,6 +760,7 @@ module.exports = {
   RUNNING_UPDATE_RECHECK_MS,
   createManagedNodeEnvironment,
   resolveLauncherPrivatePaths,
+  resolveHandoffCwd,
   runningUpdateRecheckDelay,
   runLauncher,
   scheduleRunningUpdateRecheck,

package/blun.mjs

@@ -505310,6 +505310,7 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.connecting": "MCP server \"{name}\" connecting…",
 		"sessionEvent.skill.activated": "Activated skill: {skillName}",
 		"sessionEvent.watchdog.idle": "Turn running for {minutes} min; last tool: {tool}; repeated failures: {repetitions}.",
+		"sessionEvent.watchdog.timeout": "Turn stopped after {minutes} min without progress; last tool: {tool}.",
 		"sessionEvent.watchdog.aborted": "Turn stopped after {repetitions} repeated failed calls to {tool}."
 	},
 	de: {
@@ -505339,6 +505340,7 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.connecting": "MCP-Server „{name}“ wird verbunden…",
 		"sessionEvent.skill.activated": "Skill aktiviert: {skillName}",
 		"sessionEvent.watchdog.idle": "Zug läuft seit {minutes} Min.; letztes Werkzeug: {tool}; wiederholte Fehler: {repetitions}.",
+		"sessionEvent.watchdog.timeout": "Zug nach {minutes} Min. ohne Fortschritt beendet; letztes Werkzeug: {tool}.",
 		"sessionEvent.watchdog.aborted": "Zug nach {repetitions} wiederholten fehlgeschlagenen Aufrufen von {tool} beendet."
 	},
 	es: {
@@ -505368,6 +505370,7 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.connecting": "Conectando el servidor MCP «{name}»…",
 		"sessionEvent.skill.activated": "Skill activado: {skillName}",
 		"sessionEvent.watchdog.idle": "El turno lleva {minutes} min en curso; última herramienta: {tool}; fallos repetidos: {repetitions}.",
+		"sessionEvent.watchdog.timeout": "Turno detenido tras {minutes} min sin progreso; última herramienta: {tool}.",
 		"sessionEvent.watchdog.aborted": "Turno detenido tras {repetitions} llamadas fallidas repetidas a {tool}."
 	},
 	fr: {
@@ -505397,6 +505400,7 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.connecting": "Connexion du serveur MCP « {name} »…",
 		"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.timeout": "Tour arrêté après {minutes} min sans progression ; dernier outil : {tool}.",
 		"sessionEvent.watchdog.aborted": "Tour arrêté après {repetitions} appels répétés ayant échoué pour l'outil {tool}."
 	},
 	sv: {
@@ -505426,6 +505430,7 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.connecting": "Ansluter MCP-servern ”{name}”…",
 		"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.timeout": "Körningen stoppades efter {minutes} min utan framsteg. Senaste verktyg: {tool}.",
 		"sessionEvent.watchdog.aborted": "Körningen stoppades efter {repetitions} upprepade misslyckade anrop till {tool}."
 	},
 	cs: {
@@ -505455,6 +505460,7 @@ registerUiCatalogFragment({
 		"sessionEvent.mcp.connecting": "Server MCP \"{name}\" se připojuje…",
 		"sessionEvent.skill.activated": "Aktivována dovednost: {skillName}",
 		"sessionEvent.watchdog.idle": "Kolo běží {minutes} min; poslední nástroj: {tool}; opakovaná selhání: {repetitions}.",
+		"sessionEvent.watchdog.timeout": "Kolo bylo zastaveno po {minutes} min bez pokroku; poslední nástroj: {tool}.",
 		"sessionEvent.watchdog.aborted": "Kolo bylo zastaveno po {repetitions} opakovaných neúspěšných voláních nástroje {tool}."
 	}
 });
@@ -506606,18 +506612,22 @@ function isUserCancelledSubagentError(error) {
 //#endregion
 //#region src/tui/controllers/turn-watchdog.ts
 const DEFAULT_IDLE_MINUTES = 20;
+const DEFAULT_HARD_IDLE_MINUTES = 30;
 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_HARD_IDLE_MINUTES_ENV = "BLUN_TURN_WATCHDOG_HARD_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 hardIdleMinutes = parseBoundedInteger(env[TURN_WATCHDOG_HARD_IDLE_MINUTES_ENV], DEFAULT_HARD_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,
+		hardIdleMs: hardIdleMinutes * 6e4,
 		maxFailedRepetitions
 	};
 }
@@ -506667,6 +506677,7 @@ var TurnWatchdogController = class {
 	}
 	recordToolCall(toolCallId, name, args) {
 		if (!this.active) return;
+		this.recordProgress();
 		this.lastToolName = name;
 		this.toolCalls.set(toolCallId, {
 			name,
@@ -506678,9 +506689,7 @@ var TurnWatchdogController = class {
 		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();
+		this.recordProgress();
 		if (!isError || toolCall === void 0) {
 			this.lastFailedKey = void 0;
 			this.failedRepetitions = 0;
@@ -506692,14 +506701,26 @@ var TurnWatchdogController = class {
 			this.failedRepetitions = 1;
 		}
 		if (this.failedRepetitions < this.config.maxFailedRepetitions) return;
-		const snapshot = this.snapshot();
+		const snapshot = {
+			...this.snapshot(),
+			reason: "repeated_failures"
+		};
 		this.stop();
 		this.onAbort(snapshot);
 	}
+	recordProgress() {
+		if (!this.active) return;
+		this.lastProgressAtMs = this.now();
+		this.idleReportedForProgressAtMs = void 0;
+		this.scheduleIdleCheck();
+	}
 	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));
+		const idleForMs = this.now() - this.lastProgressAtMs;
+		const warningRemaining = this.idleReportedForProgressAtMs === this.lastProgressAtMs ? Number.POSITIVE_INFINITY : this.config.idleMs - idleForMs;
+		const hardRemaining = this.config.hardIdleMs - idleForMs;
+		const remaining = Math.max(0, Math.min(warningRemaining, hardRemaining));
 		this.timer = this.setTimer(() => {
 			this.timer = void 0;
 			this.checkIdle();
@@ -506707,16 +506728,26 @@ var TurnWatchdogController = class {
 	}
 	checkIdle() {
 		if (!this.active) return;
-		if (this.now() - this.lastProgressAtMs >= this.config.idleMs && this.idleReportedForProgressAtMs !== this.lastProgressAtMs) {
+		const idleForMs = this.now() - this.lastProgressAtMs;
+		if (idleForMs >= this.config.hardIdleMs) {
+			const snapshot = {
+				...this.snapshot(),
+				reason: "idle_timeout"
+			};
+			this.stop();
+			this.onAbort(snapshot);
+			return;
+		}
+		if (idleForMs >= 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)),
+			idleMinutes: Math.max(1, Math.floor((this.now() - this.lastProgressAtMs) / 6e4)),
 			lastToolName: this.lastToolName,
 			failedRepetitions: this.failedRepetitions
 		};
@@ -507035,6 +507066,7 @@ var SessionEventHandler = class {
 		requestRunningUpdateAtSafeBoundary(this.host);
 	}
 	handleStepBegin(event) {
+		this.turnWatchdog.recordProgress();
 		this.host.commitQueuedSteerAtStepStart(event.turnId);
 		this.host.streamingUI.flushNow();
 		this.host.streamingUI.setStep(event.step);
@@ -507108,6 +507140,7 @@ var SessionEventHandler = class {
 	handleThinkingDelta(event) {
 		const { state, streamingUI } = this.host;
 		if (event.delta.length === 0 && !streamingUI.hasThinkingDraft()) return;
+		if (event.delta.length > 0) this.turnWatchdog.recordProgress();
 		streamingUI.appendThinkingDelta(event.delta);
 		this.host.patchLivePane({ mode: "idle" });
 		if (state.appState.streamingPhase !== "thinking") this.host.setAppState({
@@ -507120,6 +507153,7 @@ var SessionEventHandler = class {
 		const { state, streamingUI } = this.host;
 		if (streamingUI.hasThinkingDraft()) streamingUI.flushThinkingToTranscript("idle");
 		if (event.delta.trim().length > 0) {
+			this.turnWatchdog.recordProgress();
 			this.currentTurnHasAssistantText = true;
 			this.pendingModelBlockedFallback = void 0;
 		}
@@ -507180,6 +507214,7 @@ var SessionEventHandler = class {
 	}
 	handleToolCallDelta(event) {
 		if (event.toolCallId.length === 0) return;
+		if (event.argumentsPart.length > 0) this.turnWatchdog.recordProgress();
 		const { state, streamingUI } = this.host;
 		streamingUI.accumulateToolCallDelta(event.toolCallId, event.name, event.argumentsPart);
 		const preview = streamingUI.getStreamingToolCallPreview(event.toolCallId);
@@ -507196,6 +507231,7 @@ var SessionEventHandler = class {
 		streamingUI.scheduleFlush();
 	}
 	handleToolProgress(event) {
+		this.turnWatchdog.recordProgress();
 		if (event.update.kind === "custom" && event.update.customKind === MEDIA_PROGRESS_CUSTOM_KIND) {
 			this.host.updateMediaActivity(event.toolCallId, event.update.customData);
 			return;
@@ -507251,7 +507287,8 @@ var SessionEventHandler = class {
 		this.host.sendChannelTurnStatus?.(message);
 	}
 	abortWatchdogLoop(snapshot) {
-		const message = uiText("sessionEvent.watchdog.aborted", {
+		const message = uiText(snapshot.reason === "idle_timeout" ? "sessionEvent.watchdog.timeout" : "sessionEvent.watchdog.aborted", {
+			minutes: snapshot.idleMinutes,
 			tool: snapshot.lastToolName,
 			repetitions: snapshot.failedRepetitions
 		});
@@ -514970,7 +515007,8 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 			type: RUNNING_UPDATE_HANDOFF_MESSAGE,
 			sessionId,
 			version: tui.runningUpdatePreparedVersion,
-			mode: tui.runningUpdatePreparedMode
+			mode: tui.runningUpdatePreparedMode,
+			cwd: tui.state.appState.workDir
 		}, (error) => {
 			if (error || !isSafeRuntimeBoundary(boundaryState())) {
 				tui.runningUpdateHandoffStarted = false;

package/package.json

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