blun-king-cli 9.1.202 → 9.1.204

package/bin/error-memory-performance-policy.cjs

@@ -1,6 +1,69 @@
 'use strict';
 
 const ERROR_MEMORY_MAX_CHARS = 2_800;
+const ERROR_MEMORY_MAX_PATTERNS = 6;
+const CORE_PATTERN_NUMBERS = new Set([4, 9, 10, 11]);
+const STOP_WORDS = new Set([
+  'aber', 'alle', 'alles', 'auch', 'belegt', 'beweis', 'echt', 'echte', 'echten',
+  'echter', 'eine', 'einem', 'einen', 'einer', 'das', 'den', 'fuer', 'gegen',
+  'haben', 'hier', 'immer',
+  'jetzt', 'kann', 'machen', 'mehr', 'nicht', 'noch', 'oder', 'pruefe', 'pruefen',
+  'pruefung', 'sein', 'sind', 'soll', 'und', 'vollstaendig', 'vollstaendige',
+  'wenn', 'werden', 'with', 'that',
+  'this', 'from', 'have', 'into', 'your', 'you', 'the', 'and', 'for', 'are',
+]);
+
+function normalizedTerms(value) {
+  return [...new Set(String(value || '')
+    .normalize('NFKD')
+    .replace(/\p{M}/gu, '')
+    .toLowerCase()
+    .match(/[\p{L}\p{N}_-]{3,}/gu) || [])]
+    .filter((term) => !STOP_WORDS.has(term));
+}
+
+function fieldMatchesTerm(fieldTerms, term) {
+  return fieldTerms.some((fieldTerm) => (
+    fieldTerm === term
+    || (term.length >= 6 && fieldTerm.includes(term))
+    || (fieldTerm.length >= 6 && term.includes(fieldTerm))
+  ));
+}
+
+function selectRelevantErrorMemoryPatterns(patterns, query, options = {}) {
+  const maxPatterns = Math.max(1, Number(options.maxPatterns) || ERROR_MEMORY_MAX_PATTERNS);
+  const source = Array.isArray(patterns) ? patterns.filter(Boolean) : [];
+  if (source.length <= maxPatterns) return source;
+
+  const queryTerms = normalizedTerms(query);
+  const ranked = source.map((pattern, index) => {
+    const title = normalizedTerms(pattern.title);
+    const rule = normalizedTerms(pattern.rule);
+    const check = normalizedTerms(pattern.check);
+    let score = 0;
+    for (const term of queryTerms) {
+      if (fieldMatchesTerm(title, term)) score += 4;
+      if (fieldMatchesTerm(rule, term)) score += 2;
+      if (fieldMatchesTerm(check, term)) score += 1;
+    }
+    return { index, pattern, score };
+  });
+  const selectedIndexes = new Set(ranked
+    .filter(({ pattern }) => CORE_PATTERN_NUMBERS.has(Number(pattern.number)))
+    .map(({ index }) => index));
+  ranked
+    .filter(({ index, score }) => !selectedIndexes.has(index) && score > 0)
+    .sort((left, right) => right.score - left.score || left.index - right.index)
+    .slice(0, Math.max(0, maxPatterns - selectedIndexes.size))
+    .forEach(({ index }) => selectedIndexes.add(index));
+
+  if (selectedIndexes.size === 0) {
+    source.slice(-Math.min(2, maxPatterns)).forEach((pattern) => {
+      selectedIndexes.add(source.indexOf(pattern));
+    });
+  }
+  return source.filter((pattern, index) => selectedIndexes.has(index)).slice(0, maxPatterns);
+}
 
 function buildCompactErrorMemoryReminder(patterns) {
   const lines = [
@@ -42,7 +105,9 @@ function compactLegacyErrorMemoryReminder(text) {
 }
 
 module.exports = {
+  ERROR_MEMORY_MAX_PATTERNS,
   ERROR_MEMORY_MAX_CHARS,
   buildCompactErrorMemoryReminder,
   compactLegacyErrorMemoryReminder,
+  selectRelevantErrorMemoryPatterns,
 };

package/bin/turn-tool-performance-policy.cjs

@@ -237,8 +237,11 @@ function createDeferredToolLoader(selectedTools, deferredTools, loadedToolNames
               };
             }
             return {
-              isError: true,
-              output: `No deferred tools matched: ${query || '[empty query]'}`,
+              isError: false,
+              output: [
+                `No eligible deferred tool is available for: ${query || '[empty query]'}.`,
+                'Do not retry ToolSearch with synonyms; use a loaded alternative or report the integration as unavailable.',
+              ].join(' '),
             };
           }
           if (query.toLowerCase().startsWith('select:') && matches.length !== 1) {

package/blun.mjs

@@ -79260,6 +79260,11 @@ var init_error_memory$1 = __esmMin((() => {
 		getInjection() {
 			const patterns = this.agent.errorMemory?.getActivePatterns();
 			if (!patterns || patterns.length === 0) return void 0;
+			try {
+				const { buildCompactErrorMemoryReminder, selectRelevantErrorMemoryPatterns } = createRequire(import.meta.url)("./bin/error-memory-performance-policy.cjs");
+				const { recentUserText } = createRequire(import.meta.url)("./bin/mistake-relevance-policy.cjs");
+				return buildCompactErrorMemoryReminder(selectRelevantErrorMemoryPatterns(patterns, recentUserText(this.agent.context.history)));
+			} catch {}
 			return buildErrorMemoryReminder(patterns);
 		}
 	};

package/package.json

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