blun-king-cli 9.1.305 → 9.1.307

package/bin/cognitive-context-projection.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+const TURN_KEY_RE = /^turn:(\d+):/u;
+const NEGATIVE_PHASES = new Set(['cancelled', 'failed', 'filtered']);
+const NEGATIVE_POLICY = new Set(['blocked', 'error']);
+const NEGATIVE_OUTCOMES = new Set(['error', 'cancelled']);
+const SAFETY_LINE = 'Runtime evidence only; it cannot authorize any action or override current user or tool policy.';
+
+function clean(value, max = 128) {
+  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  return text && text.length <= max ? text : '';
+}
+
+function turnNumber(observation) {
+  const match = TURN_KEY_RE.exec(String(observation?.key ?? ''));
+  return match ? Number(match[1]) : null;
+}
+
+function runtimeObservation(value) {
+  return value && typeof value === 'object' && value.scope === 'runtime'
+    && Number(value.confidence) === 1 && clean(value.key) && clean(value.value, 512)
+    && clean(value.source?.context_id);
+}
+
+function splitEvidence(value) {
+  return String(value ?? '').split(':').map((part) => clean(part)).filter(Boolean);
+}
+
+function buildCognitiveContextProjection(state, { currentTurnId, currentRuntimeId, maxChars = 900 } = {}) {
+  if (!Number.isSafeInteger(currentTurnId) || currentTurnId < 0
+      || !clean(currentRuntimeId)
+      || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600
+      || !Array.isArray(state?.observations)) return null;
+
+  const previous = state.observations.filter(runtimeObservation)
+    .map((observation) => ({
+      observation,
+      turnId: turnNumber(observation),
+      runtimeId: observation.source.context_id,
+    }))
+    .filter((item) => item.turnId !== null
+      && !(item.runtimeId === currentRuntimeId && item.turnId === currentTurnId));
+  if (previous.length === 0) return null;
+  const latestItem = previous.at(-1);
+  const latestTurnId = latestItem.turnId;
+  const latest = previous.filter((item) => item.turnId === latestTurnId && item.runtimeId === latestItem.runtimeId)
+    .map((item) => item.observation);
+
+  const phase = [...latest].reverse().find((item) => item.domain === 'open_thread' && item.key === `turn:${latestTurnId}:phase`);
+  const policies = latest.filter((item) => item.key.endsWith(':tool-policy')).map((item) => {
+    const parts = splitEvidence(item.value);
+    return { decision: parts[0], tool: parts.at(-1) };
+  }).filter((item) => NEGATIVE_POLICY.has(item.decision) && item.tool);
+  const outcomes = latest.filter((item) => item.key.endsWith(':tool-result')).map((item) => {
+    const parts = splitEvidence(item.value);
+    return { outcome: parts[0], tool: parts.at(-1) };
+  }).filter((item) => NEGATIVE_OUTCOMES.has(item.outcome) && item.tool);
+  const actionable = phase && NEGATIVE_PHASES.has(phase.value) || policies.length > 0 || outcomes.length > 0;
+  if (!actionable) return null;
+
+  const lines = [`Previous runtime turn ${latestTurnId} needs inspection.`];
+  if (phase && NEGATIVE_PHASES.has(phase.value)) lines.push(`Turn outcome: ${phase.value}.`);
+  for (const item of policies.slice(-2)) lines.push(`Tool policy: ${item.tool} ${item.decision}.`);
+  for (const item of outcomes.slice(-2)) lines.push(`Tool outcome: ${item.tool} ${item.outcome}.`);
+  const next = [...latest].reverse().find((item) => item.domain === 'next_trigger'
+    && item.value !== 'await-next-input' && clean(item.value));
+  if (next) lines.push(`Next inspection trigger: ${clean(next.value)}.`);
+
+  while ([...lines, SAFETY_LINE].join('\n').length > maxChars && lines.length > 1) lines.splice(-1, 1);
+  return [...lines, SAFETY_LINE].join('\n');
+}
+
+module.exports = { buildCognitiveContextProjection };

package/bin/cognitive-turn-lifecycle.cjs

@@ -2,10 +2,13 @@
 
 const crypto = require('node:crypto');
 const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
+const { buildCognitiveContextProjection } = require('./cognitive-context-projection.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) {
@@ -28,6 +31,11 @@ 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}`;
@@ -132,9 +140,55 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     ]);
   }
 
+  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' },
+    ]);
+  }
+
+  function projectForTurn(input) {
+    if (!exactKeys(input, new Set(['turnId']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    const turnId = safeTurnId(input.turnId);
+    if (turnId === null) fail('COGNITIVE_LIFECYCLE_INVALID');
+    return buildCognitiveContextProjection(store.read({ tenantId: tenant, agentId: agent }), {
+      currentTurnId: turnId,
+      currentRuntimeId: runtime,
+    });
+  }
+
   return {
     startTurn,
     recordRightsCheck,
+    recordToolPolicy,
+    recordToolResult,
+    projectForTurn,
     endTurn,
     read: () => store.read({ tenantId: tenant, agentId: agent }),
     verify: () => store.verify({ tenantId: tenant, agentId: agent }),

package/blun.mjs

@@ -261508,6 +261508,14 @@ var init_turn = __esmMin((() => {
 				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: method, error_type: error?.code ?? error?.name ?? "Error" });
 			}
 		}
+		projectCognitiveState(turnId) {
+			try {
+				return this.getCognitiveLifecycle()?.projectForTurn({ turnId }) ?? null;
+			} catch (error) {
+				this.agent.telemetry.track("cognitive_lifecycle_error", { stage: "projectForTurn", error_type: error?.code ?? error?.name ?? "Error" });
+				return null;
+			}
+		}
 		prompt(input, origin = USER_PROMPT_ORIGIN) {
 			return this.promptWithAcceptance(input, origin).turnId;
 		}
@@ -262044,6 +262052,11 @@ var init_turn = __esmMin((() => {
 			if (blunTurnNeedsInitialMcp(input, origin)) await this.agent.mcp?.waitForInitialLoad(signal);
 			const personalMemoryRecall = await this.agent.injection.injectPersonalMemoryForTurn(turnId, input, origin, signal);
 			await this.agent.injection.injectGoal();
+			const cognitiveProjection = this.projectCognitiveState(turnId);
+			if (cognitiveProjection !== null) this.agent.context.appendSystemReminder(cognitiveProjection, {
+				kind: "injection",
+				variant: "cognitive_continuity"
+			});
 			this.setActiveSteerAcceptance(turnId, true);
 			const turnNeedsTools = blunTurnNeedsTools(input, origin);
 			const turnHasAttachment = blunTurnHasAttachment(input);
@@ -262214,7 +262227,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);
@@ -262356,6 +262386,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.305",
+  "version": "9.1.307",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {