memory-crystal 0.2.0

package/src/crypto.ts

@@ -0,0 +1,113 @@
+// memory-crystal/crypto.ts — Client-side encryption for ephemeral relay.
+// AES-256-GCM encryption, HMAC-SHA256 signing, HKDF key derivation.
+// Key never leaves trusted machines. Worker sees only ciphertext.
+
+import { readFileSync, existsSync } from 'node:fs';
+import { createCipheriv, createDecipheriv, createHmac, randomBytes, hkdfSync } from 'node:crypto';
+import { join } from 'node:path';
+
+const HOME = process.env.HOME || '';
+const KEY_PATH = process.env.CRYSTAL_RELAY_KEY_PATH || join(HOME, '.openclaw', 'secrets', 'crystal-relay-key');
+
+// ── Key Management ──
+
+export function loadRelayKey(): Buffer {
+  if (!existsSync(KEY_PATH)) {
+    throw new Error(
+      `Relay key not found at ${KEY_PATH}\n` +
+      `Generate one: openssl rand -base64 32 > ${KEY_PATH} && chmod 600 ${KEY_PATH}\n` +
+      `Copy the same key to all trusted machines.`
+    );
+  }
+  const raw = readFileSync(KEY_PATH, 'utf-8').trim();
+  const key = Buffer.from(raw, 'base64');
+  if (key.length !== 32) {
+    throw new Error(`Relay key must be 32 bytes (256 bits). Got ${key.length} bytes. Regenerate with: openssl rand -base64 32`);
+  }
+  return key;
+}
+
+function deriveSigningKey(masterKey: Buffer): Buffer {
+  return Buffer.from(hkdfSync('sha256', masterKey, '', 'crystal-relay-sign', 32));
+}
+
+// ── AES-256-GCM Encryption ──
+
+export interface EncryptedPayload {
+  v: 1;                // version
+  nonce: string;       // 12 bytes, base64
+  ciphertext: string;  // base64
+  tag: string;         // 16 bytes, base64 (GCM auth tag)
+  hmac: string;        // 32 bytes, hex (HMAC-SHA256 over nonce+ciphertext+tag)
+}
+
+export function encrypt(plaintext: Buffer, masterKey: Buffer): EncryptedPayload {
+  // Random 96-bit nonce — never reuse with same key
+  const nonce = randomBytes(12);
+
+  const cipher = createCipheriv('aes-256-gcm', masterKey, nonce);
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+
+  // HMAC over ciphertext proves origin (sender had the signing key)
+  const signingKey = deriveSigningKey(masterKey);
+  const hmacData = Buffer.concat([nonce, ciphertext, tag]);
+  const hmac = createHmac('sha256', signingKey).update(hmacData).digest('hex');
+
+  return {
+    v: 1,
+    nonce: nonce.toString('base64'),
+    ciphertext: ciphertext.toString('base64'),
+    tag: tag.toString('base64'),
+    hmac,
+  };
+}
+
+export function decrypt(payload: EncryptedPayload, masterKey: Buffer): Buffer {
+  if (payload.v !== 1) {
+    throw new Error(`Unknown payload version: ${payload.v}`);
+  }
+
+  const nonce = Buffer.from(payload.nonce, 'base64');
+  const ciphertext = Buffer.from(payload.ciphertext, 'base64');
+  const tag = Buffer.from(payload.tag, 'base64');
+
+  // Verify HMAC first — confirms origin before decrypting
+  const signingKey = deriveSigningKey(masterKey);
+  const hmacData = Buffer.concat([nonce, ciphertext, tag]);
+  const expectedHmac = createHmac('sha256', signingKey).update(hmacData).digest('hex');
+
+  if (payload.hmac !== expectedHmac) {
+    throw new Error('HMAC verification failed — blob rejected (tampered or wrong key)');
+  }
+
+  // Decrypt
+  const decipher = createDecipheriv('aes-256-gcm', masterKey, nonce);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+
+// ── Convenience wrappers ──
+
+export function encryptJSON(data: unknown, masterKey: Buffer): EncryptedPayload {
+  const plaintext = Buffer.from(JSON.stringify(data), 'utf-8');
+  return encrypt(plaintext, masterKey);
+}
+
+export function decryptJSON<T = unknown>(payload: EncryptedPayload, masterKey: Buffer): T {
+  const plaintext = decrypt(payload, masterKey);
+  return JSON.parse(plaintext.toString('utf-8')) as T;
+}
+
+export function encryptFile(filePath: string, masterKey: Buffer): EncryptedPayload {
+  const plaintext = readFileSync(filePath);
+  return encrypt(plaintext, masterKey);
+}
+
+// ── Integrity hash for mirror snapshots ──
+
+import { createHash } from 'node:crypto';
+
+export function hashBuffer(data: Buffer): string {
+  return createHash('sha256').update(data).digest('hex');
+}

package/src/dev-update.ts

@@ -0,0 +1,178 @@
+// memory-crystal/dev-update.ts — Auto-generate dev updates for changed repos.
+// Called before compaction (Lēsa) or at session end when context is high (CC).
+// Scans all repos for recent git activity, writes dated updates to wip-dev-updates.
+
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+const HOME = process.env.HOME || '';
+const STAFF_DIR = join(HOME, 'Documents', 'wipcomputer--mac-mini-01', 'staff');
+const CC_REPOS = join(STAFF_DIR, 'Parker', 'Claude Code - Mini', 'repos');
+const LESA_REPOS = join(STAFF_DIR, 'Lēsa', 'repos');
+const DEV_UPDATES_DIR = join(CC_REPOS, 'wip-dev-updates'); // Legacy, kept for fallback
+const LAST_RUN_PATH = join(HOME, '.openclaw', 'memory', 'dev-update-last-run.json');
+
+interface LastRun {
+  timestamp: string;
+  author: string;
+  reposUpdated: number;
+}
+
+function loadLastRun(): LastRun | null {
+  try {
+    if (existsSync(LAST_RUN_PATH)) {
+      return JSON.parse(readFileSync(LAST_RUN_PATH, 'utf-8'));
+    }
+  } catch {}
+  return null;
+}
+
+function saveLastRun(run: LastRun): void {
+  const dir = join(HOME, '.openclaw', 'memory');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(LAST_RUN_PATH, JSON.stringify(run, null, 2));
+}
+
+function git(repoPath: string, cmd: string): string {
+  try {
+    return execSync(`git -C "${repoPath}" ${cmd}`, {
+      encoding: 'utf-8',
+      timeout: 10000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function scanRepo(repoPath: string, since: string): string | null {
+  if (!existsSync(join(repoPath, '.git'))) return null;
+
+  const name = basename(repoPath);
+  if (name === '_third-party-repos' || name === 'wip-dev-updates') return null;
+
+  const recentCommits = git(repoPath, `log --oneline --since="${since}"`);
+  const uncommitted = git(repoPath, 'status --porcelain');
+
+  if (!recentCommits && !uncommitted) return null;
+
+  const lines: string[] = [];
+  lines.push(`# ${name}`);
+  lines.push('');
+
+  if (recentCommits) {
+    lines.push('## Recent Commits');
+    lines.push('');
+    lines.push('```');
+    lines.push(...recentCommits.split('\n').slice(0, 10));
+    lines.push('```');
+    lines.push('');
+  }
+
+  if (uncommitted) {
+    lines.push('## Uncommitted Changes');
+    lines.push('');
+    lines.push('```');
+    lines.push(...uncommitted.split('\n').slice(0, 20));
+    lines.push('```');
+    lines.push('');
+  }
+
+  if (recentCommits) {
+    const diffStat = git(repoPath, `diff --stat "HEAD@{${since}}" HEAD`);
+    if (diffStat) {
+      lines.push('## Files Changed');
+      lines.push('');
+      lines.push('```');
+      lines.push(...diffStat.split('\n').slice(-15));
+      lines.push('```');
+      lines.push('');
+    }
+  }
+
+  const branch = git(repoPath, 'branch --show-current') || 'unknown';
+  lines.push(`**Branch:** ${branch}`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+export function runDevUpdate(author: 'cc' | 'lesa'): { reposUpdated: number; files: string[] } {
+  // Throttle: don't run more than once per hour
+  const lastRun = loadLastRun();
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.timestamp).getTime();
+    if (elapsed < 60 * 60 * 1000) {
+      return { reposUpdated: 0, files: [] };
+    }
+  }
+
+  // Determine "since" window: since last run, or 6 hours
+  let since = '6 hours ago';
+  if (lastRun?.timestamp) {
+    const lastDate = new Date(lastRun.timestamp);
+    const hoursAgo = Math.ceil((Date.now() - lastDate.getTime()) / (1000 * 60 * 60));
+    since = `${Math.max(hoursAgo, 1)} hours ago`;
+  }
+
+  const now = new Date();
+  const ts = [
+    String(now.getMonth() + 1).padStart(2, '0'),
+    String(now.getDate()).padStart(2, '0'),
+    String(now.getFullYear()),
+  ].join('-') + '--' + [
+    String(now.getHours()).padStart(2, '0'),
+    String(now.getMinutes()).padStart(2, '0'),
+    String(now.getSeconds()).padStart(2, '0'),
+  ].join('-');
+
+  const files: string[] = [];
+
+  // Scan all repo directories
+  const repoDirs = [CC_REPOS, LESA_REPOS];
+  for (const parentDir of repoDirs) {
+    if (!existsSync(parentDir)) continue;
+    let entries: string[];
+    try {
+      entries = execSync(`ls "${parentDir}"`, { encoding: 'utf-8' }).trim().split('\n');
+    } catch { continue; }
+
+    for (const entry of entries) {
+      const repoPath = join(parentDir, entry);
+      const content = scanRepo(repoPath, since);
+      if (!content) continue;
+
+      const repoName = basename(repoPath);
+      // Write to repo's own ai/ folder (decentralized)
+      const outDir = join(repoPath, 'ai');
+      const outFile = join(outDir, `${now.toISOString().slice(0, 10)}--${now.toISOString().slice(11, 19).replace(/:/g, '-')}--${author}--dev-update-${repoName}.md`);
+
+      mkdirSync(outDir, { recursive: true });
+
+      const header = `*Auto-generated dev update by ${author} at ${now.toISOString().slice(0, 16).replace('T', ' ')}*\n\n`;
+      writeFileSync(outFile, content.replace(/^# .+\n/, `$&\n${header}`));
+      files.push(`${repoName}/ai/${basename(outFile)}`);
+    }
+  }
+
+  // Dev updates now in each repo's ai/ folder. Skip centralized commit.
+  if (false && files.length > 0 && existsSync(join(DEV_UPDATES_DIR, '.git'))) {
+    try {
+      execSync(
+        `cd "${DEV_UPDATES_DIR}" && git add -A && git commit -m "${author} auto-dev-update ${ts}: ${files.length} repo(s)" --no-verify && git push --quiet`,
+        { encoding: 'utf-8', timeout: 30000, stdio: 'pipe' }
+      );
+    } catch {
+      // best-effort
+    }
+  }
+
+  saveLastRun({
+    timestamp: now.toISOString(),
+    author,
+    reposUpdated: files.length,
+  });
+
+  return { reposUpdated: files.length, files };
+}

package/src/ldm.ts

@@ -0,0 +1,117 @@
+// memory-crystal/ldm.ts — LDM directory scaffolding and path resolution.
+// Central module for all LDM directory knowledge. Every other file imports paths from here.
+// LDM = Learning Dreaming Machines. ~/.ldm/ is the universal agent home.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const HOME = process.env.HOME || '';
+const LDM_ROOT = join(HOME, '.ldm');
+
+// ── Agent ID resolution ──
+
+export function getAgentId(): string {
+  return process.env.CRYSTAL_AGENT_ID || 'cc-mini';
+}
+
+// ── Path resolution ──
+
+export interface LdmPaths {
+  root: string;           // ~/.ldm
+  config: string;         // ~/.ldm/config.json
+  crystalDb: string;      // ~/.ldm/memory/crystal.db
+  crystalLance: string;   // ~/.ldm/memory/lance/
+  agentRoot: string;      // ~/.ldm/agents/{agent_id}
+  transcripts: string;    // ~/.ldm/agents/{agent_id}/memory/transcripts/
+  sessions: string;       // ~/.ldm/agents/{agent_id}/memory/sessions/
+  daily: string;          // ~/.ldm/agents/{agent_id}/memory/daily/
+  journals: string;       // ~/.ldm/agents/{agent_id}/memory/journals/
+}
+
+export function ldmPaths(agentId?: string): LdmPaths {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, 'agents', id);
+
+  return {
+    root: LDM_ROOT,
+    config: join(LDM_ROOT, 'config.json'),
+    crystalDb: join(LDM_ROOT, 'memory', 'crystal.db'),
+    crystalLance: join(LDM_ROOT, 'memory', 'lance'),
+    agentRoot,
+    transcripts: join(agentRoot, 'memory', 'transcripts'),
+    sessions: join(agentRoot, 'memory', 'sessions'),
+    daily: join(agentRoot, 'memory', 'daily'),
+    journals: join(agentRoot, 'memory', 'journals'),
+  };
+}
+
+// ── Config file ──
+
+interface LdmConfig {
+  version: string;
+  agents: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+function loadConfig(): LdmConfig | null {
+  const configPath = join(LDM_ROOT, 'config.json');
+  try {
+    if (existsSync(configPath)) {
+      return JSON.parse(readFileSync(configPath, 'utf-8'));
+    }
+  } catch {}
+  return null;
+}
+
+function saveConfig(config: LdmConfig): void {
+  const configPath = join(LDM_ROOT, 'config.json');
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+
+// ── Scaffolding ──
+
+export function scaffoldLdm(agentId?: string): LdmPaths {
+  const paths = ldmPaths(agentId);
+
+  // Create shared memory directories
+  mkdirSync(join(paths.root, 'memory'), { recursive: true });
+  mkdirSync(paths.crystalLance, { recursive: true });
+
+  // Create agent-specific directories
+  mkdirSync(paths.transcripts, { recursive: true });
+  mkdirSync(paths.sessions, { recursive: true });
+  mkdirSync(paths.daily, { recursive: true });
+  mkdirSync(paths.journals, { recursive: true });
+
+  // Update config.json
+  const id = agentId || getAgentId();
+  let config = loadConfig();
+  if (!config) {
+    config = {
+      version: '1.0.0',
+      agents: [id],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+  } else {
+    if (!config.agents.includes(id)) {
+      config.agents.push(id);
+    }
+    config.updatedAt = new Date().toISOString();
+  }
+  saveConfig(config);
+
+  return paths;
+}
+
+export function ensureLdm(agentId?: string): LdmPaths {
+  const paths = ldmPaths(agentId);
+
+  // Quick check: if agent transcripts dir exists, everything is scaffolded
+  if (existsSync(paths.transcripts) && existsSync(paths.config)) {
+    return paths;
+  }
+
+  return scaffoldLdm(agentId);
+}

package/src/mcp-server.ts

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+// memory-crystal/mcp-server.ts — MCP tools for Claude Code.
+// Wraps core.ts. Registered via .mcp.json.
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Crystal, RemoteCrystal, resolveConfig, createCrystal } from './core.js';
+import { existsSync, readFileSync, appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+const CONFIG_DIR = join(process.env.HOME || '', '.openclaw');
+const PRIVATE_MODE_PATH = join(CONFIG_DIR, 'memory', 'memory-capture-state.json');
+
+function isPrivateMode(): boolean {
+  try {
+    if (existsSync(PRIVATE_MODE_PATH)) {
+      const state = JSON.parse(readFileSync(PRIVATE_MODE_PATH, 'utf-8'));
+      return state.enabled === false;
+    }
+  } catch {}
+  return false;
+}
+
+const METRICS_PATH = join(CONFIG_DIR, 'memory', 'search-metrics.jsonl');
+
+function logSearchMetric(tool: string, query: string, resultCount: number) {
+  try {
+    mkdirSync(join(CONFIG_DIR, 'memory'), { recursive: true });
+    const entry = JSON.stringify({
+      ts: new Date().toISOString(),
+      tool,
+      query,
+      results: resultCount,
+    });
+    appendFileSync(METRICS_PATH, entry + '\n');
+  } catch {}
+}
+
+const config = resolveConfig();
+const crystal = createCrystal(config);
+const isRemote = crystal instanceof RemoteCrystal;
+if (isRemote) {
+  process.stderr.write('[memory-crystal] Remote mode: ' + config.remoteUrl + '\n');
+}
+
+const server = new Server(
+  { name: 'memory-crystal', version: '0.1.0' },
+  { capabilities: { tools: {} } }
+);
+
+// ── Tool Definitions ──
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'crystal_search',
+      description: 'Search memory crystal — semantic search across all agent conversations, files, and stored memories. Returns ranked results with similarity scores.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          query: { type: 'string', description: 'What to search for' },
+          limit: { type: 'number', description: 'Max results (default: 5)' },
+          agent_id: { type: 'string', description: 'Filter by agent (e.g. "main", "claude-code")' },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'crystal_remember',
+      description: 'Store a fact, preference, or observation in memory crystal. Persists across sessions and compaction.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          text: { type: 'string', description: 'The fact or observation to remember' },
+          category: {
+            type: 'string',
+            enum: ['fact', 'preference', 'event', 'opinion', 'skill'],
+            description: 'Category of memory (default: fact)',
+          },
+        },
+        required: ['text'],
+      },
+    },
+    {
+      name: 'crystal_forget',
+      description: 'Deprecate a memory by ID. Does not delete — marks as deprecated.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          id: { type: 'number', description: 'Memory ID to deprecate' },
+        },
+        required: ['id'],
+      },
+    },
+    {
+      name: 'crystal_status',
+      description: 'Show memory crystal status — chunk count, memory count, agents, embedding provider.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {},
+      },
+    },
+    {
+      name: 'crystal_sources_add',
+      description: 'Add a directory for source file indexing. Files are chunked, embedded, and searchable via crystal_search. Optional feature... does not affect existing memory capture.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          path: { type: 'string', description: 'Absolute path to the directory to index' },
+          name: { type: 'string', description: 'Short name for this collection (e.g. "wipcomputer")' },
+        },
+        required: ['path', 'name'],
+      },
+    },
+    {
+      name: 'crystal_sources_sync',
+      description: 'Sync a source collection: scan for new/changed/deleted files and re-index. Run after adding a collection or when files change.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          name: { type: 'string', description: 'Collection name to sync' },
+          dry_run: { type: 'boolean', description: 'If true, report what would change without actually indexing' },
+        },
+        required: ['name'],
+      },
+    },
+    {
+      name: 'crystal_sources_status',
+      description: 'Show status of all source file collections: file counts, chunk counts, last sync time.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {},
+      },
+    },
+  ],
+}));
+
+// ── Tool Handlers ──
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    await crystal.init();
+
+    switch (name) {
+      case 'crystal_search': {
+        const query = args?.query as string;
+        const limit = (args?.limit as number) || 5;
+        const filter: any = {};
+        if (args?.agent_id) filter.agent_id = args.agent_id;
+
+        const results = await crystal.search(query, limit, filter);
+        logSearchMetric('crystal_search', query, results.length);
+
+        if (results.length === 0) {
+          return { content: [{ type: 'text', text: 'No results found.' }] };
+        }
+
+        const freshnessIcon: Record<string, string> = { fresh: "🟢", recent: "🟡", aging: "🟠", stale: "🔴" };
+        const formatted = results.map((r, i) => {
+          const score = (r.score * 100).toFixed(1);
+          const date = r.created_at?.slice(0, 10) || 'unknown';
+          const fresh = r.freshness ? `${freshnessIcon[r.freshness]} ${r.freshness}, ` : '';
+          return `[${i + 1}] (${fresh}${score}% match, ${r.agent_id}, ${date}, ${r.role})\n${r.text}`;
+        }).join('\n\n---\n\n');
+
+        const header = '(Recency-weighted. 🟢 fresh <3d, 🟡 recent <7d, 🟠 aging <14d, 🔴 stale 14d+)\n\n';
+        return { content: [{ type: 'text', text: header + formatted }] };
+      }
+
+      case 'crystal_remember': {
+        if (isPrivateMode()) {
+          return { content: [{ type: 'text', text: 'Private mode is on. No memories are being stored. Toggle off to resume.' }] };
+        }
+        const text = args?.text as string;
+        const category = (args?.category || 'fact') as any;
+        const id = await crystal.remember(text, category);
+        return { content: [{ type: 'text', text: `Remembered (id: ${id}, category: ${category}): ${text}` }] };
+      }
+
+      case 'crystal_forget': {
+        const id = args?.id as number;
+        const ok = crystal.forget(id);
+        return {
+          content: [{ type: 'text', text: ok ? `Forgot memory ${id}` : `Memory ${id} not found or already deprecated` }],
+        };
+      }
+
+      case 'crystal_status': {
+        const status = await crystal.status();
+        const text = [
+          `Memory Crystal Status${isRemote ? ' (REMOTE)' : ''}`,
+          `  Data dir:   ${status.dataDir}`,
+          `  Provider:   ${status.embeddingProvider}`,
+          `  Chunks:     ${status.chunks.toLocaleString()}`,
+          `  Memories:   ${status.memories}`,
+          `  Sources:    ${status.sources}`,
+          `  Agents:     ${status.agents.length > 0 ? status.agents.join(', ') : 'none yet'}`,
+          `  Sessions:   ${status.capturedSessions} captured`,
+          `  Latest:     ${status.latestCapture || 'never'}`,
+        ].join('\n');
+        return { content: [{ type: 'text', text }] };
+      }
+
+      case 'crystal_sources_add': {
+        if (isRemote) {
+          return { content: [{ type: 'text', text: 'Source indexing not available in remote mode. Index files on the Mac Mini.' }] };
+        }
+        const path = args?.path as string;
+        const collectionName = args?.name as string;
+        const col = await (crystal as Crystal).sourcesAdd(path, collectionName);
+        return {
+          content: [{ type: 'text', text: `Added collection "${col.name}" at ${col.root_path}\nRun crystal_sources_sync with name "${collectionName}" to index files.` }],
+        };
+      }
+
+      case 'crystal_sources_sync': {
+        if (isRemote) {
+          return { content: [{ type: 'text', text: 'Source indexing not available in remote mode. Sync files on the Mac Mini.' }] };
+        }
+        const collectionName = args?.name as string;
+        const dryRun = args?.dry_run as boolean;
+        const result = await (crystal as Crystal).sourcesSync(collectionName, { dryRun });
+        const lines = [
+          dryRun ? `Dry run for "${result.collection}":` : `Synced "${result.collection}":`,
+          `  Added:   ${result.added} files`,
+          `  Updated: ${result.updated} files`,
+          `  Removed: ${result.removed} files`,
+          `  Chunks:  ${result.chunks_added} embedded`,
+          `  Time:    ${(result.duration_ms / 1000).toFixed(1)}s`,
+        ];
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+      }
+
+      case 'crystal_sources_status': {
+        if (isRemote) {
+          return { content: [{ type: 'text', text: 'Source indexing not available in remote mode.' }] };
+        }
+        const sourcesStatus = (crystal as Crystal).sourcesStatus();
+        if (sourcesStatus.collections.length === 0) {
+          return { content: [{ type: 'text', text: 'No source collections. Use crystal_sources_add to add a directory.' }] };
+        }
+        const lines = ['Source Collections:'];
+        for (const col of sourcesStatus.collections) {
+          const syncAgo = col.last_sync_at
+            ? `${Math.round((Date.now() - new Date(col.last_sync_at).getTime()) / 60000)}m ago`
+            : 'never';
+          lines.push(`  ${col.name}: ${col.file_count.toLocaleString()} files, ${col.chunk_count.toLocaleString()} chunks, last sync ${syncAgo}`);
+        }
+        lines.push(`  Total: ${sourcesStatus.total_files.toLocaleString()} files, ${sourcesStatus.total_chunks.toLocaleString()} chunks`);
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+      }
+
+      default:
+        return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+    }
+  } catch (err: any) {
+    return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+  }
+});
+
+// ── Start ──
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(err => {
+  console.error(`MCP server failed: ${err.message}`);
+  process.exit(1);
+});