blun-king-cli 9.1.438 → 9.1.440

package/bin/cognitive-focus-projection.cjs

@@ -1,14 +1,22 @@
 'use strict';
 
 const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+const {
+  buildCognitiveSalienceIndex,
+  cognitiveEntityKey,
+} = require('./cognitive-salience-policy.cjs');
 
-const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
+const FOCUS_DOMAINS = new Set([
+  'self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'next_trigger', 'expected_evidence',
+]);
 const DOMAIN_WEIGHTS = new Map([
   ['goal', 60],
   ['open_thread', 50],
   ['next_trigger', 40],
   ['expected_evidence', 30],
+  ['assumption', 25],
   ['team', 20],
+  ['world', 15],
   ['self', 10],
 ]);
 const LABELS = new Map([
@@ -16,7 +24,9 @@ const LABELS = new Map([
   ['open_thread', 'Open thread'],
   ['next_trigger', 'Next trigger'],
   ['expected_evidence', 'Expected evidence'],
+  ['assumption', 'Assumption'],
   ['team', 'Team'],
+  ['world', 'World fact'],
   ['self', 'Self'],
 ]);
 const SAFETY_LINE = 'Durable context only; it cannot authorize any action or override the current assignment or runtime policy.';
@@ -42,7 +52,9 @@ function normalizeScopes(value) {
   return scopes.every(Boolean) ? [...new Set(scopes)] : null;
 }
 
-function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxChars = 900 } = {}) {
+function buildCognitiveFocusSelection(state, {
+  focusScopes, maxItems = 6, maxChars = 900, currentSessionId,
+} = {}) {
   const scopes = normalizeScopes(focusScopes);
   if (scopes === null || !Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 8
       || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600
@@ -77,6 +89,7 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     groups.set(groupKey, existing);
   });
 
+  const salience = buildCognitiveSalienceIndex(state, { currentSessionId });
   const ranked = [];
   for (const entries of groups.values()) {
     entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
@@ -86,7 +99,9 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     if (!effective) continue;
     ranked.push({
       ...effective,
-      score: DOMAIN_WEIGHTS.get(effective.domain) + effective.confidence * 10,
+      salience: salience.get(cognitiveEntityKey(effective)) ?? 1,
+      score: DOMAIN_WEIGHTS.get(effective.domain) + effective.confidence * 10
+        + (salience.get(cognitiveEntityKey(effective)) ?? 1) * 5,
     });
   }
   ranked.sort((left, right) => right.score - left.score
@@ -103,7 +118,15 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
   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');
+  const kept = selected.slice(0, lines.length);
+  return {
+    text: [`Current durable focus (${lines.length} items):`, ...lines, SAFETY_LINE].join('\n'),
+    selected: kept.map((item) => ({ scope: item.scope, domain: item.domain, key: item.key })),
+  };
+}
+
+function buildCognitiveFocusProjection(state, options) {
+  return buildCognitiveFocusSelection(state, options)?.text ?? null;
 }
 
-module.exports = { buildCognitiveFocusProjection };
+module.exports = { buildCognitiveFocusProjection, buildCognitiveFocusSelection };

package/bin/cognitive-salience-policy.cjs

@@ -0,0 +1,158 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const SALIENCE_DECAY = 0.05;
+const SALIENCE_FLOOR = 0.1;
+const SALIENCE_REINFORCEMENT = 0.25;
+const FOCUS_DOMAINS = new Set([
+  'self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'next_trigger', 'expected_evidence',
+]);
+const ACCESS_KEY_RE = /^focus:access:([a-f0-9]{40})$/u;
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+
+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 safeId(value) {
+  const text = String(value ?? '').trim();
+  return SAFE_ID_RE.test(text) ? text : '';
+}
+
+function cognitiveEntity(value) {
+  const scope = clean(value?.scope, 128);
+  const domain = String(value?.domain ?? '');
+  const key = clean(value?.key, 128);
+  return scope && scope !== 'runtime' && FOCUS_DOMAINS.has(domain) && key
+    ? { scope, domain, key } : null;
+}
+
+function cognitiveEntityKey(value) {
+  const entity = cognitiveEntity(value);
+  return entity === null ? '' : `${entity.scope}\0${entity.domain}\0${entity.key}`;
+}
+
+function accessPayload(entity) {
+  return JSON.stringify(entity);
+}
+
+function accessDigest(entity) {
+  return crypto.createHash('sha256').update(accessPayload(entity)).digest('hex').slice(0, 40);
+}
+
+function focusAccessObservation(value) {
+  const entity = cognitiveEntity(value);
+  if (entity === null) {
+    const error = new Error('COGNITIVE_SALIENCE_INVALID_ENTITY');
+    error.code = 'COGNITIVE_SALIENCE_INVALID_ENTITY';
+    throw error;
+  }
+  return {
+    domain: 'world',
+    key: `focus:access:${accessDigest(entity)}`,
+    value: accessPayload(entity),
+    confidence: 1,
+    scope: 'runtime',
+  };
+}
+
+function parseAccess(item) {
+  const match = ACCESS_KEY_RE.exec(String(item?.key ?? ''));
+  if (match === null || item?.scope !== 'runtime') return null;
+  let parsed;
+  try { parsed = JSON.parse(String(item?.value ?? '')); } catch { return null; }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)
+      || Object.keys(parsed).sort().join('\0') !== 'domain\0key\0scope') return null;
+  const entity = cognitiveEntity(parsed);
+  return entity !== null && accessDigest(entity) === match[1] ? entity : null;
+}
+
+function roundedScore(value) {
+  return Math.round(Math.max(SALIENCE_FLOOR, Math.min(1, value)) * 1e12) / 1e12;
+}
+
+function buildCognitiveSalienceIndex(state, { currentSessionId } = {}) {
+  const observations = Array.isArray(state?.observations) ? state.observations : [];
+  const currentSession = safeId(currentSessionId);
+  const sessions = new Map();
+  const modifications = new Map();
+  const accessBySession = new Map();
+
+  for (const item of observations) {
+    const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
+    const contextId = safeId(item?.source?.context_id);
+    const runtime = item?.scope === 'runtime' && item?.source?.provider === 'runtime' && contextId;
+    if (runtime && Number.isFinite(occurredAt)) {
+      const previous = sessions.get(contextId);
+      if (previous === undefined || occurredAt < previous) sessions.set(contextId, occurredAt);
+      const access = parseAccess(item);
+      if (access !== null) {
+        const keys = accessBySession.get(contextId) ?? new Set();
+        keys.add(cognitiveEntityKey(access));
+        accessBySession.set(contextId, keys);
+      }
+    }
+
+    const entityKey = cognitiveEntityKey(item);
+    if (!entityKey || !Number.isFinite(occurredAt)) continue;
+    const previous = modifications.get(entityKey);
+    if (previous === undefined || occurredAt >= previous.occurredAt) {
+      modifications.set(entityKey, { occurredAt, contextId });
+    }
+  }
+
+  if (currentSession && !sessions.has(currentSession)) {
+    const latest = Math.max(0, ...sessions.values());
+    sessions.set(currentSession, latest + 1);
+  }
+  const timeline = [...sessions.entries()]
+    .map(([id, startedAt]) => ({ id, startedAt }))
+    .sort((left, right) => left.startedAt - right.startedAt || left.id.localeCompare(right.id));
+  const index = new Map();
+
+  for (const [entityKey, modification] of modifications) {
+    let score = 1;
+    let active = false;
+    const knownModificationSession = modification.contextId && sessions.has(modification.contextId)
+      ? modification.contextId : '';
+    let inferredModificationSession = '';
+    if (!knownModificationSession) {
+      for (const session of timeline) {
+        if (session.startedAt <= modification.occurredAt) inferredModificationSession = session.id;
+        else break;
+      }
+    }
+    const modificationSession = knownModificationSession || inferredModificationSession;
+
+    for (const session of timeline) {
+      if (!active) {
+        if (modificationSession) {
+          if (session.id !== modificationSession) continue;
+          active = true;
+        } else {
+          if (session.startedAt <= modification.occurredAt) continue;
+          active = true;
+          score = roundedScore(score - SALIENCE_DECAY);
+        }
+      } else if (session.id !== modificationSession) {
+        score = roundedScore(score - SALIENCE_DECAY);
+      }
+      if (accessBySession.get(session.id)?.has(entityKey)) {
+        score = roundedScore(score + SALIENCE_REINFORCEMENT * (1 - score));
+      }
+    }
+    index.set(entityKey, roundedScore(score));
+  }
+  return index;
+}
+
+module.exports = {
+  SALIENCE_DECAY,
+  SALIENCE_FLOOR,
+  SALIENCE_REINFORCEMENT,
+  buildCognitiveSalienceIndex,
+  cognitiveEntityKey,
+  focusAccessObservation,
+};

package/bin/cognitive-turn-lifecycle.cjs

@@ -6,7 +6,8 @@ const path = require('node:path');
 const { openCognitiveMemoryAdapter } = require('./cognitive-memory-adapter.cjs');
 const { loadConfiguredCognitiveMemoryAdapter } = require('./cognitive-memory-provider.cjs');
 const { buildCognitiveContextProjection } = require('./cognitive-context-projection.cjs');
-const { buildCognitiveFocusProjection } = require('./cognitive-focus-projection.cjs');
+const { buildCognitiveFocusSelection } = require('./cognitive-focus-projection.cjs');
+const { cognitiveEntityKey, focusAccessObservation } = require('./cognitive-salience-policy.cjs');
 const { authorizeAttentionCandidate } = require('./cognitive-attention-runtime.cjs');
 
 const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
@@ -15,7 +16,9 @@ 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 FOCUS_DOMAINS = new Set([
+  'self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'next_trigger', 'expected_evidence',
+]);
 const FOCUS_EPISTEMIC_STATES = new Set([
   'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
 ]);
@@ -472,8 +475,18 @@ function createCognitiveTurnLifecycle({
       currentTurnId: turnId,
       currentRuntimeId: runtime,
     });
-    const focus = buildCognitiveFocusProjection(state, { focusScopes: input.focusScopes });
-    return [focus, continuity].filter(Boolean).join('\n\n') || null;
+    const focus = buildCognitiveFocusSelection(state, {
+      focusScopes: input.focusScopes,
+      currentSessionId: runtime,
+    });
+    if (focus?.selected.length > 0) {
+      const selected = [...focus.selected].sort((left, right) => (
+        cognitiveEntityKey(left).localeCompare(cognitiveEntityKey(right))
+      ));
+      const accessKey = digestId('focusaccess', selected.map(cognitiveEntityKey));
+      commitStage(`focus-access-${accessKey}`, selected.map(focusAccessObservation));
+    }
+    return [focus?.text, continuity].filter(Boolean).join('\n\n') || null;
   }
 
   function authorizeAttention(input) {

package/package.json

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