vektor-slipstream 1.1.0 → 1.1.2

package/README.md

@@ -1,252 +1,52 @@
-\# vektor-slipstream
-
-
-
-\*\*Hardware-accelerated persistent memory for AI agents.\*\*  
-
-Local-first. Zero cloud dependency. $0 embedding cost.
-
-
-
-```bash
-
-npm install vektor-slipstream
-
-```
-
-
-
-\---
-
-
-
-\## What it is
-
-
-
-A drop-in memory layer for any AI agent. Your agent remembers everything across sessions — preferences, decisions, research, conversations — stored in a single portable SQLite file on your machine.
-
-
-
-No OpenAI embedding bill. No cloud roundtrip. No API key for memory.
-
-
-
-```js
-
-const { createMemory } = require('vektor-slipstream');
-
-
-
-const memory = await createMemory({ agentId: 'my-agent' });
-
-
-
-// Store a memory
-
-await memory.remember('User prefers TypeScript over JavaScript');
-
-
-
-// Recall by semantic similarity — avg 8ms, fully local
-
-const results = await memory.recall('coding preferences');
-
-// → \[{ content: 'User prefers TypeScript...', score: 0.97, id: 1 }]
-
-```
-
-
-
-\---
-
-
-
-\## How it works
-
-
-
-\- \*\*Local ONNX embeddings\*\* — `all-MiniLM-L6-v2 INT8` runs on your hardware via `onnxruntime-node`. No API calls.
-
-\- \*\*Hyper-PRAGMA SQLite\*\* — WAL mode, 1GB mmap, 64MB cache. Recall at RAM speeds.
-
-\- \*\*MAGMA graph\*\* — 4-layer associative graph (semantic · causal · temporal · entity). Memories connect to each other.
-
-\- \*\*Hardware auto-detection\*\* — uses CUDA on NVIDIA, CoreML on Apple Silicon, CPU everywhere else.
-
-
-
-\---
-
-
-
-\## API
-
-
-
-```js
-
-const { createMemory } = require('vektor-slipstream');
-
-
-
-const memory = await createMemory({
-
-  agentId: 'my-agent',      // isolates memories per agent
-
-  dbPath:  './memory.db',   // default: ./slipstream-memory.db
-
-  silent:  false,           // suppress boot banner
-
-});
-
-```
-
-
-
-\### `memory.remember(text, opts?)`
-
-Store a memory with its vector embedding.
-
-```js
-
-const { id } = await memory.remember('User is based in Brisbane, AU');
-
-const { id } = await memory.remember('Closed Series A at $4M', { importance: 5 });
-
-```
-
-
-
-\### `memory.recall(query, topK?)`
-
-Semantic recall — returns top-k most relevant memories.
-
-```js
-
-const results = await memory.recall('user location', 5);
-
-// → \[{ id, content, score, importance }]
-
-```
-
-
-
-\### `memory.graph(concept, opts?)`
-
-Breadth-first traversal from a concept — finds connected memories.
-
-```js
-
-const { nodes, edges } = await memory.graph('fundraising', { hops: 2 });
-
-```
-
-
-
-\### `memory.delta(topic, days?)`
-
-What changed on a topic in the last N days.
-
-```js
-
-const changes = await memory.delta('project status', 7);
-
-```
-
-
-
-\### `memory.briefing()`
-
-Summary of everything learned in the last 24 hours. Inject into system prompt.
-
-```js
-
-const brief = await memory.briefing();
-
-// → "\[SLIPSTREAM BRIEFING — last 24h — 12 memories]\\n1. ..."
-
-```
-
-
-
-\---
-
-
-
-\## Examples
-
-
-
-Three production-ready agent examples are included in `examples/`:
-
-
-
-| File | Description |
-
-|------|-------------|
-
-| `example-langchain-researcher.js` | LangChain agent that builds a persistent knowledge base |
-
-| `example-openai-assistant.js` | OpenAI assistant with automatic cross-session memory |
-
-| `example-claude-mcp.js` | Claude MCP server + direct chat mode |
-
-
-
-See \[`examples/README.md`](examples/README.md) for setup and usage.
-
-
-
-\---
-
-
-
-\## Performance
-
-
-
-| Metric | Value |
-
-|--------|-------|
-
-| Recall latency | \~8ms avg (local SQLite) |
-
-| Embedding cost | $0 — fully local ONNX |
-
-| Embedding latency | \~10ms GPU / \~25ms CPU (post-warmup) |
-
-| DB engine | SQLite WAL + 1GB mmap |
-
-| Vector dimensions | 384 (all-MiniLM-L6-v2 INT8) |
-
-
-
-\---
-
-
-
-\## Requirements
-
-
-
-\- Node.js 18+
-
-\- \~25MB disk for the ONNX model (bundled)
-
-
-
-\---
-
-
-
-\## License
-
-
-
-Commercial licence — see LICENSE file.  
-
-One-time purchase includes all future updates.  
-
-Purchase at \[vektormemory.com](https://vektormemory.com)
-
+# vektor-slipstream
+
+Hardware-accelerated persistent memory for AI agents. Local-first. No cloud. One-time payment.
+
+## Install
+```bash
+npm install vektor-slipstream
+npx vektor setup
+```
+
+## Quick Start
+```js
+const { createMemory } = require('vektor-slipstream');
+
+const memory = await createMemory({
+  agentId:    'my-agent',
+  licenceKey: process.env.VEKTOR_LICENCE_KEY,
+});
+
+await memory.remember('User prefers TypeScript over JavaScript');
+const results = await memory.recall('coding preferences');
+// → [{ content, score, id }]
+```
+
+## CLI
+```bash
+npx vektor setup       # First-run wizard
+npx vektor activate    # Activate licence key
+npx vektor test        # Test memory engine
+npx vektor status      # System health check
+npx vektor mcp         # Start Claude MCP server
+npx vektor rem         # Run REM dream cycle
+npx vektor help        # All commands
+```
+
+## What's Included
+
+- **MAGMA graph** — 4-layer associative memory (semantic, causal, temporal, entity)
+- **AUDN curation** — zero contradictions, zero duplicates
+- **REM dream cycle** — 50:1 memory compression
+- **Claude MCP server** — persistent memory for Claude Desktop
+- **Cloak** — stealth browser, AES-256 vault, layout sensor
+- **Mistral bridge** — vektor_memoire tool for Le Chat
+- **LangChain · OpenAI · Gemini · Groq · Ollama** — all supported
+- **Local ONNX embeddings** — $0 embedding cost, no API key
+- **Single SQLite file** — portable, yours forever
+
+## Licence
+
+Commercial licence. One-time payment. 3-machine activation via Polar.  
+Purchase at: https://vektormemory.com/product#pricing  
+Support: hello@vektormemory.com

package/examples/example-claude-mcp.js

@@ -1,305 +1,184 @@
+#!/usr/bin/env node
+'use strict';
+
 /**
- * example-claude-mcp.js
- * VEKTOR SLIPSTREAM — Claude MCP Agent Example
- * ─────────────────────────────────────────────
- * Two modes:
- *   1. MCP SERVER MODE  — stdio MCP server for Claude Desktop (--mcp flag)
- *   2. DIRECT CHAT MODE — interactive chat with memory
- *
- * MCP server mode (claude_desktop_config.json):
- *   {
- *     "mcpServers": {
- *       "slipstream": {
- *         "command": "node",
- *         "args": ["/path/to/example-claude-mcp.js", "--mcp"],
- *         "env": {
- *           "VEKTOR_LICENCE_KEY": "YOUR-KEY",
- *           "SLIPSTREAM_AGENT_ID": "claude-desktop"
- *         }
- *       }
- *     }
- *   }
- *
- * Direct chat mode:
- *   ANTHROPIC_API_KEY=sk-ant-... node example-claude-mcp.js
+ * VEKTOR SLIPSTREAM — Claude Desktop MCP Server
+ * Responds to initialize immediately, loads memory lazily
  */
 
-'use strict';
+const path = require('path');
+const os   = require('os');
 
-const { createMemory } = require('vektor-slipstream');
-const Anthropic        = require('@anthropic-ai/sdk');
-const readline         = require('readline');
+const IS_MCP = process.argv.includes('--mcp');
+if (!IS_MCP) { require('./example-claude-direct'); return; }
 
-const IS_MCP   = process.argv.includes('--mcp');
-const AGENT_ID = process.env.SLIPSTREAM_AGENT_ID || 'claude-mcp';
-const MODEL    = 'claude-haiku-4-5-20251001';
+// ── Tool definitions (static, no requires needed) ─────────────────────────────
 
-// ── MCP Tool Definitions ──────────────────────────────────────────────────────
-
-const MCP_TOOLS = [
+const TOOLS = [
   {
     name: 'vektor_recall',
-    description: 'Search Slipstream persistent memory for relevant context. Call before answering any question that might have prior context.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string',  description: 'What to search for.' },
-        top_k: { type: 'integer', description: 'Number of results (default 5, max 20).', default: 5 },
-      },
-      required: ['query'],
-    },
+    description: 'Search persistent memory. Call before answering anything that might have prior context.',
+    input_schema: { type: 'object', properties: { query: { type: 'string' }, top_k: { type: 'integer', default: 5 } }, required: ['query'] },
   },
   {
     name: 'vektor_store',
-    description: 'Store a fact, preference, decision, or piece of context in persistent memory.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        content:    { type: 'string', description: 'The memory to store as a clear complete sentence.' },
-        importance: { type: 'number', description: 'Importance 1-5. 5=critical, 3=useful, 1=minor.' },
-      },
-      required: ['content'],
-    },
+    description: 'Store a fact, preference, or decision in persistent memory.',
+    input_schema: { type: 'object', properties: { content: { type: 'string' }, importance: { type: 'number' } }, required: ['content'] },
   },
   {
     name: 'vektor_graph',
-    description: 'Traverse the memory graph from a concept — finds connected memories and relationships.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        concept: { type: 'string',  description: 'The concept to start from.' },
-        hops:    { type: 'integer', description: 'Traversal depth 1-3 (default 2).', default: 2 },
-      },
-      required: ['concept'],
-    },
+    description: 'Traverse the memory graph from a concept.',
+    input_schema: { type: 'object', properties: { concept: { type: 'string' }, hops: { type: 'integer', default: 2 } }, required: ['concept'] },
   },
   {
     name: 'vektor_delta',
-    description: 'See what changed in memory on a topic over recent days.',
-    input_schema: {
-      type: 'object',
-      properties: {
-        topic: { type: 'string',  description: 'The topic to check.' },
-        days:  { type: 'integer', description: 'How many days back (default 7).', default: 7 },
-      },
-      required: ['topic'],
-    },
+    description: 'See what changed in memory on a topic.',
+    input_schema: { type: 'object', properties: { topic: { type: 'string' }, days: { type: 'integer', default: 7 } }, required: ['topic'] },
+  },
+  {
+    name: 'cloak_fetch',
+    description: 'Fetch a URL using stealth headless browser. Returns clean compressed text. Saves tokens vs raw HTML.',
+    input_schema: { type: 'object', properties: { url: { type: 'string' }, force: { type: 'boolean' } }, required: ['url'] },
+  },
+  {
+    name: 'cloak_render',
+    description: 'Render a page and return computed CSS layout, fonts, and gap analysis.',
+    input_schema: { type: 'object', properties: { url: { type: 'string' }, selectors: { type: 'array', items: { type: 'string' } } }, required: ['url'] },
+  },
+  {
+    name: 'cloak_diff',
+    description: 'Return what semantically changed on a URL since last fetch.',
+    input_schema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+  },
+  {
+    name: 'cloak_passport',
+    description: 'Read/write to AES-256 encrypted credential vault. Omit value to read.',
+    input_schema: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'string' } }, required: ['key'] },
+  },
+  {
+    name: 'tokens_saved',
+    description: 'Calculate token savings and ROI for a session.',
+    input_schema: { type: 'object', properties: { raw_tokens: { type: 'number' }, actual_tokens: { type: 'number' }, agent_id: { type: 'string' } }, required: ['raw_tokens', 'actual_tokens'] },
   },
 ];
 
