stellavault 0.1.0

package/packages/cli/src/commands/init-cmd.ts

@@ -0,0 +1,145 @@
+// stellavault init — 인터랙티브 온보딩 위저드 (F-A01)
+
+import { createInterface } from 'node:readline';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import ora from 'ora';
+import chalk from 'chalk';
+import { loadConfig, createSqliteVecStore, createLocalEmbedder, indexVault, createSearchEngine } from '@stellavault/core';
+
+function ask(rl: ReturnType<typeof createInterface>, question: string, defaultVal?: string): Promise<string> {
+  const suffix = defaultVal ? ` ${chalk.dim(`(${defaultVal})`)}` : '';
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultVal || '');
+    });
+  });
+}
+
+export async function initCommand() {
+  console.log('');
+  console.log(chalk.bold('  ✦ Stellavault Setup Wizard'));
+  console.log(chalk.dim('  Notes die in folders. Let\'s bring yours to life.\n'));
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    // Step 1: Vault Path
+    console.log(chalk.cyan('  Step 1/3') + ' — Where is your Obsidian vault?');
+    console.log(chalk.dim('  This is the folder containing your .md files.\n'));
+
+    let vaultPath = '';
+    while (!vaultPath) {
+      const input = await ask(rl, '  Vault path');
+      if (!input) {
+        console.log(chalk.yellow('  Please enter your vault path.'));
+        continue;
+      }
+      const resolved = input.replace(/^~/, homedir());
+      if (!existsSync(resolved)) {
+        console.log(chalk.yellow(`  Path not found: ${resolved}`));
+        continue;
+      }
+      vaultPath = resolved;
+    }
+
+    console.log(chalk.green(`  ✓ Vault: ${vaultPath}\n`));
+
+    // Save config
+    const configDir = join(homedir(), '.stellavault');
+    mkdirSync(configDir, { recursive: true });
+    const dbPath = join(configDir, 'index.db');
+
+    const configData = {
+      vaultPath,
+      dbPath,
+      embedding: { model: 'local', localModel: 'all-MiniLM-L6-v2' },
+      chunking: { maxTokens: 300, overlap: 50, minTokens: 50 },
+      search: { defaultLimit: 10, rrfK: 60 },
+      mcp: { mode: 'stdio', port: 3333 },
+    };
+    writeFileSync(join(homedir(), '.stellavault.json'), JSON.stringify(configData, null, 2), 'utf-8');
+    console.log(chalk.dim(`  Config saved: ~/.stellavault.json`));
+
+    // Step 2: Indexing
+    console.log('');
+    console.log(chalk.cyan('  Step 2/3') + ' — Indexing your vault');
+    console.log(chalk.dim('  Vectorizing notes with local AI (no data leaves your machine).\n'));
+
+    const spinner = ora({ text: '  Loading embedding model...', indent: 2 }).start();
+
+    const store = createSqliteVecStore(dbPath);
+    await store.initialize();
+
+    const embedder = createLocalEmbedder('all-MiniLM-L6-v2');
+    await embedder.initialize();
+    spinner.text = '  Scanning vault...';
+
+    const result = await indexVault(vaultPath, {
+      store,
+      embedder,
+      chunkOptions: { maxTokens: 300, overlap: 50, minTokens: 50 },
+      onProgress(current, total, doc) {
+        const pct = Math.round((current / total) * 100);
+        const bar = '█'.repeat(Math.floor(pct / 4)) + '░'.repeat(25 - Math.floor(pct / 4));
+        spinner.text = `  [${bar}] ${pct}% (${current}/${total}) ${doc.title.slice(0, 30)}`;
+      },
+    });
+
+    spinner.succeed(chalk.green(`  Indexed ${result.indexed} docs, ${result.totalChunks} chunks (${(result.elapsedMs / 1000).toFixed(1)}s)`));
+
+    // Step 3: First Search
+    console.log('');
+    console.log(chalk.cyan('  Step 3/3') + ' — Try your first search');
+    console.log(chalk.dim('  Type a topic you know about. Stellavault finds connections.\n'));
+
+    const searchEngine = createSearchEngine({ store, embedder, rrfK: 60 });
+
+    let searchDone = false;
+    while (!searchDone) {
+      const query = await ask(rl, '  Search');
+      if (!query) {
+        console.log(chalk.dim('  Type something, or press Ctrl+C to skip.'));
+        continue;
+      }
+
+      const searchSpinner = ora({ text: '  Searching...', indent: 2 }).start();
+      const results = await searchEngine.search({ query, limit: 5 });
+      searchSpinner.stop();
+
+      if (results.length === 0) {
+        console.log(chalk.yellow('  No results. Try a different topic.'));
+        continue;
+      }
+
+      console.log('');
+      for (const r of results) {
+        const score = Math.round(r.score * 100);
+        const bar = score >= 70 ? chalk.green('●') : score >= 40 ? chalk.yellow('●') : chalk.dim('●');
+        console.log(`  ${bar} ${chalk.bold(r.document.title)} ${chalk.dim(`(${score}%)`)}`);
+        if (r.highlights[0]) {
+          console.log(`    ${chalk.dim(r.highlights[0].slice(0, 80))}...`);
+        }
+      }
+      console.log('');
+      searchDone = true;
+    }
+
+    await store.close();
+
+    // Done!
+    console.log(chalk.bold.green('  ✦ Setup complete!\n'));
+    console.log('  What\'s next:');
+    console.log(`  ${chalk.cyan('stellavault graph')}     Launch 3D knowledge graph`);
+    console.log(`  ${chalk.cyan('stellavault decay')}     See what knowledge is fading`);
+    console.log(`  ${chalk.cyan('stellavault brief')}     Get your daily knowledge briefing`);
+    console.log(`  ${chalk.cyan('stellavault serve')}     Connect AI agents via MCP`);
+    console.log('');
+    console.log(chalk.dim('  Your knowledge is now alive. ✦'));
+    console.log('');
+
+  } finally {
+    rl.close();
+  }
+}

