blun-king-cli 9.1.454 → 9.1.456

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([
@@ -14,15 +15,20 @@ const TRIGGER_KINDS = new Set([
 ]);
 const VERIFICATION_SUBJECTS = new Set(['result', 'verifier']);
 const VERIFICATION_KINDS = new Set(['inspection', 'integrity', 'syntax', 'test', 'reachability']);
+const EXTERNAL_REPORT_SOURCES = new Set(['telegram']);
 const MODEL_KEYS = new Set([
-  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'verificationProof', 'nextTrigger', 'problemFrame', 'updatedAt',
+  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'verificationProof', 'nextTrigger', 'problemFrame', 'externalReportSource', 'updatedAt',
 ]);
-const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt']);
+const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt', 'externalReportOrigin']);
 const PROBLEM_FRAME_KEYS = new Set([
   'successCriterion', 'missingKnowledge', 'candidateActions', 'selectedAction',
   'selectionReason', 'supportChoice', 'risk', 'reversibility', 'decisionBasis',
 ]);
 const NEXT_TRIGGER_KEYS = new Set(['kind', 'condition', 'dueAt']);
+const EXTERNAL_REPORT_SELECTOR_KEYS = new Set(['source', 'chatId', 'messageId']);
+const EXTERNAL_REPORT_ORIGIN_KEYS = new Set([
+  'source', 'reporter', 'reporterRef', 'eventRef', 'occurredAt',
+]);
 const EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs', 'toolArgs',
   'resultEvidenceKinds', 'resultEvidenceScopes',
@@ -32,6 +38,7 @@ const REQUIRED_EVIDENCE_INPUT_KEYS = new Set([
 ]);
 const EVIDENCE_DIGEST_RE = /^[a-f0-9]{16}$/u;
 const EVIDENCE_PRODUCER_REF_RE = /^[a-f0-9]{16}$/u;
+const EXTERNAL_REPORT_REF_RE = /^[a-f0-9]{16}$/u;
 const DECISION_BASIS_RE = /^[a-f0-9]{16}$/u;
 const COMPLETION_CRITERION_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;
@@ -189,6 +196,140 @@ function evidenceProducerRef(identity) {
     .slice(0, 16);
 }
 
+function normalizedExternalReportSource(value, field = 'external report source') {
+  const source = String(value ?? '').trim();
+  if (!EXTERNAL_REPORT_SOURCES.has(source)) throw new TypeError(`${field} is invalid`);
+  return source;
+}
+
+function normalizeExternalReportSelector(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('externalReportSource is required for external_report evidenceBasis');
+  }
+  for (const key of Object.keys(input)) {
+    if (!EXTERNAL_REPORT_SELECTOR_KEYS.has(key)) {
+      throw new TypeError(`externalReportSource field is unsupported: ${key}`);
+    }
+  }
+  return Object.freeze({
+    source: normalizedExternalReportSource(input.source),
+    chatId: bounded(input.chatId, 'externalReportSource chatId', 64),
+    messageId: bounded(input.messageId, 'externalReportSource messageId', 64),
+  });
+}
+
+function externalReportSourceFromChannelMeta(meta) {
+  if (!meta || typeof meta !== 'object' || Array.isArray(meta)) {
+    throw new TypeError('channel metadata is required for external report provenance');
+  }
+  const reporter = bounded(meta.user ?? meta.user_id, 'external report reporter', 128);
+  return Object.freeze({
+    source: 'telegram',
+    chatId: bounded(meta.chat_id, 'external report chatId', 64),
+    messageId: bounded(meta.message_id, 'external report messageId', 64),
+    reporter,
+    reporterId: bounded(meta.user_id ?? reporter, 'external report reporterId', 128),
+    occurredAt: normalizedTimestamp(meta.ts, 'external report occurredAt', true),
+  });
+}
+
+function normalizeRuntimeExternalReportSource(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(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),
+    messageId: bounded(input.messageId, 'external report messageId', 64),
+    reporter,
+    reporterId: bounded(input.reporterId ?? reporter, 'external report reporterId', 128),
+    occurredAt: normalizedTimestamp(input.occurredAt, 'external report occurredAt', true),
+    ...(claimTokens.length > 0 ? { claimTokens } : {}),
+  });
+}
+
+function externalReportSourcesFromOrigin(origin) {
+  if (!origin || typeof origin !== 'object' || !Array.isArray(origin.externalReportSources)) {
+    return Object.freeze([]);
+  }
+  const sources = [];
+  const seen = new Set();
+  for (const value of origin.externalReportSources) {
+    let source;
+    try {
+      source = normalizeRuntimeExternalReportSource(value);
+    } catch {
+      continue;
+    }
+    const key = `${source.source}\0${source.chatId}\0${source.messageId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    sources.push(source);
+  }
+  return Object.freeze(sources.slice(0, 32));
+}
+
+function normalizedExternalReportRef(value, field) {
+  const ref = String(value ?? '').trim();
+  if (!EXTERNAL_REPORT_REF_RE.test(ref)) throw new TypeError(`${field} is invalid`);
+  return ref;
+}
+
+function normalizeExternalReportOrigin(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('externalReportOrigin is invalid');
+  }
+  for (const key of Object.keys(input)) {
+    if (!EXTERNAL_REPORT_ORIGIN_KEYS.has(key)) {
+      throw new TypeError(`externalReportOrigin field is unsupported: ${key}`);
+    }
+  }
+  return Object.freeze({
+    source: normalizedExternalReportSource(input.source, 'externalReportOrigin source'),
+    reporter: bounded(input.reporter, 'externalReportOrigin reporter', 128),
+    reporterRef: normalizedExternalReportRef(input.reporterRef, 'externalReportOrigin reporterRef'),
+    eventRef: normalizedExternalReportRef(input.eventRef, 'externalReportOrigin eventRef'),
+    occurredAt: normalizedTimestamp(input.occurredAt, 'externalReportOrigin occurredAt', true),
+  });
+}
+
+function externalReportOriginFromRuntimeSource(input) {
+  const report = normalizeRuntimeExternalReportSource(input);
+  const reporterRef = crypto.createHash('sha256')
+    .update(`external-report-reporter:${report.source}\0${report.reporterId}`)
+    .digest('hex')
+    .slice(0, 16);
+  const eventRef = crypto.createHash('sha256')
+    .update(`external-report-event:${report.source}\0${report.chatId}\0${report.messageId}\0${reporterRef}\0${report.occurredAt}`)
+    .digest('hex')
+    .slice(0, 16);
+  return Object.freeze({
+    source: report.source,
+    reporter: report.reporter,
+    reporterRef,
+    eventRef,
+    occurredAt: report.occurredAt,
+  });
+}
+
+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`);
@@ -753,7 +894,7 @@ function assertActionCheckpointRevision(current, input) {
   return inputRevision;
 }
 
-function assertActionCheckpointEvidenceBasis(current, input, runtimeEvidence) {
+function assertActionCheckpointEvidenceBasis(current, input, runtimeEvidence, runtimeExternalReports) {
   const basis = normalizedEvidenceBasis(input?.evidenceBasis);
   const epistemicState = normalizedEpistemicState(input?.epistemicState);
   if (basis === 'runtime_tool') {
@@ -765,8 +906,15 @@ function assertActionCheckpointEvidenceBasis(current, input, runtimeEvidence) {
       throw new TypeError('runtime_tool evidenceBasis requires verified epistemicState');
     }
   }
-  if (basis === 'external_report' && epistemicState === 'verified') {
-    throw new TypeError('external_report evidenceBasis cannot claim verified epistemicState');
+  if (basis === 'external_report') {
+    if (epistemicState === 'verified') {
+      throw new TypeError('external_report evidenceBasis cannot claim verified epistemicState');
+    }
+    if (runtimeExternalReports !== undefined) {
+      resolveExternalReportOrigin(input?.externalReportSource, runtimeExternalReports);
+    }
+  } else if (input?.externalReportSource !== undefined) {
+    throw new TypeError('externalReportSource requires external_report evidenceBasis');
   }
   if (basis === 'carried_forward') {
     if (!current) throw new TypeError('carried_forward evidenceBasis requires a current checkpoint');
@@ -817,6 +965,22 @@ function normalizeActionCheckpoint(input, options = {}) {
   if (input.nextTrigger !== undefined) checkpoint.nextTrigger = normalizeNextTrigger(input.nextTrigger, phase);
   else if (!replay) throw new TypeError('nextTrigger is required');
   if (input.problemFrame !== undefined) checkpoint.problemFrame = normalizeProblemFrame(input.problemFrame);
+  if (input.externalReportSource !== undefined && evidenceBasis !== 'external_report') {
+    throw new TypeError('externalReportSource requires external_report evidenceBasis');
+  }
+  if (evidenceBasis === 'external_report' && options.runtimeExternalReports !== undefined) {
+    checkpoint.externalReportOrigin = resolveExternalReportOrigin(
+      input.externalReportSource,
+      options.runtimeExternalReports,
+    );
+  } else if (replay && input.externalReportOrigin !== undefined) {
+    checkpoint.externalReportOrigin = normalizeExternalReportOrigin(input.externalReportOrigin);
+  } else if (evidenceBasis === 'carried_forward'
+      && options.previousCheckpoint?.externalReportOrigin !== undefined) {
+    checkpoint.externalReportOrigin = normalizeExternalReportOrigin(
+      options.previousCheckpoint.externalReportOrigin,
+    );
+  }
   const evidenceReceipt = options.runtimeEvidence !== undefined
     ? normalizeActionEvidenceReceipt(options.runtimeEvidence)
     : options.preserveRuntimeEvidence === true && input.evidenceReceipt !== undefined
@@ -891,6 +1055,10 @@ function projectActionCheckpoint(checkpoint) {
     lines.push(`Reversibility: ${frame.reversibility}`);
     if (frame.decisionBasis !== undefined) lines.push(`Decision basis: ${frame.decisionBasis.join(' | ')}`);
   }
+  if (value.externalReportOrigin !== undefined) {
+    const report = value.externalReportOrigin;
+    lines.push(`External report origin: ${report.reporter} via ${report.source}; event ${report.eventRef}; occurred ${report.occurredAt}`);
+  }
   if (value.evidenceReceipt !== undefined) {
     const receipt = value.evidenceReceipt;
     lines.push(`Runtime evidence: turn ${receipt.turnId}; ${receipt.completedTools} completed, ${receipt.successfulTools} successful, ${receipt.failedTools} failed; digest ${receipt.digest}`);
@@ -910,6 +1078,9 @@ module.exports = {
   completionCriterionRef,
   evidenceProducerRef,
   emptyActionEvidenceReceipt,
+  externalReportOriginFromRuntimeSource,
+  externalReportSourceFromChannelMeta,
+  externalReportSourcesFromOrigin,
   normalizeActionCheckpoint,
   normalizeVerificationProof,
   projectActionCheckpoint,

package/bin/outbound-claim-provenance.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+const MAX_CLAIMS = 32;
+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 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 unattributed = [];
+
+  for (const value of claims) {
+    if (local.has(value)) {
+      localMatches.push(value);
+      continue;
+    }
+    const report = reports.find((candidate) => candidate.claimTokens.includes(value));
+    if (report === undefined) {
+      unattributed.push(value);
+      continue;
+    }
+    const external = {
+      value,
+      reporter: report.reporter,
+      ...(report.reporterRef !== undefined ? { reporterRef: report.reporterRef } : {}),
+      eventRef: report.eventRef,
+      occurredAt: report.occurredAt,
+    };
+    externalMatches.push(Object.freeze(external));
+  }
+
+  return Object.freeze({
+    local: Object.freeze(localMatches),
+    external: Object.freeze(externalMatches),
+    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.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, 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 ?? []);
@@ -230281,9 +230282,11 @@ var init_goal$1 = __esmMin((() => {
 			if (input.actionCheckpoint !== void 0) {
 				assertActionCheckpointRevision(undefined, input.actionCheckpoint);
 				const runtimeEvidence = this.agent.turn.actionEvidenceReceiptForCurrentTurn();
-				assertActionCheckpointEvidenceBasis(undefined, input.actionCheckpoint, runtimeEvidence);
+				const runtimeExternalReports = this.agent.turn.externalReportSourcesForCurrentTurn();
+				assertActionCheckpointEvidenceBasis(undefined, input.actionCheckpoint, runtimeEvidence, runtimeExternalReports);
 				state.actionCheckpoint = normalizeActionCheckpoint(input.actionCheckpoint, {
-					runtimeEvidence
+					runtimeEvidence,
+					runtimeExternalReports
 				});
 			}
 			this.persistState(state);
@@ -230365,9 +230368,12 @@ var init_goal$1 = __esmMin((() => {
 			if (state.status !== "active") throw new BlunError(ErrorCodes.GOAL_STATUS_INVALID, `Cannot checkpoint a goal in status "${state.status}"`);
 			assertActionCheckpointRevision(state.actionCheckpoint, input);
 			const runtimeEvidence = this.agent.turn.actionEvidenceReceiptForCurrentTurn();
-			assertActionCheckpointEvidenceBasis(state.actionCheckpoint, input, runtimeEvidence);
+			const runtimeExternalReports = this.agent.turn.externalReportSourcesForCurrentTurn();
+			assertActionCheckpointEvidenceBasis(state.actionCheckpoint, input, runtimeEvidence, runtimeExternalReports);
 			state.actionCheckpoint = normalizeActionCheckpoint(input, {
-				runtimeEvidence
+				runtimeEvidence,
+				runtimeExternalReports,
+				previousCheckpoint: state.actionCheckpoint
 			});
 			this.persistState(state, { change: { kind: "progress", actor } });
 			this.appendGoalUpdate({ actionCheckpoint: state.actionCheckpoint, actor });
@@ -245792,6 +245798,13 @@ var init_events$1 = __esmMin((() => {
 			phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
 			evidenceBasis: _enum(["runtime_tool", "user_statement", "external_report", "carried_forward", "legacy_unknown"]),
 			epistemicState: _enum(["verified", "credible_unverified", "hypothesis", "uncertain_memory", "stale", "unknown", "legacy_unknown"]),
+			externalReportOrigin: object({
+				source: _enum(["telegram"]),
+				reporter: string(),
+				reporterRef: string().regex(/^[a-f0-9]{16}$/u),
+				eventRef: string().regex(/^[a-f0-9]{16}$/u),
+				occurredAt: string()
+			}).strict().optional(),
 			lastVerified: string(),
 			nextAction: string(),
 			expectedEvidence: string(),
@@ -260311,6 +260324,7 @@ var create_goal_default;
 var init_create_goal$1 = __esmMin((() => {
 	create_goal_default = "Create a durable, structured goal that the runtime will pursue across multiple turns.\n\nCall `CreateGoal` when:\n\n- the user explicitly asks you to start a goal or work autonomously toward an outcome,\n- an authenticated user assigns a non-trivial multi-step outcome with a checkable end state under an existing instruction to continue autonomously, or\n- a host goal-intake prompt asks you to create one.\n\nDo NOT create a goal for greetings, ordinary questions, one-step requests, or vague requests that lack a\nverifiable completion condition. A goal needs a checkable end state.\n\nWhen the request is vague, ask the user for the missing completion criterion before creating\nthe goal. If the user clearly insists after you warn them that the wording is vague or risky,\nrespect that and create the goal.\n\nInclude a `completionCriterion` when the user provides one, or when it can be stated without\ninventing new requirements. Keep `objective` concise; reference long task descriptions by file\npath rather than pasting them. Start every created goal with revision 1 and a complete `problemFrame`\ninside `actionCheckpoint`, so the success criterion, missing knowledge, candidate actions, chosen\naction, support choice, risk, reversibility, next action, expected evidence, and exact next trigger survive interruption.\nThis frame is descriptive state only and never grants permission.\n\nCreating a goal fails if one already exists, so use `replace: true` only when the user explicitly\nwants to abandon the current goal and start a new one.\n";
 	create_goal_default += "\nBind each selected action to the projected durable facts or assumptions it relies on by copying their explicit refs into `decisionBasis`. A stale or unknown decision basis requires replanning before execution.\n";
+	create_goal_default += "\nWhen the checkpoint rests on a forwarded Telegram report, use `external_report` with `credible_unverified` and select the exact visible channel event in `externalReportSource` with its `source`, `chat_id` as `chatId`, and `message_id` as `messageId`. The runtime binds the reporter and event reference; never invent them.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/serialize.ts
@@ -260348,6 +260362,11 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 		phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
 		evidenceBasis: _enum(["runtime_tool", "user_statement", "external_report", "carried_forward"]),
 		epistemicState: _enum(["verified", "credible_unverified", "hypothesis", "uncertain_memory", "stale", "unknown"]),
+		externalReportSource: object({
+			source: _enum(["telegram"]),
+			chatId: string().min(1).max(64),
+			messageId: string().min(1).max(64)
+		}).strict().optional(),
 		lastVerified: string().min(1).max(512),
 		nextAction: string().min(1).max(512),
 		expectedEvidence: string().min(1).max(512),
@@ -261714,6 +261733,12 @@ function explicitToolResultEvidenceScopes(result) {
 function abandonedToolResultOutput(ended) {
 	return `Tool call did not complete: ${ended.reason === "cancelled" ? "the turn was cancelled" : ended.reason === "failed" ? `the turn failed${ended.error !== void 0 ? ` (${ended.error.message})` : ""}` : "the turn ended"} before its result was recorded. Do not assume the tool completed successfully.`;
 }
+function durablePromptOrigin(origin) {
+	if (!origin || typeof origin !== "object" || !Object.hasOwn(origin, "externalReportSources")) return origin;
+	const { externalReportSources, ...durableOrigin } = origin;
+	void externalReportSources;
+	return durableOrigin;
+}
 var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaToolNamesForTurnText, rankedSupportToolNamesForGoal, rankedToolNamesForTurnText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, cognitiveFocusScopesForTurn, buildCognitiveWorkFocus, buildAttentionQueueItem, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
@@ -261803,6 +261828,8 @@ var init_turn = __esmMin((() => {
 		cognitiveToolPolicyByCall = /* @__PURE__ */ new Map();
 		cognitiveToolBatchesByTurn = /* @__PURE__ */ new Map();
 		cognitiveActionEvidenceByTurn = /* @__PURE__ */ new Map();
+		cognitiveExternalReportsByTurn = /* @__PURE__ */ new Map();
+		cognitiveLocalClaimsByTurn = /* @__PURE__ */ new Map();
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261882,6 +261909,70 @@ var init_turn = __esmMin((() => {
 			const turnId = this.currentId;
 			return this.cognitiveActionEvidenceByTurn.get(turnId) ?? emptyActionEvidenceReceipt(turnId, this.agent.evidenceProducerRef);
 		}
+		recordExternalReportSources(turnId, origin) {
+			const incoming = externalReportSourcesFromOrigin(origin);
+			if (incoming.length === 0) return;
+			const current = this.cognitiveExternalReportsByTurn.get(turnId) ?? [];
+			const merged = [...current];
+			const seen = new Set(current.map((source) => `${source.source}\0${source.chatId}\0${source.messageId}`));
+			for (const source of incoming) {
+				const key = `${source.source}\0${source.chatId}\0${source.messageId}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				merged.push(source);
+			}
+			this.cognitiveExternalReportsByTurn.set(turnId, Object.freeze(merged.slice(-32)));
+		}
+		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 unattributed = provenanceAdvisory.unattributed.join(", ") || "-";
+				this.agent.emitEvent({
+					type: "warning",
+					code: "OUTBOUND_CLAIM_PROVENANCE",
+					message: uiText("sessionEvent.provenance.advisory", { external, unattributed }),
+					blocked: false,
+					details: {
+						blocked: false,
+						external: provenanceAdvisory.external,
+						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);
@@ -261936,7 +262027,7 @@ var init_turn = __esmMin((() => {
 			this.agent.records.logRecord({
 				type: "turn.prompt",
 				input,
-				origin
+				origin: durablePromptOrigin(origin)
 			});
 			const buffered = this.agent.fullCompaction.isCompacting;
 			const turnId = this.launch(input, origin);
@@ -261955,7 +262046,7 @@ var init_turn = __esmMin((() => {
 			this.agent.records.logRecord({
 				type: "turn.steer",
 				input,
-				origin
+				origin: durablePromptOrigin(origin)
 			});
 			if (this.activeTurn || this.agent.fullCompaction.isCompacting) {
 				this.bufferSteer(input, origin);
@@ -261978,7 +262069,7 @@ var init_turn = __esmMin((() => {
 			this.agent.records.logRecord({
 				type: "turn.steer",
 				input,
-				origin
+				origin: durablePromptOrigin(origin)
 			});
 			this.bufferSteer(input, origin, this.currentId);
 			return {
@@ -262110,6 +262201,9 @@ var init_turn = __esmMin((() => {
 			return this.flushSteerBuffer(turnId, snapshot.throughSequence);
 		}
 		bufferSteer(input, origin, targetTurnId) {
+			const active = this.activeTurn;
+			const reportTurnId = targetTurnId ?? (active !== null && active !== "resuming" ? active.turnId : void 0);
+			if (reportTurnId !== void 0) this.recordExternalReportSources(reportTurnId, origin);
 			this.steerBuffer.push({
 				sequence: this.nextSteerSequence,
 				input,
@@ -262127,7 +262221,7 @@ var init_turn = __esmMin((() => {
 					remaining.push(steer);
 					continue;
 				}
-				this.agent.context.appendUserMessage(steer.input, steer.origin);
+				this.agent.context.appendUserMessage(steer.input, durablePromptOrigin(steer.origin));
 				flushed = true;
 			}
 			this.steerBuffer = remaining;
@@ -262280,6 +262374,8 @@ var init_turn = __esmMin((() => {
 			const telemetryMode = this.telemetryMode();
 			this.telemetryModeByTurn.set(turnId, telemetryMode);
 			this.currentStepByTurn.set(turnId, 0);
+			this.recordExternalReportSources(turnId, origin);
+			const persistedOrigin = durablePromptOrigin(origin);
 			this.agent.telemetry.track("turn_started", {
 				mode: telemetryMode,
 				...this.requestProviderProps()
@@ -262290,9 +262386,9 @@ var init_turn = __esmMin((() => {
 			this.agent.emitEvent({
 				type: "turn.started",
 				turnId,
-				origin
+				origin: persistedOrigin
 			});
-			this.agent.context.appendUserMessage(input, origin);
+			this.agent.context.appendUserMessage(input, persistedOrigin);
 			this.recordCognitiveStage("startTurn", { turnId, originKind: origin.kind });
 			const startedAt = Date.now();
 			let ended;
@@ -262300,7 +262396,7 @@ var init_turn = __esmMin((() => {
 			let completedStopReason;
 			let errorEvent;
 			try {
-				const promptHookEnded = await this.applyUserPromptHook(turnId, input, origin, signal, startedAt);
+				const promptHookEnded = await this.applyUserPromptHook(turnId, input, persistedOrigin, signal, startedAt);
 				this.recordCognitiveStage("recordRightsCheck", {
 					turnId,
 					decision: origin.kind !== "user" ? "not_applicable" : promptHookEnded?.blocked === true ? "blocked" : "passed",
@@ -262310,7 +262406,7 @@ var init_turn = __esmMin((() => {
 					ended = promptHookEnded.event;
 					blockedByUserPromptHook = promptHookEnded.blocked;
 				} else {
-					const stopReason = await this.runStepLoop(turnId, signal, input, origin);
+					const stopReason = await this.runStepLoop(turnId, signal, input, persistedOrigin);
 					completedStopReason = stopReason;
 					ended = {
 						type: "turn.ended",
@@ -262389,6 +262485,8 @@ var init_turn = __esmMin((() => {
 			this.currentStepByTurn.delete(turnId);
 			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 {
@@ -262779,6 +262877,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,
@@ -262794,6 +262893,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";
@@ -262922,7 +263022,7 @@ var init_update_goal$1 = __esmMin((() => {
 	update_goal_default = "Update the current autonomous goal. Set `status` only for a lifecycle change. After a coherent work slice, save `actionCheckpoint` with a monotone revision, the last verified result, exact next action, expected evidence, exact `nextTrigger`, and an explicit evidence basis. Persist the exact `nextTrigger` that releases `nextAction`: use `immediate` outside the `wait` phase; while waiting, name the external event, time, dependency, or user decision instead of pretending work can continue. A `time` trigger must include the exact ISO timestamp in `dueAt`; no other trigger kind may include `dueAt`. Use `runtime_tool` only when a successful tool in this turn measured the result; use `user_statement` for a direct user assertion, `external_report` for a report not independently measured here, and `carried_forward` only when the last verified text is unchanged. Classify knowledge as `verified`, `credible_unverified`, `hypothesis`, `uncertain_memory`, `stale`, or `unknown`; never present a weaker state as verified, and preserve the state on carry-forward. Start at revision 1 and increment the currently projected revision by exactly one; stale writers fail closed. This is durable progress state, not permission, and should change only when the facts change. A checkpoint-only call keeps the goal active.\n\n- `active` — resume a paused or blocked goal when the user explicitly asks you to work on that goal.\n- `complete` — the objective is fully satisfied, all files are written, all tests pass, and any stated validation has passed. When the goal has a completion criterion, first save a `verify` checkpoint with `runtime_tool`, `verified`, and a successful runtime evidence receipt.\n- `blocked` — a genuine external condition or required user decision prevents progress.\n- `paused` — set the goal aside for now.\n\nDo not mark complete after a plan or partial result. If useful work remains, checkpoint it and continue. Do not ask for permission merely to execute an already authorized checkpoint; ask only at a real rights boundary or missing user decision.\n";
 	update_goal_default += "\nBefore completing a goal with a criterion, bind the verified claim to the exact successful current-turn verification call in `verificationProof`, including its `toolCallId`. A write, edit, copy, deploy, or other action is not proof that the changed behavior works, even when it shares a mixed-use tool such as `Bash` with tests. Use `subject: result` for a result, report, measurement, or download. Use `subject: verifier` only when the new or changed test, gate, harness, or detector itself is the completion subject; then bind `sharpnessProof` to a separate successful current-turn counterexample or mutation call. Do not require a red probe for a normal report or measurement.\n";
 	update_goal_default += "\nCopy the active goal's exact `completionCriterion` into `verificationProof.criterion`. The runtime stores only its bounded reference and refuses completion if the proof belongs to a different or superseded completion criterion.\n";
-	update_goal_default += "\nThe runtime binds fresh verification automatically to the session and agent that produced the successful tool result. Do not invent or copy a producer reference. Preserve forwarded measurements as `external_report` with `credible_unverified` until this agent measures them independently; forwarding is allowed, relabelling them as local verification is not.\n";
+	update_goal_default += "\nThe runtime binds fresh verification automatically to the session and agent that produced the successful tool result. Do not invent or copy a producer reference. Preserve forwarded measurements as `external_report` with `credible_unverified` until this agent measures them independently; forwarding is allowed, relabelling them as local verification is not. For a fresh Telegram report, copy the exact visible channel `source`, `chat_id` as `chatId`, and `message_id` as `messageId` into `externalReportSource`. The runtime, not the model, binds the reporter and event reference. A `carried_forward` checkpoint retains that origin automatically.\n";
 	update_goal_default += "\nSet the proof `kind` to the exact capability of that call: `inspection` reads or searches, `integrity` compares bytes or hashes, `syntax` parses or type-checks, and `test` runs assertions. None of these alone proves a stronger kind. Use `reachability` only for a successful runtime probe that actually invokes the changed path and emits the exact marker `BLUN_EVIDENCE_KIND=reachability` after its assertions; loading a module without reaching the changed path is not reachability.\n";
 	update_goal_default += "\nBind each proof `scope` to the exact target measured by that successful call, never to a free-text claim or intended file. Read and search tools derive scope from their target arguments. For shell or command tools, include the same safe token `BLUN_EVIDENCE_SCOPE=<scope>` in the launched non-mutating verification command and emit it only after that exact target succeeds; the runtime requires both sides.\n";
 	update_goal_default += "\nFor a non-trivial or unfamiliar problem, preserve `problemFrame` with the success criterion, missing knowledge, bounded candidate actions, selected action and reason, support choice, risk, and reversibility. The selected action must match one candidate. Bind each selected action to the projected durable facts or assumptions it relies on by copying their explicit refs into `decisionBasis`. A stale or unknown decision basis requires replanning before execution. Problem framing is descriptive state and never grants permission.\n";
@@ -265674,9 +265774,9 @@ var init_agent = __esmMin((() => {
 		get rpcMethods() {
 			return {
 				prompt: (payload) => {
-					this.turn.promptWithAcceptance(payload.input);
+					this.turn.promptWithAcceptance(payload.input, payload.origin ?? USER_PROMPT_ORIGIN);
 				},
-				promptAccepted: (payload) => this.turn.promptWithAcceptance(payload.input),
+				promptAccepted: (payload) => this.turn.promptWithAcceptance(payload.input, payload.origin ?? USER_PROMPT_ORIGIN),
 				runShellCommand: (payload) => this.tools.runShellCommand(payload.command, payload.commandId),
 				cancelShellCommand: (payload) => this.tools.cancelShellCommand(payload.commandId),
 				steer: (payload) => {
@@ -326630,17 +326730,20 @@ var Session = class {
 	async prompt(input) {
 		await this.promptAccepted(input);
 	}
-	async promptAccepted(input) {
+	async promptAccepted(input, origin = USER_PROMPT_ORIGIN) {
 		this.ensureOpen();
 		const normalized = normalizePromptInput(input);
+		const normalizedOrigin = origin && typeof origin === "object" ? origin : USER_PROMPT_ORIGIN;
 		const hasPromptAccepted = this.rpc.promptAccepted !== void 0;
 		return this.trackUserInputAcceptance(normalized, hasPromptAccepted ? () => this.rpc.promptAccepted({
 			sessionId: this.id,
-			input: normalized
+			input: normalized,
+			origin: normalizedOrigin
 		}) : async () => {
 			await this.rpc.prompt({
 				sessionId: this.id,
-				input: normalized
+				input: normalized,
+				origin: normalizedOrigin
 			});
 			return {
 				accepted: true,
@@ -327909,7 +328012,8 @@ var SDKRpcClientBase = class {
 			await rpc.prompt({
 				sessionId: input.sessionId,
 				agentId,
-				input: input.input
+				input: input.input,
+				origin: input.origin
 			});
 			return {
 				accepted: true,
@@ -327920,7 +328024,8 @@ var SDKRpcClientBase = class {
 		return rpc.promptAccepted({
 			sessionId: input.sessionId,
 			agentId,
-			input: input.input
+			input: input.input,
+			origin: input.origin
 		});
 	}
 	async runShellCommand(input) {
@@ -419162,12 +419267,14 @@ const CONTEXT_TRUNCATED_MARKER = "\n[Telegram-Kontext gekuerzt]";
 function createChannelPreambleState() {
 	return {
 		sent: false,
-		bufferedByChat: /* @__PURE__ */ new Map()
+		bufferedByChat: /* @__PURE__ */ new Map(),
+		reportSourcesByChat: /* @__PURE__ */ new Map()
 	};
 }
 function resetChannelPreambleState(state) {
 	state.sent = false;
 	state.bufferedByChat?.clear();
+	state.reportSourcesByChat?.clear();
 }
 /** Structured metadata is authoritative; old queue envelopes use the tag note. */
 function channelMessageAddressed(envelope) {
@@ -419177,21 +419284,35 @@ function channelMessageAddressed(envelope) {
 	if (addressed === "semantic") return true;
 	return !envelope.tag.includes("NUR MITLESEN");
 }
-function bufferContext(state, chatId, tag) {
+function bufferContext(state, chatId, tag, reportSource) {
 	const buffers = state.bufferedByChat ?? /* @__PURE__ */ new Map();
 	state.bufferedByChat = buffers;
+	const reportBuffers = state.reportSourcesByChat ?? /* @__PURE__ */ new Map();
+	state.reportSourcesByChat = reportBuffers;
 	const messages = buffers.get(chatId) ?? [];
+	const reports = reportBuffers.get(chatId) ?? [];
 	const projectedTag = projectUnaddressedTelegramContext(tag);
 	const boundedTag = projectedTag.length <= MAX_BUFFERED_CONTEXT_CHARS ? projectedTag : `${projectedTag.slice(0, MAX_BUFFERED_CONTEXT_CHARS - 28)}${CONTEXT_TRUNCATED_MARKER}`;
 	messages.push(boundedTag);
+	reports.push(reportSource);
 	let chars = messages.reduce((sum, message) => sum + message.length, 0);
-	while (messages.length > MAX_BUFFERED_CONTEXT_MESSAGES || chars > MAX_BUFFERED_CONTEXT_CHARS) chars -= messages.shift()?.length ?? 0;
+	while (messages.length > MAX_BUFFERED_CONTEXT_MESSAGES || chars > MAX_BUFFERED_CONTEXT_CHARS) {
+		chars -= messages.shift()?.length ?? 0;
+		reports.shift();
+	}
 	buffers.set(chatId, messages);
+	reportBuffers.set(chatId, reports);
 }
 /** Muted origin prefix for the transcript line, e.g. "Telegram · User". */
 function channelOrigin(envelope) {
 	return `Telegram · ${envelope.meta.user ?? envelope.meta.chat_id}${envelope.meta["priority"] === "urgent" ? " · Dringend" : ""}`;
 }
+function channelPromptOrigin(channelReportSources) {
+	return {
+		kind: "user",
+		externalReportSources: channelReportSources
+	};
+}
 const TELEGRAM_REMOTE_COMMANDS = Object.freeze(["loop", "goal", "idea", "chancenradar", "curiosity", "scout", "reload", "memory", "befehle"]);
 function telegramRemoteCommand(text) {
 	const trimmed = text.trim();
@@ -419213,24 +419334,36 @@ function telegramRemoteCommand(text) {
 function injectChannelEnvelope(host, envelope, preamble) {
 	const origin = channelOrigin(envelope);
 	const contextOnly = !channelMessageAddressed(envelope);
+	const reportSource = {
+		source: "telegram",
+		chatId: envelope.meta.chat_id,
+		messageId: envelope.meta.message_id,
+		reporter: envelope.meta.user,
+		reporterId: envelope.meta.user_id,
+		occurredAt: envelope.meta.ts,
+		claimTokens: extractChecksumClaims(envelope.text)
+	};
 	if (contextOnly) {
-		bufferContext(preamble, envelope.meta.chat_id, envelope.tag);
+		bufferContext(preamble, envelope.meta.chat_id, envelope.tag, reportSource);
 		host.displayContext?.(envelope.text, origin);
 		return "buffered";
 	}
 	const modelParts = [...preamble.bufferedByChat?.get(envelope.meta.chat_id) ?? [], envelope.tag];
+	const channelReportSources = [...preamble.reportSourcesByChat?.get(envelope.meta.chat_id) ?? [], reportSource];
 	if (!preamble.sent && envelope.preamble !== void 0 && envelope.preamble.length > 0) {
 		modelParts.unshift(envelope.preamble);
 		preamble.sent = true;
 	}
 	const modelInput = modelParts.join("\n\n");
 	if (!host.canDeliver() || host.isBusy()) {
-		host.enqueue(modelInput, envelope.text, origin, contextOnly);
+		host.enqueue(modelInput, envelope.text, origin, contextOnly, channelReportSources);
 		preamble.bufferedByChat?.delete(envelope.meta.chat_id);
+		preamble.reportSourcesByChat?.delete(envelope.meta.chat_id);
 		return "queued";
 	}
-	host.deliverNow(modelInput, envelope.text, origin, contextOnly);
+	host.deliverNow(modelInput, envelope.text, origin, contextOnly, channelReportSources);
 	preamble.bufferedByChat?.delete(envelope.meta.chat_id);
+	preamble.reportSourcesByChat?.delete(envelope.meta.chat_id);
 	return "delivered";
 }
 /** Parse one queue line defensively — a malformed line must never crash the TUI. */
@@ -506333,6 +506466,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}. 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})",
@@ -506363,6 +506497,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}. 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})",
@@ -506393,6 +506528,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}. 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})",
@@ -506423,6 +506559,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}. 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})",
@@ -506453,6 +506590,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}. 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})",
@@ -506483,6 +506621,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}. 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})",
@@ -517656,10 +517795,10 @@ var BlunTUI = class {
 		injectChannelEnvelope({
 			canDeliver: () => this.session !== void 0 && this.state.appState.model.trim().length > 0,
 			isBusy: () => this.state.queuedMessages.length > 0 || this.queueSteerInFlight !== void 0 || this.deferUserMessages || this.streamingUI.hasActiveTurn() || this.state.appState.streamingPhase !== "idle" || this.state.appState.isCompacting,
-			deliverNow: (modelInput, displayText, origin, contextOnly) => {
-				this.sendChannelMessageInternal(this.requireSession(), modelInput, displayText, origin, routedEnvelope.meta.chat_id, routedEnvelope.meta["image_path"], contextOnly, false, acknowledge, false, void 0, directEnvelope !== void 0, directFocus.resumeGranted);
+			deliverNow: (modelInput, displayText, origin, contextOnly, channelReportSources) => {
+				this.sendChannelMessageInternal(this.requireSession(), modelInput, displayText, origin, routedEnvelope.meta.chat_id, routedEnvelope.meta["image_path"], contextOnly, false, acknowledge, false, void 0, directEnvelope !== void 0, directFocus.resumeGranted, channelReportSources);
 			},
-			enqueue: (modelInput, displayText, origin, contextOnly) => {
+			enqueue: (modelInput, displayText, origin, contextOnly, channelReportSources) => {
 				const item = {
 					text: modelInput,
 					displayText,
@@ -517667,6 +517806,7 @@ var BlunTUI = class {
 					agentId: this.harness.interactiveAgentId,
 					mode: "channel",
 					channelChatId: routedEnvelope.meta.chat_id,
+					channelReportSources: channelReportSources,
 					channelContextOnly: contextOnly,
 					channelAcknowledge: acknowledge,
 					...urgentEnvelope !== void 0 ? { channelUrgent: true } : {},
@@ -517826,7 +517966,7 @@ var BlunTUI = class {
 			this.failSessionRequest(uiText("blunTui.session.sendFailed", { error: formatErrorMessage$2(error) }));
 		});
 	}
-	sendChannelMessageInternal(session, modelInput, displayText, origin, channelChatId, channelImagePath, contextOnly = false, transcriptRendered = false, acknowledge, channelAttention = false, queueKey, channelDirect = false, channelDirectResume = false) {
+	sendChannelMessageInternal(session, modelInput, displayText, origin, channelChatId, channelImagePath, contextOnly = false, transcriptRendered = false, acknowledge, channelAttention = false, queueKey, channelDirect = false, channelDirectResume = false, channelReportSources = []) {
 		armPersonalMemoryRememberIntent(session.id, displayText, {
 			permissionMode: this.state.appState.permissionMode,
 			channel: true
@@ -517860,7 +518000,7 @@ var BlunTUI = class {
 			type: "text",
 			text: focusedModelInput
 		}, imagePart] : focusedModelInput;
-		session.promptAccepted(promptInput).then((result) => {
+		session.promptAccepted(promptInput, channelPromptOrigin(channelReportSources)).then((result) => {
 			if (result.accepted) {
 				acknowledge?.();
 				return;
@@ -517873,6 +518013,7 @@ var BlunTUI = class {
 				agentId: this.harness.interactiveAgentId,
 				mode: "channel",
 				channelChatId,
+				channelReportSources: channelReportSources,
 				channelContextOnly: contextOnly,
 				channelTranscriptRendered: true,
 				channelAcknowledge: acknowledge,
@@ -518236,7 +518377,7 @@ var BlunTUI = class {
 		const activeSession = this.session ?? session;
 		if (item.mode === "channel") {
 			this.harness.withInteractiveAgent(item.agentId ?? "main", () => {
-				this.sendChannelMessageInternal(activeSession, item.text, item.displayText ?? "", item.origin, item.channelChatId, item.channelImagePath, item.channelContextOnly, item.channelTranscriptRendered, item.channelAcknowledge, item.channelAttention, item.queueKey, item.channelDirect, item.channelDirectResume);
+				this.sendChannelMessageInternal(activeSession, item.text, item.displayText ?? "", item.origin, item.channelChatId, item.channelImagePath, item.channelContextOnly, item.channelTranscriptRendered, item.channelAcknowledge, item.channelAttention, item.queueKey, item.channelDirect, item.channelDirectResume, item.channelReportSources);
 			});
 			return;
 		}

package/package.json

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