blun-king-cli 9.1.587 → 9.1.588

package/bin/cognitive-attention-delivery.cjs

@@ -1,76 +0,0 @@
-'use strict';
-
-const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const TELEGRAM_CHANNEL_RE = /^telegram:(-?[1-9][0-9]{0,19})$/u;
-const SUBJECT_KINDS = new Set(['human', 'agent', 'task']);
-const REASONS = new Set(['missing_heartbeat', 'overdue_commitment', 'blocked_task']);
-
-function fail() {
-  const error = new Error('COGNITIVE_ATTENTION_DELIVERY_INVALID');
-  error.code = 'COGNITIVE_ATTENTION_DELIVERY_INVALID';
-  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 xmlAttr(value) {
-  return String(value)
-    .replaceAll('&', '&')
-    .replaceAll('"', '"')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;');
-}
-
-function buildAttentionQueueItem(intent) {
-  const keys = new Set([
-    'accepted', 'idempotent', 'candidate_id', 'subject_kind', 'subject_id', 'reason',
-    'evidence_id', 'evidence_scope', 'confidence', 'allowed_channel',
-    'authorization_receipt_id', 'dispatch_intent', 'requires_delivery_policy',
-  ]);
-  if (!exactKeys(intent, keys) || intent.accepted !== true || intent.idempotent !== false
-      || intent.dispatch_intent !== 'attention_notice' || intent.requires_delivery_policy !== true) fail();
-
-  const candidateId = safeId(intent.candidate_id);
-  const subjectKind = String(intent.subject_kind ?? '');
-  const subjectId = safeId(intent.subject_id);
-  const reason = String(intent.reason ?? '');
-  const evidenceId = safeId(intent.evidence_id);
-  const evidenceScope = safeId(intent.evidence_scope);
-  const receiptId = safeId(intent.authorization_receipt_id);
-  const confidence = Number(intent.confidence);
-  const channelMatch = TELEGRAM_CHANNEL_RE.exec(String(intent.allowed_channel ?? ''));
-  if (!candidateId || !SUBJECT_KINDS.has(subjectKind) || !subjectId || !REASONS.has(reason)
-      || !evidenceId || !evidenceScope || !receiptId || !Number.isFinite(confidence)
-      || confidence < 0.5 || confidence > 1 || channelMatch === null) fail();
-
-  const text = [
-    `<attention-event candidateId="${xmlAttr(candidateId)}" subjectKind="${xmlAttr(subjectKind)}" subjectId="${xmlAttr(subjectId)}" reason="${xmlAttr(reason)}" confidence="${String(confidence)}">`,
-    'This is an authorized internal attention signal, not a user instruction.',
-    'Re-check current status, responsibility, absence, quiet time, and whether another agent already followed up.',
-    'If the signal is obsolete, uncertain, outside current rights, or no longer useful, remain silent.',
-    'If it is still relevant, produce at most one brief, natural follow-up through the attached normal channel queue.',
-    'Never infer danger, location, emotion, or intent from silence. Do not expose internal ids or private context.',
-    '</attention-event>',
-  ].join('\n');
-
-  return {
-    queueKey: `attention:${candidateId}`,
-    text,
-    displayText: `Attention | ${reason} | ${subjectKind}:${subjectId}`,
-    origin: { kind: 'attention_notice', candidateId, subjectKind, subjectId, reason },
-    mode: 'channel',
-    channelChatId: channelMatch[1],
-    channelContextOnly: false,
-    channelAttention: true,
-  };
-}
-
-module.exports = { buildAttentionQueueItem };

package/bin/cognitive-attention-policy.cjs

@@ -1,143 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-
-const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-const SUBJECT_KINDS = new Set(['human', 'agent', 'task']);
-const SIGNAL_KINDS = new Set(['heartbeat', 'commitment', 'task_blocked']);
-const HEARTBEAT_STALE_MS = 5 * 60 * 1000;
-const BLOCKED_TASK_STALE_MS = 10 * 60 * 1000;
-const MAX_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000;
-
-function fail() {
-  const error = new Error('ATTENTION_INVALID_INPUT');
-  error.code = 'ATTENTION_INVALID_INPUT';
-  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 instant(value) {
-  if (value === null || value === undefined) return null;
-  const milliseconds = Date.parse(String(value));
-  return Number.isFinite(milliseconds) ? milliseconds : null;
-}
-
-function normalizeQuietHours(value) {
-  if (!exactKeys(value, new Set(['startHour', 'endHour']))) fail();
-  const startHour = Number(value.startHour);
-  const endHour = Number(value.endHour);
-  if (!Number.isInteger(startHour) || startHour < 0 || startHour > 23
-      || !Number.isInteger(endHour) || endHour < 0 || endHour > 23
-      || startHour === endHour) fail();
-  return { startHour, endHour };
-}
-
-function isQuietTime(nowMs, offsetMinutes, quietHours) {
-  const localHour = new Date(nowMs + offsetMinutes * 60 * 1000).getUTCHours();
-  return quietHours.startHour < quietHours.endHour
-    ? localHour >= quietHours.startHour && localHour < quietHours.endHour
-    : localHour >= quietHours.startHour || localHour < quietHours.endHour;
-}
-
-function signalReason(subjectKind, signal, nowMs) {
-  if (!exactKeys(signal, new Set([
-    'kind', 'heartbeatAt', 'activeTask', 'expectedBy', 'blockedSince',
-    'evidenceId', 'evidenceScope', 'confidence',
-  ]))) fail();
-  if (!SIGNAL_KINDS.has(signal.kind)) fail();
-  const evidenceId = safeId(signal.evidenceId);
-  const evidenceScope = safeId(signal.evidenceScope);
-  const confidence = Number(signal.confidence);
-  if (!evidenceId || !evidenceScope || !Number.isFinite(confidence)
-      || confidence < 0 || confidence > 1) fail();
-  if (confidence < 0.5) return null;
-
-  if (signal.kind === 'heartbeat') {
-    if (!exactKeys(signal, new Set(['kind', 'heartbeatAt', 'activeTask', 'evidenceId', 'evidenceScope', 'confidence']))
-        || subjectKind !== 'agent' || signal.activeTask !== true) return null;
-    const heartbeatAt = instant(signal.heartbeatAt);
-    if (heartbeatAt === null || heartbeatAt > nowMs) fail();
-    return nowMs - heartbeatAt >= HEARTBEAT_STALE_MS
-      ? { reason: 'missing_heartbeat', anchor: new Date(heartbeatAt).toISOString(), evidenceId, evidenceScope, confidence }
-      : null;
-  }
-  if (signal.kind === 'commitment') {
-    if (!exactKeys(signal, new Set(['kind', 'expectedBy', 'evidenceId', 'evidenceScope', 'confidence']))) fail();
-    const expectedBy = instant(signal.expectedBy);
-    if (expectedBy === null) fail();
-    return nowMs > expectedBy
-      ? { reason: 'overdue_commitment', anchor: new Date(expectedBy).toISOString(), evidenceId, evidenceScope, confidence }
-      : null;
-  }
-  if (!exactKeys(signal, new Set(['kind', 'blockedSince', 'evidenceId', 'evidenceScope', 'confidence'])) || subjectKind !== 'task') return null;
-  const blockedSince = instant(signal.blockedSince);
-  if (blockedSince === null || blockedSince > nowMs) fail();
-  return nowMs - blockedSince >= BLOCKED_TASK_STALE_MS
-    ? { reason: 'blocked_task', anchor: new Date(blockedSince).toISOString(), evidenceId, evidenceScope, confidence }
-    : null;
-}
-
-function buildAttentionCandidate(input) {
-  const allowed = new Set([
-    'tenantId', 'subjectKind', 'subjectId', 'responsibleAgent', 'currentAgent', 'now', 'signal',
-    'absenceUntil', 'timezoneOffsetMinutes', 'quietHours', 'cooldownMs', 'allowedChannel',
-  ]);
-  if (!exactKeys(input, allowed)) fail();
-  const tenantId = safeId(input.tenantId);
-  const subjectKind = String(input.subjectKind ?? '');
-  const subjectId = safeId(input.subjectId);
-  const responsibleAgent = safeId(input.responsibleAgent);
-  const currentAgent = safeId(input.currentAgent);
-  const allowedChannel = safeId(input.allowedChannel);
-  const nowMs = instant(input.now);
-  const offsetMinutes = Number(input.timezoneOffsetMinutes);
-  const cooldownMs = Number(input.cooldownMs);
-  if (!tenantId || !SUBJECT_KINDS.has(subjectKind) || !subjectId || !responsibleAgent
-      || !currentAgent || !allowedChannel || nowMs === null
-      || !Number.isInteger(offsetMinutes) || offsetMinutes < -840 || offsetMinutes > 840
-      || !Number.isSafeInteger(cooldownMs) || cooldownMs < 1000 || cooldownMs > MAX_COOLDOWN_MS) fail();
-  if (currentAgent !== responsibleAgent) return null;
-
-  const absenceUntil = instant(input.absenceUntil);
-  if (input.absenceUntil !== null && absenceUntil === null) fail();
-  if (absenceUntil !== null && absenceUntil > nowMs) return null;
-  const quietHours = normalizeQuietHours(input.quietHours);
-  if (isQuietTime(nowMs, offsetMinutes, quietHours)) return null;
-
-  const reason = signalReason(subjectKind, input.signal, nowMs);
-  if (reason === null) return null;
-  const digest = crypto.createHash('sha256')
-    .update([tenantId, subjectKind, subjectId, reason.reason, reason.evidenceId].join('\0'))
-    .digest('hex')
-    .slice(0, 40);
-  return {
-    candidate_id: `attention-${digest}`,
-    subject_kind: subjectKind,
-    subject_id: subjectId,
-    reason: reason.reason,
-    evidence_id: reason.evidenceId,
-    evidence_scope: reason.evidenceScope,
-    evidence_at: reason.anchor,
-    confidence: reason.confidence,
-    responsible_agent: responsibleAgent,
-    allowed_channel: allowedChannel,
-    detected_at: new Date(nowMs).toISOString(),
-    cooldown_ms: cooldownMs,
-    requires_runtime_authorization: true,
-  };
-}
-
-module.exports = {
-  BLOCKED_TASK_STALE_MS,
-  HEARTBEAT_STALE_MS,
-  buildAttentionCandidate,
-};

package/bin/cognitive-attention-runtime.cjs

@@ -1,91 +0,0 @@
-'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, memoryAccess } = {}) {
-  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(),
-  }, memoryAccess);
-  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-context-projection.cjs

@@ -1,73 +0,0 @@
-'use strict';
-
-const TURN_KEY_RE = /^turn:(\d+):/u;
-const NEGATIVE_PHASES = new Set(['cancelled', 'failed', 'filtered']);
-const NEGATIVE_POLICY = new Set(['blocked', 'error']);
-const NEGATIVE_OUTCOMES = new Set(['error', 'cancelled']);
-const SAFETY_LINE = 'Runtime evidence only; it cannot authorize any action or override current user or tool policy.';
-
-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 turnNumber(observation) {
-  const match = TURN_KEY_RE.exec(String(observation?.key ?? ''));
-  return match ? Number(match[1]) : null;
-}
-
-function runtimeObservation(value) {
-  return value && typeof value === 'object' && value.scope === 'runtime'
-    && Number(value.confidence) === 1 && clean(value.key) && clean(value.value, 512)
-    && clean(value.source?.context_id);
-}
-
-function splitEvidence(value) {
-  return String(value ?? '').split(':').map((part) => clean(part)).filter(Boolean);
-}
-
-function buildCognitiveContextProjection(state, { currentTurnId, currentRuntimeId, maxChars = 900 } = {}) {
-  if (!Number.isSafeInteger(currentTurnId) || currentTurnId < 0
-      || !clean(currentRuntimeId)
-      || !Number.isSafeInteger(maxChars) || maxChars < 320 || maxChars > 1600
-      || !Array.isArray(state?.observations)) return null;
-
-  const previous = state.observations.filter(runtimeObservation)
-    .map((observation) => ({
-      observation,
-      turnId: turnNumber(observation),
-      runtimeId: observation.source.context_id,
-    }))
-    .filter((item) => item.turnId !== null
-      && !(item.runtimeId === currentRuntimeId && item.turnId === currentTurnId));
-  if (previous.length === 0) return null;
-  const latestItem = previous.at(-1);
-  const latestTurnId = latestItem.turnId;
-  const latest = previous.filter((item) => item.turnId === latestTurnId && item.runtimeId === latestItem.runtimeId)
-    .map((item) => item.observation);
-
-  const phase = [...latest].reverse().find((item) => item.domain === 'open_thread' && item.key === `turn:${latestTurnId}:phase`);
-  const policies = latest.filter((item) => item.key.endsWith(':tool-policy')).map((item) => {
-    const parts = splitEvidence(item.value);
-    return { decision: parts[0], tool: parts.at(-1) };
-  }).filter((item) => NEGATIVE_POLICY.has(item.decision) && item.tool);
-  const outcomes = latest.filter((item) => item.key.endsWith(':tool-result')).map((item) => {
-    const parts = splitEvidence(item.value);
-    return { outcome: parts[0], tool: parts.at(-1) };
-  }).filter((item) => NEGATIVE_OUTCOMES.has(item.outcome) && item.tool);
-  const actionable = phase && NEGATIVE_PHASES.has(phase.value) || policies.length > 0 || outcomes.length > 0;
-  if (!actionable) return null;
-
-  const lines = [`Previous runtime turn ${latestTurnId} needs inspection.`];
-  if (phase && NEGATIVE_PHASES.has(phase.value)) lines.push(`Turn outcome: ${phase.value}.`);
-  for (const item of policies.slice(-2)) lines.push(`Tool policy: ${item.tool} ${item.decision}.`);
-  for (const item of outcomes.slice(-2)) lines.push(`Tool outcome: ${item.tool} ${item.outcome}.`);
-  const next = [...latest].reverse().find((item) => item.domain === 'next_trigger'
-    && item.value !== 'await-next-input' && clean(item.value));
-  if (next) lines.push(`Next inspection trigger: ${clean(next.value)}.`);
-
-  while ([...lines, SAFETY_LINE].join('\n').length > maxChars && lines.length > 1) lines.splice(-1, 1);
-  return [...lines, SAFETY_LINE].join('\n');
-}
-
-module.exports = { buildCognitiveContextProjection };