package/packages/cli/src/commands/learn-cmd.ts

@@ -0,0 +1,56 @@
+// stellavault learn — AI learning path recommendations (F-A11)
+
+import chalk from 'chalk';
+import { loadConfig, createKnowledgeHub, DecayEngine, detectKnowledgeGaps, generateLearningPath } from '@stellavault/core';
+
+export async function learnCommand(_opts: any, cmd: any) {
+  const globalOpts = cmd?.parent?.opts?.() ?? {};
+  const jsonMode = globalOpts.json;
+  const config = loadConfig();
+  const hub = createKnowledgeHub(config);
+
+  await hub.store.initialize();
+  await hub.embedder.initialize();
+
+  const db = hub.store.getDb() as any;
+  if (!db) { console.error(chalk.red('Cannot access database')); process.exit(1); }
+
+  const decayEngine = new DecayEngine(db);
+  const decayReport = await decayEngine.computeAll();
+
+  let gaps: any[] = [];
+  try {
+    const gapReport = await detectKnowledgeGaps(hub.store);
+    gaps = gapReport.gaps ?? [];
+  } catch { /* gaps may fail without enough data */ }
+
+  const path = generateLearningPath({ decayReport, gaps }, 15);
+  await hub.store.close();
+
+  if (jsonMode) {
+    console.log(JSON.stringify(path, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold('  🎯 Your Learning Path'));
+  console.log(chalk.dim(`  ${path.summary.reviewCount} to review · ${path.summary.bridgeCount} gaps to bridge · ~${path.summary.estimatedMinutes}min`));
+  console.log('');
+
+  for (const item of path.items) {
+    const icon = item.category === 'review' ? '📖' : item.category === 'bridge' ? '🌉' : '🔭';
+    const prioColor = item.priority === 'critical' ? chalk.red : item.priority === 'important' ? chalk.yellow : chalk.dim;
+    const prioLabel = prioColor(item.priority.toUpperCase());
+
+    console.log(`  ${icon} ${prioLabel} ${chalk.bold(item.title)} ${chalk.dim(`(${item.score}pt)`)}`);
+    console.log(`     ${chalk.dim(item.reason)}`);
+  }
+
+  if (path.items.length === 0) {
+    console.log(chalk.green('  All clear! Your knowledge is in great shape.'));
+  }
+
+  console.log('');
+  console.log(chalk.dim('  💡 stellavault review — start reviewing decaying notes'));
+  console.log('');
+}

package/packages/cli/src/commands/pack-cmd.ts

@@ -0,0 +1,121 @@
+// stellavault pack — Knowledge Pack 관리
+
+import chalk from 'chalk';
+import { resolve, join } from 'node:path';
+import { readdirSync, existsSync, readFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import {
+  loadConfig, createKnowledgeHub,
+  createPack, exportPack, importPack, packToSummary,
+} from '@stellavault/core';
+
+const PACKS_DIR = join(homedir(), '.stellavault', 'packs');
+
+export async function packCreateCommand(name: string, options: {
+  fromSearch?: string;
+  fromCluster?: string;
+  author?: string;
+  license?: string;
+  description?: string;
+  limit?: string;
+}) {
+  const config = loadConfig();
+  const hub = createKnowledgeHub(config);
+  await hub.store.initialize();
+  await hub.embedder.initialize();
+
+  console.error(chalk.dim('⏳ Creating pack...'));
+
+  const { pack, piiReport } = await createPack(hub.store, hub.searchEngine, hub.embedder, {
+    name,
+    fromSearch: options.fromSearch,
+    fromCluster: options.fromCluster ? parseInt(options.fromCluster) : undefined,
+    author: options.author ?? 'anonymous',
+    license: options.license ?? 'CC-BY-4.0',
+    description: options.description,
+    limit: options.limit ? parseInt(options.limit) : 100,
+  });
+
+  mkdirSync(PACKS_DIR, { recursive: true });
+  const outPath = join(PACKS_DIR, `${name}.sv-pack`);
+  exportPack(pack, outPath);
+
+  console.error(chalk.green(`✅ Pack created: ${name}`));
+  console.error(`   📦 ${pack.chunks.length} chunks`);
+  console.error(`   💾 ${outPath}`);
+  if (piiReport.redactedCount > 0) {
+    console.error(chalk.yellow(`   🔒 PII masked: ${piiReport.redactedCount} items (${piiReport.types.join(', ')})`));
+  }
+
+  await hub.store.close();
+}
+
+export async function packExportCommand(name: string, options: { output?: string }) {
+  const srcPath = join(PACKS_DIR, `${name}.sv-pack`);
+  if (!existsSync(srcPath)) {
+    console.error(chalk.red(`❌ Pack not found: ${name}`));
+    process.exit(1);
+  }
+
+  const outPath = resolve(process.cwd(), options.output ?? `${name}.sv-pack`);
+  const content = readFileSync(srcPath, 'utf-8');
+  const { writeFileSync } = await import('node:fs');
+  writeFileSync(outPath, content);
+
+  console.error(chalk.green(`✅ Exported: ${outPath}`));
+}
+
+export async function packImportCommand(filePath: string) {
+  const absPath = resolve(process.cwd(), filePath);
+  if (!existsSync(absPath)) {
+    console.error(chalk.red(`❌ File not found: ${absPath}`));
+    process.exit(1);
+  }
+
+  const config = loadConfig();
+  const hub = createKnowledgeHub(config);
+  await hub.store.initialize();
+  await hub.embedder.initialize();
+
+  console.error(chalk.dim('⏳ Importing pack...'));
+  const result = await importPack(hub.store, hub.embedder, absPath);
+
+  console.error(chalk.green(`✅ Imported: ${result.imported} chunks`));
+  if (result.skipped > 0) console.error(chalk.yellow(`   ⏭️ Skipped: ${result.skipped}`));
+  if (result.modelMismatch) {
+    console.error(chalk.yellow(`   ⚠️ Model mismatch — ${result.reEmbedded} chunks re-embedded`));
+  }
+
+  await hub.store.close();
+}
+
+export async function packListCommand() {
+  mkdirSync(PACKS_DIR, { recursive: true });
+  const files = readdirSync(PACKS_DIR).filter(f => f.endsWith('.sv-pack'));
+
+  if (files.length === 0) {
+    console.error(chalk.dim('No packs found. Create one: stellavault pack create <name> --from-search <query>'));
+    return;
+  }
+
+  console.error(chalk.green(`📦 ${files.length} packs in ${PACKS_DIR}\n`));
+  for (const file of files) {
+    try {
+      const pack = JSON.parse(readFileSync(join(PACKS_DIR, file), 'utf-8'));
+      console.error(`  ${chalk.bold(pack.name)} v${pack.version} — ${pack.chunks.length} chunks (${pack.license})`);
+    } catch {
+      console.error(`  ${file} (invalid)`);
+    }
+  }
+}
+
+export async function packInfoCommand(name: string) {
+  const filePath = join(PACKS_DIR, `${name}.sv-pack`);
+  if (!existsSync(filePath)) {
+    console.error(chalk.red(`❌ Pack not found: ${name}`));
+    process.exit(1);
+  }
+
+  const pack = JSON.parse(readFileSync(filePath, 'utf-8'));
+  console.error(packToSummary(pack));
+}

package/packages/cli/src/commands/review-cmd.ts

@@ -0,0 +1,125 @@
+// Design Ref: stellavault review — 일일 지식 리뷰 (FSRS 기반)
+// Plan SC: "잊어가는 지식 리마인드 → 실제 액션"
+
+import chalk from 'chalk';
+import { createInterface } from 'node:readline';
+import { loadConfig, createKnowledgeHub, DecayEngine } from '@stellavault/core';
+
+export async function reviewCommand(options: { count?: string }) {
+  const config = loadConfig();
+  const hub = createKnowledgeHub(config);
+  const count = parseInt(options.count ?? '5', 10);
+
+  console.error(chalk.dim('⏳ Initializing...'));
+  await hub.store.initialize();
+
+  const db = hub.store.getDb() as any;
+  if (!db) {
+    console.error(chalk.red('❌ Cannot access database'));
+    process.exit(1);
+  }
+
+  const decayEngine = new DecayEngine(db);
+  const decaying = await decayEngine.getDecaying(0.6, count);
+
+  if (decaying.length === 0) {
+    console.log(chalk.green('\n✨ 모든 지식이 건강합니다! 리뷰할 노트가 없습니다.'));
+    return;
+  }
+
+  console.log(chalk.green(`\n🧠 오늘의 리뷰 (${decaying.length}개)`));
+  console.log(chalk.dim('─'.repeat(50)));
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q: string): Promise<string> => new Promise(r => rl.question(q, r));
+
+  let reviewed = 0;
+
+  for (let i = 0; i < decaying.length; i++) {
+    const d = decaying[i];
+    const elapsed = Math.round(
+      (Date.now() - new Date(d.lastAccess).getTime()) / 86400000
+    );
+    const rBar = '█'.repeat(Math.round(d.retrievability * 10))
+      + '░'.repeat(10 - Math.round(d.retrievability * 10));
+    const color = d.retrievability < 0.3 ? chalk.red : chalk.yellow;
+
+    console.log(`\n${chalk.bold(`[${i + 1}/${decaying.length}]`)} ${chalk.cyan(d.title)}`);
+    console.log(`  ${color(rBar)} R=${d.retrievability.toFixed(2)} | ${elapsed}일 전`);
+
+    const answer = await ask(chalk.dim('  → [y]열기 [n]스킵 [s]내일 다시 [q]종료: '));
+
+    if (answer.toLowerCase() === 'q') {
+      console.log(chalk.dim('\n리뷰 중단.'));
+      break;
+    }
+
+    if (answer.toLowerCase() === 's') {
+      // Snooze: stability를 1일만 살짝 올려서 내일 다시 나오게
+      await decayEngine.recordAccess({
+        documentId: d.documentId,
+        type: 'view',
+        timestamp: new Date(Date.now() - 23 * 3600000).toISOString(), // 23시간 전으로 기록
+      });
+      console.log(chalk.dim('  ⏰ 내일 다시 리마인드'));
+      continue;
+    }
+
+    if (answer.toLowerCase() === 'y') {
+      // Obsidian에서 열기
+      const relFile = (d as any).filePath
+        ? (d as any).filePath.replace(/\\/g, '/').replace(/\.md$/, '')
+        : d.title;
+
+      let vault = 'Evan';
+      try {
+        const doc = db.prepare('SELECT file_path FROM documents WHERE id = ?').get(d.documentId) as any;
+        if (doc?.file_path) {
+          const fp = doc.file_path.replace(/\\/g, '/').replace(/\.md$/, '');
+          // vault 이름 = config.vaultPath의 마지막 디렉토리명
+          vault = config.vaultPath?.replace(/\\/g, '/').replace(/\/$/, '').split('/').pop() ?? 'Evan';
+
+          const uri = `obsidian://open?vault=${encodeURIComponent(vault)}&file=${encodeURIComponent(fp)}`;
+          const open = await import('open');
+          await open.default(uri);
+        }
+      } catch { /* fallback: no open */ }
+
+      // 접근 기록 → stability 업데이트
+      await decayEngine.recordAccess({
+        documentId: d.documentId,
+        type: 'view',
+        timestamp: new Date().toISOString(),
+      });
+      reviewed++;
+      console.log(chalk.green('  ✅ 열기 + 기억 강도 업데이트'));
+    } else {
+      console.log(chalk.dim('  ⏭️ 스킵'));
+    }
+  }
+
+  rl.close();
+
+  console.log(chalk.dim('\n─'.repeat(50)));
+  console.log(chalk.green(`리뷰 완료! ${reviewed}/${decaying.length}개 열람`));
+
+  // streak 계산 (access_log에서 연속 일수)
+  try {
+    const days = db.prepare(`
+      SELECT DISTINCT date(accessed_at) as d FROM access_log
+      WHERE access_type = 'view'
+      ORDER BY d DESC LIMIT 30
+    `).all() as any[];
+
+    let streak = 0;
+    const today = new Date().toISOString().slice(0, 10);
+    for (let i = 0; i < days.length; i++) {
+      const expected = new Date(Date.now() - i * 86400000).toISOString().slice(0, 10);
+      if (days[i]?.d === expected) streak++;
+      else break;
+    }
+    if (streak > 1) {
+      console.log(chalk.yellow(`🔥 ${streak}일 연속 리뷰!`));
+    }
+  } catch { /* streak 실패해도 무시 */ }
+}

package/packages/cli/src/commands/search-cmd.ts

@@ -0,0 +1,45 @@
+import chalk from 'chalk';
+import { loadConfig, createSqliteVecStore, createLocalEmbedder, createSearchEngine } from '@stellavault/core';
+
+export async function searchCommand(query: string, options: { limit?: string }, cmd: any) {
+  const globalOpts = cmd?.parent?.opts?.() ?? {};
+  const jsonMode = globalOpts.json;
+  const config = loadConfig();
+  const limit = parseInt(options.limit ?? '5', 10);
+
+  const store = createSqliteVecStore(config.dbPath);
+  await store.initialize();
+
+  const embedder = createLocalEmbedder(config.embedding.localModel);
+  await embedder.initialize();
+
+  const engine = createSearchEngine({ store, embedder, rrfK: config.search.rrfK });
+  const results = await engine.search({ query, limit });
+
+  await store.close();
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      query, count: results.length,
+      results: results.map(r => ({
+        title: r.document.title, path: r.document.filePath,
+        score: r.score, heading: r.chunk.heading,
+        snippet: r.chunk.content.slice(0, 200),
+      })),
+    }, null, 2));
+    return;
+  }
+
+  if (results.length === 0) {
+    console.log(chalk.yellow('검색 결과가 없습니다.'));
+    return;
+  }
+
+  console.log('');
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    console.log(`  ${chalk.bold(`${i + 1}.`)} ${chalk.cyan(`[${r.score.toFixed(3)}]`)} ${chalk.white(r.document.filePath)} ${chalk.dim(`§${r.chunk.heading}`)}`);
+    console.log(`     ${chalk.dim(r.chunk.content.slice(0, 120).replace(/\n/g, ' '))}...`);
+  }
+  console.log('');
+}

