enigma-memory 0.1.18 → 0.1.22

package/packages/storage/PACKAGE_CONTRACT.md

@@ -1,6 +1,6 @@
 # Production storage contract
 
-`@enigma-ai/enigma/storage` defines the production storage schema contract for relay/gateway deployments. It is pure local code: no sockets, no provider SDKs, no environment loading, and no secret handling.
+`enigma-memory/storage` defines the production storage schema contract for relay/gateway deployments. It is pure local code: no sockets, no provider SDKs, no environment loading, and no secret handling.
 
 ## Purpose
 

package/packages/terminal-console/animations.mjs

@@ -0,0 +1,240 @@
+import { ANSI } from '../terminal-tui/merkle-tree-renderer.mjs';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { OFFICIAL_TOKEN_CA } from './banner.mjs';
+import { fetchSolanaStreamMetrics } from './solana-rpc.mjs';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isInteractiveTty(io) {
+  return Boolean(io.stdout?.isTTY);
+}
+
+export async function runConstellationAnimation(io, { frames = 15, color = true, shouldStop = undefined } = {}) {
+  const c = (text, code) => (color ? `${code}${text}${ANSI.reset}` : text);
+
+  const starFields = [
+    [
+      '  *       ·      +    .     *        ·        +',
+      '     ·     [NODE: alpha]-----------[NODE: beta]    .',
+      '  +      .     |             /            ·',
+      '      *        |     [TOPOLOGY MESH]     *       +',
+      '  ·            |             \\        .       ',
+      '     .     [NODE: gamma]-----------[NODE: delta]   ·',
+      '  +       *      ·      +    .     *        +',
+    ],
+    [
+      '  .       *      ·    +     .        *        ·',
+      '     +     [NODE: alpha]=====*=====[NODE: beta]    *',
+      '  ·      *     |             \\            +',
+      '      .        |     [TOPOLOGY MESH]     ·       .',
+      '  +            |             /        *       ',
+      '     *     [NODE: gamma]=====*=====[NODE: delta]   +',
+      '  ·       .      *      ·    +     .        ·',
+    ],
+    [
+      '  +       ·      *    .     +        ·        *',
+      '     ·     [NODE: alpha]-----*-----[NODE: beta]    +',
+      '  *      .     |             /            ·',
+      '      +        *     [TOPOLOGY MESH]     +       *',
+      '  ·            |             \\        .       ',
+      '     .     [NODE: gamma]-----*-----[NODE: delta]   ·',
+      '  *       +      ·      *    .     +        ·',
+    ],
+  ];
+
+  io.stdout.write(c('\n  CONSTELLATION MESH VISUALIZER (DECORATIVE TOPOLOGY DISPLAY)\n\n', `${ANSI.bold}${ANSI.amber}`));
+
+  function renderFrameLines(frame) {
+    return frame.map((line) => line
+      .replace(/\[NODE: [^\]]+\]/g, (match) => c(match, `${ANSI.bold}${ANSI.cyan}`))
+      .replace(/\[TOPOLOGY MESH\]/g, (match) => c(match, `${ANSI.bold}${ANSI.amber}`))
+      .replace(/====\*====/g, (match) => c(match, ANSI.amberGlow))
+      .replace(/----\*----/g, (match) => c(match, ANSI.green))
+      .replace(/[*+·.]/g, (match) => c(match, ANSI.dimText))
+    ).join('\n') + '\n';
+  }
+
+  if (!isInteractiveTty(io) || !color) {
+    // Non-interactive or piped mode: print single static frame without cursor movement
+    io.stdout.write(renderFrameLines(starFields[0]));
+    io.stdout.write(c('  [END CONSTELLATION DISPLAY]\n\n', ANSI.dim));
+    return 0;
+  }
+
+  // Interactive TTY mode with cursor-controlled animation
+  for (let i = 0; i < frames; i++) {
+    if (shouldStop && shouldStop()) break;
+    if (i > 0) {
+      io.stdout.write('\x1b[7A\r'); // Move cursor up 7 lines only after initial frame is printed
+    }
+    const frame = starFields[i % starFields.length];
+    io.stdout.write(renderFrameLines(frame));
+    await sleep(90);
+  }
+
+  io.stdout.write(c('  [END CONSTELLATION DISPLAY]\n\n', ANSI.dim));
+  return 0;
+}
+
+export async function runMatrixStream(io, { lines = 12, color = true, shouldStop = undefined } = {}) {
+  const c = (text, code) => (color ? `${code}${text}${ANSI.reset}` : text);
+
+  io.stdout.write(c('\n  HEXADECIMAL TELEMETRY RAIN (DECORATIVE STREAM)\n', `${ANSI.bold}${ANSI.amber}`));
+
+  const hexChars = '0123456789abcdef';
+  const count = (!isInteractiveTty(io) || !color) ? 4 : lines;
+
+  for (let i = 0; i < count; i++) {
+    if (shouldStop && shouldStop()) break;
+    let row = '  ';
+    for (let j = 0; j < 56; j++) {
+      const char = hexChars[Math.floor(Math.random() * hexChars.length)];
+      if (j % 8 === 0) row += ' ';
+      row += j % 4 === 0 ? c(char, ANSI.amber) : c(char, ANSI.dimText);
+    }
+    io.stdout.write(row + '\n');
+    if (isInteractiveTty(io) && color) {
+      await sleep(35);
+    }
+  }
+
+  io.stdout.write(c('  [STREAM COMPLETE]\n\n', ANSI.dim));
+  return 0;
+}
+
+async function resolveVaultRoot(bundlePath) {
+  if (!bundlePath) return 'N/A';
+  try {
+    const raw = JSON.parse(await readFile(resolve(bundlePath), 'utf8'));
+    const root = raw.vault?.active_set_root
+      || raw.vault?.set_root
+      || raw.active_set_root
+      || raw.state_root
+      || raw.merkle_root
+      || raw.passport?.active_set_root;
+    if (typeof root === 'string' && root.startsWith('sha256:')) return root;
+    return 'N/A';
+  } catch {
+    return 'N/A';
+  }
+}
+
+export async function runSolanaHeartbeatStream(io, {
+  cluster = 'mainnet-beta',
+  rpcUrl = undefined,
+  samples = undefined,
+  intervalMs = 350,
+  fetchFn = globalThis.fetch,
+  color = true,
+  bundlePath = undefined,
+  shouldStop = undefined,
+} = {}) {
+  const c = (text, code) => (color ? `${code}${text}${ANSI.reset}` : text);
+
+  const resolvedRoot = await resolveVaultRoot(bundlePath);
+
+  io.stdout.write('\n' + c('  ╔═══════════════════════════════════════════════════════════════════════════╗', ANSI.amber) + '\n');
+  io.stdout.write(c('  ║         ENIGMA ⚡ SOLANA LIVE BLOCKCHAIN HEARTBEAT & PROOF STREAM        ║', `${ANSI.bold}${ANSI.amber}`) + '\n');
+  io.stdout.write(c('  ╚═══════════════════════════════════════════════════════════════════════════╝', ANSI.amber) + '\n\n');
+
+  let sampleCount = 0;
+  let lastSlot = null;
+  let lastTxCount = null;
+  let hasPrintedHeader = false;
+  let latestOk = true;
+  const interactive = isInteractiveTty(io) && color;
+  const isCancellable = typeof shouldStop === 'function';
+  const maxSamples = (typeof samples === 'number' && samples > 0) || samples === Infinity
+    ? samples
+    : ((isCancellable || interactive) ? Infinity : 3);
+  while (sampleCount < maxSamples) {
+    if (shouldStop && shouldStop()) break;
+
+    const metrics = await fetchSolanaStreamMetrics({ cluster, rpcUrl, fetchFn });
+    latestOk = metrics.ok === true;
+
+    const epochPct = (metrics.slot_index !== null && metrics.slots_in_epoch)
+      ? ((metrics.slot_index / metrics.slots_in_epoch) * 100).toFixed(1)
+      : null;
+    const epochBar = epochPct !== null
+      ? `[${'█'.repeat(Math.min(24, Math.max(0, Math.round((Number(epochPct) / 100) * 24))))}${'░'.repeat(24 - Math.min(24, Math.max(0, Math.round((Number(epochPct) / 100) * 24))))}] ${epochPct}%`
+      : 'N/A';
+
+    if (!hasPrintedHeader) {
+      const statusBadge = metrics.ok
+        ? `${c('● CONNECTED', `${ANSI.bold}${ANSI.green}`)} (${metrics.latency_ms}ms)`
+        : `${c('○ UNREACHABLE', `${ANSI.bold}${ANSI.yellow}`)} (${metrics.error || 'no response'})`;
+
+      io.stdout.write(`  ${c('Cluster:', ANSI.dimText)}           ${metrics.cluster} (${metrics.rpc_url})\n`);
+      io.stdout.write(`  ${c('Solana Core:', ANSI.dimText)}       ${metrics.solana_core_version || 'N/A'}\n`);
+      io.stdout.write(`  ${c('RPC Status:', ANSI.dimText)}        ${statusBadge}\n`);
+      io.stdout.write(`  ${c('Token Mint CA:', ANSI.dimText)}     ${c(OFFICIAL_TOKEN_CA, `${ANSI.bold}${ANSI.white}`)}\n`);
+      io.stdout.write(`  ${c('Active SMT Root:', ANSI.dimText)}   ${c(resolvedRoot, ANSI.cyan)}\n`);
+      io.stdout.write(`  ${c('Epoch Progress:', ANSI.dimText)}    ${c(epochBar, ANSI.amberGlow)}\n\n`);
+      hasPrintedHeader = true;
+    }
+
+    // Build the horizontal pulse beam wave
+    const wave = '♥───^v';
+    const beamWidth = 32;
+    const pos = (sampleCount * 2) % (beamWidth - wave.length);
+    const coloredBeam = `[${c('─'.repeat(pos), ANSI.dimText)}${c('♥', `${ANSI.bold}${ANSI.amberGlow}`)}${c('───^v', ANSI.green)}${c('─'.repeat(beamWidth - pos - wave.length), ANSI.dimText)}]`;
+
+    if (metrics.ok) {
+      const slotText = metrics.slot !== null ? String(metrics.slot) : 'N/A';
+      let deltaSlotText = '';
+      if (metrics.slot !== null && lastSlot !== null) {
+        const delta = metrics.slot - lastSlot;
+        deltaSlotText = ` (${c(delta >= 0 ? `+${delta}` : String(delta), ANSI.amberGlow)} slots)`;
+      }
+
+      let txText = 'N/A';
+      if (metrics.transaction_count !== null) {
+        txText = metrics.transaction_count.toLocaleString();
+        if (lastTxCount !== null) {
+          const txDelta = metrics.transaction_count - lastTxCount;
+          if (txDelta > 0) txText += ` (+${txDelta.toLocaleString()})`;
+        }
+      }
+
+      const line = `  ${c('Live Pulse Bar:', ANSI.dimText)}  ${coloredBeam} slot ${c(slotText, ANSI.bold)}${deltaSlotText} • tx_count ${txText} • rpc ${metrics.latency_ms}ms`;
+
+      if (interactive && sampleCount > 0) {
+        io.stdout.write(`\r\x1b[2K${line}`);
+      } else {
+        io.stdout.write(line + (interactive ? '' : '\n'));
+      }
+
+      lastSlot = metrics.slot;
+      lastTxCount = metrics.transaction_count;
+    } else {
+      const errLine = `  ${c('Live Pulse Bar:', ANSI.dimText)}  [${c('DISCONNECTED', ANSI.red)}] ${metrics.error || 'Connection failed'} (${metrics.latency_ms}ms)`;
+      if (interactive && sampleCount > 0) {
+        io.stdout.write(`\r\x1b[2K${errLine}`);
+      } else {
+        io.stdout.write(errLine + (interactive ? '' : '\n'));
+      }
+    }
+
+    sampleCount += 1;
+
+    if (sampleCount < maxSamples) {
+      await sleep(intervalMs);
+    }
+  }
+
+  if (interactive) {
+    io.stdout.write('\n');
+  }
+
+  if (Number.isFinite(maxSamples)) {
+    io.stdout.write('\n' + c(`  [STREAM COMPLETE • ${sampleCount} sample${sampleCount === 1 ? '' : 's'} recorded]`, ANSI.dim) + '\n\n');
+  } else {
+    io.stdout.write('\n' + c('  [STREAM STOPPED]', ANSI.dim) + '\n\n');
+  }
+
+  return latestOk ? 0 : 1;
+}

