blun-king-cli 9.1.455 → 9.1.457

package/bin/cognitive-action-checkpoint.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 const crypto = require('node:crypto');
+const { extractChecksumClaims } = require('./outbound-claim-provenance.cjs');
 
 const PHASES = new Set(['orient', 'plan', 'act', 'verify', 'learn', 'wait']);
 const EVIDENCE_BASES = new Set([
@@ -237,6 +238,9 @@ function normalizeRuntimeExternalReportSource(input) {
     throw new TypeError('trusted external report source is invalid');
   }
   const reporter = bounded(input.reporter ?? input.reporterId, 'external report reporter', 128);
+  const claimTokens = extractChecksumClaims(
+    Array.isArray(input.claimTokens) ? input.claimTokens.join(' ') : '',
+  );
   return Object.freeze({
     source: normalizedExternalReportSource(input.source),
     chatId: bounded(input.chatId, 'external report chatId', 64),
@@ -244,6 +248,7 @@ function normalizeRuntimeExternalReportSource(input) {
     reporter,
     reporterId: bounded(input.reporterId ?? reporter, 'external report reporterId', 128),
     occurredAt: normalizedTimestamp(input.occurredAt, 'external report occurredAt', true),
+    ...(claimTokens.length > 0 ? { claimTokens } : {}),
   });
 }
 
@@ -292,17 +297,8 @@ function normalizeExternalReportOrigin(input) {
   });
 }
 
-function resolveExternalReportOrigin(selectorInput, runtimeExternalReports) {
-  const selector = normalizeExternalReportSelector(selectorInput);
-  const reports = Array.isArray(runtimeExternalReports)
-    ? runtimeExternalReports.map(normalizeRuntimeExternalReportSource)
-    : [];
-  const report = reports.find((candidate) => candidate.source === selector.source
-    && candidate.chatId === selector.chatId
-    && candidate.messageId === selector.messageId);
-  if (report === undefined) {
-    throw new TypeError('externalReportSource does not match a trusted external report in the current turn');
-  }
+function externalReportOriginFromRuntimeSource(input) {
+  const report = normalizeRuntimeExternalReportSource(input);
   const reporterRef = crypto.createHash('sha256')
     .update(`external-report-reporter:${report.source}\0${report.reporterId}`)
     .digest('hex')
@@ -320,6 +316,20 @@ function resolveExternalReportOrigin(selectorInput, runtimeExternalReports) {
   });
 }
 