package/packages/cli/src/commands/serve-cmd.ts

@@ -0,0 +1,17 @@
+import chalk from 'chalk';
+import { loadConfig, createKnowledgeHub } from '@stellavault/core';
+
+export async function serveCommand() {
+  const config = loadConfig();
+  const hub = createKnowledgeHub(config);
+
+  await hub.store.initialize();
+  await hub.embedder.initialize();
+
+  const stats = await hub.store.getStats();
+  console.error(chalk.green('🚀 MCP Server running (stdio mode)'));
+  console.error(`📚 ${stats.documentCount} documents | ${stats.chunkCount} chunks`);
+  console.error(chalk.dim('💡 Claude Code: claude mcp add stellavault -- stellavault serve'));
+
+  await hub.mcpServer.startStdio();
+}

package/packages/cli/src/commands/status-cmd.ts

@@ -0,0 +1,37 @@
+import chalk from 'chalk';
+import { loadConfig, createSqliteVecStore } from '@stellavault/core';
+
+export async function statusCommand(_opts: any, cmd: any) {
+  const globalOpts = cmd?.parent?.opts?.() ?? {};
+  const jsonMode = globalOpts.json;
+  const config = loadConfig();
+
+  const store = createSqliteVecStore(config.dbPath);
+  await store.initialize();
+  const stats = await store.getStats();
+  const topics = await store.getTopics();
+  await store.close();
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ...stats, vaultPath: config.vaultPath, dbPath: config.dbPath, topics: topics.slice(0, 20) }, null, 2));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold('📊 Stellavault Status'));
+  console.log('─'.repeat(40));
+  console.log(`  📄 Documents: ${stats.documentCount}`);
+  console.log(`  🧩 Chunks:    ${stats.chunkCount}`);
+  console.log(`  🕐 Last indexed: ${stats.lastIndexed ?? 'never'}`);
+  console.log(`  💾 DB: ${config.dbPath}`);
+  console.log(`  📁 Vault: ${config.vaultPath || '(not set)'}`);
+
+  if (topics.length > 0) {
+    console.log('');
+    console.log(chalk.bold('🏷️ Top topics:'));
+    topics.slice(0, 10).forEach((t: any) => {
+      console.log(`  #${t.topic} (${t.count})`);
+    });
+  }
+  console.log('');
+}

package/packages/cli/src/commands/sync-cmd.ts

@@ -0,0 +1,68 @@
+// Design Ref: stellavault sync — Notion↔Obsidian 동기화 CLI 통합
+
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+
+export async function syncCommand(options: { upload?: boolean; watch?: boolean }) {
+  const syncDir = resolve(process.cwd(), 'packages/sync');
+  const syncScript = resolve(syncDir, 'sync-to-obsidian.mjs');
+
+  if (!existsSync(syncScript)) {
+    console.error(chalk.red('❌ packages/sync/sync-to-obsidian.mjs not found'));
+    console.error(chalk.dim('   Run from project root: cd notion-obsidian-sync'));
+    process.exit(1);
+  }
+
+  // .env 확인
+  const envFile = resolve(syncDir, '.env');
+  if (!existsSync(envFile)) {
+    console.error(chalk.red('❌ packages/sync/.env not found'));
+    console.error(chalk.dim('   Copy .env.example → .env and set NOTION_TOKEN'));
+    process.exit(1);
+  }
+
+  if (options.upload) {
+    // PDCA 문서 → Notion 업로드
+    const uploadScript = resolve(syncDir, 'upload-pdca-to-notion.mjs');
+    if (!existsSync(uploadScript)) {
+      console.error(chalk.red('❌ upload-pdca-to-notion.mjs not found'));
+      process.exit(1);
+    }
+    console.error(chalk.dim('📤 Uploading PDCA documents to Notion...'));
+    await runScript(uploadScript, syncDir);
+  } else {
+    // Notion → Obsidian 동기화
+    console.error(chalk.dim('🔄 Syncing Notion → Obsidian...'));
+    await runScript(syncScript, syncDir);
+
+    if (options.watch) {
+      console.error(chalk.green('👀 Watch mode — syncing every 5 minutes'));
+      setInterval(async () => {
+        console.error(chalk.dim(`🔄 [${new Date().toLocaleTimeString()}] Re-syncing...`));
+        await runScript(syncScript, syncDir);
+      }, 5 * 60 * 1000);
+
+      // Keep alive
+      process.stdin.resume();
+    }
+  }
+}
+
+function runScript(scriptPath: string, cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('node', [scriptPath], {
+      cwd,
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Script exited with code ${code}`));
+    });
+
+    child.on('error', reject);
+  });
+}

package/packages/cli/src/commands/vault-cmd.ts

@@ -0,0 +1,64 @@
+// sv vault add/list/remove/search-all — Cross-Vault (P3)
+
+import chalk from 'chalk';
+import { addVault, removeVault, listVaults, searchAllVaults, loadConfig, createSqliteVecStore, createLocalEmbedder } from '@stellavault/core';
+
+export async function vaultAddCommand(id: string, vaultPath: string, options: { name?: string; shared?: boolean }) {
+  const config = loadConfig();
+  const dbPath = vaultPath.replace(/\/$/, '') + '/.stellavault/index.db';
+  try {
+    const entry = addVault(id, options.name ?? id, vaultPath, dbPath, !!options.shared);
+    console.log(chalk.green(`\n  ✅ Vault "${entry.name}" added (${entry.id})`));
+    console.log(chalk.dim(`    Path: ${entry.path}\n    DB: ${entry.dbPath}\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n  ❌ ${err instanceof Error ? err.message : err}\n`));
+  }
+}
+
+export async function vaultListCommand() {
+  const vaults = listVaults();
+  if (vaults.length === 0) {
+    console.log(chalk.yellow('\n  No vaults registered. Use: sv vault add <id> <path>\n'));
+    return;
+  }
+  console.log(chalk.bold('\n  Registered Vaults'));
+  for (const v of vaults) {
+    console.log(`  ${chalk.cyan(v.id)} ${v.name} ${chalk.dim(`(${v.path})`)}`);
+  }
+  console.log('');
+}
+
+export async function vaultRemoveCommand(id: string) {
+  if (removeVault(id)) {
+    console.log(chalk.green(`\n  ✅ Vault "${id}" removed\n`));
+  } else {
+    console.log(chalk.red(`\n  ❌ Vault "${id}" not found\n`));
+  }
+}
+
+export async function vaultSearchAllCommand(query: string, options: { limit?: string }) {
+  const config = loadConfig();
+  const embedder = createLocalEmbedder(config.embedding.localModel);
+  await embedder.initialize();
+
+  console.log(chalk.dim(`\n  Searching all vaults for "${query}"...`));
+
+  const results = await searchAllVaults(
+    query, embedder,
+    (dbPath) => createSqliteVecStore(dbPath),
+    { limit: parseInt(options.limit ?? '10', 10) },
+  );
+
+  if (results.length === 0) {
+    console.log(chalk.yellow('  No results across vaults.\n'));
+    return;
+  }
+
+  for (const r of results) {
+    const pct = Math.round(r.score * 100);
+    const color = pct >= 70 ? chalk.green : pct >= 40 ? chalk.yellow : chalk.dim;
+    console.log(`  ${color(`${pct}%`)} ${chalk.bold(r.title)} ${chalk.dim(`[${r.vaultName}]`)}`);
+    console.log(`     ${chalk.dim(r.snippet)}...`);
+  }
+  console.log('');
+}