blun-king-cli 9.1.213 → 9.1.215

package/bin/launcher-runtime.js

@@ -30,6 +30,7 @@ const { acquireSharedRuntimeLease, tryAcquireUpdateLease } = require('./update-l
 const { compareSemver, runExplicitUpdate, runUpdateNotice } = require('./update-notice');
 const {
   RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,
@@ -397,12 +398,26 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       handoffSessionId = message.sessionId;
       handoffMode = runningUpdateMode;
       handoffCwd = resolveHandoffCwd(message.cwd, cwd);
-      if (preparedTarget !== undefined) {
-        (options.stageRuntime || stageRuntime)(env.BLUN_SHARED_HOME, preparedTarget, {
-          mode: handoffMode,
-          sessionId: handoffSessionId,
-          cwd: handoffCwd,
-        });
+      if (preparedTarget !== undefined && message.version === preparedTarget.version) {
+        try {
+          (options.stageRuntime || stageRuntime)(env.BLUN_SHARED_HOME, preparedTarget, {
+            mode: handoffMode,
+            sessionId: handoffSessionId,
+            cwd: handoffCwd,
+          });
+          child.send({
+            type: RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
+            version: preparedTarget.version,
+            mode: handoffMode,
+            sessionId: handoffSessionId,
+          }, (error) => {
+            if (error) options.onRunningUpdateError?.(error);
+          });
+        } catch (error) {
+          handoffSessionId = undefined;
+          handoffMode = undefined;
+          options.onRunningUpdateError?.(error);
+        }
       }
     }
   };
@@ -471,6 +486,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
       },
       activateTarget: async (target) => {
         await (options.activateRuntime || activateRuntime)(env.BLUN_SHARED_HOME, target);
+        (options.clearPendingRuntime || clearPendingRuntime)(env.BLUN_SHARED_HOME, target);
         (options.recordRunningUpdateEvent || recordRunningUpdateEvent)(env.BLUN_SHARED_HOME, {
           event: 'activated',
           fromVersion: readPackageVersionAt(packageRoot),
@@ -485,6 +501,9 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         }
       },
     });
+    if (handoff.kind !== 'activated') {
+      (options.clearPendingRuntime || clearPendingRuntime)(env.BLUN_SHARED_HOME, preparedTarget);
+    }
     const resumed = handoff.core;
     if (resumed === undefined || resumed.ready !== true) return 1;
     const resumedArgs = handoffArgsForMode(args, handoffMode, handoffSessionId);

package/bin/running-update.cjs

@@ -16,6 +16,7 @@ const REGISTRY_URL = 'https://registry.npmjs.org/blun-king-cli';
 const ACTIVE_RUNTIME_FILE = 'active-runtime.json';
 const PENDING_RUNTIME_FILE = 'pending-runtime.json';
 const RUNNING_UPDATE_HANDOFF_EXIT_CODE = 76;
+const RUNNING_UPDATE_HANDOFF_ACK_MESSAGE = 'blun-running-update-handoff-ack';
 const RUNNING_UPDATE_PREPARED_MESSAGE = 'blun-running-update-prepared';
 const RUNNING_UPDATE_HANDOFF_MESSAGE = 'blun-running-update-handoff';
 const RUNNING_UPDATE_MODE_MESSAGE = 'blun-running-update-mode';
@@ -559,6 +560,7 @@ module.exports = {
   PENDING_RUNTIME_FILE,
   AUTO_UPDATE_SETTLE_MS,
   RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+  RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
   RUNNING_UPDATE_HANDOFF_MESSAGE,
   RUNNING_UPDATE_MODE_MESSAGE,
   RUNNING_UPDATE_PREPARED_MESSAGE,

package/bin/validated-learning-signal.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const COMMAND_TOOLS = new Set([
+  'bash',
+  'command',
+  'exec_command',
+  'shell',
+]);
+
+const VERIFICATION_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:node\s+--(?:test|check))|(?:(?:npm|pnpm|yarn)\s+(?:test|(?:run\s+)?(?:test|lint|check|typecheck|build)))|(?:python(?:3)?\s+-m\s+pytest)|(?:pytest)|(?:go\s+test)|(?:cargo\s+test)|(?:dotnet\s+test)|(?:npx\s+)?(?:tsc|eslint|biome\s+check))\b/iu;
+
+function isRealUserMessage(message) {
+  if (message?.role !== 'user') return false;
+  const kind = message.origin?.kind;
+  return kind !== 'injection' && kind !== 'compaction_summary' && kind !== 'system_trigger';
+}
+
+function currentUserTurn(history) {
+  if (!Array.isArray(history)) return [];
+  for (let index = history.length - 1; index >= 0; index -= 1) {
+    if (isRealUserMessage(history[index])) return history.slice(index + 1);
+  }
+  return [];
+}
+
+function parseArguments(value) {
+  if (value && typeof value === 'object') return value;
+  if (typeof value !== 'string') return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeCommand(value) {
+  return typeof value === 'string' ? value.trim().replace(/\s+/gu, ' ') : '';
+}
+
+function describeVerificationCall(call) {
+  const toolName = typeof call?.name === 'string' ? call.name : '';
+  if (!COMMAND_TOOLS.has(toolName.toLowerCase())) return null;
+  const args = parseArguments(call.arguments);
+  const command = normalizeCommand(args?.command ?? args?.cmd);
+  if (!command || !VERIFICATION_COMMAND.test(command)) return null;
+  return { toolName, command };
+}
+
+function toolCallsFrom(message) {
+  if (message?.role !== 'assistant') return [];
+  if (Array.isArray(message.toolCalls)) return message.toolCalls;
+  if (Array.isArray(message.tool_calls)) return message.tool_calls;
+  return [];
+}
+
+function detectValidatedLearningSignal(history) {
+  const turn = currentUserTurn(history);
+  const calls = new Map();
+  const failures = new Map();
+  let signal = null;
+
+  for (const message of turn) {
+    for (const call of toolCallsFrom(message)) {
+      if (typeof call?.id !== 'string') continue;
+      const verification = describeVerificationCall(call);
+      calls.set(call.id, {
+        toolName: typeof call.name === 'string' ? call.name : '',
+        verification,
+      });
+    }
+
+    if (message?.role !== 'tool' || typeof message.toolCallId !== 'string') continue;
+    const call = calls.get(message.toolCallId);
+    if (!call) continue;
+
+    if (call.toolName.toLowerCase() === 'mistakerecord' && message.isError !== true) {
+      signal = null;
+      failures.clear();
+      continue;
+    }
+
+    if (!call.verification) continue;
+    const key = `${call.verification.toolName.toLowerCase()}\0${call.verification.command}`;
+    if (message.isError === true) {
+      failures.set(key, message.toolCallId);
+      signal = null;
+      continue;
+    }
+
+    const failedToolCallId = failures.get(key);
+    if (!failedToolCallId) continue;
+    signal = {
+      toolName: call.verification.toolName,
+      command: call.verification.command,
+      failedToolCallId,
+      successfulToolCallId: message.toolCallId,
+    };
+  }
+
+  return signal;
+}
+
+module.exports = {
+  detectValidatedLearningSignal,
+  normalizeCommand,
+};

package/blun.mjs

@@ -232133,6 +232133,47 @@ var init_repeated_assistant_response = __esmMin((() => {
 	};
 }));
 //#endregion
