blun-king-cli 9.1.452 → 9.1.454

package/bin/cognitive-action-checkpoint.cjs

@@ -31,7 +31,9 @@ const REQUIRED_EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
 ]);
 const EVIDENCE_DIGEST_RE = /^[a-f0-9]{16}$/u;
+const EVIDENCE_PRODUCER_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;
 const ACTION_ONLY_TOOL_NAMES = new Set([
   'CreateGoal', 'CronCreate', 'CronDelete', 'DubVideo', 'Edit', 'EnterPlanMode',
@@ -179,6 +181,20 @@ function successfulToolDigest(toolName) {
   return crypto.createHash('sha256').update(`tool:${name}`).digest('hex').slice(0, 16);
 }
 
+function evidenceProducerRef(identity) {
+  const value = bounded(identity, 'evidence producer identity', 1024);
+  return crypto.createHash('sha256')
+    .update(`evidence-producer:${value}`)
+    .digest('hex')
+    .slice(0, 16);
+}
+
+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`);
+  return ref;
+}
+
 function successfulToolCallDigest(turnId, toolCallId, toolName) {
   const turn = normalizedTurnId(turnId);
   const callId = bounded(toolCallId, 'verificationProof toolCallId', 256);
@@ -216,6 +232,15 @@ function successfulVerificationScopeDigest(turnId, toolCallId, toolName, kind, s
     .slice(0, 16);
 }
 
+function completionCriterionRef(value) {
+  const criterion = String(value ?? '').trim();
+  if (!criterion) throw new TypeError('completion criterion is required');
+  return crypto.createHash('sha256')
+    .update(`completion-criterion:${criterion}`)
+    .digest('hex')
+    .slice(0, 16);
+}
+
 function isActionOnlyTool(toolName) {
   return ACTION_ONLY_TOOL_NAMES.has(String(toolName ?? '').trim());
 }
@@ -412,14 +437,16 @@ function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
     && Object.hasOwn(input, 'kind')
     && Object.hasOwn(input, 'claim')
     && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'claim', 'sharpnessProof'].includes(key));
-  const currentResult = subject === 'result'
+  const legacyScopedResult = options.allowLegacy === true
+    && subject === 'result'
     && keys.length === 6
     && Object.hasOwn(input, 'toolCallId')
     && Object.hasOwn(input, 'toolName')
     && Object.hasOwn(input, 'kind')
     && Object.hasOwn(input, 'scope')
     && Object.hasOwn(input, 'claim');
-  const currentVerifier = subject === 'verifier'
+  const legacyScopedVerifier = options.allowLegacy === true
+    && subject === 'verifier'
     && (keys.length === 6 || keys.length === 7)
     && Object.hasOwn(input, 'toolCallId')
     && Object.hasOwn(input, 'toolName')
@@ -427,9 +454,68 @@ function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
     && Object.hasOwn(input, 'scope')
     && Object.hasOwn(input, 'claim')
     && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'scope', 'claim', 'sharpnessProof'].includes(key));
+  const freshResult = subject === 'result'
+    && keys.length === 7
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'criterion')
+    && Object.hasOwn(input, 'claim');
+  const freshVerifier = subject === 'verifier'
+    && (keys.length === 7 || keys.length === 8)
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'criterion')
+    && Object.hasOwn(input, 'claim')
+    && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'scope', 'criterion', 'claim', 'sharpnessProof'].includes(key));
+  const replayResult = options.allowLegacy === true
+    && subject === 'result'
+    && keys.length === 7
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'criterionRef')
+    && Object.hasOwn(input, 'claim');
+  const replayVerifier = options.allowLegacy === true
+    && subject === 'verifier'
+    && (keys.length === 7 || keys.length === 8)
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'criterionRef')
+    && Object.hasOwn(input, 'claim')
+    && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'scope', 'criterionRef', 'claim', 'sharpnessProof'].includes(key));
+  const replayProvenanceResult = options.allowLegacy === true
+    && subject === 'result'
+    && keys.length === 8
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'criterionRef')
+    && Object.hasOwn(input, 'producerRef')
+    && Object.hasOwn(input, 'claim');
+  const replayProvenanceVerifier = options.allowLegacy === true
+    && subject === 'verifier'
+    && (keys.length === 8 || keys.length === 9)
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'criterionRef')
+    && Object.hasOwn(input, 'producerRef')
+    && Object.hasOwn(input, 'claim')
+    && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'scope', 'criterionRef', 'producerRef', 'claim', 'sharpnessProof'].includes(key));
   if (!legacyName && !legacyExact && !legacySubjectResult && !legacySubjectVerifier
       && !legacyTypedSubjectResult && !legacyTypedSubjectVerifier
-      && !currentResult && !currentVerifier) {
+      && !legacyScopedResult && !legacyScopedVerifier
+      && !freshResult && !freshVerifier && !replayResult && !replayVerifier
+      && !replayProvenanceResult && !replayProvenanceVerifier) {
     throw new TypeError('verificationProof fields are invalid');
   }
   const receipt = normalizeActionEvidenceReceipt(evidenceReceipt);
@@ -450,15 +536,41 @@ function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
     toolCallId: input.toolCallId,
     toolName: input.toolName,
     ...(legacySubject ? {} : { kind: input.kind }),
-    ...(currentResult || currentVerifier ? { scope: input.scope } : {}),
+    ...(legacyScopedResult || legacyScopedVerifier || freshResult || freshVerifier
+      || replayResult || replayVerifier || replayProvenanceResult || replayProvenanceVerifier
+      ? { scope: input.scope } : {}),
     claim: input.claim,
   }, receipt, 'verificationProof', {
     requireKind: !legacyExact && !legacySubject,
-    requireScope: currentResult || currentVerifier,
+    requireScope: legacyScopedResult || legacyScopedVerifier || freshResult || freshVerifier
+      || replayResult || replayVerifier || replayProvenanceResult || replayProvenanceVerifier,
   });
   if (legacyExact) return primary;
   if (!VERIFICATION_SUBJECTS.has(subject)) throw new TypeError('verificationProof subject is invalid');
-  if (subject === 'result') return Object.freeze({ subject, ...primary });
+  const criterionRef = freshResult || freshVerifier
+    ? completionCriterionRef(input.criterion)
+    : replayResult || replayVerifier || replayProvenanceResult || replayProvenanceVerifier
+      ? String(input.criterionRef ?? '')
+      : undefined;
+  if (criterionRef !== undefined && !COMPLETION_CRITERION_REF_RE.test(criterionRef)) {
+    throw new TypeError('verificationProof criterionRef is invalid');
+  }
+  const producerRef = freshResult || freshVerifier
+    ? receipt.producerRef
+    : replayProvenanceResult || replayProvenanceVerifier
+      ? normalizedEvidenceProducerRef(input.producerRef, 'verificationProof producerRef')
+      : undefined;
+  if (producerRef !== undefined && receipt.producerRef !== producerRef) {
+    throw new TypeError('verificationProof producerRef must match the runtime evidence producer');
+  }
+  if (subject === 'result') {
+    return Object.freeze({
+      subject,
+      ...primary,
+      ...(criterionRef === undefined ? {} : { criterionRef }),
+      ...(producerRef === undefined ? {} : { producerRef }),
+    });
+  }
   if (input.sharpnessProof === undefined) {
     throw new TypeError('verifier proof requires a sharpnessProof');
   }
@@ -470,13 +582,23 @@ function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
       && sharpnessProof.toolName === primary.toolName) {
     throw new TypeError('sharpnessProof must name a distinct verification call');
   }
-  return Object.freeze({ subject, ...primary, sharpnessProof });
+  return Object.freeze({
+    subject,
+    ...primary,
+    ...(criterionRef === undefined ? {} : { criterionRef }),
+    ...(producerRef === undefined ? {} : { producerRef }),
+    sharpnessProof,
+  });
 }
 
-function emptyActionEvidenceReceipt(turnId) {
+function emptyActionEvidenceReceipt(turnId, producerRef) {
   const normalized = normalizedTurnId(turnId);
+  const producer = producerRef === undefined
+    ? undefined
+    : normalizedEvidenceProducerRef(producerRef);
   return Object.freeze({
     turnId: normalized,
+    ...(producer === undefined ? {} : { producerRef: producer }),
     completedTools: 0,
     successfulTools: 0,
     failedTools: 0,
@@ -484,7 +606,12 @@ function emptyActionEvidenceReceipt(turnId) {
     successfulToolCallDigests: Object.freeze([]),
     successfulVerificationCallDigests: Object.freeze([]),
     successfulVerificationScopeDigests: Object.freeze([]),
-    digest: crypto.createHash('sha256').update(`turn:${normalized}:empty`).digest('hex').slice(0, 16),
+    digest: crypto.createHash('sha256')
+      .update(producer === undefined
+        ? `turn:${normalized}:empty`
+        : `producer:${producer}\0turn:${normalized}:empty`)
+      .digest('hex')
+      .slice(0, 16),
   });
 }
 
@@ -493,7 +620,7 @@ function normalizeActionEvidenceReceipt(input) {
   const requiredKeys = new Set(['turnId', 'completedTools', 'successfulTools', 'failedTools', 'digest']);
   const allowedKeys = new Set([
     ...requiredKeys, 'successfulToolDigests', 'successfulToolCallDigests',
-    'successfulVerificationCallDigests', 'successfulVerificationScopeDigests',
+    'successfulVerificationCallDigests', 'successfulVerificationScopeDigests', 'producerRef',
   ]);
   if (!Object.keys(input).every((key) => allowedKeys.has(key))
       || ![...requiredKeys].every((key) => Object.hasOwn(input, key))) {
@@ -501,6 +628,9 @@ function normalizeActionEvidenceReceipt(input) {
   }
   const receipt = {
     turnId: normalizedTurnId(input.turnId),
+    ...(input.producerRef === undefined
+      ? {}
+      : { producerRef: normalizedEvidenceProducerRef(input.producerRef) }),
     completedTools: Number(input.completedTools),
     successfulTools: Number(input.successfulTools),
     failedTools: Number(input.failedTools),
@@ -594,11 +724,13 @@ function advanceActionEvidenceReceipt(current, input) {
     }
   }
   const digest = crypto.createHash('sha256').update([
-    prior.digest, String(turnId), toolCallId, toolName, decision, outcome, String(durationMs),
+    prior.digest, prior.producerRef ?? 'legacy', String(turnId), toolCallId, toolName,
+    decision, outcome, String(durationMs),
     verificationKinds.join(','), verificationScopes.join(','),
   ].join('\0')).digest('hex').slice(0, 16);
   return Object.freeze({
     turnId,
+    ...(prior.producerRef === undefined ? {} : { producerRef: prior.producerRef }),
     completedTools: prior.completedTools + 1,
     successfulTools: prior.successfulTools + (successful ? 1 : 0),
     failedTools: prior.failedTools + (successful ? 0 : 1),
@@ -728,7 +860,13 @@ function projectActionCheckpoint(checkpoint) {
     const scope = value.verificationProof.scope === undefined
       ? ''
       : ` [scope: ${value.verificationProof.scope}]`;
-    lines.push(`Verification proof${subject}${kind}${scope}: ${call} - ${value.verificationProof.claim}`);
+    const criterion = value.verificationProof.criterionRef === undefined
+      ? ''
+      : ` [criterion: ${value.verificationProof.criterionRef}]`;
+    const producer = value.verificationProof.producerRef === undefined
+      ? ''
+      : ` [producer: ${value.verificationProof.producerRef}]`;
+    lines.push(`Verification proof${subject}${kind}${scope}${criterion}${producer}: ${call} - ${value.verificationProof.claim}`);
     if (value.verificationProof.sharpnessProof !== undefined) {
       const sharpness = value.verificationProof.sharpnessProof;
       const sharpnessKind = sharpness.kind === undefined ? '' : ` [${sharpness.kind}]`;
@@ -769,6 +907,8 @@ module.exports = {
   advanceActionEvidenceReceipt,
   assertActionCheckpointEvidenceBasis,
   assertActionCheckpointRevision,
+  completionCriterionRef,
+  evidenceProducerRef,
   emptyActionEvidenceReceipt,
   normalizeActionCheckpoint,
   normalizeVerificationProof,

package/bin/goal-completion-evidence-policy.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  completionCriterionRef,
   normalizeVerificationProof,
 } = require('./cognitive-action-checkpoint.cjs');
 
@@ -14,12 +15,25 @@ function successfulRuntimeEvidence(checkpoint) {
   return Number.isSafeInteger(successfulTools) && successfulTools > 0;
 }
 
-function verificationProofGaps(checkpoint) {
+function verificationProofGaps(checkpoint, criterion, expectedProducerRef) {
   if (!checkpoint?.verificationProof) {
     return ['Bind the completion claim to a successful verification tool from the checkpoint turn.'];
   }
   try {
-    normalizeVerificationProof(checkpoint.verificationProof, checkpoint.evidenceReceipt, { allowLegacy: true });
+    const proof = normalizeVerificationProof(
+      checkpoint.verificationProof,
+      checkpoint.evidenceReceipt,
+      { allowLegacy: true },
+    );
+    if (proof.criterionRef !== completionCriterionRef(criterion)) {
+      return ['Bind the completion proof to the active completion criterion.'];
+    }
+    if (expectedProducerRef !== undefined && proof.producerRef === undefined) {
+      return ['Bind the completion proof to the runtime that produced its measurement.'];
+    }
+    if (expectedProducerRef !== undefined && proof.producerRef !== expectedProducerRef) {
+      return ['The completion proof was produced by a different agent session; preserve it as an external report instead of relabelling it as local verification.'];
+    }
     return [];
   } catch (error) {
     if (/verifier proof requires a sharpnessProof|sharpnessProof must name a distinct verification call/u
@@ -48,7 +62,7 @@ function verificationProofGaps(checkpoint) {
   }
 }
 
-function evaluateGoalCompletionEvidence(goal) {
+function evaluateGoalCompletionEvidence(goal, options = {}) {
   if (!hasCompletionCriterion(goal)) {
     return {
       required: false,
@@ -86,7 +100,11 @@ function evaluateGoalCompletionEvidence(goal) {
       && checkpoint.evidenceBasis === 'runtime_tool'
       && checkpoint.epistemicState === 'verified'
       && hasRuntimeEvidence) {
-    gaps.push(...verificationProofGaps(checkpoint));
+    gaps.push(...verificationProofGaps(
+      checkpoint,
+      goal.completionCriterion,
+      options.expectedProducerRef,
+    ));
   }
 
   return {

package/blun.mjs

@@ -21463,7 +21463,7 @@ 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, normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
+var { advanceActionEvidenceReceipt, assertActionCheckpointEvidenceBasis, assertActionCheckpointRevision, emptyActionEvidenceReceipt, evidenceProducerRef, normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
 var { evaluateGoalCompletionEvidence } = createRequire(import.meta.url)("./bin/goal-completion-evidence-policy.cjs");
 async function prepareSystemPromptContext(kaos, brandHome, options) {
 	const additionalDirs = normalizeAdditionalDirs(options?.additionalDirs ?? []);
@@ -230425,7 +230425,9 @@ var init_goal$1 = __esmMin((() => {
 		async markComplete(input = {}, actor = "model") {
 			const state = this.state;
 			if (state === void 0 || state.status !== "active") return null;
-			const completionEvidence = evaluateGoalCompletionEvidence(state);
+			const completionEvidence = evaluateGoalCompletionEvidence(state, {
+				expectedProducerRef: this.agent.evidenceProducerRef
+			});
 			if (!completionEvidence.allPassed) {
 				throw new BlunError(ErrorCodes.GOAL_STATUS_INVALID, `Completion criterion needs revision: ${completionEvidence.gaps.join(" ")} Run the required verification, save a runtime-backed verify checkpoint, then mark the goal complete.`);
 			}
@@ -245812,6 +245814,7 @@ var init_events$1 = __esmMin((() => {
 			updatedAt: string(),
 			evidenceReceipt: object({
 				turnId: number$1().int().min(0),
+				producerRef: string().regex(/^[a-f0-9]{16}$/u).optional(),
 				completedTools: number$1().int().min(0),
 				successfulTools: number$1().int().min(0),
 				failedTools: number$1().int().min(0),
@@ -260354,6 +260357,7 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 			toolName: string().min(1).max(128),
 			kind: _enum(["inspection", "integrity", "syntax", "test", "reachability"]),
 			scope: string().min(1).max(256),
+			criterion: string().min(1),
 			claim: string().min(1).max(512),
 			sharpnessProof: object({
 				toolCallId: string().min(1).max(256),
@@ -261845,7 +261849,7 @@ var init_turn = __esmMin((() => {
 				return;
 			}
 			this.cognitiveToolPolicyByCall.delete(input.toolCallId);
-			const currentEvidence = this.cognitiveActionEvidenceByTurn.get(input.turnId) ?? emptyActionEvidenceReceipt(input.turnId);
+			const currentEvidence = this.cognitiveActionEvidenceByTurn.get(input.turnId) ?? emptyActionEvidenceReceipt(input.turnId, this.agent.evidenceProducerRef);
 			this.cognitiveActionEvidenceByTurn.set(input.turnId, advanceActionEvidenceReceipt(currentEvidence, {
 				...input,
 				decision: policy.decision
@@ -261876,7 +261880,7 @@ var init_turn = __esmMin((() => {
 		}
 		actionEvidenceReceiptForCurrentTurn() {
 			const turnId = this.currentId;
-			return this.cognitiveActionEvidenceByTurn.get(turnId) ?? emptyActionEvidenceReceipt(turnId);
+			return this.cognitiveActionEvidenceByTurn.get(turnId) ?? emptyActionEvidenceReceipt(turnId, this.agent.evidenceProducerRef);
 		}
 		projectCognitiveState(turnId, input) {
 			try {
@@ -262917,6 +262921,8 @@ var update_goal_default;
 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 += "\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";
@@ -265361,6 +265367,7 @@ var init_agent = __esmMin((() => {
 		blunConfig;
 		blunHomeDir;
 		homedir;
+		evidenceProducerRef;
 		mediaOriginalsDir;
 		rpc;
 		toolServices;
@@ -265416,6 +265423,7 @@ var init_agent = __esmMin((() => {
 			this.blunConfig = options.config;
 			this.blunHomeDir = options.blunHomeDir;
 			this.homedir = options.homedir;
+			this.evidenceProducerRef = options.evidenceProducerRef;
 			this.mediaOriginalsDir = options.mediaOriginalsDir;
 			this.rpc = options.rpc;
 			this.toolServices = options.toolServices;
@@ -298009,6 +298017,7 @@ var init_session$1 = __esmMin((() => {
 				config: this.options.config,
 				blunHomeDir: this.options.blunHomeDir,
 				homedir,
+				evidenceProducerRef: evidenceProducerRef(`${this.options.id ?? this.options.homedir}\0${id}`),
 				mediaOriginalsDir: sessionMediaOriginalsDir(this.options.homedir),
 				onMediaDropped: (dropped) => {
 					for (const part of dropped) this.rpc.emitEvent({

package/package.json

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