blun-king-cli 9.1.450 → 9.1.452

package/bin/cognitive-action-checkpoint.cjs

@@ -13,6 +13,7 @@ const TRIGGER_KINDS = new Set([
   'immediate', 'external_event', 'time', 'dependency', 'user_decision',
 ]);
 const VERIFICATION_SUBJECTS = new Set(['result', 'verifier']);
+const VERIFICATION_KINDS = new Set(['inspection', 'integrity', 'syntax', 'test', 'reachability']);
 const MODEL_KEYS = new Set([
   'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'verificationProof', 'nextTrigger', 'problemFrame', 'updatedAt',
 ]);
@@ -24,6 +25,7 @@ const PROBLEM_FRAME_KEYS = new Set([
 const NEXT_TRIGGER_KEYS = new Set(['kind', 'condition', 'dueAt']);
 const EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs', 'toolArgs',
+  'resultEvidenceKinds', 'resultEvidenceScopes',
 ]);
 const REQUIRED_EVIDENCE_INPUT_KEYS = new Set([
   'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
@@ -36,14 +38,20 @@ const ACTION_ONLY_TOOL_NAMES = new Set([
   'ExitPlanMode', 'GenerateImage', 'GenerateSpeech', 'GenerateVideo', 'LipSyncMedia',
   'MistakeRecord', 'SetGoalBudget', 'TaskStop', 'TaskUpdate', 'UpdateGoal', 'Write',
 ]);
-const VERIFICATION_TOOL_NAMES = new Set([
+const INSPECTION_TOOL_NAMES = new Set([
   'codebasesearch', 'cronlist', 'fetchurl', 'getgoal', 'getmedia', 'glob', 'grep',
-  'read', 'readmediafile', 'taskoutput', 'test', 'understandimage', 'understandvideo',
+  'read', 'readmediafile', 'taskoutput', 'understandimage', 'understandvideo',
   'websearch',
 ]);
+const TEST_TOOL_NAMES = new Set(['test']);
 const COMMAND_TOOL_NAMES = new Set(['bash', 'command', 'exec_command', 'shell']);
 const MUTATING_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:cp|mv|rm|mkdir|touch|tee|install|scp|sftp|ssh)\b|(?:sed\s+-i\b)|(?:git\s+(?:add|commit|push|checkout|switch|reset|clean|merge|rebase)\b)|(?:Set-Content|Add-Content|Copy-Item|Move-Item|Remove-Item|New-Item|Start-Process)\b)/iu;
-const VERIFICATION_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:node\s+--(?:test|check))|(?:node\s+[^\s;&|]*(?:check|test|verify|validate|lint|gate|probe)[^\s;&|]*\b)|(?:(?:npm|pnpm|yarn)\s+(?:test|(?:run\s+)?(?:test|lint|check|typecheck|build)))|(?:python(?:3)?\s+-m\s+pytest)|(?:pytest)|(?:go\s+test)|(?:cargo\s+test)|(?:dotnet\s+test)|(?:npx\s+)?(?:tsc|eslint|biome\s+check)|(?:git\s+(?:diff(?:\s+--check)?|fsck|status|rev-parse|show))|(?:sha(?:1|256|512)sum|shasum|cmp|diff|wc|rg|grep|cat|ls|stat)\b|(?:certutil\s+-hashfile)|(?:Get-FileHash|Get-Content|Get-Item|Test-Path|Compare-Object|Measure-Object)\b)/iu;
+const INSPECTION_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:git\s+(?:status|rev-parse|show))|(?:wc|rg|grep|cat|ls|stat)\b|(?:Get-Content|Get-Item|Test-Path|Measure-Object)\b)/iu;
+const INTEGRITY_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:git\s+(?:diff(?:\s+--check)?|fsck))|(?:sha(?:1|256|512)sum|shasum|cmp|diff)\b|(?:certutil\s+-hashfile)|(?:Get-FileHash|Compare-Object)\b)/iu;
+const SYNTAX_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:node\s+--check\b)|(?:(?:npx\s+)?tsc\b)|(?:(?:npm|pnpm|yarn)\s+(?:(?:run\s+)?typecheck)\b))/iu;
+const TEST_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:(?:node\s+--test\b)|(?:node\s+(?!--)[^\s;&|]*(?:check|test|verify|validate|lint|gate|probe)[^\s;&|]*\b)|(?:(?:npm|pnpm|yarn)\s+(?:test|(?:run\s+)?(?:test|lint|check|build))\b)|(?:python(?:3)?\s+-m\s+pytest\b)|(?:pytest\b)|(?:go\s+test\b)|(?:cargo\s+test\b)|(?:dotnet\s+test\b)|(?:(?:npx\s+)?(?:eslint|biome\s+check)\b))/iu;
+const RUNTIME_EVIDENCE_COMMAND = /(?:^|(?:&&|\|\||;|\s))(?:node\s+(?!--check\b)(?:-e\b|[^\s;&|]+)|(?:python(?:3)?\s+(?!-m\s+pytest\b)[^\s;&|]+)|(?:npm|pnpm|yarn)\s+(?:test|run\b)|pytest\b|go\s+test\b|cargo\s+test\b|dotnet\s+test\b)/iu;
+const EVIDENCE_SCOPE_MARKER = /(?:^|\s)BLUN_EVIDENCE_SCOPE=([A-Za-z0-9._:/\\-]{1,256})(?=\s|$)/gu;
 const MAX_SUCCESSFUL_TOOL_DIGESTS = 32;
 
 function bounded(value, field, max = 512) {
@@ -181,6 +189,33 @@ function successfulToolCallDigest(turnId, toolCallId, toolName) {
     .slice(0, 16);
 }
 
+function successfulVerificationCallDigest(turnId, toolCallId, toolName, kind) {
+  const turn = normalizedTurnId(turnId);
+  const callId = bounded(toolCallId, 'verificationProof toolCallId', 256);
+  const name = bounded(toolName, 'verificationProof toolName', 128);
+  const normalizedKind = normalizedVerificationKind(kind);
+  return crypto.createHash('sha256')
+    .update(`turn:${turn}\0call:${callId}\0tool:${name}\0kind:${normalizedKind}`)
+    .digest('hex')
+    .slice(0, 16);
+}
+
+function normalizedVerificationScope(value, field = 'verificationProof scope') {
+  return bounded(value, field, 256);
+}
+
+function successfulVerificationScopeDigest(turnId, toolCallId, toolName, kind, scope) {
+  const turn = normalizedTurnId(turnId);
+  const callId = bounded(toolCallId, 'verificationProof toolCallId', 256);
+  const name = bounded(toolName, 'verificationProof toolName', 128);
+  const normalizedKind = normalizedVerificationKind(kind);
+  const normalizedScope = normalizedVerificationScope(scope);
+  return crypto.createHash('sha256')
+    .update(`turn:${turn}\0call:${callId}\0tool:${name}\0kind:${normalizedKind}\0scope:${normalizedScope}`)
+    .digest('hex')
+    .slice(0, 16);
+}
+
 function isActionOnlyTool(toolName) {
   return ACTION_ONLY_TOOL_NAMES.has(String(toolName ?? '').trim());
 }
@@ -191,14 +226,93 @@ function verificationCommand(toolArgs) {
   return typeof command === 'string' ? command.trim().replace(/\s+/gu, ' ') : '';
 }
 
-function isVerificationToolCall(toolName, toolArgs) {
+function toolArgumentScope(toolName, toolArgs) {
+  if (!toolArgs || typeof toolArgs !== 'object' || Array.isArray(toolArgs)) return '';
+  const name = String(toolName ?? '').trim().toLowerCase();
+  const first = (...keys) => {
+    for (const key of keys) {
+      if (typeof toolArgs[key] === 'string' && toolArgs[key].trim().length > 0) {
+        return normalizedVerificationScope(toolArgs[key], 'verification target scope');
+      }
+    }
+    return '';
+  };
+  if (['read', 'readmediafile', 'understandimage', 'understandvideo'].includes(name)) {
+    return first('file_path', 'path', 'image_path', 'video_path');
+  }
+  if (name === 'getmedia') return first('media_id', 'id', 'path');
+  if (name === 'taskoutput') return first('task_id', 'id');
+  if (name === 'fetchurl') return first('url', 'uri');
+  if (name === 'websearch') return first('query', 'q');
+  if (name === 'grep' || name === 'glob' || name === 'codebasesearch') {
+    return first('path', 'cwd', 'directory', 'root', 'query', 'pattern');
+  }
+  if (name === 'getgoal') return 'runtime:active-goal';
+  if (name === 'cronlist') return 'runtime:cron-jobs';
+  return '';
+}
+
+function commandEvidenceScopes(toolName, toolArgs, providedScopes) {
+  const normalizedName = String(toolName ?? '').trim().toLowerCase();
+  if (!COMMAND_TOOL_NAMES.has(normalizedName)) return Object.freeze([]);
+  const command = verificationCommand(toolArgs);
+  if (command.length < 1 || MUTATING_COMMAND.test(command)) return Object.freeze([]);
+  const declared = new Set();
+  EVIDENCE_SCOPE_MARKER.lastIndex = 0;
+  for (const match of command.matchAll(EVIDENCE_SCOPE_MARKER)) declared.add(match[1]);
+  return Object.freeze(providedScopes.filter((scope) => declared.has(scope)));
+}
+
+function verificationKindsForToolCall(toolName, toolArgs) {
+  const normalizedName = String(toolName ?? '').trim().toLowerCase();
+  if (INSPECTION_TOOL_NAMES.has(normalizedName)) return Object.freeze(['inspection']);
+  if (TEST_TOOL_NAMES.has(normalizedName)) return Object.freeze(['test']);
+  if (!COMMAND_TOOL_NAMES.has(normalizedName)) return Object.freeze([]);
+  const command = verificationCommand(toolArgs);
+  if (command.length < 1 || MUTATING_COMMAND.test(command)) return Object.freeze([]);
+  const kinds = [];
+  if (INSPECTION_COMMAND.test(command)) kinds.push('inspection');
+  if (INTEGRITY_COMMAND.test(command)) kinds.push('integrity');
+  if (SYNTAX_COMMAND.test(command)) kinds.push('syntax');
+  if (TEST_COMMAND.test(command)) kinds.push('test');
+  return Object.freeze(kinds);
+}
+
+function canCarryExplicitResultEvidence(toolName, toolArgs) {
   const normalizedName = String(toolName ?? '').trim().toLowerCase();
-  if (VERIFICATION_TOOL_NAMES.has(normalizedName)) return true;
   if (!COMMAND_TOOL_NAMES.has(normalizedName)) return false;
   const command = verificationCommand(toolArgs);
   return command.length > 0
     && !MUTATING_COMMAND.test(command)
-    && VERIFICATION_COMMAND.test(command);
+    && RUNTIME_EVIDENCE_COMMAND.test(command);
+}
+
+function normalizedVerificationKind(value, field = 'verificationProof kind') {
+  const kind = String(value ?? '').trim();
+  if (!VERIFICATION_KINDS.has(kind)) throw new TypeError(`${field} is invalid`);
+  return kind;
+}
+
+function normalizedResultEvidenceKinds(value) {
+  if (value === undefined) return Object.freeze([]);
+  const kinds = Array.isArray(value) ? value.map((item) => String(item ?? '').trim()) : [];
+  if (!Array.isArray(value) || value.length > VERIFICATION_KINDS.size
+      || kinds.some((item) => !VERIFICATION_KINDS.has(item))
+      || new Set(kinds).size !== kinds.length) {
+    throw new TypeError('result evidence kinds are invalid');
+  }
+  return Object.freeze(kinds);
+}
+
+function normalizedResultEvidenceScopes(value) {
+  if (value === undefined) return Object.freeze([]);
+  const scopes = Array.isArray(value)
+    ? value.map((item, index) => normalizedVerificationScope(item, `resultEvidenceScopes[${index}]`))
+    : [];
+  if (!Array.isArray(value) || value.length > 5 || new Set(scopes).size !== scopes.length) {
+    throw new TypeError('result evidence scopes are invalid');
+  }
+  return Object.freeze(scopes);
 }
 
 function normalizeSuccessfulToolDigests(value) {
@@ -211,12 +325,17 @@ function normalizeSuccessfulToolDigests(value) {
   return Object.freeze([...value]);
 }
 
-function normalizeExactVerificationCall(input, receipt, label) {
+function normalizeExactVerificationCall(input, receipt, label, options = {}) {
+  const requireKind = options.requireKind === true;
+  const requireScope = options.requireScope === true;
+  const expectedKeys = 3 + (requireKind ? 1 : 0) + (requireScope ? 1 : 0);
   if (!input || typeof input !== 'object' || Array.isArray(input)
-      || Object.keys(input).length !== 3
+      || Object.keys(input).length !== expectedKeys
       || !Object.hasOwn(input, 'toolCallId')
       || !Object.hasOwn(input, 'toolName')
-      || !Object.hasOwn(input, 'claim')) {
+      || !Object.hasOwn(input, 'claim')
+      || requireKind !== Object.hasOwn(input, 'kind')
+      || requireScope !== Object.hasOwn(input, 'scope')) {
     throw new TypeError(`${label} fields are invalid`);
   }
   const toolCallId = bounded(input.toolCallId, `${label} toolCallId`, 256);
@@ -230,6 +349,24 @@ function normalizeExactVerificationCall(input, receipt, label) {
   if (!receipt.successfulToolCallDigests.includes(callDigest)) {
     throw new TypeError(`${label} must match a successful current-turn verification call`);
   }
+  if (requireKind) {
+    const kind = normalizedVerificationKind(input.kind, `${label} kind`);
+    const typedDigest = successfulVerificationCallDigest(receipt.turnId, toolCallId, toolName, kind);
+    if (!receipt.successfulVerificationCallDigests.includes(typedDigest)) {
+      throw new TypeError(`${label} kind must match the successful current-turn verification call`);
+    }
+    if (requireScope) {
+      const scope = normalizedVerificationScope(input.scope, `${label} scope`);
+      const scopeDigest = successfulVerificationScopeDigest(
+        receipt.turnId, toolCallId, toolName, kind, scope,
+      );
+      if (!receipt.successfulVerificationScopeDigests.includes(scopeDigest)) {
+        throw new TypeError(`${label} scope must match the successful current-turn verification call target`);
+      }
+      return Object.freeze({ toolCallId, toolName, kind, scope, claim });
+    }
+    return Object.freeze({ toolCallId, toolName, kind, claim });
+  }
   return Object.freeze({ toolCallId, toolName, claim });
 }
 
@@ -247,18 +384,52 @@ function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
     && Object.hasOwn(input, 'toolName')
     && Object.hasOwn(input, 'claim');
   const subject = String(input?.subject ?? '').trim();
-  const currentResult = subject === 'result'
+  const legacySubjectResult = options.allowLegacy === true
+    && subject === 'result'
     && keys.length === 4
     && Object.hasOwn(input, 'toolCallId')
     && Object.hasOwn(input, 'toolName')
     && Object.hasOwn(input, 'claim');
-  const currentVerifier = subject === 'verifier'
+  const legacySubjectVerifier = options.allowLegacy === true
+    && subject === 'verifier'
     && (keys.length === 4 || keys.length === 5)
     && Object.hasOwn(input, 'toolCallId')
     && Object.hasOwn(input, 'toolName')
     && Object.hasOwn(input, 'claim')
     && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'claim', 'sharpnessProof'].includes(key));
-  if (!legacyName && !legacyExact && !currentResult && !currentVerifier) {
+  const legacyTypedSubjectResult = options.allowLegacy === true
+    && subject === 'result'
+    && keys.length === 5
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'claim');
+  const legacyTypedSubjectVerifier = options.allowLegacy === true
+    && subject === 'verifier'
+    && (keys.length === 5 || keys.length === 6)
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'claim')
+    && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'claim', 'sharpnessProof'].includes(key));
+  const currentResult = 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'
+    && (keys.length === 6 || keys.length === 7)
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'kind')
+    && Object.hasOwn(input, 'scope')
+    && Object.hasOwn(input, 'claim')
+    && keys.every((key) => ['subject', 'toolCallId', 'toolName', 'kind', 'scope', 'claim', 'sharpnessProof'].includes(key));
+  if (!legacyName && !legacyExact && !legacySubjectResult && !legacySubjectVerifier
+      && !legacyTypedSubjectResult && !legacyTypedSubjectVerifier
+      && !currentResult && !currentVerifier) {
     throw new TypeError('verificationProof fields are invalid');
   }
   const receipt = normalizeActionEvidenceReceipt(evidenceReceipt);
@@ -273,18 +444,28 @@ function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
     }
     return Object.freeze({ toolName, claim });
   }
+  const legacySubject = legacySubjectResult || legacySubjectVerifier;
+  const legacyTypedSubject = legacyTypedSubjectResult || legacyTypedSubjectVerifier;
   const primary = normalizeExactVerificationCall(legacyExact ? input : {
     toolCallId: input.toolCallId,
     toolName: input.toolName,
+    ...(legacySubject ? {} : { kind: input.kind }),
+    ...(currentResult || currentVerifier ? { scope: input.scope } : {}),
     claim: input.claim,
-  }, receipt, 'verificationProof');
+  }, receipt, 'verificationProof', {
+    requireKind: !legacyExact && !legacySubject,
+    requireScope: currentResult || currentVerifier,
+  });
   if (legacyExact) return primary;
   if (!VERIFICATION_SUBJECTS.has(subject)) throw new TypeError('verificationProof subject is invalid');
   if (subject === 'result') return Object.freeze({ subject, ...primary });
   if (input.sharpnessProof === undefined) {
     throw new TypeError('verifier proof requires a sharpnessProof');
   }
-  const sharpnessProof = normalizeExactVerificationCall(input.sharpnessProof, receipt, 'sharpnessProof');
+  const sharpnessProof = normalizeExactVerificationCall(input.sharpnessProof, receipt, 'sharpnessProof', {
+    requireKind: !legacySubject,
+    requireScope: !legacySubject && !legacyTypedSubject,
+  });
   if (sharpnessProof.toolCallId === primary.toolCallId
       && sharpnessProof.toolName === primary.toolName) {
     throw new TypeError('sharpnessProof must name a distinct verification call');
@@ -301,6 +482,8 @@ function emptyActionEvidenceReceipt(turnId) {
     failedTools: 0,
     successfulToolDigests: Object.freeze([]),
     successfulToolCallDigests: Object.freeze([]),
+    successfulVerificationCallDigests: Object.freeze([]),
+    successfulVerificationScopeDigests: Object.freeze([]),
     digest: crypto.createHash('sha256').update(`turn:${normalized}:empty`).digest('hex').slice(0, 16),
   });
 }
@@ -308,7 +491,10 @@ function emptyActionEvidenceReceipt(turnId) {
 function normalizeActionEvidenceReceipt(input) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) throw new TypeError('evidence receipt must be an object');
   const requiredKeys = new Set(['turnId', 'completedTools', 'successfulTools', 'failedTools', 'digest']);
-  const allowedKeys = new Set([...requiredKeys, 'successfulToolDigests', 'successfulToolCallDigests']);
+  const allowedKeys = new Set([
+    ...requiredKeys, 'successfulToolDigests', 'successfulToolCallDigests',
+    'successfulVerificationCallDigests', 'successfulVerificationScopeDigests',
+  ]);
   if (!Object.keys(input).every((key) => allowedKeys.has(key))
       || ![...requiredKeys].every((key) => Object.hasOwn(input, key))) {
     throw new TypeError('evidence receipt fields are invalid');
@@ -320,6 +506,12 @@ function normalizeActionEvidenceReceipt(input) {
     failedTools: Number(input.failedTools),
     successfulToolDigests: normalizeSuccessfulToolDigests(input.successfulToolDigests),
     successfulToolCallDigests: normalizeSuccessfulToolDigests(input.successfulToolCallDigests),
+    successfulVerificationCallDigests: normalizeSuccessfulToolDigests(
+      input.successfulVerificationCallDigests,
+    ),
+    successfulVerificationScopeDigests: normalizeSuccessfulToolDigests(
+      input.successfulVerificationScopeDigests,
+    ),
     digest: String(input.digest ?? ''),
   };
   if (![receipt.completedTools, receipt.successfulTools, receipt.failedTools]
@@ -352,20 +544,58 @@ function advanceActionEvidenceReceipt(current, input) {
   const successful = decision === 'passed' && outcome === 'success';
   const successfulToolDigests = [...prior.successfulToolDigests];
   const successfulToolCallDigests = [...prior.successfulToolCallDigests];
+  const successfulVerificationCallDigests = [...prior.successfulVerificationCallDigests];
+  const successfulVerificationScopeDigests = [...prior.successfulVerificationScopeDigests];
   const toolDigest = successfulToolDigest(toolName);
   if (successful && !successfulToolDigests.includes(toolDigest)) {
     successfulToolDigests.push(toolDigest);
     if (successfulToolDigests.length > MAX_SUCCESSFUL_TOOL_DIGESTS) successfulToolDigests.shift();
   }
-  const verificationCall = successful && isVerificationToolCall(toolName, input.toolArgs);
+  const providedResultKinds = normalizedResultEvidenceKinds(input.resultEvidenceKinds);
+  const explicitResultKinds = successful && canCarryExplicitResultEvidence(toolName, input.toolArgs)
+    ? providedResultKinds
+    : [];
+  const verificationKinds = successful
+    ? [...new Set([...verificationKindsForToolCall(toolName, input.toolArgs), ...explicitResultKinds])]
+    : [];
+  const argumentScope = successful ? toolArgumentScope(toolName, input.toolArgs) : '';
+  const providedResultScopes = normalizedResultEvidenceScopes(input.resultEvidenceScopes);
+  const explicitResultScopes = successful
+    ? commandEvidenceScopes(toolName, input.toolArgs, providedResultScopes)
+    : [];
+  const verificationScopes = [...new Set([
+    ...(argumentScope ? [argumentScope] : []),
+    ...explicitResultScopes,
+  ])];
+  const verificationCall = verificationKinds.length > 0;
   if (verificationCall) {
     const callDigest = successfulToolCallDigest(turnId, toolCallId, toolName);
     if (!successfulToolCallDigests.includes(callDigest)) successfulToolCallDigests.push(callDigest);
     if (successfulToolCallDigests.length > MAX_SUCCESSFUL_TOOL_DIGESTS) successfulToolCallDigests.shift();
+    for (const kind of verificationKinds) {
+      const typedDigest = successfulVerificationCallDigest(turnId, toolCallId, toolName, kind);
+      if (!successfulVerificationCallDigests.includes(typedDigest)) {
+        successfulVerificationCallDigests.push(typedDigest);
+      }
+      if (successfulVerificationCallDigests.length > MAX_SUCCESSFUL_TOOL_DIGESTS) {
+        successfulVerificationCallDigests.shift();
+      }
+      for (const scope of verificationScopes) {
+        const scopeDigest = successfulVerificationScopeDigest(
+          turnId, toolCallId, toolName, kind, scope,
+        );
+        if (!successfulVerificationScopeDigests.includes(scopeDigest)) {
+          successfulVerificationScopeDigests.push(scopeDigest);
+        }
+        if (successfulVerificationScopeDigests.length > MAX_SUCCESSFUL_TOOL_DIGESTS) {
+          successfulVerificationScopeDigests.shift();
+        }
+      }
+    }
   }
   const digest = crypto.createHash('sha256').update([
     prior.digest, String(turnId), toolCallId, toolName, decision, outcome, String(durationMs),
-    String(verificationCall),
+    verificationKinds.join(','), verificationScopes.join(','),
   ].join('\0')).digest('hex').slice(0, 16);
   return Object.freeze({
     turnId,
@@ -374,6 +604,8 @@ function advanceActionEvidenceReceipt(current, input) {
     failedTools: prior.failedTools + (successful ? 0 : 1),
     successfulToolDigests: Object.freeze(successfulToolDigests),
     successfulToolCallDigests: Object.freeze(successfulToolCallDigests),
+    successfulVerificationCallDigests: Object.freeze(successfulVerificationCallDigests),
+    successfulVerificationScopeDigests: Object.freeze(successfulVerificationScopeDigests),
     digest,
   });
 }
@@ -490,10 +722,18 @@ function projectActionCheckpoint(checkpoint) {
     const subject = value.verificationProof.subject === undefined
       ? ''
       : ` [${value.verificationProof.subject}]`;
-    lines.push(`Verification proof${subject}: ${call} - ${value.verificationProof.claim}`);
+    const kind = value.verificationProof.kind === undefined
+      ? ''
+      : ` [${value.verificationProof.kind}]`;
+    const scope = value.verificationProof.scope === undefined
+      ? ''
+      : ` [scope: ${value.verificationProof.scope}]`;
+    lines.push(`Verification proof${subject}${kind}${scope}: ${call} - ${value.verificationProof.claim}`);
     if (value.verificationProof.sharpnessProof !== undefined) {
       const sharpness = value.verificationProof.sharpnessProof;
-      lines.push(`Sharpness proof: ${sharpness.toolName} call ${sharpness.toolCallId} - ${sharpness.claim}`);
+      const sharpnessKind = sharpness.kind === undefined ? '' : ` [${sharpness.kind}]`;
+      const sharpnessScope = sharpness.scope === undefined ? '' : ` [scope: ${sharpness.scope}]`;
+      lines.push(`Sharpness proof${sharpnessKind}${sharpnessScope}: ${sharpness.toolName} call ${sharpness.toolCallId} - ${sharpness.claim}`);
     }
   }
   if (value.nextTrigger !== undefined) {
@@ -534,5 +774,7 @@ module.exports = {
   normalizeVerificationProof,
   projectActionCheckpoint,
   successfulToolCallDigest,
+  successfulVerificationCallDigest,
   successfulToolDigest,
+  verificationKindsForToolCall,
 };

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

@@ -30,6 +30,14 @@ function verificationProofGaps(checkpoint) {
       .test(String(error?.message ?? ''))) {
       return ['The verifier sharpness proof does not match a successful current-turn verification call.'];
     }
+    if (/(?:verificationProof|sharpnessProof) kind must match the successful current-turn verification call/u
+      .test(String(error?.message ?? ''))) {
+      return ['The completion proof kind exceeds what its exact verification call measured.'];
+    }
+    if (/(?:verificationProof|sharpnessProof) scope must match the successful current-turn verification call target/u
+      .test(String(error?.message ?? ''))) {
+      return ['Bind the completion proof scope to the exact target measured by its successful current-turn verification call.'];
+    }
     if (/action-only tool/u.test(String(error?.message ?? ''))) {
       return ['The completion proof names an action-only tool, not a verification tool.'];
     }

package/blun.mjs

@@ -260352,10 +260352,14 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 			subject: _enum(["result", "verifier"]),
 			toolCallId: string().min(1).max(256),
 			toolName: string().min(1).max(128),
+			kind: _enum(["inspection", "integrity", "syntax", "test", "reachability"]),
+			scope: string().min(1).max(256),
 			claim: string().min(1).max(512),
 			sharpnessProof: object({
 				toolCallId: string().min(1).max(256),
 				toolName: string().min(1).max(128),
+				kind: _enum(["inspection", "integrity", "syntax", "test", "reachability"]),
+				scope: string().min(1).max(256),
 				claim: string().min(1).max(512)
 			}).strict().optional()
 		}).strict().superRefine((value, ctx) => {
@@ -261692,6 +261696,17 @@ function telemetryToolErrorType(result) {
 function toolResultText(result) {
 	return toolOutputText(result.output);
 }
+function explicitToolResultEvidenceKinds(result) {
+	const text = toolResultText(result);
+	return /(?:^|\s)BLUN_EVIDENCE_KIND=reachability(?:\s|$)/u.test(text) ? ["reachability"] : [];
+}
+function explicitToolResultEvidenceScopes(result) {
+	const text = toolResultText(result);
+	return [...text.matchAll(/(?:^|\s)BLUN_EVIDENCE_SCOPE=([A-Za-z0-9._:/\\-]{1,256})(?=\s|$)/gu)]
+		.map((match) => match[1])
+		.filter((scope, index, scopes) => scopes.indexOf(scope) === index)
+		.slice(0, 5);
+}
 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.`;
 }
@@ -262794,7 +262809,9 @@ var init_turn = __esmMin((() => {
 					toolName: started.name,
 					outcome,
 					durationMs: Date.now() - started.startedAt,
-					toolArgs: started.args
+					toolArgs: started.args,
+					resultEvidenceKinds: explicitToolResultEvidenceKinds(event.result),
+					resultEvidenceScopes: explicitToolResultEvidenceScopes(event.result)
 				});
 				this.agent.telemetry.track("tool_call", properties);
 				this.agent.feedRootMissionContract("result", {
@@ -262900,6 +262917,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 += "\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";
 }));
 //#endregion

package/package.json

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