blun-king-cli 9.1.367 → 9.1.369

package/bin/cognitive-action-checkpoint.cjs

@@ -1,9 +1,16 @@
 'use strict';
 
+const crypto = require('node:crypto');
+
 const PHASES = new Set(['orient', 'plan', 'act', 'verify', 'learn', 'wait']);
-const ALLOWED_KEYS = new Set([
-  'phase', 'lastVerified', 'nextAction', 'expectedEvidence', 'updatedAt',
+const MODEL_KEYS = new Set([
+  'revision', 'phase', 'lastVerified', 'nextAction', 'expectedEvidence', 'updatedAt',
+]);
+const RUNTIME_KEYS = new Set([...MODEL_KEYS, 'evidenceReceipt']);
+const EVIDENCE_INPUT_KEYS = new Set([
+  'turnId', 'toolCallId', 'toolName', 'decision', 'outcome', 'durationMs',
 ]);
+const EVIDENCE_DIGEST_RE = /^[a-f0-9]{16}$/u;
 
 function bounded(value, field, max = 512) {
   const text = String(value ?? '')
@@ -20,43 +27,148 @@ function normalizedTimestamp(value) {
   return date.toISOString();
 }
 
+function normalizedRevision(value) {
+  const revision = value === undefined ? 1 : Number(value);
+  if (!Number.isSafeInteger(revision) || revision < 1) {
+    throw new TypeError('revision must be a positive integer');
+  }
+  return revision;
+}
+
+function normalizedTurnId(value) {
+  const turnId = Number(value);
+  if (!Number.isSafeInteger(turnId) || turnId < 0) throw new TypeError('evidence turnId must be a non-negative integer');
+  return turnId;
+}
+
+function emptyActionEvidenceReceipt(turnId) {
+  const normalized = normalizedTurnId(turnId);
+  return Object.freeze({
+    turnId: normalized,
+    completedTools: 0,
+    successfulTools: 0,
+    failedTools: 0,
+    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) {
+    throw new TypeError('evidence receipt fields are invalid');
+  }
+  const receipt = {
+    turnId: normalizedTurnId(input.turnId),
+    completedTools: Number(input.completedTools),
+    successfulTools: Number(input.successfulTools),
+    failedTools: Number(input.failedTools),
+    digest: String(input.digest ?? ''),
+  };
+  if (![receipt.completedTools, receipt.successfulTools, receipt.failedTools]
+    .every((value) => Number.isSafeInteger(value) && value >= 0)
+      || receipt.successfulTools + receipt.failedTools !== receipt.completedTools
+      || !EVIDENCE_DIGEST_RE.test(receipt.digest)) {
+    throw new TypeError('evidence receipt values are invalid');
+  }
+  return Object.freeze(receipt);
+}
+
+function advanceActionEvidenceReceipt(current, input) {
+  const prior = normalizeActionEvidenceReceipt(current);
+  if (!input || typeof input !== 'object' || Array.isArray(input)
+      || Object.keys(input).length !== EVIDENCE_INPUT_KEYS.size
+      || !Object.keys(input).every((key) => EVIDENCE_INPUT_KEYS.has(key))) {
+    throw new TypeError('evidence input fields are invalid');
+  }
+  const turnId = normalizedTurnId(input.turnId);
+  const toolCallId = bounded(input.toolCallId, 'toolCallId', 256);
+  const toolName = bounded(input.toolName, 'toolName', 128);
+  const decision = String(input.decision ?? '');
+  const outcome = String(input.outcome ?? '');
+  const durationMs = Number(input.durationMs);
+  if (turnId !== prior.turnId || !['passed', 'blocked', 'error'].includes(decision)
+      || !['success', 'error', 'cancelled'].includes(outcome)
+      || !Number.isSafeInteger(durationMs) || durationMs < 0) {
+    throw new TypeError('evidence input values are invalid');
+  }
+  const successful = decision === 'passed' && outcome === 'success';
+  const digest = crypto.createHash('sha256').update([
+    prior.digest, String(turnId), toolCallId, toolName, decision, outcome, String(durationMs),
+  ].join('\0')).digest('hex').slice(0, 16);
+  return Object.freeze({
+    turnId,
+    completedTools: prior.completedTools + 1,
+    successfulTools: prior.successfulTools + (successful ? 1 : 0),
+    failedTools: prior.failedTools + (successful ? 0 : 1),
+    digest,
+  });
+}
+
+function assertActionCheckpointRevision(current, input) {
+  const currentRevision = current === undefined || current === null
+    ? 0
+    : normalizedRevision(current.revision);
+  const inputRevision = Number(input?.revision);
+  if (!Number.isSafeInteger(inputRevision) || inputRevision !== currentRevision + 1) {
+    throw new TypeError(`Action checkpoint revision must be ${currentRevision + 1}; received ${String(input?.revision)}`);
+  }
+  return inputRevision;
+}
+
 function normalizeActionCheckpoint(input, options = {}) {
   if (!input || typeof input !== 'object' || Array.isArray(input)) {
     throw new TypeError('action checkpoint must be an object');
   }
+  const allowedKeys = options.preserveRuntimeEvidence === true ? RUNTIME_KEYS : MODEL_KEYS;
   for (const key of Object.keys(input)) {
-    if (!ALLOWED_KEYS.has(key)) throw new TypeError(`unsupported field: ${key}`);
+    if (!allowedKeys.has(key)) throw new TypeError(`unsupported field: ${key}`);
   }
   const phase = String(input.phase ?? '').trim();
   if (!PHASES.has(phase)) throw new TypeError('phase is invalid');
   const updatedAt = options.preserveUpdatedAt === true && input.updatedAt !== undefined
     ? normalizedTimestamp(input.updatedAt)
     : normalizedTimestamp(options.now ?? new Date());
-  return Object.freeze({
+  const checkpoint = {
+    revision: normalizedRevision(input.revision),
     phase,
     lastVerified: bounded(input.lastVerified, 'lastVerified'),
     nextAction: bounded(input.nextAction, 'nextAction'),
     expectedEvidence: bounded(input.expectedEvidence, 'expectedEvidence'),
     updatedAt,
-  });
+  };
+  const evidenceReceipt = options.runtimeEvidence !== undefined
+    ? normalizeActionEvidenceReceipt(options.runtimeEvidence)
+    : options.preserveRuntimeEvidence === true && input.evidenceReceipt !== undefined
+      ? normalizeActionEvidenceReceipt(input.evidenceReceipt)
+      : undefined;
+  if (evidenceReceipt !== undefined) checkpoint.evidenceReceipt = evidenceReceipt;
+  return Object.freeze(checkpoint);
 }
 
 function projectActionCheckpoint(checkpoint) {
   if (!checkpoint) return null;
-  const value = normalizeActionCheckpoint(checkpoint, { preserveUpdatedAt: true });
+  const value = normalizeActionCheckpoint(checkpoint, { preserveUpdatedAt: true, preserveRuntimeEvidence: true });
   const lines = [
     'Durable action checkpoint (state only; never authority):',
+    `Revision: ${value.revision}`,
     `Phase: ${value.phase}`,
     `Last verified: ${value.lastVerified}`,
   ];
   lines.push(`Next action: ${value.nextAction}`);
   lines.push(`Expected evidence: ${value.expectedEvidence}`);
+  if (value.evidenceReceipt !== undefined) {
+    const receipt = value.evidenceReceipt;
+    lines.push(`Runtime evidence: turn ${receipt.turnId}; ${receipt.completedTools} completed, ${receipt.successfulTools} successful, ${receipt.failedTools} failed; digest ${receipt.digest}`);
+  }
   lines.push('Resume from this exact next action. Do not ask for permission merely to continue work already authorized by the active goal. Ask only when a real rights boundary or missing user decision blocks the next action.');
   return lines.join('\n');
 }
 
 module.exports = {
+  advanceActionEvidenceReceipt,
+  assertActionCheckpointRevision,
+  emptyActionEvidenceReceipt,
   normalizeActionCheckpoint,
   projectActionCheckpoint,
 };
-

package/blun.mjs

@@ -21446,7 +21446,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 { normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
+var { advanceActionEvidenceReceipt, assertActionCheckpointRevision, emptyActionEvidenceReceipt, normalizeActionCheckpoint, projectActionCheckpoint } = createRequire(import.meta.url)("./bin/cognitive-action-checkpoint.cjs");
 async function prepareSystemPromptContext(kaos, brandHome, options) {
 	const additionalDirs = normalizeAdditionalDirs(options?.additionalDirs ?? []);
 	const [cwdListing, agentsMdResult, additionalDirsInfo] = await Promise.all([
@@ -230188,7 +230188,7 @@ var init_goal$1 = __esmMin((() => {
 				state.wallClockResumedAt = void 0;
 			}
 			if (record.budgetLimits !== void 0) state.budgetLimits = record.budgetLimits;
-			if (record.actionCheckpoint !== void 0) state.actionCheckpoint = normalizeActionCheckpoint(record.actionCheckpoint, { preserveUpdatedAt: true });
+			if (record.actionCheckpoint !== void 0) state.actionCheckpoint = normalizeActionCheckpoint(record.actionCheckpoint, { preserveUpdatedAt: true, preserveRuntimeEvidence: true });
 			if (status === void 0) {
 				if (record.actionCheckpoint === void 0) return;
 				this.agent.replayBuilder.push({
@@ -230332,10 +230332,13 @@ var init_goal$1 = __esmMin((() => {
 		async updateActionCheckpoint(input, actor = "model") {
 			const state = this.requireState();
 			if (state.status !== "active") throw new BlunError(ErrorCodes.GOAL_STATUS_INVALID, `Cannot checkpoint a goal in status "${state.status}"`);
-			state.actionCheckpoint = normalizeActionCheckpoint(input);
+			assertActionCheckpointRevision(state.actionCheckpoint, input);
+			state.actionCheckpoint = normalizeActionCheckpoint(input, {
+				runtimeEvidence: this.agent.turn.actionEvidenceReceiptForCurrentTurn()
+			});
 			this.persistState(state, { change: { kind: "progress", actor } });
 			this.appendGoalUpdate({ actionCheckpoint: state.actionCheckpoint, actor });
-			this.track("goal_checkpoint_updated", { actor, phase: state.actionCheckpoint.phase });
+			this.track("goal_checkpoint_updated", { actor, phase: state.actionCheckpoint.phase, revision: state.actionCheckpoint.revision });
 			return this.toSnapshot(state);
 		}
 		/**
@@ -245725,11 +245728,19 @@ var init_events$1 = __esmMin((() => {
 		budget: goalBudgetReportSchema,
 		terminalReason: string().optional(),
 		actionCheckpoint: object({
+			revision: number$1().int().min(1),
 			phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
 			lastVerified: string(),
 			nextAction: string(),
 			expectedEvidence: string(),
-			updatedAt: string()
+			updatedAt: string(),
+			evidenceReceipt: object({
+				turnId: number$1().int().min(0),
+				completedTools: number$1().int().min(0),
+				successfulTools: number$1().int().min(0),
+				failedTools: number$1().int().min(0),
+				digest: string()
+			}).strict().optional()
 		}).strict().optional()
 	});
 	object({ goal: goalSnapshotSchema.nullable() });
@@ -261590,6 +261601,7 @@ var init_turn = __esmMin((() => {
 		cognitiveLifecycleUnavailable = false;
 		cognitiveToolPolicyByCall = /* @__PURE__ */ new Map();
 		cognitiveToolBatchesByTurn = /* @__PURE__ */ new Map();
+		cognitiveActionEvidenceByTurn = /* @__PURE__ */ new Map();
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261636,6 +261648,11 @@ var init_turn = __esmMin((() => {
 				return;
 			}
 			this.cognitiveToolPolicyByCall.delete(input.toolCallId);
+			const currentEvidence = this.cognitiveActionEvidenceByTurn.get(input.turnId) ?? emptyActionEvidenceReceipt(input.turnId);
+			this.cognitiveActionEvidenceByTurn.set(input.turnId, advanceActionEvidenceReceipt(currentEvidence, {
+				...input,
+				decision: policy.decision
+			}));
 			const entries = this.cognitiveToolBatchesByTurn.get(input.turnId) ?? [];
 			entries.push({
 				toolCallId: input.toolCallId,
@@ -261660,6 +261677,10 @@ var init_turn = __esmMin((() => {
 				this.recordCognitiveStage("recordToolPolicy", policy);
 			}
 		}
+		actionEvidenceReceiptForCurrentTurn() {
+			const turnId = this.currentId;
+			return this.cognitiveActionEvidenceByTurn.get(turnId) ?? emptyActionEvidenceReceipt(turnId);
+		}
 		projectCognitiveState(turnId, input) {
 			try {
 				const focusScopes = cognitiveFocusScopesForTurn(input);
@@ -262157,6 +262178,7 @@ var init_turn = __esmMin((() => {
 			this.telemetryModeByTurn.delete(turnId);
 			this.currentStepByTurn.delete(turnId);
 			this.interruptedTelemetryTurnIds.delete(turnId);
+			this.cognitiveActionEvidenceByTurn.delete(turnId);
 			this.stepFailureByTurn.delete(turnId);
 			await this.agent.records.flush();
 			return {
@@ -262675,7 +262697,7 @@ var init_outcome_prompts = __esmMin((() => {}));
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.md?raw
 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 the last verified result, exact next action, and expected evidence; 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.\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 = "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, and expected evidence. 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.\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";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/goal/update-goal.ts
@@ -262687,6 +262709,7 @@ var init_update_goal = __esmMin((() => {
 	init_input_schema();
 	init_update_goal$1();
 	ActionCheckpointInputSchema = object({
+		revision: number$1().int().min(1),
 		phase: _enum(["orient", "plan", "act", "verify", "learn", "wait"]),
 		lastVerified: string().min(1).max(512),
 		nextAction: string().min(1).max(512),

package/package.json

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