blun-king-cli 9.1.214 → 9.1.216

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

@@ -1,5 +1,12 @@
 'use strict';
 
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const CANDIDATE_TTL_MS = 24 * 60 * 60 * 1000;
+const SCHEMA_VERSION = 1;
+
 const COMMAND_TOOLS = new Set([
   'bash',
   'command',
@@ -101,7 +108,182 @@ function detectValidatedLearningSignal(history) {
   return signal;
 }
 
+function profileKey(value) {
+  const normalized = typeof value === 'string' ? value.trim() : '';
+  return (normalized || 'default').replace(/[^a-z0-9._-]/giu, '_').slice(0, 64);
+}
+
+function candidateDirectory(homeDir, profile) {
+  return path.join(
+    path.resolve(homeDir),
+    'self-improvement',
+    'validated-learning',
+    profileKey(profile),
+  );
+}
+
+function atomicCreate(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { mode: 0o700, recursive: true });
+  const temporary = `${filePath}.${process.pid}.${crypto.randomBytes(8).toString('hex')}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { encoding: 'utf8', mode: 0o600 });
+  try {
+    fs.linkSync(temporary, filePath);
+    return true;
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+    return false;
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+function statusMarker(filePath, status) {
+  return `${filePath}.${status}`;
+}
+
+function readCandidate(filePath) {
+  try {
+    const candidate = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    for (const status of ['recorded', 'expired']) {
+      const markerPath = statusMarker(filePath, status);
+      if (!fs.existsSync(markerPath)) continue;
+      const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+      return { ...candidate, ...marker, filePath };
+    }
+    return { ...candidate, filePath };
+  } catch {
+    return null;
+  }
+}
+
+function readValidatedLearningCandidates(options = {}) {
+  const homeDir = typeof options.homeDir === 'string' ? options.homeDir.trim() : '';
+  if (!homeDir) return [];
+  const directory = candidateDirectory(homeDir, options.profile);
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+      .map((entry) => readCandidate(path.join(directory, entry.name)))
+      .filter(Boolean)
+      .sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt));
+  } catch {
+    return [];
+  }
+}
+
+function currentTurnHasSuccessfulMistakeRecord(history) {
+  const calls = new Set();
+  for (const message of currentUserTurn(history)) {
+    for (const call of toolCallsFrom(message)) {
+      if (typeof call?.id === 'string' && String(call.name).toLowerCase() === 'mistakerecord') {
+        calls.add(call.id);
+      }
+    }
+    if (message?.role === 'tool'
+      && typeof message.toolCallId === 'string'
+      && calls.has(message.toolCallId)
+      && message.isError !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function newestPending(candidates) {
+  for (let index = candidates.length - 1; index >= 0; index -= 1) {
+    if (candidates[index].status === 'pending') return candidates[index];
+  }
+  return null;
+}
+
+function markCandidate(candidate, status, nowIso) {
+  if (!candidate?.filePath) return;
+  atomicCreate(statusMarker(candidate.filePath, status), {
+    resolvedAt: nowIso,
+    status,
+  });
+}
+
+function createCandidate(signal, options, nowIso) {
+  const profile = profileKey(options.profile);
+  const commandHash = crypto.createHash('sha256').update(signal.command).digest('hex');
+  const digest = crypto.createHash('sha256').update([
+    profile,
+    commandHash,
+    signal.failedToolCallId,
+    signal.successfulToolCallId,
+  ].join('\0')).digest('hex').slice(0, 32);
+  const id = `vl-${digest}`;
+  const filePath = path.join(candidateDirectory(options.homeDir, profile), `${id}.json`);
+  atomicCreate(filePath, {
+    schemaVersion: SCHEMA_VERSION,
+    id,
+    type: 'validated_red_green',
+    status: 'pending',
+    profile,
+    verification: {
+      toolName: signal.toolName,
+      commandHash,
+    },
+    evidence: {
+      failedToolCallId: signal.failedToolCallId,
+      successfulToolCallId: signal.successfulToolCallId,
+    },
+    createdAt: nowIso,
+  });
+  return readCandidate(filePath);
+}
+
+function syncValidatedLearningCandidate(history, options = {}) {
+  const signal = detectValidatedLearningSignal(history);
+  const homeDir = typeof options.homeDir === 'string' ? options.homeDir.trim() : '';
+  if (!homeDir) {
+    return signal === null ? null : {
+      ...signal,
+      source: 'current_turn',
+      status: 'pending',
+    };
+  }
+
+  const nowMs = (options.now || Date.now)();
+  const nowIso = new Date(nowMs).toISOString();
+  try {
+    let candidates = readValidatedLearningCandidates({
+      homeDir,
+      profile: options.profile,
+    });
+    if (currentTurnHasSuccessfulMistakeRecord(history)) {
+      markCandidate(newestPending(candidates), 'recorded', nowIso);
+      candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
+    }
+    if (signal !== null) {
+      return {
+        ...createCandidate(signal, { homeDir, profile: options.profile }, nowIso),
+        source: 'current_turn',
+      };
+    }
+
+    for (const candidate of candidates) {
+      if (candidate.status !== 'pending') continue;
+      if (nowMs - Date.parse(candidate.createdAt) >= CANDIDATE_TTL_MS) {
+        markCandidate(candidate, 'expired', nowIso);
+      }
+    }
+    candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
+    const pending = newestPending(candidates);
+    return pending === null ? null : { ...pending, source: 'persisted' };
+  } catch {
+    return signal === null ? null : {
+      ...signal,
+      source: 'current_turn',
+      status: 'pending',
+    };
+  }
+}
+
 module.exports = {
   detectValidatedLearningSignal,
   normalizeCommand,
+  readValidatedLearningCandidates,
+  syncValidatedLearningCandidate,
 };

package/blun.mjs

@@ -232147,14 +232147,17 @@ function buildValidatedLearningSignalReminder() {
 		"</validated-learning-signal>"
 	].join("\n");
 }
-var ValidatedLearningSignalInjector, detectValidatedLearningSignal;
+var ValidatedLearningSignalInjector, syncValidatedLearningCandidate;
 var init_validated_learning_signal = __esmMin((() => {
 	init_injector();
-	({ detectValidatedLearningSignal } = createRequire(import.meta.url)("./bin/validated-learning-signal.cjs"));
+	({ syncValidatedLearningCandidate } = 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 signal = syncValidatedLearningCandidate(this.agent.context.history, {
+				homeDir: process.env["BLUN_SHARED_HOME"] ?? process.env["BLUN_HOME"] ?? "",
+				profile: process.env["BLUN_PROFILE"] ?? "default"
+			});
 			const existing = this.agent.context.history.filter(isValidatedLearningSignalReminder);
 			if (signal === null) {
 				if (existing.length > 0) this.agent.context.removeSystemRemindersMatching(isValidatedLearningSignalReminder);
@@ -502555,7 +502558,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() {
@@ -515086,6 +515092,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,
@@ -515148,10 +515155,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);
@@ -516033,7 +516059,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() {
@@ -516224,7 +516251,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());
@@ -516337,7 +516365,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();
@@ -516809,7 +516837,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;
 		}
@@ -516820,7 +516848,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.214",
+  "version": "9.1.216",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {