blun-king-cli 9.1.425 → 9.1.426

package/bin/cognitive-cross-portal-acceptance.cjs

@@ -0,0 +1,443 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { openCognitiveMemoryAdapter } = require('./cognitive-memory-adapter.cjs');
+const { resolveCognitiveEvidenceGroup } = require('./cognitive-effective-view.cjs');
+const { loadConfiguredCognitiveMemoryAdapter } = require('./cognitive-memory-provider.cjs');
+
+const PACKAGE_VERSION = require('../package.json').version;
+const SCHEMA = 'blun.cognitive-cross-portal-acceptance/v1';
+const FIXED_TIME = '2031-04-05T09:00:00.000Z';
+const TENANT_ID = 'tenant-v7';
+const AGENT_ID = 'nova';
+const USER_ID = 'mayk';
+const PRIVATE_SCOPE = `relationship:${USER_ID}:private`;
+
+function digest(value) {
+  return crypto.createHash('sha256').update(String(value)).digest('hex');
+}
+
+function requireCondition(condition, code) {
+  if (!condition) {
+    const error = new Error(code);
+    error.code = code;
+    throw error;
+  }
+}
+
+function addCheck(checks, id, detail, evidence) {
+  checks.push({
+    id,
+    status: 'PASS',
+    detail,
+    receipt: digest(`${SCHEMA}\0${id}\0${JSON.stringify(evidence)}`),
+  });
+}
+
+function identityLink({ portalId, actorId, method, authority, receiptId }) {
+  return {
+    version: 1,
+    tenantId: TENANT_ID,
+    canonicalUserId: USER_ID,
+    sourcePortal: portalId,
+    sourceSubjectId: actorId,
+    method,
+    status: 'active',
+    confirmedAt: FIXED_TIME,
+    authority,
+    receiptId,
+  };
+}
+
+function linkedAccess({ portalId, actorId, channelId, conversationId, method, authority, receiptId }) {
+  return {
+    tenantId: TENANT_ID,
+    userId: USER_ID,
+    actorId,
+    agentId: AGENT_ID,
+    portalId,
+    channelId,
+    conversationId,
+    requestedScope: PRIVATE_SCOPE,
+    permissionContext: {
+      authority: 'runtime_user_prompt_hook',
+      decision: 'passed',
+      receiptId: `operation-${receiptId}`,
+      identityReceiptId: receiptId,
+    },
+    identityLink: identityLink({ portalId, actorId, method, authority, receiptId }),
+  };
+}
+
+function directAccess({ agentId = AGENT_ID, userId, portalId, channelId, conversationId, requestedScope }) {
+  return {
+    tenantId: TENANT_ID,
+    userId,
+    actorId: userId,
+    agentId,
+    portalId,
+    channelId,
+    conversationId,
+    requestedScope,
+    permissionContext: {
+      authority: 'runtime_user_prompt_hook',
+      decision: 'passed',
+      receiptId: `operation-${conversationId}`,
+    },
+  };
+}
+
+function event({
+  agentId = AGENT_ID,
+  eventId,
+  expectedVersion,
+  occurredAt,
+  source,
+  observationId,
+  domain = 'open_thread',
+  key,
+  value,
+  scope,
+  supersedes,
+  withdraws,
+  retentionClass = 'relationship',
+}) {
+  return {
+    tenantId: TENANT_ID,
+    agentId,
+    eventId,
+    expectedVersion,
+    occurredAt,
+    receivedAt: occurredAt,
+    retentionClass,
+    source,
+    observations: [{
+      observation_id: observationId,
+      domain,
+      key,
+      value,
+      confidence: 1,
+      epistemic_state: 'verified',
+      scope,
+      ...(supersedes ? { supersedes } : {}),
+      ...(withdraws ? { withdraws } : {}),
+    }],
+  };
+}
+
+function effectiveObservation(items, key, scope) {
+  const entries = items
+    .filter((item) => item.key === key && item.scope === scope)
+    .map((item, index) => ({
+      ...item,
+      observationId: item.observation_id,
+      occurredAt: Date.parse(item.occurred_at),
+      index,
+    }));
+  return resolveCognitiveEvidenceGroup(entries);
+}
+
+function sourceHashes(root, files) {
+  return Object.fromEntries(files.map((name) => [
+    name,
+    digest(fs.readFileSync(path.join(root, name))),
+  ]));
+}
+
+function renderCognitiveCrossPortalAcceptance(report) {
+  const lines = [`/memory acceptance ${report.ok ? 'PASS' : 'FAIL'} ${report.passed}/${report.total}`];
+  for (const check of report.checks) {
+    lines.push(`${check.id} ${check.status} receipt=${check.receipt.slice(0, 16)}`);
+  }
+  lines.push(`receipt=${report.receiptDigest}`);
+  lines.push('synthetic temporary state; evidence only; grants no authority');
+  return lines.join('\n');
+}
+
+function runCognitiveCrossPortalAcceptance() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'blun-v7-cross-portal-'));
+  const protectedFiles = ['SOUL.md', 'identity/manifest.json'];
+  let adapter;
+  try {
+    fs.mkdirSync(path.join(root, 'identity'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'SOUL.md'), '# Nova\n\nWarm, precise, and honest.\n', 'utf8');
+    fs.writeFileSync(path.join(root, 'identity', 'manifest.json'), `${JSON.stringify({
+      version: 1,
+      tenant_id: TENANT_ID,
+      active_agent_id: AGENT_ID,
+    })}\n`, 'utf8');
+    const before = sourceHashes(root, protectedFiles);
+    adapter = openCognitiveMemoryAdapter({ home: root });
+    const checks = [];
+
+    const telegram = linkedAccess({
+      portalId: 'telegram',
+      actorId: 'telegram-42',
+      channelId: 'direct',
+      conversationId: 'dm-42',
+      method: 'explicit_confirmed',
+      authority: 'identity_confirmation_service',
+      receiptId: 'identity-telegram-42',
+    });
+    const web = linkedAccess({
+      portalId: 'web',
+      actorId: 'oauth-77',
+      channelId: 'chat',
+      conversationId: 'web-chat-77',
+      method: 'verified_oauth',
+      authority: 'oauth_verifier',
+      receiptId: 'identity-oauth-77',
+    });
+    const cli = linkedAccess({
+      portalId: 'cli',
+      actorId: 'cli-profile-7',
+      channelId: 'terminal',
+      conversationId: 'cli-session-7',
+      method: 'secure_account_link',
+      authority: 'account_link_service',
+      receiptId: 'identity-cli-profile-7',
+    });
+    const initialEvent = event({
+      eventId: 'event-telegram-topic',
+      expectedVersion: 0,
+      occurredAt: '2031-04-05T09:01:00.000Z',
+      source: {
+        provider: 'telegram',
+        channel_id: 'direct',
+        actor_id: 'telegram-42',
+        context_id: 'dm-42',
+        message_id: 'telegram-message-1',
+      },
+      observationId: 'observation-shared-topic-v1',
+      key: 'shared-topic',
+      value: 'continue after the measured result',
+      scope: PRIVATE_SCOPE,
+    });
+    const firstCommit = adapter.commit(initialEvent, telegram);
+    const fromWeb = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    const webTopic = fromWeb.observations.find((item) => item.observation_id === 'observation-shared-topic-v1');
+    requireCondition(webTopic?.source?.provider === 'telegram'
+      && webTopic.source.channel_id === 'direct', 'ACCEPTANCE_PORTAL_PROVENANCE_FAILED');
+    addCheck(checks, 'portal-provenance', 'Telegram provenance remains visible after a Web read.', [
+      webTopic.source.provider,
+      webTopic.source.channel_id,
+      webTopic.source.message_id,
+    ]);
+
+    const fromCli = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, cli);
+    requireCondition(fromWeb.observations.length === 1 && fromCli.observations.length === 1,
+      'ACCEPTANCE_LINKED_IDENTITY_FAILED');
+    addCheck(checks, 'linked-identity', 'One confirmed identity reads the same memory in Web and CLI.', [
+      fromWeb.observations[0].observation_id,
+      fromCli.observations[0].observation_id,
+    ]);
+
+    const unlinkedWeb = directAccess({
+      userId: 'oauth-77',
+      portalId: 'web',
+      channelId: 'chat',
+      conversationId: 'web-chat-unlinked',
+      requestedScope: 'relationship:oauth-77:private',
+    });
+    const unlinked = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, unlinkedWeb);
+    requireCondition(unlinked.observations.length === 0, 'ACCEPTANCE_UNLINKED_ISOLATION_FAILED');
+    addCheck(checks, 'unlinked-isolation', 'A similarly named but unlinked Web identity sees no private memory.', 0);
+
+    const atlasAccess = directAccess({
+      agentId: 'atlas',
+      userId: 'atlas-user',
+      portalId: 'cli',
+      channelId: 'terminal',
+      conversationId: 'atlas-session',
+      requestedScope: 'user:atlas-user:private',
+    });
+    adapter.commit(event({
+      agentId: 'atlas',
+      eventId: 'event-atlas-only',
+      expectedVersion: 0,
+      occurredAt: '2031-04-05T09:02:00.000Z',
+      source: {
+        provider: 'cli',
+        channel_id: 'terminal',
+        actor_id: 'atlas-user',
+        context_id: 'atlas-session',
+        message_id: 'atlas-message-1',
+      },
+      observationId: 'observation-atlas-only',
+      key: 'agent-only',
+      value: 'atlas private state',
+      scope: 'user:atlas-user:private',
+    }), atlasAccess);
+    requireCondition(adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web)
+      .observations.every((item) => item.observation_id !== 'observation-atlas-only'),
+    'ACCEPTANCE_AGENT_ISOLATION_FAILED');
+    addCheck(checks, 'agent-isolation', 'A second agent stream remains outside Nova private reads.', 'atlas');
+
+    const nordAccess = directAccess({
+      userId: 'nord-member',
+      portalId: 'web',
+      channelId: 'group',
+      conversationId: 'group-nord',
+      requestedScope: 'team:nord',
+    });
+    const solAccess = directAccess({
+      userId: 'sol-member',
+      portalId: 'web',
+      channelId: 'group',
+      conversationId: 'group-sol',
+      requestedScope: 'team:sol',
+    });
+    adapter.commit(event({
+      eventId: 'event-nord-blocker',
+      expectedVersion: 1,
+      occurredAt: '2031-04-05T09:03:00.000Z',
+      source: {
+        provider: 'web',
+        channel_id: 'group',
+        actor_id: 'nord-member',
+        context_id: 'group-nord',
+        message_id: 'nord-message-1',
+      },
+      observationId: 'observation-nord-blocker',
+      domain: 'team',
+      key: 'group-blocker',
+      value: 'nord synthetic blocker',
+      scope: 'team:nord',
+      retentionClass: 'operational',
+    }), nordAccess);
+    const nord = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, nordAccess);
+    const sol = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, solAccess);
+    requireCondition(nord.observations.length === 1 && sol.observations.length === 0,
+      'ACCEPTANCE_GROUP_ISOLATION_FAILED');
+    addCheck(checks, 'group-isolation', 'The Nord scope receives its blocker while the Sol scope remains empty.', [
+      nord.observations[0].observation_id,
+      sol.observations.length,
+    ]);
+
+    const replay = adapter.commit(initialEvent, telegram);
+    requireCondition(replay.idempotent === true && replay.version === firstCommit.version,
+      'ACCEPTANCE_DEDUPLICATION_FAILED');
+    addCheck(checks, 'deduplication', 'Replaying the same portal event creates no second memory event.', [
+      replay.version,
+      replay.idempotent,
+    ]);
+
+    adapter.commit(event({
+      eventId: 'event-web-correction',
+      expectedVersion: 2,
+      occurredAt: '2031-04-05T09:04:00.000Z',
+      source: {
+        provider: 'web',
+        channel_id: 'chat',
+        actor_id: 'oauth-77',
+        context_id: 'web-chat-77',
+        message_id: 'web-message-2',
+      },
+      observationId: 'observation-shared-topic-v2',
+      key: 'shared-topic',
+      value: 'continue after the verified result',
+      scope: PRIVATE_SCOPE,
+      supersedes: 'observation-shared-topic-v1',
+    }), web);
+    const correctedCli = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, cli);
+    const corrected = effectiveObservation(correctedCli.observations, 'shared-topic', PRIVATE_SCOPE);
+    requireCondition(corrected?.value === 'continue after the verified result'
+      && corrected.supersedes === 'observation-shared-topic-v1', 'ACCEPTANCE_GLOBAL_CORRECTION_FAILED');
+    addCheck(checks, 'global-correction', 'A Web correction becomes the effective CLI value and keeps history.', [
+      corrected.observationId,
+      corrected.supersedes,
+      correctedCli.observations.length,
+    ]);
+
+    adapter.commit(event({
+      eventId: 'event-cli-deletion',
+      expectedVersion: 3,
+      occurredAt: '2031-04-05T09:05:00.000Z',
+      source: {
+        provider: 'cli',
+        channel_id: 'terminal',
+        actor_id: 'cli-profile-7',
+        context_id: 'cli-session-7',
+        message_id: 'cli-message-3',
+      },
+      observationId: 'observation-shared-topic-deleted',
+      key: 'shared-topic',
+      value: 'withdrawn',
+      scope: PRIVATE_SCOPE,
+      withdraws: 'observation-shared-topic-v2',
+    }), cli);
+    const deletedWeb = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    requireCondition(effectiveObservation(deletedWeb.observations, 'shared-topic', PRIVATE_SCOPE) === null
+      && deletedWeb.observations.some((item) => item.withdraws === 'observation-shared-topic-v2'),
+    'ACCEPTANCE_GLOBAL_DELETION_FAILED');
+    addCheck(checks, 'global-deletion', 'A CLI deletion removes the active Web value while retaining its tombstone.', [
+      deletedWeb.observations.length,
+      'observation-shared-topic-deleted',
+    ]);
+
+    const beforeProviderFailure = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    let providerError = '';
+    try {
+      loadConfiguredCognitiveMemoryAdapter({
+        modulePath: path.join(root, 'missing-provider.cjs'),
+        home: root,
+        tenantId: TENANT_ID,
+        agentId: AGENT_ID,
+        agentName: 'Nova',
+      });
+    } catch (error) {
+      providerError = error?.code ?? '';
+    }
+    const afterProviderFailure = adapter.read({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    requireCondition(providerError === 'COGNITIVE_MEMORY_PROVIDER_PATH_INVALID'
+      && JSON.stringify(beforeProviderFailure) === JSON.stringify(afterProviderFailure),
+    'ACCEPTANCE_PROVIDER_FAIL_CLOSED_FAILED');
+    addCheck(checks, 'provider-fail-closed', 'An unavailable provider fails before changing the existing memory stream.', [
+      providerError,
+      afterProviderFailure.version,
+    ]);
+
+    const after = sourceHashes(root, protectedFiles);
+    const novaVerification = adapter.verify({ tenantId: TENANT_ID, agentId: AGENT_ID }, web);
+    const atlasVerification = adapter.verify({ tenantId: TENANT_ID, agentId: 'atlas' }, atlasAccess);
+    requireCondition(JSON.stringify(before) === JSON.stringify(after)
+      && novaVerification.valid === true && atlasVerification.valid === true,
+    'ACCEPTANCE_BYTE_PRESERVATION_FAILED');
+    addCheck(checks, 'byte-preservation', 'Synthetic SOUL and identity source bytes remain unchanged and both chains verify.', [
+      after,
+      novaVerification.valid,
+      atlasVerification.valid,
+    ]);
+
+    const report = {
+      schema: SCHEMA,
+      version: PACKAGE_VERSION,
+      scenarioId: 'v7-cross-portal-memory-v1',
+      ok: true,
+      passed: checks.length,
+      total: checks.length,
+      portals: ['cli', 'telegram', 'web'],
+      checks,
+      protectedSourceHashes: after,
+      receiptDigest: digest(checks.map((check) => `${check.id}:${check.receipt}`).join('\n')),
+      scope: 'synthetic-temporary-state',
+      authority: 'acceptance-evidence-only',
+    };
+    adapter.close();
+    adapter = undefined;
+    return report;
+  } finally {
+    try { adapter?.close(); } catch {}
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  renderCognitiveCrossPortalAcceptance,
+  runCognitiveCrossPortalAcceptance,
+};
+

package/bin/cognitive-memory-command.cjs

@@ -3,6 +3,10 @@
 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;
@@ -25,12 +29,15 @@ function digestId(prefix, values) {
 
 function isCognitiveMemoryCommand(args) {
   const action = String(args ?? '').trim().split(/\s+/u, 1)[0].toLowerCase();
-  return action === 'focus' || action === 'correct' || action === 'delete';
+  return action === 'focus' || action === 'correct' || action === 'delete' || action === 'acceptance';
 }
 
 function parseCognitiveMemoryCommand(args) {
   const text = String(args ?? '').trim();
   if (text.toLowerCase() === 'focus') return { action: 'focus' };
+  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);
@@ -200,6 +207,10 @@ function runCognitiveMemoryCommand({
   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 {

package/blun.mjs

@@ -423357,7 +423357,7 @@ async function handleMemoryCommand(host, args, dependencies) {
 	}
 	const parsed = parseMemoryCommand(args);
 	if (parsed === void 0) {
-		host.showStatus("/memory status|on|off|focus|correct <id> <value>|delete <id>");
+		host.showStatus("/memory status|on|off|focus|correct <id> <value>|delete <id>|acceptance [--json]");
 		return;
 	}
 	const client = (dependencies ?? defaultDependencies()).createClient(host);

package/package.json

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