enigma-memory 0.1.1 → 0.1.3

package/docs/installers-and-desktop.md

@@ -0,0 +1,76 @@
+# Installers and desktop boundary
+
+Enigma Memory currently has one production install tier and several source-asset tiers. This page is intentionally conservative: it documents what can be used now, what can be generated from source, and what is blocked before native installer distribution.
+
+## Tier 1: npm package now
+
+Use the published package path when you want the current supported local install:
+
+```sh
+npm install -g enigma-memory
+enigma quickstart --bundle ./.enigma/bundle.json --overwrite
+enigma doctor
+```
+
+The package exposes the CLI bins `enigma`, `enigma-verify`, `enigma-mcp`, `enigma-relay`, `enigma-gateway`, and `enigma-native-host`. Node.js `>=24` is required. The local quickstart writes Enigma-controlled local artifacts only; it does not prove provider deletion, model forgetting, hosted availability, compliance certification, savings, or provider-native memory removal.
+
+## Tier 2: generated source installer assets
+
+The source checkout includes `scripts/build-installer-assets.mjs`, a dependency-free generator for reviewable installer source assets. Dry-run is the default:
+
+```sh
+node scripts/build-installer-assets.mjs --out-dir dist/installer-assets
+```
+
+Write mode is explicit:
+
+```sh
+node scripts/build-installer-assets.mjs --out-dir dist/installer-assets --write
+```
+
+Generated asset paths are listed in deterministic code-point lexical order:
+
+- `homebrew/enigma-memory.rb` — Homebrew formula draft. It is not submitted to a tap by the generator; release engineering must replace the source archive URL and SHA before any tap workflow.
+- `install-linux.sh` — POSIX shell source installer. It previews by default and only mutates global npm/local quickstart files when called with `--execute`.
+- `install-windows.ps1` — PowerShell source installer. It previews by default and only runs `npm install -g enigma-memory`, `enigma quickstart`, and `enigma doctor` when called with `-Execute`.
+- `installer-assets-manifest.json` — deterministic public manifest with checksums for the generated source assets.
+- `macos-pkgbuild/README.md` — macOS package source plan and blockers, not a signed package.
+- `macos-pkgbuild/manifest.json` — macOS package source metadata and blockers, not a signed package.
+
+The generator intentionally redacts the requested output directory in its public manifest as `<requested-output-dir>`. The generated content must not embed tokens, local absolute paths, account identifiers, raw memory, provider transcripts, signing identities, or hosted credentials.
+
+## Native `.exe` and `.pkg` blockers
+
+No signed Windows `.exe` or signed/notarized macOS `.pkg` exists from this generator.
+
+Windows `.exe` distribution is blocked on:
+
+- A selected native installer builder and reproducible input tree.
+- A Windows code-signing certificate and signing workflow.
+- Release review that installer logs and metadata do not expose local paths, credentials, account data, raw memory, or provider transcripts.
+
+macOS `.pkg` distribution is blocked on:
+
+- macOS release runner access with `pkgbuild` and `productbuild`.
+- A staged package layout for npm-installed command shims and package resources.
+- Developer ID Installer certificate selection, signing, and notarization.
+- Release review of package scripts and evidence output.
+
+Until those blockers are cleared, use npm or generated source scripts only.
+
+## Homebrew path
+
+The formula generated under `homebrew/enigma-memory.rb` is a draft for a future tap workflow. It records the intended package name, license, Node dependency, command shims, and test shape. Before publication, release engineering must replace the placeholder tarball URL and SHA with a real release archive and confirm the formula installs only the intended package files.
+
+## Desktop tray model boundary
+
+`apps/desktop/src/tray.js` is a pure tray model module. It exposes deterministic state/menu/action helpers for:
+
+- status
+- quickstart
+- connect clients
+- open docs
+- run diagnostics
+- quit
+
+It does not start a native tray process, create OS menu items, run shell commands, launch browsers, configure MCP clients, or quit a process. Host applications such as Electron, Tauri, WebView, or native wrappers must translate its action intents into real side effects and own their own OS integration, evidence capture, and shutdown behavior.

package/docs/memory-benchmarks.md

@@ -0,0 +1,82 @@
+# Memory benchmarks
+
+Enigma includes a local, dependency-free memory benchmark harness for package-readiness evidence:
+
+```sh
+cd enigma
+node scripts/run-memory-benchmarks.mjs
+node scripts/run-memory-benchmarks.mjs --out ./.enigma/memory-benchmark.json
+```
+
+The report schema is `enigma.memory_benchmark_suite.v1`. It is public-safe by design: aggregate metrics, commitments, citations, boundaries, and cross-provider profile labels are emitted, but raw fixture memory, question text, and answer text are not included.
+
+## External standards and boundaries
+
+- LoCoMo is the relevant long-term conversational-memory standard for multi-session QA, event summarization, and multimodal generation over long conversations. See https://snap-research.github.io/locomo/.
+- LongMemEval is the relevant standard for information extraction, multi-session reasoning, temporal reasoning, knowledge updates, and abstention. See https://arxiv.org/abs/2410.10813.
+- Letta's benchmark discussion is a useful boundary reminder: measured memory quality depends on the agent/framework/tool loop as well as memory-store mechanics. See https://www.letta.com/blog/benchmarking-ai-agent-memory/.
+
+This repository harness does not download or run LoCoMo, LongMemEval, provider APIs, or third-party agents. It mirrors their task categories with a deterministic local fixture so Enigma can make narrow package claims about local vault operations, context-pack generation, optimizer token estimates, export/import, verification, deduplication, abstention behavior, and latency.
+
+## What the harness measures
+
+The fixture creates multiple sessions with facts, a knowledge update, temporal questions, an abstention question, duplicate memory candidates, and provider profile labels for `chatgpt`, `claude`, `kimi`, `cursor`, and `local-llm`.
+
+The harness measures local Enigma operations only:
+
+- vault remember/update operations;
+- vault export and import;
+- context-pack retrieval through the passport package;
+- optimizer plan token estimates and duplicate removal;
+- bundle and context-pack verification;
+- local baseline comparisons over the same deterministic fixture questions;
+- p50/p95 latency with `performance.now`.
+
+Reported metrics include exact-answer recall, abstention correctness, estimated prompt tokens, duplicate candidates removed where applicable, operation latency summaries, verification status, and same-boundary cross-provider profile rows.
+
+## Local baseline comparison
+
+`metrics.local_baseline_comparisons` compares Enigma against deterministic local baselines only. Every row scores the same private fixture questions and keeps raw memory, question text, and answer text out of the report.
+
+| Row | Boundary | Reported fields |
+| --- | --- | --- |
+| `full_context` | Supplies every active fixture memory without optimization or deduplication. | Recall, abstention correctness, estimated prompt tokens, selected memory count, p50/p95 local latency. |
+| `recency_last_n` | Supplies the three most recently updated active fixture memories. | Same fields; duplicate removal is marked not applicable. |
+| `keyword_filter` | Supplies active fixture memories whose content or tags match deterministic query terms. | Same fields; duplicate removal is marked not applicable. |
+| `enigma_context_pack` | Uses the Enigma passport context-pack compiler and optimizer boundary. | Same fields plus duplicate-removal counts from the Enigma optimizer plan. |
+
+These rows are local package evidence only. They do not compare hosted providers, do not use provider APIs, and do not support invoice savings, ROI, compliance, model-forgetting, or benchmark-leadership claims.
+
+## External competitor adapter requirements
+
+`external_competitor_adapters` is a requirements matrix, not a score table. Each row has `status: "not_run_requires_credentials_or_runtime"`, `can_run_in_this_harness: false`, `required_artifacts`, `official_doc`, an exact `boundary_reason`, and `scores_included: false`.
+
+| Adapter | Official source | Required artifacts before scoring | Boundary reason |
+| --- | --- | --- | --- |
+| Letta / MemGPT | https://docs.letta.com/concepts/memgpt/ | Letta API key or self-hosted runtime; pinned SDK such as `@letta-ai/letta-client` or `letta-client`; fixed agent/tools/model/memory config; operator-supplied dataset mapping. | This harness has no Letta credentials, SDK installation, runtime, fixed agent loop, or approved external dataset. |
+| LangGraph memory | https://docs.langchain.com/oss/python/langgraph/memory | Pinned LangGraph runtime; short-term checkpointer config; namespaced long-term store config; fixed graph/model/tools/dataset mapping. | This Node local package harness does not execute a LangGraph runtime, checkpointer, store, graph, model, or adapter. |
+| Zep | https://help.getzep.com/ | Zep credentials or endpoint; pinned client; temporal Context Graph or Context Lake config; ingestion and retrieval mapping. | This harness has no Zep credentials, client package, Context Graph/Context Lake runtime, ingestion job, or retrieval dataset. |
+| Mem0 | https://docs.mem0.ai/ | Mem0 platform credentials or open-source runtime; pinned SDK/package versions; extraction/update/retrieval/model/tool config; dataset mapping. | This harness has no Mem0 credentials, runtime, configured memory loop, model/tool environment, or external dataset adapter. |
+| OpenAI ChatGPT native memory | https://help.openai.com/en/articles/8590148-memory-faq | ChatGPT account/runtime with native memory enabled; account-safe evaluation protocol; dataset prompts; evidence capture that excludes personal data and credentials. | ChatGPT native memory is a consumer-app feature rather than a public API surface available to this local package harness. |
+| Claude memory tool | https://support.anthropic.com/en/articles/11145838-using-claude-memory | Claude/provider runtime with the memory tool available; client-side tool configuration; fixed model/tool-use policy/prompts/dataset mapping; safe evidence capture. | The memory tool is provider/client-side and requires a Claude runtime plus tool environment that this benchmark does not control. |
+
+No external adapter row contains recall, abstention, token, latency, or ranking scores. Third-party claims stay blocked until the required credentials, runtimes, and datasets are supplied and reviewed.
+
+## Claim limits
+
+The benchmark report is evidence for this local deterministic fixture only. It is not provider deletion proof, model forgetting proof, compliance certification, ROI evidence, provider invoice savings evidence, benchmark leadership proof, hosted cloud readiness, or a substitute for external LoCoMo/LongMemEval evaluation.
+
+Cross-provider rows are profile labels using the same Enigma context-pack boundary. External competitor rows are adapter requirements only; they do not call, score, or rank live provider models.
+
+`public_claims_allowed` is intentionally narrow: deterministic local fixture execution, local recall/abstention metrics, local baseline comparison, local token estimates, duplicate removal where applicable, p50/p95 local latency, Enigma bundle/context-pack verification, and explicit withholding of third-party scores until the required external artifacts exist.
+
+## Extending with external datasets later
+
+To extend this harness with real external benchmark datasets without weakening claim boundaries:
+
+1. Add an explicit dataset loader that reads a local file supplied by the operator; do not add network downloads to the benchmark command.
+2. Preserve source license, version, split, and checksum metadata in the report.
+3. Keep raw conversations, private memory, questions, and answers out of public reports unless the dataset license and review process explicitly allow publication.
+4. Route every candidate through the same Enigma vault, context-pack, optimizer, export, and verify operations measured here.
+5. Add separate agent/model evaluation only when the evaluated agent loop is fixed and documented; do not attribute agent/tool behavior solely to the memory store.
+6. Keep release notes bounded to the observed command, dataset, timestamp, and review approval.

package/docs/sdk-api.md

@@ -0,0 +1,181 @@
+# SDK and API guide
+
+This guide covers the public package imports for `enigma-memory@0.1.3`. The SDK runs locally by default: vaults, passports, context packs, receipts, relay/gateway demo state, storage contracts, metering artifacts, and settlement artifacts are package-level developer surfaces. They are not evidence of hosted Enigma cloud, provider-side deletion, provider model forgetting, token ROI, invoice savings, compliance certification, or benchmark leadership.
+
+## Install and import style
+
+```sh
+npm install enigma-memory
+```
+
+Use ESM imports and explicit subpaths when you know the surface you need:
+
+```js
+import { createVault, remember } from 'enigma-memory/vault';
+import { createPassport, compileContextPack } from 'enigma-memory/passport';
+```
+
+## Package exports
+
+### `enigma-memory`
+
+The package root exports the core proof helpers. Use it for canonical JSON, hashes, signatures, receipt creation, receipt-chain verification, checkpoints, Merkle sets, and deterministic memory addresses.
+
+```js
+import { verifyReceiptChain, receiptHash, MerkleSet } from 'enigma-memory';
+```
+
+### `enigma-memory/vault`
+
+The vault module creates local encrypted vault state and proof-carrying exports. Memory text is local input. Full `exportBundle` output can include a local import keyring, so publish only reviewed public summaries, receipt reports, roots, commitments, or keyring-stripped artifacts; do not use vault exports to claim provider-side deletion or model forgetting.
+
+```js
+import { createVault, remember, exportBundle, importBundle } from 'enigma-memory/vault';
+
+const vault = createVault({ subject_id: 'demo-subject' });
+const remembered = remember({ vault, text: 'Demo project prefers local proof bundles.' });
+const bundle = exportBundle({ vault });
+```
+
+### `enigma-memory/passport`
+
+The passport module describes vault ownership/scope and compiles receipt-backed context packs for authorized local retrieval.
+
+```js
+import { createPassport, compileContextPack, verifyContextPack } from 'enigma-memory/passport';
+
+const passport = createPassport({ vault, display_name: 'Demo Developer' });
+const pack = compileContextPack({ vault, passport, query: 'project preference', limit: 1 });
+const checked = verifyContextPack({ contextPack: pack, passport, vault, publicKey: bundle.keyring.publicKey });
+```
+
+### `enigma-memory/optimizer`
+
+The optimizer module builds deterministic, local memory-selection plans and plaintext-minimized access receipts. Token and cost helpers estimate from explicit inputs only; they do not prove ROI or provider invoice savings.
+
+```js
+import { createMemoryOptimizationPlan, createMemoryAccessReceipt, estimateTextTokens } from 'enigma-memory/optimizer';
+
+const plan = createMemoryOptimizationPlan({
+  candidates: [{ address: remembered.memory_addr, content: 'Demo project prefers local proof bundles.' }],
+  prompt_tokens: estimateTextTokens('Current local app context'),
+});
+const receipt = createMemoryAccessReceipt({ item: plan.items[0], plan });
+```
+
+### `enigma-memory/connectors`
+
+The connectors module renders and manages local MCP client config for supported clients. It uses the `enigma-mcp` command and an `ENIGMA_BUNDLE` environment variable.
+
+```js
+import { supportedClients, renderMcpConfig, doctorConnectors } from 'enigma-memory/connectors';
+
+const config = renderMcpConfig({ env: { ENIGMA_BUNDLE: './enigma-bundle.json' } });
+const report = await doctorConnectors({ clientId: 'generic-mcp' });
+```
+
+### `enigma-memory/mcp-server`
+
+The MCP server module exposes descriptors, handlers, JSON-RPC handling, and a stdio server for local MCP clients.
+
+```js
+import { toolDescriptors, handlers, handleJsonRpcRequest, startStdioServer } from 'enigma-memory/mcp-server';
+
+const initTool = toolDescriptors.find((tool) => tool.name === 'enigma_init');
+const reply = await handleJsonRpcRequest({ jsonrpc: '2.0', id: 1, method: 'tools/list' });
+```
+
+### `enigma-memory/relay`
+
+The relay module exposes a local relay witness service API and demo state helpers. Local relay state is useful for development and review, but it is not hosted-cloud durability evidence.
+
+```js
+import { createRelayState, createRelayServer, runRelayDemo } from 'enigma-memory/relay';
+
+const state = createRelayState({ role: 'relay_witness' });
+const server = createRelayServer({ state });
+```
+
+### `enigma-memory/gateway`
+
+The gateway module exposes a local policy gateway service API and demo state helpers. Local gateway decisions are package/source evidence unless deployed and operated with production storage, monitoring, secrets, and incident-response controls.
+
+```js
+import { createGatewayState, handleGatewayRequest, runGatewayDemo } from 'enigma-memory/gateway';
+
+const state = createGatewayState({ gateway_id: 'local-gateway' });
+const demo = runGatewayDemo();
+```
+
+### `enigma-memory/storage`
+
+The storage module emits PostgreSQL migration and operation contracts for production storage. It is a contract/builder surface; applying migrations requires your own reviewed database environment.
+
+```js
+import { productionStorageContract, buildPostgresMigration, buildRelayRecordUpsert } from 'enigma-memory/storage';
+
+const contract = productionStorageContract({ schema: 'enigma' });
+const migration = buildPostgresMigration({ schema: 'enigma' });
+```
+
+### `enigma-memory/metering`
+
+The metering module creates content-minimized usage events and deterministic aggregates. Inputs are explicit counts and metadata; outputs do not prove provider discounts or ROI.
+
+```js
+import { createUsageEvent, aggregateUsageEvents } from 'enigma-memory/metering';
+
+const event = createUsageEvent({
+  tenant_id: 'demo-tenant',
+  provider: 'local',
+  model: 'demo-model',
+  prompt_tokens: 800,
+  completion_tokens: 120,
+  memory_baseline_tokens: 1200,
+  memory_optimized_tokens: 800,
+});
+const aggregate = aggregateUsageEvents({ events: [event] });
+```
+
+### `enigma-memory/settlement`
+
+The settlement module creates hash-only memory jobs, capacity profiles, quotes, service receipts, receipt verification, and batches for permissionless access/accountability boundaries. It does not decentralize raw memory storage or inference.
+
+```js
+import { createPermissionlessMemoryJob, createOperatorServiceQuote, createServiceSettlementReceipt, verifyServiceSettlementReceipt } from 'enigma-memory/settlement';
+
+const job = createPermissionlessMemoryJob({
+  tenant_id: 'demo-tenant',
+  job_type: 'context.pack',
+  memory_commitment_root: 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+  policy_hash: 'sha256:1111111111111111111111111111111111111111111111111111111111111111',
+  usage_event_hash: 'sha256:2222222222222222222222222222222222222222222222222222222222222222',
+  requested_at: '2026-01-01T00:00:00.000Z',
+  expires_at: '2026-01-02T00:00:00.000Z',
+  max_price_amount: 10,
+  payment_asset: 'CREDITS',
+});
+```
+
+## Verifying exported proof
+
+Package consumers should verify exported bundles through the CLI or MCP verifier rather than importing source-only verifier internals. Treat full bundles as private unless you have reviewed and removed local import key material before sharing:
+
+```sh
+enigma verify --bundle enigma-export.json
+enigma-verify enigma-export.json
+```
+
+For in-process SDK checks, use exported public keys with core receipt verification:
+
+```js
+import { verifyReceiptChain } from 'enigma-memory';
+
+const report = verifyReceiptChain({
+  receipts: bundle.receipts,
+  publicKey: bundle.keyring.publicKey,
+  expectedReceiptLogRoot: bundle.vault.receipt_log_root,
+  expectedActiveSetRoot: bundle.vault.active_set_root,
+  verifyEmbeddedReceiptLogRoot: true,
+});
+```

package/examples/ci/github-actions.yml

@@ -0,0 +1,91 @@
+name: Enigma Memory smoke
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  enigma-memory-smoke:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Set up Node 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+
+      - name: Create disposable npm project
+        run: npm init -y
+
+      - name: Install Enigma Memory
+        run: npm install enigma-memory@0.1.3
+
+      - name: Expose local benchmark script
+        run: |
+          node --input-type=module <<'JS'
+          import { readFile, writeFile } from 'node:fs/promises';
+
+          const pkg = JSON.parse(await readFile('package.json', 'utf8'));
+          pkg.scripts ??= {};
+          pkg.scripts['benchmark:memory-suite'] = 'node ./node_modules/enigma-memory/scripts/run-memory-benchmarks.mjs';
+          await writeFile('package.json', `${JSON.stringify(pkg, null, 2)}\n`, 'utf8');
+          JS
+
+      - name: Run Enigma quickstart
+        run: npx enigma quickstart --overwrite
+
+      - name: Run Enigma doctor
+        run: npx enigma doctor
+
+      - name: Run local memory benchmark
+        run: |
+          npm run benchmark:memory-suite -- --out benchmark-report.json
+          mkdir -p artifacts
+          cp benchmark-report.json artifacts/benchmark-report.json
+          echo "Saved public-safe benchmark report placeholder at artifacts/benchmark-report.json"
+
+      # Optional artifact upload placeholder:
+      # If your repository already permits actions/upload-artifact, uncomment a
+      # reviewed upload step like this. The example keeps the report saved in the
+      # workspace without requiring that action.
+      # - name: Upload benchmark report
+      #   uses: actions/upload-artifact@v4
+      #   with:
+      #     name: enigma-memory-benchmark-report
+      #     path: artifacts/benchmark-report.json
+
+      - name: Smoke test package imports
+        run: |
+          node --input-type=module <<'JS'
+          import { createVault, remember, exportBundle } from 'enigma-memory/vault';
+          import { createPassport, compileContextPack } from 'enigma-memory/passport';
+          import { verifyReceiptChain } from 'enigma-memory';
+
+          const vault = createVault({ subject_id: 'ci-demo-subject' });
+          const passport = createPassport({ vault, display_name: 'CI Demo' });
+          const remembered = remember({
+            vault,
+            text: 'CI smoke uses a generic non-private Enigma Memory fact.',
+            purpose_tags: ['ci-smoke'],
+          });
+          const pack = compileContextPack({
+            vault,
+            passport,
+            memory_addresses: [remembered.memory_addr],
+            limit: 1,
+          });
+          const bundle = exportBundle({ vault, includePlaintext: false });
+          const report = verifyReceiptChain({
+            receipts: bundle.receipts,
+            publicKey: bundle.keyring.publicKey,
+            expectedReceiptLogRoot: bundle.vault.receipt_log_root,
+            expectedActiveSetRoot: bundle.vault.active_set_root,
+            verifyEmbeddedReceiptLogRoot: true,
+          });
+          if (!report.valid) throw new Error(`receipt verification failed: ${report.errors.join('; ')}`);
+          console.log(JSON.stringify({ ok: true, memory_count: pack.memory_addresses.length, receipt_count: bundle.receipts.length }));
+          JS

package/examples/node-basic-memory.mjs

@@ -0,0 +1,84 @@
+import { createVault, remember, exportBundle } from 'enigma-memory/vault';
+import { createPassport, compileContextPack, verifyContextPack } from 'enigma-memory/passport';
+import { verifyReceiptChain } from 'enigma-memory';
+
+const now = '2026-01-01T00:00:00.000Z';
+
+const vault = createVault({
+  tenant_id: 'demo-tenant',
+  subject_id: 'demo-subject',
+  actor_id: 'demo-app',
+  policy_id: 'demo-local-policy',
+  now,
+});
+
+const remembered = remember({
+  vault,
+  text: 'Demo project prefers short context packs and local receipt verification.',
+  kind: 'preference',
+  sensitivity: 'normal',
+  purpose_tags: ['demo', 'local-proof'],
+  metadata: { demo_id: 'node-basic-memory' },
+  now: '2026-01-01T00:00:01.000Z',
+});
+
+const passport = createPassport({
+  vault,
+  display_name: 'Demo Developer',
+  now: '2026-01-01T00:00:01.500Z',
+});
+
+const contextPack = compileContextPack({
+  vault,
+  passport,
+  query: 'How should this demo handle memory context?',
+  purpose: 'demo_context',
+  provider: 'local',
+  model: 'local-demo',
+  memory_addresses: [remembered.memory_addr],
+  limit: 1,
+  now: '2026-01-01T00:00:02.000Z',
+});
+
+const proofBundle = exportBundle({
+  vault,
+  includePlaintext: false,
+  now: '2026-01-01T00:00:03.000Z',
+});
+
+const publicKey = proofBundle.keyring.publicKey;
+
+const contextVerification = verifyContextPack({
+  contextPack,
+  passport,
+  vault,
+  publicKey,
+});
+
+const receiptVerification = verifyReceiptChain({
+  receipts: proofBundle.receipts,
+  publicKey,
+  expectedReceiptLogRoot: proofBundle.vault.receipt_log_root,
+  expectedActiveSetRoot: proofBundle.vault.active_set_root,
+  verifyEmbeddedReceiptLogRoot: true,
+});
+
+const summary = {
+  ok: contextVerification.valid === true && receiptVerification.valid === true,
+  vault_id: proofBundle.vault.vault_id,
+  passport_id: passport.passport_id,
+  context_pack_id: contextPack.context_pack_id,
+  active_memory_count: proofBundle.active_memory_addresses.length,
+  receipt_count: proofBundle.receipts.length,
+  active_set_root: proofBundle.vault.active_set_root,
+  receipt_log_root: proofBundle.vault.receipt_log_root,
+  remembered_memory_addr: remembered.memory_addr,
+  context_pack_memory_count: contextPack.memory_addresses.length,
+  verification: {
+    context_pack_valid: contextVerification.valid,
+    receipt_chain_valid: receiptVerification.valid,
+    receipt_errors: receiptVerification.errors,
+  },
+};
+
+console.log(JSON.stringify(summary, null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enigma-memory",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Provider-agnostic AI memory passport and offline-verifiable proof layer.",
   "license": "Apache-2.0",
@@ -28,6 +28,8 @@
     "apps/native-host/README.md",
     "apps/native-host/manifests/",
     "apps/desktop/src/",
+    "apps/browser-extension/manifest.json",
+    "apps/browser-extension/src/",
     "apps/gateway/bin/",
     "apps/gateway/src/",
     "apps/relay/src/",
@@ -39,6 +41,7 @@
     "packages/connectors/src/",
     "packages/core/src/",
     "packages/enterprise/src/",
+    "packages/hosted-cloud/src/",
     "packages/importers/src/",
     "packages/optimizer/src/",
     "packages/mcp-server/bin/",
@@ -57,6 +60,9 @@
     "scripts/check.mjs",
     "scripts/install-enigma-local.mjs",
     "scripts/verify-registry-install.mjs",
+    "scripts/run-memory-benchmarks.mjs",
+    "scripts/build-installer-assets.mjs",
+    "scripts/package-browser-extension.mjs",
     "scripts/build-production-readiness-manifest.mjs",
     "scripts/build-production-backend-env-kit.mjs",
     "scripts/cloudflare-secret-env.mjs",
@@ -103,6 +109,15 @@
     "scripts/release-provenance.mjs",
     "scripts/build-review-packet.mjs",
     "scripts/build-demo-assets.mjs",
+    "docs/sdk-api.md",
+    "docs/developer-ecosystem.md",
+    "docs/memory-benchmarks.md",
+    "docs/benchmark-reproducibility.md",
+    "docs/installers-and-desktop.md",
+    "docs/browser-extension-install.md",
+    "docs/hosted-cloud-product.md",
+    "examples/",
+    "templates/",
     "specs/"
   ],
   "bin": {
@@ -129,6 +144,9 @@
     "cloudflare:token-request": "node scripts/build-cloudflare-token-request.mjs",
     "infrastructure:readiness": "node scripts/infrastructure-readiness.mjs",
     "memory:benchmark": "node scripts/memory-optimization-benchmark.mjs",
+    "benchmark:memory-suite": "node scripts/run-memory-benchmarks.mjs",
+    "installer:assets": "node scripts/build-installer-assets.mjs",
+    "browser:extension:package": "node scripts/package-browser-extension.mjs",
     "production:manifest": "node scripts/build-production-readiness-manifest.mjs",
     "production:backend-env": "node scripts/build-production-backend-env-kit.mjs",
     "production:storage": "node scripts/build-production-storage-migration.mjs",
@@ -181,7 +199,9 @@
     "./connectors": "./packages/connectors/src/index.js",
     "./core": "./packages/core/src/index.js",
     "./desktop": "./apps/desktop/src/app.js",
+    "./desktop/tray": "./apps/desktop/src/tray.js",
     "./enterprise": "./packages/enterprise/src/index.js",
+    "./hosted-cloud": "./packages/hosted-cloud/src/index.js",
     "./gateway": "./apps/gateway/src/server.mjs",
     "./importers": "./packages/importers/src/index.js",
     "./mcp-server": "./packages/mcp-server/src/index.js",