vektor-slipstream 1.3.9 → 1.4.1

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);
+}