+function resolveExternalReportOrigin(selectorInput, runtimeExternalReports) {
+  const selector = normalizeExternalReportSelector(selectorInput);
+  const reports = Array.isArray(runtimeExternalReports)
+    ? runtimeExternalReports.map(normalizeRuntimeExternalReportSource)
+    : [];
+  const report = reports.find((candidate) => candidate.source === selector.source
+    && candidate.chatId === selector.chatId
+    && candidate.messageId === selector.messageId);
+  if (report === undefined) {
+    throw new TypeError('externalReportSource does not match a trusted external report in the current turn');
+  }
+  return externalReportOriginFromRuntimeSource(report);
+}
+
 function normalizedEvidenceProducerRef(value, field = 'evidence producer ref') {
   const ref = String(value ?? '').trim();
   if (!EVIDENCE_PRODUCER_REF_RE.test(ref)) throw new TypeError(`${field} is invalid`);
@@ -1068,6 +1078,7 @@ module.exports = {
   completionCriterionRef,
   evidenceProducerRef,
   emptyActionEvidenceReceipt,
+  externalReportOriginFromRuntimeSource,
   externalReportSourceFromChannelMeta,
   externalReportSourcesFromOrigin,
   normalizeActionCheckpoint,

package/bin/outbound-claim-provenance.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+const MAX_CLAIMS = 32;
+const MAX_CONFLICT_ORIGINS = 8;
+const CHECKSUM_CLAIM_RE = /(?<![A-Za-z0-9])[A-Fa-f0-9]{16,128}(?![A-Za-z0-9])/gu;
+const TELEGRAM_MESSAGE_TOOL_RE = /^mcp__[^\s]*telegram[^\s]*__(?:reply|edit_message)$/iu;
+const REF_RE = /^[a-f0-9]{16}$/u;
+const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}(?::?\d{2})?)$/u;
+
+function extractChecksumClaims(value) {
+  const claims = [];
+  const seen = new Set();
+  const text = typeof value === 'string' ? value : String(value ?? '');
+  for (const match of text.matchAll(CHECKSUM_CLAIM_RE)) {
+    const claim = match[0].toLowerCase();
+    if (seen.has(claim)) continue;
+    seen.add(claim);
+    claims.push(claim);
+    if (claims.length >= MAX_CLAIMS) break;
+  }
+  return Object.freeze(claims);
+}
+
+function boundedText(value, max) {
+  const text = String(value ?? '')
+    .replace(/[\u0000-\u001f\u007f]+/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim();
+  return text.length > 0 ? text.slice(0, max) : undefined;
+}
+
+function optionalRef(value) {
+  const ref = String(value ?? '').trim().toLowerCase();
+  return REF_RE.test(ref) ? ref : undefined;
+}
+
+function optionalTimestamp(value) {
+  const timestamp = String(value ?? '').trim();
+  return ISO_TIMESTAMP_RE.test(timestamp) ? timestamp : undefined;
+}
+
+function normalizedExternalReports(value) {
+  if (!Array.isArray(value)) return [];
+  const reports = [];
+  for (const report of value.slice(0, MAX_CLAIMS)) {
+    if (!report || typeof report !== 'object' || Array.isArray(report)) continue;
+    const reporter = boundedText(report.reporter, 128);
+    const eventRef = optionalRef(report.eventRef);
+    const occurredAt = optionalTimestamp(report.occurredAt);
+    const claimTokens = extractChecksumClaims(
+      Array.isArray(report.claimTokens) ? report.claimTokens.join(' ') : '',
+    );
+    if (reporter === undefined || eventRef === undefined || occurredAt === undefined || claimTokens.length === 0) continue;
+    const reporterRef = optionalRef(report.reporterRef);
+    reports.push(Object.freeze({ reporter, reporterRef, eventRef, occurredAt, claimTokens }));
+  }
+  return reports;
+}
+
+function externalClaimOrigin(report) {
+  return Object.freeze({
+    reporter: report.reporter,
+    ...(report.reporterRef !== undefined ? { reporterRef: report.reporterRef } : {}),
+    eventRef: report.eventRef,
+    occurredAt: report.occurredAt,
+  });
+}
+
+function assessOutboundClaimProvenance({ text, localClaims = [], externalReports = [] } = {}) {
+  const claims = extractChecksumClaims(text);
+  const local = new Set(extractChecksumClaims(Array.isArray(localClaims) ? localClaims.join(' ') : ''));
+  const reports = normalizedExternalReports(externalReports);
+  const localMatches = [];
+  const externalMatches = [];
+  const conflicted = [];
+  const unattributed = [];
+
+  for (const value of claims) {
+    if (local.has(value)) {
+      localMatches.push(value);
+      continue;
+    }
+    const matchingByEvent = new Map();
+    for (const report of reports) {
+      if (report.claimTokens.includes(value) && !matchingByEvent.has(report.eventRef)) {
+        matchingByEvent.set(report.eventRef, report);
+      }
+    }
+    const matchingReports = [...matchingByEvent.values()];
+    if (matchingReports.length === 0) {
+      unattributed.push(value);
+      continue;
+    }
+    if (matchingReports.length > 1) {
+      conflicted.push(Object.freeze({
+        value,
+        totalOrigins: matchingReports.length,
+        reports: Object.freeze(
+          matchingReports.slice(0, MAX_CONFLICT_ORIGINS).map(externalClaimOrigin),
+        ),
+      }));
+      continue;
+    }
+    const [report] = matchingReports;
+    const external = {
+      value,
+      ...externalClaimOrigin(report),
+    };
+    externalMatches.push(Object.freeze(external));
+  }
+
+  return Object.freeze({
+    local: Object.freeze(localMatches),
+    external: Object.freeze(externalMatches),
+    conflicted: Object.freeze(conflicted),
+    unattributed: Object.freeze(unattributed),
+  });
+}
+
+function normalizedToolArgs(input) {
+  if (input && typeof input === 'object' && !Array.isArray(input)) return input;
+  if (typeof input !== 'string') return undefined;
+  try {
+    const parsed = JSON.parse(input);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function provenanceAdvisoryForToolCall({ toolName, toolArgs, localClaims, externalReports } = {}) {
+  if (!TELEGRAM_MESSAGE_TOOL_RE.test(String(toolName ?? ''))) return null;
+  const args = normalizedToolArgs(toolArgs);
+  if (args === undefined || typeof args.text !== 'string') return null;
+  const assessment = assessOutboundClaimProvenance({
+    text: args.text,
+    localClaims,
+    externalReports,
+  });
+  if (assessment.external.length === 0
+      && assessment.conflicted.length === 0
+      && assessment.unattributed.length === 0) return null;
+  return Object.freeze({ ...assessment, blocked: false });
+}
+
+module.exports = {
+  assessOutboundClaimProvenance,
+  extractChecksumClaims,
+  provenanceAdvisoryForToolCall,
+};

package/blun.mjs

@@ -21463,7 +21463,8 @@ var { rollbackPersonalityChoice, setPersonalityEnabledAtomic } = createRequire(i
 var { projectSoulText } = createRequire(import.meta.url)("./bin/soul-organization-policy.cjs");
 var { soulFileInstruction } = createRequire(import.meta.url)("./bin/soul-preservation-policy.cjs");
 var { readProfilePersona, resolveSoulFile } = createRequire(import.meta.url)("./bin/profile-identity-resolution.cjs");
-var { advanceActionEvidenceReceipt, assertActionCheckpointEvidenceBasis, assertActionCheckpointRevision, emptyActionEvidenceReceipt, evidenceProducerRef, externalReportSourcesFromOrigin, normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
+var { advanceActionEvidenceReceipt, assertActionCheckpointEvidenceBasis, assertActionCheckpointRevision, emptyActionEvidenceReceipt, evidenceProducerRef, externalReportOriginFromRuntimeSource, externalReportSourcesFromOrigin, normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
+var { extractChecksumClaims, provenanceAdvisoryForToolCall } = createRequire(import.meta.url)("./bin/outbound-claim-provenance.cjs");
 var { evaluateGoalCompletionEvidence } = createRequire(import.meta.url)("./bin/goal-completion-evidence-policy.cjs");
 async function prepareSystemPromptContext(kaos, brandHome, options) {
 	const additionalDirs = normalizeAdditionalDirs(options?.additionalDirs ?? []);
@@ -261828,6 +261829,7 @@ var init_turn = __esmMin((() => {
 		cognitiveToolBatchesByTurn = /* @__PURE__ */ new Map();
 		cognitiveActionEvidenceByTurn = /* @__PURE__ */ new Map();
 		cognitiveExternalReportsByTurn = /* @__PURE__ */ new Map();
+		cognitiveLocalClaimsByTurn = /* @__PURE__ */ new Map();
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261924,6 +261926,59 @@ var init_turn = __esmMin((() => {
 		externalReportSourcesForCurrentTurn() {
 			return this.cognitiveExternalReportsByTurn.get(this.currentId) ?? Object.freeze([]);
 		}
+		recordLocalClaimTokens(turnId, text) {
+			const incoming = extractChecksumClaims(text);
+			if (incoming.length === 0) return;
+			const current = this.cognitiveLocalClaimsByTurn.get(turnId) ?? [];
+			const merged = [...current];
+			const seen = new Set(current);
+			for (const claim of incoming) {
+				if (seen.has(claim)) continue;
+				seen.add(claim);
+				merged.push(claim);
+			}
+			this.cognitiveLocalClaimsByTurn.set(turnId, Object.freeze(merged.slice(-64)));
+		}
+		externalClaimReportsForCurrentTurn() {
+			return this.externalReportSourcesForCurrentTurn().map((source) => ({
+				...externalReportOriginFromRuntimeSource(source),
+				claimTokens: source.claimTokens ?? []
+			}));
+		}
+		emitOutboundClaimProvenanceAdvisory(turnId, event) {
+			try {
+				const provenanceAdvisory = provenanceAdvisoryForToolCall({
+					toolName: event.name,
+					toolArgs: event.args,
+					localClaims: this.cognitiveLocalClaimsByTurn.get(turnId) ?? [],
+					externalReports: this.externalClaimReportsForCurrentTurn()
+				});
+				if (provenanceAdvisory === null) return;
+				const external = provenanceAdvisory.external.map((entry) => `${entry.value} (${entry.reporter}; ${entry.eventRef}; ${entry.occurredAt})`).join(", ") || "-";
+				const conflicted = provenanceAdvisory.conflicted.map((entry) => `${entry.value} (${entry.reports.map((report) => `${report.reporter}; ${report.eventRef}; ${report.occurredAt}`).join(" | ")})`).join(", ") || "-";
+				const unattributed = provenanceAdvisory.unattributed.join(", ") || "-";
+				this.agent.emitEvent({
+					type: "warning",
+					code: "OUTBOUND_CLAIM_PROVENANCE",
+					message: uiText("sessionEvent.provenance.advisory", {
+						external,
+						conflicted,
+						unattributed
+					}),
+					blocked: false,
+					details: {
+						blocked: false,
+						external: provenanceAdvisory.external,
+						conflicted: provenanceAdvisory.conflicted,
+						unattributed: provenanceAdvisory.unattributed
+					}
+				});
+			} catch (error) {
+				this.agent.telemetry.track("outbound_claim_provenance_error", {
+					error_type: error?.code ?? error?.name ?? "Error"
+				});
+			}
+		}
 		projectCognitiveState(turnId, input) {
 			try {
 				const focusScopes = cognitiveFocusScopesForTurn(input);
@@ -262437,6 +262492,7 @@ var init_turn = __esmMin((() => {
 			this.interruptedTelemetryTurnIds.delete(turnId);
 			this.cognitiveActionEvidenceByTurn.delete(turnId);
 			this.cognitiveExternalReportsByTurn.delete(turnId);
+			this.cognitiveLocalClaimsByTurn.delete(turnId);
 			this.stepFailureByTurn.delete(turnId);
 			await this.agent.records.flush();
 			return {
@@ -262827,6 +262883,7 @@ var init_turn = __esmMin((() => {
 			if (event.type === "tool.call") {
 				const dupType = this.trackDuplicateToolCall(turnId, event.step, event.name, event.args);
 				this.toolCallDupType.set(event.toolCallId, dupType === "cross_step" ? "cross_step" : "normal");
+				this.emitOutboundClaimProvenanceAdvisory(turnId, event);
 				this.toolCallStartedAt.set(event.toolCallId, {
 					name: event.name,
 					args: event.args,
@@ -262842,6 +262899,7 @@ var init_turn = __esmMin((() => {
 			if (event.type === "tool.result") {
 				const started = this.toolCallStartedAt.get(event.toolCallId);
 				if (started === void 0) return;
+				this.recordLocalClaimTokens(turnId, toolResultText(event.result));
 				rememberDeferredToolAfterNotFound(this.loadedToolNames, started.name, event.result);
 				this.toolCallStartedAt.delete(event.toolCallId);
 				const dupType = this.toolCallDupType.get(event.toolCallId) ?? "normal";
@@ -419288,7 +419346,8 @@ function injectChannelEnvelope(host, envelope, preamble) {
 		messageId: envelope.meta.message_id,
 		reporter: envelope.meta.user,
 		reporterId: envelope.meta.user_id,
-		occurredAt: envelope.meta.ts
+		occurredAt: envelope.meta.ts,
+		claimTokens: extractChecksumClaims(envelope.text)
 	};
 	if (contextOnly) {
 		bufferContext(preamble, envelope.meta.chat_id, envelope.tag, reportSource);
@@ -506413,6 +506472,7 @@ registerUiCatalogFragment({
 		"sessionEvent.goalQueue.blockedTitle": "Goal blocked.",
 		"sessionEvent.goalQueue.blockedDetail": "The next queued goal will start only after this goal is complete.",
 		"sessionEvent.warning": "Warning: {message}",
+		"sessionEvent.provenance.advisory": "Source check before sending; the message was not blocked. Forwarded report: {external}. Ambiguous source events: {conflicted}. Not found in this turn's tool output or a source event: {unattributed}. Forwarding is allowed, but do not present these values as your own measurement.",
 		"sessionEvent.mcp.tool.one": "{count} tool",
 		"sessionEvent.mcp.tool.other": "{count} tools",
 		"sessionEvent.mcp.connected": "MCP server \"{name}\" connected · {tools} ({transport})",
@@ -506443,6 +506503,7 @@ registerUiCatalogFragment({
 		"sessionEvent.goalQueue.blockedTitle": "Ziel blockiert.",
 		"sessionEvent.goalQueue.blockedDetail": "Das nächste vorgemerkte Ziel startet erst, wenn dieses Ziel abgeschlossen ist.",
 		"sessionEvent.warning": "Warnung: {message}",
+		"sessionEvent.provenance.advisory": "Herkunftsprüfung vor dem Senden; die Nachricht wurde nicht blockiert. Weitergeleiteter Bericht: {external}. Mehrdeutige Quellereignisse: {conflicted}. Weder in einer Werkzeugausgabe dieses Durchlaufs noch in einem Quellereignis gefunden: {unattributed}. Die Weitergabe ist erlaubt, diese Werte dürfen jedoch nicht als eigene Messung dargestellt werden.",
 		"sessionEvent.mcp.tool.one": "{count} Tool",
 		"sessionEvent.mcp.tool.other": "{count} Tools",
 		"sessionEvent.mcp.connected": "MCP-Server „{name}“ verbunden · {tools} ({transport})",
@@ -506473,6 +506534,7 @@ registerUiCatalogFragment({
 		"sessionEvent.goalQueue.blockedTitle": "Objetivo bloqueado.",
 		"sessionEvent.goalQueue.blockedDetail": "El siguiente objetivo en cola no se iniciará hasta que este objetivo se complete.",
 		"sessionEvent.warning": "Advertencia: {message}",
+		"sessionEvent.provenance.advisory": "Comprobación de procedencia antes de enviar; el mensaje no se bloqueó. Informe reenviado: {external}. Eventos de origen ambiguos: {conflicted}. No se encontraron en la salida de las herramientas de este turno ni en un evento de origen: {unattributed}. Se permite reenviar estos valores, pero no presentarlos como mediciones propias.",
 		"sessionEvent.mcp.tool.one": "{count} herramienta",
 		"sessionEvent.mcp.tool.other": "{count} herramientas",
 		"sessionEvent.mcp.connected": "Servidor MCP «{name}» conectado · {tools} ({transport})",
@@ -506503,6 +506565,7 @@ registerUiCatalogFragment({
 		"sessionEvent.goalQueue.blockedTitle": "Objectif bloqué.",
 		"sessionEvent.goalQueue.blockedDetail": "L’objectif suivant ne démarrera qu’une fois cet objectif terminé.",
 		"sessionEvent.warning": "Avertissement : {message}",
+		"sessionEvent.provenance.advisory": "Vérification de la provenance avant l’envoi ; le message n’a pas été bloqué. Rapport transmis : {external}. Événements source ambigus : {conflicted}. Valeurs introuvables dans la sortie des outils de ce tour et dans les événements source : {unattributed}. Leur transmission est autorisée, mais ne les présentez pas comme vos propres mesures.",
 		"sessionEvent.mcp.tool.one": "{count} outil",
 		"sessionEvent.mcp.tool.other": "{count} outils",
 		"sessionEvent.mcp.connected": "Serveur MCP « {name} » connecté · {tools} ({transport})",
@@ -506533,6 +506596,7 @@ registerUiCatalogFragment({
 		"sessionEvent.goalQueue.blockedTitle": "Målet är blockerat.",
 		"sessionEvent.goalQueue.blockedDetail": "Nästa köade mål startar först när det här målet är slutfört.",
 		"sessionEvent.warning": "Varning: {message}",
+		"sessionEvent.provenance.advisory": "Ursprungskontroll före sändning; meddelandet blockerades inte. Vidarebefordrad rapport: {external}. Tvetydiga källhändelser: {conflicted}. Hittades varken i verktygsutdata från den här körningen eller i en källhändelse: {unattributed}. Värdena får vidarebefordras, men framställ dem inte som egna mätningar.",
 		"sessionEvent.mcp.tool.one": "{count} verktyg",
 		"sessionEvent.mcp.tool.other": "{count} verktyg",
 		"sessionEvent.mcp.connected": "MCP-servern ”{name}” är ansluten · {tools} ({transport})",
@@ -506563,6 +506627,7 @@ registerUiCatalogFragment({
 		"sessionEvent.goalQueue.blockedTitle": "Cíl je blokován.",
 		"sessionEvent.goalQueue.blockedDetail": "Další cíl ve frontě se spustí pouze po dokončení tohoto cíle.",
 		"sessionEvent.warning": "Upozornění: {message}",
+		"sessionEvent.provenance.advisory": "Kontrola původu před odesláním; zpráva nebyla zablokována. Předaný report: {external}. Nejednoznačné zdrojové události: {conflicted}. Nenalezeno ve výstupu nástrojů tohoto kola ani ve zdrojové události: {unattributed}. Tyto hodnoty lze předat dál, ale neuvádějte je jako vlastní měření.",
 		"sessionEvent.mcp.tool.one": "Nástroje: {count}",
 		"sessionEvent.mcp.tool.other": "Nástroje: {count}",
 		"sessionEvent.mcp.connected": "Server MCP \"{name}\" připojen · {tools} ({transport})",

package/package.json

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