package/packages/terminal-console/auto-anchor.mjs

@@ -0,0 +1,220 @@
+// Enigma Sovereign AI Memory — Autonomous Solana Auto-Anchor Engine
+// Orchestrates SignerStore, AutoAnchorOutbox, and SolanaTransport with strict policy guardrails.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { SignerStore } from './signer-store.mjs';
+import { AutoAnchorOutbox } from './outbox.mjs';
+import { SolanaTransport, SOLANA_MEMO_PROGRAM_ID, MAX_AUTO_ANCHOR_FEE_LAMPORTS } from './solana-transport.mjs';
+import {
+  buildDelegationChallenge,
+  createDelegationArtifact,
+  verifyDelegationArtifact,
+  computeAuthorizationHash,
+  DEFAULT_DELEGATION_EXPIRY_DAYS,
+} from './delegation.mjs';
+
+export { SignerStore } from './signer-store.mjs';
+export { AutoAnchorOutbox } from './outbox.mjs';
+export { SolanaTransport, SOLANA_MEMO_PROGRAM_ID, MAX_AUTO_ANCHOR_FEE_LAMPORTS } from './solana-transport.mjs';
+export {
+  buildDelegationChallenge,
+  createDelegationArtifact,
+  verifyDelegationArtifact,
+  computeAuthorizationHash,
+} from './delegation.mjs';
+
+export const MAX_DAILY_TRANSACTIONS = 50;
+
+export class AutoAnchorEngine {
+  constructor({
+    rootDir = '.enigma/auto-anchor',
+    cluster = 'mainnet-beta',
+    rpcUrl = undefined,
+    signerStore = undefined,
+    transport = undefined,
+    maxDailyTx = MAX_DAILY_TRANSACTIONS,
+  } = {}) {
+    this.rootDir = resolve(rootDir);
+    this.cluster = cluster;
+    this.signerStore = signerStore || new SignerStore({ signerPath: join(this.rootDir, 'signer.enc.json') });
+    this.transport = transport || new SolanaTransport({ rpcUrl, cluster });
+    this.delegationPath = join(this.rootDir, 'delegation.json');
+    this.outboxPath = join(this.rootDir, 'outbox.json');
+    this.outbox = new AutoAnchorOutbox(this.outboxPath);
+    this.maxDailyTx = maxDailyTx;
+    this.active = false;
+    this.timer = null;
+    this.isProcessing = false;
+  }
+  isConfigured() {
+    return this.signerStore.hasSigner() && existsSync(this.delegationPath);
+  }
+
+  setupSigner() {
+    if (!existsSync(this.rootDir)) mkdirSync(this.rootDir, { recursive: true });
+    const { publicKeyBase58, secretKeyBuffer } = this.signerStore.generateKeypair();
+    this.signerStore.saveSignerSecretKey(secretKeyBuffer, { publicKeyBase58 });
+    return { publicKeyBase58 };
+  }
+
+  getDelegationChallenge({ ownerPubkey }) {
+    const signerPubkey = this.signerStore.getPublicKey();
+    if (!signerPubkey) throw new Error('Automation signer must be initialized first');
+    const issuedAt = new Date().toISOString();
+    const expiresAt = new Date(Date.now() + DEFAULT_DELEGATION_EXPIRY_DAYS * 24 * 60 * 60 * 1000).toISOString();
+    const descriptor = {
+      schema: 'enigma.delegated_signer_authorization.v1',
+      owner_pubkey: ownerPubkey,
+      signer_pubkey: signerPubkey,
+      cluster: this.cluster,
+      policy: 'spl-memo-proof-anchoring-only',
+      max_fee_lamports: MAX_AUTO_ANCHOR_FEE_LAMPORTS,
+      issued_at: issuedAt,
+      expires_at: expiresAt,
+    };
+    const authorizationHash = computeAuthorizationHash(descriptor);
+    const challenge = buildDelegationChallenge({ ...descriptor, authorization_hash: authorizationHash });
+    return {
+      challenge,
+      descriptor: { ...descriptor, authorization_hash: authorizationHash },
+      signerPubkey,
+      ownerPubkey,
+      cluster: this.cluster,
+      issuedAt,
+      expiresAt,
+      authorizationHash,
+    };
+  }
+  getDelegation() {
+    try {
+      const data = JSON.parse(readFileSync(this.delegationPath, 'utf8'));
+      const verification = verifyDelegationArtifact(data, { expectedCluster: this.cluster });
+      return verification.ok ? data : null;
+    } catch {
+      return null;
+    }
+  }
+
+  setDelegation(delegationArtifact) {
+    const verified = verifyDelegationArtifact(delegationArtifact, { expectedCluster: this.cluster });
+    if (!verified.ok) throw new Error(`Invalid delegation authorization: ${verified.error}`);
+    if (!existsSync(this.rootDir)) mkdirSync(this.rootDir, { recursive: true });
+    writeFileSync(this.delegationPath, JSON.stringify(delegationArtifact, null, 2), 'utf8');
+    return true;
+  }
+
+  get24HourTxCount() {
+    const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+    return this.outbox.history.filter((item) => new Date(item.confirmedAt).getTime() >= oneDayAgo).length;
+  }
+
+  async processNextOutboxItem({ force = false } = {}) {
+    if (this.isProcessing) return { ok: false, skipped: true, reason: 'Processing already in progress' };
+    if (!this.active && !force) return { ok: false, skipped: true, reason: 'Auto-anchor engine is inactive' };
+    const item = this.outbox.peek();
+    if (!item) return { ok: true, skipped: true, reason: 'Outbox queue is empty' };
+    // Rate limiting: daily velocity cap
+    const dailyCount = this.get24HourTxCount();
+    if (dailyCount >= this.maxDailyTx) {
+      this.outbox.markFailed(item.id, `Daily transaction velocity limit reached (${dailyCount}/${this.maxDailyTx})`);
+      return { ok: false, error: 'DAILY_VELOCITY_LIMIT_REACHED' };
+    }
+
+    this.isProcessing = true;
+    this.outbox.markProcessing(item.id);
+
+    try {
+      const pubkey = this.signerStore.getPublicKey();
+      if (!pubkey) throw new Error('Signer public key not configured');
+
+      const { lamports } = await this.transport.getBalance(pubkey);
+      if (lamports < MAX_AUTO_ANCHOR_FEE_LAMPORTS) {
+        this.outbox.markFailed(item.id, `Insufficient signer funds: ${lamports} lamports available (minimum ${MAX_AUTO_ANCHOR_FEE_LAMPORTS} required)`);
+        return { ok: false, error: 'INSUFFICIENT_FUNDS', lamports };
+      }
+
+      const delegation = this.getDelegation();
+      if (!delegation) {
+        throw new Error('Valid owner delegation authorization required before broadcasting on-chain');
+      }
+
+      // Check delegation binds this exact automation signer public key
+      if (delegation.signer_pubkey !== pubkey) {
+        throw new Error(`Delegation signer public key mismatch: authorized for ${delegation.signer_pubkey}, but active signer is ${pubkey}`);
+      }
+
+      // Check authorization hash if enqueued item specified one
+      if (item.authorizationHash && delegation.authorization_hash !== item.authorizationHash) {
+        throw new Error(`Authorization hash mismatch: queued for ${item.authorizationHash}, active is ${delegation.authorization_hash}`);
+      }
+
+      // Check delegation expiry
+      if (new Date(delegation.expires_at).getTime() < Date.now()) {
+        throw new Error('Delegation authorization has expired');
+      }
+
+      const secretKey = this.signerStore.loadSignerSecretKey();
+      const memoRef = {
+        v: 1,
+        protocol: 'enigma-proof-network',
+        rail: 'solana-memo',
+        cluster: this.cluster,
+        owner: delegation.owner_pubkey,
+        auth_hash: delegation.authorization_hash,
+        active_set_root: item.activeSetRoot,
+        receipt_log_root: item.receiptLogRoot,
+        sequence: item.sequence || 0,
+        timestamp: item.createdAt,
+      };
+
+      const result = await this.transport.broadcastMemo({
+        payerSecretKey: secretKey,
+        memoRef,
+      });
+
+      const confirmed = this.outbox.markAnchored(item.id, {
+        signature: result.signature,
+        slot: result.slot,
+        cluster: this.cluster,
+      });
+
+      return { ok: true, item: confirmed, result };
+    } catch (err) {
+      this.outbox.markFailed(item.id, err.message);
+      return { ok: false, error: err.message };
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  start(intervalMs = 3000) {
+    this.active = true;
+    if (!this.timer) {
+      this.timer = setInterval(() => {
+        this.processNextOutboxItem().catch(() => {});
+      }, intervalMs);
+    }
+  }
+
+  stop() {
+    this.active = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  getStatus() {
+    return {
+      configured: this.isConfigured(),
+      active: this.active,
+      signerPublicKey: this.signerStore.getPublicKey(),
+      delegation: this.getDelegation(),
+      pendingOutboxCount: this.outbox.queue.length,
+      historicalAnchorCount: this.outbox.history.length,
+      dailyTxCount: this.get24HourTxCount(),
+      maxDailyTx: this.maxDailyTx,
+    };
+  }
+}

package/packages/terminal-console/banner.mjs

@@ -0,0 +1,91 @@
+import { ANSI } from '../terminal-tui/merkle-tree-renderer.mjs';
+import { ENIGMA_VERSION } from '../core/src/version.mjs';
+
+export const OFFICIAL_TOKEN_CA = 'EknDj8VZUHL6FhV9pSk3m6xP2U2sDzwjRDVstKeQpump';
+
+export function renderTerminalBanner({ color = true } = {}) {
+  const c = (text, code) => (color ? `${code}${text}${ANSI.reset}` : text);
+
+  const lines = [
+    c('  ███████╗███╗   ██╗██╗ ██████╗ ███╗   ███╗ █████╗ ', `${ANSI.bold}${ANSI.amber}`),
+    c('  ██╔════╝████╗  ██║██║██╔════╝ ████╗ ████║██╔══██╗', `${ANSI.bold}${ANSI.amber}`),
+    c('  █████╗  ██╔██╗ ██║██║██║  ███╗██╔████╔██║███████║', `${ANSI.bold}${ANSI.amberGlow}`),
+    c('  ██╔══╝  ██║╚██╗██║██║██║   ██║██║╚██╔╝██║██╔══██║', `${ANSI.bold}${ANSI.amberGlow}`),
+    c('  ███████╗██║ ╚████║██║╚██████╔╝██║ ╚═╝ ██║██║  ██║', `${ANSI.bold}${ANSI.amber}`),
+    c('  ╚══════╝╚═╝  ╚═══╝╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝', `${ANSI.bold}${ANSI.amber}`),
+    '',
+    `  ${c('ENIGMA SOVEREIGN AI MEMORY TERMINAL', `${ANSI.bold}${ANSI.white}`)} ${c(`v${ENIGMA_VERSION}`, ANSI.gray)}`,
+    `  ${c('Decentralized Context Layer for Autonomous AI on Solana', ANSI.dimText)}`,
+    `  ${c('● LIVE TOKEN CA:', `${ANSI.bold}${ANSI.amber}`)} ${c(OFFICIAL_TOKEN_CA, `${ANSI.bold}${ANSI.white}`)}`,
+    `  ${c('Security Mode:', ANSI.gray)} ${c('Local Standalone', ANSI.green)} | ${c('Developer Default: Plaintext Keyring (Set ENIGMA_PASSPHRASE for AES-GCM Encryption)', ANSI.dim)}`,
+    '',
+    c('  Type "help" or "?" to list commands, "constellation" or "matrix" for animations.', ANSI.gray),
+    c('  ----------------------------------------------------------------------------------', ANSI.dim),
+  ];
+
+  return lines.join('\n');
+}
+
+export function renderHelpCatalog({ color = true } = {}) {
+  const c = (text, code) => (color ? `${code}${text}${ANSI.reset}` : text);
+
+  const sections = [
+    `  ${c('CORE MEMORY COMMANDS', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    ${c('quickstart', ANSI.cyan)} [--overwrite]           Initialize a new sovereign memory vault bundle`,
+    `    ${c('remember', ANSI.cyan)} <text> [--purpose <p>]   Ingest an encrypted memory atom with signed receipt`,
+    `    ${c('context', ANSI.cyan)} <query> [--out <path>]    Query purpose-scoped context pack`,
+    `    ${c('doctor', ANSI.cyan)}                             Verify local runtime, keyring, and connector health`,
+    '',
+    `  ${c('VISUALIZATION & TELEMETRY', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    ${c('tree', ANSI.cyan)} [--depth <n>]                 Render live ASCII Merkle tree with proof verification path`,
+    `    ${c('tui', ANSI.cyan)} | ${c('dashboard', ANSI.cyan)}                 Open full-screen terminal control plane dashboard`,
+    `    ${c('monitor', ANSI.cyan)} [--interval <ms>]          Stream real-time vault telemetry and MCP events`,
+    `    ${c('constellation', ANSI.cyan)}                      Run animated multi-node context mesh visualization`,
+    `    ${c('matrix', ANSI.cyan)}                             Stream animated cryptographic hash rain`,
+    '',
+    `  ${c('ENTERPRISE SECURITY & SWARM', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    ${c('enclave cycle', ANSI.cyan)}                      Execute atomic key zeroization with signed receipt`,
+    `    ${c('enclave attest', ANSI.cyan)}                     Generate simulated PCR attestation measurement`,
+    `    ${c('enclave verify', ANSI.cyan)} <receipt_path>      Verify enclave zeroization receipt offline`,
+    `    ${c('swarm status', ANSI.cyan)}                       Inspect multi-agent namespace fencing and metadata`,
+    `    ${c('swarm graph', ANSI.cyan)}                        View memory entity and associative relation graph`,
+    '',
+    `  ${c('SOLANA & DECENTRALIZED PROOFS', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    ${c('solana status', ANSI.cyan)}                       Probe Solana RPC health without exposing memory plaintext`,
+    `    ${c('solana stream', ANSI.cyan)} | ${c('pulse', ANSI.cyan)}                Stream live Solana blockchain heartbeat & block metrics`,
+    `    ${c('solana anchor-bundle', ANSI.cyan)} --out <file>   Build public-safe bundle root anchor batch for Solana Memo`,
+    `    ${c('solana submit', ANSI.cyan)} --file <file>          Dry-run or execute SPL Memo proof anchoring`,
+    `    ${c('solana verify-anchor', ANSI.cyan)} --sig <tx> --file <file> Verify on-chain SPL Memo proof commitment against local artifact`,
+    `    ${c('wallet connect', ANSI.cyan)}                     Connect Phantom browser wallet via authenticated companion`,
+    `    ${c('wallet status', ANSI.cyan)}                      Inspect active connected wallet and balance`,
+    `    ${c('wallet disconnect', ANSI.cyan)}                  Disconnect active wallet session`,
+    `    ${c('token', ANSI.cyan)} | ${c('ca', ANSI.cyan)}                         Display official Solana token CA and launch coordinates`,
+    `    ${c('export', ANSI.cyan)} [--out <path>]              Export self-contained cryptographic proof bundle`,
+    `    ${c('verify', ANSI.cyan)} [--export <path>]           Perform 100% offline verification across all receipts`,
+    '',
+  `  ${c('ZKCP MARKETPLACE // CLIENT-PROVEN FAIR EXCHANGE', `${ANSI.bold}${ANSI.amber}`)}`,
+  `    ${c('market status', ANSI.cyan)}                      Inspect local marketplace configuration, circuit parameters, and custody state`,
+  `    ${c('market list', ANSI.cyan)}                        List local saleable memory listings from ZK state`,
+  `    ${c('market verify', ANSI.cyan)} --listing <file>      Verify delivered ciphertext fold against 32-chunk Poseidon commitments`,
+  `    ${c('market demo', ANSI.cyan)}                        Run simulated ZKCP fair-exchange fixture demo`,
+    `  ${c('GHOSTMESH // ENCRYPTED P2P RELAY LAYER', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    ${c('mesh status', ANSI.cyan)}                        Inspect local destination hash, peer count, and store-forward queue`,
+    `    ${c('mesh announce', ANSI.cyan)}                      Broadcast Ed25519-signed announce packet across active transports`,
+    `    ${c('mesh send', ANSI.cyan)} --to <dest> --memory <m> Seal & route E2EE memory capsule via multi-hop mesh`,
+    `    ${c('mesh demo', ANSI.cyan)}                          Run in-memory multi-node multi-transport mesh simulation`,
+    '',
+    `  ${c('TERMINAL CONTROLS', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    ${c('clear', ANSI.cyan)} | ${c('cls', ANSI.cyan)}                    Clear the terminal screen`,
+    `    ${c('bundle', ANSI.cyan)} <path>                      Switch active memory bundle path`,
+    `    ${c('help', ANSI.cyan)} | ${c('?', ANSI.cyan)}                         Show this command reference`,
+    `    ${c('exit', ANSI.cyan)} | ${c('quit', ANSI.cyan)}                    Exit the Enigma Terminal Console`,
+    '',
+    `  ${c('SECURITY & AT-REST CONFIDENTIALITY NOTICE', `${ANSI.bold}${ANSI.amber}`)}`,
+    `    • ${c('Encrypted Default', ANSI.white)}: Set ${c('ENIGMA_PASSPHRASE', ANSI.cyan)} or pass ${c('--passphrase-file <path>', ANSI.cyan)}.`,
+    `      ${c('Quickstart and persistent vault access fail closed without credentials.', ANSI.dim)}`,
+    `    • ${c('INSECURE, EVALUATION ONLY', ANSI.white)}: ${c('--insecure-dev', ANSI.cyan)} creates an unencrypted disposable keyring.`,
+    `      ${c('It has NO at-rest confidentiality and must never hold normal or persistent data.', ANSI.dim)}`,
+  ];
+
+  return sections.join('\n');
+}