blun-king-cli 9.1.171 → 9.1.173

package/bin/launcher-runtime.js

@@ -58,6 +58,25 @@ const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.ar
 const ARGS = PROFILE.args;
 const CORE_LOAD_TIMEOUT_MS = 30_000;
 const RUNTIME_READY_TIMEOUT_MS = 60_000;
+const RUNNING_UPDATE_RECHECK_MS = 60_000;
+const RUNNING_UPDATE_RECHECK_JITTER_MS = 30_000;
+
+function runningUpdateRecheckDelay(randomValue = Math.random()) {
+  const normalized = Number.isFinite(randomValue)
+    ? Math.min(Math.max(randomValue, 0), 0.999999999)
+    : 0;
+  return RUNNING_UPDATE_RECHECK_MS
+    + Math.floor(normalized * RUNNING_UPDATE_RECHECK_JITTER_MS);
+}
+
+function scheduleRunningUpdateRecheck(callback, options = {}) {
+  const timer = (options.setTimeoutImpl || setTimeout)(
+    callback,
+    options.delayMs ?? runningUpdateRecheckDelay((options.randomImpl || Math.random)()),
+  );
+  timer.unref?.();
+  return timer;
+}
 
 function normalizeWindowsPath(value) {
   return path.win32.normalize(value).replace(/\\+$/u, '').toLowerCase();
@@ -232,9 +251,23 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   let handoffMode;
   let updateStarted = false;
   let runtimeReady = false;
+  let runningUpdatePollTimer;
   let runningUpdateMode = readRunningUpdateMode(env.BLUN_HOME);
   const automaticMode = () => runningUpdateMode === RUNNING_UPDATE_MODES.RESUME
     || runningUpdateMode === RUNNING_UPDATE_MODES.NEW;
+  const clearRunningUpdatePoll = () => {
+    if (runningUpdatePollTimer === undefined) return;
+    (options.clearTimeoutImpl || clearTimeout)(runningUpdatePollTimer);
+    runningUpdatePollTimer = undefined;
+  };
+  const scheduleNextPreparation = (child) => {
+    clearRunningUpdatePoll();
+    if (preparedTarget !== undefined || updateStarted || !automaticMode()) return;
+    runningUpdatePollTimer = (options.scheduleRunningUpdateRecheck || scheduleRunningUpdateRecheck)(() => {
+      runningUpdatePollTimer = undefined;
+      startPreparation(child);
+    });
+  };
   const announcePrepared = (child) => {
     if (preparedTarget === undefined || !automaticMode() || child.connected !== true) return;
     child.send({
@@ -249,6 +282,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     const sharedHome = env.BLUN_SHARED_HOME;
     if (typeof sharedHome !== 'string' || sharedHome.length === 0) {
       updateStarted = false;
+      scheduleNextPreparation(child);
       return;
     }
     Promise.resolve((options.prepareRunningUpdate || prepareRunningUpdate)({
@@ -258,16 +292,19 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
     })).then((target) => {
       if (target === null) {
         updateStarted = false;
+        scheduleNextPreparation(child);
         return;
       }
       preparedTarget = target;
+      clearRunningUpdatePoll();
       announcePrepared(child);
     }).catch((error) => {
       updateStarted = false;
       options.onRunningUpdateError?.(error);
+      scheduleNextPreparation(child);
     });
   };
-  const core = spawnProtectedCore(args, env, cwd, {
+  const core = (options.spawnProtectedCore || spawnProtectedCore)(args, env, cwd, {
     packageRoot,
     onMessage(message, child) {
       if (message?.type === RUNTIME_READY_MESSAGE) {
@@ -278,6 +315,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
         runningUpdateMode = normalizeRunningUpdateMode(message.mode);
         handoffSessionId = undefined;
         handoffMode = undefined;
+        clearRunningUpdatePoll();
         if (automaticMode()) {
           if (preparedTarget !== undefined) announcePrepared(child);
           else if (runtimeReady) {
@@ -299,6 +337,7 @@ async function superviseProtectedCore(args, env, cwd, releaseNotice, options = {
   const loaded = await core.loaded;
   await releaseNotice();
   const result = await core.completed;
+  clearRunningUpdatePoll();
   if (result.error) throw result.error;
   if (result.code === RUNNING_UPDATE_HANDOFF_EXIT_CODE
     && preparedTarget !== undefined
@@ -656,9 +695,14 @@ async function runLauncher(options = {}) {
 }
 
 module.exports = {
+  RUNNING_UPDATE_RECHECK_JITTER_MS,
+  RUNNING_UPDATE_RECHECK_MS,
   createManagedNodeEnvironment,
   resolveLauncherPrivatePaths,
+  runningUpdateRecheckDelay,
   runLauncher,
+  scheduleRunningUpdateRecheck,
   shouldDetachProtectedCore,
   spawnManagedLauncher,
+  superviseProtectedCore,
 };

package/bin/repeated-assistant-response-policy.cjs

@@ -0,0 +1,109 @@
+'use strict';
+
+const MIN_RESPONSE_CHARS = 160;
+const MAX_RECENT_ASSISTANT_RESPONSES = 8;
+const REQUIRED_MATCHING_RESPONSES = 3;
+const RESPONSE_SIMILARITY_THRESHOLD = 0.78;
+
+function isUserPrompt(message) {
+  if (message?.role !== 'user') return false;
+  const kind = message.origin?.kind;
+  return kind !== 'injection' && kind !== 'compaction_summary' && kind !== 'system_trigger';
+}
+
+function assistantResponseText(message) {
+  if (
+    message?.role !== 'assistant'
+    || (message.toolCalls?.length ?? 0) > 0
+    || message.origin?.kind === 'injection'
+    || !Array.isArray(message.content)
+  ) return '';
+
+  const text = message.content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n')
+    .trim();
+  return text.length >= MIN_RESPONSE_CHARS ? text : '';
+}
+
+function normalizedResponseTokens(text) {
+  return String(text)
+    .normalize('NFKC')
+    .toLocaleLowerCase('en-US')
+    .match(/[\p{L}\p{N}_]+/gu)
+    ?.map((token) => /\p{N}/u.test(token) ? '#' : token) ?? [];
+}
+
+function tokenBigrams(tokens) {
+  const result = new Set();
+  for (let index = 0; index + 1 < tokens.length; index += 1) {
+    result.add(`${tokens[index]}\u0000${tokens[index + 1]}`);
+  }
+  return result;
+}
+
+function responseSimilarity(left, right) {
+  const leftBigrams = tokenBigrams(normalizedResponseTokens(left));
+  const rightBigrams = tokenBigrams(normalizedResponseTokens(right));
+  if (leftBigrams.size < 8 || rightBigrams.size < 8) return 0;
+
+  let intersection = 0;
+  for (const bigram of leftBigrams) {
+    if (rightBigrams.has(bigram)) intersection += 1;
+  }
+  return (2 * intersection) / (leftBigrams.size + rightBigrams.size);
+}
+
+function hasUserPromptBetween(history, leftIndex, rightIndex) {
+  for (let index = leftIndex + 1; index < rightIndex; index += 1) {
+    if (isUserPrompt(history[index])) return true;
+  }
+  return false;
+}
+
+function detectRepeatedAssistantResponse(history) {
+  if (!Array.isArray(history) || history.length === 0) return null;
+
+  let latestUserIndex = -1;
+  for (let index = history.length - 1; index >= 0; index -= 1) {
+    if (isUserPrompt(history[index])) {
+      latestUserIndex = index;
+      break;
+    }
+  }
+  if (latestUserIndex < 0) return null;
+
+  const responses = [];
+  for (let index = latestUserIndex - 1; index >= 0 && responses.length < MAX_RECENT_ASSISTANT_RESPONSES; index -= 1) {
+    const text = assistantResponseText(history[index]);
+    if (text) responses.push({ index, text });
+  }
+  if (responses.length < REQUIRED_MATCHING_RESPONSES) return null;
+
+  const latest = responses[0];
+  const matches = [latest];
+  for (const candidate of responses.slice(1)) {
+    if (!hasUserPromptBetween(history, candidate.index, latest.index)) continue;
+    const similarity = responseSimilarity(latest.text, candidate.text);
+    if (similarity >= RESPONSE_SIMILARITY_THRESHOLD) {
+      matches.push({ ...candidate, similarity });
+    }
+  }
+  if (matches.length < REQUIRED_MATCHING_RESPONSES) return null;
+
+  return {
+    count: matches.length,
+    minimumSimilarity: Math.min(...matches.slice(1).map((match) => match.similarity)),
+  };
+}
+
+module.exports = {
+  MAX_RECENT_ASSISTANT_RESPONSES,
+  MIN_RESPONSE_CHARS,
+  REQUIRED_MATCHING_RESPONSES,
+  RESPONSE_SIMILARITY_THRESHOLD,
+  assistantResponseText,
+  detectRepeatedAssistantResponse,
+  responseSimilarity,
+};

package/blun.mjs

@@ -232089,6 +232089,47 @@ var init_tool_awareness = __esmMin((() => {
 	};
 }));
 //#endregion
+//#region ../../packages/agent-core/src/agent/injection/repeated-assistant-response.ts
+function isRepeatedAssistantResponseReminder(message) {
+	return message.origin?.kind === "injection" && message.origin.variant === "repeated_assistant_response";
+}
+function buildRepeatedAssistantResponseReminder() {
+	return [
+		"<response-loop-check>",
+		"Your latest text-only answer substantially repeats at least two earlier answers despite newer user messages between them.",
+		"Do not repeat the earlier question, list, or waiting state again.",
+		"Re-read the latest non-injection user message and every newer correction, then take a different concrete action that advances that request.",
+		"If action is genuinely blocked, report the exact current blocker and its evidence once instead of returning to the old answer.",
+		"</response-loop-check>"
+	].join("\n");
+}
+var RepeatedAssistantResponseInjector, detectRepeatedAssistantResponse;
+var init_repeated_assistant_response = __esmMin((() => {
+	init_injector();
+	({ detectRepeatedAssistantResponse } = createRequire(import.meta.url)("./bin/repeated-assistant-response-policy.cjs"));
+	RepeatedAssistantResponseInjector = class extends DynamicInjector {
+		injectionVariant = "repeated_assistant_response";
+		async inject() {
+			const detection = detectRepeatedAssistantResponse(this.agent.context.history);
+			const existing = this.agent.context.history.filter(isRepeatedAssistantResponseReminder);
+			if (detection === null) {
+				if (existing.length > 0) this.agent.context.removeSystemRemindersMatching(isRepeatedAssistantResponseReminder);
+				return;
+			}
+			const injection = buildRepeatedAssistantResponseReminder();
+			const expected = `<system-reminder>\n${injection}\n</system-reminder>`;
+			if (existing.length === 1 && reminderText(existing[0]) === expected) return;
+			this.agent.context.removeSystemRemindersMatching(isRepeatedAssistantResponseReminder);
+			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";
@@ -232887,6 +232928,7 @@ var init_manager$2 = __esmMin((() => {
 	init_personal_memory_recall();
 	init_plugin_session_start();
 	init_plan_mode();
+	init_repeated_assistant_response();
 	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 {
@@ -232902,6 +232944,7 @@ var init_manager$2 = __esmMin((() => {
 				new ErrorMemoryInjector(agent),
 				new ToolAwarenessInjector(agent),
 				new MistakeMdInjector(agent),
+				new RepeatedAssistantResponseInjector(agent),
 				new ActionStyleInjector(agent),
 				new PlanModeInjector(agent),
 				new PermissionModeInjector(agent)

package/package.json

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