enigma-memory 0.1.0 → 0.1.2

package/apps/browser-extension/src/native-bridge.js

@@ -0,0 +1,289 @@
+const NATIVE_HOST = 'com.enigma.native_host';
+const PROTOCOL = 'enigma.native.browser.v1';
+const REQUEST_TIMEOUT_MS = 30000;
+const MAX_CONTEXT_CHARS = 32000;
+const SAFE_NATIVE_ERROR_CODE = /^[A-Z][A-Z0-9_]{0,31}$/;
+
+export const SUPPORTED_PROVIDERS = Object.freeze({
+  chatgpt: Object.freeze({ id: 'chatgpt', label: 'ChatGPT', hosts: Object.freeze(['chatgpt.com', 'chat.openai.com']) }),
+  claude: Object.freeze({ id: 'claude', label: 'Claude', hosts: Object.freeze(['claude.ai']) }),
+  kimi: Object.freeze({ id: 'kimi', label: 'Kimi', hosts: Object.freeze(['kimi.com', 'www.kimi.com', 'kimi.moonshot.cn']) }),
+  perplexity: Object.freeze({ id: 'perplexity', label: 'Perplexity', hosts: Object.freeze(['perplexity.ai', 'www.perplexity.ai']) })
+});
+
+const RECEIPT_RAW_FIELD_NAMES = new Set([
+  'memory',
+  'memories',
+  'plaintext',
+  'plainText',
+  'raw',
+  'rawMemory',
+  'rawMemories',
+  'context',
+  'contextText',
+  'text',
+  'content',
+  'prompt'
+]);
+
+export function detectProviderFromUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(String(url));
+  } catch {
+    return undefined;
+  }
+
+  if (parsed.protocol !== 'https:') return undefined;
+  const hostname = parsed.hostname.toLowerCase();
+  for (const provider of Object.values(SUPPORTED_PROVIDERS)) {
+    if (provider.hosts.includes(hostname)) return provider;
+  }
+  return undefined;
+}
+
+export async function requestContextPack(input) {
+  const provider = requireSupportedProvider(input?.url, input?.providerId);
+  const response = await sendNativeMessage({
+    protocol: PROTOCOL,
+    id: requestId(),
+    type: 'enigma.browser.context.request',
+    provider: provider.id,
+    page: sanitizePage(input, provider),
+    selection: sanitizeSelection(input?.selection),
+    requirements: {
+      custody: 'local-only',
+      approval: 'user-click',
+      receipt: 'required',
+      receiptPlaintext: 'forbidden',
+      providerNativeMemory: 'cache-only',
+      storage: 'transient-extension-memory'
+    }
+  });
+
+  return validateContextResponse(response);
+}
+
+export async function recordInsertionReceipt(input) {
+  const provider = requireSupportedProvider(input?.url, input?.providerId);
+  const receipt = sanitizeReceipt(input?.receipt);
+  const response = await sendNativeMessage({
+    protocol: PROTOCOL,
+    id: requestId(),
+    type: 'enigma.browser.insertion.record',
+    provider: provider.id,
+    page: sanitizePage(input, provider),
+    insertion: {
+      mode: input?.mode === 'replace-selection' ? 'replace-selection' : 'insert-at-cursor',
+      target: typeof input?.target === 'string' ? input.target.slice(0, 80) : 'prompt',
+      insertedCharCount: nonNegativeInteger(input?.insertedCharCount),
+      insertedAt: requireString(input?.insertedAt, 'insertion.insertedAt', 80),
+      receipt
+    },
+    requirements: {
+      plaintextInRecord: 'forbidden',
+      receiptPlaintext: 'forbidden'
+    }
+  });
+
+  if (!response || response.protocol !== PROTOCOL || response.type !== 'enigma.browser.insertion.recorded') {
+    throw new Error('Native host returned an invalid insertion receipt acknowledgement.');
+  }
+  if (response.ok !== true) {
+    throw new Error(nativeHostErrorMessage('Native host rejected insertion receipt.', response));
+  }
+  return Object.freeze({ ok: true, receipt });
+}
+
+export function serializeError(error) {
+  if (error instanceof Error) return { message: sanitizeSerializableErrorMessage(error.message) };
+  return { message: 'Unexpected Enigma bridge error.' };
+}
+
+function requireSupportedProvider(url, expectedProviderId) {
+  const provider = detectProviderFromUrl(url);
+  if (!provider) throw new Error('Unsupported or unknown AI provider page.');
+  if (expectedProviderId !== undefined && expectedProviderId !== provider.id) {
+    throw new Error('Provider mismatch for active tab URL.');
+  }
+  return provider;
+}
+
+function sanitizePage(input, provider) {
+  const parsed = new URL(String(input?.url ?? ''));
+  return Object.freeze({
+    providerId: provider.id,
+    origin: parsed.origin,
+    hostname: parsed.hostname.toLowerCase(),
+    display: Object.freeze({
+      providerLabel: provider.label,
+      hostLabel: parsed.hostname.toLowerCase(),
+      titlePresent: typeof input?.title === 'string' && input.title.length > 0,
+      titleCharCount: typeof input?.title === 'string' ? input.title.length : 0
+    }),
+    topLevel: input?.topLevel !== false
+  });
+}
+
+function sanitizeSelection(selection) {
+  if (!selection || typeof selection !== 'object') return undefined;
+  const text = typeof selection.text === 'string' ? selection.text : '';
+  if (text.length === 0) return undefined;
+  if (text.length > 4000) throw new Error('Selected page text exceeds 4000 characters.');
+  const source = typeof selection.source === 'string' && selection.source.length > 0 ? selection.source : 'user-selection';
+  if (source.length > 80) throw new Error('selection.source exceeds 80 characters.');
+  return Object.freeze({
+    text,
+    source
+  });
+}
+
+function validateContextResponse(response) {
+  if (!response || response.protocol !== PROTOCOL || response.type !== 'enigma.browser.context.response') {
+    throw new Error('Native host returned an invalid Enigma context response.');
+  }
+  if (response.ok !== true) {
+    throw new Error(nativeHostErrorMessage('Native host rejected context request.', response));
+  }
+
+  const text = response.context?.text;
+  if (typeof text !== 'string' || text.length === 0) {
+    throw new Error('Native host did not return insertable context.');
+  }
+  if (text.length > MAX_CONTEXT_CHARS) {
+    throw new Error(`Native host context exceeds ${MAX_CONTEXT_CHARS} characters.`);
+  }
+
+  const receipt = sanitizeReceipt(response.receipt);
+  return Object.freeze({
+    ok: true,
+    context: Object.freeze({
+      text,
+      mime: response.context?.mime === 'text/markdown' ? 'text/markdown' : 'text/plain',
+      charCount: text.length
+    }),
+    receipt
+  });
+}
+
+function sanitizeReceipt(receipt) {
+  if (!receipt || typeof receipt !== 'object' || Array.isArray(receipt)) {
+    throw new Error('Enigma native host must return a receipt object.');
+  }
+  if (containsRawReceiptField(receipt)) {
+    throw new Error('Receipt contains a forbidden plaintext-like field.');
+  }
+
+  const id = requireString(receipt.id, 'receipt.id', 160);
+  const commitment = requireString(receipt.commitment ?? receipt.digest, 'receipt.commitment', 256);
+  const digestAlgorithm = requireString(receipt.digestAlgorithm, 'receipt.digestAlgorithm', 80);
+  const createdAt = requireString(receipt.createdAt, 'receipt.createdAt', 80);
+
+  return Object.freeze({ id, commitment, digestAlgorithm, createdAt });
+}
+
+function containsRawReceiptField(value, depth = 0) {
+  if (depth > 12 || value === null || typeof value !== 'object') return false;
+  if (Array.isArray(value)) return value.some((item) => containsRawReceiptField(item, depth + 1));
+  for (const [key, child] of Object.entries(value)) {
+    if (RECEIPT_RAW_FIELD_NAMES.has(key)) return true;
+    if (containsRawReceiptField(child, depth + 1)) return true;
+  }
+  return false;
+}
+
+function requireString(value, name, maxLength) {
+  if (typeof value !== 'string' || value.length === 0) throw new Error(`Missing ${name}.`);
+  if (value.length > maxLength) throw new Error(`${name} exceeds ${maxLength} characters.`);
+  return value;
+}
+
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+
+function requestId() {
+  const random = new Uint8Array(16);
+  crypto.getRandomValues(random);
+  return Array.from(random, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+function sendNativeMessage(message) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const timeout = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      reject(new Error('Timed out waiting for Enigma native host.'));
+    }, REQUEST_TIMEOUT_MS);
+
+    chrome.runtime.sendNativeMessage(NATIVE_HOST, message, (response) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+
+      const lastError = chrome.runtime.lastError;
+      if (lastError) {
+        reject(new Error(nativeHostErrorMessage('Unable to reach Enigma native host.', lastError)));
+        return;
+      }
+      if (response && response.id !== message.id) {
+        reject(new Error('Native host response id did not match the request id.'));
+        return;
+      }
+      resolve(response);
+    });
+  });
+}
+
+function nativeHostErrorMessage(fallback, detail) {
+  const code = safeNativeErrorCode(detail);
+  return code ? `${fallback} (${code})` : fallback;
+}
+
+function safeNativeErrorCode(detail) {
+  if (!detail || typeof detail !== 'object') return undefined;
+  const code = detail.code ?? detail.errorCode;
+  if (typeof code !== 'string') return undefined;
+  const trimmed = code.trim();
+  return SAFE_NATIVE_ERROR_CODE.test(trimmed) ? trimmed : undefined;
+}
+
+function sanitizeSerializableErrorMessage(message) {
+  if (typeof message !== 'string') return 'Unexpected Enigma bridge error.';
+  const trimmed = message.trim();
+  if (!trimmed) return 'Unexpected Enigma bridge error.';
+  if (trimmed.length > 240 || looksLikeSensitiveErrorText(trimmed) || !isKnownSafeErrorMessage(trimmed)) {
+    return 'Enigma action failed without exposing local memory.';
+  }
+  return trimmed;
+}
+
+function isKnownSafeErrorMessage(message) {
+  switch (message) {
+    case 'Unsupported or unknown AI provider page.':
+    case 'Provider mismatch for active tab URL.':
+    case 'Message provider does not match the active page.':
+    case 'Unsupported Enigma extension message.':
+    case 'Native host rejected context request.':
+    case 'Native host rejected insertion receipt.':
+    case 'Unable to reach Enigma native host.':
+    case 'Timed out waiting for Enigma native host.':
+    case 'Native host returned an invalid Enigma context response.':
+    case 'Native host returned an invalid insertion receipt acknowledgement.':
+    case 'Native host response id did not match the request id.':
+    case 'Native host did not return insertable context.':
+    case 'Enigma native host must return a receipt object.':
+    case 'Receipt contains a forbidden plaintext-like field.':
+    case 'Selected page text exceeds 4000 characters.':
+    case 'selection.source exceeds 80 characters.':
+      return true;
+    default:
+      return /^(?:Native host context exceeds|Missing [A-Za-z0-9_.]+|[A-Za-z0-9_.]+ exceeds) \d+ characters\.$/.test(message) ||
+        /^Missing [A-Za-z0-9_.]+\.$/.test(message);
+  }
+}
+
+function looksLikeSensitiveErrorText(text) {
+  return /https?:\/\/|[?&#](?:token|key|prompt|q)=|\b(selectedText|selected_text|plaintext|rawMemory|raw_memory|contextText|context_text)\b|["'](?:text|content|memory|raw|prompt|receipt)["']\s*:/i.test(text);
+}

package/apps/cli/bin/enigma.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createHash } from 'node:crypto';
 import { createServer as createHttpServer } from 'node:http';
 import { realpathSync } from 'node:fs';
 import { access, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
@@ -29,6 +30,25 @@ import {
 const DEFAULT_BUNDLE = '.enigma/bundle.json';
 export const DEFAULT_RELAY_PORT = 8787;
 export const DEFAULT_GATEWAY_PORT = 8797;
+const DEFAULT_QUICKSTART_MEMORY = 'Enigma quickstart demo memory: local proof bundles can be created and verified without provider or cloud credentials.';
+const DEFAULT_CROSS_MODEL_DEMO_BUNDLE = '.enigma/cross-model-demo-bundle.json';
+const DEFAULT_CROSS_MODEL_MEMORY = 'Enigma cross-model demo memory: a local encrypted memory can be packaged for ChatGPT, Claude, Kimi, Cursor, and a local LLM without provider credentials.';
+const CROSS_MODEL_PROFILES = Object.freeze([
+  { id: 'chatgpt', provider: 'chatgpt', model: 'chatgpt-mcp-profile', label: 'ChatGPT' },
+  { id: 'claude', provider: 'claude', model: 'claude-mcp-profile', label: 'Claude' },
+  { id: 'kimi', provider: 'kimi', model: 'kimi-mcp-profile', label: 'Kimi' },
+  { id: 'cursor', provider: 'cursor', model: 'cursor-mcp-profile', label: 'Cursor' },
+  { id: 'local-llm', provider: 'local', model: 'local-llm-profile', label: 'Local LLM' },
+]);
+const CROSS_MODEL_CLAIM_BOUNDARIES = Object.freeze({
+  local_only: true,
+  provider_credentials_required: false,
+  provider_native_memory_canonical: false,
+  provider_deletion_proof: false,
+  model_forgetting_proof: false,
+  roi_or_savings_guarantee: false,
+  compliance_certification: false,
+});
 const PACKAGE_JSON_URL = new URL('../../../package.json', import.meta.url);
 const SPECS_URL = new URL('../../../specs/', import.meta.url);
 const IMPORTERS = Object.freeze({
@@ -145,6 +165,118 @@ async function fileExists(path) {
   }
 }
 
+function pathFlag(flags, names, fallback) {
+  const value = getFlag(flags, names, fallback);
+  if (value === true || value === '') throw new Error(`Missing required --${names[0]}.`);
+  return String(value);
+}
+
+function quickstartPathDisplay(outDirInput, name) {
+  const base = String(outDirInput);
+  if (base === '' || base === '.') return name;
+  return `${base.replace(/[\\/]+$/, '')}/${name}`;
+}
+
+function ensureDistinctOutputPaths(paths) {
+  const normalized = paths.map((path) => (process.platform === 'win32' ? path.toLowerCase() : path));
+  if (new Set(normalized).size !== paths.length) {
+    throw new Error('Quickstart output paths must be distinct.');
+  }
+}
+
+async function assertCanWriteQuickstartOutputs(outputs, overwrite) {
+  if (overwrite) return;
+  const existing = [];
+  for (const output of outputs) {
+    if (await fileExists(output.path)) existing.push(output.display);
+  }
+  if (existing.length > 0) {
+    throw new Error(`Quickstart output already exists: ${existing.join(', ')}. Pass --overwrite to replace it.`);
+  }
+}
+
+async function quickstartMemoryTextFromFlags(flags) {
+  const inlineText = getFlag(flags, ['memory-text', 'memoryText']);
+  const textFile = getFlag(flags, ['memory-file', 'memoryFile', 'text-file', 'textFile']);
+  if (inlineText !== undefined && textFile !== undefined) throw new Error('Use either --memory-text or --memory-file, not both.');
+  if (inlineText !== undefined) {
+    if (inlineText === true || inlineText === '') throw new Error('Missing required --memory-text.');
+    return String(inlineText);
+  }
+  if (textFile !== undefined) {
+    if (textFile === true || textFile === '') throw new Error('Missing required --memory-file.');
+    return readFile(resolve(String(textFile)), 'utf8');
+  }
+  return DEFAULT_QUICKSTART_MEMORY;
+}
+
+async function crossModelMemoryTextFromFlags(flags) {
+  const textFile = getFlag(flags, ['memory-file', 'memoryFile', 'text-file', 'textFile']);
+  if (textFile === undefined) return DEFAULT_CROSS_MODEL_MEMORY;
+  if (textFile === true || textFile === '') throw new Error('Missing required --memory-file.');
+  return readFile(resolve(String(textFile)), 'utf8');
+}
+
+function activeMemoryCount(vault) {
+  return vault.activeAddresses instanceof Set ? vault.activeAddresses.size : 0;
+}
+
+function sha256Json(value) {
+  return `sha256:${createHash('sha256').update(JSON.stringify(value)).digest('hex')}`;
+}
+
+function contextPackPublicDigest(pack) {
+  return sha256Json({
+    schema: pack.schema,
+    context_pack_id: pack.context_pack_id,
+    provider: pack.provider,
+    model: pack.model,
+    purpose: pack.purpose,
+    memory_addresses: pack.memory_addresses,
+    receipt_hashes: pack.receipt_hashes,
+    active_set_root: pack.active_set_root,
+    receipt_log_root: pack.receipt_log_root,
+  });
+}
+
+function publicReceiptRefs(receipts) {
+  return (Array.isArray(receipts) ? receipts : []).map((receipt) => ({
+    receipt_id: receipt.receipt_id,
+    operation: receipt.operation,
+    memory_addr: receipt.memory_addr,
+    provider: receipt.provider,
+    model: receipt.model,
+    event_hash: receipt.event_hash,
+    receipt_log_root: receipt.receipt_log_root,
+    timestamp: receipt.timestamp,
+  }));
+}
+
+function publicContextPackSummary(pack) {
+  const receipts = publicReceiptRefs(pack.receipts);
+  return {
+    schema: pack.schema,
+    context_pack_ref: `enigma://context-pack/${pack.context_pack_id}`,
+    context_pack_id: pack.context_pack_id,
+    context_pack_digest: contextPackPublicDigest(pack),
+    provider: pack.provider,
+    model: pack.model,
+    purpose: pack.purpose,
+    memory_addresses: Array.isArray(pack.memory_addresses) ? [...pack.memory_addresses] : [],
+    memory_count: Array.isArray(pack.memory_addresses) ? pack.memory_addresses.length : 0,
+    receipt_count: receipts.length,
+    receipt_hashes: Array.isArray(pack.receipt_hashes) ? [...pack.receipt_hashes] : [],
+    receipts,
+    active_set_root: pack.active_set_root,
+    receipt_log_root: pack.receipt_log_root,
+    content_redacted: true,
+  };
+}
+
+function demoBundleRef(bundleWasSupplied) {
+  return bundleWasSupplied ? 'supplied_bundle' : DEFAULT_CROSS_MODEL_DEMO_BUNDLE;
+}
+
 async function readPackageJson() {
   return readJson(PACKAGE_JSON_URL);
 }
@@ -361,6 +493,200 @@ async function initCommand(flags, io) {
   return 0;
 }
 
+export async function quickstartCommand(flags, io) {
+  const bundleInput = pathFlag(flags, ['bundle', 'file'], DEFAULT_BUNDLE);
+  const outDirInput = pathFlag(flags, ['out-dir', 'outDir'], dirname(bundleInput));
+  const bundlePath = resolve(bundleInput);
+  const outDirPath = resolve(outDirInput);
+  const contextPackPath = resolve(outDirPath, 'context-pack.json');
+  const exportPath = resolve(outDirPath, 'export.json');
+  const verifyReportPath = resolve(outDirPath, 'verify-report.json');
+  const contextPackDisplay = quickstartPathDisplay(outDirInput, 'context-pack.json');
+  const exportDisplay = quickstartPathDisplay(outDirInput, 'export.json');
+  const verifyReportDisplay = quickstartPathDisplay(outDirInput, 'verify-report.json');
+  const outputs = [
+    { path: bundlePath, display: bundleInput },
+    { path: contextPackPath, display: contextPackDisplay },
+    { path: exportPath, display: exportDisplay },
+    { path: verifyReportPath, display: verifyReportDisplay },
+  ];
+  ensureDistinctOutputPaths(outputs.map((output) => output.path));
+  const overwrite = getFlag(flags, ['overwrite'], false) === true || getFlag(flags, ['overwrite'], false) === 'true';
+  await assertCanWriteQuickstartOutputs(outputs, overwrite);
+
+  const vault = createVault({
+    subjectId: String(getFlag(flags, ['subject', 'subject-id'], 'local-user')),
+    displayName: String(getFlag(flags, ['display-name', 'name'], 'Local user')),
+    passphrase: String(getFlag(flags, ['passphrase'], 'local-development-passphrase')),
+  });
+  const passport = createPassport({
+    vault,
+    subjectId: vault.subject_id,
+    displayName: String(getFlag(flags, ['display-name', 'name'], 'Local user')),
+  });
+  remember({
+    vault,
+    passport,
+    text: await quickstartMemoryTextFromFlags(flags),
+    purpose: 'quickstart_local_proof',
+    purpose_tags: ['quickstart'],
+    metadata: { source: 'enigma quickstart' },
+  });
+  const contextPack = compileContextPack({
+    vault,
+    passport,
+    query: '',
+    purpose: 'quickstart_local_context',
+    limit: 8,
+  });
+  const exported = exportBundle({ vault, includePlaintext: false });
+  const bundle = exported.bundle ?? exported;
+  const verifyReport = verifyBundle(bundle);
+
+  await writeJson(bundlePath, bundle);
+  await writeJson(contextPackPath, contextPack);
+  await writeJson(exportPath, bundle);
+  await writeJson(verifyReportPath, verifyReport);
+
+  print({
+    ok: verifyReport.ok === true,
+    bundle: bundleInput,
+    context_pack: contextPackDisplay,
+    export: exportDisplay,
+    verify_report: verifyReportDisplay,
+    memory_count: Array.isArray(bundle.memory_objects) ? bundle.memory_objects.length : 0,
+    receipt_count: Array.isArray(bundle.receipts) ? bundle.receipts.length : 0,
+    context_item_count: Array.isArray(contextPack.memories) ? contextPack.memories.length : 0,
+    verify_ok: verifyReport.ok === true,
+    next_commands: [
+      `enigma verify --export ${exportDisplay}`,
+      `enigma connect generic-mcp --bundle ${bundleInput} --dry-run`,
+    ],
+    claim_boundaries: {
+      local_only: true,
+      provider_credentials_required: false,
+      provider_deletion_proof: false,
+      model_forgetting_proof: false,
+      roi_or_savings_guarantee: false,
+      compliance_certification: false,
+    },
+  }, io);
+  return verifyReport.ok === true ? 0 : 1;
+}
+
+export async function crossModelDemoCommand(flags, io) {
+  const bundleFlag = getFlag(flags, ['bundle', 'file']);
+  if (bundleFlag === true || bundleFlag === '') throw new Error('Missing required --bundle.');
+  const bundleWasSupplied = bundleFlag !== undefined;
+  const bundleInput = bundleWasSupplied ? String(bundleFlag) : DEFAULT_CROSS_MODEL_DEMO_BUNDLE;
+  const bundlePath = resolve(bundleInput);
+  const out = getFlag(flags, ['out']);
+  if (out === true || out === '') throw new Error('Missing required --out.');
+  const outPath = out === undefined ? undefined : resolve(String(out));
+  if (outPath !== undefined) ensureDistinctOutputPaths([bundlePath, outPath]);
+
+  const memoryFileWasSupplied = getFlag(flags, ['memory-file', 'memoryFile', 'text-file', 'textFile']) !== undefined;
+  let bundleCreated = false;
+  let vault;
+  let passport;
+  let demoMemoryAddr;
+
+  if (!bundleWasSupplied) {
+    vault = createVault({
+      subjectId: 'cross-model-demo-user',
+      displayName: 'Cross-model demo user',
+      passphrase: 'local-cross-model-demo-passphrase',
+    });
+    passport = createPassport({ vault, subjectId: vault.subject_id, displayName: 'Cross-model demo user' });
+    const remembered = remember({
+      vault,
+      passport,
+      text: await crossModelMemoryTextFromFlags(flags),
+      purpose: 'cross_model_demo_memory',
+      purpose_tags: ['cross-model-demo'],
+      metadata: { source: memoryFileWasSupplied ? 'local file supplied to demo' : 'generic cross-model demo memory' },
+    });
+    demoMemoryAddr = remembered.memory_addr;
+    bundleCreated = true;
+  } else {
+    const existed = await fileExists(bundlePath);
+    if (!existed) {
+      await ensureBundle(bundlePath, flags);
+      bundleCreated = true;
+    }
+    ({ vault, passport } = await loadState(bundlePath));
+    const remembered = remember({
+      vault,
+      passport,
+      text: await crossModelMemoryTextFromFlags(flags),
+      purpose: 'cross_model_demo_memory',
+      purpose_tags: ['cross-model-demo'],
+      metadata: { source: memoryFileWasSupplied ? 'local file supplied to demo' : 'generic cross-model demo memory' },
+    });
+    demoMemoryAddr = remembered.memory_addr;
+  }
+  const memorySource = memoryFileWasSupplied ? 'memory_file' : 'generic_demo';
+
+  const limit = integerFlag(flags, ['limit'], 'limit', 1);
+  if (limit < 1) throw new Error('--limit must be at least 1.');
+  const receiptCountBeforeProfiles = Array.isArray(vault.receipts) ? vault.receipts.length : 0;
+  const profiles = [];
+  for (const profile of CROSS_MODEL_PROFILES) {
+    const pack = compileContextPack({
+      vault,
+      passport,
+      provider: profile.provider,
+      model: profile.model,
+      query: 'memory follows me across models',
+      purpose: `cross_model_demo:${profile.id}`,
+      memory_addresses: [demoMemoryAddr],
+      limit,
+    });
+    const contextPack = publicContextPackSummary(pack);
+    profiles.push({
+      profile: profile.id,
+      label: profile.label,
+      provider: profile.provider,
+      model: profile.model,
+      context_pack_ref: contextPack.context_pack_ref,
+      context_pack_id: contextPack.context_pack_id,
+      context_pack_digest: contextPack.context_pack_digest,
+      context_pack: contextPack,
+      receipt_count: contextPack.receipt_count,
+      memory_count: contextPack.memory_count,
+      provider_native_memory_canonical: false,
+      receipts: contextPack.receipts,
+      claim_boundaries: { ...CROSS_MODEL_CLAIM_BOUNDARIES },
+    });
+  }
+
+  const bundle = await persistState(bundlePath, vault);
+  const report = {
+    ok: true,
+    schema: 'enigma.cross_model_demo.v1',
+    command: 'enigma demo cross-model',
+    story: 'One local Enigma memory is packaged as public-safe context pack references and receipts for ChatGPT, Claude, Kimi, Cursor, and a local LLM. No provider is called.',
+    bundle_ref: demoBundleRef(bundleWasSupplied),
+    bundle_supplied: bundleWasSupplied,
+    bundle_created: bundleCreated,
+    demo_only_vault: !bundleWasSupplied,
+    memory_source: memorySource,
+    demo_memory_addr: demoMemoryAddr,
+    profile_count: profiles.length,
+    profiles,
+    memory_count: activeMemoryCount(vault),
+    receipt_count: Array.isArray(bundle.receipts) ? bundle.receipts.length : 0,
+    generated_receipt_count: (Array.isArray(bundle.receipts) ? bundle.receipts.length : 0) - receiptCountBeforeProfiles,
+    provider_credentials_required: false,
+    provider_native_memory_canonical: false,
+    out_written: outPath !== undefined,
+    claim_boundaries: { ...CROSS_MODEL_CLAIM_BOUNDARIES },
+  };
+  if (outPath !== undefined) await writeJson(outPath, report);
+  print(report, io);
+  return 0;
+}
+
 async function rememberCommand(flags, io) {
   const bundlePath = resolve(String(getFlag(flags, ['bundle', 'file'], DEFAULT_BUNDLE)));
   const { vault, passport } = await loadState(bundlePath);
@@ -946,6 +1272,8 @@ function usage() {
     usage: 'enigma <command> [options]',
     commands: [
       'init',
+      'quickstart',
+      'demo cross-model',
       'doctor',
       'install',
       'connect <client>',
@@ -990,6 +1318,21 @@ function usage() {
       '--text <text>': 'Inline local memory text. Avoid for private content because argv can be logged by process tooling.',
       '--text-file <path>': 'Read local memory text from a file so private smoke input is not exposed in shell argv. Aliases: --memory-file, --textFile, --memoryFile.',
     },
+    quickstart_options: {
+      '--bundle <path>': 'Bundle JSON to create. Defaults to .enigma/bundle.json.',
+      '--out-dir <path>': 'Directory for context-pack.json, export.json, and verify-report.json. Defaults to the bundle directory.',
+      '--subject <id>': 'Local subject id. Defaults to local-user.',
+      '--display-name <name>': 'Local display name. Defaults to Local user.',
+      '--memory-file <path>': 'Read local memory text from a file. Alias: --text-file.',
+      '--memory-text <text>': 'Inline demo memory text for non-private demos only.',
+      '--overwrite': 'Replace existing quickstart output files.',
+    },
+    cross_model_demo_options: {
+      '--bundle <path>': `Reuse a local Enigma bundle. If omitted, ${DEFAULT_CROSS_MODEL_DEMO_BUNDLE} is recreated as a demo-only local vault.`,
+      '--memory-file <path>': 'Seed the demo from a local file without echoing plaintext. Alias: --text-file.',
+      '--out <path>': 'Write the same public-safe JSON report to a local file.',
+      '--limit <n>': 'Maximum active memories per generated profile context pack. Defaults to 1 for the same-memory demo story.',
+    },
     native_host: {
       bin: 'enigma-native-host',
       host_name: 'com.enigma.native_host',
@@ -1055,15 +1398,17 @@ export async function main(argv = process.argv.slice(2), io = { stdout: process.
     print(usage(), io);
     return 0;
   }
-  const twoPartCommands = ['boundary', 'mcp', 'mesh', 'enterprise', 'capsule', 'relay', 'gateway', 'connect', 'disconnect', 'import', 'native-host', 'meter', 'settlement'];
+  const twoPartCommands = ['boundary', 'mcp', 'mesh', 'enterprise', 'capsule', 'relay', 'gateway', 'connect', 'disconnect', 'import', 'native-host', 'meter', 'settlement', 'demo'];
   const flags = parseArgs(twoPartCommands.includes(command) ? argv.slice(2) : argv.slice(1));
   const positionalFile = optionalPositional(argv[2]);
-  if ((flags.has('help') || argv.includes('-h')) && (((command === 'relay' || command === 'gateway') && (subcommand === 'serve' || subcommand === 'demo')) || (command === 'native-host' && (subcommand === 'manifest' || subcommand === 'install-plan')))) {
+  if ((flags.has('help') || argv.includes('-h')) && (((command === 'relay' || command === 'gateway') && (subcommand === 'serve' || subcommand === 'demo')) || (command === 'native-host' && (subcommand === 'manifest' || subcommand === 'install-plan')) || (command === 'demo' && subcommand === 'cross-model'))) {
     print(usage(), io);
     return 0;
   }
   try {
     if (command === 'init') return await initCommand(flags, io);
+    if (command === 'quickstart') return await quickstartCommand(flags, io);
+    if (command === 'demo' && subcommand === 'cross-model') return await crossModelDemoCommand(flags, io);
     if (command === 'doctor') return await doctorCommand(flags, io);
     if (command === 'install') return await installCommand(flags, io);
     if (command === 'connect') return await connectCommand(subcommand, flags, io);