+//#region ../../packages/agent-core/src/agent/injection/validated-learning-signal.ts
+function isValidatedLearningSignalReminder(message) {
+	return message.origin?.kind === "injection" && message.origin.variant === "validated_learning_signal";
+}
+function buildValidatedLearningSignalReminder() {
+	return [
+		"<validated-learning-signal>",
+		"The same verification command failed and now succeeds in this user turn.",
+		"Use MistakeRecord only when the red-to-green result exposes a reusable lesson.",
+		"Do not record transient environment failures, raw command output, or a success with no general repetition guard.",
+		"If there is a reusable lesson, record the incorrect assumption, the measured correction, and the concrete condition that would cause it again.",
+		"</validated-learning-signal>"
+	].join("\n");
+}
+var ValidatedLearningSignalInjector, detectValidatedLearningSignal;
+var init_validated_learning_signal = __esmMin((() => {
+	init_injector();
+	({ detectValidatedLearningSignal } = createRequire(import.meta.url)("./bin/validated-learning-signal.cjs"));
+	ValidatedLearningSignalInjector = class extends DynamicInjector {
+		injectionVariant = "validated_learning_signal";
+		async inject() {
+			const signal = detectValidatedLearningSignal(this.agent.context.history);
+			const existing = this.agent.context.history.filter(isValidatedLearningSignalReminder);
+			if (signal === null) {
+				if (existing.length > 0) this.agent.context.removeSystemRemindersMatching(isValidatedLearningSignalReminder);
+				return;
+			}
+			const injection = buildValidatedLearningSignalReminder();
+			const expected = `<system-reminder>\n${injection}\n</system-reminder>`;
+			if (existing.length === 1 && reminderText(existing[0]) === expected) return;
+			this.agent.context.removeSystemRemindersMatching(isValidatedLearningSignalReminder);
+			this.injectedAt = this.agent.context.history.length;
+			this.lastInjection = injection;
+			this.agent.context.appendSystemReminder(injection, {
+				kind: "injection",
+				variant: this.injectionVariant
+			});
+		}
+	};
+}));
+//#endregion
 //#region ../../packages/agent-core/src/agent/injection/mission-contract-evidence.js
 function createEvidenceApi(dependencies) {
 	"use strict";
@@ -232932,6 +232973,7 @@ var init_manager$2 = __esmMin((() => {
 	init_plugin_session_start();
 	init_plan_mode();
 	init_repeated_assistant_response();
+	init_validated_learning_signal();
 	init_tool_awareness();
 	ACTIVE_BACKGROUND_TASK_GUIDANCE = "The conversation was compacted, so the earlier messages that started these background tasks are gone — but the tasks are still running from before. Do not start duplicates. Use TaskOutput to fetch a task’s result, TaskList to list them, TaskUpdate to send additional instructions to a running agent task, and TaskStop to cancel one.";
 	InjectionManager = class {
@@ -232948,6 +232990,7 @@ var init_manager$2 = __esmMin((() => {
 				new ToolAwarenessInjector(agent),
 				new MistakeMdInjector(agent),
 				new RepeatedAssistantResponseInjector(agent),
+				new ValidatedLearningSignalInjector(agent),
 				new ActionStyleInjector(agent),
 				new PlanModeInjector(agent),
 				new PermissionModeInjector(agent)
@@ -502512,7 +502555,10 @@ var ChannelQueueDeadlineController = class {
 	}
 	requestDeliveryNow() {
 		if (this.retainReleaseWhileDeliveryIsInFlight()) return;
-		if (this.host.hasWaitingWork() && !this.host.canDeliverWork()) return;
+		if (this.host.hasWaitingWork() && !this.host.canDeliverWork()) {
+			this.scheduleRetry();
+			return;
+		}
 		this.requestDelivery();
 	}
 	retainReleaseWhileDeliveryIsInFlight() {
@@ -515043,6 +515089,7 @@ function turnsToTrim(turns, maxTurns, hysteresis) {
 const {
 	AUTO_UPDATE_SETTLE_MS,
 	RUNNING_UPDATE_HANDOFF_EXIT_CODE,
+	RUNNING_UPDATE_HANDOFF_ACK_MESSAGE,
 	RUNNING_UPDATE_HANDOFF_MESSAGE,
 	RUNNING_UPDATE_MODE_MESSAGE,
 	RUNNING_UPDATE_PREPARED_MESSAGE,
@@ -515105,10 +515152,29 @@ function requestRunningUpdateAtSafeBoundary(tui) {
 }
 function installRunningUpdateListener(tui) {
 	const handler = (message) => {
+		if (message?.type === RUNNING_UPDATE_HANDOFF_ACK_MESSAGE) {
+			if (!tui.runningUpdateHandoffStarted || message.version !== tui.runningUpdatePreparedVersion || message.mode !== tui.runningUpdatePreparedMode || message.sessionId !== tui.getCurrentSessionId()) return;
+			if (!isSafeRuntimeBoundary({
+				isShuttingDown: tui.isShuttingDown,
+				streamingPhase: tui.state.appState.streamingPhase,
+				isCompacting: tui.state.appState.isCompacting,
+				queuedMessages: tui.state.queuedMessages.length,
+				activeToolCalls: tui.streamingUI.hasActiveToolCalls() ? 1 : 0,
+				shellCommands: tui.shellOutputStreams.size,
+				queueCommandRunning: tui.queueCommandRunning
+			})) {
+				tui.runningUpdateHandoffStarted = false;
+				return;
+			}
+			tui.showStatus("Ein Update wird geladen und die TUI wird neu gestartet.", "success");
+			void tui.stop(RUNNING_UPDATE_HANDOFF_EXIT_CODE).catch(() => {
+				tui.runningUpdateHandoffStarted = false;
+			});
+			return;
+		}
 		if (message?.type !== RUNNING_UPDATE_PREPARED_MESSAGE || typeof message.version !== "string" || message.mode !== RUNNING_UPDATE_MODES.RESUME && message.mode !== RUNNING_UPDATE_MODES.NEW) return;
 		tui.runningUpdatePreparedVersion = message.version;
 		tui.runningUpdatePreparedMode = message.mode;
-		tui.showStatus(`Update ${message.version} ist bereit und wird beim nächsten Start aktiviert.`, "success");
 		requestRunningUpdateAtSafeBoundary(tui);
 	};
 	process.on("message", handler);
@@ -515990,7 +516056,8 @@ var BlunTUI = class {
 	}
 	canDeliverQueuedChannelHead() {
 		const item = this.state.queuedMessages[0];
-		if (this.isShuttingDown || this.queueCommandRunning || this.queueSteerInFlight !== void 0 || this.editorReplacementActive || this.deferUserMessages || this.session === void 0 || this.state.appState.model.trim().length === 0 || this.state.appState.streamingPhase === "idle" || this.state.appState.streamingPhase === "shell" || item?.mode !== "channel") return false;
+		const hasActiveTurn = this.streamingUI.hasActiveTurn() || (this.state.appState.streamingPhase !== "idle" && this.state.appState.streamingPhase !== "shell");
+		if (this.isShuttingDown || this.queueCommandRunning || this.queueSteerInFlight !== void 0 || this.editorReplacementActive || this.deferUserMessages || this.session === void 0 || this.state.appState.model.trim().length === 0 || !hasActiveTurn || item?.mode !== "channel") return false;
 		return true;
 	}
 	async deliverQueuedChannelHead() {
@@ -516181,7 +516248,8 @@ var BlunTUI = class {
 		this.scheduleQueueDrain();
 	}
 	steerQueueFlushPrefix() {
-		if (this.queueSteerInFlight !== void 0 || this.queueFlushBatchRemaining === 0 || this.deferUserMessages || this.state.appState.isCompacting || this.state.appState.streamingPhase === "idle" || this.state.appState.streamingPhase === "shell") return;
+		const hasActiveTurn = this.streamingUI.hasActiveTurn() || this.state.appState.streamingPhase !== "idle";
+		if (this.queueSteerInFlight !== void 0 || this.queueFlushBatchRemaining === 0 || this.deferUserMessages || this.state.appState.isCompacting || this.state.appState.streamingPhase === "shell" || !hasActiveTurn) return;
 		const session = this.session;
 		if (session === void 0 || this.state.appState.model.trim().length === 0) {
 			this.showError(llmNotSetMessage());
@@ -516294,7 +516362,7 @@ var BlunTUI = class {
 					channelAcknowledge: acknowledge,
 					...envelope.meta["image_path"] !== void 0 ? { channelImagePath: envelope.meta["image_path"] } : {}
 				});
-				this.syncChannelQueueDeadline();
+				this.channelQueueDeadline.requestDeliveryNow();
 				this.scheduleQueueDrain();
 				this.track("input_queue");
 				this.updateQueueDisplay();
@@ -516766,7 +516834,7 @@ var BlunTUI = class {
 			this.sendTelegramRemoteCommandMessage(session, input, options, telegramContext);
 			return;
 		}
-		if (this.deferUserMessages || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting) {
+		if (this.deferUserMessages || this.streamingUI.hasActiveTurn() || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting) {
 			this.enqueueMessage(input, options);
 			return;
 		}
@@ -516777,7 +516845,8 @@ var BlunTUI = class {
 			for (const part of input) this.enqueueMessage(part);
 			return;
 		}
-		if (this.state.appState.streamingPhase === "idle") {
+		const hasActiveTurn = this.streamingUI.hasActiveTurn() || this.state.appState.streamingPhase !== "idle";
+		if (!hasActiveTurn) {
 			for (const part of input) this.sendMessageInternal(session, part);
 			return;
 		}

package/package.json

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