blun-king-cli 9.1.444 → 9.1.446

package/bin/live-response-repetition-guard.cjs

@@ -5,6 +5,11 @@ const DEFAULT_WINDOW_WORDS = 20;
 const DEFAULT_REQUIRED_OCCURRENCES = 4;
 const DEFAULT_MAX_CHARS = 24_000;
 const DEFAULT_CHECK_EVERY_WORDS = 24;
+const DEFAULT_SHORT_BURST_MAX_WORDS = 8;
+const DEFAULT_SHORT_BURST_MIN_OCCURRENCES = 8;
+const DEFAULT_SHORT_BURST_MIN_TOTAL_WORDS = 24;
+const DEFAULT_SHORT_BURST_MIN_WORDS = 2;
+const DEFAULT_SHORT_BURST_SCAN_WORDS = 192;
 
 function normalizeWords(text) {
   return String(text)
@@ -40,16 +45,80 @@ function repeatedWindow(words, options) {
   return null;
 }
 
+function equalWindow(words, left, right, width) {
+  for (let offset = 0; offset < width; offset += 1) {
+    if (words[left + offset] !== words[right + offset]) return false;
+  }
+  return true;
+}
+
+function canCloseConsecutiveWindow(words, minWords, maxWords) {
+  const lastIndex = words.length - 1;
+  for (let windowWords = minWords; windowWords <= maxWords; windowWords += 1) {
+    const previousIndex = lastIndex - windowWords;
+    if (previousIndex >= 0 && words[lastIndex] === words[previousIndex]) return true;
+  }
+  return false;
+}
+
+function repeatedConsecutiveWindow(words, options) {
+  const {
+    maxWords,
+    minOccurrences,
+    minTotalWords,
+    minWords,
+    scanWords,
+    firstEnd = 1,
+  } = options;
+  const sourceStart = Math.max(0, words.length - scanWords);
+  const localFirstEnd = Math.max(sourceStart + 1, firstEnd);
+
+  for (let end = localFirstEnd; end <= words.length; end += 1) {
+    for (let windowWords = minWords; windowWords <= maxWords; windowWords += 1) {
+      const requiredOccurrences = Math.max(
+        minOccurrences,
+        Math.ceil(minTotalWords / windowWords),
+      );
+      const requiredSpan = windowWords * requiredOccurrences;
+      const start = end - requiredSpan;
+      if (start < sourceStart) continue;
+      let count = 1;
+      let cursor = start + windowWords;
+      while (cursor + windowWords <= end
+        && equalWindow(words, start, cursor, windowWords)) {
+        count += 1;
+        cursor += windowWords;
+      }
+      if (count < requiredOccurrences) continue;
+      return {
+        kind: 'short_burst',
+        count,
+        firstWords: words.slice(start, start + windowWords).join(' '),
+      };
+    }
+  }
+  return null;
+}
+
 function createLiveResponseRepetitionGuard(options = {}) {
   const config = {
     checkEveryWords: options.checkEveryWords ?? DEFAULT_CHECK_EVERY_WORDS,
     maxChars: options.maxChars ?? DEFAULT_MAX_CHARS,
     minWords: options.minWords ?? DEFAULT_MIN_WORDS,
     requiredOccurrences: options.requiredOccurrences ?? DEFAULT_REQUIRED_OCCURRENCES,
+    shortBurstMaxWords: options.shortBurstMaxWords ?? DEFAULT_SHORT_BURST_MAX_WORDS,
+    shortBurstMinOccurrences: options.shortBurstMinOccurrences
+      ?? DEFAULT_SHORT_BURST_MIN_OCCURRENCES,
+    shortBurstMinTotalWords: options.shortBurstMinTotalWords
+      ?? DEFAULT_SHORT_BURST_MIN_TOTAL_WORDS,
+    shortBurstMinWords: options.shortBurstMinWords ?? DEFAULT_SHORT_BURST_MIN_WORDS,
+    shortBurstScanWords: options.shortBurstScanWords ?? DEFAULT_SHORT_BURST_SCAN_WORDS,
     windowWords: options.windowWords ?? DEFAULT_WINDOW_WORDS,
   };
   let text = '';
   let lastCheckedWords = 0;
+  let lastShortBurstLastWord = '';
+  let lastShortBurstWordCount = 0;
   let detection = null;
 
   return {
@@ -57,12 +126,46 @@ function createLiveResponseRepetitionGuard(options = {}) {
       if (detection !== null || typeof delta !== 'string' || delta.length === 0) return detection;
       text = `${text}${delta}`.slice(-config.maxChars);
       const words = normalizeWords(text);
+      const previousShortBurstWordCount = lastShortBurstWordCount;
+      const lastWord = words.at(-1) ?? '';
+      const wordCountChanged = words.length !== previousShortBurstWordCount;
+      const lastWordChanged = lastWord !== lastShortBurstLastWord;
+      const firstChangedEnd = words.length > lastShortBurstWordCount
+        ? Math.max(1, lastShortBurstWordCount)
+        : words.length;
+      const shouldCheckShortBurst = wordCountChanged || (lastWordChanged
+        && canCloseConsecutiveWindow(
+          words,
+          config.shortBurstMinWords,
+          config.shortBurstMaxWords,
+        ));
+      lastShortBurstLastWord = lastWord;
+      lastShortBurstWordCount = words.length;
+      if (words.length >= config.shortBurstMinTotalWords && shouldCheckShortBurst) {
+        const shortBurst = repeatedConsecutiveWindow(words, {
+          firstEnd: firstChangedEnd,
+          maxWords: config.shortBurstMaxWords,
+          minOccurrences: config.shortBurstMinOccurrences,
+          minTotalWords: config.shortBurstMinTotalWords,
+          minWords: config.shortBurstMinWords,
+          scanWords: config.shortBurstScanWords,
+        });
+        if (shortBurst !== null) {
+          detection = {
+            ...shortBurst,
+            charCount: text.length,
+            wordCount: words.length,
+          };
+          return detection;
+        }
+      }
       if (words.length < config.minWords) return null;
       if (words.length - lastCheckedWords < config.checkEveryWords) return null;
       lastCheckedWords = words.length;
       const repeated = repeatedWindow(words, config);
       if (repeated === null) return null;
       detection = {
+        kind: 'long_window',
         ...repeated,
         charCount: text.length,
         wordCount: words.length,
@@ -80,8 +183,14 @@ module.exports = {
   DEFAULT_MAX_CHARS,
   DEFAULT_MIN_WORDS,
   DEFAULT_REQUIRED_OCCURRENCES,
+  DEFAULT_SHORT_BURST_MAX_WORDS,
+  DEFAULT_SHORT_BURST_MIN_OCCURRENCES,
+  DEFAULT_SHORT_BURST_MIN_TOTAL_WORDS,
+  DEFAULT_SHORT_BURST_MIN_WORDS,
+  DEFAULT_SHORT_BURST_SCAN_WORDS,
   DEFAULT_WINDOW_WORDS,
   createLiveResponseRepetitionGuard,
   normalizeWords,
+  repeatedConsecutiveWindow,
   repeatedWindow,
 };

package/bin/validated-learning-outcome-trace.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SCHEMA_VERSION = 1;
+const MAX_LESSONS = 5;
+const MAX_HEADING_CHARS = 160;
+const MAX_SEMANTIC_MATCHES = 6;
+const CANDIDATE_ID = /^vl-[a-f0-9]{32}$/u;
+
+function cleanText(value, maxChars) {
+  const text = String(value ?? '')
+    .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim();
+  return text.slice(0, maxChars);
+}
+
+function lessonKey(reference, heading) {
+  return crypto.createHash('sha256')
+    .update(`${String(reference ?? '')}\0${heading}`)
+    .digest('hex')
+    .slice(0, 24);
+}
+
+function normalizeLessons(value) {
+  if (!Array.isArray(value)) return [];
+  const lessons = [];
+  const seen = new Set();
+  for (const item of value) {
+    const heading = cleanText(item?.heading, MAX_HEADING_CHARS);
+    if (!heading) continue;
+    const key = lessonKey(item?.reference, heading);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const semanticMatches = [...new Set(
+      (Array.isArray(item?.semanticMatches) ? item.semanticMatches : [])
+        .map((tag) => cleanText(tag, 48))
+        .filter(Boolean),
+    )].sort().slice(0, MAX_SEMANTIC_MATCHES);
+    lessons.push({
+      lessonKey: key,
+      heading,
+      ...(semanticMatches.length > 0 ? { semanticMatches } : {}),
+    });
+    if (lessons.length >= MAX_LESSONS) break;
+  }
+  return lessons;
+}
+
+function atomicCreate(filePath, value) {
+  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 readTrace(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function recordValidatedLearningOutcomeTrace(candidate, selectedLessons, options = {}) {
+  if (candidate?.source !== 'current_turn'
+    || candidate.status !== 'pending'
+    || !CANDIDATE_ID.test(String(candidate.id ?? ''))
+    || typeof candidate.filePath !== 'string'
+    || !candidate.filePath) return null;
+  const lessons = normalizeLessons(selectedLessons);
+  if (lessons.length === 0) return null;
+
+  const directory = path.dirname(candidate.filePath);
+  const filePath = path.join(directory, `${candidate.id}.lesson-exposure.jsonl`);
+  const trace = {
+    schemaVersion: SCHEMA_VERSION,
+    type: 'lesson_exposure_red_green',
+    status: 'observed',
+    candidateId: candidate.id,
+    outcome: 'validated_red_green',
+    causalAttribution: false,
+    lessons,
+    recordedAt: new Date((options.now || Date.now)()).toISOString(),
+  };
+  const created = atomicCreate(filePath, trace);
+  return {
+    created,
+    filePath,
+    trace: created ? trace : readTrace(filePath),
+  };
+}
+
+module.exports = {
+  normalizeLessons,
+  recordValidatedLearningOutcomeTrace,
+};

package/blun.mjs

@@ -231592,6 +231592,7 @@ var init_mistake_md = __esmMin((() => {
 		reserveChecked = false;
 		mistakeDir;
 		mistakeFile;
+		selectedLessons = [];
 		constructor(agent) {
 			super(agent);
 			this.mistakeDir = resolveMistakeDir(agent.blunHomeDir);
@@ -231600,6 +231601,10 @@ var init_mistake_md = __esmMin((() => {
 		onContextClear() {
 			super.onContextClear();
 			this.reserveChecked = false;
+			this.selectedLessons = [];
+		}
+		getSelectedLessons() {
+			return this.selectedLessons.map((lesson) => ({ ...lesson }));
 		}
 		async inject() {
 			const injection = await this.getInjection();
@@ -231619,6 +231624,7 @@ var init_mistake_md = __esmMin((() => {
 			});
 		}
 		async getInjection() {
+			this.selectedLessons = [];
 			try {
 				if (isLowInformationMistakeTurn(this.agent.context.history)) return void 0;
 				const sources = await readProjectMistakeSources(this.agent);
@@ -231638,6 +231644,7 @@ var init_mistake_md = __esmMin((() => {
 				const query = mistakeQueryTextForTurn(this.agent.context.history, this.agent.goal.getGoal().goal);
 				const selected = selectRelevantMistakeSources(sources, query);
 				if (!selected.text) return void 0;
+				this.selectedLessons = selected.selected;
 				let prefix = "";
 				if (!this.reserveChecked && sharedContent) {
 					this.reserveChecked = true;
@@ -232243,13 +232250,19 @@ function buildValidatedLearningSignalReminder(signal) {
 	lines.push("</validated-learning-signal>");
 	return lines.join("\n");
 }
-var ValidatedLearningSignalInjector, shouldSyncValidatedLearningCandidate, syncValidatedLearningCandidate;
+var ValidatedLearningSignalInjector, recordValidatedLearningOutcomeTrace, 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"));
+	({ recordValidatedLearningOutcomeTrace } = createRequire(import.meta.url)("./bin/validated-learning-outcome-trace.cjs"));
 	ValidatedLearningSignalInjector = class extends DynamicInjector {
 		injectionVariant = "validated_learning_signal";
+		selectedLessons;
+		constructor(agent, selectedLessons) {
+			super(agent);
+			this.selectedLessons = selectedLessons;
+		}
 		async inject() {
 			const existing = this.agent.context.history.filter(isValidatedLearningSignalReminder);
 			if (!shouldSyncValidatedLearningCandidate(this.agent.context.history)) return;
@@ -232262,6 +232275,9 @@ var init_validated_learning_signal = __esmMin((() => {
 				if (existing.length > 0) this.agent.context.removeSystemRemindersMatching(isValidatedLearningSignalReminder);
 				return;
 			}
+			if (signal.source === "current_turn") try {
+				recordValidatedLearningOutcomeTrace(signal, this.selectedLessons?.() ?? []);
+			} catch {}
 			const injection = buildValidatedLearningSignalReminder(signal);
 			const expected = `<system-reminder>\n${injection}\n</system-reminder>`;
 			if (existing.length === 1 && reminderText(existing[0]) === expected) return;
@@ -233086,13 +233102,14 @@ var init_manager$2 = __esmMin((() => {
 		missionContractInjector = null;
 		constructor(agent) {
 			this.agent = agent;
+			const mistakeMdInjector = new MistakeMdInjector(agent);
 			this.injectors = [
 				new PluginSessionStartInjector(agent),
 				new ErrorMemoryInjector(agent),
 				new ToolAwarenessInjector(agent),
-				new MistakeMdInjector(agent),
+				mistakeMdInjector,
 				new RepeatedAssistantResponseInjector(agent),
-				new ValidatedLearningSignalInjector(agent),
+				new ValidatedLearningSignalInjector(agent, () => mistakeMdInjector.getSelectedLessons()),
 				new ActionStyleInjector(agent),
 				new PlanModeInjector(agent),
 				new PermissionModeInjector(agent)

package/package.json

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