blun-king-cli 9.1.446 → 9.1.448

package/bin/cognitive-action-checkpoint.cjs

@@ -13,19 +13,26 @@ const TRIGGER_KINDS = new Set([
   'immediate', 'external_event', 'time', 'dependency', 'user_decision',
 ]);
 const MODEL_KEYS = new Set([
-  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'nextTrigger', 'problemFrame', 'updatedAt',
+  'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'verificationProof', 'nextTrigger', 'problemFrame', 'updatedAt',
 ]);
 const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt']);
 const PROBLEM_FRAME_KEYS = new Set([
   'successCriterion', 'missingKnowledge', 'candidateActions', 'selectedAction',
-  'selectionReason', 'supportChoice', 'risk', 'reversibility',
+  'selectionReason', 'supportChoice', 'risk', 'reversibility', 'decisionBasis',
 ]);
 const NEXT_TRIGGER_KEYS = new Set(['kind', 'condition', 'dueAt']);
 const EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
 ]);
 const EVIDENCE_DIGEST_RE = /^[a-f0-9]{16}$/u;
+const DECISION_BASIS_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',
+  'ExitPlanMode', 'GenerateImage', 'GenerateSpeech', 'GenerateVideo', 'LipSyncMedia',
+  'MistakeRecord', 'SetGoalBudget', 'TaskStop', 'TaskUpdate', 'UpdateGoal', 'Write',
+]);
+const MAX_SUCCESSFUL_TOOL_DIGESTS = 32;
 
 function bounded(value, field, max = 512) {
   const text = String(value ?? '')
@@ -60,6 +67,15 @@ function boundedList(value, field) {
   return Object.freeze(value.map((item, index) => bounded(item, `${field}[${index}]`, 256)));
 }
 
+function normalizedDecisionBasis(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 5
+      || value.some((item) => typeof item !== 'string' || !DECISION_BASIS_RE.test(item))
+      || new Set(value).size !== value.length) {
+    throw new TypeError('decisionBasis must contain between 1 and 5 unique evidence refs');
+  }
+  return Object.freeze([...value]);
+}
+
 function normalizeProblemFrame(input) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) {
     throw new TypeError('problemFrame must be an object');
@@ -73,7 +89,7 @@ function normalizeProblemFrame(input) {
   if (!candidateActions.includes(selectedAction)) {
     throw new TypeError('selectedAction must match a candidateAction');
   }
-  return Object.freeze({
+  const frame = {
     successCriterion: bounded(input.successCriterion, 'successCriterion'),
     missingKnowledge,
     candidateActions,
@@ -82,7 +98,9 @@ function normalizeProblemFrame(input) {
     supportChoice: bounded(input.supportChoice, 'supportChoice', 256),
     risk: bounded(input.risk, 'risk'),
     reversibility: bounded(input.reversibility, 'reversibility'),
-  });
+  };
+  if (input.decisionBasis !== undefined) frame.decisionBasis = normalizedDecisionBasis(input.decisionBasis);
+  return Object.freeze(frame);
 }
 
 function normalizeNextTrigger(input, phase) {
@@ -136,6 +154,44 @@ function normalizedTurnId(value) {
   return turnId;
 }
 
+function successfulToolDigest(toolName) {
+  const name = bounded(toolName, 'verificationProof toolName', 128);
+  return crypto.createHash('sha256').update(`tool:${name}`).digest('hex').slice(0, 16);
+}
+
+function isActionOnlyTool(toolName) {
+  return ACTION_ONLY_TOOL_NAMES.has(String(toolName ?? '').trim());
+}
+
+function normalizeSuccessfulToolDigests(value) {
+  if (value === undefined) return Object.freeze([]);
+  if (!Array.isArray(value) || value.length > MAX_SUCCESSFUL_TOOL_DIGESTS
+      || value.some((item) => typeof item !== 'string' || !EVIDENCE_DIGEST_RE.test(item))
+      || new Set(value).size !== value.length) {
+    throw new TypeError('successful tool digests are invalid');
+  }
+  return Object.freeze([...value]);
+}
+
+function normalizeVerificationProof(input, evidenceReceipt) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)
+      || Object.keys(input).length !== 2
+      || !Object.hasOwn(input, 'toolName')
+      || !Object.hasOwn(input, 'claim')) {
+    throw new TypeError('verificationProof fields are invalid');
+  }
+  const toolName = bounded(input.toolName, 'verificationProof toolName', 128);
+  const claim = bounded(input.claim, 'verificationProof claim');
+  if (isActionOnlyTool(toolName)) {
+    throw new TypeError('action-only tool cannot serve as verification proof');
+  }
+  const receipt = normalizeActionEvidenceReceipt(evidenceReceipt);
+  if (!receipt.successfulToolDigests.includes(successfulToolDigest(toolName))) {
+    throw new TypeError('verificationProof must name a successful current-turn tool');
+  }
+  return Object.freeze({ toolName, claim });
+}
+
 function emptyActionEvidenceReceipt(turnId) {
   const normalized = normalizedTurnId(turnId);
   return Object.freeze({
@@ -143,14 +199,17 @@ function emptyActionEvidenceReceipt(turnId) {
     completedTools: 0,
     successfulTools: 0,
     failedTools: 0,
+    successfulToolDigests: Object.freeze([]),
     digest: crypto.createHash('sha256').update(`turn:${normalized}:empty`).digest('hex').slice(0, 16),
   });
 }
 
 function normalizeActionEvidenceReceipt(input) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('evidence receipt must be an object');
-  const keys = new Set(['turnId', 'completedTools', 'successfulTools', 'failedTools', 'digest']);
-  if (!Object.keys(input).every((key) => keys.has(key)) || Object.keys(input).length !== keys.size) {
+  const requiredKeys = new Set(['turnId', 'completedTools', 'successfulTools', 'failedTools', 'digest']);
+  const allowedKeys = new Set([...requiredKeys, 'successfulToolDigests']);
+  if (!Object.keys(input).every((key) => allowedKeys.has(key))
+      || ![...requiredKeys].every((key) => Object.hasOwn(input, key))) {
     throw new TypeError('evidence receipt fields are invalid');
   }
   const receipt = {
@@ -158,6 +217,7 @@ function normalizeActionEvidenceReceipt(input) {
     completedTools: Number(input.completedTools),
     successfulTools: Number(input.successfulTools),
     failedTools: Number(input.failedTools),
+    successfulToolDigests: normalizeSuccessfulToolDigests(input.successfulToolDigests),
     digest: String(input.digest ?? ''),
   };
   if (![receipt.completedTools, receipt.successfulTools, receipt.failedTools]
@@ -188,6 +248,12 @@ function advanceActionEvidenceReceipt(current, input) {
     throw new TypeError('evidence input values are invalid');
   }
   const successful = decision === 'passed' && outcome === 'success';
+  const successfulToolDigests = [...prior.successfulToolDigests];
+  const toolDigest = successfulToolDigest(toolName);
+  if (successful && !successfulToolDigests.includes(toolDigest)) {
+    successfulToolDigests.push(toolDigest);
+    if (successfulToolDigests.length > MAX_SUCCESSFUL_TOOL_DIGESTS) successfulToolDigests.shift();
+  }
   const digest = crypto.createHash('sha256').update([
     prior.digest, String(turnId), toolCallId, toolName, decision, outcome, String(durationMs),
   ].join('\0')).digest('hex').slice(0, 16);
@@ -196,6 +262,7 @@ function advanceActionEvidenceReceipt(current, input) {
     completedTools: prior.completedTools + 1,
     successfulTools: prior.successfulTools + (successful ? 1 : 0),
     failedTools: prior.failedTools + (successful ? 0 : 1),
+    successfulToolDigests: Object.freeze(successfulToolDigests),
     digest,
   });
 }
@@ -281,6 +348,12 @@ function normalizeActionCheckpoint(input, options = {}) {
       ? normalizeActionEvidenceReceipt(input.evidenceReceipt)
       : undefined;
   if (evidenceReceipt !== undefined) checkpoint.evidenceReceipt = evidenceReceipt;
+  if (input.verificationProof !== undefined) {
+    if (phase !== 'verify' || evidenceBasis !== 'runtime_tool') {
+      throw new TypeError('verificationProof requires a runtime_tool verify checkpoint');
+    }
+    checkpoint.verificationProof = normalizeVerificationProof(input.verificationProof, evidenceReceipt);
+  }
   return Object.freeze(checkpoint);
 }
 
@@ -297,6 +370,9 @@ function projectActionCheckpoint(checkpoint) {
   ];
   lines.push(`Next action: ${value.nextAction}`);
   lines.push(`Expected evidence: ${value.expectedEvidence}`);
+  if (value.verificationProof !== undefined) {
+    lines.push(`Verification proof: ${value.verificationProof.toolName} - ${value.verificationProof.claim}`);
+  }
   if (value.nextTrigger !== undefined) {
     lines.push(`Next trigger: ${value.nextTrigger.kind.replaceAll('_', ' ')} - ${value.nextTrigger.condition}`);
     if (value.nextTrigger.dueAt !== undefined) lines.push(`Due at: ${value.nextTrigger.dueAt}`);
@@ -312,6 +388,7 @@ function projectActionCheckpoint(checkpoint) {
     lines.push(`Support choice: ${frame.supportChoice}`);
     lines.push(`Risk: ${frame.risk}`);
     lines.push(`Reversibility: ${frame.reversibility}`);
+    if (frame.decisionBasis !== undefined) lines.push(`Decision basis: ${frame.decisionBasis.join(' | ')}`);
   }
   if (value.evidenceReceipt !== undefined) {
     const receipt = value.evidenceReceipt;
@@ -331,5 +408,7 @@ module.exports = {
   assertActionCheckpointRevision,
   emptyActionEvidenceReceipt,
   normalizeActionCheckpoint,
+  normalizeVerificationProof,
   projectActionCheckpoint,
+  successfulToolDigest,
 };

package/bin/cognitive-focus-projection.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+const crypto = require('node:crypto');
 const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
 const {
   buildCognitiveSalienceIndex,
@@ -55,15 +56,19 @@ function normalizeScopes(value) {
   return scopes.every(Boolean) ? [...new Set(scopes)] : null;
 }
 
-function buildCognitiveFocusSelection(state, {
-  focusScopes, maxItems = 6, maxChars = 900, currentSessionId,
-} = {}) {
-  const scopes = normalizeScopes(focusScopes);
-  if (scopes === null || !Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 8
-      || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600
-      || !Array.isArray(state?.observations)) return null;
-  if (scopes.length === 0) return null;
+function cognitiveEvidenceRef(item) {
+  const scope = clean(item?.scope, 128);
+  const domain = String(item?.domain ?? '');
+  const key = clean(item?.key, 128);
+  const observationId = clean(item?.observationId ?? item?.observation_id, 128);
+  if (!scope || scope === 'runtime' || !FOCUS_DOMAINS.has(domain) || !key || !observationId) return '';
+  return crypto.createHash('sha256')
+    .update([scope, domain, key, observationId].join('\0'))
+    .digest('hex').slice(0, 16);
+}
 
+function normalizedFocusGroups(state) {
+  if (!Array.isArray(state?.observations)) return null;
   const groups = new Map();
   state.observations.forEach((item, index) => {
     const domain = String(item?.domain ?? '');
@@ -80,7 +85,7 @@ function buildCognitiveFocusSelection(state, {
       ? 'legacy_unknown' : String(item.epistemic_state);
     const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
     if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime'
-        || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
+        || !observationId || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
         || !EPISTEMIC_MARKERS.has(epistemicState)
         || !Number.isFinite(occurredAt)) return;
     const groupKey = `${scope}\0${domain}\0${key}`;
@@ -91,11 +96,66 @@ function buildCognitiveFocusSelection(state, {
     });
     groups.set(groupKey, existing);
   });
+  for (const entries of groups.values()) {
+    entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
+  }
+  return groups;
+}
+
+function currentEvidenceRefs(entries, effective) {
+  if (!effective || effective.conflict) return [];
+  const withdrawals = entries.filter((item) => Boolean(item.withdraws));
+  const deletionCutoff = withdrawals.length > 0
+    ? Math.max(...withdrawals.map((item) => item.occurredAt)) : Number.NEGATIVE_INFINITY;
+  const evidence = entries.filter((item) => !item.withdraws && item.occurredAt > deletionCutoff);
+  const superseded = new Set(evidence.map((item) => item.supersedes).filter(Boolean));
+  return evidence
+    .filter((item) => !superseded.has(item.observationId) && item.value === effective.value)
+    .map(cognitiveEvidenceRef)
+    .filter(Boolean);
+}
+
+function evaluateCognitiveDecisionBasis(state, refs) {
+  if (refs === undefined || refs === null) return null;
+  if (!Array.isArray(refs) || refs.length < 1 || refs.length > 5
+      || refs.some((ref) => !/^[a-f0-9]{16}$/u.test(String(ref)))
+      || new Set(refs).size !== refs.length) {
+    return { status: 'unknown', currentRefs: [], staleRefs: [], unknownRefs: [] };
+  }
+  const groups = normalizedFocusGroups(state);
+  if (groups === null) return { status: 'unknown', currentRefs: [], staleRefs: [], unknownRefs: [...refs] };
+  const historical = new Set();
+  const current = new Set();
+  for (const entries of groups.values()) {
+    entries.map(cognitiveEvidenceRef).filter(Boolean).forEach((ref) => historical.add(ref));
+    const effective = resolveCognitiveEvidenceGroup(entries);
+    currentEvidenceRefs(entries, effective).forEach((ref) => current.add(ref));
+  }
+  const currentRefs = refs.filter((ref) => current.has(ref));
+  const staleRefs = refs.filter((ref) => !current.has(ref) && historical.has(ref));
+  const unknownRefs = refs.filter((ref) => !current.has(ref) && !historical.has(ref));
+  return {
+    status: staleRefs.length > 0 ? 'stale' : unknownRefs.length > 0 ? 'unknown' : 'current',
+    currentRefs,
+    staleRefs,
+    unknownRefs,
+  };
+}
+
+function buildCognitiveFocusSelection(state, {
+  focusScopes, maxItems = 6, maxChars = 900, currentSessionId,
+} = {}) {
+  const scopes = normalizeScopes(focusScopes);
+  if (scopes === null || !Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 8
+      || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600) return null;
+  if (scopes.length === 0) return null;
+
+  const groups = normalizedFocusGroups(state);
+  if (groups === null) return null;
 
   const salience = buildCognitiveSalienceIndex(state, { currentSessionId });
   const ranked = [];
   for (const entries of groups.values()) {
-    entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
     const latest = entries.at(-1);
     if (!scopes.includes(latest.scope)) continue;
     const effective = resolveCognitiveEvidenceGroup(entries);
@@ -117,7 +177,7 @@ function buildCognitiveFocusSelection(state, {
     if (item.conflict) return `- Conflict: ${item.key} has incompatible evidence; verify before relying on it.`;
     const marker = item.corrected ? ' [corrected]'
       : item.contested ? ' [contested; stronger evidence]' : item.revised ? ' [revised]' : '';
-    return `- ${LABELS.get(item.domain)}: ${item.value}${EPISTEMIC_MARKERS.get(item.epistemicState)}${marker}`;
+    return `- ${LABELS.get(item.domain)}: ${item.value}${EPISTEMIC_MARKERS.get(item.epistemicState)}${marker} [ref:${cognitiveEvidenceRef(item)}]`;
   });
   while ([`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n').length > maxChars
       && lines.length > 0) lines.pop();
@@ -125,7 +185,12 @@ function buildCognitiveFocusSelection(state, {
   const kept = selected.slice(0, lines.length);
   return {
     text: [`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n'),
-    selected: kept.map((item) => ({ scope: item.scope, domain: item.domain, key: item.key })),
+    selected: kept.map((item) => ({
+      scope: item.scope,
+      domain: item.domain,
+      key: item.key,
+      ...(item.conflict ? {} : { evidenceRef: cognitiveEvidenceRef(item) }),
+    })),
   };
 }
 
@@ -133,4 +198,9 @@ function buildCognitiveFocusProjection(state, options) {
   return buildCognitiveFocusSelection(state, options)?.text ?? null;
 }
 
-module.exports = { buildCognitiveFocusProjection, buildCognitiveFocusSelection };
+module.exports = {
+  buildCognitiveFocusProjection,
+  buildCognitiveFocusSelection,
+  cognitiveEvidenceRef,
+  evaluateCognitiveDecisionBasis,
+};

package/bin/cognitive-turn-lifecycle.cjs

@@ -6,7 +6,10 @@ const path = require('node:path');
 const { openCognitiveMemoryAdapter } = require('./cognitive-memory-adapter.cjs');
 const { loadConfiguredCognitiveMemoryAdapter } = require('./cognitive-memory-provider.cjs');
 const { buildCognitiveContextProjection } = require('./cognitive-context-projection.cjs');
-const { buildCognitiveFocusSelection } = require('./cognitive-focus-projection.cjs');
+const {
+  buildCognitiveFocusSelection,
+  evaluateCognitiveDecisionBasis,
+} = require('./cognitive-focus-projection.cjs');
 const { cognitiveEntityKey, focusAccessObservation } = require('./cognitive-salience-policy.cjs');
 const { authorizeAttentionCandidate } = require('./cognitive-attention-runtime.cjs');
 
@@ -490,6 +493,11 @@ function createCognitiveTurnLifecycle({
     return [focus?.text, continuity].filter(Boolean).join('\n\n') || null;
   }
 
+  function evaluateDecisionBasis(refs) {
+    const state = store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess);
+    return evaluateCognitiveDecisionBasis(state, refs);
+  }
+
   function authorizeAttention(input) {
     const candidate = input?.candidate;
     const authorization = input?.authorization;
@@ -552,6 +560,7 @@ function createCognitiveTurnLifecycle({
     withdrawFocusObservation,
     authorizeAttention,
     memoryStatus,
+    evaluateDecisionBasis,
     projectForTurn,
     endTurn,
     read: () => store.read({ tenantId: tenant, agentId: agent }, internalMemoryAccess),

package/bin/cognitive-work-focus.cjs

@@ -23,7 +23,7 @@ function bounded(value, max = 512) {
   return text.length <= max ? text : `${text.slice(0, max - 3).trimEnd()}...`;
 }
 
-function buildCognitiveWorkFocus(goal) {
+function buildCognitiveWorkFocus(goal, { decisionFreshness } = {}) {
   if (!goal || typeof goal !== 'object' || Array.isArray(goal)) return null;
   const goalId = String(goal.goalId ?? '').trim();
   const objective = bounded(goal.objective);
@@ -75,6 +75,11 @@ function buildCognitiveWorkFocus(goal) {
   const frameSupportChoice = bounded(problemFrame?.supportChoice, 256);
   const frameRisk = bounded(problemFrame?.risk);
   const frameReversibility = bounded(problemFrame?.reversibility);
+  const frameDecisionBasis = Array.isArray(problemFrame?.decisionBasis)
+    && problemFrame.decisionBasis.length >= 1 && problemFrame.decisionBasis.length <= 5
+    && problemFrame.decisionBasis.every((item) => /^[a-f0-9]{16}$/u.test(String(item)))
+    && new Set(problemFrame.decisionBasis).size === problemFrame.decisionBasis.length
+    ? [...problemFrame.decisionBasis] : [];
   const hasProblemFrame = problemFrame !== null && frameSuccessCriterion
     && frameMissingKnowledge.length > 0 && frameCandidates.length > 0
     && frameSelectedAction && frameSelectionReason && frameSupportChoice
@@ -83,8 +88,17 @@ function buildCognitiveWorkFocus(goal) {
     && nextAction && checkpointEvidence;
   const epistemicState = hasCheckpoint && EPISTEMIC_STATES.has(checkpointEpistemicState)
     ? checkpointEpistemicState : hasCheckpoint ? 'legacy_unknown' : 'verified';
-  const knowledgeGapValue = hasProblemFrame ? frameMissingKnowledge.join(' | ') : 'none';
+  const decisionFreshnessStatus = frameDecisionBasis.length > 0
+    && ['current', 'stale', 'unknown'].includes(decisionFreshness?.status)
+    ? decisionFreshness.status : frameDecisionBasis.length > 0 ? 'unknown' : '';
+  const staleDecision = decisionFreshnessStatus === 'stale' || decisionFreshnessStatus === 'unknown';
+  const replanKnowledgeGap = 'Re-evaluate the selected action against current durable evidence.';
+  const replanTrigger = 'Re-evaluate the selected action against the current durable evidence.';
+  const replanEvidence = 'A replacement action is bound to current durable evidence refs.';
+  const knowledgeGapValue = staleDecision ? `${replanKnowledgeGap} ${frameMissingKnowledge.join(' | ')}`
+    : hasProblemFrame ? frameMissingKnowledge.join(' | ') : 'none';
   const decisionThread = hasProblemFrame ? [
+    ...(staleDecision ? [`Decision basis ${decisionFreshnessStatus}; replan before executing the selected action.`] : []),
     `Goal is ${status}`,
     `Phase ${checkpointPhase}`,
     `Last verified: ${bounded(lastVerified, 80)}`,
@@ -112,6 +126,8 @@ function buildCognitiveWorkFocus(goal) {
       hasProblemFrame ? frameSupportChoice : '',
       hasProblemFrame ? frameRisk : '',
       hasProblemFrame ? frameReversibility : '',
+      hasProblemFrame ? frameDecisionBasis.join('\0') : '',
+      decisionFreshnessStatus,
     ].join('\0'))
     .digest('hex').slice(0, 40);
   const keyRoot = `goal:${goalId}`;
@@ -128,24 +144,34 @@ function buildCognitiveWorkFocus(goal) {
             `Next action: ${nextAction}`,
           ].join(' ')
           : `Goal is ${status}.`),
-        confidence: 1, epistemicState, scope: focusScope,
+        confidence: 1,
+        epistemicState: staleDecision ? decisionFreshnessStatus : epistemicState,
+        scope: focusScope,
       },
       {
         domain: 'knowledge_gap', key: `${keyRoot}:knowledge-gaps`,
         value: knowledgeGapValue,
         confidence: 1,
-        epistemicState: hasProblemFrame ? 'unknown' : 'verified',
+        epistemicState: hasProblemFrame || staleDecision ? 'unknown' : 'verified',
         scope: focusScope,
       },
       {
         domain: 'next_trigger', key: `${keyRoot}:next`,
-        value: status === 'active' && hasCheckpoint ? triggerValue : NEXT_TRIGGER.get(status),
-        confidence: 1, epistemicState, scope: focusScope,
+        value: status === 'active' && hasCheckpoint
+          ? staleDecision ? replanTrigger : triggerValue
+          : NEXT_TRIGGER.get(status),
+        confidence: 1,
+        epistemicState: staleDecision ? decisionFreshnessStatus : epistemicState,
+        scope: focusScope,
       },
       {
         domain: 'expected_evidence', key: `${keyRoot}:evidence`,
-        value: status === 'active' && hasCheckpoint ? checkpointEvidence : completionCriterion,
-        confidence: 1, epistemicState, scope: focusScope,
+        value: status === 'active' && hasCheckpoint
+          ? staleDecision ? replanEvidence : checkpointEvidence
+          : completionCriterion,
+        confidence: 1,
+        epistemicState: staleDecision ? decisionFreshnessStatus : epistemicState,
+        scope: focusScope,
       },
     ],
   };

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

@@ -1,5 +1,9 @@
 'use strict';
 
+const {
+  normalizeVerificationProof,
+} = require('./cognitive-action-checkpoint.cjs');
+
 function hasCompletionCriterion(goal) {
   return typeof goal?.completionCriterion === 'string'
     && goal.completionCriterion.trim().length > 0;
@@ -10,6 +14,24 @@ function successfulRuntimeEvidence(checkpoint) {
   return Number.isSafeInteger(successfulTools) && successfulTools > 0;
 }
 
+function verificationProofGaps(checkpoint) {
+  if (!checkpoint?.verificationProof) {
+    return ['Bind the completion claim to a successful verification tool from the checkpoint turn.'];
+  }
+  try {
+    normalizeVerificationProof(checkpoint.verificationProof, checkpoint.evidenceReceipt);
+    return [];
+  } catch (error) {
+    if (/action-only tool/u.test(String(error?.message ?? ''))) {
+      return ['The completion proof names an action-only tool, not a verification tool.'];
+    }
+    if (/successful current-turn tool/u.test(String(error?.message ?? ''))) {
+      return ['The completion proof does not match a successful verification tool from the checkpoint turn.'];
+    }
+    return ['The completion verification proof is malformed.'];
+  }
+}
+
 function evaluateGoalCompletionEvidence(goal) {
   if (!hasCompletionCriterion(goal)) {
     return {
@@ -40,9 +62,16 @@ function evaluateGoalCompletionEvidence(goal) {
   if (checkpoint.epistemicState !== 'verified') {
     gaps.push('The completion proof must be classified as verified.');
   }
-  if (!successfulRuntimeEvidence(checkpoint)) {
+  const hasRuntimeEvidence = successfulRuntimeEvidence(checkpoint);
+  if (!hasRuntimeEvidence) {
     gaps.push('The runtime evidence receipt must contain at least one successful tool result.');
   }
+  if (checkpoint.phase === 'verify'
+      && checkpoint.evidenceBasis === 'runtime_tool'
+      && checkpoint.epistemicState === 'verified'
+      && hasRuntimeEvidence) {
+    gaps.push(...verificationProofGaps(checkpoint));
+  }
 
   return {
     required: true,

package/blun.mjs

@@ -245806,7 +245806,8 @@ var init_events$1 = __esmMin((() => {
 				selectionReason: string(),
 				supportChoice: string(),
 				risk: string(),
-				reversibility: string()
+				reversibility: string(),
+				decisionBasis: array(string()).optional()
 			}).strict().optional(),
 			updatedAt: string(),
 			evidenceReceipt: object({
@@ -260306,6 +260307,7 @@ bytesWritten: number$1().int().nonnegative() });
 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";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/serialize.ts
@@ -260333,7 +260335,8 @@ function createProblemFrameInputSchema() {
 		selectionReason: string().min(1).max(512),
 		supportChoice: string().min(1).max(256),
 		risk: string().min(1).max(512),
-		reversibility: string().min(1).max(512)
+		reversibility: string().min(1).max(512),
+		decisionBasis: array(string().regex(/^[a-f0-9]{16}$/u)).min(1).max(5).optional()
 	}).strict();
 }
 function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFrame = false) {
@@ -260345,6 +260348,10 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 		lastVerified: string().min(1).max(512),
 		nextAction: string().min(1).max(512),
 		expectedEvidence: string().min(1).max(512),
+		verificationProof: object({
+			toolName: string().min(1).max(128),
+			claim: string().min(1).max(512)
+		}).strict().optional(),
 		nextTrigger: object({
 			kind: _enum(["immediate", "external_event", "time", "dependency", "user_decision"]),
 			condition: string().min(1).max(512),
@@ -261835,7 +261842,9 @@ var init_turn = __esmMin((() => {
 			try {
 				const focusScopes = cognitiveFocusScopesForTurn(input);
 				const lifecycle = this.getCognitiveLifecycle();
-				const workFocus = buildCognitiveWorkFocus(this.agent.goal.getGoal().goal);
+				const goal = this.agent.goal.getGoal().goal;
+				const decisionFreshness = lifecycle?.evaluateDecisionBasis(goal?.actionCheckpoint?.problemFrame?.decisionBasis) ?? null;
+				const workFocus = buildCognitiveWorkFocus(goal, { decisionFreshness });
 				if (workFocus !== null) {
 					lifecycle?.recordFocusSnapshot({
 						snapshotId: workFocus.snapshotId,
@@ -262863,7 +262872,8 @@ var init_outcome_prompts = __esmMin((() => {}));
 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 += "\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. Problem framing is descriptive state and never grants permission.\n";
+	update_goal_default += "\nBefore completing a goal with a criterion, bind the verified claim to the successful current-turn verification tool in `verificationProof`. A write or edit is an action, not proof that the changed behavior works. Run a separate observation, test, or counterexample probe and name that successful tool plus the exact claim it supports.\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";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts

package/package.json

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