vektor-slipstream 1.3.8 → 1.4.0

package/examples/example-claude-mcp.js

@@ -1,656 +1,220 @@
 'use strict';
-
 /**
- * VEKTOR SLIPSTREAM — Claude Desktop MCP Server v1.4
+ * example-claude-mcp.js — VEKTOR Slipstream + Claude
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Auto-memory: every conversation turn is stored in the MAGMA graph.
+ * Claude recalls relevant context before every response.
+ * No setup required — memory just works.
  *
- * Tools:
- *   Memory:  vektor_recall, vektor_store, vektor_graph, vektor_delta
- *   Cloak:   cloak_fetch, cloak_render, cloak_diff, cloak_diff_text,
- *            cloak_passport, tokens_saved, cloak_fetch_smart,
- *            cloak_detect_captcha, cloak_solve_captcha,
- *            cloak_identity_create, cloak_identity_use, cloak_identity_list,
- *            turbo_quant_stats, turbo_quant_compress
- *   Warmup:  cloak_warmup_session, cloak_warmup_stats
- *   Behav:   cloak_inject_behaviour, cloak_behaviour_stats, cloak_load_pattern
- *   Pattern: cloak_pattern_stats, cloak_pattern_list, cloak_pattern_prune, cloak_pattern_seed
+ * Usage (MCP server for Claude Desktop):
+ *   node example-claude-mcp.js --mcp
  *
- * Windows-safe: no shebang line (breaks Windows Node.js when invoked directly)
+ * Usage (direct chat):
+ *   ANTHROPIC_API_KEY=sk-ant-... VEKTOR_LICENCE_KEY=... node example-claude-mcp.js
  */
 
-const path = require('path');
-const os   = require('os');
-
-const IS_MCP = process.argv.includes('--mcp');
-if (!IS_MCP) { require('./example-claude-direct'); return; }
-
-// ── Tool definitions ───────────────────────────────────────────────────────────
-
-const TOOLS = [
-
-  // ── Memory tools ──────────────────────────────────────────────────────────────
-  {
-    name: 'vektor_recall',
-    description: 'Search persistent memory. Call before answering anything that might have prior context.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string',  description: 'What to search for.' },
-        top_k: { type: 'integer', description: 'Number of results (default 5).', default: 5 },
-      },
-      required: ['query'],
-    },
-  },
-  {
-    name: 'vektor_store',
-    description: 'Store a fact, preference, or decision in persistent memory.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        content:    { type: 'string',  description: 'What to remember.' },
-        importance: { type: 'number',  description: 'Importance 1-5 (default 3).', default: 3 },
-      },
-      required: ['content'],
-    },
-  },
-  {
-    name: 'vektor_graph',
-    description: 'Traverse the memory graph from a concept.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        concept: { type: 'string',  description: 'Concept to traverse from.' },
-        hops:    { type: 'integer', description: 'Graph depth (default 2).', default: 2 },
-      },
-      required: ['concept'],
-    },
-  },
-  {
-    name: 'vektor_delta',
-    description: 'See what changed in memory on a topic.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        topic: { type: 'string',  description: 'Topic to check.' },
-        days:  { type: 'integer', description: 'How many days back (default 7).', default: 7 },
-      },
-      required: ['topic'],
-    },
-  },
-
-  // ── v1.1 Cloak tools ──────────────────────────────────────────────────────────
-  {
-    name: 'cloak_fetch',
-    description: 'Fetch a URL using stealth headless browser. Returns clean compressed text. Saves tokens vs raw HTML.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url:   { type: 'string' },
-        force: { type: 'boolean' },
-        limit: { type: 'integer', description: 'Max characters to return' },
-      },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_render',
-    description: 'Render a page and return computed CSS layout, fonts, and gap analysis.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url:       { type: 'string' },
-        selectors: { type: 'array', items: { type: 'string' } },
-        mobile:    { type: 'boolean' },
-      },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_diff',
-    description: 'Return what semantically changed on a URL since last fetch.',
-    inputSchema: {
-      type: 'object',
-      properties: { url: { type: 'string' } },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_diff_text',
-    description: 'Diff two text strings and return a semantic change summary.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        a: { type: 'string', description: 'Original text' },
-        b: { type: 'string', description: 'New text' },
-      },
-      required: ['a', 'b'],
-    },
-  },
-  {
-    name: 'cloak_passport',
-    description: 'Read/write to AES-256 encrypted credential vault. Omit value to read.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        key:   { type: 'string' },
-        value: { type: 'string' },
-      },
-      required: ['key'],
-    },
-  },
-  {
-    name: 'tokens_saved',
-    description: 'Calculate token savings and ROI for a session.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        raw_tokens:    { type: 'number' },
-        actual_tokens: { type: 'number' },
-        agent_id:      { type: 'string' },
-        provider:      { type: 'string' },
-        cost_per_1m:   { type: 'number' },
-      },
-      required: ['raw_tokens', 'actual_tokens'],
-    },
-  },
-
-  // ── v1.2 Cloak tools ──────────────────────────────────────────────────────────
-  {
-    name: 'cloak_fetch_smart',
-    description: 'Smart fetch — checks llms.txt first, falls back to stealth browser.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url:           { type: 'string' },
-        force:         { type: 'boolean' },
-        skipLlmsCheck: { type: 'boolean' },
-      },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_detect_captcha',
-    description: 'Navigate to a URL and detect if a CAPTCHA is present.',
-    inputSchema: {
-      type: 'object',
-      properties: { url: { type: 'string' } },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_solve_captcha',
-    description: 'Detect and solve any CAPTCHA using vision AI. Injects solution automatically.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url:      { type: 'string' },
-        provider: { type: 'string', description: '"claude" (default) or "openai"' },
-      },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_identity_create',
-    description: 'Create a persistent browser identity with full fingerprint.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string' },
-        seed: { type: 'string' },
-      },
-      required: ['name'],
-    },
-  },
-  {
-    name: 'cloak_identity_use',
-    description: 'Browse a URL using a saved identity. Maintains cookies across sessions.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string' },
-        url:  { type: 'string' },
-      },
-      required: ['name', 'url'],
-    },
-  },
-  {
-    name: 'cloak_identity_list',
-    description: 'List all saved browser identities.',
-    inputSchema: { type: 'object', properties: {} },
-  },
-  {
-    name: 'turbo_quant_stats',
-    description: 'Show TurboQuant 3-bit compression stats.',
-    inputSchema: { type: 'object', properties: {} },
-  },
-  {
-    name: 'turbo_quant_compress',
-    description: 'Migrate memory database to TurboQuant 3-bit compressed storage. ~10x size reduction.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        dbPath: { type: 'string' },
-      },
-    },
-  },
-
-  // ── v1.3 Warmup & Behaviour tools ─────────────────────────────────────────────
-  {
-    name: 'cloak_warmup_session',
-    description: 'Run a session warmup before navigating to a bot-protected URL. Primes reCAPTCHA trust score.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        targetUrl:    { type: 'string' },
-        identityName: { type: 'string' },
-        sites:        { type: 'integer', default: 3 },
-        dwellMs:      { type: 'integer', default: 2500 },
-        primeGoogle:  { type: 'boolean', default: true },
-        visitRoot:    { type: 'boolean', default: true },
-        customSites:  { type: 'array', items: { type: 'string' } },
-      },
-      required: ['targetUrl'],
-    },
-  },
-  {
-    name: 'cloak_warmup_stats',
-    description: 'Show warmup strategy details — trust signals, referrer chains, timing.',
-    inputSchema: { type: 'object', properties: {} },
-  },
-  {
-    name: 'cloak_inject_behaviour',
-    description: 'Inject human-realistic mouse/scroll behaviour into a browser session.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        url:         { type: 'string' },
-        category:    { type: 'string', enum: ['reading', 'form', 'shopping', 'login', 'idle'] },
-        patternName: { type: 'string' },
-        speedFactor: { type: 'number' },
-        synthetic:   { type: 'boolean' },
-        durationMs:  { type: 'integer' },
-      },
-      required: ['url'],
-    },
-  },
-  {
-    name: 'cloak_behaviour_stats',
-    description: 'List available behaviour patterns and categories.',
-    inputSchema: { type: 'object', properties: {} },
-  },
-  {
-    name: 'cloak_load_pattern',
-    description: 'Load a custom behaviour pattern recorded with cloak-recorder-snippet.js.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name:    { type: 'string' },
-        pattern: { type: 'string', description: 'JSON string from recorder' },
-        save:    { type: 'boolean' },
-      },
-      required: ['name', 'pattern'],
-    },
-  },
-
-  // ── v1.4 Pattern store tools ──────────────────────────────────────────────────
-  {
-    name: 'cloak_pattern_stats',
-    description: 'Show self-improving pattern store stats — tier breakdown, win/loss rates.',
-    inputSchema: { type: 'object', properties: {} },
-  },
-  {
-    name: 'cloak_pattern_list',
-    description: 'List all behaviour patterns with score, tier, wins, and losses.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        tier: { type: 'string', enum: ['elite', 'active', 'probation'] },
-      },
-    },
-  },
-  {
-    name: 'cloak_pattern_prune',
-    description: 'Force prune the pattern store — removes stale and low-scoring patterns.',
-    inputSchema: { type: 'object', properties: {} },
-  },
-  {
-    name: 'cloak_pattern_seed',
-    description: 'Seed the store with built-in patterns (only runs if store is empty).',
-    inputSchema: { type: 'object', properties: {} },
-  },
-];
-
-// ── Lazy loaders ──────────────────────────────────────────────────────────────
+const { createMemory } = require('vektor-slipstream');
+const readline = require('readline');
 
+// ── Memory init ───────────────────────────────────────────────────────────────
 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,
+    agentId:    process.env.SLIPSTREAM_AGENT_ID || 'claude-vektor',
     licenceKey: process.env.VEKTOR_LICENCE_KEY,
+    dbPath:     process.env.VEKTOR_DB_PATH,
+    silent:     true,
   });
   return _memory;
 }
 
-let _cloak = null;
-function getCloak() {
-  if (!_cloak) _cloak = require('vektor-slipstream/cloak');
-  return _cloak;
-}
+// ── Auto-store: extract memorable facts from a conversation turn ──────────────
+async function autoStore(memory, userMsg, assistantResponse) {
+  // Store the user message if it contains memorable content
+  const memorable = isMemorableContent(userMsg);
+  if (memorable) {
+    await memory.remember(userMsg, { importance: memorable.importance }).catch(() => {});
+  }
 
-let _warmup = null;
-function getWarmup() {
-  if (!_warmup) _warmup = require('vektor-slipstream/cloak-warmup');
-  return _warmup;
+  // Store a condensed version of the exchange
+  const exchange = `User: ${userMsg.slice(0, 200)} | Assistant: ${assistantResponse.slice(0, 300)}`;
+  await memory.remember(exchange, { importance: 2 }).catch(() => {});
 }
 
-let _behaviour = null;
-function getBehaviour() {
-  if (!_behaviour) _behaviour = require('vektor-slipstream/cloak-behaviour');
-  return _behaviour;
-}
+// ── Heuristic: is this content worth storing? ─────────────────────────────────
+function isMemorableContent(text) {
+  const t = text.toLowerCase();
 
-let _patternStore = null;
-function getPatternStore() {
-  if (!_patternStore) _patternStore = require('vektor-slipstream/cloak-pattern-store');
-  return _patternStore;
+  // High importance — preferences, decisions, critical facts
+  if (/prefer|always|never|hate|love|my name|i am|i'm a|i work|my project|deadline|important|remember/.test(t)) {
+    return { importance: 4 };
+  }
+  // Medium importance — project details, tech choices, context
+  if (/project|build|using|stack|version|deploy|api|database|language|framework|decided|going with/.test(t)) {
+    return { importance: 3 };
+  }
+  // Low importance — general context worth keeping
+  if (text.length > 80) {
+    return { importance: 2 };
+  }
+  return null;
 }
 
-// ── Tool runner ───────────────────────────────────────────────────────────────
-
-async function runTool(name, input) {
-  switch (name) {
-
-    case 'vektor_recall': {
-      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 mem = await getMemory();
-      const { id } = await mem.remember(input.content, { importance: input.importance || 3 });
-      return { stored: true, id, content: input.content };
-    }
-
-    case 'vektor_graph': {
-      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 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, limit: input.limit });
-      return { text: r.text, tokens_saved: r.tokensSaved, from_cache: r.fromCache };
-    }
-
-    case 'cloak_render': {
-      return await getCloak().cloak_render(input.url, input.selectors || [], { mobile: input.mobile });
-    }
-
-    case 'cloak_diff': {
-      return await getCloak().cloak_diff(input.url);
-    }
-
-    case 'cloak_diff_text': {
-      return getCloak().cloak_diff_text(input.a, input.b);
-    }
-
-    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,
-        provider:      input.provider,
-        cost_per_1m:   input.cost_per_1m,
-      });
-    }
-
-    case 'cloak_fetch_smart': {
-      const result = await getCloak().cloak_fetch_smart(input.url, {
-        force: input.force, skipLlmsCheck: input.skipLlmsCheck,
-      });
-      return { text: result.text, tokens_saved: result.tokensSaved, from_cache: result.fromCache, source: result.source, llms_friendly: result.llmsFriendly };
-    }
-
-    case 'cloak_detect_captcha': {
-      const { captcha } = getCloak();
-      const { chromium } = require('playwright');
-      let browser;
-      try {
-        browser = await chromium.launch({ headless: true });
-        const page = await browser.newPage();
-        await page.goto(input.url, { waitUntil: 'domcontentloaded', timeout: 20000 });
-        const detected = await captcha.detectCaptcha(page);
-        return detected || { found: false };
-      } finally {
-        if (browser) await browser.close().catch(() => {});
+// ── MCP Server mode ───────────────────────────────────────────────────────────
+if (process.argv.includes('--mcp')) {
+  const TOOLS = [
+    {
+      name: 'vektor_recall',
+      description: 'Search persistent memory for relevant context. Call before answering anything that might have prior context.',
+      inputSchema: { type: 'object', properties: { query: { type: 'string' }, top_k: { type: 'integer', default: 5 } }, required: ['query'] },
+    },
+    {
+      name: 'vektor_store',
+      description: 'Store a fact, preference, decision, or context in persistent memory.',
+      inputSchema: { type: 'object', properties: { content: { type: 'string' }, importance: { type: 'integer', default: 3 } }, required: ['content'] },
+    },
+    {
+      name: 'vektor_graph',
+      description: 'Traverse the associative memory graph to find connected memories.',
+      inputSchema: { type: 'object', properties: { topic: { type: 'string' }, depth: { type: 'integer', default: 2 } }, required: ['topic'] },
+    },
+    {
+      name: 'vektor_delta',
+      description: 'See what changed in memory on a topic recently.',
+      inputSchema: { type: 'object', properties: { topic: { type: 'string' }, days: { type: 'integer', default: 7 } }, required: ['topic'] },
+    },
+    {
+      name: 'vektor_briefing',
+      description: 'Generate a briefing summary from recent memories.',
+      inputSchema: { type: 'object', properties: {} },
+    },
+  ];
+
+  async function runTool(name, input) {
+    const mem = await getMemory();
+    switch (name) {
+      case 'vektor_recall': {
+        const results = await mem.recall(input.query, input.top_k || 5);
+        return { results: (results || []).map(r => ({ id: r.id, content: r.content, score: r.score })) };
       }
-    }
-
-    case 'cloak_solve_captcha': {
-      const { captcha } = getCloak();
-      const { chromium } = require('playwright');
-      let browser;
-      try {
-        browser = await chromium.launch({ headless: true });
-        const page = await browser.newPage();
-        await page.goto(input.url, { waitUntil: 'domcontentloaded', timeout: 20000 });
-        const detected = await captcha.detectCaptcha(page);
-        if (!detected) return { solved: false, reason: 'No CAPTCHA detected' };
-        const token = await captcha.solveCaptcha(page, detected, {
-          provider: input.provider || 'claude',
-          anthropicKey: process.env.ANTHROPIC_API_KEY,
-        });
-        if (token) {
-          await captcha.injectCaptchaSolution(page, detected, token);
-          return { solved: true, type: detected.type, token: token.slice ? token.slice(0, 20) + '...' : token };
-        }
-        return { solved: false, type: detected.type, reason: 'Vision model returned no selection' };
-      } finally {
-        if (browser) await browser.close().catch(() => {});
+      case 'vektor_store': {
+        const { id } = await mem.remember(input.content, { importance: input.importance || 3 });
+        return { id, stored: true };
       }
+      case 'vektor_graph':    return await mem.graph(input.topic, input.depth || 2);
+      case 'vektor_delta':    return await mem.delta(input.topic, input.days || 7);
+      case 'vektor_briefing': return { briefing: await mem.briefing() };
+      default: throw new Error(`Unknown tool: ${name}`);
     }
+  }
 
-    case 'cloak_identity_create': {
-      const { CloakIdentity } = getCloak();
-      const id = CloakIdentity.create(input.name, input.seed || null);
-      id.save();
-      return { created: true, ...id.summary };
-    }
-
-    case 'cloak_identity_use': {
-      const { CloakIdentity } = getCloak();
-      const { chromium } = require('playwright');
-      const id = CloakIdentity.load(input.name);
-      if (!id) return { error: `Identity "${input.name}" not found. Create with cloak_identity_create first.` };
-      let browser;
-      try {
-        browser = await chromium.launch({ headless: true });
-        const context = await browser.newContext({
-          viewport: id.profile.viewport, userAgent: id.profile.userAgent,
-          timezoneId: id.profile.timezone, locale: id.profile.language,
-        });
-        await id.applyToContext(context);
-        const page = await context.newPage();
-        await page.goto(input.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-        const text = await page.evaluate(() => {
-          document.querySelectorAll('script,style,nav,footer').forEach(el => el.remove());
-          return document.body?.innerText || '';
-        });
-        await id.saveCookiesFromContext(context);
-        id.recordVisit(input.url);
-        id.save();
-        return { text: text.slice(0, 8000), identity: id.summary, url: input.url };
-      } finally {
-        if (browser) await browser.close().catch(() => {});
-      }
-    }
-
-    case 'cloak_identity_list': {
-      const { CloakIdentity } = getCloak();
-      return CloakIdentity.list().map(n => CloakIdentity.load(n)?.summary).filter(Boolean);
-    }
-
-    case 'turbo_quant_stats': {
-      return getCloak().turboQuant.compressionStats(384);
-    }
-
-    case 'turbo_quant_compress': {
-      const { turboQuant } = getCloak();
-      const dbPath = input.dbPath || process.env.VEKTOR_DB_PATH ||
-        path.join(os.homedir(), 'vektor-slipstream-memory.db');
-      const Database = require('better-sqlite3');
-      const db = new Database(dbPath);
-      const result = turboQuant.migrateDatabase(db);
-      db.close();
-      return { ...result, dbPath };
-    }
-
-    case 'cloak_warmup_session': {
-      const { quickWarmup } = getWarmup();
-      let identityProfile = null;
-      if (input.identityName) {
-        try {
-          const { CloakIdentity } = getCloak();
-          const id = CloakIdentity.load(input.identityName);
-          if (id) identityProfile = id.profile;
-        } catch (_) {}
+  process.stdin.setEncoding('utf8');
+  let buffer = '';
+  const 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();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let req;
+      try { req = JSON.parse(line); } catch {
+        send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+        continue;
       }
-      return await quickWarmup(input.targetUrl, identityProfile, {
-        sites: input.sites ?? 3, dwellMs: input.dwellMs ?? 2500,
-        primeGoogle: input.primeGoogle ?? true, visitRoot: input.visitRoot ?? true,
-        customSites: input.customSites || null,
-      });
-    }
-
-    case 'cloak_warmup_stats': {
-      return getWarmup().warmupStats();
-    }
-
-    case 'cloak_inject_behaviour': {
-      const { injectBehaviour, replayPattern, syntheticBrowse } = getBehaviour();
-      const { chromium } = require('playwright');
-      let browser;
+      if (req.method?.startsWith('notifications/')) continue;
       try {
-        browser = await chromium.launch({ headless: true });
-        const page = await (await browser.newContext()).newPage();
-        await page.goto(input.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-        let result;
-        if (input.synthetic) {
-          result = await syntheticBrowse(page, { durationMs: input.durationMs ?? 5000, scrollDepth: 0.6, pauseCount: 3 });
-        } else if (input.patternName) {
-          result = await replayPattern(page, input.patternName, { speedFactor: input.speedFactor ?? 1.0 });
-        } else {
-          result = await injectBehaviour(page, input.category || 'reading', { speedFactor: input.speedFactor ?? 1.0 });
+        switch (req.method) {
+          case 'initialize':
+            send({ jsonrpc: '2.0', id: req.id, result: {
+              protocolVersion: '2024-11-05',
+              serverInfo: { name: 'vektor-slipstream', version: '1.3.9' },
+              capabilities: { tools: { listChanged: false } },
+            }});
+            break;
+          case 'tools/list':
+            send({ jsonrpc: '2.0', id: req.id, result: { tools: TOOLS } });
+            break;
+          case '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) }],
+              isError: false,
+            }});
+            break;
+          }
+          default:
+            send({ jsonrpc: '2.0', id: req.id, error: { code: -32601, message: `Method not found: ${req.method}` }});
         }
-        return { injected: true, url: input.url, ...result };
-      } finally {
-        if (browser) await browser.close().catch(() => {});
+      } catch(e) {
+        send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: e.message }});
       }
     }
+  });
+  process.stdin.on('end', () => process.exit(0));
+  process.on('uncaughtException', e => process.stderr.write('[vektor-mcp] ' + e.message + '\n'));
 
-    case 'cloak_behaviour_stats': {
-      return getBehaviour().behaviourStats();
-    }
+} else {
+  // ── Direct chat mode with auto-memory ───────────────────────────────────────
+  const Anthropic = require('@anthropic-ai/sdk');
 
-    case 'cloak_load_pattern': {
-      const { loadCustomPattern, saveCustomPattern } = getBehaviour();
-      let data;
-      try { data = JSON.parse(input.pattern); } catch (e) { return { error: 'Invalid JSON: ' + e.message }; }
-      const result = loadCustomPattern(input.name, data);
-      if (input.save !== false) { try { saveCustomPattern(input.name); } catch (_) {} }
-      return result;
-    }
+  async function main() {
+    const memory   = await getMemory();
+    const client   = new Anthropic();
+    const messages = [];
 
-    case 'cloak_pattern_stats': {
-      const ps = getPatternStore();
-      ps.seedBuiltins();
-      return ps.storeStats();
-    }
+    // Morning briefing
+    const brief = await memory.briefing().catch(() => '');
 
-    case 'cloak_pattern_list': {
-      return getPatternStore().listPatterns(input.tier || null);
-    }
+    const systemPrompt = [
+      'You are a helpful assistant with persistent memory via VEKTOR Slipstream.',
+      'Your memory persists across all sessions — you remember everything.',
+      brief ? `\nMEMORY BRIEFING (last 24h):\n${brief}` : '',
+      '\nWhen the user shares preferences, decisions, or important facts — they are automatically remembered.',
+      'Recall relevant context before answering. Store important new facts as they arise.',
+    ].filter(Boolean).join('\n');
 
-    case 'cloak_pattern_prune': {
-      return getPatternStore().pruneNow();
-    }
+    console.log('\n🧠 VEKTOR Memory active — all conversations stored in MAGMA graph');
+    console.log('Type your message (Ctrl+C to exit)\n');
 
-    case 'cloak_pattern_seed': {
-      return getPatternStore().seedBuiltins();
-    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
-    default:
-      return { error: `Unknown tool: ${name}` };
-  }
-}
+    const ask = () => rl.question('You: ', async userInput => {
+      if (!userInput.trim()) return ask();
 
-// ── MCP stdio server ──────────────────────────────────────────────────────────
+      // Auto-recall before responding
+      const recalled = await memory.recall(userInput, 5).catch(() => []);
+      const context  = recalled.length
+        ? '\n\nRELEVANT MEMORY:\n' + recalled.map(r => `- ${r.content} (score: ${r.score?.toFixed(2)})`).join('\n')
+        : '';
 
-process.stdin.setEncoding('utf8');
-let buf = '';
+      messages.push({ role: 'user', content: userInput + context });
 
-function send(obj) { process.stdout.write(JSON.stringify(obj) + '\n'); }
+      try {
+        const res = await client.messages.create({
+          model:      'claude-opus-4-5',
+          max_tokens: 1024,
+          system:     systemPrompt,
+          messages,
+        });
 
-process.stdin.on('data', async chunk => {
-  buf += chunk;
-  const lines = buf.split('\n');
-  buf = lines.pop();
+        const reply = res.content[0].text;
+        console.log(`\nClaude: ${reply}\n`);
+        messages.push({ role: 'assistant', content: reply });
 
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    let req;
-    try { req = JSON.parse(line); } catch {
-      send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
-      continue;
-    }
-    if (!req || typeof req.method !== 'string') continue;
-    if (req.method.startsWith('notifications/')) continue;
-    if (!('id' in req)) continue;
+        // Auto-store the exchange into MAGMA graph
+        await autoStore(memory, userInput, reply);
 
-    try {
-      if (req.method === 'initialize') {
-        send({ jsonrpc: '2.0', id: req.id, result: {
-          protocolVersion: '2025-11-25',
-          serverInfo: { name: 'vektor-slipstream', version: '1.2.0' },
-          capabilities: { tools: {} },
-        }});
-        getMemory().catch(e => process.stderr.write('[vektor-mcp] Memory init: ' + e.message + '\n'));
-        continue;
+      } catch (err) {
+        console.error('API error:', err.message);
       }
-      if (req.method === 'tools/list') {
-        send({ jsonrpc: '2.0', id: req.id, result: { tools: TOOLS } });
-        continue;
-      }
-      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;
-      }
-      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 } });
-    }
+
+      ask();
+    });
   }
-});
 
-process.stdin.resume();
+  main().catch(console.error);
+}

package/examples/example-langchain-researcher.js

@@ -1,116 +1,82 @@
+'use strict';
 /**
- * example-langchain-researcher.js
- * VEKTOR SLIPSTREAM — LangChain Research Agent Example
- * ─────────────────────────────────────────────────────
- * A research agent that uses LangChain to search the web,
- * summarise findings, and store everything in persistent
- * Slipstream memory so it learns across sessions.
- *
- * Install:
- *   npm install vektor-slipstream langchain @langchain/openai
+ * example-langchain-researcher.js — VEKTOR Slipstream + LangChain
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Auto-memory: agent context, research results, and decisions flow
+ * into the MAGMA graph automatically after every run.
  *
  * Usage:
- *   OPENAI_API_KEY=sk-... node example-langchain-researcher.js
+ *   OPENAI_API_KEY=sk-... VEKTOR_LICENCE_KEY=... node example-langchain-researcher.js
  */
 
-'use strict';
-
-const { createMemory }            = require('vektor-slipstream');
-const { ChatOpenAI }              = require('@langchain/openai');
-const { AgentExecutor }           = require('langchain/agents');
-const { createOpenAIFunctionsAgent } = require('langchain/agents');
-const { TavilySearchResults }     = require('@langchain/community/tools/tavily_search');
-const { ChatPromptTemplate, MessagesPlaceholder } = require('@langchain/core/prompts');
-
-// ── Config ────────────────────────────────────────────────────────────────────
-
-const AGENT_ID   = 'langchain-researcher';
-const TOPIC      = process.argv[2] || 'latest developments in agentic AI memory systems';
-
-// ── Boot ──────────────────────────────────────────────────────────────────────
+const { createMemory }                                    = require('vektor-slipstream');
+const { ChatOpenAI }                                      = require('@langchain/openai');
+const { AgentExecutor, createOpenAIFunctionsAgent }       = require('langchain/agents');
+const { TavilySearchResults }                             = require('@langchain/community/tools/tavily_search');
+const { ChatPromptTemplate, MessagesPlaceholder }         = require('@langchain/core/prompts');
+const readline                                            = require('readline');
 
 async function main() {
-  console.log('\n[RESEARCHER] Booting Slipstream memory...');
-  const memory = await createMemory({ agentId: AGENT_ID, dbPath: './research-memory.db', licenceKey: process.env.VEKTOR_LICENCE_KEY });
-
-  // ── 1. Recall what we already know ──────────────────────────────────────────
-  console.log(`[RESEARCHER] Recalling prior knowledge on: "${TOPIC}"`);
-  const priorKnowledge = await memory.recall(TOPIC, 5);
-
-  let priorContext = 'No prior research on this topic.';
-  if (priorKnowledge.length > 0) {
-    priorContext = priorKnowledge
-      .map((m, i) => `${i + 1}. [score: ${m.score}] ${m.content}`)
-      .join('\n');
-    console.log(`[RESEARCHER] Found ${priorKnowledge.length} prior memories.`);
-  } else {
-    console.log('[RESEARCHER] No prior memories — starting fresh.');
-  }
-
-  // ── 2. Build the LangChain agent ────────────────────────────────────────────
-  const llm   = new ChatOpenAI({ modelName: 'gpt-4o-mini', temperature: 0.1 });
-  const tools = [new TavilySearchResults({ maxResults: 5 })];
-
-  const prompt = ChatPromptTemplate.fromMessages([
-    ['system', `You are a meticulous research agent with persistent memory.
-
-PRIOR KNOWLEDGE FROM MEMORY:
-${priorContext}
-
-Instructions:
-- Search for new information on the given topic
-- Compare findings with prior knowledge — note what's changed or new
-- Produce a concise research summary (3-5 paragraphs)
-- End with a "KEY FINDINGS:" section listing 3-5 bullet points
-- Be specific: cite sources, dates, and data points`],
-    ['human', '{input}'],
-    new MessagesPlaceholder('agent_scratchpad'),
-  ]);
-
-  const agent   = await createOpenAIFunctionsAgent({ llm, tools, prompt });
-  const executor = new AgentExecutor({ agent, tools, verbose: false });
-
-  // ── 3. Run research ──────────────────────────────────────────────────────────
-  console.log('[RESEARCHER] Running LangChain agent...\n');
-  const result = await executor.invoke({ input: `Research this topic thoroughly: ${TOPIC}` });
-  const output = result.output;
-
-  console.log('─'.repeat(60));
-  console.log(output);
-  console.log('─'.repeat(60));
-
-  // ── 4. Store findings in Slipstream ─────────────────────────────────────────
-  console.log('\n[RESEARCHER] Storing findings in Slipstream memory...');
-
-  // Store the full summary
-  await memory.remember(
-    `[RESEARCH] ${TOPIC}: ${output}`,
-    { importance: 2 }
-  );
-
-  // Extract and store each KEY FINDING separately for granular recall
-  const keyFindingsMatch = output.match(/KEY FINDINGS:([\s\S]+?)(?:\n\n|$)/i);
-  if (keyFindingsMatch) {
-    const findings = keyFindingsMatch[1]
-      .split('\n')
-      .map(l => l.replace(/^[-•*]\s*/, '').trim())
-      .filter(Boolean);
-
-    for (const finding of findings) {
-      await memory.remember(`[FINDING] ${finding}`, { importance: 3 });
+  // ── Init VEKTOR memory ──────────────────────────────────────────────────────
+  const memory = await createMemory({
+    agentId:    process.env.SLIPSTREAM_AGENT_ID || 'langchain-vektor',
+    licenceKey: process.env.VEKTOR_LICENCE_KEY,
+    dbPath:     process.env.VEKTOR_DB_PATH,
+    silent:     true,
+  });
+
+  const brief = await memory.briefing().catch(() => '');
+  console.log('\n🧠 VEKTOR Memory active — research stored in MAGMA graph');
+  if (brief) console.log(`\nBriefing: ${brief}\n`);
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = () => rl.question('\nResearch topic (Ctrl+C to exit): ', async topic => {
+    if (!topic.trim()) return ask();
+
+    // ── Recall prior research on this topic ─────────────────────────────────
+    const prior     = await memory.recall(topic, 5).catch(() => []);
+    const priorText = prior.length
+      ? 'PRIOR RESEARCH:\n' + prior.map(r => `- ${r.content}`).join('\n')
+      : 'No prior research found on this topic.';
+
+    // ── Build agent ──────────────────────────────────────────────────────────
+    const llm   = new ChatOpenAI({ modelName: 'gpt-4o-mini', temperature: 0.1 });
+    const tools = [new TavilySearchResults({ maxResults: 5 })];
+
+    const prompt = ChatPromptTemplate.fromMessages([
+      ['system', `You are a research agent with persistent memory.\n\n${priorText}\n\nBuild on prior research. Identify new findings. Be concise.`],
+      ['human', '{input}'],
+      new MessagesPlaceholder('agent_scratchpad'),
+    ]);
+
+    const agent    = await createOpenAIFunctionsAgent({ llm, tools, prompt });
+    const executor = new AgentExecutor({ agent, tools, verbose: false });
+
+    try {
+      console.log(`\nResearching: ${topic}...`);
+      const result = await executor.invoke({ input: topic });
+
+      console.log(`\nFindings:\n${result.output}\n`);
+
+      // ── Auto-store findings into MAGMA graph ─────────────────────────────
+      await memory.remember(`Research topic: ${topic}`, { importance: 3 }).catch(() => {});
+      await memory.remember(`Research findings: ${result.output.slice(0, 500)}`, { importance: 4 }).catch(() => {});
+
+      // Store key sentences as individual memories for better graph connectivity
+      const sentences = result.output.split(/[.!?]+/).filter(s => s.trim().length > 40);
+      for (const sentence of sentences.slice(0, 5)) {
+        await memory.remember(sentence.trim(), { importance: 2 }).catch(() => {});
+      }
+
+      console.log(`✓ ${sentences.slice(0, 5).length + 2} memories stored in MAGMA graph`);
+
+    } catch (err) {
+      console.error('Agent error:', err.message);
     }
-    console.log(`[RESEARCHER] Stored ${findings.length} key findings separately.`);
-  }
-
-  // ── 5. Show memory briefing ──────────────────────────────────────────────────
-  const briefing = await memory.briefing();
-  console.log('\n[RESEARCHER] Memory briefing (last 24h):');
-  console.log(briefing);
 
-  console.log('\n[RESEARCHER] Done. Run again tomorrow — agent will build on today\'s findings.');
+    ask();
+  });
 }
 
-main().catch(e => {
-  console.error('[RESEARCHER] Error:', e.message);
-  process.exit(1);
-});
+main().catch(console.error);

package/examples/example-openai-assistant.js

@@ -1,195 +1,84 @@
+'use strict';
 /**
- * example-openai-assistant.js
- * VEKTOR SLIPSTREAM — OpenAI Agents SDK Assistant Loop Example
- * ─────────────────────────────────────────────────────────────
- * A persistent assistant that remembers every conversation.
- * Uses the OpenAI Agents SDK for tool use and Slipstream for
- * cross-session memory — the assistant genuinely knows who you
- * are and what you've discussed before.
- *
- * Install:
- *   npm install vektor-slipstream openai @openai/agents readline
+ * example-openai-assistant.js — VEKTOR Slipstream + OpenAI
+ * ─────────────────────────────────────────────────────────────────────────────
+ * Auto-memory: every conversation turn flows into the MAGMA graph.
+ * No setup required — memory just works from the first message.
  *
  * Usage:
- *   OPENAI_API_KEY=sk-... node example-openai-assistant.js
+ *   OPENAI_API_KEY=sk-... VEKTOR_LICENCE_KEY=... node example-openai-assistant.js
  */
 
-'use strict';
-
 const { createMemory } = require('vektor-slipstream');
 const OpenAI           = require('openai');
 const readline         = require('readline');
 
-// ── Config ────────────────────────────────────────────────────────────────────
-
-const AGENT_ID = 'openai-assistant';
-const MODEL    = 'gpt-4o-mini';
-
-// ── Tools available to the assistant ─────────────────────────────────────────
-
-function buildTools(memory) {
-  return [
-    {
-      type: 'function',
-      function: {
-        name: 'remember',
-        description: 'Store an important fact, preference, or decision in long-term memory. Call this whenever the user shares something worth remembering across sessions.',
-        parameters: {
-          type: 'object',
-          properties: {
-            content: {
-              type: 'string',
-              description: 'The fact or information to remember, written as a clear complete sentence.',
-            },
-            importance: {
-              type: 'number',
-              description: 'Importance score 1-5. Use 5 for critical facts (name, key decisions), 3 for useful context, 1 for minor details.',
-            },
-          },
-          required: ['content'],
-        },
-      },
-    },
-    {
-      type: 'function',
-      function: {
-        name: 'recall',
-        description: 'Search long-term memory for relevant information. Call this when you need context about the user or a topic discussed previously.',
-        parameters: {
-          type: 'object',
-          properties: {
-            query: {
-              type: 'string',
-              description: 'What to search for in memory.',
-            },
-          },
-          required: ['query'],
-        },
-      },
-    },
-    {
-      type: 'function',
-      function: {
-        name: 'memory_graph',
-        description: 'Explore connected memories around a concept. Use this to understand the full context around a topic.',
-        parameters: {
-          type: 'object',
-          properties: {
-            concept: { type: 'string', description: 'The concept to explore.' },
-            hops:    { type: 'number', description: 'How many hops to traverse (1-3). Default 2.' },
-          },
-          required: ['concept'],
-        },
-      },
-    },
-  ];
+// ── Heuristic: importance scoring ────────────────────────────────────────────
+function scoreImportance(text) {
+  const t = text.toLowerCase();
+  if (/prefer|always|never|my name|i am|i'm a|i work|my project|deadline|critical|remember/.test(t)) return 4;
+  if (/project|build|using|stack|deploy|api|database|decided|going with|language|framework/.test(t)) return 3;
+  if (text.length > 80) return 2;
+  return null;
 }
 
-// ── Tool execution ────────────────────────────────────────────────────────────
-
-async function executeTool(name, args, memory) {
-  switch (name) {
-    case 'remember': {
-      const { id } = await memory.remember(args.content, { importance: args.importance || 2 });
-      return `Stored memory #${id}: "${args.content.slice(0, 80)}${args.content.length > 80 ? '...' : ''}"`;
-    }
-    case 'recall': {
-      const results = await memory.recall(args.query, 5);
-      if (!results.length) return 'No relevant memories found.';
-      return results.map((r, i) =>
-        `${i + 1}. [relevance: ${r.score}] ${r.content}`
-      ).join('\n');
-    }
-    case 'memory_graph': {
-      const { nodes, edges } = await memory.graph(args.concept, { hops: args.hops || 2 });
-      return `Found ${nodes.length} connected memories and ${edges.length} relationships.\n` +
-        nodes.slice(0, 5).map(n => `• ${n.content.slice(0, 100)}`).join('\n');
-    }
-    default:
-      return 'Unknown tool.';
-  }
-}
-
-// ── Main assistant loop ───────────────────────────────────────────────────────
-
 async function main() {
-  console.log('\n[ASSISTANT] Booting Slipstream memory...');
-  const memory = await createMemory({ agentId: AGENT_ID, dbPath: './assistant-memory.db', licenceKey: process.env.VEKTOR_LICENCE_KEY });
+  const memory = await createMemory({
+    agentId:    process.env.SLIPSTREAM_AGENT_ID || 'openai-vektor',
+    licenceKey: process.env.VEKTOR_LICENCE_KEY,
+    dbPath:     process.env.VEKTOR_DB_PATH,
+    silent:     true,
+  });
 
   const client   = new OpenAI();
-  const tools    = buildTools(memory);
   const messages = [];
 
-  // Inject morning briefing as system context
-  const briefing = await memory.briefing();
-  const systemPrompt = `You are a persistent personal assistant with long-term memory powered by VEKTOR Slipstream.
+  // Boot briefing — inject yesterday's context
+  const brief = await memory.briefing().catch(() => '');
+  const system = [
+    'You are a helpful assistant with persistent memory. You remember everything across sessions.',
+    brief ? `\nMEMORY BRIEFING:\n${brief}` : '',
+  ].filter(Boolean).join('\n');
 
-You have access to tools to remember and recall information across sessions.
-Always recall relevant memories before answering questions about past conversations or the user's context.
-When the user shares important information, use the remember tool to store it.
+  console.log('\n🧠 VEKTOR Memory active — conversations stored in MAGMA graph');
+  console.log('Type your message (Ctrl+C to exit)\n');
 
-${briefing}`;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
 
-  messages.push({ role: 'system', content: systemPrompt });
+  const ask = () => rl.question('You: ', async userInput => {
+    if (!userInput.trim()) return ask();
 
-  // Terminal interface
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const prompt = () => new Promise(resolve => rl.question('\nYou: ', resolve));
+    // Auto-recall relevant context
+    const recalled = await memory.recall(userInput, 5).catch(() => []);
+    const context  = recalled.length
+      ? '\n\n[MEMORY CONTEXT]\n' + recalled.map(r => `- ${r.content}`).join('\n') + '\n[/MEMORY CONTEXT]'
+      : '';
 
-  console.log('\n[ASSISTANT] Ready. Your memories persist across sessions.');
-  console.log('[ASSISTANT] Type "exit" to quit, "briefing" to see memory summary.\n');
+    messages.push({ role: 'user', content: userInput + context });
 
-  while (true) {
-    const userInput = (await prompt()).trim();
-    if (!userInput) continue;
-    if (userInput.toLowerCase() === 'exit') { rl.close(); break; }
+    try {
+      const res   = await client.chat.completions.create({ model: 'gpt-4o-mini', messages: [{ role: 'system', content: system }, ...messages] });
+      const reply = res.choices[0].message.content;
 
-    if (userInput.toLowerCase() === 'briefing') {
-      console.log('\n' + await memory.briefing());
-      continue;
-    }
+      console.log(`\nAssistant: ${reply}\n`);
+      messages.push({ role: 'assistant', content: reply });
 
-    messages.push({ role: 'user', content: userInput });
-
-    // Agent loop — handles tool calls automatically
-    let response;
-    while (true) {
-      response = await client.chat.completions.create({
-        model: MODEL,
-        messages,
-        tools,
-        tool_choice: 'auto',
-      });
-
-      const msg = response.choices[0].message;
-      messages.push(msg);
-
-      if (!msg.tool_calls?.length) break; // Done
-
-      // Execute all tool calls
-      const toolResults = await Promise.all(
-        msg.tool_calls.map(async tc => {
-          const args   = JSON.parse(tc.function.arguments);
-          const result = await executeTool(tc.function.name, args, memory);
-          console.log(`  [tool:${tc.function.name}] ${result.slice(0, 120)}`);
-          return {
-            role:         'tool',
-            tool_call_id: tc.id,
-            content:      result,
-          };
-        })
-      );
-      messages.push(...toolResults);
-    }
+      // Auto-store user input if memorable
+      const imp = scoreImportance(userInput);
+      if (imp) await memory.remember(userInput, { importance: imp }).catch(() => {});
 
-    const reply = response.choices[0].message.content;
-    console.log(`\nAssistant: ${reply}`);
-  }
+      // Always store the exchange summary
+      await memory.remember(
+        `Exchange — User: ${userInput.slice(0, 150)} | Assistant: ${reply.slice(0, 200)}`,
+        { importance: 2 }
+      ).catch(() => {});
+
+    } catch (err) {
+      console.error('API error:', err.message);
+    }
 
-  console.log('\n[ASSISTANT] Session ended. Memories saved for next time.');
+    ask();
+  });
 }
 
-main().catch(e => {
-  console.error('[ASSISTANT] Error:', e.message);
-  process.exit(1);
-});
+main().catch(console.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vektor-slipstream",
-  "version": "1.3.8",
+  "version": "1.4.0",
   "description": "Hardware-accelerated persistent memory for AI agents. Local-first, zero cloud dependency, $0 embedding cost.",
   "main": "slipstream-core-extended.js",
   "types": "./types/index.d.ts",
@@ -71,7 +71,8 @@
   },
   "dependencies": {
     "better-sqlite3": "^12.8.0",
-    "onnxruntime-node": "^1.17.3"
+    "onnxruntime-node": "^1.17.3",
+    "vektor-slipstream": "^1.4.0"
   },
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.82.0",