blun-king-cli 9.1.587 → 9.1.588

package/bin/cognitive-memory-adapter.cjs

@@ -1,282 +0,0 @@
-'use strict';
-
-const { openCognitiveStateStore } = require('./cognitive-state-store.cjs');
-
-const COGNITIVE_MEMORY_ADAPTER_VERSION = 6;
-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_REQUIRED_KEYS = Object.freeze([
-  'actorId', 'agentId', 'channelId', 'conversationId', 'permissionContext',
-  'portalId', 'requestedScope', 'tenantId', 'userId',
-]);
-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',
-  'hasEvent',
-  'verify',
-  'claimAttention',
-  'authorizeAttention',
-  'close',
-]);
-
-function fail(code) {
-  const error = new Error(code);
-  error.code = code;
-  throw error;
-}
-
-function exactKeys(value, expected) {
-  return value && typeof value === 'object' && !Array.isArray(value)
-    && 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 (!requiredAndOptionalKeys(access, ACCESS_REQUIRED_KEYS, ACCESS_OPTIONAL_KEYS)
-      || !requiredAndOptionalKeys(
-        access.permissionContext,
-        PERMISSION_REQUIRED_KEYS,
-        PERMISSION_OPTIONAL_KEYS,
-      )) {
-    fail('COGNITIVE_MEMORY_ACCESS_INVALID');
-  }
-  const normalized = {
-    tenantId: safeId(access.tenantId),
-    userId: safeId(access.userId),
-    actorId: safeId(access.actorId),
-    agentId: safeId(access.agentId),
-    portalId: safeId(access.portalId),
-    channelId: safeId(access.channelId),
-    conversationId: safeId(access.conversationId),
-    requestedScope: safeId(access.requestedScope),
-    permissionContext: {
-      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
-      || !normalized.portalId || !normalized.channelId || !normalized.conversationId
-      || !normalized.requestedScope || !normalized.permissionContext.authority
-      || !normalized.permissionContext.receiptId) fail('COGNITIVE_MEMORY_ACCESS_INVALID');
-  if (normalized.permissionContext.decision !== 'passed') fail('COGNITIVE_MEMORY_ACCESS_DENIED');
-  const requestTenant = safeId(request?.tenantId);
-  const requestAgent = safeId(request?.agentId ?? request?.candidate?.responsible_agent ?? request?.claimedBy);
-  if (!requestTenant || !requestAgent
-      || 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);
-}
-
-function isInternalAgentAccess(access) {
-  return access.userId === access.agentId
-    && access.actorId === access.agentId
-    && access.portalId === 'cli'
-    && access.channelId === 'runtime'
-    && access.requestedScope === 'agent:memory'
-    && access.permissionContext.authority === 'runtime_internal'
-    && access.permissionContext.receiptId === access.conversationId;
-}
-
-function assertVisibleScope(scope, access) {
-  if (!isInternalAgentAccess(access) && safeId(scope) !== access.requestedScope) {
-    fail('COGNITIVE_MEMORY_VISIBILITY_DENIED');
-  }
-}
-
-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');
-  }
-}
-
-function projectReadableState(state, access) {
-  if (isInternalAgentAccess(access)) return state;
-  if (!state || typeof state !== 'object' || !Array.isArray(state.observations)) {
-    fail('COGNITIVE_MEMORY_ADAPTER_INVALID');
-  }
-  return {
-    ...state,
-    observations: state.observations.filter((item) => safeId(item?.scope) === access.requestedScope),
-  };
-}
-
-function assertCognitiveMemoryAdapter(adapter) {
-  if (!adapter || typeof adapter !== 'object' || Array.isArray(adapter)) {
-    fail('COGNITIVE_MEMORY_ADAPTER_INVALID');
-  }
-  if (adapter.contractVersion !== COGNITIVE_MEMORY_ADAPTER_VERSION) {
-    fail('COGNITIVE_MEMORY_ADAPTER_VERSION_UNSUPPORTED');
-  }
-  if (!KIND_RE.test(String(adapter.kind ?? ''))
-      || REQUIRED_METHODS.some((method) => typeof adapter[method] !== 'function')) {
-    fail('COGNITIVE_MEMORY_ADAPTER_INVALID');
-  }
-  return adapter;
-}
-
-function guardCognitiveMemoryAdapter(adapter) {
-  const raw = assertCognitiveMemoryAdapter(adapter);
-  const guarded = {
-    contractVersion: raw.contractVersion,
-    kind: raw.kind,
-    commit: (input, access) => {
-      const normalizedAccess = normalizeMemoryAccess(access, input);
-      assertCommitAccess(input, normalizedAccess);
-      return raw.commit(input, normalizedAccess);
-    },
-    read: (input, access) => {
-      const normalizedAccess = normalizeMemoryAccess(access, input);
-      return projectReadableState(raw.read(input, normalizedAccess), normalizedAccess);
-    },
-    hasEvent: (input, access) => {
-      if (!exactKeys(input, ['agentId', 'eventId', 'tenantId', 'visibilityScope'])
-          || !safeId(input.eventId) || !safeId(input.visibilityScope)) {
-        fail('COGNITIVE_MEMORY_ACCESS_INVALID');
-      }
-      const normalizedAccess = normalizeMemoryAccess(access, input);
-      assertVisibleScope(input.visibilityScope, normalizedAccess);
-      return raw.hasEvent(input, normalizedAccess);
-    },
-    verify: (input, access) => {
-      const normalizedAccess = normalizeMemoryAccess(access, input);
-      const result = raw.verify(input, normalizedAccess);
-      if (isInternalAgentAccess(normalizedAccess)) return result;
-      if (!result || typeof result.valid !== 'boolean') fail('COGNITIVE_MEMORY_ADAPTER_INVALID');
-      return { valid: result.valid };
-    },
-    claimAttention: (input, access) => {
-      const normalizedAccess = normalizeMemoryAccess(access, input);
-      assertVisibleScope(input?.candidate?.evidence_scope, normalizedAccess);
-      return raw.claimAttention(input, normalizedAccess);
-    },
-    authorizeAttention: (input, access) => {
-      const normalizedAccess = normalizeMemoryAccess(access, input);
-      assertVisibleScope(input?.candidate?.evidence_scope, normalizedAccess);
-      return raw.authorizeAttention(input, normalizedAccess);
-    },
-    close: () => raw.close(),
-  };
-  return Object.freeze(guarded);
-}
-
-function createLocalCognitiveMemoryAdapter({ home } = {}) {
-  const store = openCognitiveStateStore({ home });
-  return guardCognitiveMemoryAdapter({
-    contractVersion: COGNITIVE_MEMORY_ADAPTER_VERSION,
-    kind: 'local-cognitive-event-store',
-    commit: (input) => store.commit(input),
-    read: (input, access) => store.read({
-      ...input,
-      visibilityScope: isInternalAgentAccess(access) ? 'agent:memory' : access.requestedScope,
-    }),
-    hasEvent: (input) => store.hasEvent(input),
-    verify: (input) => store.verify(input),
-    claimAttention: (input) => store.claimAttention(input),
-    authorizeAttention: (input) => store.authorizeAttention(input),
-    close: () => store.close(),
-  });
-}
-
-function openCognitiveMemoryAdapter({ home, adapter } = {}) {
-  return adapter === undefined
-    ? createLocalCognitiveMemoryAdapter({ home })
-    : guardCognitiveMemoryAdapter(adapter);
-}
-
-module.exports = {
-  COGNITIVE_MEMORY_ADAPTER_VERSION,
-  REQUIRED_METHODS,
-  assertCognitiveMemoryAdapter,
-  createLocalCognitiveMemoryAdapter,
-  normalizeMemoryAccess,
-  openCognitiveMemoryAdapter,
-};

package/bin/cognitive-memory-command.cjs

@@ -1,293 +0,0 @@
-'use strict';
-
-const crypto = require('node:crypto');
-const { createRuntimeCognitiveTurnLifecycle } = require('./cognitive-turn-lifecycle.cjs');
-const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
-const {
-  renderCognitiveCrossPortalAcceptance,
-  runCognitiveCrossPortalAcceptance,
-} = require('./cognitive-cross-portal-acceptance.cjs');
-
-const FOCUS_DOMAINS = new Set(['self', 'team', 'goal', 'open_thread', 'next_trigger', 'expected_evidence']);
-const POSITIVE_ID_RE = /^[1-9]\d*$/u;
-const NUMERIC_CHAT_ID_RE = /^-?\d+$/u;
-
-function fail(code) {
-  const error = new Error(code);
-  error.code = code;
-  throw error;
-}
-
-function clean(value, max) {
-  const text = String(value ?? '').replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim();
-  return text && text.length <= max ? text : '';
-}
-
-function digestId(prefix, values) {
-  return `${prefix}-${crypto.createHash('sha256').update(values.join('\0')).digest('hex').slice(0, 40)}`;
-}
-
-function isCognitiveMemoryCommand(args) {
-  const action = String(args ?? '').trim().split(/\s+/u, 1)[0].toLowerCase();
-  return action === 'focus' || action === 'core' || action === 'correct'
-    || action === 'delete' || action === 'acceptance';
-}
-
-function parseCognitiveMemoryCommand(args) {
-  const text = String(args ?? '').trim();
-  if (text.toLowerCase() === 'focus') return { action: 'focus' };
-  if (/^core(?:\s+--json)?$/iu.test(text)) {
-    return { action: 'core', json: /\s+--json$/iu.test(text) };
-  }
-  if (/^acceptance(?:\s+--json)?$/iu.test(text)) {
-    return { action: 'acceptance', json: /\s+--json$/iu.test(text) };
-  }
-  const correction = /^correct\s+(\S+)\s+(.+)$/iu.exec(text);
-  if (correction) {
-    const target = clean(correction[1], 128);
-    const value = clean(correction[2], 512);
-    if (target && value) return { action: 'correct', target, value };
-  }
-  const deletion = /^delete\s+(\S+)$/iu.exec(text);
-  if (deletion) {
-    const target = clean(deletion[1], 128);
-    if (target) return { action: 'delete', target };
-  }
-  fail('COGNITIVE_COMMAND_USAGE');
-}
-
-function normalizeObservation(item, index) {
-  const domain = String(item?.domain ?? '');
-  const key = clean(item?.key, 128);
-  const value = clean(item?.value, 512);
-  const scope = clean(item?.scope, 128);
-  const observationId = clean(item?.observation_id, 128);
-  const supersedes = item?.supersedes == null ? null : clean(item.supersedes, 128);
-  const withdraws = item?.withdraws == null ? null : clean(item.withdraws, 128);
-  const confidence = Number(item?.confidence);
-  const occurredAt = Date.parse(String(item?.occurred_at ?? ''));
-  if (!FOCUS_DOMAINS.has(domain) || !key || !value || !scope || scope === 'runtime' || !observationId
-      || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || !Number.isFinite(occurredAt)) return null;
-  return {
-    domain,
-    key,
-    value,
-    scope,
-    observationId,
-    supersedes,
-    withdraws,
-    confidence,
-    occurredAt,
-    occurredAtIso: new Date(occurredAt).toISOString(),
-    source: item?.source,
-    index,
-  };
-}
-
-function normalizedFocusObservations(state) {
-  return (state?.observations ?? []).map(normalizeObservation).filter(Boolean);
-}
-
-function effectiveFocusObservations(state) {
-  const groups = new Map();
-  normalizedFocusObservations(state).forEach((normalized) => {
-    const groupKey = `${normalized.scope}\0${normalized.domain}\0${normalized.key}`;
-    const entries = groups.get(groupKey) ?? [];
-    entries.push(normalized);
-    groups.set(groupKey, entries);
-  });
-  const active = [];
-  for (const entries of groups.values()) {
-    const resolved = resolveCognitiveEvidenceGroup(entries);
-    if (resolved !== null) active.push(resolved);
-  }
-  return active.sort((left, right) => right.occurredAt - left.occurredAt
-    || left.domain.localeCompare(right.domain) || left.key.localeCompare(right.key));
-}
-
-function observationsVisibleToSource(items, telegram) {
-  if (telegram === null) return items;
-  return items.filter((item) => !item.scope.startsWith('relationship:')
-    || item.scope === telegram.relationshipScope);
-}
-
-function resolveTarget(items, selector) {
-  const exact = items.find((item) => item.observationId === selector);
-  if (exact) return exact;
-  const matches = selector.length < 6 ? [] : items.filter((item) => item.observationId.startsWith(selector));
-  if (matches.length === 1) return matches[0];
-  if (matches.length > 1) fail('COGNITIVE_COMMAND_TARGET_AMBIGUOUS');
-  fail('COGNITIVE_COMMAND_TARGET_INACTIVE');
-}
-
-function matchesRevisionReplay(items, target, command, commandSource) {
-  return items.some((item) => {
-    const linked = command.action === 'correct'
-      ? item.supersedes === target.observationId && item.value === command.value
-      : 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
-      && item.occurredAtIso === commandSource.occurredAt;
-  });
-}
-
-function normalizeTelegramSource(source) {
-  if (source === undefined) return null;
-  const userId = String(source?.userId ?? '').trim();
-  const chatId = String(source?.chatId ?? '').trim();
-  const messageId = String(source?.messageId ?? '').trim();
-  if (!POSITIVE_ID_RE.test(userId) || !NUMERIC_CHAT_ID_RE.test(chatId) || !POSITIVE_ID_RE.test(messageId)) {
-    fail('COGNITIVE_COMMAND_SOURCE_INVALID');
-  }
-  if (userId !== chatId) fail('COGNITIVE_COMMAND_PRIVATE_REQUIRED');
-  const occurredAt = String(source?.occurredAt ?? '').trim();
-  const timestamp = Number.isNaN(Date.parse(occurredAt)) ? null : new Date(occurredAt).toISOString();
-  return {
-    requestId: digestId('tgrequest', [userId, chatId, messageId]),
-    occurredAt: timestamp,
-    relationshipScope: `relationship:telegram-${userId}:private`,
-    source: {
-      provider: 'telegram',
-      channelId: 'direct',
-      actorId: `tg_user_${userId}`,
-      contextId: `tg_chat_${chatId}`,
-      messageId: `tg_message_${messageId}`,
-    },
-  };
-}
-
-function assertPrivateTelegramMemorySource(source) {
-  normalizeTelegramSource(source);
-}
-
-function localSource({ env, sessionId, occurredAt, nonce }) {
-  const actor = clean(env.USERNAME ?? env.USER ?? 'local_user', 48).replace(/[^A-Za-z0-9._:-]+/gu, '_') || 'local_user';
-  const session = clean(sessionId, 96) || 'local_session';
-  const unique = clean(nonce, 96) || crypto.randomUUID();
-  return {
-    requestId: digestId('clirequest', [actor, session, unique]),
-    occurredAt,
-    source: {
-      provider: 'cli',
-      channelId: 'terminal',
-      actorId: digestId('localuser', [actor]),
-      contextId: digestId('clisession', [session]),
-      messageId: digestId('cliinput', [unique]),
-    },
-  };
-}
-
-function openLifecycle(env, lifecycleFactory) {
-  const home = String(env.BLUN_HOME ?? '').trim();
-  const agentName = String(env.BLUN_AGENT_ID ?? env.BLUN_PROFILE ?? 'main').trim();
-  if (!home || !agentName) fail('COGNITIVE_COMMAND_RUNTIME_INVALID');
-  return lifecycleFactory({
-    home,
-    agentName,
-    ...(env.BLUN_IDENTITY_TENANT_ID === undefined ? {} : { tenantId: env.BLUN_IDENTITY_TENANT_ID }),
-    ...(env.BLUN_AGENT_ID === undefined ? {} : { agentId: env.BLUN_AGENT_ID }),
-  });
-}
-
-function formatFocus(items) {
-  if (items.length === 0) return '/memory focus (0)';
-  const selected = items.slice(0, 8);
-  const lines = selected.map((item) => `${item.observationId} | ${item.domain}:${item.key.slice(0, 64)} | ${item.scope.slice(0, 64)} | ${item.value.slice(0, 160)}`);
-  const suffix = items.length > selected.length ? `\n... ${items.length - selected.length} more` : '';
-  return `/memory focus (${items.length})\n${lines.join('\n')}${suffix}`;
-}
-
-function formatCore(status) {
-  const state = status.crossPortal.status === 'blocked-profile-local'
-    ? 'LOCAL_ONLY'
-    : status.crossPortal.status === 'blocked-profile-derived-identity'
-      ? 'IDENTITY_BLOCKED' : 'CONFIGURED_UNVERIFIED';
-  const crossPortal = status.crossPortal.status === 'blocked-profile-local'
-    ? 'BLOCKED profile-local fallback'
-    : status.crossPortal.status === 'blocked-profile-derived-identity'
-      ? 'BLOCKED profile-derived identity'
-      : 'UNVERIFIED configured provider';
-  return [
-    `/memory core ${state}`,
-    `adapter: ${status.adapter.kind} (contract ${status.adapter.contractVersion})`,
-    `identity: ${status.identity.mode}`,
-    `integrity: ${status.integrity.valid ? 'PASS' : 'FAIL'}`,
-    `cross-portal: ${crossPortal}; evidence ${status.crossPortal.evidence}`,
-  ].join('\n');
-}
-
-function runCognitiveMemoryCommand({
-  args,
-  env = process.env,
-  channelSource,
-  sessionId,
-  now = () => new Date().toISOString(),
-  nonce,
-  lifecycleFactory = createRuntimeCognitiveTurnLifecycle,
-} = {}) {
-  const command = parseCognitiveMemoryCommand(args);
-  if (command.action === 'acceptance') {
-    const report = runCognitiveCrossPortalAcceptance();
-    return command.json ? JSON.stringify(report) : renderCognitiveCrossPortalAcceptance(report);
-  }
-  const telegram = normalizeTelegramSource(channelSource);
-  const lifecycle = openLifecycle(env, lifecycleFactory);
-  try {
-    if (command.action === 'core') {
-      const status = lifecycle.memoryStatus();
-      return command.json ? JSON.stringify(status) : formatCore(status);
-    }
-    const state = lifecycle.read();
-    const all = observationsVisibleToSource(normalizedFocusObservations(state), telegram);
-    const active = observationsVisibleToSource(effectiveFocusObservations(state), telegram);
-    if (command.action === 'focus') return formatFocus(active);
-    const occurredAt = String(now());
-    if (Number.isNaN(Date.parse(occurredAt))) fail('COGNITIVE_COMMAND_RUNTIME_INVALID');
-    const commandSource = telegram ?? localSource({
-      env,
-      sessionId,
-      occurredAt: new Date(occurredAt).toISOString(),
-      nonce,
-    });
-    if (commandSource.occurredAt === null) commandSource.occurredAt = new Date(occurredAt).toISOString();
-    const selected = resolveTarget(all, command.target);
-    const target = active.find((item) => item.observationId === selected.observationId);
-    if (target === undefined) {
-      if (matchesRevisionReplay(all, selected, command, commandSource)) {
-        const verb = command.action === 'correct' ? 'corrected' : 'deleted';
-        return `/memory ${verb} ${selected.observationId} (already applied)`;
-      }
-      fail('COGNITIVE_COMMAND_TARGET_INACTIVE');
-    }
-    const common = {
-      requestId: commandSource.requestId,
-      targetObservationId: target.observationId,
-      domain: target.domain,
-      key: target.key,
-      scope: target.scope,
-      authority: 'runtime_user_prompt_hook',
-      confirmation: 'explicit_user_request',
-      occurredAt: commandSource.occurredAt,
-      source: commandSource.source,
-    };
-    const result = command.action === 'correct'
-      ? lifecycle.correctFocusObservation({ ...common, value: command.value })
-      : lifecycle.withdrawFocusObservation(common);
-    const verb = command.action === 'correct' ? 'corrected' : 'deleted';
-    return `/memory ${verb} ${target.observationId}${result.idempotent ? ' (already applied)' : ''}`;
-  } finally {
-    lifecycle.close();
-  }
-}
-
-module.exports = {
-  assertPrivateTelegramMemorySource,
-  effectiveFocusObservations,
-  isCognitiveMemoryCommand,
-  parseCognitiveMemoryCommand,
-  runCognitiveMemoryCommand,
-};

package/bin/cognitive-memory-provider.cjs

@@ -1,92 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const {
-  COGNITIVE_MEMORY_ADAPTER_VERSION,
-  assertCognitiveMemoryAdapter,
-} = require('./cognitive-memory-adapter.cjs');
-
-const PROVIDER_ENV = 'BLUN_COGNITIVE_MEMORY_ADAPTER_MODULE';
-const SAFE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u;
-
-function fail(code) {
-  const error = new Error(code);
-  error.code = code;
-  throw error;
-}
-
-function canonicalFile(input) {
-  const configured = String(input ?? '').trim();
-  if (!configured || !path.isAbsolute(configured)) fail('COGNITIVE_MEMORY_PROVIDER_PATH_INVALID');
-  const resolved = path.resolve(configured);
-  let stat;
-  let canonical;
-  try {
-    stat = fs.lstatSync(resolved);
-    canonical = fs.realpathSync(resolved);
-  } catch {
-    fail('COGNITIVE_MEMORY_PROVIDER_PATH_INVALID');
-  }
-  if (!stat.isFile() || stat.isSymbolicLink()
-      || path.normalize(canonical).toLowerCase() !== path.normalize(resolved).toLowerCase()) {
-    fail('COGNITIVE_MEMORY_PROVIDER_PATH_INVALID');
-  }
-  return canonical;
-}
-
-function boundedContext({ home, tenantId, agentId, agentName }) {
-  const tenant = String(tenantId ?? '').trim();
-  const agent = String(agentId ?? '').trim();
-  const name = String(agentName ?? '').trim();
-  let canonicalHome;
-  try {
-    const stat = fs.lstatSync(path.resolve(String(home ?? '')));
-    canonicalHome = fs.realpathSync(path.resolve(String(home ?? '')));
-    if (!stat.isDirectory() || stat.isSymbolicLink()) fail('COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID');
-  } catch (error) {
-    if (error?.code === 'COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID') throw error;
-    fail('COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID');
-  }
-  if (!SAFE_ID_RE.test(tenant) || !SAFE_ID_RE.test(agent) || !name || name.length > 128
-      || /[\u0000-\u001f\u007f]/u.test(name)) {
-    fail('COGNITIVE_MEMORY_PROVIDER_CONTEXT_INVALID');
-  }
-  return Object.freeze({
-    contractVersion: COGNITIVE_MEMORY_ADAPTER_VERSION,
-    home: canonicalHome,
-    tenantId: tenant,
-    agentId: agent,
-    agentName: name,
-  });
-}
-
-function loadConfiguredCognitiveMemoryAdapter({
-  modulePath,
-  env = process.env,
-  home,
-  tenantId,
-  agentId,
-  agentName,
-} = {}) {
-  const configured = modulePath === undefined ? env?.[PROVIDER_ENV] : modulePath;
-  if (!String(configured ?? '').trim()) return undefined;
-  const providerPath = canonicalFile(configured);
-  const provider = require(providerPath);
-  if (!provider || typeof provider.createCognitiveMemoryAdapter !== 'function') {
-    fail('COGNITIVE_MEMORY_PROVIDER_FACTORY_REQUIRED');
-  }
-  const adapter = provider.createCognitiveMemoryAdapter(boundedContext({
-    home,
-    tenantId,
-    agentId,
-    agentName,
-  }));
-  if (adapter && typeof adapter.then === 'function') fail('COGNITIVE_MEMORY_PROVIDER_ASYNC_UNSUPPORTED');
-  return assertCognitiveMemoryAdapter(adapter);
-}
-
-module.exports = {
-  PROVIDER_ENV,
-  loadConfiguredCognitiveMemoryAdapter,
-};