-// ── Tool execution ────────────────────────────────────────────────────────────
+// ── Lazy loaders ──────────────────────────────────────────────────────────────
+
+let _memory = null;
+async function getMemory() {
+  if (_memory) return _memory;
+  const { createMemory } = require('vektor-slipstream');
+  const dbPath = process.env.VEKTOR_DB_PATH ||
+    path.join(os.homedir(), 'vektor-slipstream-memory.db');
+  _memory = await createMemory({
+    agentId:    'claude-mcp',
+    dbPath,
+    silent:     true,
+    licenceKey: process.env.VEKTOR_LICENCE_KEY,
+  });
+  return _memory;
+}
+
+let _cloak = null;
+function getCloak() {
+  if (!_cloak) _cloak = require('vektor-slipstream/cloak');
+  return _cloak;
+}
 
-async function runTool(name, input, memory) {
+// ── Tool runner ───────────────────────────────────────────────────────────────
+
+async function runTool(name, input) {
   switch (name) {
     case 'vektor_recall': {
-      const results = await memory.recall(input.query, input.top_k || 5);
-      if (!results.length) return { found: 0, memories: [] };
-      return {
-        found: results.length,
-        memories: results.map(r => ({ content: r.content, relevance: r.score, id: r.id })),
-      };
+      const mem = await getMemory();
+      const results = await mem.recall(input.query, input.top_k || 5);
+      return { found: results.length, memories: results.map(r => ({ content: r.content, score: r.score, id: r.id })) };
     }
     case 'vektor_store': {
-      const { id } = await memory.remember(input.content, { importance: input.importance || 2 });
-      return { stored: true, memory_id: id, content: input.content };
+      const mem = await getMemory();
+      const { id } = await mem.remember(input.content, { importance: input.importance || 2 });
+      return { stored: true, id, content: input.content };
     }
     case 'vektor_graph': {
-      const { nodes, edges } = await memory.graph(input.concept, { hops: input.hops || 2 });
-      return {
-        nodes: nodes.slice(0, 10).map(n => ({ id: n.id, content: n.content, importance: n.importance })),
-        edge_count: edges.length,
-        node_count: nodes.length,
-      };
+      const mem = await getMemory();
+      const { nodes, edges } = await mem.graph(input.concept, { hops: input.hops || 2 });
+      return { nodes: nodes.slice(0, 10).map(n => ({ id: n.id, content: n.content })), edge_count: edges.length };
     }
     case 'vektor_delta': {
-      const changes = await memory.delta(input.topic, input.days || 7);
-      return {
-        topic:   input.topic,
-        days:    input.days || 7,
-        changes: changes.slice(0, 10).map(c => ({ content: c.content, updated_at: c.updated_at })),
-      };
+      const mem = await getMemory();
+      const changes = await mem.delta(input.topic, input.days || 7);
+      return { topic: input.topic, changes: changes.slice(0, 10) };
+    }
+    case 'cloak_fetch': {
+      const r = await getCloak().cloak_fetch(input.url, { force: input.force });
+      return { text: r.text, tokens_saved: r.tokensSaved, from_cache: r.fromCache };
     }
-    default:
-      return { error: `Unknown tool: ${name}` };
+    case 'cloak_render':  return await getCloak().cloak_render(input.url, input.selectors || []);
+    case 'cloak_diff':    return await getCloak().cloak_diff(input.url);
+    case 'cloak_passport': return { result: getCloak().cloak_passport(input.key, input.value) || null };
+    case 'tokens_saved':  return getCloak().tokens_saved({ raw_tokens: input.raw_tokens, actual_tokens: input.actual_tokens, agent_id: input.agent_id });
+    default: return { error: `Unknown tool: ${name}` };
   }
 }
 
-// ── MCP Server Mode ───────────────────────────────────────────────────────────
-// CRITICAL: Must respond to `initialize` IMMEDIATELY — before any async work.
-// Claude Desktop times out after ~2 seconds. We start listening on stdin first,
-// then load memory in the background while the handshake completes.
-
-async function runMCPServer() {
-  // Start memory loading in background — don't await yet
-  const memoryPromise = createMemory({
-    agentId:    AGENT_ID,
-    dbPath:     './claude-memory.db',
-    silent:     true,
-    licenceKey: process.env.VEKTOR_LICENCE_KEY,
-  }).catch(e => {
-    process.stderr.write('[vektor-mcp] Memory init failed: ' + e.message + '\n');
-    return null;
-  });
+// ── MCP stdio server ──────────────────────────────────────────────────────────
 
-  let memory = null; // will be set once memoryPromise resolves
+process.stdin.setEncoding('utf8');
+let buf = '';
 
-  // Start resolving memory immediately (non-blocking)
-  memoryPromise.then(m => { memory = m; });
-
-  process.stdin.setEncoding('utf8');
-  let buffer = '';
-
-  function send(obj) {
-    process.stdout.write(JSON.stringify(obj) + '\n');
-  }
-
-  process.stdin.on('data', async chunk => {
-    buffer += chunk;
-    const lines = buffer.split('\n');
-    buffer = lines.pop();
+function send(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
 
-    for (const line of lines) {
-      if (!line.trim()) continue;
+process.stdin.on('data', async chunk => {
+  buf += chunk;
+  const lines = buf.split('\n');
+  buf = lines.pop();
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let req;
+    try { req = JSON.parse(line); } catch (e) {
+      send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+      continue;
+    }
 
-      let req;
-      try {
-        req = JSON.parse(line);
-      } catch (e) {
-        send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+    if (!req || typeof req.method !== 'string') continue;
+    if (req.method.startsWith('notifications/')) continue;
+    if (!('id' in req)) continue;
+
+    try {
+      if (req.method === 'initialize') {
+        send({ jsonrpc: '2.0', id: req.id, result: {
+          protocolVersion: '2025-11-25',
+          serverInfo: { name: 'vektor-slipstream', version: '1.1.1' },
+          capabilities: { tools: {} },
+        }});
+        // Warm up memory in background after responding
+        getMemory().catch(e => process.stderr.write('[vektor-mcp] Memory init: ' + e.message + '\n'));
         continue;
       }
 
-      // Notifications — no response needed
-      if (req.method && req.method.startsWith('notifications/')) continue;
-      if (!('id' in req)) continue;
-
-      try {
-        if (req.method === 'initialize') {
-          // Respond IMMEDIATELY — do not wait for memory
-          send({
-            jsonrpc: '2.0',
-            id: req.id,
-            result: {
-              protocolVersion: '2025-11-25',
-              serverInfo: { name: 'vektor-slipstream', version: '1.0.6' },
-              capabilities: { tools: {} },
-            },
-          });
-          continue;
-        }
-
-        if (req.method === 'tools/list') {
-          send({ jsonrpc: '2.0', id: req.id, result: { tools: MCP_TOOLS } });
-          continue;
-        }
-
-        if (req.method === 'tools/call') {
-          // Wait for memory if not ready yet
-          if (!memory) memory = await memoryPromise;
-          if (!memory) {
-            send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: 'Memory not initialised' } });
-            continue;
-          }
-          const { name, arguments: args } = req.params;
-          const result = await runTool(name, args, memory);
-          send({
-            jsonrpc: '2.0',
-            id: req.id,
-            result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] },
-          });
-          continue;
-        }
-
-        // Unknown method
-        send({ jsonrpc: '2.0', id: req.id, error: { code: -32601, message: 'Method not found' } });
-
-      } catch (e) {
-        process.stderr.write('[vektor-mcp] Error: ' + e.message + '\n');
-        send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: e.message } });
+      if (req.method === 'tools/list') {
+        send({ jsonrpc: '2.0', id: req.id, result: { tools: TOOLS } });
+        continue;
       }
-    }
-  });
-
-  // Keep process alive
-  process.stdin.resume();
-}
-
-// ── Direct Chat Mode ──────────────────────────────────────────────────────────
-
-async function runDirectChat() {
-  console.log('\n[CLAUDE+SLIPSTREAM] Booting Slipstream memory...');
-
-  const memory = await createMemory({
-    agentId:    AGENT_ID,
-    dbPath:     './claude-memory.db',
-    silent:     false,
-    licenceKey: process.env.VEKTOR_LICENCE_KEY,
-  });
-
-  const client   = new Anthropic();
-  const messages = [];
-  const briefing = await memory.briefing();
-
-  const system = `You are a persistent assistant with long-term memory via VEKTOR Slipstream.
-
-You have four memory tools: vektor_recall, vektor_store, vektor_graph, vektor_delta.
-- Always recall before answering questions that might have prior context
-- Store important facts the user shares
-- Be proactive about remembering preferences and decisions
-
-${briefing}`;
 
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const prompt = () => new Promise(resolve => rl.question('\nYou: ', resolve));
-
-  console.log('\n[CLAUDE+SLIPSTREAM] Ready. Memories persist across sessions.');
-  console.log('[CLAUDE+SLIPSTREAM] Type "exit" to quit.\n');
-
-  while (true) {
-    const userInput = (await prompt()).trim();
-    if (!userInput) continue;
-    if (userInput.toLowerCase() === 'exit') { rl.close(); break; }
-
-    messages.push({ role: 'user', content: userInput });
-
-    while (true) {
-      const response = await client.messages.create({
-        model: MODEL, max_tokens: 1024, system, tools: MCP_TOOLS, messages,
-      });
-
-      messages.push({ role: 'assistant', content: response.content });
-
-      if (response.stop_reason !== 'tool_use') {
-        const text = response.content.find(b => b.type === 'text')?.text || '';
-        console.log(`\nClaude: ${text}`);
-        break;
+      if (req.method === 'tools/call') {
+        const { name, arguments: args } = req.params;
+        const result = await runTool(name, args || {});
+        send({ jsonrpc: '2.0', id: req.id, result: {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+        }});
+        continue;
       }
 
-      const toolResults = [];
-      for (const block of response.content) {
-        if (block.type !== 'tool_use') continue;
-        const result = await runTool(block.name, block.input, memory);
-        console.log(`  [${block.name}] ${JSON.stringify(result).slice(0, 100)}...`);
-        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: JSON.stringify(result) });
-      }
-      messages.push({ role: 'user', content: toolResults });
+      send({ jsonrpc: '2.0', id: req.id, error: { code: -32601, message: 'Method not found' } });
+    } catch (e) {
+      process.stderr.write('[vektor-mcp] Error: ' + e.message + '\n');
+      send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: e.message } });
     }
   }
