context-vault 2.17.1 → 3.0.2

package/bin/cli.js

@@ -34,7 +34,7 @@ const HOME = homedir();
 
 const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8"));
 const VERSION = pkg.version;
-const SERVER_PATH = resolve(ROOT, "src", "server", "index.js");
+const SERVER_PATH = resolve(ROOT, "src", "server.js");
 
 /** Detect if running as an npm-installed package (global or local) vs local dev clone */
 function isInstalledPackage() {
@@ -306,12 +306,14 @@ ${bold("Commands:")}
   ${cyan("restart")}                    Stop running MCP server processes (client auto-restarts)
   ${cyan("search")}                     Search vault entries from CLI
   ${cyan("save")}                       Save an entry to the vault from CLI
-  ${cyan("import")} <path>              Import entries from file or directory
-  ${cyan("export")}                     Export vault to JSON or CSV
+  ${cyan("import")} <path>              Import entries from file, directory, or .zip archive
+  ${cyan("export")}                     Export vault entries (JSON, CSV, or portable ZIP)
   ${cyan("ingest")} <url>               Fetch URL and save as vault entry
   ${cyan("ingest-project")} <path>      Scan project directory and register as project entity
   ${cyan("reindex")}                    Rebuild search index from knowledge files
   ${cyan("migrate-dirs")} [--dry-run]   Rename plural vault dirs to singular (post-2.18.0)
+  ${cyan("archive")}                    Archive old ephemeral/event entries (use --dry-run to preview)
+  ${cyan("restore")} <id>               Restore an archived entry back into the vault
   ${cyan("prune")}                      Remove expired entries (use --dry-run to preview)
   ${cyan("update")}                     Check for and install updates
   ${cyan("uninstall")}                  Remove MCP configs and optionally data
@@ -372,6 +374,26 @@ async function runSetup() {
     } catch {}
 
     if (latestVersion === VERSION) {
+      // Even when "up to date", ensure the launcher points to a valid server
+      const dataDir = join(HOME, ".context-mcp");
+      const launcherPath = join(dataDir, "server.mjs");
+      let launcherOk = false;
+      if (existsSync(launcherPath)) {
+        const content = readFileSync(launcherPath, "utf-8");
+        const m = content.match(/import "(.+?)"/);
+        if (m && existsSync(m[1])) launcherOk = true;
+      }
+      if (!launcherOk && !isNpx()) {
+        mkdirSync(dataDir, { recursive: true });
+        writeFileSync(launcherPath, `import "${SERVER_PATH}";\n`);
+        console.log(
+          green(`  ✓ context-vault v${VERSION} is up to date`) +
+            dim(`  (vault: ${existingVault})`),
+        );
+        console.log(dim(`  ↳ Repaired server launcher → ${SERVER_PATH}`));
+        console.log();
+        return;
+      }
       console.log(
         green(`  ✓ context-vault v${VERSION} is up to date`) +
           dim(`  (vault: ${existingVault})`),
@@ -799,7 +821,7 @@ async function runSetup() {
       }, 100);
 
       try {
-        const { embed } = await import("@context-vault/core/index/embed");
+        const { embed } = await import("@context-vault/core/embed");
         let timeoutHandle;
         const timeout = new Promise((_, reject) => {
           timeoutHandle = setTimeout(
@@ -1034,7 +1056,7 @@ async function runSetup() {
   // Verify DB is accessible
   let dbAccessible = false;
   try {
-    const { initDatabase } = await import("@context-vault/core/index/db");
+    const { initDatabase } = await import("@context-vault/core/db");
     const db = await initDatabase(vaultConfig.dbPath);
     db.prepare("SELECT 1").get();
     db.close();
@@ -1577,7 +1599,7 @@ async function runSwitch() {
   if (target === "local") {
     const launcherPath = join(dataDir, "server.mjs");
     if (!existsSync(launcherPath)) {
-      const serverAbs = resolve(ROOT, "src", "server", "index.js");
+      const serverAbs = resolve(ROOT, "src", "server.js");
       mkdirSync(dataDir, { recursive: true });
       writeFileSync(launcherPath, `import "${serverAbs}";\n`);
     }
@@ -1673,10 +1695,10 @@ async function runSwitch() {
 async function runReindex() {
   console.log(dim("Loading vault..."));
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, prepareStatements, insertVec, deleteVec } =
-    await import("@context-vault/core/index/db");
-  const { embed } = await import("@context-vault/core/index/embed");
+    await import("@context-vault/core/db");
+  const { embed } = await import("@context-vault/core/embed");
   const { reindex } = await import("@context-vault/core/index");
 
   const config = resolveConfig();
@@ -1715,7 +1737,7 @@ async function runMigrateDirs() {
   let vaultDir = positional;
 
   if (!vaultDir) {
-    const { resolveConfig } = await import("@context-vault/core/core/config");
+    const { resolveConfig } = await import("@context-vault/core/config");
     const config = resolveConfig();
     if (!config.vaultDirExists) {
       console.error(red(`Vault directory not found: ${config.vaultDir}`));
@@ -1731,7 +1753,7 @@ async function runMigrateDirs() {
   }
 
   const { planMigration, executeMigration } =
-    await import("@context-vault/core/core/migrate-dirs");
+    await import("@context-vault/core/migrate-dirs");
 
   const ops = planMigration(vaultDir);
 
@@ -1784,9 +1806,9 @@ async function runMigrateDirs() {
 async function runPrune() {
   const dryRun = flags.has("--dry-run");
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, prepareStatements, insertVec, deleteVec } =
-    await import("@context-vault/core/index/db");
+    await import("@context-vault/core/db");
   const { pruneExpired } = await import("@context-vault/core/index");
 
   const config = resolveConfig();
@@ -1844,12 +1866,169 @@ async function runPrune() {
   }
 }
 
+async function runArchive() {
+  const dryRun = flags.has("--dry-run");
+
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase, prepareStatements, insertVec, deleteVec } =
+    await import("@context-vault/core/db");
+  const { findArchiveCandidates, archiveEntries } =
+    await import("@context-vault/core/archive");
+
+  const config = resolveConfig();
+  if (!config.vaultDirExists) {
+    console.error(red(`Vault directory not found: ${config.vaultDir}`));
+    console.error("Run " + cyan("context-vault setup") + " to configure.");
+    process.exit(1);
+  }
+
+  const db = await initDatabase(config.dbPath);
+
+  if (dryRun) {
+    const ctx = {
+      db,
+      config,
+      stmts: prepareStatements(db),
+      embed: async () => null,
+      insertVec: () => {},
+      deleteVec: () => {},
+    };
+    const candidates = findArchiveCandidates(ctx);
+    db.close();
+
+    if (candidates.length === 0) {
+      console.log(green("  No entries eligible for archiving."));
+      const lifecycle = config.lifecycle || {};
+      console.log(dim("\n  Retention windows:"));
+      for (const [tier, rules] of Object.entries(lifecycle)) {
+        if (rules?.archiveAfterDays) {
+          console.log(dim(`    ${tier}: archive after ${rules.archiveAfterDays} days`));
+        }
+      }
+      return;
+    }
+
+    console.log(
+      `\n  ${bold(String(candidates.length))} ${candidates.length === 1 ? "entry" : "entries"} eligible for archiving:\n`,
+    );
+    for (const e of candidates) {
+      const label = e.title ? `${e.kind}: ${e.title}` : `${e.kind} (${e.id})`;
+      const age = e.updated_at || e.created_at;
+      console.log(
+        `  ${dim("-")} ${label} ${dim(`(tier=${e.tier}, last updated ${age})`)}`,
+      );
+    }
+    console.log(dim("\n  Dry run — no entries were archived."));
+    console.log(dim("  Remove --dry-run to archive."));
+    return;
+  }
+
+  const stmts = prepareStatements(db);
+  const ctx = {
+    db,
+    config,
+    stmts,
+    embed: async () => null,
+    insertVec: (r, e) => insertVec(stmts, r, e),
+    deleteVec: (r) => deleteVec(stmts, r),
+  };
+
+  const result = await archiveEntries(ctx);
+  db.close();
+
+  if (result.count === 0) {
+    console.log(green("  No entries eligible for archiving."));
+  } else {
+    console.log(
+      green(
+        `  ✓ Archived ${result.count} ${result.count === 1 ? "entry" : "entries"} to _archive/`,
+      ),
+    );
+    console.log(
+      dim(`  Files moved to: ${join(config.vaultDir, "_archive")}`),
+    );
+    console.log(
+      dim("  Restore with: context-vault restore <id>"),
+    );
+  }
+}
+
+async function runRestore() {
+  const entryId = args[1];
+
+  if (!entryId || entryId.startsWith("--")) {
+    const { resolveConfig } = await import("@context-vault/core/config");
+    const { listArchivedEntries } =
+      await import("@context-vault/core/archive");
+
+    const config = resolveConfig();
+
+    console.log(`\n  ${bold("context-vault restore")} <id>\n`);
+    console.log(`  Restore an archived entry back into the active vault.\n`);
+
+    if (config.vaultDirExists) {
+      const entries = listArchivedEntries(config.vaultDir);
+      if (entries.length > 0) {
+        console.log(`  ${bold("Archived entries")} (${entries.length}):\n`);
+        for (const e of entries.slice(0, 20)) {
+          const label = e.title
+            ? `${e.kind}: ${e.title.slice(0, 60)}`
+            : `${e.kind} (${e.id})`;
+          console.log(`    ${dim(e.id || "?")}  ${label}`);
+        }
+        if (entries.length > 20) {
+          console.log(dim(`\n    ... and ${entries.length - 20} more`));
+        }
+      } else {
+        console.log(dim("  No archived entries found."));
+      }
+    }
+    console.log();
+    return;
+  }
+
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase, prepareStatements, insertVec, deleteVec } =
+    await import("@context-vault/core/db");
+  const { embed } = await import("@context-vault/core/embed");
+  const { restoreEntry } = await import("@context-vault/core/archive");
+
+  const config = resolveConfig();
+  if (!config.vaultDirExists) {
+    console.error(red(`Vault directory not found: ${config.vaultDir}`));
+    console.error("Run " + cyan("context-vault setup") + " to configure.");
+    process.exit(1);
+  }
+
+  const db = await initDatabase(config.dbPath);
+  const stmts = prepareStatements(db);
+  const ctx = {
+    db,
+    config,
+    stmts,
+    embed,
+    insertVec: (r, e) => insertVec(stmts, r, e),
+    deleteVec: (r) => deleteVec(stmts, r),
+  };
+
+  const result = await restoreEntry(ctx, entryId);
+  db.close();
+
+  if (result.restored) {
+    console.log(green(`  ✓ Restored ${result.kind} entry: ${result.id}`));
+    console.log(dim(`  File: ${result.filePath}`));
+  } else {
+    console.error(red(`  ✗ ${result.reason}`));
+    process.exit(1);
+  }
+}
+
 async function runStatus() {
-  const { resolveConfig } = await import("@context-vault/core/core/config");
-  const { initDatabase } = await import("@context-vault/core/index/db");
-  const { gatherVaultStatus } = await import("@context-vault/core/core/status");
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase } = await import("@context-vault/core/db");
+  const { gatherVaultStatus } = await import("../src/status.js");
   const { errorLogPath, errorLogCount } =
-    await import("@context-vault/core/core/error-log");
+    await import("../src/error-log.js");
 
   const config = resolveConfig();
 
@@ -1938,6 +2117,15 @@ async function runStatus() {
     }
   }
 
+  if (status.archivedCount > 0) {
+    console.log();
+    console.log(
+      dim(
+        `  ${status.archivedCount} archived ${status.archivedCount === 1 ? "entry" : "entries"} in _archive/ (excluded from search)`,
+      ),
+    );
+  }
+
   if (status.stalePaths) {
     console.log();
     console.log(yellow("  Stale paths detected in DB."));
@@ -2129,7 +2317,7 @@ async function runMigrate() {
     return;
   }
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const config = resolveConfig();
 
   if (direction === "to-hosted") {
@@ -2183,20 +2371,33 @@ async function runImport() {
   const target = args[1];
   if (!target) {
     console.log(`\n  ${bold("context-vault import")} <path>\n`);
-    console.log(`  Import entries from a file or directory.\n`);
-    console.log(`  Supported formats: .md, .csv, .tsv, .json, .txt\n`);
+    console.log(`  Import entries from a file, directory, or portable archive.\n`);
+    console.log(`  Supported formats: .md, .csv, .tsv, .json, .txt, .zip\n`);
     console.log(`  Options:`);
     console.log(`    --kind <kind>    Default kind (default: insight)`);
     console.log(`    --source <src>   Default source (default: cli-import)`);
     console.log(`    --dry-run        Show parsed entries without importing`);
+    console.log(`    --vault <path>   Target vault directory (default: configured vault)`);
     console.log();
     return;
   }
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const dryRun = flags.has("--dry-run");
+  const targetPath = resolve(target);
+
+  if (!existsSync(targetPath)) {
+    console.error(red(`  Path not found: ${targetPath}`));
+    process.exit(1);
+  }
+
+  if (targetPath.endsWith(".zip")) {
+    return runImportZip(targetPath, dryRun);
+  }
+
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, prepareStatements, insertVec, deleteVec } =
-    await import("@context-vault/core/index/db");
-  const { embed } = await import("@context-vault/core/index/embed");
+    await import("@context-vault/core/db");
+  const { embed } = await import("@context-vault/core/embed");
   const { parseFile, parseDirectory } =
     await import("@context-vault/core/capture/importers");
   const { importEntries } =
@@ -2205,13 +2406,6 @@ async function runImport() {
 
   const kind = getFlag("--kind") || undefined;
   const source = getFlag("--source") || "cli-import";
-  const dryRun = flags.has("--dry-run");
-
-  const targetPath = resolve(target);
-  if (!existsSync(targetPath)) {
-    console.error(red(`  Path not found: ${targetPath}`));
-    process.exit(1);
-  }
 
   const stat = statSync(targetPath);
   let entries;
@@ -2282,17 +2476,215 @@ async function runImport() {
   console.log();
 }
 
+async function runImportZip(zipPath, dryRun) {
+  const AdmZip = (await import("adm-zip")).default;
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase, prepareStatements, insertVec, deleteVec } =
+    await import("@context-vault/core/db");
+  const { embed } = await import("@context-vault/core/embed");
+  const { indexEntry } = await import("@context-vault/core/index");
+  const { parseFrontmatter } = await import("@context-vault/core/frontmatter");
+  const { categoryDirFor } = await import("@context-vault/core/categories");
+  const { mkdirSync, writeFileSync, existsSync: existsFn } = await import("node:fs");
+  const { join: joinPath, basename: baseName } = await import("node:path");
+
+  let zip;
+  try {
+    zip = new AdmZip(zipPath);
+  } catch (e) {
+    console.error(red(`\n  Failed to open archive: ${e.message}\n`));
+    process.exit(1);
+  }
+
+  const manifestEntry = zip.getEntry("manifest.json");
+  if (!manifestEntry) {
+    console.error(red("\n  Invalid archive: missing manifest.json\n"));
+    process.exit(1);
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(zip.readAsText("manifest.json"));
+  } catch {
+    console.error(red("\n  Invalid archive: corrupt manifest.json\n"));
+    process.exit(1);
+  }
+
+  const indexEntry_ = zip.getEntry("index.json");
+  if (!indexEntry_) {
+    console.error(red("\n  Invalid archive: missing index.json\n"));
+    process.exit(1);
+  }
+
+  let index;
+  try {
+    index = JSON.parse(zip.readAsText("index.json"));
+  } catch {
+    console.error(red("\n  Invalid archive: corrupt index.json\n"));
+    process.exit(1);
+  }
+
+  const entries = index.entries || [];
+  if (entries.length === 0) {
+    console.log(yellow("\n  Archive contains no entries.\n"));
+    return;
+  }
+
+  console.log(`\n  ${bold("◇ context-vault import")} ${dim(baseName(zipPath))}`);
+  console.log(dim(`  Archive: v${manifest.version} · ${manifest.entry_count} entries · ${manifest.context_vault_version || "?"}`));
+
+  const kindCounts = {};
+  for (const e of entries) {
+    kindCounts[e.kind] = (kindCounts[e.kind] || 0) + 1;
+  }
+  console.log();
+  for (const [k, count] of Object.entries(kindCounts).sort((a, b) => b[1] - a[1])) {
+    console.log(`    ${k}: ${count}`);
+  }
+
+  const vaultDirOverride = getFlag("--vault");
+  const config = (await import("@context-vault/core/config")).resolveConfig();
+  const targetVaultDir = vaultDirOverride ? resolve(vaultDirOverride) : config.vaultDir;
+
+  if (!existsFn(targetVaultDir)) {
+    console.error(red(`\n  Vault directory not found: ${targetVaultDir}`));
+    console.error(`  Run ${cyan("context-vault setup")} to configure.`);
+    process.exit(1);
+  }
+
+  const db = await initDatabase(config.dbPath);
+  const stmts = prepareStatements(db);
+  const ctx = {
+    db,
+    config: { ...config, vaultDir: targetVaultDir },
+    stmts,
+    embed,
+    insertVec: (r, e) => insertVec(stmts, r, e),
+    deleteVec: (r) => deleteVec(stmts, r),
+  };
+
+  const existingIds = new Set();
+  const allIds = db.prepare("SELECT id FROM vault").all();
+  for (const row of allIds) existingIds.add(row.id);
+
+  let imported = 0;
+  let skippedDuplicate = 0;
+  let skippedMissing = 0;
+  let failed = 0;
+  const errors = [];
+
+  if (dryRun) {
+    for (let i = 0; i < Math.min(entries.length, 25); i++) {
+      const e = entries[i];
+      const isDuplicate = existingIds.has(e.id);
+      const tagStr = e.tags?.length ? ` ${dim(`[${e.tags.join(", ")}]`)}` : "";
+      const statusIcon = isDuplicate ? yellow("~") : green("+");
+      const statusText = isDuplicate ? dim(" (duplicate, would skip)") : "";
+      console.log(`\n  ${statusIcon} ${dim(`[${i + 1}]`)} ${e.kind} — ${e.title || e.id}${tagStr}${statusText}`);
+    }
+    if (entries.length > 25) {
+      console.log(dim(`\n  ... and ${entries.length - 25} more`));
+    }
+    const wouldSkip = entries.filter((e) => existingIds.has(e.id)).length;
+    console.log(`\n  ${dim(`Would import ${entries.length - wouldSkip}, skip ${wouldSkip} duplicates.`)}`);
+    console.log(dim("  Dry run — no entries were imported.\n"));
+    db.close();
+    return;
+  }
+
+  for (let i = 0; i < entries.length; i++) {
+    const entryMeta = entries[i];
+    process.stdout.write(`\r  Importing... ${i + 1}/${entries.length}`);
+
+    if (existingIds.has(entryMeta.id)) {
+      skippedDuplicate++;
+      continue;
+    }
+
+    const zipEntry = zip.getEntry(entryMeta.file);
+    if (!zipEntry) {
+      skippedMissing++;
+      continue;
+    }
+
+    const mdContent = zip.readAsText(entryMeta.file);
+    const { meta: fmMeta, body: rawBody } = parseFrontmatter(mdContent);
+
+    const kind = entryMeta.kind || fmMeta.kind || "insight";
+    const categoryDir = categoryDirFor(kind);
+    const targetDir = joinPath(targetVaultDir, categoryDir, kind);
+
+    try {
+      mkdirSync(targetDir, { recursive: true });
+
+      const fileName = baseName(entryMeta.file);
+      const filePath = joinPath(targetDir, fileName);
+      writeFileSync(filePath, mdContent);
+
+      const id = fmMeta.id || entryMeta.id;
+      const tags = Array.isArray(fmMeta.tags) ? fmMeta.tags : entryMeta.tags || [];
+      const title = fmMeta.title || entryMeta.title || null;
+      const source = fmMeta.source || entryMeta.source || "archive-import";
+      const identity_key = fmMeta.identity_key || entryMeta.identity_key || null;
+      const expires_at = fmMeta.expires_at || entryMeta.expires_at || null;
+      const createdAt = fmMeta.created || entryMeta.created_at || new Date().toISOString();
+
+      await indexEntry(ctx, {
+        id,
+        kind,
+        category: entryMeta.category || undefined,
+        title,
+        body: rawBody,
+        meta: null,
+        tags,
+        source,
+        filePath,
+        createdAt,
+        identity_key,
+        expires_at,
+      });
+
+      imported++;
+    } catch (e) {
+      failed++;
+      errors.push({ id: entryMeta.id, error: e.message });
+    }
+  }
+
+  db.close();
+
+  console.log(`\r  ${green("✓")} Import complete                    `);
+  console.log(`    ${green("+")} ${imported} imported`);
+  if (skippedDuplicate > 0) {
+    console.log(`    ${dim("~")} ${skippedDuplicate} skipped (already exist)`);
+  }
+  if (skippedMissing > 0) {
+    console.log(`    ${yellow("!")} ${skippedMissing} skipped (file missing in archive)`);
+  }
+  if (failed > 0) {
+    console.log(`    ${red("x")} ${failed} failed`);
+    for (const e of errors.slice(0, 5)) {
+      console.log(`      ${dim(e.error)}`);
+    }
+  }
+  console.log();
+}
+
 async function runExport() {
   const format = getFlag("--format") || "json";
-  const output = getFlag("--output");
+  const output = getFlag("--output") || getFlag("-o");
   const rawPageSize = getFlag("--page-size");
   const pageSize = rawPageSize
     ? Math.max(1, parseInt(rawPageSize, 10) || 100)
     : null;
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  if (format === "zip") {
+    return runExportZip();
+  }
+
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, prepareStatements } =
-    await import("@context-vault/core/index/db");
+    await import("@context-vault/core/db");
   const { writeFileSync } = await import("node:fs");
 
   const config = resolveConfig();
@@ -2308,7 +2700,6 @@ async function runExport() {
 
   let entries;
   if (pageSize) {
-    // Paginated: fetch in chunks to avoid loading everything into memory
     entries = [];
     let offset = 0;
     const stmt = db.prepare(
@@ -2378,6 +2769,188 @@ async function runExport() {
   }
 }
 
+async function runExportZip() {
+  const output = getFlag("--output") || getFlag("-o");
+  const dryRun = flags.has("--dry-run");
+  const tagsRaw = getFlag("--tags");
+  const kindRaw = getFlag("--kind");
+  const since = getFlag("--since");
+  const until = getFlag("--until");
+  const exportAll = flags.has("--all");
+
+  const tagsFilter = tagsRaw
+    ? tagsRaw.split(",").map((t) => t.trim()).filter(Boolean)
+    : null;
+  const kindFilter = kindRaw
+    ? kindRaw.split(",").map((k) => k.trim()).filter(Boolean)
+    : null;
+
+  if (!exportAll && !tagsFilter && !kindFilter && !since && !until) {
+    console.log(`\n  ${bold("context-vault export --format zip")} [options]\n`);
+    console.log(`  Export vault entries as a portable ZIP archive.\n`);
+    console.log(`  ${bold("Filters (at least one required, or use --all):")}`);
+    console.log(`    --tags <t1,t2>       Filter by tags (comma-separated)`);
+    console.log(`    --kind <k1,k2>       Filter by kind (comma-separated)`);
+    console.log(`    --since <YYYY-MM-DD> Entries created on or after date`);
+    console.log(`    --until <YYYY-MM-DD> Entries created on or before date`);
+    console.log(`    --all                Export all entries\n`);
+    console.log(`  ${bold("Options:")}`);
+    console.log(`    --output, -o <path>  Output file path`);
+    console.log(`    --dry-run            Show what would be exported\n`);
+    console.log(`  ${bold("Examples:")}`);
+    console.log(`    context-vault export --tags stormfors --format zip -o stormfors.zip`);
+    console.log(`    context-vault export --kind decision,pattern --format zip`);
+    console.log(`    context-vault export --since 2026-01-01 --until 2026-02-28 --format zip`);
+    console.log(`    context-vault export --all --format zip --dry-run\n`);
+    return;
+  }
+
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase } = await import("@context-vault/core/db");
+  const { readFileSync: readFs, existsSync: existsFn } = await import("node:fs");
+  const { basename } = await import("node:path");
+
+  const config = resolveConfig();
+  if (!config.vaultDirExists) {
+    console.error(red(`  Vault directory not found: ${config.vaultDir}`));
+    process.exit(1);
+  }
+
+  const db = await initDatabase(config.dbPath);
+
+  const conditions = ["(expires_at IS NULL OR expires_at > datetime('now'))"];
+  const params = [];
+
+  if (tagsFilter) {
+    const tagClauses = tagsFilter.map(() =>
+      "EXISTS (SELECT 1 FROM json_each(vault.tags) WHERE json_each.value = ?)"
+    );
+    conditions.push(`(${tagClauses.join(" OR ")})`);
+    params.push(...tagsFilter);
+  }
+
+  if (kindFilter) {
+    const placeholders = kindFilter.map(() => "?").join(", ");
+    conditions.push(`kind IN (${placeholders})`);
+    params.push(...kindFilter);
+  }
+
+  if (since) {
+    conditions.push("created_at >= ?");
+    params.push(since.includes("T") ? since : `${since}T00:00:00.000Z`);
+  }
+
+  if (until) {
+    conditions.push("created_at <= ?");
+    params.push(until.includes("T") ? until : `${until}T23:59:59.999Z`);
+  }
+
+  const sql = `SELECT * FROM vault WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC`;
+  const rows = db.prepare(sql).all(...params);
+  db.close();
+
+  if (rows.length === 0) {
+    console.log(yellow("\n  No entries match the given filters.\n"));
+    return;
+  }
+
+  const kindCounts = {};
+  for (const row of rows) {
+    kindCounts[row.kind] = (kindCounts[row.kind] || 0) + 1;
+  }
+
+  console.log(`\n  ${bold(String(rows.length))} entries match filters:\n`);
+  for (const [k, count] of Object.entries(kindCounts).sort((a, b) => b[1] - a[1])) {
+    console.log(`    ${k}: ${count}`);
+  }
+
+  const earliest = rows[rows.length - 1]?.created_at;
+  const latest = rows[0]?.created_at;
+  console.log(dim(`\n  Date range: ${earliest?.slice(0, 10) || "?"} → ${latest?.slice(0, 10) || "?"}`));
+
+  if (dryRun) {
+    console.log();
+    for (let i = 0; i < Math.min(rows.length, 25); i++) {
+      const r = rows[i];
+      const tags = safeJsonParse(r.tags, []);
+      const tagStr = tags.length ? ` ${dim(`[${tags.join(", ")}]`)}` : "";
+      console.log(`  ${dim(`[${i + 1}]`)} ${r.kind} — ${r.title || (r.body || "").slice(0, 60)}${tagStr}`);
+    }
+    if (rows.length > 25) {
+      console.log(dim(`  ... and ${rows.length - 25} more`));
+    }
+    console.log(dim("\n  Dry run — no archive created.\n"));
+    return;
+  }
+
+  const AdmZip = (await import("adm-zip")).default;
+  const zip = new AdmZip();
+
+  const indexEntries = [];
+  let filesSkipped = 0;
+
+  for (const row of rows) {
+    const entryPath = `entries/${row.kind}/${basename(row.file_path || `${row.id}.md`)}`;
+
+    let fileContent = null;
+    if (row.file_path && existsFn(row.file_path)) {
+      fileContent = readFs(row.file_path);
+    }
+
+    if (!fileContent) {
+      filesSkipped++;
+      continue;
+    }
+
+    zip.addFile(entryPath, fileContent);
+
+    indexEntries.push({
+      id: row.id,
+      kind: row.kind,
+      category: row.category,
+      title: row.title || null,
+      tags: safeJsonParse(row.tags, []),
+      source: row.source || null,
+      identity_key: row.identity_key || null,
+      expires_at: row.expires_at || null,
+      created_at: row.created_at,
+      file: entryPath,
+    });
+  }
+
+  const manifest = {
+    version: 1,
+    created_at: new Date().toISOString(),
+    context_vault_version: VERSION,
+    entry_count: indexEntries.length,
+    date_range: { earliest, latest },
+    filters: {
+      tags: tagsFilter || null,
+      kind: kindFilter || null,
+      since: since || null,
+      until: until || null,
+      all: exportAll || false,
+    },
+  };
+
+  zip.addFile("manifest.json", Buffer.from(JSON.stringify(manifest, null, 2)));
+  zip.addFile("index.json", Buffer.from(JSON.stringify({ entries: indexEntries }, null, 2)));
+
+  const today = new Date().toISOString().slice(0, 10);
+  const defaultName = tagsFilter
+    ? `vault-${tagsFilter[0]}-${today}.zip`
+    : `vault-export-${today}.zip`;
+  const outputPath = resolve(output || defaultName);
+
+  zip.writeZip(outputPath);
+
+  console.log(`\n  ${green("✓")} Exported ${indexEntries.length} entries to ${outputPath}`);
+  if (filesSkipped > 0) {
+    console.log(yellow(`  ⚠ ${filesSkipped} entries skipped (file not found on disk)`));
+  }
+  console.log();
+}
+
 function safeJsonParse(str, fallback) {
   if (!str) return fallback;
   try {
@@ -2446,10 +3019,10 @@ async function runIngest() {
     return;
   }
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, prepareStatements, insertVec, deleteVec } =
-    await import("@context-vault/core/index/db");
-  const { embed } = await import("@context-vault/core/index/embed");
+    await import("@context-vault/core/db");
+  const { embed } = await import("@context-vault/core/embed");
   const { captureAndIndex } = await import("@context-vault/core/capture");
 
   const config = resolveConfig();
@@ -2513,10 +3086,10 @@ async function runIngestProject() {
 
   console.log(dim(`  Scanning ${projectPath}...`));
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, prepareStatements, insertVec, deleteVec } =
-    await import("@context-vault/core/index/db");
-  const { embed } = await import("@context-vault/core/index/embed");
+    await import("@context-vault/core/db");
+  const { embed } = await import("@context-vault/core/embed");
   const { captureAndIndex } = await import("@context-vault/core/capture");
   const { existsSync: fsExists, readFileSync: fsRead } =
     await import("node:fs");
@@ -2727,21 +3300,21 @@ async function runRecall() {
 
   let db;
   try {
-    const { resolveConfig } = await import("@context-vault/core/core/config");
+    const { resolveConfig } = await import("@context-vault/core/config");
     const config = resolveConfig();
 
     if (!config.vaultDirExists) return;
 
     const { initDatabase, prepareStatements } =
-      await import("@context-vault/core/index/db");
-    const { embed } = await import("@context-vault/core/index/embed");
-    const { hybridSearch } = await import("@context-vault/core/retrieve/index");
+      await import("@context-vault/core/db");
+    const { embed } = await import("@context-vault/core/embed");
+    const { hybridSearch } = await import("@context-vault/core/search");
 
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
     const ctx = { db, config, stmts, embed };
 
-    const { categoryFor } = await import("@context-vault/core/core/categories");
+    const { categoryFor } = await import("@context-vault/core/categories");
     const recall = config.recall;
 
     const results = await hybridSearch(ctx, query, {
@@ -2781,8 +3354,8 @@ async function runRecall() {
 }
 
 async function runFlush() {
-  const { resolveConfig } = await import("@context-vault/core/core/config");
-  const { initDatabase } = await import("@context-vault/core/index/db");
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase } = await import("@context-vault/core/db");
 
   let db;
   try {
@@ -2828,12 +3401,12 @@ async function runSessionCapture() {
     }
     const { kind, title, body, tags, source } = payload;
     if (!kind || !body) return;
-    const { resolveConfig } = await import("@context-vault/core/core/config");
+    const { resolveConfig } = await import("@context-vault/core/config");
     const config = resolveConfig();
     if (!config.vaultDirExists) return;
     const { initDatabase, prepareStatements, insertVec, deleteVec } =
-      await import("@context-vault/core/index/db");
-    const { embed } = await import("@context-vault/core/index/embed");
+      await import("@context-vault/core/db");
+    const { embed } = await import("@context-vault/core/embed");
     const { captureAndIndex } = await import("@context-vault/core/capture");
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
@@ -2863,13 +3436,158 @@ async function runSessionCapture() {
 }
 
 async function runSessionEnd() {
-  const { main } = await import("../src/hooks/session-end.mjs");
-  await main();
+  let db;
+  try {
+    const raw = await new Promise((resolve) => {
+      let data = "";
+      process.stdin.on("data", (chunk) => (data += chunk));
+      process.stdin.on("end", () => resolve(data));
+    });
+    if (!raw.trim()) return;
+    let input;
+    try {
+      input = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const { session_id, transcript_path, cwd } = input ?? {};
+    if (!transcript_path || !cwd) return;
+
+    // Read transcript (JSONL)
+    let turns = [];
+    try {
+      const transcriptRaw = readFileSync(transcript_path, "utf-8");
+      for (const line of transcriptRaw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try { turns.push(JSON.parse(trimmed)); } catch {}
+      }
+    } catch { return; }
+
+    const extractText = (turn) => {
+      if (typeof turn.content === "string") return turn.content;
+      if (Array.isArray(turn.content))
+        return turn.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+      return "";
+    };
+
+    const userTurns = turns.filter((t) => t.role === "user");
+    if (userTurns.length === 0) return;
+
+    // Tool use blocks
+    const allToolUse = [];
+    for (const turn of turns) {
+      if (!Array.isArray(turn.content)) continue;
+      for (const block of turn.content) {
+        if (block.type === "tool_use") allToolUse.push(block);
+      }
+    }
+
+    // Files modified
+    const seenFiles = new Set();
+    const filesModified = [];
+    for (const block of allToolUse) {
+      if (block.name === "Write" || block.name === "Edit") {
+        const path = block.input?.file_path ?? block.input?.path ?? null;
+        if (path && !seenFiles.has(path)) { seenFiles.add(path); filesModified.push(path); }
+      }
+    }
+
+    // Commands run
+    const commandsRun = [];
+    for (const block of allToolUse) {
+      if (block.name === "Bash") {
+        const cmd = block.input?.command ?? block.input?.cmd ?? null;
+        if (cmd) commandsRun.push(cmd.slice(0, 100));
+      }
+    }
+
+    // Tool counts
+    const toolCounts = {};
+    for (const block of allToolUse) {
+      const name = block.name ?? "unknown";
+      toolCounts[name] = (toolCounts[name] ?? 0) + 1;
+    }
+    const toolSummary = Object.entries(toolCounts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([name, count]) => `${name}: ${count}`)
+      .join(", ");
+
+    // Duration
+    let durationStr = null;
+    const timestampedTurns = turns.filter((t) => t.timestamp != null);
+    if (timestampedTurns.length >= 2) {
+      const diffMs = new Date(timestampedTurns[timestampedTurns.length - 1].timestamp) - new Date(timestampedTurns[0].timestamp);
+      if (!isNaN(diffMs) && diffMs >= 0) {
+        const totalSec = Math.round(diffMs / 1000);
+        const hours = Math.floor(totalSec / 3600);
+        const minutes = Math.floor((totalSec % 3600) / 60);
+        const seconds = totalSec % 60;
+        durationStr = hours > 0 ? `${hours}h ${minutes}m` : minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+      }
+    }
+
+    const message_count = userTurns.length;
+    const project = cwd.split("/").pop() || "unknown";
+    const first_prompt = extractText(userTurns[0]).slice(0, 200);
+    const last_prompt = message_count > 1 ? extractText(userTurns[message_count - 1]).slice(0, 200) : first_prompt;
+
+    // Build body
+    const durationPart = durationStr ? `, ~${durationStr}` : "";
+    const bodyLines = [
+      `Session in ${project} (${message_count} exchange${message_count !== 1 ? "s" : ""}${durationPart}).`,
+      "", "## What was done",
+      `Opened with: ${first_prompt}`, "",
+      `Closed with: ${last_prompt}`,
+    ];
+    const limitedFiles = filesModified.slice(0, 20);
+    if (limitedFiles.length > 0) {
+      bodyLines.push("", "## Files modified");
+      for (const f of limitedFiles) bodyLines.push(`- ${f}`);
+      if (filesModified.length > 20) bodyLines.push(`- ... and ${filesModified.length - 20} more`);
+    }
+    const limitedCmds = commandsRun.slice(0, 10);
+    if (limitedCmds.length > 0) {
+      bodyLines.push("", "## Key commands");
+      for (const c of limitedCmds) bodyLines.push(`- ${c}`);
+      if (commandsRun.length > 10) bodyLines.push(`- ... and ${commandsRun.length - 10} more`);
+    }
+    if (toolSummary) bodyLines.push("", "## Tools used", toolSummary);
+    const body = bodyLines.join("\n");
+
+    // Save via core APIs
+    const { resolveConfig } = await import("@context-vault/core/config");
+    const config = resolveConfig();
+    if (!config.vaultDirExists) return;
+    const { initDatabase, prepareStatements, insertVec, deleteVec } =
+      await import("@context-vault/core/db");
+    const { captureAndIndex } = await import("@context-vault/core/capture");
+    db = await initDatabase(config.dbPath);
+    const stmts = prepareStatements(db);
+    const ctx = {
+      db, config, stmts,
+      embed: async () => null,
+      insertVec: (rowid, embedding) => insertVec(stmts, rowid, embedding),
+      deleteVec: (rowid) => deleteVec(stmts, rowid),
+    };
+    const entry = await captureAndIndex(ctx, {
+      kind: "session",
+      title: `Session — ${project} ${new Date().toLocaleString("en-US", { month: "short", day: "numeric", year: "numeric", hour: "2-digit", minute: "2-digit" })}`,
+      body,
+      tags: ["session-end", "session-summary", project],
+      source: "claude-code",
+      meta: { session_id: session_id ?? null, cwd, message_count },
+    });
+    console.log(`context-vault session captured — id: ${entry.id}`);
+  } catch {
+    // fail silently — never block session end
+  } finally {
+    try { db?.close(); } catch {}
+  }
 }
 
 async function runPostToolCall() {
-  const { main } = await import("../src/hooks/post-tool-call.mjs");
-  await main();
+  // Removed in v3 — post-tool-call hooks are no longer supported
 }
 
 async function runSave() {
@@ -2912,7 +3630,7 @@ async function runSave() {
 
   let db;
   try {
-    const { resolveConfig } = await import("@context-vault/core/core/config");
+    const { resolveConfig } = await import("@context-vault/core/config");
     const config = resolveConfig();
     if (!config.vaultDirExists) {
       console.error(
@@ -2921,8 +3639,8 @@ async function runSave() {
       process.exit(1);
     }
     const { initDatabase, prepareStatements, insertVec, deleteVec } =
-      await import("@context-vault/core/index/db");
-    const { embed } = await import("@context-vault/core/index/embed");
+      await import("@context-vault/core/db");
+    const { embed } = await import("@context-vault/core/embed");
     const { captureAndIndex } = await import("@context-vault/core/capture");
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
@@ -2996,7 +3714,7 @@ async function runSearch() {
 
   let db;
   try {
-    const { resolveConfig } = await import("@context-vault/core/core/config");
+    const { resolveConfig } = await import("@context-vault/core/config");
     const config = resolveConfig();
     if (!config.vaultDirExists) {
       console.error(red("No vault found. Run: context-vault setup"));
@@ -3004,9 +3722,9 @@ async function runSearch() {
     }
 
     const { initDatabase, prepareStatements } =
-      await import("@context-vault/core/index/db");
-    const { embed } = await import("@context-vault/core/index/embed");
-    const { hybridSearch } = await import("@context-vault/core/retrieve/index");
+      await import("@context-vault/core/db");
+    const { embed } = await import("@context-vault/core/embed");
+    const { hybridSearch } = await import("@context-vault/core/search");
 
     db = await initDatabase(config.dbPath);
     const stmts = prepareStatements(db);
@@ -3763,9 +4481,9 @@ ${bold("Commands:")}
 }
 
 async function runDoctor() {
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { errorLogPath, errorLogCount } =
-    await import("@context-vault/core/core/error-log");
+    await import("../src/error-log.js");
 
   console.log();
   console.log(`  ${bold("◇ context-vault doctor")} ${dim(`v${VERSION}`)}`);
@@ -3839,7 +4557,7 @@ async function runDoctor() {
     let db;
     if (existsSync(config.dbPath)) {
       try {
-        const { initDatabase } = await import("@context-vault/core/index/db");
+        const { initDatabase } = await import("@context-vault/core/db");
         db = await initDatabase(config.dbPath);
         const schemaRow = db.prepare("PRAGMA user_version").get();
         const schemaVersion = schemaRow?.user_version ?? "unknown";
@@ -3861,7 +4579,7 @@ async function runDoctor() {
 
     // ── Embedding model ──────────────────────────────────────────────────
     try {
-      const { embed } = await import("@context-vault/core/index/embed");
+      const { embed } = await import("@context-vault/core/embed");
       const vec = await embed("doctor check");
       if (vec && vec.length > 0) {
         console.log(
@@ -4227,9 +4945,9 @@ async function runDoctor() {
 }
 
 async function runHealth() {
-  const { resolveConfig } = await import("@context-vault/core/core/config");
+  const { resolveConfig } = await import("@context-vault/core/config");
   const { initDatabase, testConnection } =
-    await import("@context-vault/core/index/db");
+    await import("@context-vault/core/db");
 
   let config;
   let healthy = true;
@@ -4418,8 +5136,8 @@ async function runConsolidate() {
   const dryRun = flags.has("--dry-run");
   const tagArg = getFlag("--tag");
 
-  const { resolveConfig } = await import("@context-vault/core/core/config");
-  const { initDatabase } = await import("@context-vault/core/index/db");
+  const { resolveConfig } = await import("@context-vault/core/config");
+  const { initDatabase } = await import("@context-vault/core/db");
   const { findHotTags, findColdEntries } =
     await import("@context-vault/core/consolidation/index");
 
@@ -4538,7 +5256,7 @@ async function runConsolidate() {
       );
       console.log(
         dim(
-          `  To archive: use context-vault search --kind <kind> and review manually.`,
+          `  To archive: run context-vault archive (or --dry-run to preview).`,
         ),
       );
     }
@@ -4548,7 +5266,7 @@ async function runConsolidate() {
 }
 
 async function runServe() {
-  await import("../src/server/index.js");
+  await import("../src/server.js");
 }
 
 async function main() {
@@ -4633,6 +5351,12 @@ async function main() {
     case "migrate-dirs":
       await runMigrateDirs();
       break;
+    case "archive":
+      await runArchive();
+      break;
+    case "restore":
+      await runRestore();
+      break;
     case "prune":
       await runPrune();
       break;