blun-king-cli 9.1.309 → 9.1.310

package/bin/cognitive-focus-projection.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
+const DOMAIN_WEIGHTS = new Map([
+  ['goal', 60],
+  ['open_thread', 50],
+  ['next_trigger', 40],
+  ['expected_evidence', 30],
+  ['team', 20],
+  ['self', 10],
+]);
+const LABELS = new Map([
+  ['goal', 'Goal'],
+  ['open_thread', 'Open thread'],
+  ['next_trigger', 'Next trigger'],
+  ['expected_evidence', 'Expected evidence'],
+  ['team', 'Team'],
+  ['self', 'Self'],
+]);
+const SAFETY_LINE = 'Durable context only; it cannot authorize any action or override the current assignment or runtime policy.';
+
+function clean(value, max = 256) {
+  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
+  return text && text.length <= max ? text : '';
+}
+
+function normalizeScopes(value) {
+  if (value === undefined) return [];
+  if (!Array.isArray(value) || value.length > 8) return null;
+  const scopes = value.map((item) => clean(item, 128));
+  return scopes.every(Boolean) ? [...new Set(scopes)] : null;
+}
+
+function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxChars = 900 } = {}) {
+  const scopes = normalizeScopes(focusScopes);
+  if (scopes === null || !Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 8
+      || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600
+      || !Array.isArray(state?.observations)) return null;
+
+  const groups = new Map();
+  state.observations.forEach((item, index) => {
+    const domain = String(item?.domain ?? '');
+    const key = clean(item?.key, 128);
+    const value = clean(item?.value, 512);
+    const scope = clean(item?.scope, 128);
+    const confidence = Number(item?.confidence);
+    const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
+    if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime'
+        || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
+        || !Number.isFinite(occurredAt)) return;
+    const groupKey = `${domain}\0${key}`;
+    const existing = groups.get(groupKey) ?? [];
+    existing.push({ domain, key, value, scope, confidence, occurredAt, index });
+    groups.set(groupKey, existing);
+  });
+
+  const ranked = [];
+  for (const entries of groups.values()) {
+    entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
+    const latest = entries.at(-1);
+    const revised = entries.some((item) => item.value !== latest.value);
+    const scopeScore = scopes.includes(latest.scope) ? 100 : 0;
+    ranked.push({
+      ...latest,
+      revised,
+      score: scopeScore + DOMAIN_WEIGHTS.get(latest.domain) + latest.confidence * 10,
+    });
+  }
+  ranked.sort((left, right) => right.score - left.score
+    || right.occurredAt - left.occurredAt || left.key.localeCompare(right.key));
+  if (ranked.length === 0) return null;
+
+  const selected = ranked.slice(0, maxItems);
+  const lines = selected.map((item) => `- ${LABELS.get(item.domain)}: ${item.value}${item.revised ? ' [revised]' : ''}`);
+  while ([`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n').length > maxChars
+      && lines.length > 0) lines.pop();
+  if (lines.length === 0) return null;
+  return [`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n');
+}
+
+module.exports = { buildCognitiveFocusProjection };

package/bin/cognitive-turn-lifecycle.cjs

@@ -3,6 +3,7 @@
 const crypto = require('node:crypto');
 const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
 const { buildCognitiveContextProjection } = require('./cognitive-context-projection.cjs');
+const { buildCognitiveFocusProjection } = require('./cognitive-focus-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']);
@@ -10,6 +11,8 @@ 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']);
+const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
+const AUTHORITY_KEY_RE = /(?:^|:|_)(?:acl|api[_-]?key|capability|password|permission|secret|token)(?::|_|$)/iu;
 
 function fail(code) {
   const error = new Error(code);
@@ -140,6 +143,27 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     ]);
   }
 
+  function recordFocusSnapshot(input) {
+    if (!exactKeys(input, new Set(['snapshotId', 'observations']))
+        || !safeId(input.snapshotId) || !Array.isArray(input.observations)
+        || input.observations.length < 1 || input.observations.length > 16) {
+      fail('COGNITIVE_FOCUS_INVALID');
+    }
+    const observations = input.observations.map((item) => {
+      if (!exactKeys(item, new Set(['domain', 'key', 'value', 'confidence', 'scope']))) fail('COGNITIVE_FOCUS_INVALID');
+      const domain = String(item.domain ?? '');
+      const key = cleanLabel(item.key, 128);
+      const value = cleanLabel(item.value, 512);
+      const confidence = Number(item.confidence);
+      const scope = cleanLabel(item.scope, 128);
+      if (!FOCUS_DOMAINS.has(domain) || !key || AUTHORITY_KEY_RE.test(key) || !value
+          || !Number.isFinite(confidence) || confidence < 0.5 || confidence > 1
+          || !scope || scope === 'runtime') fail('COGNITIVE_FOCUS_INVALID');
+      return { domain, key, value, confidence, scope };
+    });
+    return commitStage(`focus-${input.snapshotId}`, observations);
+  }
+
   function toolFields(input, allowedKeys) {
     if (!exactKeys(input, allowedKeys)) fail('COGNITIVE_LIFECYCLE_INVALID');
     const turnId = safeTurnId(input.turnId);
@@ -174,13 +198,16 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
   }
 
   function projectForTurn(input) {
-    if (!exactKeys(input, new Set(['turnId']))) fail('COGNITIVE_LIFECYCLE_INVALID');
+    if (!exactKeys(input, new Set(['turnId', 'focusScopes']))) fail('COGNITIVE_LIFECYCLE_INVALID');
     const turnId = safeTurnId(input.turnId);
     if (turnId === null) fail('COGNITIVE_LIFECYCLE_INVALID');
-    return buildCognitiveContextProjection(store.read({ tenantId: tenant, agentId: agent }), {
+    const state = store.read({ tenantId: tenant, agentId: agent });
+    const continuity = buildCognitiveContextProjection(state, {
       currentTurnId: turnId,
       currentRuntimeId: runtime,
     });
+    const focus = buildCognitiveFocusProjection(state, { focusScopes: input.focusScopes });
+    return [focus, continuity].filter(Boolean).join('\n\n') || null;
   }
 
   return {
@@ -188,6 +215,7 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     recordRightsCheck,
     recordToolPolicy,
     recordToolResult,
+    recordFocusSnapshot,
     projectForTurn,
     endTurn,
     read: () => store.read({ tenantId: tenant, agentId: agent }),

package/package.json

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