blun-king-cli 9.1.587 → 9.1.588

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

@@ -1,443 +0,0 @@
-'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-effective-view.cjs

@@ -1,77 +0,0 @@
-'use strict';
-
-const CANONICAL_LATEST_DOMAINS = new Set([
-  'goal', 'open_thread', 'knowledge_gap', 'next_trigger', 'expected_evidence',
-]);
-const CONFIDENCE_MARGIN = 0.2;
-
-function compareVariants(left, right) {
-  return right.maxConfidence - left.maxConfidence
-    || right.confirmations - left.confirmations
-    || right.latestOccurredAt - left.latestOccurredAt
-    || left.value.localeCompare(right.value);
-}
-
-function resolveCognitiveEvidenceGroup(entries) {
-  if (!Array.isArray(entries) || entries.length === 0) return null;
-  const withdrawals = entries.filter((item) => Boolean(item.withdraws));
-  const deletionCutoff = withdrawals.length > 0
-    ? Math.max(...withdrawals.map((item) => item.occurredAt)) : Number.NEGATIVE_INFINITY;
-  const evidence = entries.filter((item) => !item.withdraws && item.occurredAt > deletionCutoff);
-  const superseded = new Set(evidence.map((item) => item.supersedes).filter(Boolean));
-  const active = evidence.filter((item) => !superseded.has(item.observationId));
-  if (active.length === 0) return null;
-  const ordered = [...active].sort((left, right) => left.occurredAt - right.occurredAt
-    || left.index - right.index);
-  const latest = ordered.at(-1);
-  const corrected = ordered.some((item) => Boolean(item.supersedes));
-  const distinctValues = new Set(ordered.map((item) => item.value));
-  if (distinctValues.size === 1) return { ...latest, revised: false, corrected, contested: false, conflict: false };
-  if (CANONICAL_LATEST_DOMAINS.has(latest.domain)) {
-    return { ...latest, revised: true, corrected, contested: false, conflict: false };
-  }
-
-  const variants = new Map();
-  for (const item of ordered) {
-    const variant = variants.get(item.value) ?? {
-      value: item.value,
-      maxConfidence: item.confidence,
-      confirmations: 0,
-      latestOccurredAt: item.occurredAt,
-      representative: item,
-    };
-    variant.confirmations += 1;
-    variant.latestOccurredAt = Math.max(variant.latestOccurredAt, item.occurredAt);
-    if (item.confidence > variant.maxConfidence
-        || item.confidence === variant.maxConfidence && item.occurredAt >= variant.representative.occurredAt) {
-      variant.maxConfidence = item.confidence;
-      variant.representative = item;
-    }
-    variants.set(item.value, variant);
-  }
-  const ranked = [...variants.values()].sort(compareVariants);
-  const strongest = ranked[0];
-  const runnerUp = ranked[1];
-  if (strongest.maxConfidence - runnerUp.maxConfidence >= CONFIDENCE_MARGIN - Number.EPSILON) {
-    return {
-      ...strongest.representative,
-      confidence: strongest.maxConfidence,
-      occurredAt: strongest.latestOccurredAt,
-      revised: false,
-      corrected,
-      contested: true,
-      conflict: false,
-    };
-  }
-  return {
-    ...latest,
-    confidence: strongest.maxConfidence,
-    occurredAt: Math.max(...ranked.map((item) => item.latestOccurredAt)),
-    revised: false,
-    corrected,
-    contested: false,
-    conflict: true,
-  };
-}
-
-module.exports = { resolveCognitiveEvidenceGroup };