blun-king-cli 9.1.587 → 9.1.588

package/bin/cognitive-salience-policy.cjs

@@ -1,159 +0,0 @@
-'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', 'knowledge_gap',
-  '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-state-store.cjs

@@ -1,508 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-const { DatabaseSync } = require('node:sqlite');
-
-const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const DOMAINS = new Set([
-  'self', 'world', 'team', 'goal', 'open_thread', 'assumption', 'knowledge_gap',
-  'next_trigger', 'expected_evidence',
-]);
-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;
-
-function fail(code) {
-  const error = new Error(code);
-  error.code = code;
-  throw error;
-}
-
-function safeId(value) {
-  const text = String(value ?? '').trim();
-  return SAFE_ID_RE.test(text) ? text : '';
-}
-
-function cleanText(value, max = 512) {
-  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
-  return text && text.length <= max ? text : '';
-}
-
-function hasForbiddenKey(value) {
-  if (!value || typeof value !== 'object') return false;
-  if (Array.isArray(value)) return value.some(hasForbiddenKey);
-  return Object.entries(value).some(([key, child]) => FORBIDDEN_KEY_RE.test(key) || hasForbiddenKey(child));
-}
-
-function exactKeys(value, keys) {
-  return value && typeof value === 'object' && !Array.isArray(value)
-    && Object.keys(value).every((key) => keys.has(key));
-}
-
-function normalizeSource(source) {
-  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),
-  };
-  if (Object.values(normalized).some((value) => !value)) fail('COGNITIVE_INVALID_EVENT');
-  return normalized;
-}
-
-function normalizeObservation(value) {
-  const allowed = new Set(['observation_id', 'domain', 'key', 'value', 'confidence', 'epistemic_state', 'scope', 'supersedes', 'withdraws']);
-  if (!exactKeys(value, allowed) || hasForbiddenKey(value)) fail('COGNITIVE_FORBIDDEN_FIELD');
-  const observation = {
-    observation_id: safeId(value.observation_id),
-    domain: String(value.domain ?? ''),
-    key: cleanText(value.key, 128),
-    value: cleanText(value.value, 2048),
-    confidence: Number(value.confidence),
-    epistemic_state: value.epistemic_state === undefined
-      ? 'legacy_unknown' : String(value.epistemic_state),
-    scope: cleanText(value.scope, 128),
-  };
-  if (!observation.observation_id || !DOMAINS.has(observation.domain) || !observation.key
-      || !observation.value || !Number.isFinite(observation.confidence)
-      || observation.confidence < 0 || observation.confidence > 1
-      || !EPISTEMIC_STATES.has(observation.epistemic_state) || !observation.scope) {
-    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');
-  }
-  if (value.withdraws !== undefined && value.withdraws !== null) {
-    observation.withdraws = safeId(value.withdraws);
-    if (!observation.withdraws || observation.confidence !== 1 || observation.value !== 'withdrawn') {
-      fail('COGNITIVE_INVALID_WITHDRAWAL');
-    }
-  }
-  if (observation.supersedes && observation.withdraws) fail('COGNITIVE_INVALID_EVENT');
-  return observation;
-}
-
-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 = {
-    tenant_id: tenantId,
-    agent_id: agentId,
-    event_id: eventId,
-    expected_version: expectedVersion,
-    occurred_at: new Date(occurredAt).toISOString(),
-    received_at: new Date(receivedAt).toISOString(),
-    retention_class: retentionClass,
-    source: normalizeSource(input.source),
-    observations: input.observations.map(normalizeObservation),
-  };
-  const ids = new Set(normalized.observations.map((item) => item.observation_id));
-  if (ids.size !== normalized.observations.length) fail('COGNITIVE_INVALID_EVENT');
-  const payload = JSON.stringify(normalized);
-  if (Buffer.byteLength(payload) > MAX_EVENT_BYTES) fail('COGNITIVE_INVALID_EVENT');
-  return { normalized, payload };
-}
-
-function ensureHome(home) {
-  const root = path.resolve(String(home ?? ''));
-  try {
-    const stat = fs.lstatSync(root);
-    if (!stat.isDirectory() || stat.isSymbolicLink()) fail('COGNITIVE_UNSAFE_HOME');
-    return fs.realpathSync(root);
-  } catch (error) {
-    if (error?.code === 'COGNITIVE_UNSAFE_HOME') throw error;
-    fail('COGNITIVE_UNSAFE_HOME');
-  }
-}
-
-function initialize(db) {
-  db.exec(`
-    PRAGMA foreign_keys = ON;
-    PRAGMA journal_mode = WAL;
-    PRAGMA busy_timeout = 5000;
-    CREATE TABLE IF NOT EXISTS cognitive_streams (
-      tenant_id TEXT NOT NULL,
-      agent_id TEXT NOT NULL,
-      version INTEGER NOT NULL,
-      updated_at TEXT NOT NULL,
-      PRIMARY KEY (tenant_id, agent_id)
-    );
-    CREATE TABLE IF NOT EXISTS cognitive_events (
-      event_id TEXT PRIMARY KEY,
-      tenant_id TEXT NOT NULL,
-      agent_id TEXT NOT NULL,
-      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
-    );
-    CREATE TABLE IF NOT EXISTS cognitive_observations (
-      observation_id TEXT PRIMARY KEY,
-      event_id TEXT NOT NULL REFERENCES cognitive_events(event_id),
-      tenant_id TEXT NOT NULL,
-      agent_id TEXT NOT NULL,
-      domain TEXT NOT NULL,
-      fact_key TEXT NOT NULL,
-      value_text TEXT NOT NULL,
-      confidence REAL NOT NULL,
-      epistemic_state TEXT NOT NULL DEFAULT 'legacy_unknown',
-      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
-    );
-    CREATE INDEX IF NOT EXISTS cognitive_observations_stream
-      ON cognitive_observations (tenant_id, agent_id, occurred_at, observation_id);
-    CREATE INDEX IF NOT EXISTS cognitive_observations_visibility
-      ON cognitive_observations (tenant_id, agent_id, scope, occurred_at, observation_id);
-    CREATE TABLE IF NOT EXISTS cognitive_attention_claims (
-      tenant_id TEXT NOT NULL,
-      candidate_id TEXT NOT NULL,
-      claimed_by TEXT NOT NULL,
-      claimed_at TEXT NOT NULL,
-      next_allowed_at TEXT NOT NULL,
-      PRIMARY KEY (tenant_id, candidate_id)
-    );
-    CREATE TABLE IF NOT EXISTS cognitive_attention_authorizations (
-      tenant_id TEXT NOT NULL,
-      receipt_id TEXT NOT NULL,
-      candidate_id TEXT NOT NULL,
-      authority TEXT NOT NULL,
-      authorized_at TEXT NOT NULL,
-      accepted INTEGER NOT NULL,
-      claimed_by TEXT NOT NULL,
-      next_allowed_at TEXT NOT NULL,
-      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');
-  }
-  if (!observationColumns.some((column) => column.name === 'withdraws_observation_id')) {
-    db.exec('ALTER TABLE cognitive_observations ADD COLUMN withdraws_observation_id TEXT');
-  }
-  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 } = {}) {
-  const root = ensureHome(home);
-  const stateRoot = path.join(root, 'state');
-  fs.mkdirSync(stateRoot, { recursive: true });
-  if (!fs.realpathSync(stateRoot).startsWith(`${root}${path.sep}`)) fail('COGNITIVE_UNSAFE_HOME');
-  const db = new DatabaseSync(path.join(stateRoot, 'cognitive-state.sqlite'));
-  initialize(db);
-
-  function commit(input) {
-    const { normalized, payload } = normalizeEvent(input);
-    const existing = db.prepare('SELECT payload_json, new_version, event_hash FROM cognitive_events WHERE event_id = ?').get(normalized.event_id);
-    if (existing) {
-      if (existing.payload_json !== payload) fail('COGNITIVE_EVENT_ID_REUSE');
-      return { version: existing.new_version, event_hash: existing.event_hash, idempotent: true };
-    }
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      const stream = db.prepare('SELECT version FROM cognitive_streams WHERE tenant_id = ? AND agent_id = ?').get(normalized.tenant_id, normalized.agent_id);
-      const actualVersion = Number(stream?.version ?? 0);
-      if (actualVersion !== normalized.expected_version) fail('COGNITIVE_VERSION_CONFLICT');
-      const previous = db.prepare('SELECT event_hash FROM cognitive_events WHERE tenant_id = ? AND agent_id = ? ORDER BY new_version DESC LIMIT 1').get(normalized.tenant_id, normalized.agent_id);
-      const previousHash = String(previous?.event_hash ?? '0'.repeat(64));
-      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, 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, 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) {
-          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');
-        }
-        if (observation.withdraws) {
-          const target = db.prepare(`SELECT tenant_id, agent_id, domain, fact_key, scope
-            FROM cognitive_observations WHERE observation_id = ?`).get(observation.withdraws);
-          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_WITHDRAWAL');
-        }
-        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, 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`)
-        .run(normalized.tenant_id, normalized.agent_id, newVersion, normalized.occurred_at);
-      db.exec('COMMIT');
-      return { version: newVersion, event_hash: eventHash };
-    } catch (error) {
-      try { db.exec('ROLLBACK'); } catch {}
-      throw error;
-    }
-  }
-
-  function read({ tenantId, agentId, visibilityScope } = {}) {
-    const tenant = safeId(tenantId);
-    const agent = safeId(agentId);
-    const requestedVisibility = visibilityScope === undefined ? '' : safeId(visibilityScope);
-    if (!tenant || !agent || (visibilityScope !== undefined && !requestedVisibility)) {
-      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, 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`)
-        .all(tenant, agent, requestedVisibility)
-      : db.prepare(`${select} WHERE tenant_id = ? AND agent_id = ? ORDER BY occurred_at, rowid`).all(tenant, agent);
-    return {
-      version: Number(stream?.version ?? 0),
-      ...(stream?.updated_at ? { updated_at: stream.updated_at } : {}),
-      observations: rows.map((row) => ({
-        observation_id: row.observation_id,
-        domain: row.domain,
-        key: row.fact_key,
-        value: row.value_text,
-        confidence: row.confidence,
-        epistemic_state: row.epistemic_state,
-        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,
-      })),
-    };
-  }
-
-  function hasEvent(input) {
-    if (input && typeof input === 'object' && !Array.isArray(input)) {
-      const keys = Object.keys(input);
-      const event = safeId(input.eventId);
-      const tenant = safeId(input.tenantId);
-      const agent = safeId(input.agentId);
-      const visibilityScope = safeId(input.visibilityScope);
-      if (keys.length !== 4
-          || !keys.every((key) => ['agentId', 'eventId', 'tenantId', 'visibilityScope'].includes(key))
-          || !event || !tenant || !agent || !visibilityScope) fail('COGNITIVE_INVALID_EVENT');
-      if (visibilityScope !== 'agent:memory') {
-        return Boolean(db.prepare(`SELECT 1 AS found FROM cognitive_events AS event
-          INNER JOIN cognitive_observations AS observation ON observation.event_id = event.event_id
-          WHERE event.event_id = ? AND event.tenant_id = ? AND event.agent_id = ? AND observation.scope = ?
-          LIMIT 1`).get(event, tenant, agent, visibilityScope));
-      }
-      return Boolean(db.prepare(`SELECT 1 AS found FROM cognitive_events
-        WHERE event_id = ? AND tenant_id = ? AND agent_id = ?`).get(event, tenant, agent));
-    }
-    const event = safeId(input);
-    if (!event) fail('COGNITIVE_INVALID_EVENT');
-    return Boolean(db.prepare('SELECT 1 AS found FROM cognitive_events WHERE event_id = ?').get(event));
-  }
-
-  function verify({ tenantId, agentId } = {}) {
-    const tenant = safeId(tenantId);
-    const agent = safeId(agentId);
-    if (!tenant || !agent) fail('COGNITIVE_INVALID_EVENT');
-    const rows = db.prepare(`SELECT payload_json, previous_hash, event_hash FROM cognitive_events
-      WHERE tenant_id = ? AND agent_id = ? ORDER BY new_version`).all(tenant, agent);
-    let previousHash = '0'.repeat(64);
-    for (const row of rows) {
-      const calculated = crypto.createHash('sha256').update(`${previousHash}\0${row.payload_json}`).digest('hex');
-      if (row.previous_hash !== previousHash || row.event_hash !== calculated) return { valid: false, events: rows.length };
-      previousHash = row.event_hash;
-    }
-    return { valid: true, events: rows.length, head_hash: previousHash };
-  }
-
-  function claimAttention(input) {
-    const allowedInput = new Set(['tenantId', 'candidate', 'claimedBy', 'claimedAt']);
-    const allowedCandidate = new Set([
-      'candidate_id', 'subject_kind', 'subject_id', 'reason', 'responsible_agent',
-      'evidence_id', 'evidence_scope', 'evidence_at', 'confidence', 'allowed_channel',
-      'detected_at', 'cooldown_ms', 'requires_runtime_authorization',
-    ]);
-    if (!exactKeys(input, allowedInput) || !exactKeys(input.candidate, allowedCandidate)
-        || hasForbiddenKey(input)) fail('COGNITIVE_FORBIDDEN_FIELD');
-    const tenant = safeId(input.tenantId);
-    const candidateId = safeId(input.candidate.candidate_id);
-    const claimedBy = safeId(input.claimedBy);
-    const claimedAtMs = Date.parse(String(input.claimedAt ?? ''));
-    const cooldownMs = Number(input.candidate.cooldown_ms);
-    if (!tenant || !candidateId || !claimedBy || !Number.isFinite(claimedAtMs)
-        || !Number.isSafeInteger(cooldownMs) || cooldownMs < 1000
-        || input.candidate.requires_runtime_authorization !== true) fail('COGNITIVE_INVALID_EVENT');
-    const claimedAt = new Date(claimedAtMs).toISOString();
-    const nextAllowedAt = new Date(claimedAtMs + cooldownMs).toISOString();
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      const existing = db.prepare(`SELECT claimed_by, next_allowed_at FROM cognitive_attention_claims
-        WHERE tenant_id = ? AND candidate_id = ?`).get(tenant, candidateId);
-      if (existing && Date.parse(existing.next_allowed_at) > claimedAtMs) {
-        db.exec('COMMIT');
-        return {
-          claimed: false,
-          claimed_by: existing.claimed_by,
-          next_allowed_at: existing.next_allowed_at,
-        };
-      }
-      db.prepare(`INSERT INTO cognitive_attention_claims
-        (tenant_id, candidate_id, claimed_by, claimed_at, next_allowed_at) VALUES (?, ?, ?, ?, ?)
-        ON CONFLICT(tenant_id, candidate_id) DO UPDATE SET
-          claimed_by = excluded.claimed_by,
-          claimed_at = excluded.claimed_at,
-          next_allowed_at = excluded.next_allowed_at`)
-        .run(tenant, candidateId, claimedBy, claimedAt, nextAllowedAt);
-      db.exec('COMMIT');
-      return { claimed: true, claimed_by: claimedBy, next_allowed_at: nextAllowedAt };
-    } catch (error) {
-      try { db.exec('ROLLBACK'); } catch {}
-      throw error;
-    }
-  }
-
-  function authorizeAttention(input) {
-    const allowedInput = new Set([
-      'tenantId', 'candidate', 'claimedBy', 'claimedAt', 'receiptId', 'authority', 'authorizedAt',
-    ]);
-    const allowedCandidate = new Set([
-      'candidate_id', 'subject_kind', 'subject_id', 'reason', 'responsible_agent',
-      'evidence_id', 'evidence_scope', 'evidence_at', 'confidence', 'allowed_channel',
-      'detected_at', 'cooldown_ms', 'requires_runtime_authorization',
-    ]);
-    if (!exactKeys(input, allowedInput) || !exactKeys(input.candidate, allowedCandidate)
-        || hasForbiddenKey({ candidate: input.candidate })) fail('COGNITIVE_FORBIDDEN_FIELD');
-    const tenant = safeId(input.tenantId);
-    const candidateId = safeId(input.candidate.candidate_id);
-    const claimedBy = safeId(input.claimedBy);
-    const receiptId = safeId(input.receiptId);
-    const authority = safeId(input.authority);
-    const claimedAtMs = Date.parse(String(input.claimedAt ?? ''));
-    const authorizedAtMs = Date.parse(String(input.authorizedAt ?? ''));
-    const cooldownMs = Number(input.candidate.cooldown_ms);
-    if (!tenant || !candidateId || !claimedBy || !receiptId || !authority
-        || !Number.isFinite(claimedAtMs) || !Number.isFinite(authorizedAtMs)
-        || !Number.isSafeInteger(cooldownMs) || cooldownMs < 1000
-        || input.candidate.requires_runtime_authorization !== true) fail('COGNITIVE_INVALID_EVENT');
-    const claimedAt = new Date(claimedAtMs).toISOString();
-    const authorizedAt = new Date(authorizedAtMs).toISOString();
-    const nextAllowedAt = new Date(claimedAtMs + cooldownMs).toISOString();
-    db.exec('BEGIN IMMEDIATE');
-    try {
-      const receipt = db.prepare(`SELECT candidate_id, accepted, claimed_by, next_allowed_at
-        FROM cognitive_attention_authorizations WHERE tenant_id = ? AND receipt_id = ?`).get(tenant, receiptId);
-      if (receipt) {
-        if (receipt.candidate_id !== candidateId) fail('COGNITIVE_ATTENTION_RECEIPT_REUSE');
-        db.exec('COMMIT');
-        return {
-          claimed: receipt.accepted === 1,
-          claimed_by: receipt.claimed_by,
-          next_allowed_at: receipt.next_allowed_at,
-          idempotent: true,
-        };
-      }
-      const existing = db.prepare(`SELECT claimed_by, next_allowed_at FROM cognitive_attention_claims
-        WHERE tenant_id = ? AND candidate_id = ?`).get(tenant, candidateId);
-      const accepted = !(existing && Date.parse(existing.next_allowed_at) > claimedAtMs);
-      const effectiveClaimedBy = accepted ? claimedBy : existing.claimed_by;
-      const effectiveNextAllowedAt = accepted ? nextAllowedAt : existing.next_allowed_at;
-      if (accepted) {
-        db.prepare(`INSERT INTO cognitive_attention_claims
-          (tenant_id, candidate_id, claimed_by, claimed_at, next_allowed_at) VALUES (?, ?, ?, ?, ?)
-          ON CONFLICT(tenant_id, candidate_id) DO UPDATE SET
-            claimed_by = excluded.claimed_by,
-            claimed_at = excluded.claimed_at,
-            next_allowed_at = excluded.next_allowed_at`)
-          .run(tenant, candidateId, claimedBy, claimedAt, nextAllowedAt);
-      }
-      db.prepare(`INSERT INTO cognitive_attention_authorizations
-        (tenant_id, receipt_id, candidate_id, authority, authorized_at, accepted, claimed_by, next_allowed_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(tenant, receiptId, candidateId, authority, authorizedAt, accepted ? 1 : 0,
-          effectiveClaimedBy, effectiveNextAllowedAt);
-      db.exec('COMMIT');
-      return {
-        claimed: accepted,
-        claimed_by: effectiveClaimedBy,
-        next_allowed_at: effectiveNextAllowedAt,
-        idempotent: false,
-      };
-    } catch (error) {
-      try { db.exec('ROLLBACK'); } catch {}
-      throw error;
-    }
-  }
-
-  return {
-    commit,
-    hasEvent,
-    read,
-    verify,
-    claimAttention,
-    authorizeAttention,
-    close: () => {
-      try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch {}
-      db.close();
-    },
-  };
-}
-
-module.exports = { openCognitiveStateStore };