@jhizzard/termdeck 0.2.1 → 0.2.2

package/README.md

@@ -26,7 +26,7 @@ Enabling Flashback takes **one additional 15-minute setup step** — see Tier 2
 
 ## How Flashback works
 
-When a panel's status transitions to `errored`, the server's output analyzer fires an event. The engram bridge takes the session context (type, project, last command, error tail) and queries your Engram memory store for the top similar match. If it finds one above the relevance threshold, the result is pushed to the panel's WebSocket as a `proactive_memory` message. The client renders it as a toast anchored to the panel, showing the match's project tag, source type, similarity score, and content snippet. You click the toast to expand into the Memory tab of that panel's drawer.
+When a panel's status transitions to `errored`, the server's output analyzer fires an event. The mnestra bridge takes the session context (type, project, last command, error tail) and queries your Mnestra memory store for the top similar match. If it finds one above the relevance threshold, the result is pushed to the panel's WebSocket as a `proactive_memory` message. The client renders it as a toast anchored to the panel, showing the match's project tag, source type, similarity score, and content snippet. You click the toast to expand into the Memory tab of that panel's drawer.
 
 Rate-limited to once per 30 seconds per panel. Needs RAG enabled and credentials configured (Tier 2+). Fires on **any** terminal panel — shell, Claude Code, Python server, anything.
 
@@ -39,8 +39,8 @@ TermDeck is one piece of a three-tier memory stack. Each tier adds capability; e
 | Tier | Install time | What you get |
 |---|---|---|
 | **1 — TermDeck alone** | 90 seconds | Full multiplexer, metadata, layouts, themes, tour, session history, command logging. Flashback silent. |
-| **2 — + Engram memory store** | ~15 minutes | Flashback actively fires. Cross-session recall. "Ask about this terminal" queries real memories. Optional Engram-as-MCP for Claude Code / Cursor / Windsurf. |
-| **3 — + Rumen async learning** | ~30 minutes | Async learning layer runs on a cron, synthesizes insights across projects, writes them back into Engram. Flashback starts surfacing cross-project patterns, not just direct matches. |
+| **2 — + Mnestra memory store** | ~15 minutes | Flashback actively fires. Cross-session recall. "Ask about this terminal" queries real memories. Optional Mnestra-as-MCP for Claude Code / Cursor / Windsurf. |
+| **3 — + Rumen async learning** | ~30 minutes | Async learning layer runs on a cron, synthesizes insights across projects, writes them back into Mnestra. Flashback starts surfacing cross-project patterns, not just direct matches. |
 
 ### Tier 1 — `npx @jhizzard/termdeck` (you're here)
 
@@ -61,22 +61,22 @@ What's included:
 
 What's excluded at this tier: **Flashback is silent**, the "Ask about this terminal" input returns nothing, and no memories are surfaced. All other features work.
 
-### Tier 2 — Add Engram to light up Flashback
+### Tier 2 — Add Mnestra to light up Flashback
 
-Engram is a separate npm package — `@jhizzard/engram@0.2.0` — that ships a Postgres-backed persistent memory store with an MCP server, a webhook server, six search tools, and six SQL migrations. It can be consumed by TermDeck (for Flashback), by Claude Code (as an MCP memory layer), or by any tool that speaks the MCP protocol.
+Mnestra is a separate npm package — `@jhizzard/mnestra@0.2.0` — that ships a Postgres-backed persistent memory store with an MCP server, a webhook server, six search tools, and six SQL migrations. It can be consumed by TermDeck (for Flashback), by Claude Code (as an MCP memory layer), or by any tool that speaks the MCP protocol.
 
 To enable Flashback in TermDeck:
 
 1. **Provision Postgres with pgvector.** Easiest: create a free Supabase project at supabase.com. Copy the **Project URL** and the **service_role key** from Project Settings → API.
-2. **Apply Engram's migrations** to the database. Run each in order via the Supabase SQL Editor, or via `psql`:
+2. **Apply Mnestra's migrations** to the database. Run each in order via the Supabase SQL Editor, or via `psql`:
    ```bash
-   npm install -g @jhizzard/engram
-   psql "$DATABASE_URL" -f node_modules/@jhizzard/engram/migrations/001_engram_tables.sql
-   psql "$DATABASE_URL" -f node_modules/@jhizzard/engram/migrations/002_engram_search_function.sql
-   psql "$DATABASE_URL" -f node_modules/@jhizzard/engram/migrations/003_engram_event_webhook.sql
-   psql "$DATABASE_URL" -f node_modules/@jhizzard/engram/migrations/004_engram_match_count_cap_and_explain.sql
-   psql "$DATABASE_URL" -f node_modules/@jhizzard/engram/migrations/005_v0_1_to_v0_2_upgrade.sql
-   psql "$DATABASE_URL" -f node_modules/@jhizzard/engram/migrations/006_memory_status_rpc.sql
+   npm install -g @jhizzard/mnestra
+   psql "$DATABASE_URL" -f node_modules/@jhizzard/mnestra/migrations/001_mnestra_tables.sql
+   psql "$DATABASE_URL" -f node_modules/@jhizzard/mnestra/migrations/002_mnestra_search_function.sql
+   psql "$DATABASE_URL" -f node_modules/@jhizzard/mnestra/migrations/003_mnestra_event_webhook.sql
+   psql "$DATABASE_URL" -f node_modules/@jhizzard/mnestra/migrations/004_mnestra_match_count_cap_and_explain.sql
+   psql "$DATABASE_URL" -f node_modules/@jhizzard/mnestra/migrations/005_v0_1_to_v0_2_upgrade.sql
+   psql "$DATABASE_URL" -f node_modules/@jhizzard/mnestra/migrations/006_memory_status_rpc.sql
    ```
 3. **Get an OpenAI API key** (text-embedding-3-large).
 4. **Create `~/.termdeck/secrets.env`:**
@@ -93,18 +93,18 @@ To enable Flashback in TermDeck:
      supabaseUrl: ${SUPABASE_URL}
      supabaseKey: ${SUPABASE_SERVICE_ROLE_KEY}
      openaiApiKey: ${OPENAI_API_KEY}
-     engramMode: direct
+     mnestraMode: direct
    ```
 6. **Restart TermDeck** (`Ctrl+C`, then `npx @jhizzard/termdeck` again).
 
 Flashback now fires when panels error. Initially your store is empty, so nothing surfaces. As you use TermDeck day-to-day, the output analyzer captures session events, command history, and error contexts — each one becomes a memory. After a few days of real work, Flashback starts surfacing real hits.
 
-### Tier 2 bonus — Engram as a Claude Code MCP server
+### Tier 2 bonus — Mnestra as a Claude Code MCP server
 
-Independently of TermDeck, install Engram as an MCP server so Claude Code (and Cursor / Windsurf / Cline / Continue) have persistent memory across sessions pointing at the same database TermDeck uses:
+Independently of TermDeck, install Mnestra as an MCP server so Claude Code (and Cursor / Windsurf / Cline / Continue) have persistent memory across sessions pointing at the same database TermDeck uses:
 
 ```bash
-npm install -g @jhizzard/engram
+npm install -g @jhizzard/mnestra
 ```
 
 Edit `~/.claude/mcp.json`:
@@ -112,8 +112,8 @@ Edit `~/.claude/mcp.json`:
 ```json
 {
   "mcpServers": {
-    "engram": {
-      "command": "engram",
+    "mnestra": {
+      "command": "mnestra",
       "env": {
         "SUPABASE_URL": "https://your-project.supabase.co",
         "SUPABASE_SERVICE_ROLE_KEY": "sb_secret_...",
@@ -125,11 +125,11 @@ Edit `~/.claude/mcp.json`:
 }
 ```
 
-Restart Claude Code. Six MCP tools appear: `memory_remember`, `memory_recall`, `memory_search`, `memory_forget`, `memory_status`, `memory_summarize_session`. Your AI assistant can now read and write memories that TermDeck's Flashback will later surface automatically. See [github.com/jhizzard/engram](https://github.com/jhizzard/engram) for full MCP reference.
+Restart Claude Code. Six MCP tools appear: `memory_remember`, `memory_recall`, `memory_search`, `memory_forget`, `memory_status`, `memory_summarize_session`. Your AI assistant can now read and write memories that TermDeck's Flashback will later surface automatically. See [github.com/jhizzard/mnestra](https://github.com/jhizzard/mnestra) for full MCP reference.
 
 ### Tier 3 — Add Rumen for async learning
 
-Rumen is a separate npm package — `@jhizzard/rumen@0.2.0` — that ships as a Supabase Edge Function designed to run on a 15-minute `pg_cron` schedule. It's the async reflection layer over Engram: it reads recent session memories, cross-references them with your entire historical corpus via hybrid search, synthesizes insights via Claude Haiku, and writes the results back into `rumen_insights` (a new table alongside Engram's `memory_items`). TermDeck's Flashback and Claude Code's `memory_recall` both automatically benefit because insights flow back into the same database.
+Rumen is a separate npm package — `@jhizzard/rumen@0.2.0` — that ships as a Supabase Edge Function designed to run on a 15-minute `pg_cron` schedule. It's the async reflection layer over Mnestra: it reads recent session memories, cross-references them with your entire historical corpus via hybrid search, synthesizes insights via Claude Haiku, and writes the results back into `rumen_insights` (a new table alongside Mnestra's `memory_items`). TermDeck's Flashback and Claude Code's `memory_recall` both automatically benefit because insights flow back into the same database.
 
 Rumen v0.2 is the current shipped version. Setup is still manual — Sprint 3 (next) ships a `termdeck init --rumen` one-liner that automates the deploy. For now, follow [github.com/jhizzard/rumen#readme](https://github.com/jhizzard/rumen) to deploy via the Supabase CLI.
 
@@ -162,12 +162,12 @@ Honest limits, stated upfront so the skeptic has nothing to chase:
 │  - Express + ws                         │
 │  - node-pty per session                 │
 │  - SQLite persistence                   │
-│  - Engram bridge (direct/webhook/mcp)   │
+│  - Mnestra bridge (direct/webhook/mcp)   │
 └─────────────────┬───────────────────────┘
                   │ hybrid search + embeddings
                   ▼
 ┌─────────────────────────────────────────┐
-│  Engram                                 │
+│  Mnestra                                 │
 │  - Postgres + pgvector                  │
 │  - MCP server (6 tools)                 │
 │  - HTTP webhook                         │
@@ -183,7 +183,7 @@ Honest limits, stated upfront so the skeptic has nothing to chase:
 └─────────────────────────────────────────┘
 ```
 
-All three packages are independent. You can use Engram alone as a Claude Code memory layer. You can run Rumen on any pgvector store with compatible schema. You can use TermDeck with zero memory features. The stack is designed to be progressively adopted.
+All three packages are independent. You can use Mnestra alone as a Claude Code memory layer. You can run Rumen on any pgvector store with compatible schema. You can use TermDeck with zero memory features. The stack is designed to be progressively adopted.
 
 ---
 
@@ -201,7 +201,7 @@ For users who want more than `npx` — cloning from source, building a macOS `.a
 
 ## Related packages
 
-- **[@jhizzard/engram](https://www.npmjs.com/package/@jhizzard/engram)** — persistent dev memory MCP server. pgvector + hybrid search + 3-layer progressive disclosure. Works standalone with any MCP client.
+- **[@jhizzard/mnestra](https://www.npmjs.com/package/@jhizzard/mnestra)** — persistent dev memory MCP server. pgvector + hybrid search + 3-layer progressive disclosure. Works standalone with any MCP client.
 - **[@jhizzard/rumen](https://www.npmjs.com/package/@jhizzard/rumen)** — async learning layer. Extract/Relate/Synthesize loop over any pgvector store. Supabase Edge Function + `pg_cron`.
 
 ---
@@ -218,7 +218,7 @@ npm run dev
 The server runs at `http://127.0.0.1:3000` with file-watch reload. Workspace layout:
 
 - `packages/cli/src/` — the `termdeck` binary launcher
-- `packages/server/src/` — Express + WebSocket + PTY + Engram bridge + session analyzer
+- `packages/server/src/` — Express + WebSocket + PTY + Mnestra bridge + session analyzer
 - `packages/client/public/` — vanilla-JS dashboard (single HTML file, no build step, loads xterm.js from CDN)
 - `config/` — example `config.yaml` and `secrets.env.example`
 - `docs/` — planning documents, launch strategy, install guide, followup items, ship checklist
@@ -258,7 +258,7 @@ MIT © Joshua Izzard. See [LICENSE](LICENSE).
 - GitHub: [github.com/jhizzard/termdeck](https://github.com/jhizzard/termdeck)
 - npm: [@jhizzard/termdeck](https://www.npmjs.com/package/@jhizzard/termdeck)
 - Issues: [github.com/jhizzard/termdeck/issues](https://github.com/jhizzard/termdeck/issues)
-- Engram: [github.com/jhizzard/engram](https://github.com/jhizzard/engram) · [npm](https://www.npmjs.com/package/@jhizzard/engram)
+- Mnestra: [github.com/jhizzard/mnestra](https://github.com/jhizzard/mnestra) · [npm](https://www.npmjs.com/package/@jhizzard/mnestra)
 - Rumen: [github.com/jhizzard/rumen](https://github.com/jhizzard/rumen) · [npm](https://www.npmjs.com/package/@jhizzard/rumen)
 
 Built because every LLM starts from zero, and every terminal starts from zero, and I got tired of re-debugging the same CORS error.

package/config/config.example.yaml

@@ -35,20 +35,20 @@ rag:
   # developerId: your-username (defaults to OS username)
   syncIntervalMs: 10000
 
-  # Engram bridge — how /api/ai/query talks to @jhizzard/engram.
+  # Mnestra bridge — how /api/ai/query talks to @jhizzard/mnestra.
   #   direct  — server embeds + queries Supabase itself (default, preserves v0.1 behavior)
-  #   webhook — POST to a running `engram serve` HTTP webhook (see engramWebhookUrl)
-  #   mcp     — spawn the local `engram` binary and talk JSON-RPC over stdio
-  engramMode: direct
-  engramWebhookUrl: http://localhost:37778/engram
-  # engramBinary: engram   # override path to the @jhizzard/engram CLI for mcp mode
+  #   webhook — POST to a running `mnestra serve` HTTP webhook (see mnestraWebhookUrl)
+  #   mcp     — spawn the local `mnestra` binary and talk JSON-RPC over stdio
+  mnestraMode: direct
+  mnestraWebhookUrl: http://localhost:37778/mnestra
+  # mnestraBinary: mnestra   # override path to the @jhizzard/mnestra CLI for mcp mode
 
   # Supabase table names (created by config/supabase-migration.sql)
   tables:
-    session: engram_session_memory
-    project: engram_project_memory
-    developer: engram_developer_memory
-    commands: engram_commands
+    session: mnestra_session_memory
+    project: mnestra_project_memory
+    developer: mnestra_developer_memory
+    commands: mnestra_commands
 
 # Per-session markdown logs written to ~/.termdeck/sessions/ on session exit.
 # Zero-config: works without Supabase / OpenAI. Optional LLM summary requires

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhizzard/termdeck",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Browser-based terminal multiplexer with metadata overlays, panel flashback memory recall, and AI-aware session management",
   "bin": {
     "termdeck": "./packages/cli/src/index.js"

package/packages/cli/src/index.js

@@ -3,8 +3,13 @@
 // TermDeck CLI launcher
 // Usage:
 //   termdeck [--port 3000] [--no-open]
-//   termdeck init --engram [flags]
-//   termdeck init --rumen  [flags]
+//   termdeck init --mnestra [flags]   # Tier 2 memory setup (wired to init-mnestra.js)
+//   termdeck init --rumen  [flags]   # Tier 3 async learning deploy
+//
+// Note (Sprint 3): the `--mnestra` flag name matches the current init-mnestra.js
+// filename. When the main orchestrator completes the Mnestra → Ingram rename
+// sweep over this repo, both the flag name and the filename should flip to
+// `--ingram` / `init-ingram.js` together.
 
 const path = require('path');
 const { execSync } = require('child_process');
@@ -12,10 +17,10 @@ const { execSync } = require('child_process');
 // Parse CLI args
 const args = process.argv.slice(2);
 
-// Subcommand dispatch — handle `termdeck init --engram|--rumen` before
-// falling through to the default launcher's flag parsing. This lives above
-// the launcher so `require('./init-*')` is lazy — users running the normal
-// `termdeck` command never pay the cost of loading pg / supabase helpers.
+// Subcommand dispatch — handle `termdeck init --mnestra|--rumen` before
+// falling through to the default launcher's flag parsing. The `require` of
+// init-*.js is lazy so users running the normal `termdeck` command never pay
+// the cost of loading pg / supabase helpers at startup.
 if (args[0] === 'init') {
   const mode = args[1];
   const rest = args.slice(2);
@@ -23,9 +28,9 @@ if (args[0] === 'init') {
     const fn = require(modPath);
     return fn(rest).then((code) => process.exit(code || 0));
   };
-  if (mode === '--engram') {
-    run(path.join(__dirname, 'init-engram.js')).catch((err) => {
-      console.error('[cli] init --engram failed:', err && err.stack || err);
+  if (mode === '--mnestra') {
+    run(path.join(__dirname, 'init-mnestra.js')).catch((err) => {
+      console.error('[cli] init --mnestra failed:', err && err.stack || err);
       process.exit(1);
     });
     return;
@@ -37,8 +42,8 @@ if (args[0] === 'init') {
     });
     return;
   }
-  console.error('Usage: termdeck init --engram | --rumen');
-  console.error('  termdeck init --engram   Configure Tier 2 memory (Supabase + Engram)');
+  console.error('Usage: termdeck init --mnestra | --rumen');
+  console.error('  termdeck init --mnestra   Configure Tier 2 memory (Supabase + Ingram)');
   console.error('  termdeck init --rumen    Deploy Tier 3 async learning (Rumen)');
   process.exit(1);
 }
@@ -61,7 +66,7 @@ for (let i = 0; i < args.length; i++) {
     termdeck --port 8080        Start on custom port
     termdeck --no-open          Don't auto-open browser
     termdeck --session-logs     Write per-session markdown logs to ~/.termdeck/sessions/
-    termdeck init --engram      Configure Tier 2 memory (Supabase + Engram)
+    termdeck init --mnestra      Configure Tier 2 memory (Supabase + Ingram)
     termdeck init --rumen       Deploy Tier 3 async learning (Rumen)
 
   Keyboard shortcuts (in browser):

package/packages/cli/src/init-rumen.js

@@ -2,13 +2,13 @@
 
 // `termdeck init --rumen` — interactive wizard for deploying Rumen as a
 // Supabase Edge Function + pg_cron schedule against the same Supabase
-// project that holds the Engram store.
+// project that holds the Mnemos store.
 //
 // Requirements checked at runtime:
 //   - `supabase` CLI on PATH
 //   - `deno` on PATH
 //   - `~/.termdeck/secrets.env` with SUPABASE_URL + SUPABASE_SERVICE_ROLE_KEY +
-//     DATABASE_URL + ANTHROPIC_API_KEY populated (run `termdeck init --engram` first)
+//     DATABASE_URL + ANTHROPIC_API_KEY populated (run `termdeck init --mnemos` first)
 //
 // Steps:
 //   1. Preflight: which supabase, which deno, read secrets.env
@@ -47,7 +47,7 @@ const HELP = [
   '  --skip-schedule   Deploy the function but do not install the pg_cron schedule',
   '',
   'Requires: Supabase CLI and Deno already installed.',
-  'Requires: `termdeck init --engram` has already run (needs secrets.env).',
+  'Requires: `termdeck init --mnemos` has already run (needs secrets.env).',
   ''
 ].join('\n');
 
@@ -112,14 +112,14 @@ function preflight() {
   }
   ok();
 
-  step('Reading Engram config from ~/.termdeck/secrets.env...');
+  step('Reading Mnemos config from ~/.termdeck/secrets.env...');
   const secrets = dotenv.readSecrets();
   const required = ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY', 'DATABASE_URL', 'ANTHROPIC_API_KEY'];
   const missing = required.filter((k) => !secrets[k]);
   if (missing.length > 0) {
     fail(`missing keys: ${missing.join(', ')}`);
     process.stderr.write(
-      '\nRun `termdeck init --engram` first — it writes the keys this wizard needs.\n'
+      '\nRun `termdeck init --mnemos` first — it writes the keys this wizard needs.\n'
     );
     return null;
   }
@@ -363,7 +363,7 @@ Next steps:
   1. Monitor:  psql "$DATABASE_URL" -c "SELECT * FROM rumen_jobs ORDER BY started_at DESC LIMIT 5"
   2. Store the service_role key in Supabase Vault as \`rumen_service_role_key\`
      so the cron call in migrations/002_pg_cron_schedule.sql can authenticate.
-  3. Rumen insights flow back into Engram's memory_items via rumen_insights.
+  3. Rumen insights flow back into Mnemos's memory_items via rumen_insights.
   4. TermDeck's Flashback will surface cross-project patterns automatically.
 `);
 }

package/packages/client/public/index.html

@@ -1901,7 +1901,7 @@
 
       toast.innerHTML = `
         <button class="t-dismiss" aria-label="Dismiss">×</button>
-        <div class="t-title">Engram — possible match</div>
+        <div class="t-title">Mnestra — possible match</div>
         <div class="t-body">Found a similar error in <b>${proj}</b>${score ? ` · ${score}` : ''} — click to see.</div>
         <div class="t-meta">${snippet}</div>
       `;
@@ -2596,7 +2596,7 @@
       // Early return if AI queries are not available
       if (!state.config.aiQueryAvailable) {
         entry.terminal.write(
-          '\r\n\x1b[33m[engram] AI queries are not available.\x1b[0m\r\n' +
+          '\r\n\x1b[33m[mnestra] AI queries are not available.\x1b[0m\r\n' +
           '\x1b[33mTo enable, add the following to ~/.termdeck/config.yaml:\x1b[0m\r\n' +
           '\x1b[90m  rag:\r\n' +
           '    supabaseUrl: https://your-project.supabase.co\r\n' +
@@ -2618,7 +2618,7 @@
         });
 
         if (result.error) {
-          entry.terminal.write(`\r\n\x1b[33m[engram] ${result.error}\x1b[0m\r\n`);
+          entry.terminal.write(`\r\n\x1b[33m[mnestra] ${result.error}\x1b[0m\r\n`);
         } else if (result.memories && result.memories.length > 0) {
           // Cache hits for the Memory tab
           if (!entry.memoryHits) entry.memoryHits = [];
@@ -2651,7 +2651,7 @@
             return lines;
           };
 
-          entry.terminal.write(`\r\n\x1b[36m━━━ Engram: ${result.total} memories found ━━━\x1b[0m\r\n`);
+          entry.terminal.write(`\r\n\x1b[36m━━━ Mnestra: ${result.total} memories found ━━━\x1b[0m\r\n`);
           for (const m of result.memories) {
             const score = m.similarity ? `${(m.similarity * 100).toFixed(0)}%` : '';
             const proj = m.project ? m.project : '';
@@ -2663,11 +2663,11 @@
           }
           entry.terminal.write(`\r\n\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\r\n\r\n`);
         } else {
-          entry.terminal.write(`\r\n\x1b[33m[engram] No relevant memories found.\x1b[0m\r\n`);
+          entry.terminal.write(`\r\n\x1b[33m[mnestra] No relevant memories found.\x1b[0m\r\n`);
         }
       } catch (err) {
         console.error('[client] AI query failed:', err);
-        entry.terminal.write(`\r\n\x1b[31m[engram] Query failed: ${err.message}\x1b[0m\r\n`);
+        entry.terminal.write(`\r\n\x1b[31m[mnestra] Query failed: ${err.message}\x1b[0m\r\n`);
       }
 
       inputEl.value = '';
@@ -3073,14 +3073,14 @@
       {
         target: '.ctrl-input',
         title: 'Ask about this terminal',
-        body: `Type a question here and TermDeck queries your <strong>Engram memory store</strong> for relevant context — scoped to the current panel's project. Prefix with <kbd>all:</kbd> to search every project. Results render inline in the terminal with similarity scores.`,
+        body: `Type a question here and TermDeck queries your <strong>Mnestra memory store</strong> for relevant context — scoped to the current panel's project. Prefix with <kbd>all:</kbd> to search every project. Results render inline in the terminal with similarity scores.`,
         onEnter: async () => { await openFirstPanelDrawer('overview'); },
         fallback: '#topbarQuickLaunch',
       },
       {
         target: null,
         title: 'Flashback — proactive recall',
-        body: `When a panel errors out, TermDeck <strong>automatically</strong> queries Engram for similar past errors and surfaces the top match as a toast. You don't have to ask. Rate-limited to one per 30 seconds per panel. Click the toast to open the Memory tab with the full hit expanded.`,
+        body: `When a panel errors out, TermDeck <strong>automatically</strong> queries Mnestra for similar past errors and surfaces the top match as a toast. You don't have to ask. Rate-limited to one per 30 seconds per panel. Click the toast to open the Memory tab with the full hit expanded.`,
       },
       {
         target: '.prompt-bar',

package/packages/server/src/config.js

@@ -141,13 +141,13 @@ function defaultConfig() {
       anthropicApiKey: null,
       developerId: os.userInfo().username,
       syncIntervalMs: 10000,
-      engramMode: 'direct',
-      engramWebhookUrl: 'http://localhost:37778/engram',
+      mnestraMode: 'direct',
+      mnestraWebhookUrl: 'http://localhost:37778/mnestra',
       tables: {
-        session: 'engram_session_memory',
-        project: 'engram_project_memory',
-        developer: 'engram_developer_memory',
-        commands: 'engram_commands'
+        session: 'mnestra_session_memory',
+        project: 'mnestra_project_memory',
+        developer: 'mnestra_developer_memory',
+        commands: 'mnestra_commands'
       }
     },
     sessionLogs: {
@@ -194,8 +194,8 @@ rag:
   openaiApiKey: \${OPENAI_API_KEY}
   anthropicApiKey: \${ANTHROPIC_API_KEY}
   syncIntervalMs: 10000
-  engramMode: direct
-  engramWebhookUrl: http://localhost:37778/engram
+  mnestraMode: direct
+  mnestraWebhookUrl: http://localhost:37778/mnestra
 
 sessionLogs:
   enabled: false

package/packages/server/src/index.js

@@ -17,7 +17,7 @@ try { Database = require('better-sqlite3'); } catch { Database = null; }
 const { SessionManager } = require('./session');
 const { initDatabase, logCommand, getSessionHistory, getProjectSessions } = require('./database');
 const { RAGIntegration } = require('./rag');
-const { createBridge } = require('./engram-bridge');
+const { createBridge } = require('./mnestra-bridge');
 const { writeSessionLog } = require('./session-logger');
 const { themes, statusColors } = require('./themes');
 const { loadConfig, addProject } = require('./config');
@@ -54,10 +54,10 @@ function createServer(config) {
   // Initialize session manager
   const sessions = new SessionManager(db);
 
-  // Initialize RAG + Engram bridge
+  // Initialize RAG + Mnestra bridge
   const rag = new RAGIntegration(config, db);
-  const engramBridge = createBridge(config);
-  console.log(`[engram-bridge] mode=${engramBridge.mode}`);
+  const mnestraBridge = createBridge(config);
+  console.log(`[mnestra-bridge] mode=${mnestraBridge.mode}`);
 
   // Wire RAG to session events
   sessions.on('session:created', (s) => rag.onSessionCreated(s));
@@ -171,11 +171,11 @@ function createServer(config) {
           rag.onStatusChanged(sess, oldStatus, newStatus);
         };
 
-        // Proactive Engram queries on error — fire-and-forget, respects rag.enabled
+        // Proactive Mnestra queries on error — fire-and-forget, respects rag.enabled
         session.onErrorDetected = (sess, ctx) => {
           if (!rag.enabled) return;
           const question = `${sess.meta.type} error ${ctx.lastCommand || ''} ${ctx.tail || ''}`.trim();
-          engramBridge.queryEngram({
+          mnestraBridge.queryMnestra({
             question,
             project: sess.meta.project,
             searchAll: false,
@@ -196,7 +196,7 @@ function createServer(config) {
               }
             }
           }).catch((err) => {
-            console.warn('[engram-bridge] proactive query failed:', err.message);
+            console.warn('[mnestra-bridge] proactive query failed:', err.message);
           });
         };
 
@@ -415,7 +415,7 @@ function createServer(config) {
     });
   });
 
-  // POST /api/ai/query - query Engram memory via the bridge (direct|webhook|mcp)
+  // POST /api/ai/query - query Mnestra memory via the bridge (direct|webhook|mcp)
   app.post('/api/ai/query', async (req, res) => {
     let { question, sessionId, project } = req.body;
     if (!question) return res.status(400).json({ error: 'Missing question' });
@@ -435,7 +435,7 @@ function createServer(config) {
     } : null;
 
     try {
-      const { memories, total } = await engramBridge.queryEngram({
+      const { memories, total } = await mnestraBridge.queryMnestra({
         question,
         project,
         searchAll,
@@ -455,7 +455,7 @@ function createServer(config) {
         total
       });
     } catch (err) {
-      console.error('[engram-bridge] query failed:', err.message);
+      console.error('[mnestra-bridge] query failed:', err.message);
       // Config-shaped errors are 503, everything else 502
       const msg = err.message || 'Query failed';
       const status = /not configured|OPENAI_API_KEY/i.test(msg) ? 503 : 502;

package/packages/server/src/{engram-bridge → mnestra-bridge}/index.js

@@ -1,7 +1,7 @@
-// Engram bridge — routes TermDeck memory queries through one of three backends:
+// Mnestra bridge — routes TermDeck memory queries through one of three backends:
 //   - direct:  talk to Supabase + OpenAI from the server (pre-bridge behavior)
-//   - webhook: POST to Engram's HTTP webhook server (T3.1) at rag.engramWebhookUrl
-//   - mcp:     spawn the @jhizzard/engram binary and talk JSON-RPC over stdio
+//   - webhook: POST to Mnestra's HTTP webhook server (T3.1) at rag.mnestraWebhookUrl
+//   - mcp:     spawn the @jhizzard/mnestra binary and talk JSON-RPC over stdio
 //
 // All three modes return the same shape:
 //   { memories: Array<{ content, source_type, project, similarity, created_at }>, total }
@@ -11,7 +11,7 @@
 const { spawn } = require('child_process');
 
 function createBridge(config) {
-  const mode = config.rag?.engramMode || 'direct';
+  const mode = config.rag?.mnestraMode || 'direct';
   const state = { mcpChild: null, mcpQueue: [], mcpNextId: 1, mcpBuffer: '' };
 
   async function queryDirect({ question, project, searchAll }) {
@@ -40,7 +40,7 @@ function createBridge(config) {
     });
     if (!embeddingRes.ok) {
       const err = await embeddingRes.text();
-      console.error('[engram-bridge:direct] embedding failed:', err);
+      console.error('[mnestra-bridge:direct] embedding failed:', err);
       throw new Error('Embedding generation failed');
     }
     const embeddingData = await embeddingRes.json();
@@ -68,7 +68,7 @@ function createBridge(config) {
     });
     if (!searchRes.ok) {
       const err = await searchRes.text();
-      console.error('[engram-bridge:direct] supabase search failed:', err);
+      console.error('[mnestra-bridge:direct] supabase search failed:', err);
       throw new Error('Memory search failed');
     }
     const rows = await searchRes.json();
@@ -85,7 +85,7 @@ function createBridge(config) {
   }
 
   async function queryWebhook({ question, project, searchAll }) {
-    const url = config.rag?.engramWebhookUrl || 'http://localhost:37778/engram';
+    const url = config.rag?.mnestraWebhookUrl || 'http://localhost:37778/mnestra';
     const res = await fetch(url, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -98,8 +98,8 @@ function createBridge(config) {
     });
     if (!res.ok) {
       const err = await res.text();
-      console.error('[engram-bridge:webhook] request failed:', err);
-      throw new Error(`Engram webhook returned ${res.status}`);
+      console.error('[mnestra-bridge:webhook] request failed:', err);
+      throw new Error(`Mnestra webhook returned ${res.status}`);
     }
     const data = await res.json();
     const rows = data.memories || [];
@@ -118,7 +118,7 @@ function createBridge(config) {
   function ensureMcpChild() {
     if (state.mcpChild && !state.mcpChild.killed) return state.mcpChild;
 
-    const bin = config.rag?.engramBinary || 'engram';
+    const bin = config.rag?.mnestraBinary || 'mnestra';
     const child = spawn(bin, ['serve', '--stdio'], { stdio: ['pipe', 'pipe', 'pipe'] });
     state.mcpChild = child;
     state.mcpBuffer = '';
@@ -135,24 +135,24 @@ function createBridge(config) {
           const pending = state.mcpQueue.find((p) => p.id === msg.id);
           if (pending) {
             state.mcpQueue = state.mcpQueue.filter((p) => p !== pending);
-            if (msg.error) pending.reject(new Error(msg.error.message || 'Engram MCP error'));
+            if (msg.error) pending.reject(new Error(msg.error.message || 'Mnestra MCP error'));
             else pending.resolve(msg.result);
           }
         } catch (err) {
-          console.error('[engram-bridge:mcp] parse error:', err.message, line);
+          console.error('[mnestra-bridge:mcp] parse error:', err.message, line);
         }
       }
     });
 
     child.stderr.on('data', (chunk) => {
-      console.error('[engram-bridge:mcp]', chunk.toString('utf-8').trim());
+      console.error('[mnestra-bridge:mcp]', chunk.toString('utf-8').trim());
     });
 
     child.on('exit', (code, signal) => {
-      console.warn(`[engram-bridge:mcp] child exited (code=${code}, signal=${signal}); will respawn on next call`);
+      console.warn(`[mnestra-bridge:mcp] child exited (code=${code}, signal=${signal}); will respawn on next call`);
       state.mcpChild = null;
       for (const pending of state.mcpQueue) {
-        pending.reject(new Error('Engram MCP child exited'));
+        pending.reject(new Error('Mnestra MCP child exited'));
       }
       state.mcpQueue = [];
     });
@@ -177,7 +177,7 @@ function createBridge(config) {
         const pending = state.mcpQueue.find((p) => p.id === id);
         if (pending) {
           state.mcpQueue = state.mcpQueue.filter((p) => p !== pending);
-          pending.reject(new Error('Engram MCP call timed out'));
+          pending.reject(new Error('Mnestra MCP call timed out'));
         }
       }, 15000);
     });
@@ -214,7 +214,7 @@ function createBridge(config) {
     }
   }
 
-  async function queryEngram({ question, project, searchAll }) {
+  async function queryMnestra({ question, project, searchAll }) {
     switch (mode) {
       case 'webhook':
         return queryWebhook({ question, project, searchAll });
@@ -226,7 +226,7 @@ function createBridge(config) {
     }
   }
 
-  return { mode, queryEngram };
+  return { mode, queryMnestra };
 }
 
 module.exports = { createBridge };

package/packages/server/src/rag.js

@@ -16,10 +16,10 @@ class RAGIntegration {
 
     // Table configuration matching Josh's multi-layer schema
     this.tables = {
-      sessionMemory: config.rag?.tables?.session || 'engram_session_memory',
-      projectMemory: config.rag?.tables?.project || 'engram_project_memory',
-      developerMemory: config.rag?.tables?.developer || 'engram_developer_memory',
-      commandLog: config.rag?.tables?.commands || 'engram_commands'
+      sessionMemory: config.rag?.tables?.session || 'mnestra_session_memory',
+      projectMemory: config.rag?.tables?.project || 'mnestra_project_memory',
+      developerMemory: config.rag?.tables?.developer || 'mnestra_developer_memory',
+      commandLog: config.rag?.tables?.commands || 'mnestra_commands'
     };
 
     if (this.enabled) {
@@ -120,7 +120,7 @@ class RAGIntegration {
       }
     } catch (err) {
       // Will be retried by sync loop
-      console.error('[engram] Push failed:', err.message);
+      console.error('[mnestra] Push failed:', err.message);
     }
   }
 
@@ -163,7 +163,7 @@ class RAGIntegration {
           markRagEventsSynced(this.db, synced);
         }
       } catch (err) {
-        console.error('[engram] Sync cycle error:', err.message);
+        console.error('[mnestra] Sync cycle error:', err.message);
       }
     }, this.syncInterval);
   }