blun-king-cli 9.1.217 → 9.1.219

package/bin/validated-learning-performance-policy.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+const {
+  isLowInformationPersonalMemoryQuery,
+} = require('./personal-memory-performance-policy.cjs');
+
+function isRealUserMessage(message) {
+  if (message?.role !== 'user') return false;
+  const kind = message.origin?.kind;
+  return kind !== 'injection' && kind !== 'compaction_summary' && kind !== 'system_trigger';
+}
+
+function textFromMessage(message) {
+  if (typeof message?.content === 'string') return message.content.trim();
+  if (!Array.isArray(message?.content)) return '';
+  return message.content
+    .filter((part) => part?.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text.trim())
+    .filter(Boolean)
+    .join('\n');
+}
+
+function directMessageText(value) {
+  let text = value.trim();
+  const marker = /^#?\s*\[tg\s+dm\b[^\]]*\]\s*/iu;
+  if (!marker.test(text)) return text;
+  text = text.replace(marker, '');
+  text = text.replace(/^[^\r\n]{1,160}\s+schrieb:\s*/iu, '');
+  return text.replace(/\r?\nWeiter-Signal:\s*[\s\S]*$/iu, '').trim();
+}
+
+function hasToolActivityAfter(history, userIndex) {
+  return history.slice(userIndex + 1).some((message) => (
+    message?.role === 'tool'
+    || (message?.role === 'assistant'
+      && (Array.isArray(message.toolCalls) || Array.isArray(message.tool_calls))
+      && (message.toolCalls?.length > 0 || message.tool_calls?.length > 0))
+  ));
+}
+
+function shouldSyncValidatedLearningCandidate(history) {
+  if (!Array.isArray(history)) return true;
+  const userIndex = history.findLastIndex(isRealUserMessage);
+  if (userIndex < 0 || hasToolActivityAfter(history, userIndex)) return true;
+  const message = history[userIndex];
+  if (Array.isArray(message.content)) {
+    const hasAttachment = message.content.some((part) => part?.type !== 'text' && part?.type !== 'think');
+    if (hasAttachment) return true;
+  }
+  return !isLowInformationPersonalMemoryQuery(directMessageText(textFromMessage(message)));
+}
+
+module.exports = { shouldSyncValidatedLearningCandidate };

package/bin/validated-learning-signal.cjs

@@ -206,9 +206,25 @@ function markCandidate(candidate, status, nowIso) {
   });
 }
 
+function verificationCommandHash(signal) {
+  return crypto.createHash('sha256').update(signal.command).digest('hex');
+}
+
+function pendingCandidateForSignal(candidates, signal) {
+  const commandHash = verificationCommandHash(signal);
+  for (let index = candidates.length - 1; index >= 0; index -= 1) {
+    const candidate = candidates[index];
+    if (candidate.status === 'pending'
+      && candidate.verification?.commandHash === commandHash) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
 function createCandidate(signal, options, nowIso) {
   const profile = profileKey(options.profile);
-  const commandHash = crypto.createHash('sha256').update(signal.command).digest('hex');
+  const commandHash = verificationCommandHash(signal);
   const digest = crypto.createHash('sha256').update([
     profile,
     commandHash,
@@ -264,20 +280,27 @@ function syncValidatedLearningCandidate(history, options = {}) {
     if (recordedCandidateIds.size > 0) {
       candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
     }
-    if (signal !== null) {
-      return {
-        ...createCandidate(signal, { homeDir, profile: options.profile }, nowIso),
-        source: 'current_turn',
-      };
-    }
-
+    let expiredCandidate = false;
     for (const candidate of candidates) {
       if (candidate.status !== 'pending') continue;
       if (nowMs - Date.parse(candidate.createdAt) >= CANDIDATE_TTL_MS) {
         markCandidate(candidate, 'expired', nowIso);
+        expiredCandidate = true;
+      }
+    }
+    if (expiredCandidate) {
+      candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
+    }
+    if (signal !== null) {
+      const duplicate = pendingCandidateForSignal(candidates, signal);
+      if (duplicate !== null) {
+        return { ...duplicate, source: 'current_turn' };
       }
+      return {
+        ...createCandidate(signal, { homeDir, profile: options.profile }, nowIso),
+        source: 'current_turn',
+      };
     }
-    candidates = readValidatedLearningCandidates({ homeDir, profile: options.profile });
     const pending = newestPending(candidates);
     return pending === null ? null : { ...pending, source: 'persisted' };
   } catch {

package/blun.mjs

@@ -232151,18 +232151,20 @@ function buildValidatedLearningSignalReminder(signal) {
 	lines.push("</validated-learning-signal>");
 	return lines.join("\n");
 }
-var ValidatedLearningSignalInjector, syncValidatedLearningCandidate;
+var ValidatedLearningSignalInjector, shouldSyncValidatedLearningCandidate, syncValidatedLearningCandidate;
 var init_validated_learning_signal = __esmMin((() => {
 	init_injector();
 	({ syncValidatedLearningCandidate } = createRequire(import.meta.url)("./bin/validated-learning-signal.cjs"));
+	({ shouldSyncValidatedLearningCandidate } = createRequire(import.meta.url)("./bin/validated-learning-performance-policy.cjs"));
 	ValidatedLearningSignalInjector = class extends DynamicInjector {
 		injectionVariant = "validated_learning_signal";
 		async inject() {
+			const existing = this.agent.context.history.filter(isValidatedLearningSignalReminder);
+			if (!shouldSyncValidatedLearningCandidate(this.agent.context.history)) return;
 			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);
 				return;

package/package.json

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