-
-  console.log('\n[CLAUDE+SLIPSTREAM] Session ended. Memories saved.');
-}
-
-// ── Entry Point ───────────────────────────────────────────────────────────────
-
-async function main() {
-  if (IS_MCP) {
-    await runMCPServer();
-  } else {
-    await runDirectChat();
-  }
-}
-
-main().catch(e => {
-  process.stderr.write('[CLAUDE+SLIPSTREAM] Fatal: ' + e.message + '\n');
-  process.exit(1);
 });
+
+process.stdin.resume();

package/package.json

@@ -1,69 +1,91 @@
-{
-  "name": "vektor-slipstream",
-  "version": "1.1.0",
-  "description": "Hardware-accelerated persistent memory for AI agents. Local-first, zero cloud dependency, $0 embedding cost.",
-  "main": "slipstream-core.js",
-  "bin": {
-    "vektor": "./vektor-cli.js"
-  },
-  "exports": {
-    ".":           "./slipstream-core.js",
-    "./cloak":     "./cloak.js",
-    "./db":        "./slipstream-db.js",
-    "./embedder":  "./slipstream-embedder.js"
-  },
-  "keywords": [
-    "ai", "memory", "agent", "vector", "sqlite", "embeddings",
-    "langchain", "openai", "anthropic", "claude", "mcp", "rag",
-    "persistent-memory", "local-ai", "onnx", "mistral", "cloak"
-  ],
-  "author": "VEKTOR Memory <hello@vektormemory.com>",
-  "license": "SEE LICENSE IN LICENSE",
-  "homepage": "https://vektormemory.com",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Vektor-Memory/Vektor-memory"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "better-sqlite3": "^12.8.0",
-    "onnxruntime-node": "^1.17.3"
-  },
-  "optionalDependencies": {
-    "@anthropic-ai/sdk":         "^0.82.0",
-    "@xenova/transformers":      "^2.17.2",
-    "playwright":                "^1.44.0",
-    "sqlite-vec-darwin-arm64":   "^0.1.6",
-    "sqlite-vec-linux-x64":      "^0.1.6",
-    "sqlite-vec-windows-x64":    "^0.1.6"
-  },
-  "files": [
-    "slipstream-core.js",
-    "slipstream-db.js",
-    "slipstream-embedder.js",
-    "detect-hardware.js",
-    "vektor-licence.js",
-    "vektor-licence-prompt.js",
-    "vektor-cli.js",
-    "vektor-setup.js",
-    "vektor-banner-loader.js",
-    "boot-screen.html",
-    "cloak.js",
-    "sovereign.js",
-    "visualize.js",
-    "TENETS.md",
-    "README.md",
-    "LICENSE",
-    "models/",
-    "examples/",
-    "mistral/"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "devDependencies": {
-    "javascript-obfuscator": "^5.4.1"
-  }
-}
+{
+    "name":  "vektor-slipstream",
+    "version":  "1.1.2",
+    "description":  "Hardware-accelerated persistent memory for AI agents. Local-first, zero cloud dependency, $0 embedding cost.",
+    "main":  "slipstream-core.js",
+    "bin":  {
+                "vektor":  "./vektor-cli.js"
+            },
+    "exports":  {
+                    ".":  "./slipstream-core.js",
+                    "./cloak":  "./cloak.js",
+                    "./db":  "./slipstream-db.js",
+                    "./embedder":  "./slipstream-embedder.js"
+                },
+    "keywords":  [
+                     "ai",
+                     "memory",
+                     "agent",
+                     "vector",
+                     "sqlite",
+                     "embeddings",
+                     "langchain",
+                     "openai",
+                     "anthropic",
+                     "claude",
+                     "mcp",
+                     "rag",
+                     "persistent-memory",
+                     "local-ai",
+                     "onnx",
+                     "mistral",
+                     "cloak"
+                 ],
+    "author":  "VEKTOR Memory <hello@vektormemory.com>",
+    "license":  "SEE LICENSE IN LICENSE",
+    "homepage":  "https://vektormemory.com",
+    "repository":  {
+                       "type":  "git",
+                       "url":  "https://github.com/Vektor-Memory/Vektor-memory"
+                   },
+    "engines":  {
+                    "node":  ">=18.0.0"
+                },
+    "dependencies":  {
+                         "better-sqlite3":  "^12.8.0",
+                         "blessed":  "^0.1.81",
+                         "blessed-contrib":  "^4.11.0",
+                         "onnxruntime-node":  "^1.17.3"
+                     },
+    "optionalDependencies":  {
+                                 "@anthropic-ai/sdk":  "^0.82.0",
+                                 "@xenova/transformers":  "^2.17.2",
+                                 "playwright":  "^1.44.0",
+                                 "sqlite-vec-darwin-arm64":  "^0.1.6",
+                                 "sqlite-vec-linux-x64":  "^0.1.6",
+                                 "sqlite-vec-windows-x64":  "^0.1.6",
+                                 "blessed":  "^0.1.81",
+                                 "blessed-contrib":  "^4.11.0"
+                             },
+    "files":  [
+                  "slipstream-core.js",
+                  "slipstream-db.js",
+                  "slipstream-embedder.js",
+                  "detect-hardware.js",
+                  "vektor-licence.js",
+                  "vektor-licence-prompt.js",
+                  "vektor-cli.js",
+                  "vektor-setup.js",
+                  "vektor-banner-loader.js",
+                  "vektor-tui.js",
+                  "graph-viewer.html",
+                  "boot-screen.html",
+                  "cloak.js",
+                  "sovereign.js",
+                  "visualize.js",
+                  "TENETS.md",
+                  "README.md",
+                  "LICENSE",
+                  "models/",
+                  "examples/",
+                  "mistral/",
+                  "vektor-tui.js",
+                  "graph-viewer.html"
+              ],
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "devDependencies":  {
+                            "javascript-obfuscator":  "^5.4.1"
+                        }
+}

package/vektor-cli.js

@@ -199,10 +199,12 @@ async function cmdSetup() {
   require('./vektor-setup');
 }
 
+async function cmdTui() { require('./vektor-tui'); }
+
 const commands = {
   help: cmdHelp, status: cmdStatus, activate: cmdActivate,
   deactivate: cmdDeactivate, test: cmdTest, mcp: cmdMcp,
-  rem: cmdRem, setup: cmdSetup,
+  rem: cmdRem, setup: cmdSetup, tui: async function(){ require('./vektor-tui'); },
 };
 
 const fn = commands[command];

package/vektor-tui.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+'use strict';
+
+let blessed;
+try { blessed = require('blessed'); }
+catch(e) {
+  require('child_process').execSync('npm install blessed --prefix ' + __dirname, { stdio: 'inherit' });
+  blessed = require('blessed');
+}
+
+const path = require('path');
+let PKG;
+try { PKG = require('./package.json'); } catch(_) { PKG = { version: '1.1.1' }; }
+
+// ── PALETTE (SBB-inspired warm dark) ─────────────────────────────────────────
+const P = {
+  bg:      '#151510',
+  bg2:     '#1e1e18',
+  card:    '#1a1a14',
+  border:  '#2a2a20',
+  orange:  '#e8742a',
+  amber:   '#d4a017',
+  cream:   '#c8b896',
+  dim:     '#5a5040',
+  white:   '#e8e0d0',
+  green:   '#7ab87a',
+  red:     '#c45050',
+  cyan:    '#7ab8c8',
+  sel:     '#2a2418',
+  selbrd:  '#e8742a',
+};
+
+// ── SCREEN ────────────────────────────────────────────────────────────────────
+const screen = blessed.screen({ smartCSR: true, fullUnicode: true, title: 'VEKTOR TUI' });
+
+// ── TOP SEARCH BAR ────────────────────────────────────────────────────────────
+const searchBar = blessed.box({
+  top: 0, left: 0, width: '100%', height: 3,
+  style: { bg: P.bg2, fg: P.cream },
+  content: '',
+});
+
+const searchLeft = blessed.textbox({
+  parent: searchBar,
+  top: 0, left: 0, width: '45%', height: 3,
+  border: { type: 'line' },
+  style: { fg: P.cream, bg: P.bg2, border: { fg: P.border }, focus: { border: { fg: P.orange } } },
+  inputOnFocus: true,
+  value: 'search memories...',
+});
+
+const searchRight = blessed.textbox({
+  parent: searchBar,
+  top: 0, left: '45%', width: '35%', height: 3,
+  border: { type: 'line' },
+  style: { fg: P.cream, bg: P.bg2, border: { fg: P.border }, focus: { border: { fg: P.orange } } },
+  inputOnFocus: true,
+  value: 'type: all',
+});
+
+const searchBtn = blessed.box({
+  parent: searchBar,
+  top: 0, right: 0, width: '20%', height: 3,
+  border: { type: 'line' },
+  tags: true,
+  style: { fg: P.cream, bg: P.bg2, border: { fg: P.border } },
+  content: `  {bold}{#e8742a-fg}▶{/#e8742a-fg}{/bold} VEKTOR SLIPSTREAM  v${PKG.version}`,
+});
+
+screen.append(searchBar);
+
+// ── MAIN AREA ─────────────────────────────────────────────────────────────────
+const mainLeft = blessed.box({
+  top: 3, left: 0, width: '48%', height: '100%-6',
+  scrollable: true, alwaysScroll: true, keys: true, mouse: true,
+  style: { bg: P.bg },
+  tags: true,
+});
+
+const mainRight = blessed.box({
+  top: 3, left: '48%', width: '52%', height: '100%-6',
+  border: { type: 'line' },
+  style: { bg: P.bg, border: { fg: P.border } },
+  tags: true, scrollable: true, keys: true, mouse: true,
+});
+
+screen.append(mainLeft);
+screen.append(mainRight);
+
+// ── BOTTOM STATUS BAR ─────────────────────────────────────────────────────────
+const statusBar = blessed.box({
+  bottom: 0, left: 0, width: '100%', height: 3,
+  border: { type: 'line' },
+  tags: true,
+  style: { bg: P.bg2, border: { fg: P.border } },
+  content: '',
+});
+screen.append(statusBar);
+
+function renderStatusBar(msg='') {
+  const keys = [
+    ['↑↓', 'navigate'],
+    ['↵', 'inspect'],
+    ['A', 'add'],
+    ['D', 'delete'],
+    ['/', 'search'],
+    ['R', 'REM'],
+    ['B', 'briefing'],
+    ['Q', 'quit'],
+  ];
+  const left = keys.map(([k,v]) =>
+    ` {#e8742a-fg}{bold}${k}{/bold}{/#e8742a-fg} {#5a5040-fg}${v}{/#5a5040-fg}`
+  ).join('  ');
+  const right = msg
+    ? `{#7ab87a-fg}${msg}{/#7ab87a-fg}  `
+    : `{#5a5040-fg}VEKTOR-TUI v${PKG.version}{/#5a5040-fg}  `;
+  statusBar.setContent(left + '    ' + right);
+  screen.render();
+}
+
+// ── STATE ─────────────────────────────────────────────────────────────────────
+let memory = null, memories = [], selected = 0, filterType = 'all';
+
+// ── CARD RENDERER ─────────────────────────────────────────────────────────────
+function typeColor(type) {
+  return { semantic: P.cyan, causal: P.amber, temporal: P.green, entity: P.red }[type] || P.dim;
+}
+
+function typeBg(type) {
+  return { semantic: '#1a2a30', causal: '#2a2010', temporal: '#1a2a1a', entity: '#2a1a1a' }[type] || P.card;
+}
+
+function renderTimeline(importance) {
+  // Draw ●──○──○──● style based on importance
+  const steps = 5;
+  const filled = importance || 1;
+  let line = '{#e8742a-fg}●{/#e8742a-fg}';
+  for (let i = 1; i < steps; i++) {
+    line += '{#2a2a20-fg}──{/#2a2a20-fg}';
+    if (i < filled) {
+      line += '{#e8742a-fg}●{/#e8742a-fg}';
+    } else {
+      line += '{#2a2a20-fg}○{/#2a2a20-fg}';
+    }
+  }
+  return line;
+}
+
+function renderCards() {
+  const W = Math.floor(screen.cols * 0.48) - 4;
+  let content = '\n';
+
+  memories.forEach((m, i) => {
+    const isSelected = i === selected;
+    const color = typeColor(m.type);
+    const age = m.created_at ? Math.round((Date.now() - m.created_at) / 3600000) + 'h ago' : '—';
+    const typeTag = (m.type || 'mem').slice(0, 3).toUpperCase();
+    const bColor = isSelected ? P.selbrd : P.border;
+    const preview = m.content.slice(0, W - 4);
+
+    content += isSelected
+      ? `{${P.orange}-fg}┌${'─'.repeat(W - 2)}┐{/${P.orange}-fg}\n`
+      : `{${P.border}-fg}┌${'─'.repeat(W - 2)}┐{/${P.border}-fg}\n`;
+
+    // Title row
+    content += isSelected ? `{${P.orange}-fg}│{/${P.orange}-fg}` : `{${P.border}-fg}│{/${P.border}-fg}`;
+    content += ` {bold}{${color}-fg}${typeTag}{/${color}-fg}{/bold}`;
+    content += `  {${isSelected ? P.white : P.cream}-fg}${preview}{/${isSelected ? P.white : P.cream}-fg}`;
+    content += ' '.repeat(Math.max(0, W - 6 - typeTag.length - preview.length));
+    content += isSelected ? `{${P.orange}-fg}│{/${P.orange}-fg}\n` : `{${P.border}-fg}│{/${P.border}-fg}\n`;
+
+    // Timeline row
+    content += isSelected ? `{${P.orange}-fg}│{/${P.orange}-fg}` : `{${P.border}-fg}│{/${P.border}-fg}`;
+    content += `  ${renderTimeline(m.importance)}`;
+    content += `  {${P.dim}-fg}${age}{/${P.dim}-fg}`;
+    content += ' '.repeat(Math.max(0, W - 4 - (m.importance || 1) * 4 - age.length - 2));
+    content += isSelected ? `{${P.orange}-fg}│{/${P.orange}-fg}\n` : `{${P.border}-fg}│{/${P.border}-fg}\n`;
+
+    content += isSelected
+      ? `{${P.orange}-fg}└${'─'.repeat(W - 2)}┘{/${P.orange}-fg}\n`
+      : `{${P.border}-fg}└${'─'.repeat(W - 2)}┘{/${P.border}-fg}\n`;
+    content += '\n';
+  });
+
+  if (memories.length === 0) {
+    content += `\n  {${P.dim}-fg}No memories found.{/${P.dim}-fg}\n\n`;
+    content += `  {${P.amber}-fg}Press A to add your first memory.{/${P.amber}-fg}\n`;
+  }
+
+  mainLeft.setContent(content);
+
+  // Scroll to selected
+  const cardHeight = 4;
+  const scrollTo = selected * (cardHeight + 1);
+  mainLeft.scrollTo(scrollTo);
+
+  screen.render();
+}
+
+// ── DETAIL PANEL ─────────────────────────────────────────────────────────────
+function renderDetail() {
+  const m = memories[selected];
+  if (!m) {
+    mainRight.setContent(`\n\n  {${P.dim}-fg}Select a memory to inspect{/${P.dim}-fg}`);
+    screen.render();
+    return;
+  }
+
+  const color  = typeColor(m.type);
+  const age    = m.created_at ? new Date(m.created_at).toLocaleString() : '—';
+  const typeTag = (m.type || 'memory').toUpperCase();
+
+  let content = '\n';
+  content += `  {bold}{${color}-fg}${typeTag}{/${color}-fg}{/bold}  {${P.dim}-fg}#${m.id}{/${P.dim}-fg}\n\n`;
+  content += `  {bold}{${P.white}-fg}${m.content}{/${P.white}-fg}{/bold}\n\n`;
+  content += `  {${P.border}-fg}${'─'.repeat(40)}{/${P.border}-fg}\n\n`;
+  content += `  {${P.dim}-fg}IMPORTANCE {/${P.dim}-fg}  ${renderTimeline(m.importance)}\n\n`;
+  content += `  {${P.dim}-fg}CREATED    {/${P.dim}-fg}  {${P.cream}-fg}${age}{/${P.cream}-fg}\n\n`;
+  content += `  {${P.border}-fg}${'─'.repeat(40)}{/${P.border}-fg}\n\n`;
+  content += `  {${P.dim}-fg}[D]{/${P.dim}-fg} delete    {${P.dim}-fg}[E]{/${P.dim}-fg} edit importance\n\n`;
+
+  // Show connected memories count if available
+  const total = memories.length;
+  const sameType = memories.filter(x => x.type === m.type).length;
+  content += `  {${P.border}-fg}${'─'.repeat(40)}{/${P.border}-fg}\n\n`;
+  content += `  {${P.dim}-fg}TYPE POOL  {/${P.dim}-fg}  {${color}-fg}${sameType}{/${color}-fg} {${P.dim}-fg}of ${total} memories{/${P.dim}-fg}\n`;
+
+  mainRight.setContent(content);
+  screen.render();
+}
+
+// ── INPUT OVERLAY ─────────────────────────────────────────────────────────────
+const inputOverlay = blessed.box({
+  top: 'center', left: 'center', width: '60%', height: 5,
+  hidden: true,
+  border: { type: 'line' },
+  style: { bg: P.bg2, border: { fg: P.orange } },
+  tags: true,
+});
+
+const inputField = blessed.textbox({
+  parent: inputOverlay,
+  top: 1, left: 2, width: '100%-6', height: 1,
+  style: { fg: P.orange, bg: P.bg2 },
+  inputOnFocus: true,
+});
+
+screen.append(inputOverlay);
+
+function showInput(label, cb) {
+  inputOverlay.setLabel(` {#e8742a-fg}${label}{/#e8742a-fg} `);
+  inputField.setValue('');
+  inputOverlay.show();
+  screen.render();
+  inputField.focus();
+  inputField.readInput((err, val) => {
+    inputOverlay.hide();
+    screen.render();
+    if (!err && val && val.trim()) cb(val.trim());
+    else mainLeft.focus();
+  });
+}
+
+// ── LOAD ──────────────────────────────────────────────────────────────────────
+async function loadMemories(query = '') {
+  try {
+    if (query) {
+      memories = await memory.recall(query, 100);
+    } else {
+      memories = memory.db.prepare(
+        'SELECT * FROM memories ORDER BY created_at DESC LIMIT 500'
+      ).all();
+      if (filterType !== 'all') {
+        memories = memories.filter(m => m.type === filterType);
+      }
+    }
+    if (selected >= memories.length) selected = Math.max(0, memories.length - 1);
+    renderCards();
+    renderDetail();
+    renderStatusBar(`${memories.length} memories`);
+  } catch(e) {
+    renderStatusBar('Error: ' + e.message.slice(0, 40));
+  }
+}
+
+// ── ACTIONS ───────────────────────────────────────────────────────────────────
+async function addMemory(content) {
+  try {
+    const { id } = await memory.remember(content, { importance: 3 });
+    renderStatusBar('✓ Saved #' + id);
+    await loadMemories();
+  } catch(e) { renderStatusBar('Error: ' + e.message.slice(0, 40)); }
+}
+
+async function deleteSelected() {
+  const m = memories[selected];
+  if (!m) return;
+  try {
+    memory.db.prepare('DELETE FROM memories WHERE id=?').run(m.id);
+    renderStatusBar('Deleted #' + m.id);
+    await loadMemories();
+  } catch(e) { renderStatusBar('Error: ' + e.message.slice(0, 40)); }
+}
+
+async function runRem() {
+  renderStatusBar('REM cycle running...');
+  try {
+    if (memory) await memory.dream();
+    renderStatusBar('✓ REM complete');
+    await loadMemories();
+  } catch(e) { renderStatusBar('REM: ' + e.message.slice(0, 40)); }
+}
+
+async function showBriefing() {
+  try {
+    const brief = await memory.briefing();
+    mainRight.setLabel(' {bold}BRIEFING{/bold} ');
+    mainRight.setContent('\n' + brief.split('\n').map(l => '  ' + l).join('\n'));
+    screen.render();
+  } catch(e) { renderStatusBar('Briefing error'); }
+}
+
+// ── KEYBOARD ──────────────────────────────────────────────────────────────────
+screen.key(['q', 'C-c'], () => { screen.destroy(); process.exit(0); });
+
+screen.key(['up', 'k'], () => {
+  if (selected > 0) { selected--; renderCards(); renderDetail(); }
+});
+screen.key(['down', 'j'], () => {
+  if (selected < memories.length - 1) { selected++; renderCards(); renderDetail(); }
+});
+
+screen.key(['a'], () => showInput('▶ ADD MEMORY', addMemory));
+screen.key(['d'], deleteSelected);
+screen.key(['/'], () => showInput('▶ SEARCH', async q => { await loadMemories(q); }));
+screen.key(['l'], async () => { await loadMemories(); });
+screen.key(['r'], runRem);
+screen.key(['b'], showBriefing);
+screen.key(['enter'], () => { renderDetail(); });
+
+// Tab through filter types
+screen.key(['t'], async () => {
+  const types = ['all', 'semantic', 'causal', 'temporal', 'entity'];
+  const idx = types.indexOf(filterType);
+  filterType = types[(idx + 1) % types.length];
+  searchRight.setValue('type: ' + filterType);
+  await loadMemories();
+});
+
+// ── BOOT ──────────────────────────────────────────────────────────────────────
+async function boot() {
+  const _l = console.log; const _e = console.error;
+  console.log = console.error = () => {};
+
+  renderStatusBar('connecting...');
+  renderCards();
+  screen.render();
+
+  try {
+    const { createMemory } = require('./slipstream-core');
+    const dbPath = process.env.VEKTOR_DB_PATH || path.join(process.cwd(), 'slipstream-memory.db');
+    memory = await createMemory({
+      agentId: process.env.VEKTOR_AGENT_ID || 'tui',
+      dbPath, silent: true,
+      licenceKey: process.env.VEKTOR_LICENCE_KEY,
+    });
+    await loadMemories();
+  } catch(e) {
+    renderStatusBar('Error: ' + e.message.slice(0, 50));
+    memories = [];
+    renderCards();
+    renderDetail();
+  }
+
+  console.log = _l; console.error = _e;
+  mainLeft.focus();
+  screen.render();
+
+  setInterval(() => { if (memory) loadMemories(); }, 30000);
+}
+
+boot();