blun-king-cli 9.1.310 → 9.1.311

package/bin/cognitive-attention-runtime.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
+const AUTHORITIES = new Set(['runtime_user_prompt_hook', 'runtime_tool_policy']);
+const RECEIPT_MAX_AGE_MS = 5 * 60 * 1000;
+
+function fail(code = 'COGNITIVE_ATTENTION_AUTH_INVALID') {
+  const error = new Error(code);
+  error.code = code;
+  throw error;
+}
+
+function exactKeys(value, keys) {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).every((key) => keys.has(key));
+}
+
+function safeId(value) {
+  const text = String(value ?? '').trim();
+  return SAFE_ID_RE.test(text) ? text : '';
+}
+
+function authorizeAttentionCandidate({ store, tenantId, currentAgent, now, input } = {}) {
+  if (!store || typeof store.authorizeAttention !== 'function' || typeof now !== 'function'
+      || !exactKeys(input, new Set(['candidate', 'channel', 'authorization']))) fail();
+  const tenant = safeId(tenantId);
+  const agent = safeId(currentAgent);
+  const channel = safeId(input.channel);
+  const candidate = input.candidate;
+  const authorization = input.authorization;
+  const candidateKeys = 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',
+  ]);
+  const authorizationKeys = new Set(['authority', 'decision', 'receiptId', 'scope', 'issuedAt']);
+  if (!tenant || !agent || !channel || !exactKeys(candidate, candidateKeys)
+      || !exactKeys(authorization, authorizationKeys)) fail();
+
+  const candidateId = safeId(candidate.candidate_id);
+  const responsibleAgent = safeId(candidate.responsible_agent);
+  const allowedChannel = safeId(candidate.allowed_channel);
+  const authority = String(authorization.authority ?? '');
+  const receiptId = safeId(authorization.receiptId);
+  const scope = String(authorization.scope ?? '');
+  const nowMs = Date.parse(String(now()));
+  const issuedAtMs = Date.parse(String(authorization.issuedAt ?? ''));
+  if (!candidateId || !responsibleAgent || responsibleAgent !== agent
+      || !allowedChannel || channel !== allowedChannel
+      || candidate.requires_runtime_authorization !== true
+      || !AUTHORITIES.has(authority) || authorization.decision !== 'passed'
+      || !receiptId || scope !== `attention:${candidateId}`
+      || !Number.isFinite(nowMs) || !Number.isFinite(issuedAtMs)
+      || issuedAtMs > nowMs || nowMs - issuedAtMs > RECEIPT_MAX_AGE_MS) fail();
+
+  const admitted = store.authorizeAttention({
+    tenantId: tenant,
+    candidate,
+    claimedBy: agent,
+    claimedAt: new Date(nowMs).toISOString(),
+    receiptId,
+    authority,
+    authorizedAt: new Date(issuedAtMs).toISOString(),
+  });
+  if (!admitted.claimed) {
+    return {
+      accepted: false,
+      reason: 'cooldown',
+      candidate_id: candidateId,
+      claimed_by: admitted.claimed_by,
+      next_allowed_at: admitted.next_allowed_at,
+    };
+  }
+  return {
+    accepted: true,
+    idempotent: admitted.idempotent === true,
+    candidate_id: candidateId,
+    subject_kind: candidate.subject_kind,
+    subject_id: candidate.subject_id,
+    reason: candidate.reason,
+    evidence_id: candidate.evidence_id,
+    evidence_scope: candidate.evidence_scope,
+    confidence: candidate.confidence,
+    allowed_channel: allowedChannel,
+    authorization_receipt_id: receiptId,
+    dispatch_intent: 'attention_notice',
+    requires_delivery_policy: true,
+  };
+}
+
+module.exports = { RECEIPT_MAX_AGE_MS, authorizeAttentionCandidate };

package/bin/cognitive-state-store.cjs

@@ -155,6 +155,17 @@ function initialize(db) {
       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)
+    );
   `);
 }
 
@@ -289,11 +300,84 @@ function openCognitiveStateStore({ home } = {}) {
     }
   }
 
+  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,
     read,
     verify,
     claimAttention,
+    authorizeAttention,
     close: () => {
       try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch {}
       db.close();

package/bin/cognitive-turn-lifecycle.cjs

@@ -4,6 +4,7 @@ const crypto = require('node:crypto');
 const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
 const { buildCognitiveContextProjection } = require('./cognitive-context-projection.cjs');
 const { buildCognitiveFocusProjection } = require('./cognitive-focus-projection.cjs');
+const { authorizeAttentionCandidate } = require('./cognitive-attention-runtime.cjs');
 
 const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
 const RIGHTS_AUTHORITIES = new Set(['runtime_user_prompt_hook', 'runtime_tool_policy']);
@@ -210,12 +211,23 @@ function createCognitiveTurnLifecycle({ home, tenantId, agentId, runtimeId, now
     return [focus, continuity].filter(Boolean).join('\n\n') || null;
   }
 
+  function authorizeAttention(input) {
+    return authorizeAttentionCandidate({
+      store,
+      tenantId: tenant,
+      currentAgent: agent,
+      now,
+      input,
+    });
+  }
+
   return {
     startTurn,
     recordRightsCheck,
     recordToolPolicy,
     recordToolResult,
     recordFocusSnapshot,
+    authorizeAttention,
     projectForTurn,
     endTurn,
     read: () => store.read({ tenantId: tenant, agentId: agent }),

package/package.json

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