blun-king-cli 9.1.449 → 9.1.450

package/bin/cognitive-action-checkpoint.cjs

@@ -12,6 +12,7 @@ const EPISTEMIC_STATES = new Set([
 const TRIGGER_KINDS = new Set([
   'immediate', 'external_event', 'time', 'dependency', 'user_decision',
 ]);
+const VERIFICATION_SUBJECTS = new Set(['result', 'verifier']);
 const MODEL_KEYS = new Set([
   'revision', 'phase', 'evidenceBasis', 'epistemicState', 'lastVerified', 'nextAction', 'expectedEvidence', 'verificationProof', 'nextTrigger', 'problemFrame', 'updatedAt',
 ]);
@@ -210,39 +211,85 @@ function normalizeSuccessfulToolDigests(value) {
   return Object.freeze([...value]);
 }
 
+function normalizeExactVerificationCall(input, receipt, label) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)
+      || Object.keys(input).length !== 3
+      || !Object.hasOwn(input, 'toolCallId')
+      || !Object.hasOwn(input, 'toolName')
+      || !Object.hasOwn(input, 'claim')) {
+    throw new TypeError(`${label} fields are invalid`);
+  }
+  const toolCallId = bounded(input.toolCallId, `${label} toolCallId`, 256);
+  const toolName = bounded(input.toolName, `${label} toolName`, 128);
+  const claim = bounded(input.claim, `${label} claim`);
+  if (isActionOnlyTool(toolName)) {
+    const purpose = label === 'verificationProof' ? 'verification proof' : label;
+    throw new TypeError(`action-only tool cannot serve as ${purpose}`);
+  }
+  const callDigest = successfulToolCallDigest(receipt.turnId, toolCallId, toolName);
+  if (!receipt.successfulToolCallDigests.includes(callDigest)) {
+    throw new TypeError(`${label} must match a successful current-turn verification call`);
+  }
+  return Object.freeze({ toolCallId, toolName, claim });
+}
+
 function normalizeVerificationProof(input, evidenceReceipt, options = {}) {
   const keys = input && typeof input === 'object' && !Array.isArray(input)
     ? Object.keys(input)
     : [];
-  const legacy = options.allowLegacy === true
+  const legacyName = options.allowLegacy === true
     && keys.length === 2
     && Object.hasOwn(input, 'toolName')
     && Object.hasOwn(input, 'claim');
-  const current = keys.length === 3
+  const legacyExact = options.allowLegacy === true
+    && keys.length === 3
+    && Object.hasOwn(input, 'toolCallId')
+    && Object.hasOwn(input, 'toolName')
+    && Object.hasOwn(input, 'claim');
+  const subject = String(input?.subject ?? '').trim();
+  const currentResult = subject === 'result'
+    && keys.length === 4
     && Object.hasOwn(input, 'toolCallId')
     && Object.hasOwn(input, 'toolName')
     && Object.hasOwn(input, 'claim');
-  if (!legacy && !current) {
+  const currentVerifier = 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) {
     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 (legacy) {
+  if (legacyName) {
+    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');
+    }
     if (!receipt.successfulToolDigests.includes(successfulToolDigest(toolName))) {
       throw new TypeError('verificationProof must name a successful current-turn tool');
     }
     return Object.freeze({ toolName, claim });
   }
-  const toolCallId = bounded(input.toolCallId, 'verificationProof toolCallId', 256);
-  const callDigest = successfulToolCallDigest(receipt.turnId, toolCallId, toolName);
-  if (!receipt.successfulToolCallDigests.includes(callDigest)) {
-    throw new TypeError('verificationProof must match a successful current-turn verification call');
-  }
-  return Object.freeze({ toolCallId, toolName, claim });
+  const primary = normalizeExactVerificationCall(legacyExact ? input : {
+    toolCallId: input.toolCallId,
+    toolName: input.toolName,
+    claim: input.claim,
+  }, receipt, 'verificationProof');
+  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');
+  if (sharpnessProof.toolCallId === primary.toolCallId
+      && sharpnessProof.toolName === primary.toolName) {
+    throw new TypeError('sharpnessProof must name a distinct verification call');
+  }
+  return Object.freeze({ subject, ...primary, sharpnessProof });
 }
 
 function emptyActionEvidenceReceipt(turnId) {
@@ -440,7 +487,14 @@ function projectActionCheckpoint(checkpoint) {
     const call = value.verificationProof.toolCallId === undefined
       ? value.verificationProof.toolName
       : `${value.verificationProof.toolName} call ${value.verificationProof.toolCallId}`;
-    lines.push(`Verification proof: ${call} - ${value.verificationProof.claim}`);
+    const subject = value.verificationProof.subject === undefined
+      ? ''
+      : ` [${value.verificationProof.subject}]`;
+    lines.push(`Verification proof${subject}: ${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}`);
+    }
   }
   if (value.nextTrigger !== undefined) {
     lines.push(`Next trigger: ${value.nextTrigger.kind.replaceAll('_', ' ')} - ${value.nextTrigger.condition}`);

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

@@ -22,6 +22,14 @@ function verificationProofGaps(checkpoint) {
     normalizeVerificationProof(checkpoint.verificationProof, checkpoint.evidenceReceipt, { allowLegacy: true });
     return [];
   } catch (error) {
+    if (/verifier proof requires a sharpnessProof|sharpnessProof must name a distinct verification call/u
+      .test(String(error?.message ?? ''))) {
+      return ['A verifier completion needs a distinct current-turn counterexample or mutation call.'];
+    }
+    if (/sharpnessProof must match a successful current-turn verification call/u
+      .test(String(error?.message ?? ''))) {
+      return ['The verifier sharpness proof does not match a 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

@@ -260349,10 +260349,34 @@ function createActionCheckpointInputSchema(problemFrameSchema, requireProblemFra
 		nextAction: string().min(1).max(512),
 		expectedEvidence: string().min(1).max(512),
 		verificationProof: object({
+			subject: _enum(["result", "verifier"]),
 			toolCallId: string().min(1).max(256),
 			toolName: string().min(1).max(128),
-			claim: string().min(1).max(512)
-		}).strict().optional(),
+			claim: string().min(1).max(512),
+			sharpnessProof: object({
+				toolCallId: string().min(1).max(256),
+				toolName: string().min(1).max(128),
+				claim: string().min(1).max(512)
+			}).strict().optional()
+		}).strict().superRefine((value, ctx) => {
+			if (value.subject === "verifier" && value.sharpnessProof === void 0) ctx.addIssue({
+				code: "custom",
+				path: ["sharpnessProof"],
+				message: "verifier subject requires sharpnessProof"
+			});
+			if (value.subject === "result" && value.sharpnessProof !== void 0) ctx.addIssue({
+				code: "custom",
+				path: ["sharpnessProof"],
+				message: "result subject cannot carry sharpnessProof"
+			});
+			if (value.sharpnessProof !== void 0
+				&& value.sharpnessProof.toolCallId === value.toolCallId
+				&& value.sharpnessProof.toolName === value.toolName) ctx.addIssue({
+				code: "custom",
+				path: ["sharpnessProof"],
+				message: "sharpnessProof must name a distinct verification call"
+			});
+		}).optional(),
 		nextTrigger: object({
 			kind: _enum(["immediate", "external_event", "time", "dependency", "user_decision"]),
 			condition: string().min(1).max(512),
@@ -262875,7 +262899,7 @@ 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 += "\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. Run a separate observation, test, or counterexample probe and cite that exact successful call plus the claim it supports.\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 += "\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.449",
+  "version": "9.1.450",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {