blun-king-cli 9.1.444 → 9.1.445

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.445",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {