vektor-slipstream 1.4.0 → 1.4.2

package/README.md

@@ -1,237 +1,241 @@
-# vektor-slipstream
-
-Hardware-accelerated persistent memory for AI agents. Local-first. No cloud. One-time payment.
-
-[![npm](https://img.shields.io/npm/v/vektor-slipstream)](https://www.npmjs.com/package/vektor-slipstream)
-[![license](https://img.shields.io/badge/license-Commercial-blue)](https://vektormemory.com/product#pricing)
-
-## 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,
-});
-
-// 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', 5);
-// → [{ content, score, id }]
-
-// Traverse the graph
-const graph = await memory.graph('TypeScript', { hops: 2 });
-
-// What changed in 7 days?
-const delta = await memory.delta('project decisions', 7);
-
-// Morning briefing
-const brief = await memory.briefing();
-```
-
-## CLI
-
-```bash
-npx vektor setup      # First-run wizard — licence, hardware, integrations
-npx vektor activate   # Activate licence key on this machine
-npx vektor test       # Test memory engine with progress bar
-npx vektor status     # System health check
-npx vektor mcp        # Start Claude Desktop MCP server
-npx vektor rem        # Run REM dream cycle
-npx vektor help       # All commands
-```
-
-## CLOAK — Developer Context Layer for Claude Code
-
-CLOAK is a 4-tool MCP layer that gives Claude Code persistent memory of your project.
-Every session starts with full context. Every error is remembered. Every wasted token is tracked.
-
-### What it does
-
-| Tool | Does exactly one thing |
-|---|---|
-| `cloak_cortex` | Scans project files, builds a token-aware anatomy index in Vektor's entity graph |
-| `cloak_axon` | Session boundary handler — loads last context on start, saves MemCell on stop |
-| `cloak_cerebellum` | Pre-write enforcer — checks writes against known error patterns, auto-resolves fixes |
-| `cloak_token` | Token ledger — detects repeated reads and waste, one summary write per session |
-
-### Import
-
-```js
-const { runCortex }        = require('vektor-slipstream/cloak/cortex');
-const { onSessionStart,
-        onSessionStop }    = require('vektor-slipstream/cloak/axon');
-const { checkWrite,
-        recordError }      = require('vektor-slipstream/cloak/cerebellum');
-const { getSessionSummary} = require('vektor-slipstream/cloak/token');
-
-// Clean terminal output (replaces emoji with box-drawing chars)
-const { createMemory }     = require('vektor-slipstream/boot');
-```
-
-### Claude Code setup
-
-Add to `.claude/settings.json` in your project:
-
-```json
-{
-  "mcpServers": {
-    "cloak": {
-      "command": "node",
-      "args": ["/path/to/node_modules/vektor-slipstream/index.js"],
-      "env": {
-        "VEKTOR_LICENCE_KEY": "your-licence-key",
-        "CLOAK_PROJECT_PATH": "/path/to/your/project"
-      }
-    }
-  },
-  "hooks": {
-    "SessionStart": [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook SessionStart" }],
-    "Stop":         [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook Stop" }],
-    "PreToolUse":   [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook PreToolUse" }],
-    "PostToolUse":  [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook PostToolUse" }]
-  }
-}
-```
-
-### Usage
-
-```js
-// Scan project files into Vektor entity graph (call once on init)
-await cloak_cortex({})
-
-// Start session — loads last context automatically
-await cloak_axon({ action: 'start' })
-
-// Check before a risky write
-await cloak_cerebellum({
-  action: 'check',
-  content: '...code...',
-  filePath: 'src/auth.ts'
-})
-
-// Record a bug you just hit
-await cloak_cerebellum({
-  action: 'record_error',
-  description: 'Null ref on user.id when DB returns empty',
-  filePath: 'src/auth.ts',
-  errorType: 'null_reference',
-  fix: 'Add guard: if (user && user.id)'
-})
-
-// Save session with intent — the "why" not just the "what"
-await cloak_axon({
-  action: 'stop',
-  narrative: 'Fixed null reference in auth module'
-})
-
-// Check token waste
-await cloak_token({ action: 'summary' })
-```
-
-### Architecture
-
-```
-Claude Code
-    ↓ hooks + MCP tool calls
-CLOAK (4 tools, ~800 lines Node.js)
-    ↓ memory.remember() / memory.recall()
-Vektor / MAGMA
-    ↓ 4-layer graph (semantic, temporal, causal, entity)
-SQLite-vec (local, no cloud)
-```
-
-### DB growth
-
-CLOAK writes 3-5 nodes per session — not per operation.
-At 1 year of daily use: ~1,000 nodes. Sub-millisecond recall throughout.
-
-> ⚠️ **Concurrency warning**: Use stdio MCP (default). The HTTP mode
-> (`CLOAK_HTTP=1`) does not support concurrent multi-agent sessions.
-
----
-
-## What's Included
-
-### Memory Core (MAGMA)
-
-- 4-layer associative graph — semantic, causal, temporal, entity
-- AUDN curation loop — zero contradictions, zero duplicates
-- REM dream cycle — up to 50:1 compression
-- Sub-20ms recall — HNSW index, local SQLite
-- Local ONNX embeddings — $0 embedding cost, no API key required
-
-### Integrations
-
-- **Claude MCP** — `vektor_recall`, `vektor_store`, `vektor_graph`, `vektor_delta`
-- **Claude Code** — CLOAK 4-tool developer context layer (see above)
-- **LangChain** — v1 + v2 adapter included
-- **OpenAI Agents SDK** — drop-in integration
-- **Mistral** — `vektor_memoire` HTTP tool, localhost bridge
-- **Gemini · Groq · Ollama** — provider agnostic
-
-### Cloak (Sovereign Identity)
-
-- `cloak_fetch` — stealth headless browser fetch
-- `cloak_render` — computed CSS · post-JS DOM sensor
-- `cloak_passport` — AES-256-GCM credential vault, machine-bound
-- `cloak_diff` — semantic diff since last fetch
-- `tokens_saved` — ROI audit per session
-
-```js
-const { cloak_passport, cloak_fetch, tokens_saved } = require('vektor-slipstream/cloak');
-
-cloak_passport('GITHUB_TOKEN', 'ghp_xxxx');
-const token = cloak_passport('GITHUB_TOKEN');
-
-const { text, tokensSaved } = await cloak_fetch('https://example.com');
-
-const roi = tokens_saved({ raw_tokens: 10000, actual_tokens: 3000 });
-// → { reduction_pct: 70, cost_saved_usd: 0.0175, roi_multiple: 2.3 }
-```
-
-## Performance
-
-| Metric | Value |
-|--------|-------|
-| Recall latency | ~8ms avg (local SQLite) |
-| Embedding cost | $0 — fully local ONNX |
-| Embedding latency | ~10ms GPU / ~25ms CPU |
-| First run | ~2 min (downloads ~25MB model once) |
-| Subsequent boots | <100ms |
-
-## Hardware Auto-Detection
-
-Zero config. VEKTOR detects and uses the best available accelerator:
-
-- **NVIDIA CUDA** — GPU acceleration
-- **Apple Silicon** — CoreML
-- **CPU** — optimised fallback, works everywhere
-
-## Licence
-
-Commercial licence. One-time payment of $159. Activates on up to 3 machines.
-Manage at [polar.sh](https://polar.sh).
-
-Purchase: [vektormemory.com/product#pricing](https://vektormemory.com/product#pricing)
-Docs: [vektormemory.com/docs](https://vektormemory.com/docs)
-Support: hello@vektormemory.com
-
-## Research
-
-Built on peer-reviewed research:
-
-- [MAGMA (arxiv:2601.03236)](https://arxiv.org/abs/2601.03236) — Multi-Graph Agentic Memory Architecture
-- [EverMemOS (arxiv:2601.02163)](https://arxiv.org/abs/2601.02163) — Self-Organizing Memory OS
-- [HippoRAG (arxiv:2405.14831)](https://arxiv.org/abs/2405.14831) — Neurobiologically Inspired Long-Term Memory (NeurIPS 2024)
-- [Mem0 (arxiv:2504.19413)](https://arxiv.org/abs/2504.19413) — Production-Ready Agent Memory
+# vektor-slipstream
+
+Hardware-accelerated persistent memory for AI agents. Local-first. No cloud. One-time payment.
+
+[![npm](https://img.shields.io/npm/v/vektor-slipstream)](https://www.npmjs.com/package/vektor-slipstream)
+[![license](https://img.shields.io/badge/license-Commercial-blue)](https://vektormemory.com/product#pricing)
+
+## 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,
+});
+
+// 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', 5);
+// → [{ content, score, id }]
+
+// Traverse the graph
+const graph = await memory.graph('TypeScript', { hops: 2 });
+
+// What changed in 7 days?
+const delta = await memory.delta('project decisions', 7);
+
+// Morning briefing
+const brief = await memory.briefing();
+```
+
+## CLI
+
+```bash
+npx vektor setup      # First-run wizard — licence, hardware, integrations
+npx vektor activate   # Activate licence key on this machine
+npx vektor test       # Test memory engine with progress bar
+npx vektor status     # System health check
+npx vektor mcp        # Start Claude Desktop MCP server
+npx vektor rem        # Run REM dream cycle
+npx vektor chat       # Persistent memory chat (all LLMs)
+npx vektor remember   # Store a fact: npx vektor remember "I prefer TypeScript"
+npx vektor ask        # Query memory: npx vektor ask "what stack am I using?"
+npx vektor agent      # Autonomous goal executor
+npx vektor help       # All commands
+```
+
+## CLOAK — Developer Context Layer for Claude Code
+
+CLOAK is a 4-tool MCP layer that gives Claude Code persistent memory of your project.
+Every session starts with full context. Every error is remembered. Every wasted token is tracked.
+
+### What it does
+
+| Tool | Does exactly one thing |
+|---|---|
+| `cloak_cortex` | Scans project files, builds a token-aware anatomy index in Vektor's entity graph |
+| `cloak_axon` | Session boundary handler — loads last context on start, saves MemCell on stop |
+| `cloak_cerebellum` | Pre-write enforcer — checks writes against known error patterns, auto-resolves fixes |
+| `cloak_token` | Token ledger — detects repeated reads and waste, one summary write per session |
+
+### Import
+
+```js
+const { runCortex }        = require('vektor-slipstream/cloak/cortex');
+const { onSessionStart,
+        onSessionStop }    = require('vektor-slipstream/cloak/axon');
+const { checkWrite,
+        recordError }      = require('vektor-slipstream/cloak/cerebellum');
+const { getSessionSummary} = require('vektor-slipstream/cloak/token');
+
+// Clean terminal output (replaces emoji with box-drawing chars)
+const { createMemory }     = require('vektor-slipstream/boot');
+```
+
+### Claude Code setup
+
+Add to `.claude/settings.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "cloak": {
+      "command": "node",
+      "args": ["/path/to/node_modules/vektor-slipstream/index.js"],
+      "env": {
+        "VEKTOR_LICENCE_KEY": "your-licence-key",
+        "CLOAK_PROJECT_PATH": "/path/to/your/project"
+      }
+    }
+  },
+  "hooks": {
+    "SessionStart": [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook SessionStart" }],
+    "Stop":         [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook Stop" }],
+    "PreToolUse":   [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook PreToolUse" }],
+    "PostToolUse":  [{ "type": "command", "command": "node /path/to/node_modules/vektor-slipstream/index.js --hook PostToolUse" }]
+  }
+}
+```
+
+### Usage
+
+```js
+// Scan project files into Vektor entity graph (call once on init)
+await cloak_cortex({})
+
+// Start session — loads last context automatically
+await cloak_axon({ action: 'start' })
+
+// Check before a risky write
+await cloak_cerebellum({
+  action: 'check',
+  content: '...code...',
+  filePath: 'src/auth.ts'
+})
+
+// Record a bug you just hit
+await cloak_cerebellum({
+  action: 'record_error',
+  description: 'Null ref on user.id when DB returns empty',
+  filePath: 'src/auth.ts',
+  errorType: 'null_reference',
+  fix: 'Add guard: if (user && user.id)'
+})
+
+// Save session with intent — the "why" not just the "what"
+await cloak_axon({
+  action: 'stop',
+  narrative: 'Fixed null reference in auth module'
+})
+
+// Check token waste
+await cloak_token({ action: 'summary' })
+```
+
+### Architecture
+
+```
+Claude Code
+    ↓ hooks + MCP tool calls
+CLOAK (4 tools, ~800 lines Node.js)
+    ↓ memory.remember() / memory.recall()
+Vektor / MAGMA
+    ↓ 4-layer graph (semantic, temporal, causal, entity)
+SQLite-vec (local, no cloud)
+```
+
+### DB growth
+
+CLOAK writes 3-5 nodes per session — not per operation.
+At 1 year of daily use: ~1,000 nodes. Sub-millisecond recall throughout.
+
+> ⚠️ **Concurrency warning**: Use stdio MCP (default). The HTTP mode
+> (`CLOAK_HTTP=1`) does not support concurrent multi-agent sessions.
+
+---
+
+## What's Included
+
+### Memory Core (MAGMA)
+
+- 4-layer associative graph — semantic, causal, temporal, entity
+- AUDN curation loop — zero contradictions, zero duplicates
+- REM dream cycle — up to 50:1 compression
+- Sub-20ms recall — HNSW index, local SQLite
+- Local ONNX embeddings — $0 embedding cost, no API key required
+
+### Integrations
+
+- **Claude MCP** — `vektor_recall`, `vektor_store`, `vektor_graph`, `vektor_delta`
+- **Claude Code** — CLOAK 4-tool developer context layer (see above)
+- **LangChain** — v1 + v2 adapter included
+- **OpenAI Agents SDK** — drop-in integration
+- **Mistral** — `vektor_memoire` HTTP tool, localhost bridge
+- **Gemini · Groq · Ollama** — provider agnostic
+
+### Cloak (Sovereign Identity)
+
+- `cloak_fetch` — stealth headless browser fetch
+- `cloak_render` — computed CSS · post-JS DOM sensor
+- `cloak_passport` — AES-256-GCM credential vault, machine-bound
+- `cloak_diff` — semantic diff since last fetch
+- `tokens_saved` — ROI audit per session
+
+```js
+const { cloak_passport, cloak_fetch, tokens_saved } = require('vektor-slipstream/cloak');
+
+cloak_passport('GITHUB_TOKEN', 'ghp_xxxx');
+const token = cloak_passport('GITHUB_TOKEN');
+
+const { text, tokensSaved } = await cloak_fetch('https://example.com');
+
+const roi = tokens_saved({ raw_tokens: 10000, actual_tokens: 3000 });
+// → { reduction_pct: 70, cost_saved_usd: 0.0175, roi_multiple: 2.3 }
+```
+
+## Performance
+
+| Metric | Value |
+|--------|-------|
+| Recall latency | ~8ms avg (local SQLite) |
+| Embedding cost | $0 — fully local ONNX |
+| Embedding latency | ~10ms GPU / ~25ms CPU |
+| First run | ~2 min (downloads ~25MB model once) |
+| Subsequent boots | <100ms |
+
+## Hardware Auto-Detection
+
+Zero config. VEKTOR detects and uses the best available accelerator:
+
+- **NVIDIA CUDA** — GPU acceleration
+- **Apple Silicon** — CoreML
+- **CPU** — optimised fallback, works everywhere
+
+## Licence
+
+Commercial licence. One-time payment of $159. Activates on up to 3 machines.
+Manage at [polar.sh](https://polar.sh).
+
+Purchase: [vektormemory.com/product#pricing](https://vektormemory.com/product#pricing)
+Docs: [vektormemory.com/docs](https://vektormemory.com/docs)
+Support: hello@vektormemory.com
+
+## Research
+
+Built on peer-reviewed research:
+
+- [MAGMA (arxiv:2601.03236)](https://arxiv.org/abs/2601.03236) — Multi-Graph Agentic Memory Architecture
+- [EverMemOS (arxiv:2601.02163)](https://arxiv.org/abs/2601.02163) — Self-Organizing Memory OS
+- [HippoRAG (arxiv:2405.14831)](https://arxiv.org/abs/2405.14831) — Neurobiologically Inspired Long-Term Memory (NeurIPS 2024)
+- [Mem0 (arxiv:2504.19413)](https://arxiv.org/abs/2504.19413) — Production-Ready Agent Memory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vektor-slipstream",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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",
@@ -72,7 +72,7 @@
   "dependencies": {
     "better-sqlite3": "^12.8.0",
     "onnxruntime-node": "^1.17.3",
-    "vektor-slipstream": "^1.4.0"
+    "vektor-slipstream": "^1.4.1"
   },
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.82.0",

package/vektor-cli.js

@@ -44,42 +44,69 @@ function printBox() {
 
 async function cmdHelp() {
   printBox();
-  console.log(bold('  COMMANDS\n'));
+  console.log(bold('  MEMORY COMMANDS\n'));
+
+  const memoryCmds = [
+    ['chat',        'Persistent memory chat — all conversations stored in MAGMA graph'],
+    ['remember',    'Store a fact instantly: npx vektor remember "I prefer TypeScript"'],
+    ['ask',         'Ask a question using your memory: npx vektor ask "what stack am I using?"'],
+    ['agent',       'Autonomous goal executor: npx vektor agent "research X and summarise"'],
+    ['briefing',    'Generate a morning briefing from recent memories'],
+    ['rem',         'Run the REM dream cycle — compress and consolidate memories'],
+    ['tui',         'Launch the interactive memory browser (terminal UI)'],
+  ];
+
+  memoryCmds.forEach(([cmd, desc]) => {
+    console.log('  ' + cyan(('npx vektor ' + cmd).padEnd(26)) + dim(desc));
+  });
+
+  console.log('');
+  console.log(bold('  SYSTEM COMMANDS\n'));
 
-  const cmds = [
+  const sysCmds = [
     ['setup',      'First-run wizard — activate licence, test memory, configure integrations'],
     ['activate',   'Activate your licence key on this machine'],
     ['deactivate', "Free up this machine's activation slot"],
     ['status',     'Show licence status, memory stats, and system info'],
     ['test',       'Run a quick memory test (remember + recall + briefing)'],
     ['mcp',        'Start the Claude MCP server (for Claude Desktop)'],
-    ['tui',        'Launch the interactive memory browser (terminal UI)'],
-    ['rem',        'Run the REM dream cycle on your memory database'],
-    ['briefing',   'Generate a morning briefing from recent memories'],
     ['help',       'Show this help message'],
   ];
 
-  cmds.forEach(([cmd, desc]) => {
+  sysCmds.forEach(([cmd, desc]) => {
     console.log('  ' + cyan(('npx vektor ' + cmd).padEnd(26)) + dim(desc));
   });
 
+  console.log('');
+  console.log(bold('  CHAT PROVIDERS\n'));
+  console.log('  ' + cyan('--provider claude ') + '  ' + dim('Anthropic Claude  (ANTHROPIC_API_KEY)'));
+  console.log('  ' + cyan('--provider openai ') + '  ' + dim('OpenAI GPT        (OPENAI_API_KEY)'));
+  console.log('  ' + cyan('--provider groq   ') + '  ' + dim('Groq LLaMA        (GROQ_API_KEY)'));
+  console.log('  ' + cyan('--provider gemini ') + '  ' + dim('Google Gemini     (GEMINI_API_KEY)'));
+  console.log('  ' + cyan('--provider ollama ') + '  ' + dim('Local Ollama      (free, ollama serve)'));
+
   console.log('');
   console.log(bold('  ENVIRONMENT\n'));
-  console.log('  ' + cyan('VEKTOR_LICENCE_KEY') + '  ' + dim('Your Polar licence key (skips interactive prompt)'));
+  console.log('  ' + cyan('VEKTOR_LICENCE_KEY') + '  ' + dim('Your Polar licence key'));
   console.log('  ' + cyan('VEKTOR_DB_PATH    ') + '  ' + dim('Path to memory database (default: ~/vektor-slipstream-memory.db)'));
-  console.log('  ' + cyan('VEKTOR_AGENT_ID   ') + '  ' + dim('Agent identifier (default: default)'));
+  console.log('  ' + cyan('VEKTOR_PROVIDER   ') + '  ' + dim('Default LLM provider (default: ollama)'));
+  console.log('  ' + cyan('VEKTOR_AGENT_ID   ') + '  ' + dim('Agent identifier (default: vektor-cli)'));
   console.log('');
   console.log(bold('  EXAMPLES\n'));
-  console.log(dim('  # First time setup'));
-  console.log('  npx vektor setup\n');
+  console.log(dim('  # Start chatting with persistent memory (uses Ollama by default)'));
+  console.log('  npx vektor chat\n');
+  console.log(dim('  # Chat with Claude'));
+  console.log('  npx vektor chat --provider claude\n');
+  console.log(dim('  # Store a fact instantly'));
+  console.log('  npx vektor remember "Client deadline is April 20th" --importance 5\n');
+  console.log(dim('  # Ask your memory a question'));
+  console.log('  npx vektor ask "what projects am I working on?"\n');
+  console.log(dim('  # Run an autonomous research agent'));
+  console.log('  npx vektor agent "research VEKTOR competitors and summarise findings"\n');
+  console.log(dim('  # Pipe content into memory'));
+  console.log('  cat README.md | npx vektor remember\n');
   console.log(dim('  # Connect to Claude Desktop'));
   console.log('  npx vektor mcp\n');
-  console.log(dim('  # Browse your memory interactively'));
-  console.log('  npx vektor tui\n');
-  console.log(dim('  # Run overnight memory compression'));
-  console.log('  npx vektor rem\n');
-  console.log(dim('  # Check everything is working'));
-  console.log('  npx vektor status\n');
   console.log('  ' + dim('Purchase at: https://vektormemory.com/product#pricing'));
   console.log('');
 }
@@ -117,6 +144,20 @@ async function cmdStatus() {
   try { require('onnxruntime-node'); hasOnnx = true; } catch (_) {}
   console.log('  ONNX runtime  ' + (hasOnnx ? green('✓ installed') : red('✗ missing (npm install onnxruntime-node)')));
 
+  // Provider check
+  const provider = process.env.VEKTOR_PROVIDER || 'ollama';
+  console.log('  LLM provider  ' + cyan(provider));
+  if (provider === 'ollama') {
+    try {
+      const res = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(2000) });
+      const data = await res.json();
+      const models = data.models?.map(m => m.name).join(', ') || 'none';
+      console.log('  Ollama models ' + green('✓ running') + dim(' — ' + models));
+    } catch {
+      console.log('  Ollama        ' + yellow('– not running (start with: ollama serve)'));
+    }
+  }
+
   console.log('\n  ' + cyan('vektor-slipstream') + ' ' + dim('v' + PKG.version));
   console.log('');
 }
@@ -235,7 +276,6 @@ async function cmdMcp() {
     console.error(red('  ✗ MCP server not found: ') + mcpScript);
     process.exit(1);
   }
-  // Override argv so the MCP script sees --mcp flag
   process.argv = ['node', mcpScript, '--mcp'];
   require(mcpScript);
 }
@@ -275,7 +315,6 @@ async function cmdRem() {
       licenceKey: process.env.VEKTOR_LICENCE_KEY,
     });
 
-    // ── Phase 1: Audit ──────────────────────────────────────────────────────
     console.log('  ' + dim('┌─ Phase 1/4  Auditing memory graph...'));
     const stats  = await memory.stats();
     const total  = stats.total || 0;
@@ -286,12 +325,10 @@ async function cmdRem() {
       return;
     }
 
-    // ── Phase 2: Surface recent activity ───────────────────────────────────
     console.log('  ' + dim('├─ Phase 2/4  Scanning recent activity...'));
     const recent = await memory.recent(20);
     console.log(dim('  │  Recent nodes scanned: ' + (recent ? recent.length : 0)));
 
-    // ── Phase 3: Prune noise nodes ──────────────────────────────────────────
     console.log('  ' + dim('├─ Phase 3/4  Pruning noise nodes...'));
     let pruned = 0;
     const NOISE = [
@@ -311,7 +348,6 @@ async function cmdRem() {
     }
     console.log(dim('  │  Noise nodes pruned: ' + pruned));
 
-    // ── Phase 4: Briefing as consolidation summary ──────────────────────────
     console.log('  ' + dim('├─ Phase 4/4  Generating consolidation summary...'));
     let briefSnippet = '';
     try {
@@ -319,7 +355,6 @@ async function cmdRem() {
       if (brief) briefSnippet = brief.slice(0, 120) + (brief.length > 120 ? '...' : '');
     } catch { /* non-fatal */ }
 
-    // ── Result ──────────────────────────────────────────────────────────────
     const statsAfter = await memory.stats();
     const totalAfter = statsAfter.total || 0;
     const delta      = total - totalAfter;
@@ -372,6 +407,7 @@ async function cmdBriefing() {
       console.log('\n  ' + dim('─────────────────────────────────────────────────────'));
     } else {
       console.log(dim('  No briefing available — add more memories first.'));
+      console.log(dim('  Try: npx vektor chat  or  npx vektor remember "some fact"'));
     }
   } catch (e) {
     console.error(red('  ✗ Briefing error: ') + e.message);
@@ -386,6 +422,25 @@ async function cmdSetup() {
   require('./vektor-setup');
 }
 
+// ── Chat / Remember / Ask / Agent — from vektor-cli-chat.js ──────────────────
+
+async function cmdChat()     { const { cmdChat     } = require('./vektor-cli-chat'); await cmdChat(process.argv); }
+async function cmdRemember() { const { cmdRemember } = require('./vektor-cli-chat'); await cmdRemember(process.argv); }
+async function cmdAsk()      { const { cmdAsk      } = require('./vektor-cli-chat'); await cmdAsk(process.argv); }
+async function cmdAgent()    { const { cmdAgent    } = require('./vektor-cli-chat'); await cmdAgent(process.argv); }
+
+// ── Pipe support — cat file.txt | npx vektor remember ────────────────────────
+async function handlePipe() {
+  if (process.stdin.isTTY) return false;
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  const piped = chunks.join('').trim();
+  if (!piped) return false;
+  // Inject piped content as the text argument
+  process.argv.push(piped);
+  return true;
+}
+
 // ── Router ────────────────────────────────────────────────────────────────────
 
 const commands = {
@@ -399,6 +454,11 @@ const commands = {
   rem:        cmdRem,
   briefing:   cmdBriefing,
   setup:      cmdSetup,
+  // New commands
+  chat:       cmdChat,
+  remember:   cmdRemember,
+  ask:        cmdAsk,
+  agent:      cmdAgent,
 };
 
 const fn = commands[command];
@@ -408,7 +468,15 @@ if (!fn) {
   process.exit(1);
 }
 
-fn().catch(e => {
-  console.error(red('\n  ✗ Error: ') + e.message);
-  process.exit(1);
-});
+// Handle pipe for remember command
+if (command === 'remember') {
+  handlePipe().then(() => fn()).catch(e => {
+    console.error(red('\n  ✗ Error: ') + e.message);
+    process.exit(1);
+  });
+} else {
+  fn().catch(e => {
+    console.error(red('\n  ✗ Error: ') + e.message);
+    process.exit(1);
+  });
+}