blun-king-cli 9.1.388 → 9.1.390

package/bin/cognitive-memory-adapter.cjs

@@ -2,8 +2,9 @@
 
 const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
 
-const COGNITIVE_MEMORY_ADAPTER_VERSION = 3;
+const COGNITIVE_MEMORY_ADAPTER_VERSION = 5;
 const KIND_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const RETENTION_CLASSES = new Set(['operational', 'durable', 'relationship', 'audit']);
 const ACCESS_KEYS = Object.freeze([
   'actorId', 'agentId', 'channelId', 'conversationId', 'permissionContext',
   'portalId', 'requestedScope', 'tenantId', 'userId',
@@ -86,12 +87,18 @@ function assertVisibleScope(scope, access) {
 }
 
 function assertCommitAccess(input, access) {
+  if (Number.isNaN(Date.parse(String(input?.occurredAt ?? '')))
+      || Number.isNaN(Date.parse(String(input?.receivedAt ?? '')))
+      || !RETENTION_CLASSES.has(String(input?.retentionClass ?? ''))) {
+    fail('COGNITIVE_MEMORY_EVENT_ENVELOPE_INVALID');
+  }
   if (isInternalAgentAccess(access)) return;
   if (!Array.isArray(input?.observations) || input.observations.length < 1) {
     fail('COGNITIVE_MEMORY_VISIBILITY_DENIED');
   }
   for (const observation of input.observations) assertVisibleScope(observation?.scope, access);
   if (safeId(input?.source?.provider) !== access.portalId
+      || safeId(input?.source?.channel_id) !== access.channelId
       || safeId(input?.source?.actor_id) !== access.actorId
       || safeId(input?.source?.context_id) !== access.conversationId) {
     fail('COGNITIVE_MEMORY_SOURCE_MISMATCH');

package/bin/cognitive-memory-command.cjs

@@ -110,6 +110,7 @@ function matchesRevisionReplay(items, target, command, commandSource) {
       : item.withdraws === target.observationId && item.value === 'withdrawn';
     return linked
       && item.source?.provider === commandSource.source.provider
+      && item.source?.channel_id === commandSource.source.channelId
       && item.source?.actor_id === commandSource.source.actorId
       && item.source?.context_id === commandSource.source.contextId
       && item.source?.message_id === commandSource.source.messageId
@@ -133,6 +134,7 @@ function normalizeTelegramSource(source) {
     occurredAt: timestamp,
     source: {
       provider: 'telegram',
+      channelId: 'direct',
       actorId: `tg_user_${userId}`,
       contextId: `tg_chat_${chatId}`,
       messageId: `tg_message_${messageId}`,
@@ -153,6 +155,7 @@ function localSource({ env, sessionId, occurredAt, nonce }) {
     occurredAt,
     source: {
       provider: 'cli',
+      channelId: 'terminal',
       actorId: digestId('localuser', [actor]),
       contextId: digestId('clisession', [session]),
       messageId: digestId('cliinput', [unique]),

package/bin/cognitive-state-store.cjs

@@ -10,6 +10,7 @@ const DOMAINS = new Set(['self', 'world', 'team', 'goal', 'open_thread', 'assump
 const EPISTEMIC_STATES = new Set([
   'verified', 'credible_unverified', 'hypothesis', 'uncertain_memory', 'stale', 'unknown', 'legacy_unknown',
 ]);
+const RETENTION_CLASSES = new Set(['operational', 'durable', 'relationship', 'audit']);
 const FORBIDDEN_KEY_RE = /(?:^|_)(?:acl|api_key|capability|password|permission|secret|token)(?:_|$)/iu;
 const MAX_EVENT_BYTES = 64 * 1024;
 const MAX_OBSERVATIONS = 32;
@@ -42,10 +43,11 @@ function exactKeys(value, keys) {
 }
 
 function normalizeSource(source) {
-  const allowed = new Set(['provider', 'actor_id', 'context_id', 'message_id']);
+  const allowed = new Set(['provider', 'channel_id', 'actor_id', 'context_id', 'message_id']);
   if (!exactKeys(source, allowed) || hasForbiddenKey(source)) fail('COGNITIVE_FORBIDDEN_FIELD');
   const normalized = {
     provider: safeId(source.provider),
+    channel_id: safeId(source.channel_id),
     actor_id: safeId(source.actor_id),
     context_id: safeId(source.context_id),
     message_id: safeId(source.message_id),
@@ -89,13 +91,21 @@ function normalizeObservation(value) {
 }
 
 function normalizeEvent(input) {
+  const allowed = new Set([
+    'tenantId', 'agentId', 'eventId', 'expectedVersion', 'occurredAt', 'receivedAt',
+    'retentionClass', 'source', 'observations',
+  ]);
+  if (!exactKeys(input, allowed) || hasForbiddenKey(input)) fail('COGNITIVE_FORBIDDEN_FIELD');
   const tenantId = safeId(input.tenantId);
   const agentId = safeId(input.agentId);
   const eventId = safeId(input.eventId);
   const expectedVersion = Number(input.expectedVersion);
   const occurredAt = String(input.occurredAt ?? '').trim();
+  const receivedAt = String(input.receivedAt ?? '').trim();
+  const retentionClass = String(input.retentionClass ?? '').trim();
   if (!tenantId || !agentId || !eventId || !Number.isSafeInteger(expectedVersion)
       || expectedVersion < 0 || Number.isNaN(Date.parse(occurredAt))
+      || Number.isNaN(Date.parse(receivedAt)) || !RETENTION_CLASSES.has(retentionClass)
       || !Array.isArray(input.observations) || input.observations.length < 1
       || input.observations.length > MAX_OBSERVATIONS) fail('COGNITIVE_INVALID_EVENT');
   const normalized = {
@@ -103,7 +113,9 @@ function normalizeEvent(input) {
     agent_id: agentId,
     event_id: eventId,
     expected_version: expectedVersion,
-    occurred_at: occurredAt,
+    occurred_at: new Date(occurredAt).toISOString(),
+    received_at: new Date(receivedAt).toISOString(),
+    retention_class: retentionClass,
     source: normalizeSource(input.source),
     observations: input.observations.map(normalizeObservation),
   };
@@ -145,6 +157,8 @@ function initialize(db) {
       expected_version INTEGER NOT NULL,
       new_version INTEGER NOT NULL,
       occurred_at TEXT NOT NULL,
+      received_at TEXT NOT NULL,
+      retention_class TEXT NOT NULL,
       payload_json TEXT NOT NULL,
       previous_hash TEXT NOT NULL,
       event_hash TEXT NOT NULL UNIQUE
@@ -162,6 +176,8 @@ function initialize(db) {
       scope TEXT NOT NULL,
       source_json TEXT NOT NULL,
       occurred_at TEXT NOT NULL,
+      received_at TEXT NOT NULL,
+      retention_class TEXT NOT NULL,
       supersedes_observation_id TEXT,
       withdraws_observation_id TEXT
     );
@@ -199,6 +215,19 @@ function initialize(db) {
   if (!observationColumns.some((column) => column.name === 'epistemic_state')) {
     db.exec("ALTER TABLE cognitive_observations ADD COLUMN epistemic_state TEXT NOT NULL DEFAULT 'legacy_unknown'");
   }
+  if (!observationColumns.some((column) => column.name === 'received_at')) {
+    db.exec("ALTER TABLE cognitive_observations ADD COLUMN received_at TEXT NOT NULL DEFAULT ''");
+  }
+  if (!observationColumns.some((column) => column.name === 'retention_class')) {
+    db.exec("ALTER TABLE cognitive_observations ADD COLUMN retention_class TEXT NOT NULL DEFAULT 'legacy_unknown'");
+  }
+  const eventColumns = db.prepare('PRAGMA table_info(cognitive_events)').all();
+  if (!eventColumns.some((column) => column.name === 'received_at')) {
+    db.exec("ALTER TABLE cognitive_events ADD COLUMN received_at TEXT NOT NULL DEFAULT ''");
+  }
+  if (!eventColumns.some((column) => column.name === 'retention_class')) {
+    db.exec("ALTER TABLE cognitive_events ADD COLUMN retention_class TEXT NOT NULL DEFAULT 'legacy_unknown'");
+  }
 }
 
 function openCognitiveStateStore({ home } = {}) {
@@ -226,12 +255,13 @@ function openCognitiveStateStore({ home } = {}) {
       const eventHash = crypto.createHash('sha256').update(`${previousHash}\0${payload}`).digest('hex');
       const newVersion = actualVersion + 1;
       db.prepare(`INSERT INTO cognitive_events
-        (event_id, tenant_id, agent_id, expected_version, new_version, occurred_at, payload_json, previous_hash, event_hash)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(normalized.event_id, normalized.tenant_id, normalized.agent_id, actualVersion, newVersion, normalized.occurred_at, payload, previousHash, eventHash);
+        (event_id, tenant_id, agent_id, expected_version, new_version, occurred_at, received_at, retention_class, payload_json, previous_hash, event_hash)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(normalized.event_id, normalized.tenant_id, normalized.agent_id, actualVersion, newVersion,
+          normalized.occurred_at, normalized.received_at, normalized.retention_class, 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, epistemic_state, scope, source_json, occurred_at, supersedes_observation_id, withdraws_observation_id)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        (observation_id, event_id, tenant_id, agent_id, domain, fact_key, value_text, confidence, epistemic_state, scope, source_json, occurred_at, received_at, retention_class, supersedes_observation_id, withdraws_observation_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
       const sourceJson = JSON.stringify(normalized.source);
       for (const observation of normalized.observations) {
         if (observation.supersedes) {
@@ -251,7 +281,8 @@ function openCognitiveStateStore({ home } = {}) {
         insertObservation.run(observation.observation_id, normalized.event_id, normalized.tenant_id, normalized.agent_id,
           observation.domain, observation.key, observation.value, observation.confidence, observation.epistemic_state,
           observation.scope, sourceJson,
-          normalized.occurred_at, observation.supersedes ?? null, observation.withdraws ?? null);
+          normalized.occurred_at, normalized.received_at, normalized.retention_class,
+          observation.supersedes ?? null, observation.withdraws ?? 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`)
@@ -272,7 +303,8 @@ function openCognitiveStateStore({ home } = {}) {
       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 select = `SELECT domain, fact_key, value_text, confidence, epistemic_state, scope, source_json, occurred_at, observation_id,
+    const select = `SELECT domain, fact_key, value_text, confidence, epistemic_state, scope, source_json, occurred_at, received_at,
+      retention_class, observation_id,
       supersedes_observation_id, withdraws_observation_id FROM cognitive_observations`;
     const rows = requestedVisibility && requestedVisibility !== 'agent:memory'
       ? db.prepare(`${select} WHERE tenant_id = ? AND agent_id = ? AND scope = ? ORDER BY occurred_at, rowid`)
@@ -291,6 +323,8 @@ function openCognitiveStateStore({ home } = {}) {
         scope: row.scope,
         source: JSON.parse(row.source_json),
         occurred_at: row.occurred_at,
+        received_at: row.received_at || row.occurred_at,
+        retention_class: row.retention_class || 'legacy_unknown',
         supersedes: row.supersedes_observation_id ?? null,
         withdraws: row.withdraws_observation_id ?? null,
       })),

package/bin/cognitive-turn-lifecycle.cjs

@@ -127,8 +127,11 @@ function createCognitiveTurnLifecycle({
           eventId,
           expectedVersion,
           occurredAt,
+          receivedAt: occurredAt,
+          retentionClass: 'operational',
           source: {
             provider: 'runtime',
+            channel_id: 'runtime',
             actor_id: agent,
             context_id: runtime,
             message_id: stageKey,
@@ -175,8 +178,11 @@ function createCognitiveTurnLifecycle({
           eventId,
           expectedVersion,
           occurredAt,
+          receivedAt: occurredAt,
+          retentionClass: 'durable',
           source: {
             provider: 'runtime',
+            channel_id: 'runtime',
             actor_id: agent,
             context_id: 'durable-focus',
             message_id: stageKey,
@@ -282,11 +288,12 @@ function createCognitiveTurnLifecycle({
     if (!requestId || !targetObservationId || !FOCUS_DOMAINS.has(domain) || !key
         || AUTHORITY_KEY_RE.test(key) || !scope || scope === 'runtime'
         || Number.isNaN(Date.parse(occurredAt))
-        || !exactKeys(source, new Set(['provider', 'actorId', 'contextId', 'messageId']))) {
+        || !exactKeys(source, new Set(['provider', 'channelId', 'actorId', 'contextId', 'messageId']))) {
       fail('COGNITIVE_REVISION_INVALID');
     }
     const normalizedSource = {
       provider: safeId(source.provider),
+      channel_id: safeId(source.channelId),
       actor_id: safeId(source.actorId),
       context_id: safeId(source.contextId),
       message_id: safeId(source.messageId),
@@ -307,13 +314,14 @@ function createCognitiveTurnLifecycle({
       ...(correction ? { supersedes: targetObservationId } : { withdraws: targetObservationId }),
     };
     const normalizedOccurredAt = new Date(occurredAt).toISOString();
+    const receivedAt = stageTime(`revision:${kind}:${requestId}`);
     const revisionMemoryAccess = {
       tenantId: tenant,
       userId: normalizedSource.actor_id,
       actorId: normalizedSource.actor_id,
       agentId: agent,
       portalId: normalizedSource.provider,
-      channelId: normalizedSource.provider,
+      channelId: normalizedSource.channel_id,
       conversationId: normalizedSource.context_id,
       requestedScope: scope,
       permissionContext: {
@@ -332,6 +340,7 @@ function createCognitiveTurnLifecycle({
           && existing.supersedes === (observation.supersedes ?? null)
           && existing.withdraws === (observation.withdraws ?? null)
           && existing.source.provider === normalizedSource.provider
+          && existing.source.channel_id === normalizedSource.channel_id
           && existing.source.actor_id === normalizedSource.actor_id
           && existing.source.context_id === normalizedSource.context_id
           && existing.source.message_id === normalizedSource.message_id;
@@ -349,6 +358,8 @@ function createCognitiveTurnLifecycle({
           eventId,
           expectedVersion: current.version,
           occurredAt: normalizedOccurredAt,
+          receivedAt,
+          retentionClass: 'durable',
           source: normalizedSource,
           observations: [observation],
         }, revisionMemoryAccess);

package/bin/identity-context-policy.cjs

@@ -462,6 +462,7 @@ function recordChannelIdentity(envelope, env = process.env) {
   const groupId = chatId.startsWith('-') ? `telegram-chat-${chatId.slice(1)}` : undefined;
   const displayName = cleanText(meta.user, 120) || actorId;
   const firstSeenAt = trustedTimestamp(meta.ts);
+  const receivedAt = trustedTimestamp(meta.received_at) || firstSeenAt;
   const created = [];
   if (createJsonOnce(root, ['actors', `${actorId}.json`], {
     version: 1,
@@ -517,6 +518,7 @@ function recordChannelIdentity(envelope, env = process.env) {
     sourceChannel: groupId ? 'group' : 'direct',
     conversationId: groupId || `telegram-dm-${chatId}`,
     messageId: safeId(meta.message_id),
+    receivedAt,
   });
   if (firstSeenAt) recordInteractionActivity(root, agentId, actorId, firstSeenAt);
   const modelContext = renderIdentityContext({

package/bin/personality-memory-adapter.cjs

@@ -9,7 +9,7 @@ const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 const SENSITIVITIES = new Set(['low', 'medium']);
 const INPUT_KEYS = [
   'actorId', 'agentId', 'conversationId', 'cooldownMs', 'messageId', 'occurredAt',
-  'sensitivity', 'sourceChannel', 'sourcePortal', 'tenantId', 'topic',
+  'receivedAt', 'sensitivity', 'sourceChannel', 'sourcePortal', 'tenantId', 'topic',
 ];
 const MAX_COOLDOWN_MS = 90 * 24 * 60 * 60 * 1000;
 
@@ -49,6 +49,7 @@ function normalizePresentation(input) {
     conversationId: safeId(input.conversationId),
     messageId: safeId(input.messageId),
     occurredAt: String(input.occurredAt ?? '').trim(),
+    receivedAt: String(input.receivedAt ?? '').trim(),
     topic: safeId(input.topic),
     sensitivity: String(input.sensitivity ?? ''),
     cooldownMs: Number(input.cooldownMs),
@@ -57,11 +58,13 @@ function normalizePresentation(input) {
       || !normalized.sourcePortal || !normalized.sourceChannel || !normalized.conversationId
       || !normalized.messageId || !normalized.topic || !SENSITIVITIES.has(normalized.sensitivity)
       || Number.isNaN(Date.parse(normalized.occurredAt))
+      || Number.isNaN(Date.parse(normalized.receivedAt))
       || !Number.isSafeInteger(normalized.cooldownMs) || normalized.cooldownMs < 1000
       || normalized.cooldownMs > MAX_COOLDOWN_MS) {
     fail('PERSONALITY_MEMORY_INVALID_INPUT');
   }
   normalized.occurredAt = new Date(normalized.occurredAt).toISOString();
+  normalized.receivedAt = new Date(normalized.receivedAt).toISOString();
   return normalized;
 }
 
@@ -138,8 +141,11 @@ function createPersonalityMemoryAdapter({ identityRoot, memoryAdapter } = {}) {
           eventId,
           expectedVersion: current.version,
           occurredAt: value.occurredAt,
+          receivedAt: value.receivedAt,
+          retentionClass: 'relationship',
           source: {
             provider: value.sourcePortal,
+            channel_id: value.sourceChannel,
             actor_id: value.actorId,
             context_id: value.conversationId,
             message_id: value.messageId,

package/bin/relationship-curiosity-policy.cjs

@@ -64,11 +64,12 @@ function prepareCuriosityOpportunity(input = {}) {
   const agentId = safeId(input.agentId);
   const actorId = safeId(input.actorId);
   const occurredAt = trustedTimestamp(input.occurredAt);
+  const receivedAt = trustedTimestamp(input.receivedAt);
   const sourcePortal = safeId(input.sourcePortal) || 'telegram';
   const sourceChannel = safeId(input.sourceChannel) || 'direct';
   const conversationId = safeId(input.conversationId) || digestId('conversation', [actorId]);
   const cue = curiosityCue(input.text);
-  if (!tenantId || !agentId || !actorId || !occurredAt || !cue) return undefined;
+  if (!tenantId || !agentId || !actorId || !occurredAt || !receivedAt || !cue) return undefined;
   const messageId = safeId(input.messageId) || digestId('message', [
     sourcePortal, sourceChannel, conversationId, actorId, occurredAt, normalizedText(input.text),
   ]);
@@ -88,6 +89,7 @@ function prepareCuriosityOpportunity(input = {}) {
       conversationId,
       messageId,
       occurredAt,
+      receivedAt,
       topic: cue.topic,
       sensitivity: cue.sensitivity,
       cooldownMs: COOLDOWN_MS,

package/package.json

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