blun-king-cli 9.1.443 → 9.1.445

package/bin/mistake-relevance-policy.cjs

@@ -6,6 +6,7 @@ const {
 
 const DEFAULT_MAX_CHARS = 3_000;
 const DEFAULT_MAX_SECTIONS = 5;
+const GOAL_MISTAKE_QUERY_MAX_CHARS = 2_000;
 const RECENT_USER_MESSAGES = 4;
 const NON_ACTIONABLE_USER_ORIGINS = new Set([
   'background_task',
@@ -86,6 +87,55 @@ function recentUserText(history, limit = RECENT_USER_MESSAGES) {
     .join('\n');
 }
 
+function boundedQueryValue(value, maxChars = 320) {
+  const text = String(value ?? '')
+    .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim();
+  if (!text) return '';
+  return text.length <= maxChars ? text : `${text.slice(0, maxChars - 3).trimEnd()}...`;
+}
+
+function goalMistakeQuery(goal) {
+  if (!goal || typeof goal !== 'object' || Array.isArray(goal) || goal.status !== 'active') return '';
+  const objective = boundedQueryValue(goal.objective, 512);
+  if (!objective) return '';
+  const checkpoint = goal.actionCheckpoint && typeof goal.actionCheckpoint === 'object'
+    && !Array.isArray(goal.actionCheckpoint) ? goal.actionCheckpoint : null;
+  const frame = checkpoint?.problemFrame && typeof checkpoint.problemFrame === 'object'
+    && !Array.isArray(checkpoint.problemFrame) ? checkpoint.problemFrame : null;
+  const lines = [`Goal: ${objective}`];
+  const add = (label, value, maxChars = 320) => {
+    const bounded = boundedQueryValue(value, maxChars);
+    if (bounded) lines.push(`${label}: ${bounded}`);
+  };
+  add('Completion criterion', goal.completionCriterion, 384);
+  add('Phase', checkpoint?.phase, 32);
+  add('Last verified', checkpoint?.lastVerified);
+  add('Next action', checkpoint?.nextAction);
+  const gaps = Array.isArray(frame?.missingKnowledge)
+    ? frame.missingKnowledge.slice(0, 5).map((item) => boundedQueryValue(item, 256)).filter(Boolean)
+    : [];
+  if (gaps.length > 0) lines.push(`Missing knowledge: ${gaps.join(' | ')}`);
+  add('Selected action', frame?.selectedAction);
+  add('Selection reason', frame?.selectionReason);
+  add('Support choice', frame?.supportChoice, 256);
+  add('Risk', frame?.risk);
+  add('Expected evidence', checkpoint?.expectedEvidence, 384);
+  return lines.join('\n').slice(0, GOAL_MISTAKE_QUERY_MAX_CHARS).trimEnd();
+}
+
+function mistakeQueryTextForTurn(history, goal) {
+  const latestInput = Array.isArray(history) ? history.findLast(isActionableMistakeInput) : undefined;
+  const isGoalContinuation = latestInput?.origin?.kind === 'system_trigger'
+    && latestInput.origin.name === 'goal_continuation';
+  if (isGoalContinuation) {
+    const query = goalMistakeQuery(goal);
+    if (query) return query;
+  }
+  return recentUserText(history);
+}
+
 function isLowInformationMistakeTurn(history) {
   if (!Array.isArray(history)) return false;
   const message = history.findLast(isActionableMistakeInput);
@@ -258,8 +308,10 @@ function selectRelevantMistakeContent(source, query, options = {}) {
 module.exports = {
   DEFAULT_MAX_CHARS,
   DEFAULT_MAX_SECTIONS,
+  GOAL_MISTAKE_QUERY_MAX_CHARS,
   RECENT_USER_MESSAGES,
   isLowInformationMistakeTurn,
+  mistakeQueryTextForTurn,
   recentUserText,
   semanticSignalTags,
   selectRelevantMistakeContent,

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

@@ -231582,16 +231582,17 @@ async function readProjectMistakeSources(agent) {
 	}
 	return sources;
 }
-var MistakeMdInjector, isLowInformationMistakeTurn, recentUserText, selectRelevantMistakeSources;
+var MistakeMdInjector, isLowInformationMistakeTurn, mistakeQueryTextForTurn, selectRelevantMistakeSources;
 var init_mistake_md = __esmMin((() => {
 	init_injector();
 	init_mistake_md_writer();
-	({ isLowInformationMistakeTurn, recentUserText, selectRelevantMistakeSources } = createRequire(import.meta.url)("./bin/mistake-relevance-policy.cjs"));
+	({ isLowInformationMistakeTurn, mistakeQueryTextForTurn, selectRelevantMistakeSources } = createRequire(import.meta.url)("./bin/mistake-relevance-policy.cjs"));
 	MistakeMdInjector = class extends DynamicInjector {
 		injectionVariant = "mistake_md";
 		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);
@@ -231635,9 +231641,10 @@ var init_mistake_md = __esmMin((() => {
 					content: sharedContent
 				});
 				if (sources.length === 0) return void 0;
-				const query = recentUserText(this.agent.context.history);
+				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.443",
+  "version": "9.1.445",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {