blun-king-cli 9.1.360 → 9.1.362

package/bin/cognitive-effective-view.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+const CANONICAL_LATEST_DOMAINS = new Set([
+  'goal', 'open_thread', 'next_trigger', 'expected_evidence',
+]);
+const CONFIDENCE_MARGIN = 0.2;
+
+function compareVariants(left, right) {
+  return right.maxConfidence - left.maxConfidence
+    || right.confirmations - left.confirmations
+    || right.latestOccurredAt - left.latestOccurredAt
+    || left.value.localeCompare(right.value);
+}
+
+function resolveCognitiveEvidenceGroup(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) return null;
+  const superseded = new Set(entries.map((item) => item.supersedes).filter(Boolean));
+  const active = entries.filter((item) => !superseded.has(item.observationId));
+  if (active.length === 0) return null;
+  const ordered = [...active].sort((left, right) => left.occurredAt - right.occurredAt
+    || left.index - right.index);
+  const latest = ordered.at(-1);
+  const corrected = ordered.some((item) => Boolean(item.supersedes));
+  const distinctValues = new Set(ordered.map((item) => item.value));
+  if (distinctValues.size === 1) return { ...latest, revised: false, corrected, contested: false, conflict: false };
+  if (CANONICAL_LATEST_DOMAINS.has(latest.domain)) {
+    return { ...latest, revised: true, corrected, contested: false, conflict: false };
+  }
+
+  const variants = new Map();
+  for (const item of ordered) {
+    const variant = variants.get(item.value) ?? {
+      value: item.value,
+      maxConfidence: item.confidence,
+      confirmations: 0,
+      latestOccurredAt: item.occurredAt,
+      representative: item,
+    };
+    variant.confirmations += 1;
+    variant.latestOccurredAt = Math.max(variant.latestOccurredAt, item.occurredAt);
+    if (item.confidence > variant.maxConfidence
+        || item.confidence === variant.maxConfidence && item.occurredAt >= variant.representative.occurredAt) {
+      variant.maxConfidence = item.confidence;
+      variant.representative = item;
+    }
+    variants.set(item.value, variant);
+  }
+  const ranked = [...variants.values()].sort(compareVariants);
+  const strongest = ranked[0];
+  const runnerUp = ranked[1];
+  if (strongest.maxConfidence - runnerUp.maxConfidence >= CONFIDENCE_MARGIN - Number.EPSILON) {
+    return {
+      ...strongest.representative,
+      confidence: strongest.maxConfidence,
+      occurredAt: strongest.latestOccurredAt,
+      revised: false,
+      corrected,
+      contested: true,
+      conflict: false,
+    };
+  }
+  return {
+    ...latest,
+    confidence: strongest.maxConfidence,
+    occurredAt: Math.max(...ranked.map((item) => item.latestOccurredAt)),
+    revised: false,
+    corrected,
+    contested: false,
+    conflict: true,
+  };
+}
+
+module.exports = { resolveCognitiveEvidenceGroup };

package/bin/cognitive-focus-projection.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+
 const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
 const DOMAIN_WEIGHTS = new Map([
   ['goal', 60],
@@ -44,6 +46,9 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     const key = clean(item?.key, 128);
     const value = clean(item?.value, 512);
     const scope = clean(item?.scope, 128);
+    const observationId = clean(item?.observation_id, 128);
+    const supersedes = item?.supersedes === null || item?.supersedes === undefined
+      ? null : clean(item.supersedes, 128);
     const confidence = Number(item?.confidence);
     const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
     if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime'
@@ -51,7 +56,7 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
         || !Number.isFinite(occurredAt)) return;
     const groupKey = `${scope}\0${domain}\0${key}`;
     const existing = groups.get(groupKey) ?? [];
-    existing.push({ domain, key, value, scope, confidence, occurredAt, index });
+    existing.push({ domain, key, value, scope, observationId, supersedes, confidence, occurredAt, index });
     groups.set(groupKey, existing);
   });
 
@@ -60,11 +65,11 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
     entries.sort((left, right) => left.occurredAt - right.occurredAt || left.index - right.index);
     const latest = entries.at(-1);
     if (!scopes.includes(latest.scope)) continue;
-    const revised = entries.some((item) => item.value !== latest.value);
+    const effective = resolveCognitiveEvidenceGroup(entries);
+    if (!effective) continue;
     ranked.push({
-      ...latest,
-      revised,
-      score: DOMAIN_WEIGHTS.get(latest.domain) + latest.confidence * 10,
+      ...effective,
+      score: DOMAIN_WEIGHTS.get(effective.domain) + effective.confidence * 10,
     });
   }
   ranked.sort((left, right) => right.score - left.score
@@ -72,7 +77,12 @@ function buildCognitiveFocusProjection(state, { focusScopes, maxItems = 6, maxCh
   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]' : ''}`);
+  const lines = selected.map((item) => {
+    if (item.conflict) return `- Conflict: ${item.key} has incompatible evidence; verify before relying on it.`;
+    const marker = item.corrected ? ' [corrected]'
+      : item.contested ? ' [contested; stronger evidence]' : item.revised ? ' [revised]' : '';
+    return `- ${LABELS.get(item.domain)}: ${item.value}${marker}`;
+  });
   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;

package/bin/cognitive-state-store.cjs

@@ -52,7 +52,7 @@ function normalizeSource(source) {
 }
 
 function normalizeObservation(value) {
-  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'scope']);
+  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'scope', 'supersedes']);
   if (!exactKeys(value, allowed) || hasForbiddenKey(value)) fail('COGNITIVE_FORBIDDEN_FIELD');
   const observation = {
     observation_id: safeId(value.observation_id),
@@ -68,6 +68,10 @@ function normalizeObservation(value) {
     fail('COGNITIVE_INVALID_EVENT');
   }
   if (FORBIDDEN_KEY_RE.test(observation.key)) fail('COGNITIVE_FORBIDDEN_FIELD');
+  if (value.supersedes !== undefined && value.supersedes !== null) {
+    observation.supersedes = safeId(value.supersedes);
+    if (!observation.supersedes || observation.confidence !== 1) fail('COGNITIVE_INVALID_CORRECTION');
+  }
   return observation;
 }
 
@@ -143,7 +147,8 @@ function initialize(db) {
       confidence REAL NOT NULL,
       scope TEXT NOT NULL,
       source_json TEXT NOT NULL,
-      occurred_at TEXT NOT NULL
+      occurred_at TEXT NOT NULL,
+      supersedes_observation_id TEXT
     );
     CREATE INDEX IF NOT EXISTS cognitive_observations_stream
       ON cognitive_observations (tenant_id, agent_id, occurred_at, observation_id);
@@ -167,6 +172,10 @@ function initialize(db) {
       PRIMARY KEY (tenant_id, receipt_id)
     );
   `);
+  const observationColumns = db.prepare('PRAGMA table_info(cognitive_observations)').all();
+  if (!observationColumns.some((column) => column.name === 'supersedes_observation_id')) {
+    db.exec('ALTER TABLE cognitive_observations ADD COLUMN supersedes_observation_id TEXT');
+  }
 }
 
 function openCognitiveStateStore({ home } = {}) {
@@ -198,12 +207,20 @@ function openCognitiveStateStore({ home } = {}) {
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
         .run(normalized.event_id, normalized.tenant_id, normalized.agent_id, actualVersion, newVersion, normalized.occurred_at, payload, previousHash, eventHash);
       const insertObservation = db.prepare(`INSERT INTO cognitive_observations
-        (observation_id, event_id, tenant_id, agent_id, domain, fact_key, value_text, confidence, scope, source_json, occurred_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        (observation_id, event_id, tenant_id, agent_id, domain, fact_key, value_text, confidence, scope, source_json, occurred_at, supersedes_observation_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
       const sourceJson = JSON.stringify(normalized.source);
       for (const observation of normalized.observations) {
+        if (observation.supersedes) {
+          const target = db.prepare(`SELECT tenant_id, agent_id, domain, fact_key, scope
+            FROM cognitive_observations WHERE observation_id = ?`).get(observation.supersedes);
+          if (!target || target.tenant_id !== normalized.tenant_id || target.agent_id !== normalized.agent_id
+              || target.domain !== observation.domain || target.fact_key !== observation.key
+              || target.scope !== observation.scope) fail('COGNITIVE_INVALID_CORRECTION');
+        }
         insertObservation.run(observation.observation_id, normalized.event_id, normalized.tenant_id, normalized.agent_id,
-          observation.domain, observation.key, observation.value, observation.confidence, observation.scope, sourceJson, normalized.occurred_at);
+          observation.domain, observation.key, observation.value, observation.confidence, observation.scope, sourceJson,
+          normalized.occurred_at, observation.supersedes ?? null);
       }
       db.prepare(`INSERT INTO cognitive_streams (tenant_id, agent_id, version, updated_at) VALUES (?, ?, ?, ?)
         ON CONFLICT(tenant_id, agent_id) DO UPDATE SET version = excluded.version, updated_at = excluded.updated_at`)
@@ -221,7 +238,8 @@ function openCognitiveStateStore({ home } = {}) {
     const agent = safeId(agentId);
     if (!tenant || !agent) fail('COGNITIVE_INVALID_EVENT');
     const stream = db.prepare('SELECT version, updated_at FROM cognitive_streams WHERE tenant_id = ? AND agent_id = ?').get(tenant, agent);
-    const rows = db.prepare(`SELECT domain, fact_key, value_text, confidence, scope, source_json, occurred_at, observation_id
+    const rows = db.prepare(`SELECT domain, fact_key, value_text, confidence, scope, source_json, occurred_at, observation_id,
+      supersedes_observation_id
       FROM cognitive_observations WHERE tenant_id = ? AND agent_id = ? ORDER BY occurred_at, rowid`).all(tenant, agent);
     return {
       version: Number(stream?.version ?? 0),
@@ -235,6 +253,7 @@ function openCognitiveStateStore({ home } = {}) {
         scope: row.scope,
         source: JSON.parse(row.source_json),
         occurred_at: row.occurred_at,
+        supersedes: row.supersedes_observation_id ?? null,
       })),
     };
   }

package/package.json

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