blun-king-cli 9.1.389 → 9.1.391

package/bin/cognitive-memory-adapter.cjs

@@ -2,13 +2,25 @@
 
 const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
 
-const COGNITIVE_MEMORY_ADAPTER_VERSION = 4;
+const COGNITIVE_MEMORY_ADAPTER_VERSION = 6;
 const KIND_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const ACCESS_KEYS = Object.freeze([
+const RETENTION_CLASSES = new Set(['operational', 'durable', 'relationship', 'audit']);
+const ACCESS_REQUIRED_KEYS = Object.freeze([
   'actorId', 'agentId', 'channelId', 'conversationId', 'permissionContext',
   'portalId', 'requestedScope', 'tenantId', 'userId',
 ]);
-const PERMISSION_KEYS = Object.freeze(['authority', 'decision', 'receiptId']);
+const ACCESS_OPTIONAL_KEYS = Object.freeze(['identityLink']);
+const PERMISSION_REQUIRED_KEYS = Object.freeze(['authority', 'decision', 'receiptId']);
+const PERMISSION_OPTIONAL_KEYS = Object.freeze(['identityReceiptId']);
+const IDENTITY_LINK_KEYS = Object.freeze([
+  'authority', 'canonicalUserId', 'confirmedAt', 'method', 'receiptId',
+  'sourcePortal', 'sourceSubjectId', 'status', 'tenantId', 'version',
+]);
+const IDENTITY_LINK_AUTHORITIES = new Map([
+  ['verified_oauth', 'oauth_verifier'],
+  ['secure_account_link', 'account_link_service'],
+  ['explicit_confirmed', 'identity_confirmation_service'],
+]);
 const REQUIRED_METHODS = Object.freeze([
   'commit',
   'read',
@@ -30,13 +42,70 @@ function exactKeys(value, expected) {
     && Object.keys(value).sort().join('\0') === [...expected].sort().join('\0');
 }
 
+function requiredAndOptionalKeys(value, required, optional) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const allowed = new Set([...required, ...optional]);
+  return required.every((key) => Object.prototype.hasOwnProperty.call(value, key))
+    && Object.keys(value).every((key) => allowed.has(key));
+}
+
 function safeId(value) {
   const text = String(value ?? '').trim();
   return KIND_RE.test(text) ? text : '';
 }
 
+function normalizeIdentityLink(access, normalized) {
+  const link = access.identityLink;
+  const identityReceiptId = normalized.permissionContext.identityReceiptId;
+  if (normalized.userId === normalized.actorId) {
+    if (link !== undefined || identityReceiptId !== undefined) fail('COGNITIVE_IDENTITY_LINK_INVALID');
+    return undefined;
+  }
+  if (link === undefined || link === null) fail('COGNITIVE_IDENTITY_LINK_REQUIRED');
+  if (!exactKeys(link, IDENTITY_LINK_KEYS)) fail('COGNITIVE_IDENTITY_LINK_INVALID');
+  if (String(link.status ?? '') === 'revoked') fail('COGNITIVE_IDENTITY_LINK_REVOKED');
+  const method = String(link.method ?? '');
+  const normalizedLink = {
+    version: Number(link.version),
+    tenantId: safeId(link.tenantId),
+    canonicalUserId: safeId(link.canonicalUserId),
+    sourcePortal: safeId(link.sourcePortal),
+    sourceSubjectId: safeId(link.sourceSubjectId),
+    method,
+    status: String(link.status ?? ''),
+    confirmedAt: String(link.confirmedAt ?? '').trim(),
+    authority: safeId(link.authority),
+    receiptId: safeId(link.receiptId),
+  };
+  if (normalizedLink.version !== 1 || normalizedLink.status !== 'active'
+      || Number.isNaN(Date.parse(normalizedLink.confirmedAt))
+      || IDENTITY_LINK_AUTHORITIES.get(method) !== normalizedLink.authority
+      || normalizedLink.tenantId !== normalized.tenantId
+      || normalizedLink.canonicalUserId !== normalized.userId
+      || normalizedLink.sourcePortal !== normalized.portalId
+      || normalizedLink.sourceSubjectId !== normalized.actorId
+      || !identityReceiptId || normalizedLink.receiptId !== identityReceiptId) {
+    fail('COGNITIVE_IDENTITY_LINK_INVALID');
+  }
+  const canonicalScope = `relationship:${normalized.userId}:private`;
+  const personalScope = `user:${normalized.userId}:private`;
+  if ((normalized.requestedScope.startsWith('relationship:') && normalized.requestedScope !== canonicalScope)
+      || (normalized.requestedScope.startsWith('user:') && normalized.requestedScope !== personalScope)) {
+    fail('COGNITIVE_IDENTITY_SCOPE_MISMATCH');
+  }
+  return Object.freeze({
+    ...normalizedLink,
+    confirmedAt: new Date(normalizedLink.confirmedAt).toISOString(),
+  });
+}
+
 function normalizeMemoryAccess(access, request) {
-  if (!exactKeys(access, ACCESS_KEYS) || !exactKeys(access.permissionContext, PERMISSION_KEYS)) {
+  if (!requiredAndOptionalKeys(access, ACCESS_REQUIRED_KEYS, ACCESS_OPTIONAL_KEYS)
+      || !requiredAndOptionalKeys(
+        access.permissionContext,
+        PERMISSION_REQUIRED_KEYS,
+        PERMISSION_OPTIONAL_KEYS,
+      )) {
     fail('COGNITIVE_MEMORY_ACCESS_INVALID');
   }
   const normalized = {
@@ -52,6 +121,9 @@ function normalizeMemoryAccess(access, request) {
       authority: safeId(access.permissionContext.authority),
       decision: String(access.permissionContext.decision ?? ''),
       receiptId: safeId(access.permissionContext.receiptId),
+      ...(Object.prototype.hasOwnProperty.call(access.permissionContext, 'identityReceiptId')
+        ? { identityReceiptId: safeId(access.permissionContext.identityReceiptId) }
+        : {}),
     },
   };
   if (!normalized.tenantId || !normalized.userId || !normalized.actorId || !normalized.agentId
@@ -65,6 +137,8 @@ function normalizeMemoryAccess(access, request) {
       || requestTenant !== normalized.tenantId || requestAgent !== normalized.agentId) {
     fail('COGNITIVE_MEMORY_ACCESS_SCOPE_MISMATCH');
   }
+  const identityLink = normalizeIdentityLink(access, normalized);
+  if (identityLink) normalized.identityLink = identityLink;
   normalized.permissionContext = Object.freeze(normalized.permissionContext);
   return Object.freeze(normalized);
 }
@@ -86,6 +160,11 @@ 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');

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;
@@ -90,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 = {
@@ -104,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),
   };
@@ -146,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
@@ -163,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
     );
@@ -200,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 } = {}) {
@@ -227,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) {
@@ -252,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`)
@@ -273,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`)
@@ -292,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,6 +127,8 @@ function createCognitiveTurnLifecycle({
           eventId,
           expectedVersion,
           occurredAt,
+          receivedAt: occurredAt,
+          retentionClass: 'operational',
           source: {
             provider: 'runtime',
             channel_id: 'runtime',
@@ -176,6 +178,8 @@ function createCognitiveTurnLifecycle({
           eventId,
           expectedVersion,
           occurredAt,
+          receivedAt: occurredAt,
+          retentionClass: 'durable',
           source: {
             provider: 'runtime',
             channel_id: 'runtime',
@@ -310,6 +314,7 @@ 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,
@@ -353,6 +358,8 @@ function createCognitiveTurnLifecycle({
           eventId,
           expectedVersion: current.version,
           occurredAt: normalizedOccurredAt,
+          receivedAt,
+          retentionClass: 'durable',
           source: normalizedSource,
           observations: [observation],
         }, revisionMemoryAccess);
@@ -466,7 +473,7 @@ function createCognitiveTurnLifecycle({
     const authorization = input?.authorization;
     const memoryAccess = {
       tenantId: tenant,
-      userId: String(candidate?.subject_id ?? ''),
+      userId: agent,
       actorId: agent,
       agentId: agent,
       portalId: 'cli',

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,6 +141,8 @@ function createPersonalityMemoryAdapter({ identityRoot, memoryAdapter } = {}) {
           eventId,
           expectedVersion: current.version,
           occurredAt: value.occurredAt,
+          receivedAt: value.receivedAt,
+          retentionClass: 'relationship',
           source: {
             provider: value.sourcePortal,
             channel_id: value.sourceChannel,

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.389",
+  "version": "9.1.391",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {