blun-king-cli 9.1.304 → 9.1.306

package/bin/cognitive-state-store.cjs

@@ -235,7 +235,15 @@ function openCognitiveStateStore({ home } = {}) {
     return { valid: true, events: rows.length, head_hash: previousHash };
   }
 
-  return { commit, read, verify, close: () => db.close() };
+  return {
+    commit,
+    read,
+    verify,
+    close: () => {
+      try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch {}
+      db.close();
+    },
+  };
 }
 
 module.exports = { openCognitiveStateStore };

package/bin/cognitive-turn-lifecycle.cjs

@@ -0,0 +1,200 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const RIGHTS_AUTHORITIES = new Set(['runtime_user_prompt_hook', 'runtime_tool_policy']);
+const RIGHTS_DECISIONS = new Set(['passed', 'blocked', 'not_applicable']);
+const TOOL_POLICY_DECISIONS = new Set(['passed', 'blocked', 'error']);
+const TOOL_OUTCOMES = new Set(['success', 'error', 'cancelled']);
+const TURN_REASONS = new Set(['completed', 'cancelled', 'filtered', 'failed']);
+
+function fail(code) {
+  const error = new Error(code);
+  error.code = code;
+  throw error;
+}
+
+function exactKeys(value, keys) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every((key) => keys.has(key));
+}
+
+function safeId(value) {
+  const text = String(value ?? '').trim();
+  return SAFE_ID_RE.test(text) ? text : '';
+}
+
+function safeTurnId(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+
+function cleanLabel(value, max = 128) {
+  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  return text && text.length <= max ? text : '';
+}
+
+function digestId(prefix, values) {
+  const digest = crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40);
+  return `${prefix}-${digest}`;
+}
+
+function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now = () => new Date().toISOString() } = {}) {
+  const tenant = safeId(tenantId);
+  const agent = safeId(agentId);
+  const runtime = safeId(runtimeId ?? `runtime-${process.pid}-${Date.now()}`);
+  if (!tenant || !agent || !runtime || typeof now !== 'function') fail('COGNITIVE_LIFECYCLE_INVALID');
+  const store = openCognitiveStateStore({ home });
+  const stageTimes = new Map();
+  const stageResults = new Map();
+
+  function stageTime(stageKey) {
+    if (!stageTimes.has(stageKey)) {
+      const occurredAt = String(now());
+      if (Number.isNaN(Date.parse(occurredAt))) fail('COGNITIVE_LIFECYCLE_INVALID');
+      stageTimes.set(stageKey, occurredAt);
+    }
+    return stageTimes.get(stageKey);
+  }
+
+  function commitStage(stageKey, observations) {
+    if (stageResults.has(stageKey)) return { ...stageResults.get(stageKey), idempotent: true };
+    const occurredAt = stageTime(stageKey);
+    const eventId = digestId('cycle', [tenant, agent, runtime, stageKey]);
+    const normalized = observations.map((item, index) => ({
+      observation_id: digestId('cycleobs', [eventId, String(index)]),
+      ...item,
+    }));
+    for (let attempt = 0; attempt < 4; attempt += 1) {
+      const expectedVersion = store.read({ tenantId: tenant, agentId: agent }).version;
+      try {
+        const result = store.commit({
+          tenantId: tenant,
+          agentId: agent,
+          eventId,
+          expectedVersion,
+          occurredAt,
+          source: {
+            provider: 'runtime',
+            actor_id: agent,
+            context_id: runtime,
+            message_id: stageKey,
+          },
+          observations: normalized,
+        });
+        stageResults.set(stageKey, result);
+        return result;
+      } catch (error) {
+        if (error?.code !== 'COGNITIVE_VERSION_CONFLICT' || attempt === 3) throw error;
+      }
+    }
+    fail('COGNITIVE_VERSION_CONFLICT');
+  }
+
+  function startTurn(input) {
+    if (!exactKeys(input, new Set(['turnId', 'originKind']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    const originKind = safeId(input.originKind);
+    if (turnId === null || !originKind) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const key = `turn:${turnId}`;
+    return commitStage(`turn-${turnId}-start`, [
+      { domain: 'open_thread', key: `${key}:phase`, value: 'perceived', confidence: 1, scope: 'runtime' },
+      { domain: 'assumption', key: `${key}:classification`, value: `origin:${originKind}`, confidence: 1, scope: 'runtime' },
+      { domain: 'goal', key: `${key}:plan`, value: 'run-bounded-model-turn', confidence: 1, scope: 'runtime' },
+      { domain: 'next_trigger', key: `${key}:next`, value: 'runtime-policy-check', confidence: 1, scope: 'runtime' },
+      { domain: 'expected_evidence', key: `${key}:evidence`, value: 'turn.ended-event', confidence: 1, scope: 'runtime' },
+    ]);
+  }
+
+  function recordRightsCheck(input) {
+    if (!exactKeys(input, new Set(['turnId', 'decision', 'authority']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    const decision = String(input.decision ?? '');
+    const authority = String(input.authority ?? '');
+    if (turnId === null || !RIGHTS_DECISIONS.has(decision)) fail('COGNITIVE_LIFECYCLE_INVALID');
+    if (!RIGHTS_AUTHORITIES.has(authority)) fail('COGNITIVE_RIGHTS_AUTHORITY_REQUIRED');
+    return commitStage(`turn-${turnId}-rights-${authority}`, [{
+      domain: 'world',
+      key: `turn:${turnId}:rights-check`,
+      value: `${decision}:${authority}`,
+      confidence: 1,
+      scope: 'runtime',
+    }]);
+  }
+
+  function endTurn(input) {
+    if (!exactKeys(input, new Set(['turnId', 'reason', 'durationMs']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    const reason = String(input.reason ?? '');
+    const durationMs = Number(input.durationMs);
+    if (turnId === null || !TURN_REASONS.has(reason) || !Number.isSafeInteger(durationMs) || durationMs < 0) {
+      fail('COGNITIVE_LIFECYCLE_INVALID');
+    }
+    const key = `turn:${turnId}`;
+    return commitStage(`turn-${turnId}-end`, [
+      { domain: 'open_thread', key: `${key}:phase`, value: reason, confidence: 1, scope: 'runtime' },
+      { domain: 'expected_evidence', key: `${key}:result`, value: `turn.ended:${reason}:${durationMs}ms`, confidence: 1, scope: 'runtime' },
+      { domain: 'next_trigger', key: `${key}:next`, value: reason === 'completed' ? 'await-next-input' : 'inspect-turn-outcome', confidence: 1, scope: 'runtime' },
+    ]);
+  }
+
+  function toolFields(input, allowedKeys) {
+    if (!exactKeys(input, allowedKeys)) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    const toolCallId = cleanLabel(input.toolCallId, 256);
+    const toolName = cleanLabel(input.toolName, 128);
+    if (turnId === null || !toolCallId || !toolName) fail('COGNITIVE_LIFECYCLE_INVALID');
+    return { turnId, toolCallId, toolName, callKey: digestId('call', [toolCallId]).slice(0, 21) };
+  }
+
+  function recordToolPolicy(input) {
+    const { turnId, toolCallId, toolName, callKey } = toolFields(input, new Set(['turnId', 'toolCallId', 'toolName', 'decision']));
+    const decision = String(input.decision ?? '');
+    if (!TOOL_POLICY_DECISIONS.has(decision)) fail('COGNITIVE_LIFECYCLE_INVALID');
+    return commitStage(`turn-${turnId}-${callKey}-policy`, [{
+      domain: 'world',
+      key: `turn:${turnId}:${callKey}:tool-policy`,
+      value: `${decision}:runtime_tool_policy:${toolName}`,
+      confidence: 1,
+      scope: 'runtime',
+    }]);
+  }
+
+  function recordToolResult(input) {
+    const { turnId, toolCallId, toolName, callKey } = toolFields(input, new Set(['turnId', 'toolCallId', 'toolName', 'outcome', 'durationMs']));
+    const outcome = String(input.outcome ?? '');
+    const durationMs = Number(input.durationMs);
+    if (!TOOL_OUTCOMES.has(outcome) || !Number.isSafeInteger(durationMs) || durationMs < 0) fail('COGNITIVE_LIFECYCLE_INVALID');
+    return commitStage(`turn-${turnId}-${callKey}-result`, [
+      { domain: 'expected_evidence', key: `turn:${turnId}:${callKey}:tool-result`, value: `${outcome}:${durationMs}ms:${toolName}`, confidence: 1, scope: 'runtime' },
+      { domain: 'next_trigger', key: `turn:${turnId}:${callKey}:tool-next`, value: outcome === 'success' ? 'continue-after-tool' : 'inspect-tool-failure', confidence: 1, scope: 'runtime' },
+    ]);
+  }
+
+  return {
+    startTurn,
+    recordRightsCheck,
+    recordToolPolicy,
+    recordToolResult,
+    endTurn,
+    read: () => store.read({ tenantId: tenant, agentId: agent }),
+    verify: () => store.verify({ tenantId: tenant, agentId: agent }),
+    close: () => store.close(),
+  };
+}
+
+function createRuntimeCognitiveTurnLifecycle({ home, agentName, runtimeId, now } = {}) {
+  const resolvedHome = String(home ?? '').trim();
+  const resolvedAgent = String(agentName ?? '').trim();
+  if (!resolvedHome || !resolvedAgent) fail('COGNITIVE_LIFECYCLE_INVALID');
+  return createCognitiveTurnLifecycle({
+    home: resolvedHome,
+    tenantId: digestId('home', [resolvedHome.toLowerCase()]),
+    agentId: digestId('agent', [resolvedAgent.toLowerCase()]),
+    runtimeId,
+    now,
+  });
+}
+
+module.exports = { createCognitiveTurnLifecycle, createRuntimeCognitiveTurnLifecycle };

package/blun.mjs

@@ -261391,7 +261391,7 @@ function toolResultText(result) {
 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.`;
 }
-var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaGenerationToolNamesForText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
+var BLUN_CORE_TOOL_NAMES, BLUN_LEAN_TOOL_NAMES, BLUN_ATTACHMENT_MARKER_RE, BLUN_TELEGRAM_OUTBOUND_TOOL_RE, BLUN_TELEGRAM_CHANNEL_RE, BLUN_TOOL_BUDGET_RATIO, createDeferredToolLoader, mediaGenerationToolNamesForText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens, projectRecurringCronHistory, TelegramDeliveryLedger, createRuntimeCognitiveTurnLifecycle, LLM_NOT_SET_MESSAGE, GOAL_CONTINUATION_ORIGIN, GOAL_COMPLETION_REMINDER_NAME, GOAL_BLOCKED_REMINDER_NAME, GOAL_RATE_LIMIT_PAUSE_REASON, GOAL_PROVIDER_CONNECTION_PAUSE_PREFIX, GOAL_PROVIDER_AUTH_PAUSE_PREFIX, GOAL_PROVIDER_API_PAUSE_PREFIX, GOAL_MODEL_CONFIG_PAUSE_PREFIX, GOAL_RUNTIME_PAUSE_PREFIX, GOAL_PROVIDER_FILTERED_PAUSE_REASON, GOAL_CONTINUATION_PROMPT, TurnFlow;
 var init_turn = __esmMin((() => {
 	init_dist$4();
 	init_src$4();
@@ -261411,6 +261411,7 @@ var init_turn = __esmMin((() => {
 	({ CORE_TOOL_NAMES: BLUN_CORE_TOOL_NAMES, createDeferredToolLoader, mediaGenerationToolNamesForText, rememberDeferredToolAfterNotFound, toolSchemaBudgetTokens } = createRequire(import.meta.url)("./bin/turn-tool-performance-policy.cjs"));
 	({ projectRecurringCronHistory } = createRequire(import.meta.url)("./bin/recurring-cron-history-policy.cjs"));
 	({ TelegramDeliveryLedger } = createRequire(import.meta.url)("./bin/repeated-user-message-projection.cjs"));
+	({ createRuntimeCognitiveTurnLifecycle } = createRequire(import.meta.url)("./bin/cognitive-turn-lifecycle.cjs"));
 	BLUN_LEAN_TOOL_NAMES = new Set(BLUN_CORE_TOOL_NAMES);
 	BLUN_ATTACHMENT_MARKER_RE = /\b(?:attachment_file_id|telegram-anhang|telegram attachment)\b/i;
 	BLUN_TELEGRAM_OUTBOUND_TOOL_RE = /^mcp__[^\s]*telegram[^\s]*__(?:reply|react|edit_message)$/i;
@@ -261471,6 +261472,8 @@ var init_turn = __esmMin((() => {
 		interruptedTelemetryTurnIds = /* @__PURE__ */ new Set();
 		stepFailureByTurn = /* @__PURE__ */ new Map();
 		currentStep = 0;
+		cognitiveLifecycle;
+		cognitiveLifecycleUnavailable = false;
 		constructor(agent) {
 			this.agent = agent;
 		}
@@ -261478,6 +261481,33 @@ var init_turn = __esmMin((() => {
 		get agentId() {
 			return this.agent.homedir ? basename$2(this.agent.homedir) : this.agent.type;
 		}
+		getCognitiveLifecycle() {
+			if (this.cognitiveLifecycleUnavailable) return null;
+			if (this.cognitiveLifecycle !== void 0) return this.cognitiveLifecycle;
+			const home = this.agent.blunHomeDir ?? this.agent.homedir;
+			if (home === void 0) {
+				this.cognitiveLifecycleUnavailable = true;
+				return null;
+			}
+			try {
+				this.cognitiveLifecycle = createRuntimeCognitiveTurnLifecycle({
+					home,
+					agentName: this.agent.activeProfile?.name ?? this.agent.type
+				});
+				return this.cognitiveLifecycle;
+			} catch (error) {
+				this.cognitiveLifecycleUnavailable = true;
+				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: "open", error_type: error?.code ?? error?.name ?? "Error" });
+				return null;
+			}
+		}
+		recordCognitiveStage(method, input) {
+			try {
+				this.getCognitiveLifecycle()?.[method](input);
+			} catch (error) {
+				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: method, error_type: error?.code ?? error?.name ?? "Error" });
+			}
+		}
 		prompt(input, origin = USER_PROMPT_ORIGIN) {
 			return this.promptWithAcceptance(input, origin).turnId;
 		}
@@ -261805,6 +261835,12 @@ var init_turn = __esmMin((() => {
 				origin
 			});
 			this.agent.context.appendUserMessage(input, origin);
+			this.recordCognitiveStage("startTurn", { turnId, originKind: origin.kind });
+			this.recordCognitiveStage("recordRightsCheck", {
+				turnId,
+				decision: "not_applicable",
+				authority: "runtime_user_prompt_hook"
+			});
 			const ended = {
 				type: "turn.ended",
 				turnId,
@@ -261812,6 +261848,7 @@ var init_turn = __esmMin((() => {
 				durationMs: Date.now() - startedAt
 			};
 			this.agent.usage.endTurn();
+			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			return ended;
 		}
@@ -261841,6 +261878,7 @@ var init_turn = __esmMin((() => {
 				origin
 			});
 			this.agent.context.appendUserMessage(input, origin);
+			this.recordCognitiveStage("startTurn", { turnId, originKind: origin.kind });
 			const startedAt = Date.now();
 			let ended;
 			let blockedByUserPromptHook = false;
@@ -261848,6 +261886,11 @@ var init_turn = __esmMin((() => {
 			let errorEvent;
 			try {
 				const promptHookEnded = await this.applyUserPromptHook(turnId, input, origin, signal, startedAt);
+				this.recordCognitiveStage("recordRightsCheck", {
+					turnId,
+					decision: origin.kind !== "user" ? "not_applicable" : promptHookEnded?.blocked === true ? "blocked" : "passed",
+					authority: "runtime_user_prompt_hook"
+				});
 				if (promptHookEnded !== void 0) {
 					ended = promptHookEnded.event;
 					blockedByUserPromptHook = promptHookEnded.blocked;
@@ -261919,6 +261962,7 @@ var init_turn = __esmMin((() => {
 				mode: this.telemetryModeByTurn.get(turnId) ?? this.telemetryMode(),
 				...this.requestProviderProps()
 			});
+			this.recordCognitiveStage("endTurn", { turnId, reason: ended.reason, durationMs: ended.durationMs ?? 0 });
 			this.agent.emitEvent(ended);
 			this.agent.endResponderTurn();
 			if (standalone && this.currentId === turnId && this.agent.goal.getGoal().goal?.status !== "active") this.activeTurn = null;
@@ -262170,7 +262214,24 @@ var init_turn = __esmMin((() => {
 								if (cached !== null) return { syntheticResult: cached };
 							},
 							authorizeToolExecution: async (ctx) => {
-								return this.agent.permission.beforeToolCall(ctx);
+								try {
+									const resolution = await this.agent.permission.beforeToolCall(ctx);
+									this.recordCognitiveStage("recordToolPolicy", {
+										turnId,
+										toolCallId: ctx.toolCall.id,
+										toolName: ctx.toolCall.name,
+										decision: resolution?.block === true ? "blocked" : "passed"
+									});
+									return resolution;
+								} catch (error) {
+									this.recordCognitiveStage("recordToolPolicy", {
+										turnId,
+										toolCallId: ctx.toolCall.id,
+										toolName: ctx.toolCall.name,
+										decision: "error"
+									});
+									throw error;
+								}
 							},
 							finalizeToolResult: async (ctx) => {
 								const finalResult = await deduper.finalizeResult(ctx.toolCall.id, ctx.toolCall.name, ctx.args, ctx.result);
@@ -262312,6 +262373,13 @@ var init_turn = __esmMin((() => {
 				};
 				const errorType = outcome === "error" ? telemetryToolErrorType(event.result) : void 0;
 				if (errorType !== void 0) properties["error_type"] = errorType;
+				this.recordCognitiveStage("recordToolResult", {
+					turnId,
+					toolCallId: event.toolCallId,
+					toolName: started.name,
+					outcome,
+					durationMs: Date.now() - started.startedAt
+				});
 				this.agent.telemetry.track("tool_call", properties);
 				this.agent.feedRootMissionContract("result", {
 					toolCallId: event.toolCallId,

package/package.json

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