unforgit 0.1.0

package/dist/index.js

@@ -0,0 +1,3504 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command28 } from "commander";
+
+// src/commands/init.ts
+import fs2 from "fs";
+import { Command } from "commander";
+
+// src/utils.ts
+import readline from "readline";
+function truncate(text, maxLength) {
+  const singleLine = text.replace(/\n/g, " ").trim();
+  if (singleLine.length <= maxLength) return singleLine;
+  return singleLine.slice(0, maxLength - 3) + "...";
+}
+function maskKey(key) {
+  if (key.length <= 10) return "***";
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${message} (yes/no): `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function outputJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function paginate(items, page, perPage) {
+  const total = items.length;
+  const totalPages = Math.ceil(total / perPage);
+  const currentPage = Math.min(page, totalPages);
+  const start = (currentPage - 1) * perPage;
+  return {
+    items: items.slice(start, start + perPage),
+    totalPages,
+    currentPage,
+    total
+  };
+}
+
+// src/logger.ts
+var level = 1;
+function setVerbosity(v) {
+  level = v;
+}
+var REDACTED = "[REDACTED]";
+var secretPatterns = [
+  /\b([A-Z][A-Z0-9_]*(?:KEY|TOKEN|SECRET|PASSWORD))\s*=\s*([^\s]+)/gi,
+  /\b(authorization\s*:\s*bearer)\s+([^\s]+)/gi,
+  /\b(client_secret)\s*=\s*([^\s&]+)/gi,
+  /(postgres(?:ql)?:\/\/[^:\s/@]+:)([^@\s]+)(@)/gi
+];
+function redactSecrets(msg) {
+  return msg.replace(secretPatterns[0], (_match, prefix) => `${prefix}=${REDACTED}`).replace(secretPatterns[1], (_match, prefix) => `${prefix} ${REDACTED}`).replace(secretPatterns[2], (_match, prefix) => `${prefix}=${REDACTED}`).replace(secretPatterns[3], (_match, prefix, _secret, suffix) => `${prefix}${REDACTED}${suffix}`);
+}
+function safeMessage(msg) {
+  return redactSecrets(msg);
+}
+var logger = {
+  fatal(msg) {
+    if (!isJsonMode()) console.error(`fatal: ${safeMessage(msg)}`);
+  },
+  error(msg) {
+    if (!isJsonMode()) console.error(`error: ${safeMessage(msg)}`);
+  },
+  warn(msg) {
+    if (level >= 1 && !isJsonMode()) console.error(`warning: ${safeMessage(msg)}`);
+  },
+  info(msg) {
+    if (level >= 1 && !isJsonMode()) console.log(safeMessage(msg));
+  },
+  debug(msg) {
+    if (level >= 2 && !isJsonMode()) console.error(`debug: ${safeMessage(msg)}`);
+  },
+  progress(current, total, label) {
+    if (level >= 1 && !isJsonMode()) {
+      const pct = total > 0 ? Math.round(current / total * 100) : 0;
+      const suffix = label ? ` ${safeMessage(label)}` : "";
+      process.stdout.write(`\rProcessing ${current}/${total} (${pct}%)${suffix}`);
+      if (current === total) process.stdout.write("\n");
+    }
+  }
+};
+
+// src/commands/init.ts
+import {
+  getDataDir,
+  getConfigPath,
+  getDbPath,
+  defaultConfig,
+  saveConfig,
+  isInitialized,
+  detectGitInfo
+} from "unforgit-config";
+import { LocalStore } from "unforgit-db";
+
+// src/ide-integration.ts
+import fs from "fs";
+import path from "path";
+var ALL_IDE_NAMES = [
+  "cursor",
+  "claude",
+  "vscode",
+  "windsurf"
+];
+var UNFORGIT_MARKER = "Unforgit Memory Integration";
+var MEMORY_INSTRUCTIONS = `# Unforgit Memory Integration
+
+You have access to \`unforgit_recall\` and \`unforgit_add\` MCP tools for persistent repository memory across sessions.
+
+## 1. Recall at the Start
+
+At the **beginning of every conversation**, use the \`unforgit_recall\` tool with a query based on the user's first message to retrieve relevant context from past sessions.
+
+Use recalled memories to avoid repeating past mistakes, follow known conventions, and apply previous decisions.
+
+## 2. Save During the Conversation
+
+Save memories **as soon as something noteworthy happens** \u2014 don't wait until the end.
+
+Trigger a save with the \`unforgit_add\` tool immediately after:
+- A bug is found and fixed
+- An architectural or design decision is made
+- A non-obvious gotcha or workaround is discovered
+- A new convention or pattern is established
+- A deployment/setup procedure is figured out
+
+### Memory types
+
+| Type | When | Example |
+|------|------|---------|
+| \`semantic\` | Decisions, conventions, architecture facts | "We use UTC timestamps everywhere" |
+| \`procedural\` | Workflows, how-tos, playbooks | "To deploy: run make release, then kubectl apply" |
+| \`episodic\` | Bugs found, gotchas, observations | "Found race condition in queue worker" |
+
+### Rules
+
+- Keep text concise but self-contained \u2014 a future reader should understand it without extra context
+- Use meaningful tags for discoverability (e.g. \`["auth", "bug"]\`, \`["deploy", "playbook"]\`)
+- Prefer \`semantic\` for stable facts, \`procedural\` for how-tos, \`episodic\` for transient observations
+- Do NOT save trivial changes, obvious things, or info already in the codebase docs
+- Quality over quantity \u2014 only save what's genuinely useful for future sessions
+- **Always write memory text in English**, regardless of the language the user is speaking`;
+function fileContainsUnforgit(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  return fs.readFileSync(filePath, "utf-8").includes(UNFORGIT_MARKER);
+}
+function upsertJsonMcp(filePath, serverKey, mcpEntry) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(filePath)) {
+    const config = { [serverKey]: { unforgit: mcpEntry } };
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    return { path: filePath, action: "created" };
+  }
+  const existing = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  const servers = existing[serverKey];
+  if (servers?.unforgit) {
+    return { path: filePath, action: "exists" };
+  }
+  existing[serverKey] = existing[serverKey] || {};
+  existing[serverKey].unforgit = mcpEntry;
+  fs.writeFileSync(
+    filePath,
+    JSON.stringify(existing, null, 2) + "\n",
+    "utf-8"
+  );
+  return { path: filePath, action: "updated" };
+}
+function appendOrCreateMarkdown(filePath, content) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  if (!fs.existsSync(filePath)) {
+    fs.writeFileSync(filePath, content + "\n", "utf-8");
+    return { path: filePath, action: "created" };
+  }
+  if (fileContainsUnforgit(filePath)) {
+    return { path: filePath, action: "exists" };
+  }
+  const existing = fs.readFileSync(filePath, "utf-8");
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  fs.writeFileSync(filePath, existing + separator + content + "\n", "utf-8");
+  return { path: filePath, action: "updated" };
+}
+var CURSOR_RULE_CONTENT = `---
+description: Auto-manage repository memory with Unforgit via MCP tools
+alwaysApply: true
+---
+
+${MEMORY_INSTRUCTIONS}
+`;
+function setupCursor(cwd4) {
+  const rulesDir = path.join(cwd4, ".cursor", "rules");
+  const rulePath = path.join(rulesDir, "unforgit-memory.mdc");
+  let rules;
+  if (fileContainsUnforgit(rulePath)) {
+    rules = { path: rulePath, action: "exists" };
+  } else {
+    fs.mkdirSync(rulesDir, { recursive: true });
+    fs.writeFileSync(rulePath, CURSOR_RULE_CONTENT, "utf-8");
+    rules = { path: rulePath, action: "created" };
+  }
+  const mcpPath = path.join(cwd4, ".cursor", "mcp.json");
+  const mcp = upsertJsonMcp(mcpPath, "mcpServers", {
+    command: "unforgit-mcp",
+    args: []
+  });
+  return { ide: "cursor", rules, mcp };
+}
+function setupClaude(cwd4) {
+  const claudeMdPath = path.join(cwd4, "CLAUDE.md");
+  const rules = appendOrCreateMarkdown(claudeMdPath, MEMORY_INSTRUCTIONS);
+  const mcpPath = path.join(cwd4, ".mcp.json");
+  const mcp = upsertJsonMcp(mcpPath, "mcpServers", {
+    command: "unforgit-mcp",
+    args: []
+  });
+  return { ide: "claude", rules, mcp };
+}
+function setupVscode(cwd4) {
+  const instructionsPath = path.join(
+    cwd4,
+    ".github",
+    "copilot-instructions.md"
+  );
+  const rules = appendOrCreateMarkdown(instructionsPath, MEMORY_INSTRUCTIONS);
+  const mcpPath = path.join(cwd4, ".vscode", "mcp.json");
+  const mcp = upsertJsonMcp(mcpPath, "servers", {
+    type: "stdio",
+    command: "unforgit-mcp"
+  });
+  return { ide: "vscode", rules, mcp };
+}
+var WINDSURF_RULE_CONTENT = `${MEMORY_INSTRUCTIONS}
+`;
+function setupWindsurf(cwd4) {
+  const rulesPath = path.join(cwd4, ".windsurfrules");
+  const rules = appendOrCreateMarkdown(rulesPath, WINDSURF_RULE_CONTENT);
+  const mcpPath = path.join(cwd4, ".windsurf", "mcp.json");
+  const mcp = upsertJsonMcp(mcpPath, "mcpServers", {
+    command: "unforgit-mcp",
+    args: []
+  });
+  return { ide: "windsurf", rules, mcp };
+}
+var IDE_INDICATORS = {
+  cursor: [".cursor"],
+  claude: ["CLAUDE.md", ".claude"],
+  vscode: [".vscode"],
+  windsurf: [".windsurf", ".windsurfrules"]
+};
+function detectIdes(cwd4) {
+  const detected = [];
+  for (const [ide, indicators] of Object.entries(IDE_INDICATORS)) {
+    for (const indicator of indicators) {
+      if (fs.existsSync(path.join(cwd4, indicator))) {
+        detected.push(ide);
+        break;
+      }
+    }
+  }
+  return detected;
+}
+var IDE_HANDLERS = {
+  cursor: setupCursor,
+  claude: setupClaude,
+  vscode: setupVscode,
+  windsurf: setupWindsurf
+};
+var IDE_LABELS = {
+  cursor: "Cursor",
+  claude: "Claude Code",
+  vscode: "VS Code (Copilot)",
+  windsurf: "Windsurf"
+};
+function setupIdes(cwd4, ides) {
+  const results = [];
+  for (const ide of ides) {
+    const handler = IDE_HANDLERS[ide];
+    const result = handler(cwd4);
+    results.push(result);
+  }
+  return results;
+}
+function logIdeResults(results) {
+  if (results.length === 0) {
+    logger.info("  IDE integration: skipped");
+    return;
+  }
+  for (const result of results) {
+    const label = IDE_LABELS[result.ide];
+    logger.info(`  ${label}:`);
+    if (result.rules) {
+      const verb = result.rules.action === "exists" ? "already exists" : result.rules.action;
+      logger.info(`    Rules: ${verb} \u2192 ${result.rules.path}`);
+    }
+    if (result.mcp) {
+      const verb = result.mcp.action === "exists" ? "already configured" : result.mcp.action;
+      logger.info(`    MCP:   ${verb} \u2192 ${result.mcp.path}`);
+    }
+  }
+}
+function parseIdeOption(value) {
+  if (value === "all") return [...ALL_IDE_NAMES];
+  const names = value.split(",").map((s) => s.trim().toLowerCase());
+  const valid = [];
+  for (const name of names) {
+    if (ALL_IDE_NAMES.includes(name)) {
+      valid.push(name);
+    } else {
+      logger.warn(`Unknown IDE: "${name}". Valid options: ${ALL_IDE_NAMES.join(", ")}`);
+    }
+  }
+  return valid;
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Initialize Unforgit in the current repository").option("--org-id <orgId>", "Override auto-detected organization ID").option("--repo-id <repoId>", "Override auto-detected repository ID").option("--remote-url <url>", "Remote API URL", "http://localhost:3737").option(
+  "--ide <ides>",
+  `IDE integrations to set up: ${ALL_IDE_NAMES.join(", ")}, all (default: auto-detect)`
+).option("--no-ide", "Skip all IDE integrations").option("--no-cursor-rule", "Skip IDE integrations (deprecated, use --no-ide)").action((opts) => {
+  const cwd4 = process.cwd();
+  if (isInitialized(cwd4)) {
+    logger.info("Unforgit is already initialized in this directory.");
+    return;
+  }
+  const dataDir = getDataDir(cwd4);
+  fs2.mkdirSync(dataDir, { recursive: true });
+  const git = detectGitInfo(cwd4);
+  const config = defaultConfig();
+  config.remote.orgId = opts.orgId ?? git.orgId;
+  config.remote.repoId = opts.repoId ?? git.repoId;
+  if (opts.remoteUrl) config.remote.url = opts.remoteUrl;
+  saveConfig(config, cwd4);
+  const store = new LocalStore(getDbPath(cwd4));
+  store.close();
+  logger.info(`Initialized Unforgit at ${dataDir}`);
+  logger.info(`  Config: ${getConfigPath(cwd4)}`);
+  logger.info(`  Local DB: ${getDbPath(cwd4)}`);
+  if (config.remote.orgId || config.remote.repoId) {
+    logger.info(`  Org: ${config.remote.orgId}`);
+    logger.info(`  Repo: ${config.remote.repoId}`);
+    if (!opts.orgId && !opts.repoId) {
+      logger.info("  (auto-detected from git remote)");
+    }
+  } else {
+    logger.info(
+      "\nTip: Set org_id and repo_id in .unforgit/unforgit.yaml or add a git remote."
+    );
+  }
+  const skipIde = opts.ide === false || opts.cursorRule === false;
+  if (!skipIde) {
+    let ides;
+    if (opts.ide && typeof opts.ide === "string") {
+      ides = parseIdeOption(opts.ide);
+    } else {
+      ides = detectIdes(cwd4);
+      if (ides.length === 0) {
+        ides = ["cursor"];
+        logger.info(
+          "\n  No IDE detected, defaulting to Cursor. Use --ide to specify."
+        );
+      } else {
+        logger.info(
+          `
+  Auto-detected IDEs: ${ides.join(", ")}`
+        );
+      }
+    }
+    const results = setupIdes(cwd4, ides);
+    logIdeResults(results);
+  } else {
+    logger.info("\n  IDE integration: skipped");
+  }
+});
+
+// src/commands/add.ts
+import { Command as Command2 } from "commander";
+import { loadConfig, getDbPath as getDbPath2 } from "unforgit-config";
+
+// src/exit-codes.ts
+var EXIT_ERROR = 1;
+var EXIT_CONFIG_ERROR = 2;
+var EXIT_SIGINT = 130;
+var EXIT_SIGTERM = 143;
+
+// src/commands/add.ts
+import { LocalStore as LocalStore2 } from "unforgit-db";
+import { resolveVisibility } from "unforgit-core";
+import { applyLifecycleDefaults } from "unforgit-core";
+import { getTemplate, applyTemplate, formatTemplateList } from "unforgit-core";
+import { validateMemoryType, parseConfidence, parseTtl } from "unforgit-config";
+var addCommand = new Command2("add").description("Add a memory (local by default)").argument("<text>", "Memory text content").option(
+  "-t, --type <type>",
+  "Memory type (episodic|semantic|procedural)"
+).option("--tags <tags>", "Comma-separated tags", "").option(
+  "--visibility <visibility>",
+  "Visibility (private|repo|auto)"
+).option("--source-pr <url>", "Source PR URL").option("--source-commit <sha>", "Source commit SHA").option("--confidence <n>", "Confidence score 0-1").option("--ttl <seconds>", "TTL in seconds").option("--template <name>", "Use a template (decision, gotcha, playbook, etc.)").option("--list-templates", "List available templates").addHelpText("after", `
+Examples:
+  unforgit add "We use UTC timestamps everywhere" -t semantic --tags time,convention
+  unforgit add "Found race condition in worker" -t episodic --tags bug
+  unforgit add "To deploy: run make release" --template playbook`).action((text, opts) => {
+  if (opts.listTemplates) {
+    logger.info(formatTemplateList());
+    return;
+  }
+  if (!text || !text.trim()) {
+    logger.error("Memory text cannot be empty.");
+    process.exit(EXIT_ERROR);
+  }
+  const config = loadConfig();
+  const store = new LocalStore2(getDbPath2());
+  try {
+    let userTags = [...new Set(
+      opts.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : []
+    )];
+    if (opts.type && !validateMemoryType(opts.type)) {
+      logger.error(`Invalid memory type "${opts.type}". Must be one of: episodic, semantic, procedural`);
+      process.exit(EXIT_ERROR);
+    }
+    let memoryType = opts.type ?? config.defaults.memoryType;
+    let memoryText = text;
+    let visibility = opts.visibility ?? config.defaults.visibility;
+    if (opts.template) {
+      const template = getTemplate(opts.template);
+      if (!template) {
+        logger.error(`Unknown template: ${opts.template}`);
+        logger.info("\n" + formatTemplateList());
+        process.exit(EXIT_ERROR);
+      }
+      const applied = applyTemplate(template, text, userTags);
+      memoryText = applied.text;
+      memoryType = applied.memoryType;
+      userTags = applied.tags;
+      if (visibility === "auto") {
+        visibility = applied.visibility;
+      }
+      logger.info(`Using template: ${template.name}`);
+    }
+    const sourceRefs = {};
+    if (opts.sourcePr) sourceRefs.pr_url = opts.sourcePr;
+    if (opts.sourceCommit) sourceRefs.commit_sha = opts.sourceCommit;
+    const input = applyLifecycleDefaults({
+      orgId: config.remote.orgId || "local",
+      repoId: config.remote.repoId || "local",
+      memoryType,
+      text: memoryText,
+      tags: userTags,
+      sourceRefs: Object.keys(sourceRefs).length > 0 ? sourceRefs : void 0,
+      confidence: opts.confidence ? parseConfidence(opts.confidence) : void 0,
+      ttlSeconds: opts.ttl ? parseTtl(opts.ttl) : void 0,
+      visibility
+    }, config.lifecycle);
+    const policy = resolveVisibility(input);
+    const memory = store.store({
+      ...input,
+      visibility: policy.visibility
+    });
+    logger.info(`Memory stored: ${memory.id}`);
+    logger.info(`  Type: ${memory.memoryType}`);
+    logger.info(`  Visibility: ${memory.visibility}`);
+    logger.info(`  Tags: ${memory.tags.join(", ") || "(none)"}`);
+    if (policy.suggestion === "promote") {
+      logger.info(
+        `
+  Hint: This memory might be useful for the team. Use 'unforgit promote ${memory.id}' to share it.`
+      );
+    }
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/recall.ts
+import { Command as Command3 } from "commander";
+import { loadConfig as loadConfig2, getDbPath as getDbPath3 } from "unforgit-config";
+import { LocalStore as LocalStore3 } from "unforgit-db";
+import { RemoteClient } from "unforgit-config";
+import { mergeAndRank } from "unforgit-core";
+import { resolveLifecycleConfig } from "unforgit-core";
+import { parsePositiveInt } from "unforgit-config";
+var recallCommand = new Command3("recall").description("Recall memories matching a query").argument("<query>", "Search query").option(
+  "--types <types>",
+  "Comma-separated types (episodic,semantic,procedural)"
+).option("--tags <tags>", "Comma-separated tags to filter").option("-k, --limit <n>", "Max results", "10").option("--remote-only", "Only query remote").option("--local-only", "Only query local").option("--page <n>", "Page number for pagination", "1").option("--per-page <n>", "Items per page", "10").addHelpText("after", `
+Examples:
+  unforgit recall "authentication"             Search all memories
+  unforgit recall "deploy" --types procedural  Filter by type
+  unforgit recall "bug" --tags auth,api        Filter by tags
+  unforgit recall "setup" --local-only         Local search only`).action(async (query, opts) => {
+  if (!query || !query.trim()) {
+    logger.error("Search query cannot be empty.");
+    process.exit(EXIT_ERROR);
+  }
+  const config = loadConfig2();
+  const usageTrackingLimit = resolveLifecycleConfig(config.lifecycle).usageBoost.topKToRecord;
+  const k = parsePositiveInt(opts.limit, "limit");
+  const VALID_TYPES = ["episodic", "semantic", "procedural"];
+  const types = opts.types ? opts.types.split(",").map((t) => t.trim()) : void 0;
+  if (types) {
+    const invalid = types.filter((t) => !VALID_TYPES.includes(t));
+    if (invalid.length > 0) {
+      logger.error(
+        `Invalid memory type(s): ${invalid.join(", ")}. Must be one of: ${VALID_TYPES.join(", ")}`
+      );
+      process.exit(EXIT_ERROR);
+    }
+  }
+  const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0;
+  let localResults = [];
+  let remoteResults = [];
+  const recallQuery = {
+    orgId: config.remote.orgId || "local",
+    repoId: config.remote.repoId || "local",
+    query,
+    types,
+    tags,
+    k
+  };
+  if (!opts.remoteOnly) {
+    let store;
+    try {
+      store = new LocalStore3(getDbPath3());
+      localResults = store.recall(recallQuery);
+      const idsToRecord = localResults.slice(0, usageTrackingLimit).map((result) => result.id);
+      if (idsToRecord.length > 0) {
+        store.recordUsageBatch(idsToRecord, query);
+      }
+    } catch {
+      if (!opts.localOnly) {
+        logger.warn("Local store not available");
+      }
+    } finally {
+      store?.close();
+    }
+  }
+  if (!opts.localOnly && config.remote.url) {
+    try {
+      const client = new RemoteClient(config.remote.url);
+      const response = await client.recall(recallQuery);
+      remoteResults = response.results.map((r) => ({
+        ...r,
+        source: "remote"
+      }));
+    } catch {
+      if (!opts.remoteOnly) {
+        logger.warn("Remote API not available");
+      }
+    }
+  }
+  const results = mergeAndRank(localResults, remoteResults, k);
+  const page = parsePositiveInt(opts.page, "page");
+  const perPage = parsePositiveInt(opts.perPage, "per-page");
+  const paged = paginate(results, page, perPage);
+  if (isJsonMode()) {
+    outputJson({
+      results: paged.items.map((r) => ({
+        id: r.id,
+        source: r.source,
+        type: r.memoryType,
+        score: r.score,
+        text: r.text,
+        tags: r.tags
+      })),
+      page: paged.currentPage,
+      totalPages: paged.totalPages,
+      total: paged.total
+    });
+    return;
+  }
+  if (results.length === 0) {
+    logger.info("No memories found.");
+    return;
+  }
+  logger.info(`Found ${results.length} memories:
+`);
+  for (const r of paged.items) {
+    const sourceTag = r.source === "local" ? "[local]" : "[remote]";
+    logger.info(
+      `${sourceTag} [${r.memoryType}] ${r.id.slice(0, 8)}... (score: ${r.score.toFixed(3)})`
+    );
+    logger.info(`  ${r.text.slice(0, 120)}${r.text.length > 120 ? "..." : ""}`);
+    if (r.tags.length > 0) logger.info(`  Tags: ${r.tags.join(", ")}`);
+    logger.info("");
+  }
+  if (paged.totalPages > 1) {
+    logger.info(`Page ${paged.currentPage}/${paged.totalPages} (${paged.total} total)`);
+  }
+});
+
+// src/commands/promote.ts
+import { Command as Command4 } from "commander";
+import { loadConfig as loadConfig3, getDbPath as getDbPath4 } from "unforgit-config";
+import { LocalStore as LocalStore4 } from "unforgit-db";
+import { RemoteClient as RemoteClient2 } from "unforgit-config";
+var promoteCommand = new Command4("promote").description("Promote a local memory to remote (shared)").argument("<id>", "Memory ID to promote").option("--to <scope>", "Target scope", "repo").option("--source-pr <url>", "Source PR URL").option("--source-commit <sha>", "Source commit SHA").addHelpText("after", `
+Examples:
+  unforgit promote abc123
+  unforgit promote abc123 --source-pr https://github.com/org/repo/pull/42`).action(async (id, opts) => {
+  const config = loadConfig3();
+  if (!config.remote.url) {
+    logger.error("Remote URL not configured. Update unforgit.yaml.");
+    process.exit(EXIT_ERROR);
+  }
+  const store = new LocalStore4(getDbPath4());
+  try {
+    const memory = store.getById(id);
+    if (!memory) {
+      logger.error(`Memory ${id} not found locally.`);
+      process.exit(EXIT_ERROR);
+    }
+    const sourceRefs = { ...memory.sourceRefs ?? {} };
+    if (opts.sourcePr) sourceRefs.pr_url = opts.sourcePr;
+    if (opts.sourceCommit) sourceRefs.commit_sha = opts.sourceCommit;
+    const client = new RemoteClient2(config.remote.url);
+    const result = await client.store({
+      orgId: config.remote.orgId || memory.orgId,
+      repoId: config.remote.repoId || memory.repoId,
+      memoryType: memory.memoryType,
+      text: memory.text,
+      summary: memory.summary,
+      tags: memory.tags,
+      sourceRefs,
+      confidence: memory.confidence,
+      visibility: "repo"
+    });
+    store.updateVisibility(id, "repo");
+    logger.info(`Promoted memory ${id.slice(0, 8)}... to remote.`);
+    logger.info(`  Remote ID: ${result.id}`);
+    logger.info(`  Scope: ${opts.to}`);
+  } catch (err) {
+    logger.error(
+      `Promoting memory: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/consolidate.ts
+import { Command as Command5 } from "commander";
+import { loadConfig as loadConfig4 } from "unforgit-config";
+import { RemoteClient as RemoteClient3 } from "unforgit-config";
+import { parsePositiveInt as parsePositiveInt2 } from "unforgit-config";
+var consolidateCommand = new Command5("consolidate").description("Consolidate episodic memories into semantic/procedural").option("--from-pr <url>", "PR URL to consolidate from").option("--from-commit <sha>", "Commit SHA to consolidate from").option("--last-n <n>", "Consolidate the last N memories").action(async (opts) => {
+  const config = loadConfig4();
+  if (!config.remote.url) {
+    logger.error("Remote URL not configured. Update unforgit.yaml.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const client = new RemoteClient3(config.remote.url);
+  const body = {
+    orgId: config.remote.orgId,
+    repoId: config.remote.repoId
+  };
+  if (opts.fromPr || opts.fromCommit) {
+    body.source = {
+      prUrl: opts.fromPr,
+      commitSha: opts.fromCommit
+    };
+  }
+  if (opts.lastN) {
+    body.lastN = parsePositiveInt2(opts.lastN, "last-n");
+  }
+  try {
+    const result = await client.consolidate(body);
+    logger.info("Consolidation complete:");
+    logger.info(`  Created: ${result.created.length} memories`);
+    logger.info(`  Superseded: ${result.superseded.length} memories`);
+    logger.info(`  Processed: ${result.processedCount} total`);
+    if (result.created.length > 0) {
+      logger.info("\nNew memories:");
+      for (const id of result.created) {
+        logger.info(`  - ${id}`);
+      }
+    }
+  } catch (err) {
+    logger.error(
+      `Consolidating: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(EXIT_ERROR);
+  }
+});
+
+// src/commands/deprecate.ts
+import { Command as Command6 } from "commander";
+import { loadConfig as loadConfig5, getDbPath as getDbPath5 } from "unforgit-config";
+import { LocalStore as LocalStore5 } from "unforgit-db";
+import { RemoteClient as RemoteClient4 } from "unforgit-config";
+var deprecateCommand = new Command6("deprecate").description("Mark a memory as deprecated").argument("<id>", "Memory ID to deprecate").option("--reason <reason>", "Reason for deprecation").option("--remote", "Deprecate on remote").addHelpText("after", `
+Examples:
+  unforgit deprecate abc123 --reason "No longer relevant"
+  unforgit deprecate abc123 --remote`).action(async (id, opts) => {
+  if (opts.remote) {
+    const config = loadConfig5();
+    const client = new RemoteClient4(config.remote.url);
+    try {
+      await client.deprecate(id, opts.reason);
+      logger.info(`Deprecated remote memory ${id.slice(0, 8)}...`);
+      if (opts.reason) logger.info(`  Reason: ${opts.reason}`);
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore5(getDbPath5());
+  try {
+    const memory = store.getById(id);
+    if (!memory) {
+      logger.error(`Memory ${id} not found.`);
+      process.exit(EXIT_ERROR);
+    }
+    if (memory.status === "deprecated") {
+      logger.warn(`Memory ${id.slice(0, 8)} is already deprecated.`);
+      return;
+    }
+    const ok = store.deprecate(id, opts.reason);
+    if (!ok) {
+      logger.error(`Memory ${id} not found.`);
+      process.exit(EXIT_ERROR);
+    }
+    logger.info(`Deprecated local memory ${id.slice(0, 8)}...`);
+    if (opts.reason) logger.info(`  Reason: ${opts.reason}`);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/supersede.ts
+import { Command as Command7 } from "commander";
+import { loadConfig as loadConfig6, getDbPath as getDbPath6 } from "unforgit-config";
+import { LocalStore as LocalStore6 } from "unforgit-db";
+import { RemoteClient as RemoteClient5 } from "unforgit-config";
+var supersedeCommand = new Command7("supersede").description("Mark a memory as superseded by another").argument("<old-id>", "Memory ID being superseded").requiredOption("--with <new-id>", "ID of the new memory that replaces it").option("--remote", "Supersede on remote").option("--force", "Skip confirmation").addHelpText("after", `
+Examples:
+  unforgit supersede abc123 --with def456
+  unforgit supersede abc123 --with def456 --remote`).action(async (oldId, opts) => {
+  if (oldId === opts.with) {
+    logger.error("A memory cannot supersede itself.");
+    process.exit(EXIT_ERROR);
+  }
+  if (!opts.force) {
+    const confirmed = await confirm(
+      `Supersede memory ${oldId.slice(0, 8)}... with ${opts.with.slice(0, 8)}...?`
+    );
+    if (!confirmed) {
+      logger.info("Supersede cancelled.");
+      return;
+    }
+  }
+  if (opts.remote) {
+    const config = loadConfig6();
+    const client = new RemoteClient5(config.remote.url);
+    try {
+      await client.supersede(oldId, opts.with);
+      logger.info(
+        `Superseded remote memory ${oldId.slice(0, 8)}... with ${opts.with.slice(0, 8)}...`
+      );
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore6(getDbPath6());
+  try {
+    const ok = store.supersede(oldId, opts.with);
+    if (!ok) {
+      logger.error(`Memory ${oldId} not found.`);
+      process.exit(EXIT_ERROR);
+    }
+    logger.info(
+      `Superseded local memory ${oldId.slice(0, 8)}... with ${opts.with.slice(0, 8)}...`
+    );
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/delete.ts
+import { Command as Command8 } from "commander";
+import { loadConfig as loadConfig7, getDbPath as getDbPath7 } from "unforgit-config";
+import { LocalStore as LocalStore7 } from "unforgit-db";
+import { RemoteClient as RemoteClient6 } from "unforgit-config";
+var deleteCommand = new Command8("delete").description("Soft delete a memory (can be restored)").argument("<id>", "Memory ID to delete").option("--hard", "Permanently delete (cannot be restored)").option("--remote", "Delete on remote").option("--by <author>", "Author of the deletion").option("--force", "Skip confirmation for hard delete").addHelpText("after", `
+Examples:
+  unforgit delete abc12345              Soft delete (can be restored)
+  unforgit delete abc12345 --hard       Permanent delete
+  unforgit delete abc12345 --remote     Delete on remote server`).action(async (id, opts) => {
+  if (opts.hard && !opts.force) {
+    const confirmed = await confirm(
+      `Permanently delete memory ${id.slice(0, 8)}...? This cannot be undone.`
+    );
+    if (!confirmed) {
+      logger.info("Delete cancelled.");
+      return;
+    }
+  }
+  if (opts.remote) {
+    const config = loadConfig7();
+    const client = new RemoteClient6(config.remote.url);
+    try {
+      await client.delete(id, opts.by, opts.hard);
+      const action = opts.hard ? "Hard deleted" : "Soft deleted";
+      logger.info(`${action} remote memory ${id.slice(0, 8)}...`);
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore7(getDbPath7());
+  try {
+    let ok;
+    if (opts.hard) {
+      ok = store.hardDelete(id);
+    } else {
+      ok = store.softDelete({ id, deletedBy: opts.by });
+    }
+    if (!ok) {
+      logger.error(`Memory ${id} not found.`);
+      process.exit(EXIT_ERROR);
+    }
+    const action = opts.hard ? "Hard deleted" : "Soft deleted";
+    logger.info(`${action} local memory ${id.slice(0, 8)}...`);
+    if (!opts.hard) {
+      logger.info("  This memory can be restored with 'unforgit restore'.");
+    }
+  } finally {
+    store.close();
+  }
+});
+var restoreCommand = new Command8("restore").description("Restore a soft-deleted memory").argument("<id>", "Memory ID to restore").option("--remote", "Restore on remote").action(async (id, opts) => {
+  if (opts.remote) {
+    const config = loadConfig7();
+    const client = new RemoteClient6(config.remote.url);
+    try {
+      await client.restore(id);
+      logger.info(`Restored remote memory ${id.slice(0, 8)}...`);
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore7(getDbPath7());
+  try {
+    const ok = store.restore(id);
+    if (!ok) {
+      logger.error(`Memory ${id} not found or not deleted.`);
+      process.exit(EXIT_ERROR);
+    }
+    logger.info(`Restored local memory ${id.slice(0, 8)}...`);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/web.ts
+import { Command as Command9 } from "commander";
+import { spawn } from "child_process";
+import path2 from "path";
+import fs3 from "fs";
+import { isInitialized as isInitialized2 } from "unforgit-config";
+var webCommand = new Command9("web").description("Start the Unforgit web dashboard").option("-p, --port <port>", "Port to run on", "3838").option("--no-open", "Don't open browser automatically").action(async (opts) => {
+  const cwd4 = process.cwd();
+  if (!isInitialized2(cwd4)) {
+    logger.error("Unforgit not initialized in this directory. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const webDir = findWebDir();
+  if (!webDir) {
+    logger.error("Web dashboard not found. Make sure unforgit is installed correctly.");
+    process.exit(EXIT_ERROR);
+  }
+  const env = {
+    ...process.env,
+    UNFORGIT_WORKSPACE: cwd4,
+    PORT: opts.port
+  };
+  const dotenvPath = path2.join(cwd4, ".env");
+  if (fs3.existsSync(dotenvPath)) {
+    const content = fs3.readFileSync(dotenvPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const match = line.match(/^\s*([^#=]+?)\s*=\s*(.+?)\s*$/);
+      if (match) {
+        env[match[1]] = match[2].replace(/^["']|["']$/g, "");
+      }
+    }
+  }
+  logger.info(`Starting Unforgit web dashboard on port ${opts.port}...`);
+  logger.info(`Workspace: ${cwd4}`);
+  const hasNextBuild = fs3.existsSync(path2.join(webDir, ".next"));
+  const cmd = hasNextBuild ? "next" : "next";
+  const args = hasNextBuild ? ["start", "-p", opts.port] : ["dev", "-p", opts.port];
+  const nextBin = path2.join(webDir, "node_modules", ".bin", "next");
+  const finalCmd = fs3.existsSync(nextBin) ? nextBin : cmd;
+  const child = spawn(finalCmd, args, {
+    cwd: webDir,
+    env,
+    stdio: "inherit"
+  });
+  if (opts.open !== false) {
+    setTimeout(() => {
+      const url = `http://localhost:${opts.port}`;
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      spawn(openCmd, [url], { stdio: "ignore", detached: true }).unref();
+    }, 2e3);
+  }
+  child.on("error", (err) => {
+    logger.fatal(`Failed to start web dashboard: ${err.message}`);
+    process.exit(EXIT_ERROR);
+  });
+  child.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+});
+function findWebDir() {
+  const candidates = [
+    path2.resolve(import.meta.dirname, "../../../web"),
+    path2.resolve(import.meta.dirname, "../../web"),
+    path2.join(process.cwd(), "web")
+  ];
+  for (const dir of candidates) {
+    if (fs3.existsSync(dir) && fs3.existsSync(path2.join(dir, "package.json"))) {
+      return dir;
+    }
+  }
+  return null;
+}
+
+// src/commands/link.ts
+import { Command as Command10 } from "commander";
+import { loadConfig as loadConfig8, getDbPath as getDbPath8 } from "unforgit-config";
+import { LocalStore as LocalStore8 } from "unforgit-db";
+import { RemoteClient as RemoteClient7 } from "unforgit-config";
+var VALID_LINK_TYPES = [
+  "related_to",
+  "derived_from",
+  "contradicts",
+  "depends_on"
+];
+var linkCommand = new Command10("link").description("Create a link between two memories").argument("<source-id>", "Source memory ID").argument("<target-id>", "Target memory ID").requiredOption(
+  "--type <link-type>",
+  "Link type (related_to, derived_from, contradicts, depends_on)"
+).option("--remote", "Create link on remote").addHelpText("after", `
+Examples:
+  unforgit link abc123 def456 --type related_to
+  unforgit link abc123 def456 --type derived_from --remote`).action(async (sourceId, targetId, opts) => {
+  if (!VALID_LINK_TYPES.includes(opts.type)) {
+    logger.error(
+      `Invalid link type "${opts.type}". Must be one of: ${VALID_LINK_TYPES.join(", ")}`
+    );
+    process.exit(EXIT_ERROR);
+  }
+  if (sourceId === targetId) {
+    logger.error("Cannot link a memory to itself.");
+    process.exit(EXIT_ERROR);
+  }
+  if (opts.remote) {
+    const config = loadConfig8();
+    const client = new RemoteClient7(config.remote.url);
+    try {
+      const result = await client.link(sourceId, targetId, opts.type);
+      logger.info(
+        `Linked remote: ${sourceId.slice(0, 8)} --[${opts.type}]--> ${targetId.slice(0, 8)} (${result.link.id.slice(0, 8)})`
+      );
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore8(getDbPath8());
+  try {
+    const source = store.getById(sourceId);
+    if (!source) {
+      logger.error(`Source memory ${sourceId} not found.`);
+      process.exit(EXIT_ERROR);
+    }
+    if (source.status === "deleted") {
+      logger.error(`Source memory ${sourceId.slice(0, 8)} is deleted. Restore it first.`);
+      process.exit(EXIT_ERROR);
+    }
+    const target = store.getById(targetId);
+    if (!target) {
+      logger.error(`Target memory ${targetId} not found.`);
+      process.exit(EXIT_ERROR);
+    }
+    if (target.status === "deleted") {
+      logger.error(`Target memory ${targetId.slice(0, 8)} is deleted. Restore it first.`);
+      process.exit(EXIT_ERROR);
+    }
+    const link = store.link({
+      sourceId,
+      targetId,
+      linkType: opts.type
+    });
+    logger.info(
+      `Linked: ${sourceId.slice(0, 8)} --[${opts.type}]--> ${targetId.slice(0, 8)} (${link.id.slice(0, 8)})`
+    );
+  } catch (err) {
+    logger.error(
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+var unlinkCommand = new Command10("unlink").description("Remove a link between two memories").argument("<source-id>", "Source memory ID").argument("<target-id>", "Target memory ID").requiredOption(
+  "--type <link-type>",
+  "Link type (related_to, derived_from, contradicts, depends_on)"
+).option("--remote", "Remove link on remote").action(async (sourceId, targetId, opts) => {
+  if (!VALID_LINK_TYPES.includes(opts.type)) {
+    logger.error(
+      `Invalid link type "${opts.type}". Must be one of: ${VALID_LINK_TYPES.join(", ")}`
+    );
+    process.exit(EXIT_ERROR);
+  }
+  if (opts.remote) {
+    const config = loadConfig8();
+    const client = new RemoteClient7(config.remote.url);
+    try {
+      await client.unlink(sourceId, targetId, opts.type);
+      logger.info(
+        `Unlinked remote: ${sourceId.slice(0, 8)} --[${opts.type}]--> ${targetId.slice(0, 8)}`
+      );
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore8(getDbPath8());
+  try {
+    const ok = store.unlink(sourceId, targetId, opts.type);
+    if (!ok) {
+      logger.error("Link not found.");
+      process.exit(EXIT_ERROR);
+    }
+    logger.info(
+      `Unlinked: ${sourceId.slice(0, 8)} --[${opts.type}]--> ${targetId.slice(0, 8)}`
+    );
+  } finally {
+    store.close();
+  }
+});
+var linksCommand = new Command10("links").description("List all links for a memory").argument("<memory-id>", "Memory ID to get links for").option(
+  "--type <link-type>",
+  "Filter by link type (related_to, derived_from, contradicts, depends_on)"
+).option("--remote", "List links on remote").action(async (memoryId, opts) => {
+  if (opts.type && !VALID_LINK_TYPES.includes(opts.type)) {
+    logger.error(
+      `Invalid link type "${opts.type}". Must be one of: ${VALID_LINK_TYPES.join(", ")}`
+    );
+    process.exit(EXIT_ERROR);
+  }
+  if (opts.remote) {
+    const config = loadConfig8();
+    const client = new RemoteClient7(config.remote.url);
+    try {
+      const result = await client.getLinks(memoryId, opts.type);
+      if (isJsonMode()) {
+        outputJson(result);
+        return;
+      }
+      if (result.links.length === 0) {
+        logger.info("No links found.");
+        return;
+      }
+      logger.info(`Found ${result.links.length} links:
+`);
+      for (const l of result.links) {
+        const direction = l.sourceId === memoryId ? `--[${l.linkType}]--> ${l.targetId.slice(0, 8)}` : `<--[${l.linkType}]-- ${l.sourceId.slice(0, 8)}`;
+        logger.info(`  ${l.id.slice(0, 8)}: ${direction}`);
+      }
+    } catch (err) {
+      logger.error(
+        err instanceof Error ? err.message : String(err)
+      );
+      process.exit(EXIT_ERROR);
+    }
+    return;
+  }
+  const store = new LocalStore8(getDbPath8());
+  try {
+    const links = store.getLinks({
+      memoryId,
+      linkType: opts.type
+    });
+    if (isJsonMode()) {
+      outputJson({
+        links: links.map((l) => ({
+          id: l.id,
+          sourceId: l.sourceId,
+          targetId: l.targetId,
+          linkType: l.linkType
+        }))
+      });
+      return;
+    }
+    if (links.length === 0) {
+      logger.info("No links found.");
+      return;
+    }
+    logger.info(`Found ${links.length} links:
+`);
+    for (const l of links) {
+      const direction = l.sourceId === memoryId ? `--[${l.linkType}]--> ${l.targetId.slice(0, 8)}` : `<--[${l.linkType}]-- ${l.sourceId.slice(0, 8)}`;
+      logger.info(`  ${l.id.slice(0, 8)}: ${direction}`);
+    }
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/merge.ts
+import { Command as Command11 } from "commander";
+import { LocalStore as LocalStore9 } from "unforgit-db";
+import { loadConfig as loadConfig9, getDbPath as getDbPath9, isInitialized as isInitialized3 } from "unforgit-config";
+import {
+  parseThreshold,
+  parsePositiveInt as parsePositiveInt3,
+  validateMemoryType as validateMemoryType2
+} from "unforgit-config";
+var cwd = process.cwd();
+var mergeCommand = new Command11("merge").description(
+  "Consolidate multiple local memories into one unified memory while preserving history"
+).argument("<ids...>", "Memory IDs to consolidate (minimum 2)").requiredOption(
+  "-t, --text <text>",
+  "Consolidated text combining insights from source memories"
+).option(
+  "--type <type>",
+  "Memory type for consolidated memory (episodic, semantic, procedural)"
+).option("--tags <tags>", "Comma-separated tags for the consolidated memory").option(
+  "--no-supersede",
+  "Do not mark original memories as superseded"
+).action(async (ids, opts) => {
+  if (!isInitialized3(cwd)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  if (ids.length < 2) {
+    logger.error("At least 2 memory IDs are required for merge.");
+    process.exit(EXIT_ERROR);
+  }
+  if (opts.type && !validateMemoryType2(opts.type)) {
+    logger.error("--type must be one of: episodic, semantic, procedural");
+    process.exit(EXIT_ERROR);
+  }
+  const config = loadConfig9(cwd);
+  const store = new LocalStore9(getDbPath9(cwd));
+  try {
+    for (const id of ids) {
+      const mem = store.getById(id);
+      if (!mem) {
+        logger.error(`Memory ${id} not found.`);
+        process.exit(EXIT_ERROR);
+      }
+      if (mem.status === "deleted") {
+        logger.error(`Memory ${id.slice(0, 8)} is deleted. Restore it before merging.`);
+        process.exit(EXIT_ERROR);
+      }
+      if (mem.status === "superseded") {
+        logger.error(`Memory ${id.slice(0, 8)} is already superseded. Cannot merge superseded memories.`);
+        process.exit(EXIT_ERROR);
+      }
+    }
+    const result = store.consolidateMemories({
+      orgId: config.remote.orgId || "local",
+      repoId: config.remote.repoId || "local",
+      sourceIds: ids,
+      consolidatedText: opts.text,
+      memoryType: opts.type,
+      tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0,
+      preserveOriginals: opts.supersede !== false
+    });
+    logger.info("Merge complete!");
+    logger.info(`  Consolidated ID: ${result.consolidatedId}`);
+    logger.info(`  Version: ${result.version}`);
+    logger.info(`  Sources preserved: ${result.sourcesPreserved}`);
+    logger.info(
+      `  Source IDs: ${result.sourceIds.map((id) => id.slice(0, 8)).join(", ")}`
+    );
+    logger.info("");
+    logger.info(
+      "Original memories are linked via 'derived_from' and marked as 'superseded'."
+    );
+    logger.info("Use 'unforgit history <id>' to view the consolidation history.");
+  } catch (err) {
+    logger.error(
+      `Merging memories: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+var remergeCommand = new Command11("remerge").description(
+  "Update an existing consolidation with new information or additional sources"
+).argument("<consolidation-id>", "ID of existing consolidated memory to update").requiredOption("-t, --text <text>", "Updated consolidated text").option(
+  "--add <ids>",
+  "Comma-separated IDs of additional memories to include"
+).option("--tags <tags>", "Comma-separated tags (keeps existing if not provided)").action(async (consolidationId, opts) => {
+  if (!isInitialized3(cwd)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig9(cwd);
+  const store = new LocalStore9(getDbPath9(cwd));
+  try {
+    const result = store.reconsolidate({
+      orgId: config.remote.orgId || "local",
+      repoId: config.remote.repoId || "local",
+      existingConsolidationId: consolidationId,
+      additionalSourceIds: opts.add ? opts.add.split(",").map((t) => t.trim()) : void 0,
+      newText: opts.text,
+      tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0
+    });
+    logger.info("Remerge complete!");
+    logger.info(`  New consolidated ID: ${result.consolidatedId}`);
+    logger.info(`  New version: ${result.version}`);
+    logger.info(`  Total sources: ${result.sourcesPreserved}`);
+    logger.info(
+      `  Previous consolidation: ${consolidationId.slice(0, 8)} (now superseded)`
+    );
+    logger.info("");
+    logger.info("Use 'unforgit history <id>' to view all versions.");
+  } catch (err) {
+    logger.error(
+      `Remerging: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+var similarCommand = new Command11("similar").description("Find memories similar to a given memory (candidates for merging)").argument("<memory-id>", "Memory ID to find similar ones for").option(
+  "-k, --limit <n>",
+  "Max number of similar memories to return",
+  "10"
+).option(
+  "--threshold <score>",
+  "Minimum similarity score (0-1)",
+  "0.3"
+).addHelpText("after", `
+Examples:
+  unforgit similar abc123
+  unforgit similar abc123 --threshold 0.5 -k 5`).action(async (memoryId, opts) => {
+  if (!isInitialized3(cwd)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig9(cwd);
+  const store = new LocalStore9(getDbPath9(cwd));
+  try {
+    const similar = store.findSimilar({
+      orgId: config.remote.orgId || "local",
+      repoId: config.remote.repoId || "local",
+      memoryId,
+      threshold: parseThreshold(opts.threshold),
+      k: parsePositiveInt3(opts.limit, "limit")
+    });
+    if (isJsonMode()) {
+      outputJson({
+        results: similar.map((m) => ({
+          id: m.id,
+          type: m.memoryType,
+          score: m.score,
+          text: m.text,
+          tags: m.tags
+        }))
+      });
+      return;
+    }
+    if (similar.length === 0) {
+      logger.info("No similar memories found.");
+      return;
+    }
+    logger.info(`Found ${similar.length} similar memories:
+`);
+    for (const mem of similar) {
+      logger.info(
+        `[${mem.memoryType}] ${mem.id.slice(0, 8)} (score: ${mem.score.toFixed(3)})`
+      );
+      logger.info(`  ${mem.text.slice(0, 100)}${mem.text.length > 100 ? "..." : ""}`);
+      if (mem.tags.length > 0) {
+        logger.info(`  Tags: ${mem.tags.join(", ")}`);
+      }
+      logger.info("");
+    }
+    logger.info(`Tip: Use 'unforgit merge <id1> <id2> ... -t "merged text"' to consolidate.`);
+  } catch (err) {
+    logger.error(
+      `Finding similar: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+var historyCommand = new Command11("history").description("Show consolidation history for a memory").argument("<memory-id>", "Memory ID to show history for").action(async (memoryId) => {
+  if (!isInitialized3(cwd)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const store = new LocalStore9(getDbPath9(cwd));
+  try {
+    const memory = store.getById(memoryId);
+    if (!memory) {
+      logger.error("Memory not found.");
+      process.exit(EXIT_ERROR);
+    }
+    logger.info(`Memory: ${memory.id.slice(0, 8)}`);
+    logger.info(`Type: ${memory.memoryType}`);
+    logger.info(`Status: ${memory.status}`);
+    logger.info(`Is Consolidation: ${memory.isConsolidation ? "Yes" : "No"}`);
+    if (memory.isConsolidation) {
+      logger.info(`Version: ${memory.consolidationVersion ?? 1}`);
+      logger.info(`Text: ${memory.text}`);
+      const sources = store.getConsolidatedSources(memoryId);
+      if (sources.length > 0) {
+        logger.info("\nSource memories:");
+        for (const src of sources) {
+          logger.info(
+            `  \u2514\u2500 [${src.memoryType}] ${src.id.slice(0, 8)}: ${src.text.slice(0, 60)}...`
+          );
+        }
+      }
+      const history = store.getConsolidationHistory(memoryId);
+      const previousVersions = history.filter((h) => h.isConsolidation);
+      if (previousVersions.length > 0) {
+        logger.info("\nPrevious consolidation versions:");
+        for (const prev of previousVersions) {
+          logger.info(
+            `  \u2514\u2500 v${prev.consolidationVersion ?? 1} (${prev.id.slice(0, 8)}): ${prev.text.slice(0, 60)}...`
+          );
+        }
+      }
+    } else {
+      logger.info(`Text: ${memory.text}`);
+      const links = store.getLinks({ memoryId, linkType: "derived_from" });
+      const consolidations = links.filter((l) => l.targetId === memoryId);
+      if (consolidations.length > 0) {
+        logger.info("\nIncluded in consolidations:");
+        for (const link of consolidations) {
+          const consol = store.getById(link.sourceId);
+          if (consol) {
+            logger.info(
+              `  \u2514\u2500 v${consol.consolidationVersion ?? 1} (${consol.id.slice(0, 8)}): ${consol.text.slice(0, 60)}...`
+            );
+          }
+        }
+      }
+    }
+  } catch (err) {
+    logger.error(
+      `Fetching history: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/auto-consolidate.ts
+import { Command as Command12 } from "commander";
+import { LocalStore as LocalStore10 } from "unforgit-db";
+import { loadConfig as loadConfig10, getDbPath as getDbPath10, isInitialized as isInitialized4 } from "unforgit-config";
+import {
+  findConsolidationCandidates,
+  executeConsolidation,
+  formatCandidatePreview
+} from "unforgit-core";
+import * as readline2 from "readline";
+import {
+  parseThreshold as parseThreshold2,
+  parsePositiveInt as parsePositiveInt4,
+  validateMemoryType as validateMemoryType3
+} from "unforgit-config";
+var cwd2 = process.cwd();
+function createReadlineInterface() {
+  return readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+async function askConfirmation(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+var autoConsolidateCommand = new Command12("auto-consolidate").description(
+  "Automatically find and consolidate similar memories using AI"
+).option(
+  "--threshold <score>",
+  "Minimum similarity score (0-1)",
+  "0.4"
+).option(
+  "--min-group <n>",
+  "Minimum group size for consolidation",
+  "2"
+).option(
+  "--max-groups <n>",
+  "Maximum number of groups to process",
+  "10"
+).option(
+  "--type <type>",
+  "Filter by memory type (episodic, semantic, procedural)"
+).option(
+  "--dry-run",
+  "Show preview without consolidating"
+).option(
+  "-y, --yes",
+  "Skip confirmation prompts"
+).option(
+  "--model <model>",
+  "OpenAI model to use",
+  "gpt-5.4"
+).option(
+  "--no-preserve",
+  "Do not preserve original memories (hard delete)"
+).action(async (opts) => {
+  if (!isInitialized4(cwd2)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  if (opts.type && !validateMemoryType3(opts.type)) {
+    logger.error("--type must be one of: episodic, semantic, procedural");
+    process.exit(EXIT_ERROR);
+  }
+  const config = loadConfig10(cwd2);
+  const store = new LocalStore10(getDbPath10(cwd2));
+  const orgId = config.remote.orgId || "local";
+  const repoId = config.remote.repoId || "local";
+  const threshold = parseThreshold2(opts.threshold);
+  const minGroupSize = parsePositiveInt4(opts.minGroup, "min-group");
+  const maxGroups = parsePositiveInt4(opts.maxGroups, "max-groups");
+  const types = opts.type ? [opts.type] : void 0;
+  try {
+    logger.info("Scanning memories for consolidation candidates...\n");
+    const result = findConsolidationCandidates(store, orgId, repoId, {
+      threshold,
+      minGroupSize,
+      maxGroups,
+      types,
+      excludeConsolidations: true
+    });
+    logger.info(`Scanned ${result.totalMemoriesScanned} active memories`);
+    logger.info(`Found ${result.totalCandidateGroups} potential groups`);
+    logger.info(`Showing top ${result.candidates.length} candidates
+`);
+    if (result.candidates.length === 0) {
+      logger.info("No consolidation candidates found.");
+      logger.info(
+        "Try lowering the threshold (--threshold 0.3) or the minimum group size (--min-group 2)."
+      );
+      return;
+    }
+    for (let i = 0; i < result.candidates.length; i++) {
+      const candidate = result.candidates[i];
+      logger.info(`
+${"=".repeat(60)}`);
+      logger.info(`Candidate ${i + 1}/${result.candidates.length}`);
+      logger.info("=".repeat(60));
+      logger.info(formatCandidatePreview(candidate));
+    }
+    if (opts.dryRun) {
+      logger.info("\n[Dry run mode - no changes made]");
+      logger.info(
+        "Remove --dry-run flag to consolidate these memories."
+      );
+      return;
+    }
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (!openaiKey) {
+      logger.error("OpenAI API key not set.");
+      logger.error("Set the OPENAI_API_KEY environment variable.");
+      process.exit(EXIT_ERROR);
+    }
+    process.env.OPENAI_API_KEY = openaiKey;
+    const rl = createReadlineInterface();
+    let consolidatedCount = 0;
+    let skippedCount = 0;
+    try {
+      for (let i = 0; i < result.candidates.length; i++) {
+        const candidate = result.candidates[i];
+        if (!opts.yes) {
+          logger.info(`
+${"\u2500".repeat(60)}`);
+          logger.info(`Processing candidate ${i + 1}/${result.candidates.length}`);
+          logger.info(formatCandidatePreview(candidate));
+          const shouldConsolidate = await askConfirmation(
+            rl,
+            "\nConsolidate this group? [y/N] "
+          );
+          if (!shouldConsolidate) {
+            logger.info("Skipped.");
+            skippedCount++;
+            logger.progress(i + 1, result.candidates.length, "candidates");
+            continue;
+          }
+        }
+        logger.info("\nGenerating consolidated text with AI...");
+        try {
+          const execResult = await executeConsolidation(
+            store,
+            candidate,
+            orgId,
+            repoId,
+            {
+              model: opts.model,
+              preserveOriginals: opts.preserve !== false
+            }
+          );
+          logger.info("\nConsolidation complete!");
+          logger.info(`  New memory ID: ${execResult.consolidatedId}`);
+          logger.info(`  Type: ${execResult.memoryType}`);
+          logger.info(`  Tags: ${execResult.suggestedTags.join(", ") || "none"}`);
+          logger.info(`  Sources consolidated: ${execResult.sourceIds.length}`);
+          logger.info(`
+Generated text:`);
+          logger.info(`  ${execResult.generatedText}`);
+          consolidatedCount++;
+        } catch (err) {
+          logger.error(
+            `Consolidating: ${err instanceof Error ? err.message : err}`
+          );
+          skippedCount++;
+        }
+        logger.progress(i + 1, result.candidates.length, "candidates");
+      }
+    } finally {
+      rl.close();
+    }
+    logger.info(`
+${"=".repeat(60)}`);
+    logger.info("Summary");
+    logger.info("=".repeat(60));
+    logger.info(`Consolidated: ${consolidatedCount} groups`);
+    logger.info(`Skipped: ${skippedCount} groups`);
+    logger.info(
+      `
+Original memories are preserved with status 'superseded'.`
+    );
+    logger.info("Use 'unforgit history <id>' to view consolidation history.");
+  } catch (err) {
+    logger.error(
+      `Auto-consolidate: ${err instanceof Error ? err.message : err}`
+    );
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/unconsolidate.ts
+import { Command as Command13 } from "commander";
+import { getDbPath as getDbPath11, isInitialized as isInitialized5 } from "unforgit-config";
+import { LocalStore as LocalStore11 } from "unforgit-db";
+var unconsolidateCommand = new Command13("unconsolidate").description("Revert a consolidation, restoring original memories to active status").argument("<consolidation-id>", "ID of the consolidated memory to revert").option("--dry-run", "Show what would be restored without making changes").option("--force", "Skip confirmation").addHelpText("after", `
+Examples:
+  unforgit unconsolidate abc123 --dry-run   Preview what would be restored
+  unforgit unconsolidate abc123             Revert a consolidation`).action(async (consolidationId, opts) => {
+  const cwd4 = process.cwd();
+  if (!isInitialized5(cwd4)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const dbPath = getDbPath11(cwd4);
+  const store = new LocalStore11(dbPath);
+  try {
+    const memory = store.getById(consolidationId);
+    if (!memory) {
+      logger.error(`Memory not found: ${consolidationId}`);
+      process.exit(EXIT_ERROR);
+    }
+    if (!memory.isConsolidation) {
+      logger.error(`Memory ${consolidationId} is not a consolidation.`);
+      logger.error("Only consolidated memories can be unconsolidated.");
+      process.exit(EXIT_ERROR);
+    }
+    const sourceLinks = store.getLinks({ memoryId: consolidationId, linkType: "derived_from" });
+    const sourceIds = sourceLinks.filter((l) => l.sourceId === consolidationId).map((l) => l.targetId);
+    logger.info(`Consolidation: ${consolidationId.slice(0, 8)}`);
+    logger.info(`Version: ${memory.consolidationVersion ?? 1}`);
+    logger.info(`Source memories: ${sourceIds.length}`);
+    if (sourceIds.length === 0) {
+      logger.error("No source memories found for this consolidation.");
+      process.exit(EXIT_ERROR);
+    }
+    logger.info("Source memories to restore:");
+    for (const sourceId of sourceIds) {
+      const source = store.getById(sourceId);
+      if (source) {
+        const status = source.status === "superseded" ? "will restore" : `${source.status} (no change)`;
+        const preview = source.text.slice(0, 60) + (source.text.length > 60 ? "..." : "");
+        logger.info(`  - ${sourceId.slice(0, 8)} [${source.memoryType}] (${status})`);
+        logger.info(`    ${preview}`);
+      }
+    }
+    logger.info("");
+    if (opts.dryRun) {
+      logger.info("[Dry run - no changes made]");
+      logger.info("Run without --dry-run to execute the unconsolidation.");
+      return;
+    }
+    if (!opts.force) {
+      const confirmed = await confirm(
+        `Revert consolidation ${consolidationId.slice(0, 8)}... and restore ${sourceIds.length} source memories?`
+      );
+      if (!confirmed) {
+        logger.info("Unconsolidation cancelled.");
+        return;
+      }
+    }
+    const result = store.unconsolidate(consolidationId);
+    logger.info("Unconsolidation complete:");
+    logger.info(`  Restored: ${result.restoredIds.length} memories`);
+    logger.info(`  Links removed: ${result.linksRemoved}`);
+    logger.info(`  Consolidation deleted: ${result.consolidationDeleted ? "Yes" : "No"}`);
+    if (result.restoredIds.length > 0) {
+      logger.info("\nRestored memories:");
+      for (const id of result.restoredIds) {
+        logger.info(`  - ${id.slice(0, 8)}`);
+      }
+    }
+    logger.info("\nThe consolidated memory has been soft-deleted and can be restored with 'unforgit restore'.");
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/status.ts
+import { Command as Command14 } from "commander";
+import { loadConfig as loadConfig11, getDbPath as getDbPath12, isInitialized as isInitialized6 } from "unforgit-config";
+import { LocalStore as LocalStore12 } from "unforgit-db";
+var statusCommand = new Command14("status").description("Show the working tree status (pending sync state)").option("-s, --short", "Give the output in short format").addHelpText("after", `
+Examples:
+  unforgit status         Show full sync status
+  unforgit status -s      Short format
+  unforgit status --json  Machine-readable output`).action((opts) => {
+  if (!isInitialized6()) {
+    logger.fatal("not an unforgit repository (or any of the parent directories)");
+    logger.fatal("Run 'unforgit init' to initialize.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig11();
+  const store = new LocalStore12(getDbPath12());
+  try {
+    const orgId = config.remote.orgId || "local";
+    const repoId = config.remote.repoId || "local";
+    const remoteUrl = config.remote.url;
+    const remoteName = "origin";
+    const pendingPush = store.getPendingPush();
+    const conflicts = store.getConflicts();
+    const untracked = store.getUntrackedMemories(orgId, repoId);
+    const summary = store.getSyncSummary(orgId, repoId);
+    if (isJsonMode()) {
+      outputJson({
+        remote: remoteUrl || null,
+        pendingPush: pendingPush.length,
+        conflicts: conflicts.length,
+        untracked: untracked.length,
+        synced: summary.synced
+      });
+      return;
+    }
+    if (opts.short) {
+      printShortStatus(pendingPush, conflicts, untracked);
+    } else {
+      printLongStatus(remoteName, remoteUrl, pendingPush, conflicts, untracked, summary);
+    }
+  } finally {
+    store.close();
+  }
+});
+function printShortStatus(pendingPush, conflicts, untracked) {
+  for (const { memory } of pendingPush) {
+    logger.info(`M  ${memory.id.slice(0, 8)} ${truncate(memory.text, 50)}`);
+  }
+  for (const { memory } of conflicts) {
+    logger.info(`C  ${memory.id.slice(0, 8)} ${truncate(memory.text, 50)}`);
+  }
+  for (const memory of untracked) {
+    logger.info(`?? ${memory.id.slice(0, 8)} ${truncate(memory.text, 50)}`);
+  }
+}
+function printLongStatus(remoteName, remoteUrl, pendingPush, conflicts, untracked, summary) {
+  if (remoteUrl) {
+    logger.info(`Remote '${remoteName}' at ${remoteUrl}`);
+  } else {
+    logger.info("No remote configured. Use 'unforgit remote add origin <url>' to add one.");
+  }
+  logger.info("");
+  if (pendingPush.length === 0 && conflicts.length === 0 && untracked.length === 0) {
+    logger.info("Nothing to push, working tree clean");
+    if (summary.synced > 0) {
+      logger.info(`  ${summary.synced} memories synced with remote`);
+    }
+    return;
+  }
+  if (pendingPush.length > 0) {
+    logger.info("Changes to be pushed:");
+    logger.info('  (use "unforgit push" to sync with remote)');
+    logger.info("");
+    for (const { memory } of pendingPush) {
+      const action = memory.status === "active" ? "new memory" : "modified";
+      logger.info(`        ${action}:   ${memory.id.slice(0, 8)}... "${truncate(memory.text, 40)}"`);
+    }
+    logger.info("");
+  }
+  if (conflicts.length > 0) {
+    logger.info("Conflicts:");
+    logger.info('  (use "unforgit push --force" to overwrite remote or "unforgit pull --force" to accept remote)');
+    logger.info("");
+    for (const { memory } of conflicts) {
+      logger.info(`        conflict:  ${memory.id.slice(0, 8)}... "${truncate(memory.text, 40)}"`);
+    }
+    logger.info("");
+  }
+  if (untracked.length > 0) {
+    logger.info("Untracked memories:");
+    logger.info("  (these memories were created before sync tracking was enabled)");
+    logger.info('  (use "unforgit push" to sync them)');
+    logger.info("");
+    for (const memory of untracked) {
+      logger.info(`        ${memory.id.slice(0, 8)}... "${truncate(memory.text, 40)}"`);
+    }
+    logger.info("");
+  }
+  const total = pendingPush.length + conflicts.length + untracked.length;
+  logger.info(`${total} change(s) pending`);
+}
+
+// src/commands/push.ts
+import { Command as Command15 } from "commander";
+import { loadConfig as loadConfig12, getDbPath as getDbPath13, isInitialized as isInitialized7 } from "unforgit-config";
+import { LocalStore as LocalStore13 } from "unforgit-db";
+import { RemoteClient as RemoteClient8 } from "unforgit-config";
+var pushCommand = new Command15("push").description("Push local memories to remote").argument("[remote]", "Remote name to push to", "origin").option("-f, --force", "Force push, overwriting remote conflicts").option("--dry-run", "Show what would be pushed without actually pushing").option("-a, --all", "Push all memories including untracked ones").action(async (remote, opts) => {
+  if (!isInitialized7()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig12();
+  const store = new LocalStore13(getDbPath13());
+  try {
+    const orgId = config.remote.orgId || "local";
+    const repoId = config.remote.repoId || "local";
+    if (!config.remote.url) {
+      logger.fatal(`No remote '${remote}' configured.`);
+      logger.error("Use 'unforgit remote add origin <url>' to add a remote.");
+      process.exit(EXIT_CONFIG_ERROR);
+    }
+    const client = new RemoteClient8(config.remote.url);
+    const pendingPush = store.getPendingPush();
+    const untracked = opts.all ? store.getUntrackedMemories(orgId, repoId) : [];
+    for (const memory of untracked) {
+      store.initSyncStateForMemory(memory.id);
+    }
+    const allToPush = opts.all ? [...pendingPush, ...untracked.map((m) => ({ memory: m, syncState: store.getSyncState(m.id) }))] : pendingPush;
+    const supersededToSync = store.getSupersededMemoriesToSync(orgId, repoId);
+    const linksToSync = store.getLinksToSync(orgId, repoId);
+    if (allToPush.length === 0 && supersededToSync.length === 0 && linksToSync.length === 0) {
+      logger.info("Everything up-to-date");
+      return;
+    }
+    logger.info(`Pushing to ${remote} (${config.remote.url})...`);
+    if (opts.dryRun) {
+      if (allToPush.length > 0) {
+        logger.info("\nWould push the following memories:");
+        for (const { memory } of allToPush) {
+          logger.info(`  ${memory.id.slice(0, 8)}... "${truncate(memory.text, 50)}"`);
+        }
+      }
+      if (supersededToSync.length > 0) {
+        logger.info("\nWould sync superseded status:");
+        for (const { memory, newId } of supersededToSync) {
+          logger.info(`  ${memory.id.slice(0, 8)}... -> superseded by ${newId.slice(0, 8)}...`);
+        }
+      }
+      if (linksToSync.length > 0) {
+        logger.info("\nWould sync links:");
+        for (const { link } of linksToSync) {
+          logger.info(`  ${link.sourceId.slice(0, 8)}... -> ${link.targetId.slice(0, 8)}... (${link.linkType})`);
+        }
+      }
+      logger.info(`
+Total: ${allToPush.length} memories, ${supersededToSync.length} status updates, ${linksToSync.length} links`);
+      return;
+    }
+    let pushed = 0;
+    let errors = 0;
+    for (const { memory, syncState } of allToPush) {
+      try {
+        const fullMemory = store.getById(memory.id);
+        if (!fullMemory) continue;
+        if (fullMemory.visibility !== "repo" && !opts.force) {
+          logger.info(`  Skipping ${memory.id.slice(0, 8)}... (private memory, use --force to push anyway)`);
+          continue;
+        }
+        await client.store({
+          id: fullMemory.id,
+          orgId: fullMemory.orgId,
+          repoId: fullMemory.repoId,
+          memoryType: fullMemory.memoryType,
+          text: fullMemory.text,
+          summary: fullMemory.summary,
+          tags: fullMemory.tags,
+          sourceRefs: fullMemory.sourceRefs,
+          confidence: fullMemory.confidence,
+          ttlSeconds: fullMemory.ttlSeconds,
+          visibility: "repo",
+          authorId: fullMemory.authorId,
+          authorName: fullMemory.authorName
+        });
+        store.markAsPushed(memory.id, fullMemory.version);
+        pushed++;
+        logger.progress(pushed + errors, allToPush.length, "memories");
+        logger.debug(`pushed ${memory.id.slice(0, 8)}...`);
+      } catch (err) {
+        errors++;
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        logger.error(`  ${memory.id.slice(0, 8)}... failed: ${errorMsg}`);
+        if (errorMsg.includes("409") || errorMsg.includes("conflict")) {
+          if (opts.force) {
+            logger.info(`    Forcing overwrite...`);
+          } else {
+            store.markAsConflict(memory.id, syncState?.remoteVersion ?? 0);
+            logger.info(`    Marked as conflict. Use --force to overwrite.`);
+          }
+        }
+      }
+    }
+    let supersededSynced = 0;
+    for (const { memory, newId } of supersededToSync) {
+      try {
+        await client.supersede(memory.id, newId);
+        store.markStatusSynced(memory.id);
+        supersededSynced++;
+        logger.info(`  ${memory.id.slice(0, 8)}... marked as superseded on remote`);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (!errorMsg.includes("404")) {
+          errors++;
+          logger.error(`  ${memory.id.slice(0, 8)}... failed to sync superseded status: ${errorMsg}`);
+        }
+      }
+    }
+    let linksSynced = 0;
+    for (const { link } of linksToSync) {
+      try {
+        await client.link(link.sourceId, link.targetId, link.linkType, link.metadata);
+        store.markLinkSynced(link.id);
+        linksSynced++;
+        logger.info(`  link ${link.sourceId.slice(0, 8)}... -> ${link.targetId.slice(0, 8)}... (${link.linkType})`);
+      } catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (!errorMsg.includes("404")) {
+          errors++;
+          logger.error(`  link ${link.sourceId.slice(0, 8)}... failed: ${errorMsg}`);
+        }
+      }
+    }
+    logger.info("");
+    if (pushed > 0) {
+      logger.info(`${pushed} memory(s) pushed successfully`);
+    }
+    if (supersededSynced > 0) {
+      logger.info(`${supersededSynced} memory(s) marked as superseded on remote`);
+    }
+    if (linksSynced > 0) {
+      logger.info(`${linksSynced} link(s) synced`);
+    }
+    if (errors > 0) {
+      logger.info(`${errors} error(s) during push`);
+    }
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/pull.ts
+import { Command as Command16 } from "commander";
+import { loadConfig as loadConfig13, getDbPath as getDbPath14, isInitialized as isInitialized8 } from "unforgit-config";
+import { LocalStore as LocalStore14 } from "unforgit-db";
+import { RemoteClient as RemoteClient9 } from "unforgit-config";
+var pullCommand = new Command16("pull").description("Pull remote memories to local").argument("[remote]", "Remote name to pull from", "origin").option("-f, --force", "Force pull, overwriting local conflicts").option("--dry-run", "Show what would be pulled without actually pulling").action(async (remote, opts) => {
+  if (!isInitialized8()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig13();
+  const store = new LocalStore14(getDbPath14());
+  try {
+    const orgId = config.remote.orgId || "local";
+    const repoId = config.remote.repoId || "local";
+    if (!config.remote.url) {
+      logger.fatal(`No remote '${remote}' configured.`);
+      logger.fatal("Use 'unforgit remote add origin <url>' to add a remote.");
+      process.exit(EXIT_CONFIG_ERROR);
+    }
+    const client = new RemoteClient9(config.remote.url);
+    logger.info(`Fetching from ${remote} (${config.remote.url})...`);
+    const response = await client.recall({
+      orgId,
+      repoId,
+      query: "*",
+      k: 1e3,
+      includeDeprecated: true
+    });
+    const remoteMemories = response.results;
+    if (remoteMemories.length === 0) {
+      logger.info("Already up to date (no memories on remote)");
+      return;
+    }
+    if (opts.dryRun) {
+      let newCount = 0;
+      let updateCount = 0;
+      for (const remoteMem of remoteMemories) {
+        const localMem = store.getById(remoteMem.id);
+        if (!localMem) {
+          newCount++;
+        } else {
+          updateCount++;
+        }
+      }
+      logger.info(`
+Would pull:`);
+      logger.info(`  ${newCount} new memories`);
+      logger.info(`  ${updateCount} updates`);
+      return;
+    }
+    let created = 0;
+    let updated = 0;
+    let skipped = 0;
+    let conflicts = 0;
+    for (const remoteMem of remoteMemories) {
+      const localMem = store.getById(remoteMem.id);
+      const remoteStatus = remoteMem.status ?? "active";
+      if (!localMem) {
+        store.upsertFromRemote({
+          id: remoteMem.id,
+          orgId,
+          repoId,
+          scopeType: "repo",
+          memoryType: remoteMem.memoryType,
+          visibility: "repo",
+          status: remoteStatus,
+          text: remoteMem.text,
+          summary: remoteMem.summary,
+          tags: remoteMem.tags,
+          sourceRefs: remoteMem.sourceRefs,
+          supersedesId: remoteMem.supersedesId,
+          version: 1,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+        store.setSyncState({
+          memoryId: remoteMem.id,
+          localVersion: 1,
+          remoteVersion: 1,
+          lastPulledAt: /* @__PURE__ */ new Date(),
+          syncStatus: "synced"
+        });
+        created++;
+        const statusNote = remoteStatus !== "active" ? ` [${remoteStatus}]` : "";
+        logger.info(`  ${remoteMem.id.slice(0, 8)}... new memory${statusNote}`);
+        logger.progress(created + updated + skipped + conflicts, remoteMemories.length, "memories");
+      } else {
+        const syncState = store.getSyncState(remoteMem.id);
+        const localVersion = syncState?.localVersion ?? localMem.version;
+        const remoteVersion = syncState?.remoteVersion ?? 0;
+        if (syncState?.syncStatus === "pending_push" && !opts.force) {
+          conflicts++;
+          store.markAsConflict(remoteMem.id, remoteVersion + 1);
+          logger.info(`  ${remoteMem.id.slice(0, 8)}... conflict (local has unpushed changes)`);
+          logger.progress(created + updated + skipped + conflicts, remoteMemories.length, "memories");
+          continue;
+        }
+        const statusChanged = localMem.status !== remoteStatus;
+        const textChanged = localMem.text !== remoteMem.text;
+        if (!textChanged && !statusChanged) {
+          skipped++;
+          logger.progress(created + updated + skipped + conflicts, remoteMemories.length, "memories");
+          continue;
+        }
+        if (opts.force || syncState?.syncStatus !== "pending_push") {
+          store.upsertFromRemote({
+            id: remoteMem.id,
+            orgId,
+            repoId,
+            scopeType: "repo",
+            memoryType: remoteMem.memoryType,
+            visibility: "repo",
+            status: remoteStatus,
+            text: remoteMem.text,
+            summary: remoteMem.summary,
+            tags: remoteMem.tags,
+            sourceRefs: remoteMem.sourceRefs,
+            supersedesId: remoteMem.supersedesId,
+            version: localVersion + 1,
+            createdAt: localMem.createdAt,
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+          store.markAsPulled(remoteMem.id, localVersion + 1);
+          updated++;
+          const changeType = statusChanged && !textChanged ? "status updated" : "updated";
+          const statusNote = remoteStatus !== "active" ? ` [${remoteStatus}]` : "";
+          logger.info(`  ${remoteMem.id.slice(0, 8)}... ${changeType}${statusNote}`);
+          logger.progress(created + updated + skipped + conflicts, remoteMemories.length, "memories");
+        }
+      }
+    }
+    logger.info("");
+    logger.info(`Pull complete:`);
+    if (created > 0) logger.info(`  ${created} new memories`);
+    if (updated > 0) logger.info(`  ${updated} updates`);
+    if (skipped > 0) logger.info(`  ${skipped} already up to date`);
+    if (conflicts > 0) {
+      logger.info(`  ${conflicts} conflicts (use --force to overwrite local)`);
+    }
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.fatal(`Could not fetch from remote: ${errorMsg}`);
+    process.exit(EXIT_ERROR);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/remote.ts
+import { Command as Command17 } from "commander";
+import { isInitialized as isInitialized9, loadConfig as loadConfig14, saveConfig as saveConfig2 } from "unforgit-config";
+var remoteCommand = new Command17("remote").description("Manage set of tracked remote repositories").addHelpText("after", `
+Examples:
+  unforgit remote                        List remotes
+  unforgit remote add origin <url>       Add a remote
+  unforgit remote show origin            Show remote details`).action(() => {
+  if (!isInitialized9()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig14();
+  const remotes = getRemotes(config);
+  if (Object.keys(remotes).length === 0) {
+    logger.info("No remotes configured.");
+    logger.info("Use 'unforgit remote add <name> <url>' to add a remote.");
+    return;
+  }
+  for (const [name, remote] of Object.entries(remotes)) {
+    logger.info(`${name}	${remote.url}`);
+  }
+});
+var remoteAddCommand = new Command17("add").description("Add a new remote").argument("<name>", "Name for the remote (e.g., origin)").argument("<url>", "URL of the remote unforgit server").option("--org <orgId>", "Organization ID").option("--repo <repoId>", "Repository ID").action((name, url, opts) => {
+  if (!isInitialized9()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig14();
+  const remotes = getRemotes(config);
+  if (remotes[name]) {
+    logger.fatal(`remote '${name}' already exists.`);
+    logger.error(`Use 'unforgit remote set-url ${name} <newurl>' to change the URL.`);
+    process.exit(EXIT_ERROR);
+  }
+  remotes[name] = {
+    url,
+    orgId: opts.org || config.remote?.orgId || "",
+    repoId: opts.repo || config.remote?.repoId || ""
+  };
+  saveRemotes(config, remotes);
+  logger.info(`Remote '${name}' added: ${url}`);
+});
+var remoteRemoveCommand = new Command17("remove").alias("rm").description("Remove a remote").argument("<name>", "Name of the remote to remove").action((name) => {
+  if (!isInitialized9()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig14();
+  const remotes = getRemotes(config);
+  if (!remotes[name]) {
+    logger.fatal(`No such remote: '${name}'`);
+    process.exit(EXIT_ERROR);
+  }
+  delete remotes[name];
+  saveRemotes(config, remotes);
+  logger.info(`Remote '${name}' removed.`);
+});
+var remoteSetUrlCommand = new Command17("set-url").description("Change the URL for a remote").argument("<name>", "Name of the remote").argument("<newurl>", "New URL for the remote").action((name, newurl) => {
+  if (!isInitialized9()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig14();
+  const remotes = getRemotes(config);
+  if (!remotes[name]) {
+    logger.fatal(`No such remote: '${name}'`);
+    logger.error(`Use 'unforgit remote add ${name} ${newurl}' to add it.`);
+    process.exit(EXIT_ERROR);
+  }
+  remotes[name].url = newurl;
+  saveRemotes(config, remotes);
+  logger.info(`Remote '${name}' URL changed to: ${newurl}`);
+});
+var remoteShowCommand = new Command17("show").description("Show information about a remote").argument("<name>", "Name of the remote").action((name) => {
+  if (!isInitialized9()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig14();
+  const remotes = getRemotes(config);
+  if (!remotes[name]) {
+    logger.fatal(`No such remote: '${name}'`);
+    process.exit(EXIT_ERROR);
+  }
+  const remote = remotes[name];
+  logger.info(`* remote ${name}`);
+  logger.info(`  URL: ${remote.url}`);
+  logger.info(`  Org ID: ${remote.orgId || "(not set)"}`);
+  logger.info(`  Repo ID: ${remote.repoId || "(not set)"}`);
+});
+remoteCommand.addCommand(remoteAddCommand);
+remoteCommand.addCommand(remoteRemoveCommand);
+remoteCommand.addCommand(remoteSetUrlCommand);
+remoteCommand.addCommand(remoteShowCommand);
+function getRemotes(config) {
+  if (config.remotes) {
+    return { ...config.remotes };
+  }
+  if (config.remote?.url) {
+    return {
+      origin: {
+        url: config.remote.url,
+        orgId: config.remote.orgId,
+        repoId: config.remote.repoId
+      }
+    };
+  }
+  return {};
+}
+function saveRemotes(config, remotes) {
+  config.remotes = remotes;
+  if (remotes.origin) {
+    config.remote = {
+      ...config.remote,
+      url: remotes.origin.url,
+      orgId: remotes.origin.orgId,
+      repoId: remotes.origin.repoId
+    };
+  }
+  saveConfig2(config);
+}
+
+// src/commands/log.ts
+import { Command as Command18 } from "commander";
+import { loadConfig as loadConfig15, getDbPath as getDbPath15, isInitialized as isInitialized10 } from "unforgit-config";
+import { LocalStore as LocalStore15 } from "unforgit-db";
+import { parsePositiveInt as parsePositiveInt5, validateMemoryType as validateMemoryType4 } from "unforgit-config";
+var logCommand = new Command18("log").description("Show memory history log").option("-n, --max-count <n>", "Limit the number of memories shown", "20").option("--oneline", "Show each memory on a single line").option("--all", "Show all memories including deprecated/superseded").option("--type <type>", "Filter by memory type (episodic|semantic|procedural)").option("--tags <tags>", "Filter by tags (comma-separated)").option("--page <n>", "Page number for pagination", "1").option("--per-page <n>", "Items per page", "20").addHelpText("after", `
+Examples:
+  unforgit log                     Show recent memories
+  unforgit log --all               Include deprecated/superseded
+  unforgit log --type semantic     Filter by type
+  unforgit log --oneline           Compact output
+  unforgit log --page 2            Second page of results`).action((opts) => {
+  if (!isInitialized10()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig15();
+  const store = new LocalStore15(getDbPath15());
+  try {
+    const orgId = config.remote.orgId || "local";
+    const repoId = config.remote.repoId || "local";
+    const limit = parsePositiveInt5(opts.maxCount, "max-count");
+    if (opts.type && !validateMemoryType4(opts.type)) {
+      logger.error(`Invalid memory type "${opts.type}". Must be one of: episodic, semantic, procedural`);
+      process.exit(EXIT_ERROR);
+    }
+    const types = opts.type ? [opts.type] : void 0;
+    const status = opts.all ? void 0 : ["active"];
+    const memories = store.list({
+      orgId,
+      repoId,
+      types,
+      status,
+      limit,
+      sortBy: "createdAt",
+      sortOrder: "desc"
+    });
+    let filteredMemories = memories;
+    if (opts.tags) {
+      const filterTags = opts.tags.split(",").map((t) => t.trim());
+      filteredMemories = memories.filter(
+        (m) => m.tags.some((t) => filterTags.includes(t))
+      );
+    }
+    const page = parsePositiveInt5(opts.page, "page");
+    const perPage = parsePositiveInt5(opts.perPage, "per-page");
+    const paged = paginate(filteredMemories, page, perPage);
+    if (isJsonMode()) {
+      outputJson({
+        memories: paged.items.map((m) => ({
+          id: m.id,
+          type: m.memoryType,
+          status: m.status,
+          text: m.text,
+          tags: m.tags,
+          createdAt: m.createdAt.toISOString()
+        })),
+        page: paged.currentPage,
+        totalPages: paged.totalPages,
+        total: paged.total
+      });
+      return;
+    }
+    if (paged.items.length === 0) {
+      logger.info("No memories found.");
+      return;
+    }
+    if (opts.oneline) {
+      for (const mem of paged.items) {
+        const text = mem.text.replace(/\n/g, " ").slice(0, 60);
+        logger.info(`${mem.id.slice(0, 7)} [${mem.memoryType}] ${text}${mem.text.length > 60 ? "..." : ""}`);
+      }
+    } else {
+      for (const mem of paged.items) {
+        const date = mem.createdAt.toISOString().split("T")[0];
+        const time = mem.createdAt.toISOString().split("T")[1].slice(0, 5);
+        logger.info(`memory ${mem.id}`);
+        logger.info(`Type:   ${mem.memoryType}`);
+        logger.info(`Date:   ${date} ${time}`);
+        logger.info(`Status: ${mem.status}`);
+        if (mem.tags.length > 0) {
+          logger.info(`Tags:   ${mem.tags.join(", ")}`);
+        }
+        logger.info("");
+        logger.info(`    ${mem.text.split("\n").join("\n    ")}`);
+        logger.info("");
+      }
+    }
+    if (paged.totalPages > 1) {
+      logger.info(`Page ${paged.currentPage}/${paged.totalPages} (${paged.total} total)`);
+    }
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/diff.ts
+import { Command as Command19 } from "commander";
+import { loadConfig as loadConfig16, getDbPath as getDbPath16, isInitialized as isInitialized11 } from "unforgit-config";
+import { LocalStore as LocalStore16 } from "unforgit-db";
+import { RemoteClient as RemoteClient10 } from "unforgit-config";
+var diffCommand = new Command19("diff").description("Show differences between local and remote memories").argument("[memoryId]", "Specific memory ID to diff").option("--stat", "Show only statistics").addHelpText("after", `
+Examples:
+  unforgit diff              Show all differences
+  unforgit diff --stat       Show difference statistics only
+  unforgit diff abc12345     Diff a specific memory`).action(async (memoryId, opts) => {
+  if (!isInitialized11()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig16();
+  const store = new LocalStore16(getDbPath16());
+  try {
+    const orgId = config.remote.orgId || "local";
+    const repoId = config.remote.repoId || "local";
+    if (!config.remote.url) {
+      logger.fatal("No remote configured.");
+      process.exit(EXIT_CONFIG_ERROR);
+    }
+    const client = new RemoteClient10(config.remote.url);
+    if (memoryId) {
+      await diffSingleMemory(store, client, memoryId, orgId, repoId);
+    } else {
+      await diffAll(store, client, orgId, repoId, opts.stat);
+    }
+  } finally {
+    store.close();
+  }
+});
+async function diffSingleMemory(store, client, memoryId, orgId, repoId) {
+  const fullId = memoryId.length < 36 ? findFullId(store, memoryId, orgId, repoId) : memoryId;
+  if (!fullId) {
+    logger.error(`memory '${memoryId}' not found`);
+    process.exit(EXIT_ERROR);
+  }
+  const localMem = store.getById(fullId);
+  let remoteMem = null;
+  try {
+    const response = await client.recall({
+      orgId,
+      repoId,
+      query: fullId,
+      k: 1
+    });
+    remoteMem = response.results.find((r) => r.id === fullId);
+  } catch {
+    logger.warn("Could not fetch from remote");
+  }
+  if (!localMem && !remoteMem) {
+    logger.error(`memory '${memoryId}' not found locally or remotely`);
+    process.exit(EXIT_ERROR);
+  }
+  if (isJsonMode()) {
+    outputJson({
+      memoryId: fullId,
+      local: localMem ? { text: localMem.text, status: localMem.status } : null,
+      remote: remoteMem ? { text: remoteMem.text, status: remoteMem.status } : null,
+      identical: localMem && remoteMem ? localMem.text === remoteMem.text : false
+    });
+    return;
+  }
+  logger.info(`diff ${fullId.slice(0, 8)}...`);
+  logger.info("---");
+  if (!localMem) {
+    logger.info("(not in local)");
+    logger.info("+ " + remoteMem.text.split("\n").join("\n+ "));
+    return;
+  }
+  if (!remoteMem) {
+    logger.info("(not in remote)");
+    logger.info("+ " + localMem.text.split("\n").join("\n+ "));
+    return;
+  }
+  if (localMem.text === remoteMem.text) {
+    logger.info("No differences");
+    return;
+  }
+  const localLines = localMem.text.split("\n");
+  const remoteLines = remoteMem.text.split("\n");
+  logger.info("--- local");
+  logger.info("+++ remote");
+  logger.info("");
+  for (let i = 0; i < Math.max(localLines.length, remoteLines.length); i++) {
+    const localLine = localLines[i];
+    const remoteLine = remoteLines[i];
+    if (localLine === remoteLine) {
+      logger.info(`  ${localLine ?? ""}`);
+    } else if (localLine && !remoteLine) {
+      logger.info(`- ${localLine}`);
+    } else if (!localLine && remoteLine) {
+      logger.info(`+ ${remoteLine}`);
+    } else {
+      logger.info(`- ${localLine}`);
+      logger.info(`+ ${remoteLine}`);
+    }
+  }
+}
+async function diffAll(store, client, orgId, repoId, statOnly) {
+  const pendingPush = store.getPendingPush();
+  const conflicts = store.getConflicts();
+  let remoteOnlyCount = 0;
+  try {
+    const response = await client.recall({ orgId, repoId, query: "*", k: 1e3 });
+    for (const remoteMem of response.results) {
+      const localMem = store.getById(remoteMem.id);
+      if (!localMem) {
+        remoteOnlyCount++;
+      }
+    }
+  } catch {
+    logger.warn("Could not fetch remote memories for full diff");
+  }
+  if (pendingPush.length === 0 && conflicts.length === 0 && remoteOnlyCount === 0) {
+    if (isJsonMode()) {
+      outputJson({ pendingPush: 0, conflicts: 0, remoteOnly: 0, total: 0 });
+      return;
+    }
+    logger.info("No differences");
+    return;
+  }
+  if (isJsonMode()) {
+    outputJson({
+      pendingPush: pendingPush.length,
+      conflicts: conflicts.length,
+      remoteOnly: remoteOnlyCount,
+      total: pendingPush.length + conflicts.length + remoteOnlyCount
+    });
+    return;
+  }
+  if (statOnly) {
+    logger.info(`${pendingPush.length} memories to push`);
+    logger.info(`${conflicts.length} conflicts`);
+    if (remoteOnlyCount > 0) {
+      logger.info(`${remoteOnlyCount} remote-only memories (use 'unforgit pull')`);
+    }
+    return;
+  }
+  if (pendingPush.length > 0) {
+    logger.info("Changes to push:");
+    logger.info("");
+    for (const { memory } of pendingPush) {
+      logger.info(`  + ${memory.id.slice(0, 8)}... "${truncate(memory.text, 50)}"`);
+    }
+    logger.info("");
+  }
+  if (conflicts.length > 0) {
+    logger.info("Conflicts:");
+    logger.info("");
+    for (const { memory, syncState } of conflicts) {
+      logger.info(`  ! ${memory.id.slice(0, 8)}... local:v${syncState.localVersion} remote:v${syncState.remoteVersion ?? "?"}`);
+      logger.info(`    "${truncate(memory.text, 60)}"`);
+    }
+    logger.info("");
+  }
+  if (remoteOnlyCount > 0) {
+    logger.info(`${remoteOnlyCount} remote-only memories (run 'unforgit pull' to fetch)`);
+    logger.info("");
+  }
+  logger.info(`Total: ${pendingPush.length + conflicts.length + remoteOnlyCount} differences`);
+}
+function findFullId(store, partialId, orgId, repoId) {
+  const memories = store.list({ orgId, repoId, limit: 1e3 });
+  const match = memories.find((m) => m.id.startsWith(partialId));
+  return match?.id ?? null;
+}
+
+// src/commands/keys.ts
+import { Command as Command20 } from "commander";
+import { loadConfig as loadConfig17, isInitialized as isInitialized12 } from "unforgit-config";
+import { RemoteClient as RemoteClient11 } from "unforgit-config";
+function requireRemote() {
+  if (!isInitialized12()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig17();
+  if (!config.remote.url) {
+    logger.fatal("No remote configured.");
+    logger.error("Use 'unforgit remote add origin <url>' to add a remote.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const apiKey = process.env.UNFORGIT_API_KEY;
+  if (!apiKey) {
+    logger.fatal("No API key configured.");
+    logger.error("Set the UNFORGIT_API_KEY environment variable.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  return { url: config.remote.url, apiKey };
+}
+var keysCommand = new Command20("keys").description("Manage API keys for remote authentication");
+keysCommand.command("create").description("Create a new API key").requiredOption("--name <name>", "Name for the API key").requiredOption("--org <orgId>", "Organization ID for the key").addHelpText("after", `
+Examples:
+  unforgit keys create --name "CI pipeline" --org my-org
+  unforgit keys list --org my-org`).action(async (opts) => {
+  const { url, apiKey } = requireRemote();
+  const client = new RemoteClient11(url, apiKey);
+  try {
+    const result = await client.createApiKey(opts.name, opts.org);
+    if (isJsonMode()) {
+      outputJson(result);
+      return;
+    }
+    logger.info("API key created successfully!");
+    logger.info("");
+    logger.info(`  ID:    ${result.id}`);
+    logger.info(`  Name:  ${result.name}`);
+    logger.info(`  Org:   ${result.orgId}`);
+    logger.info(`  Key:   ${result.key}`);
+    logger.info("");
+    logger.info("Store this key securely. It will not be shown again.");
+    logger.info("");
+    logger.info("To use this key, set it as an environment variable:");
+    logger.info("");
+    logger.info(`  export UNFORGIT_API_KEY="${result.key}"`);
+  } catch (err) {
+    logger.fatal(err instanceof Error ? err.message : String(err));
+    process.exit(EXIT_ERROR);
+  }
+});
+keysCommand.command("list").description("List all API keys").option("--org <orgId>", "Filter by organization ID").action(async (opts) => {
+  const { url, apiKey } = requireRemote();
+  const client = new RemoteClient11(url, apiKey);
+  try {
+    const result = await client.listApiKeys(opts.org);
+    if (isJsonMode()) {
+      outputJson(result);
+      return;
+    }
+    if (result.keys.length === 0) {
+      logger.info("No API keys found.");
+      return;
+    }
+    logger.info(`Found ${result.keys.length} API key(s):
+`);
+    for (const key of result.keys) {
+      const status = key.isActive ? "[active]" : "[revoked]";
+      const lastUsed = key.lastUsedAt ? `last used ${new Date(key.lastUsedAt).toLocaleDateString()}` : "never used";
+      logger.info(`${status} ${key.id.slice(0, 8)}  ${key.name}`);
+      logger.info(`    org: ${key.orgId}  |  ${lastUsed}`);
+    }
+  } catch (err) {
+    logger.fatal(err instanceof Error ? err.message : String(err));
+    process.exit(EXIT_ERROR);
+  }
+});
+keysCommand.command("revoke").description("Revoke an API key").argument("<id>", "API key ID to revoke").action(async (id) => {
+  const { url, apiKey } = requireRemote();
+  const client = new RemoteClient11(url, apiKey);
+  try {
+    await client.revokeApiKey(id);
+    logger.info(`API key ${id.slice(0, 8)}... revoked successfully.`);
+  } catch (err) {
+    logger.fatal(err instanceof Error ? err.message : String(err));
+    process.exit(EXIT_ERROR);
+  }
+});
+
+// src/commands/auth.ts
+import { Command as Command21 } from "commander";
+import { loadConfig as loadConfig18, isInitialized as isInitialized13 } from "unforgit-config";
+var authCommand = new Command21("auth").description("Check authentication status for remote server and APIs");
+authCommand.command("status").description("Check authentication status").action(async () => {
+  if (!isInitialized13()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig18();
+  logger.info("Authentication status:");
+  logger.info(`  Remote URL: ${config.remote.url || "(not configured)"}`);
+  logger.info(`  Org ID: ${config.remote.orgId || "(not configured)"}`);
+  logger.info(`  Repo ID: ${config.remote.repoId || "(not configured)"}`);
+  const apiKey = process.env.UNFORGIT_API_KEY;
+  if (apiKey) {
+    logger.info(`  API Key: ${maskKey(apiKey)} (from UNFORGIT_API_KEY env var)`);
+    if (config.remote.url) {
+      logger.info("\nTesting connection...");
+      try {
+        const res = await fetch(`${config.remote.url}/health`);
+        if (res.ok) {
+          logger.info("  [ok] Server reachable");
+          const authRes = await fetch(`${config.remote.url}/v1/api-keys`, {
+            headers: { Authorization: `Bearer ${apiKey}` }
+          });
+          if (authRes.ok) {
+            logger.info("  [ok] API key valid");
+          } else if (authRes.status === 401) {
+            logger.info("  [ERR] API key invalid or expired");
+          } else {
+            logger.info(`  [??] Could not verify API key (HTTP ${authRes.status})`);
+          }
+        } else {
+          logger.info(`  [ERR] Server returned HTTP ${res.status}`);
+        }
+      } catch (err) {
+        logger.info(`  [ERR] Could not connect: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  } else {
+    logger.info("  API Key: (not configured)");
+    logger.info("\nSet the UNFORGIT_API_KEY environment variable.");
+  }
+  const openaiKey = process.env.OPENAI_API_KEY;
+  if (openaiKey) {
+    logger.info(`  OpenAI Key: ${maskKey(openaiKey)} (from OPENAI_API_KEY env var)`);
+  } else {
+    logger.info("  OpenAI Key: (not configured)");
+    logger.info("  Set OPENAI_API_KEY env var for embeddings and auto-consolidation.");
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command22 } from "commander";
+import { isInitialized as isInitialized14, loadConfig as loadConfig19, saveConfig as saveConfig3 } from "unforgit-config";
+var configCommand = new Command22("config").description("Manage unforgit configuration");
+configCommand.command("list").alias("ls").description("List all configuration values").action(() => {
+  if (!isInitialized14()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig19();
+  if (isJsonMode()) {
+    outputJson(config);
+    return;
+  }
+  logger.info("Current configuration:\n");
+  logger.info(`remote.url = ${config.remote.url || "(not set)"}`);
+  logger.info(`remote.orgId = ${config.remote.orgId || "(not set)"}`);
+  logger.info(`remote.repoId = ${config.remote.repoId || "(not set)"}`);
+  logger.info(`defaults.visibility = ${config.defaults.visibility}`);
+  logger.info(`defaults.memoryType = ${config.defaults.memoryType}`);
+  logger.info(`lifecycle.ttlSecondsByType.episodic = ${config.lifecycle?.ttlSecondsByType?.episodic ?? "(none)"}`);
+  logger.info(`lifecycle.usageBoost.topKToRecord = ${config.lifecycle?.usageBoost?.topKToRecord ?? "(not set)"}`);
+  logger.info(`lifecycle.usageBoost.minUsageCount = ${config.lifecycle?.usageBoost?.minUsageCount ?? "(not set)"}`);
+  logger.info(`lifecycle.usageBoost.maxBoost = ${config.lifecycle?.usageBoost?.maxBoost ?? "(not set)"}`);
+  logger.info(`lifecycle.usageBoost.halfLifeDays = ${config.lifecycle?.usageBoost?.halfLifeDays ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.staleEpisodicDays = ${config.lifecycle?.maintenance?.staleEpisodicDays ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.consolidationThreshold = ${config.lifecycle?.maintenance?.consolidationThreshold ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.consolidationMinGroupSize = ${config.lifecycle?.maintenance?.consolidationMinGroupSize ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.consolidationMaxGroups = ${config.lifecycle?.maintenance?.consolidationMaxGroups ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.promoteRecallCount = ${config.lifecycle?.maintenance?.promoteRecallCount ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.pinRecallCount = ${config.lifecycle?.maintenance?.pinRecallCount ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.dryRunDefault = ${config.lifecycle?.maintenance?.dryRunDefault ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.autoRunOnStore = ${config.lifecycle?.maintenance?.autoRunOnStore ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.autoRunOnRecall = ${config.lifecycle?.maintenance?.autoRunOnRecall ?? "(not set)"}`);
+  logger.info(`lifecycle.maintenance.debounceMs = ${config.lifecycle?.maintenance?.debounceMs ?? "(not set)"}`);
+});
+configCommand.command("get").description("Get a configuration value").argument("<key>", "Configuration key (e.g., remote.url, defaults.memoryType)").action((key) => {
+  if (!isInitialized14()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig19();
+  const value = getConfigValue(config, key);
+  if (value === void 0) {
+    logger.fatal(`key '${key}' not found`);
+    process.exit(EXIT_ERROR);
+  }
+  if (isJsonMode()) {
+    outputJson({ key, value });
+    return;
+  }
+  logger.info(String(value));
+});
+var VALID_CONFIG_KEYS = [
+  "remote.url",
+  "remote.orgId",
+  "remote.repoId",
+  "defaults.visibility",
+  "defaults.memoryType",
+  "lifecycle.ttlSecondsByType.episodic",
+  "lifecycle.ttlSecondsByType.semantic",
+  "lifecycle.ttlSecondsByType.procedural",
+  "lifecycle.usageBoost.enabled",
+  "lifecycle.usageBoost.topKToRecord",
+  "lifecycle.usageBoost.minUsageCount",
+  "lifecycle.usageBoost.maxBoost",
+  "lifecycle.usageBoost.halfLifeDays",
+  "lifecycle.maintenance.staleEpisodicDays",
+  "lifecycle.maintenance.consolidationThreshold",
+  "lifecycle.maintenance.consolidationMinGroupSize",
+  "lifecycle.maintenance.consolidationMaxGroups",
+  "lifecycle.maintenance.promoteRecallCount",
+  "lifecycle.maintenance.pinRecallCount",
+  "lifecycle.maintenance.dryRunDefault",
+  "lifecycle.maintenance.autoRunOnStore",
+  "lifecycle.maintenance.autoRunOnRecall",
+  "lifecycle.maintenance.debounceMs",
+  "configVersion"
+];
+configCommand.command("set").description("Set a configuration value").argument("<key>", "Configuration key").argument("<value>", "Value to set").addHelpText("after", `
+Valid keys: ${VALID_CONFIG_KEYS.join(", ")}
+
+Examples:
+  unforgit config set remote.url http://my-server:3737
+  unforgit config set defaults.memoryType semantic`).action((key, value) => {
+  if (!isInitialized14()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  if (!VALID_CONFIG_KEYS.includes(key)) {
+    logger.error(
+      `Unknown config key "${key}". Valid keys: ${VALID_CONFIG_KEYS.join(", ")}`
+    );
+    process.exit(EXIT_ERROR);
+  }
+  const config = loadConfig19();
+  setConfigValue(config, key, value);
+  saveConfig3(config);
+  logger.info(`${key} = ${value}`);
+});
+configCommand.command("unset").description("Remove a configuration value").argument("<key>", "Configuration key to remove").action((key) => {
+  if (!isInitialized14()) {
+    logger.fatal("not an unforgit repository");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig19();
+  unsetConfigValue(config, key);
+  saveConfig3(config);
+  logger.info(`Unset ${key}`);
+});
+function getConfigValue(config, key) {
+  const parts = key.split(".");
+  let current = config;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function setConfigValue(config, key, value) {
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    config[key] = value;
+    return;
+  }
+  let current = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = coerceConfigValue(value);
+}
+function unsetConfigValue(config, key) {
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    delete config[key];
+    return;
+  }
+  let current = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object") {
+      return;
+    }
+    current = current[part];
+  }
+  delete current[parts[parts.length - 1]];
+}
+function coerceConfigValue(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+
+// src/commands/embeddings.ts
+import { Command as Command23 } from "commander";
+import { LocalStore as LocalStore17 } from "unforgit-db";
+import { loadConfig as loadConfig20, getDbPath as getDbPath17, isInitialized as isInitialized15 } from "unforgit-config";
+import { generateEmbedding } from "unforgit-core";
+import { parsePositiveInt as parsePositiveInt6 } from "unforgit-config";
+var cwd3 = process.cwd();
+var embeddingsCommand = new Command23("embeddings").description("Manage memory embeddings for semantic search");
+embeddingsCommand.command("backfill").description("Generate embeddings for memories that don't have them").option("--batch-size <n>", "Number of memories to process in parallel", "5").option("--delay <ms>", "Delay between batches (ms)", "500").option("--dry-run", "Show what would be done without making changes").option("--model <model>", "OpenAI embedding model", "text-embedding-3-small").action(async (opts) => {
+  if (!isInitialized15(cwd3)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig20(cwd3);
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey && !opts.dryRun) {
+    logger.error("OpenAI API key not set.");
+    logger.error("Set the OPENAI_API_KEY environment variable.");
+    process.exit(EXIT_ERROR);
+  }
+  const dbPath = getDbPath17(cwd3);
+  const store = new LocalStore17(dbPath);
+  const orgId = config.remote.orgId || "local";
+  const repoId = config.remote.repoId || "local";
+  try {
+    const memories = store.getMemoriesWithoutEmbeddings(orgId, repoId);
+    const stats = store.getEmbeddingStats(orgId, repoId);
+    logger.info(`Embedding stats:`);
+    logger.info(`  Total memories: ${stats.total}`);
+    logger.info(`  With embedding: ${stats.withEmbedding}`);
+    logger.info(`  Without embedding: ${stats.withoutEmbedding}`);
+    logger.info("");
+    if (memories.length === 0) {
+      logger.info("All memories already have embeddings.");
+      return;
+    }
+    logger.info(`Found ${memories.length} memories without embeddings.`);
+    if (opts.dryRun) {
+      logger.info("\n[Dry run - no changes made]");
+      logger.info("Would generate embeddings for:");
+      for (const m of memories.slice(0, 10)) {
+        logger.info(`  - ${m.id.slice(0, 8)}: ${m.text.slice(0, 50)}...`);
+      }
+      if (memories.length > 10) {
+        logger.info(`  ... and ${memories.length - 10} more`);
+      }
+      return;
+    }
+    const batchSize = parsePositiveInt6(opts.batchSize, "batch-size");
+    const delay = parsePositiveInt6(opts.delay, "delay");
+    let processed = 0;
+    let errors = 0;
+    logger.info(`
+Generating embeddings (batch size: ${batchSize}, delay: ${delay}ms)...`);
+    for (let i = 0; i < memories.length; i += batchSize) {
+      const batch = memories.slice(i, i + batchSize);
+      await Promise.all(
+        batch.map(async (memory) => {
+          try {
+            const result = await generateEmbedding(memory.text, {
+              apiKey,
+              model: opts.model
+            });
+            await store.storeEmbedding(memory.id, result.embedding, result.model);
+            processed++;
+            logger.progress(processed, memories.length, "embeddings");
+          } catch (err) {
+            errors++;
+            logger.error(`${memory.id.slice(0, 8)}: ${err instanceof Error ? err.message : err}`);
+          }
+        })
+      );
+      if (i + batchSize < memories.length) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    logger.info(`
+Backfill complete:`);
+    logger.info(`  Processed: ${processed}`);
+    logger.info(`  Errors: ${errors}`);
+  } finally {
+    store.close();
+  }
+});
+embeddingsCommand.command("stats").description("Show embedding statistics").action(async () => {
+  if (!isInitialized15(cwd3)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig20(cwd3);
+  const dbPath = getDbPath17(cwd3);
+  const store = new LocalStore17(dbPath);
+  const orgId = config.remote.orgId || "local";
+  const repoId = config.remote.repoId || "local";
+  try {
+    const stats = store.getEmbeddingStats(orgId, repoId);
+    const coverage = stats.total > 0 ? (stats.withEmbedding / stats.total * 100).toFixed(1) : "0";
+    if (isJsonMode()) {
+      outputJson({ ...stats, coverage: parseFloat(coverage) });
+      return;
+    }
+    logger.info("Embedding Statistics");
+    logger.info("====================");
+    logger.info(`Total memories:     ${stats.total}`);
+    logger.info(`With embedding:     ${stats.withEmbedding}`);
+    logger.info(`Without embedding:  ${stats.withoutEmbedding}`);
+    logger.info(`Coverage:           ${coverage}%`);
+    if (stats.withoutEmbedding > 0) {
+      logger.info(`
+Run 'unforgit embeddings backfill' to generate missing embeddings.`);
+    }
+  } finally {
+    store.close();
+  }
+});
+embeddingsCommand.command("clear").description("Remove all embeddings (requires regeneration)").option("--yes", "Skip confirmation").action(async (opts) => {
+  if (!isInitialized15(cwd3)) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  if (!opts.yes) {
+    logger.info("This will delete all embeddings. They will need to be regenerated.");
+    logger.info("Use --yes to confirm.");
+    return;
+  }
+  const dbPath = getDbPath17(cwd3);
+  const store = new LocalStore17(dbPath);
+  try {
+    const deleted = store.clearEmbeddings();
+    logger.info(`All embeddings cleared (${deleted} removed).`);
+  } finally {
+    store.close();
+  }
+});
+
+// src/commands/reset.ts
+import { Command as Command24 } from "commander";
+import { loadConfig as loadConfig21, getDbPath as getDbPath18 } from "unforgit-config";
+import { LocalStore as LocalStore18 } from "unforgit-db";
+import { RemoteClient as RemoteClient12 } from "unforgit-config";
+var resetCommand = new Command24("reset").description("Permanently delete all memories and related data").option("--local", "Reset local store only").option("--remote", "Reset remote store only").option("--force", "Skip confirmation prompt").addHelpText("after", `
+Examples:
+  unforgit reset                Reset both local and remote
+  unforgit reset --local        Reset local store only
+  unforgit reset --remote       Reset remote store only
+  unforgit reset --force        Skip confirmation`).action(async (opts) => {
+  const resetLocal = opts.local || !opts.local && !opts.remote;
+  const resetRemote = opts.remote || !opts.local && !opts.remote;
+  const targets = [
+    resetLocal ? "local" : null,
+    resetRemote ? "remote" : null
+  ].filter(Boolean);
+  if (!opts.force) {
+    logger.info(
+      `WARNING: This will permanently delete ALL memories, links, embeddings, and sync state from: ${targets.join(" + ")}`
+    );
+    logger.info("This action CANNOT be undone.");
+    const confirmed = await confirm("Type 'yes' to confirm");
+    if (!confirmed) {
+      logger.info("Reset cancelled.");
+      return;
+    }
+  }
+  const config = loadConfig21();
+  if (resetLocal) {
+    const store = new LocalStore18(getDbPath18());
+    try {
+      const result = store.resetAll();
+      logger.info(`Local reset complete:`);
+      logger.info(`  Memories deleted: ${result.memoriesDeleted}`);
+      logger.info(`  Links deleted: ${result.linksDeleted}`);
+      logger.info(`  Embeddings deleted: ${result.embeddingsDeleted}`);
+    } finally {
+      store.close();
+    }
+  }
+  if (resetRemote) {
+    if (!config.remote?.url) {
+      if (opts.remote) {
+        logger.error("No remote URL configured. Run 'unforgit init' first.");
+        process.exit(EXIT_ERROR);
+      }
+      logger.info("No remote configured, skipping remote reset.");
+      return;
+    }
+    const client = new RemoteClient12(config.remote.url);
+    const orgId = config.remote.orgId;
+    const repoId = config.remote.repoId;
+    if (!orgId || !repoId) {
+      logger.error("orgId and repoId must be configured for remote reset.");
+      process.exit(EXIT_ERROR);
+    }
+    try {
+      const result = await client.resetAll(orgId, repoId);
+      logger.info(`Remote reset complete:`);
+      logger.info(`  Memories deleted: ${result.memoriesDeleted}`);
+      logger.info(`  Links deleted: ${result.linksDeleted}`);
+      logger.info(`  Embeddings deleted: ${result.embeddingsDeleted}`);
+    } catch (err) {
+      logger.error(err instanceof Error ? err.message : String(err));
+      process.exit(EXIT_ERROR);
+    }
+  }
+});
+
+// src/commands/doctor.ts
+import { Command as Command25 } from "commander";
+import { loadConfig as loadConfig22, getDbPath as getDbPath19, isInitialized as isInitialized16, getConfigPath as getConfigPath2 } from "unforgit-config";
+import { LocalStore as LocalStore19 } from "unforgit-db";
+import { RemoteClient as RemoteClient13 } from "unforgit-config";
+import fs4 from "fs";
+var doctorCommand = new Command25("doctor").description("Check system health and diagnose common issues").action(async () => {
+  const results = [];
+  if (!isInitialized16()) {
+    results.push({
+      check: "initialization",
+      status: "error",
+      message: "Not an unforgit repository. Run 'unforgit init' first."
+    });
+    if (isJsonMode()) {
+      outputJson({ results });
+      return;
+    }
+    printResults(results);
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  results.push({ check: "initialization", status: "ok", message: "Repository initialized" });
+  const configPath = getConfigPath2();
+  try {
+    const config = loadConfig22();
+    results.push({ check: "config", status: "ok", message: `Valid config at ${configPath}` });
+    if (process.platform !== "win32") {
+      try {
+        const stat = fs4.statSync(configPath);
+        const mode = stat.mode & 511;
+        if (mode & 36) {
+          results.push({
+            check: "config-permissions",
+            status: "warn",
+            message: `Config readable by others (mode ${mode.toString(8)}). Run: chmod 600 ${configPath}`
+          });
+        } else {
+          results.push({ check: "config-permissions", status: "ok", message: "Config file permissions are secure" });
+        }
+      } catch {
+        results.push({ check: "config-permissions", status: "warn", message: "Could not check config file permissions" });
+      }
+    }
+    const store = new LocalStore19(getDbPath19());
+    try {
+      const orgId = config.remote.orgId || "local";
+      const repoId = config.remote.repoId || "local";
+      store.list({ orgId, repoId, limit: 1 });
+      results.push({ check: "local-db", status: "ok", message: "SQLite database is accessible" });
+      const stats = store.getEmbeddingStats(orgId, repoId);
+      if (stats.total === 0) {
+        results.push({ check: "embeddings", status: "ok", message: "No memories yet" });
+      } else if (stats.withoutEmbedding === 0) {
+        results.push({ check: "embeddings", status: "ok", message: `All ${stats.total} memories have embeddings` });
+      } else {
+        const pct = (stats.withEmbedding / stats.total * 100).toFixed(1);
+        results.push({
+          check: "embeddings",
+          status: "warn",
+          message: `${stats.withoutEmbedding}/${stats.total} memories lack embeddings (${pct}% coverage). Run 'unforgit embeddings backfill'`
+        });
+      }
+      const pendingPush = store.getPendingPush();
+      const conflicts = store.getConflicts();
+      if (conflicts.length > 0) {
+        results.push({
+          check: "sync",
+          status: "warn",
+          message: `${conflicts.length} sync conflict(s) need resolution`
+        });
+      } else if (pendingPush.length > 0) {
+        results.push({
+          check: "sync",
+          status: "ok",
+          message: `${pendingPush.length} memory(s) pending push`
+        });
+      } else {
+        results.push({ check: "sync", status: "ok", message: "Sync state clean" });
+      }
+    } finally {
+      store.close();
+    }
+    const apiKey = process.env.UNFORGIT_API_KEY;
+    if (config.remote.url) {
+      if (!apiKey) {
+        results.push({
+          check: "auth",
+          status: "warn",
+          message: "No API key configured. Set the UNFORGIT_API_KEY environment variable."
+        });
+      } else {
+        results.push({
+          check: "auth",
+          status: "ok",
+          message: `API key configured: ${maskKey(apiKey)}`
+        });
+      }
+      try {
+        const res = await fetch(`${config.remote.url}/health`);
+        if (res.ok) {
+          results.push({ check: "remote", status: "ok", message: `Server reachable at ${config.remote.url}` });
+          if (apiKey) {
+            const client = new RemoteClient13(config.remote.url);
+            try {
+              await client.listApiKeys();
+              results.push({ check: "remote-auth", status: "ok", message: "API key is valid" });
+            } catch {
+              results.push({ check: "remote-auth", status: "error", message: "API key is invalid or expired" });
+            }
+          }
+        } else {
+          results.push({
+            check: "remote",
+            status: "error",
+            message: `Server returned HTTP ${res.status}`
+          });
+        }
+      } catch (err) {
+        results.push({
+          check: "remote",
+          status: "error",
+          message: `Cannot connect to ${config.remote.url}: ${err instanceof Error ? err.message : err}`
+        });
+      }
+    } else {
+      results.push({ check: "remote", status: "warn", message: "No remote URL configured" });
+    }
+    const openaiKey = process.env.OPENAI_API_KEY;
+    if (openaiKey) {
+      results.push({ check: "openai", status: "ok", message: `OpenAI API key configured: ${maskKey(openaiKey)}` });
+    } else {
+      results.push({
+        check: "openai",
+        status: "warn",
+        message: "No OpenAI API key. Auto-consolidation and embeddings backfill require it."
+      });
+    }
+  } catch (err) {
+    results.push({
+      check: "config",
+      status: "error",
+      message: err instanceof Error ? err.message : String(err)
+    });
+  }
+  if (isJsonMode()) {
+    outputJson({ results });
+    return;
+  }
+  printResults(results);
+});
+function printResults(results) {
+  const icons = { ok: "[ok]", warn: "[!!]", error: "[ERR]" };
+  logger.info("Unforgit Doctor\n");
+  for (const r of results) {
+    const icon = icons[r.status];
+    logger.info(`  ${icon} ${r.check}: ${r.message}`);
+  }
+  const errors = results.filter((r) => r.status === "error").length;
+  const warnings = results.filter((r) => r.status === "warn").length;
+  logger.info("");
+  if (errors > 0) {
+    logger.info(`${errors} error(s), ${warnings} warning(s)`);
+  } else if (warnings > 0) {
+    logger.info(`No errors, ${warnings} warning(s)`);
+  } else {
+    logger.info("All checks passed!");
+  }
+}
+
+// src/commands/completion.ts
+import { Command as Command26 } from "commander";
+var BASH_COMPLETION = `
+_unforgit_completions() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="init add recall promote consolidate deprecate supersede delete restore web link unlink links merge remerge similar history auto-consolidate unconsolidate status push pull remote log diff keys auth config embeddings reset doctor curate completion"
+
+  case "\${prev}" in
+    unforgit)
+      COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+      return 0
+      ;;
+    remote)
+      COMPREPLY=( $(compgen -W "add remove set-url show" -- "\${cur}") )
+      return 0
+      ;;
+    keys)
+      COMPREPLY=( $(compgen -W "create list revoke" -- "\${cur}") )
+      return 0
+      ;;
+    auth)
+      COMPREPLY=( $(compgen -W "set status remove openai openai-remove" -- "\${cur}") )
+      return 0
+      ;;
+    config)
+      COMPREPLY=( $(compgen -W "list get set unset" -- "\${cur}") )
+      return 0
+      ;;
+    embeddings)
+      COMPREPLY=( $(compgen -W "backfill stats clear" -- "\${cur}") )
+      return 0
+      ;;
+    --type)
+      COMPREPLY=( $(compgen -W "episodic semantic procedural" -- "\${cur}") )
+      return 0
+      ;;
+  esac
+
+  if [[ "\${cur}" == -* ]]; then
+    COMPREPLY=( $(compgen -W "--verbose --quiet --json --help --version" -- "\${cur}") )
+    return 0
+  fi
+}
+complete -F _unforgit_completions unforgit
+`.trim();
+var ZSH_COMPLETION = `
+#compdef unforgit
+
+_unforgit() {
+  local -a commands
+  commands=(
+    'init:Initialize Unforgit in the current repository'
+    'add:Add a memory'
+    'recall:Recall memories matching a query'
+    'promote:Promote a local memory to remote'
+    'consolidate:Consolidate episodic memories'
+    'deprecate:Mark a memory as deprecated'
+    'supersede:Mark a memory as superseded'
+    'delete:Soft delete a memory'
+    'restore:Restore a soft-deleted memory'
+    'web:Start the web dashboard'
+    'link:Create a link between memories'
+    'unlink:Remove a link between memories'
+    'links:List links for a memory'
+    'merge:Consolidate multiple local memories'
+    'remerge:Update an existing consolidation'
+    'similar:Find similar memories'
+    'history:Show consolidation history'
+    'auto-consolidate:AI-powered consolidation'
+    'unconsolidate:Revert a consolidation'
+    'status:Show sync status'
+    'push:Push local memories to remote'
+    'pull:Pull remote memories to local'
+    'remote:Manage remotes'
+    'log:Show memory history log'
+    'diff:Show differences between local and remote'
+    'keys:Manage API keys'
+    'auth:Configure authentication'
+    'config:Manage configuration'
+    'embeddings:Manage embeddings'
+    'reset:Delete all memories'
+    'doctor:Check system health'
+    'curate:Preview or run lifecycle maintenance'
+    'completion:Generate shell completions'
+  )
+
+  _arguments -C \\
+    '--verbose[Enable verbose output]' \\
+    '--quiet[Suppress non-essential output]' \\
+    '--json[Output as JSON]' \\
+    '--help[Show help]' \\
+    '--version[Show version]' \\
+    '1: :->cmd' \\
+    '*::arg:->args'
+
+  case "$state" in
+    cmd)
+      _describe 'command' commands
+      ;;
+  esac
+}
+
+_unforgit "$@"
+`.trim();
+var FISH_COMPLETION = `
+complete -c unforgit -f
+complete -c unforgit -n '__fish_use_subcommand' -a 'init' -d 'Initialize Unforgit'
+complete -c unforgit -n '__fish_use_subcommand' -a 'add' -d 'Add a memory'
+complete -c unforgit -n '__fish_use_subcommand' -a 'recall' -d 'Recall memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'promote' -d 'Promote to remote'
+complete -c unforgit -n '__fish_use_subcommand' -a 'consolidate' -d 'Consolidate memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'deprecate' -d 'Deprecate a memory'
+complete -c unforgit -n '__fish_use_subcommand' -a 'supersede' -d 'Supersede a memory'
+complete -c unforgit -n '__fish_use_subcommand' -a 'delete' -d 'Delete a memory'
+complete -c unforgit -n '__fish_use_subcommand' -a 'restore' -d 'Restore a memory'
+complete -c unforgit -n '__fish_use_subcommand' -a 'web' -d 'Start web dashboard'
+complete -c unforgit -n '__fish_use_subcommand' -a 'link' -d 'Link two memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'unlink' -d 'Unlink memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'links' -d 'List links'
+complete -c unforgit -n '__fish_use_subcommand' -a 'merge' -d 'Merge memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'remerge' -d 'Update consolidation'
+complete -c unforgit -n '__fish_use_subcommand' -a 'similar' -d 'Find similar memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'history' -d 'Consolidation history'
+complete -c unforgit -n '__fish_use_subcommand' -a 'auto-consolidate' -d 'AI consolidation'
+complete -c unforgit -n '__fish_use_subcommand' -a 'unconsolidate' -d 'Revert consolidation'
+complete -c unforgit -n '__fish_use_subcommand' -a 'status' -d 'Show sync status'
+complete -c unforgit -n '__fish_use_subcommand' -a 'push' -d 'Push to remote'
+complete -c unforgit -n '__fish_use_subcommand' -a 'pull' -d 'Pull from remote'
+complete -c unforgit -n '__fish_use_subcommand' -a 'remote' -d 'Manage remotes'
+complete -c unforgit -n '__fish_use_subcommand' -a 'log' -d 'Memory log'
+complete -c unforgit -n '__fish_use_subcommand' -a 'diff' -d 'Show differences'
+complete -c unforgit -n '__fish_use_subcommand' -a 'keys' -d 'Manage API keys'
+complete -c unforgit -n '__fish_use_subcommand' -a 'auth' -d 'Configure auth'
+complete -c unforgit -n '__fish_use_subcommand' -a 'config' -d 'Manage config'
+complete -c unforgit -n '__fish_use_subcommand' -a 'embeddings' -d 'Manage embeddings'
+complete -c unforgit -n '__fish_use_subcommand' -a 'reset' -d 'Delete all memories'
+complete -c unforgit -n '__fish_use_subcommand' -a 'doctor' -d 'Check system health'
+complete -c unforgit -n '__fish_use_subcommand' -a 'curate' -d 'Preview or run lifecycle maintenance'
+complete -c unforgit -n '__fish_use_subcommand' -a 'completion' -d 'Generate completions'
+complete -c unforgit -l verbose -d 'Enable verbose output'
+complete -c unforgit -l quiet -d 'Suppress non-essential output'
+complete -c unforgit -l json -d 'Output as JSON'
+`.trim();
+var completionCommand = new Command26("completion").description("Generate shell completion scripts").argument("<shell>", "Shell type (bash, zsh, fish)").addHelpText("after", `
+Examples:
+  unforgit completion bash >> ~/.bashrc
+  unforgit completion zsh >> ~/.zshrc
+  unforgit completion fish > ~/.config/fish/completions/unforgit.fish`).action((shell) => {
+  switch (shell.toLowerCase()) {
+    case "bash":
+      console.log(BASH_COMPLETION);
+      break;
+    case "zsh":
+      console.log(ZSH_COMPLETION);
+      break;
+    case "fish":
+      console.log(FISH_COMPLETION);
+      break;
+    default:
+      logger.error(`Unsupported shell: ${shell}. Use bash, zsh, or fish.`);
+      process.exit(1);
+  }
+});
+
+// src/commands/curate.ts
+import { Command as Command27 } from "commander";
+import { getDbPath as getDbPath20, isInitialized as isInitialized17, loadConfig as loadConfig23 } from "unforgit-config";
+import { LocalStore as LocalStore20 } from "unforgit-db";
+import { RemoteClient as RemoteClient14 } from "unforgit-config";
+import { runLocalLifecycleMaintenance } from "unforgit-core";
+function formatCandidatePreview2(candidate) {
+  const lines = [
+    `Group: ${candidate.reason}`,
+    `Tags: ${candidate.suggestedTags.join(", ") || "none"}`,
+    "Memories:"
+  ];
+  for (const memory of candidate.memories) {
+    const text = memory.text.length > 80 ? `${memory.text.slice(0, 80)}...` : memory.text;
+    lines.push(`  - [${memory.memoryType}] ${memory.id.slice(0, 8)}: ${text}`);
+  }
+  return lines.join("\n");
+}
+var curateCommand = new Command27("curate").description("Preview or run lifecycle maintenance for repository memories").option("--remote", "Run maintenance against the remote server").option("--execute", "Apply changes instead of previewing them").option("--model <model>", "OpenAI model to use for consolidation").option("--no-preserve", "Do not preserve original memories during consolidation").addHelpText("after", `
+Examples:
+  unforgit curate
+  unforgit curate --execute
+  unforgit curate --remote --execute --model gpt-5.4`).action(async (opts) => {
+  if (!isInitialized17()) {
+    logger.error("Unforgit not initialized. Run 'unforgit init' first.");
+    process.exit(EXIT_CONFIG_ERROR);
+  }
+  const config = loadConfig23();
+  const orgId = config.remote.orgId || "local";
+  const repoId = config.remote.repoId || "local";
+  const dryRun = opts.execute ? false : void 0;
+  try {
+    const result = opts.remote ? await runRemoteCurate(config.remote.url, {
+      orgId,
+      repoId,
+      dryRun,
+      model: opts.model,
+      preserveOriginals: opts.preserve !== false
+    }) : await runLocalCurate(getDbPath20(), orgId, repoId, {
+      dryRun,
+      model: opts.model,
+      preserveOriginals: opts.preserve !== false,
+      lifecycle: config.lifecycle
+    });
+    if (isJsonMode()) {
+      outputJson(result);
+      return;
+    }
+    logger.info(result.dryRun ? "Lifecycle maintenance preview\n" : "Lifecycle maintenance execution\n");
+    logger.info(`Active memories scanned: ${result.totalActiveMemories}`);
+    logger.info(`Expiring episodic memories: ${result.expiredCandidates.length}`);
+    logger.info(`Strengthened candidates: ${result.strengthenedCandidates.length}`);
+    logger.info(`Consolidation candidates: ${result.consolidationCandidates.length}`);
+    if (result.expiredCandidates.length > 0) {
+      logger.info("\nExpired candidates:");
+      for (const candidate of result.expiredCandidates.slice(0, 10)) {
+        logger.info(`  ${candidate.id.slice(0, 8)} (${candidate.ttlSeconds}s): ${candidate.textPreview}`);
+      }
+    }
+    if (result.strengthenedCandidates.length > 0) {
+      logger.info("\nStrengthened candidates:");
+      for (const candidate of result.strengthenedCandidates.slice(0, 10)) {
+        logger.info(
+          `  ${candidate.id.slice(0, 8)} [${candidate.recommendedAction}] (${candidate.usageCount} recalls): ${candidate.textPreview}`
+        );
+      }
+    }
+    if (result.consolidationCandidates.length > 0) {
+      logger.info("\nConsolidation candidates:");
+      for (const candidate of result.consolidationCandidates.slice(0, 5)) {
+        logger.info(formatCandidatePreview2(candidate));
+        logger.info("");
+      }
+    }
+    if (!result.dryRun && result.executedConsolidations.length > 0) {
+      logger.info("Executed consolidations:");
+      for (const executed of result.executedConsolidations) {
+        logger.info(
+          `  ${executed.consolidatedId.slice(0, 8)} from ${executed.sourceIds.length} memories`
+        );
+      }
+    }
+    for (const warning of result.warnings) {
+      logger.warn(warning);
+    }
+    for (const error of result.errors) {
+      logger.error(error);
+    }
+    if (result.dryRun) {
+      logger.info("\nDry run complete. Re-run with --execute to apply expiry and consolidation.");
+    }
+  } catch (error) {
+    logger.error(
+      `Curate: ${error instanceof Error ? error.message : error}`
+    );
+    process.exit(EXIT_ERROR);
+  }
+});
+async function runLocalCurate(dbPath, orgId, repoId, options) {
+  const store = new LocalStore20(dbPath);
+  try {
+    return await runLocalLifecycleMaintenance(store, orgId, repoId, options);
+  } finally {
+    store.close();
+  }
+}
+async function runRemoteCurate(remoteUrl, options) {
+  if (!remoteUrl) {
+    throw new Error("Remote URL not configured. Update unforgit.yaml or omit --remote.");
+  }
+  const client = new RemoteClient14(remoteUrl);
+  return client.runLifecycle(options);
+}
+
+// src/index.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var cleanupHandlers = [];
+function registerCleanup(fn) {
+  cleanupHandlers.push(fn);
+}
+function unregisterCleanup(fn) {
+  const idx = cleanupHandlers.indexOf(fn);
+  if (idx >= 0) cleanupHandlers.splice(idx, 1);
+}
+function runCleanup() {
+  for (const fn of cleanupHandlers) {
+    try {
+      fn();
+    } catch {
+    }
+  }
+}
+process.on("SIGINT", () => {
+  runCleanup();
+  process.exit(EXIT_SIGINT);
+});
+process.on("SIGTERM", () => {
+  runCleanup();
+  process.exit(EXIT_SIGTERM);
+});
+process.on("uncaughtException", (err) => {
+  console.error(`fatal: ${err.message}`);
+  runCleanup();
+  process.exit(EXIT_ERROR);
+});
+process.on("unhandledRejection", (err) => {
+  console.error(`fatal: ${err instanceof Error ? err.message : err}`);
+  runCleanup();
+  process.exit(EXIT_ERROR);
+});
+var program = new Command28();
+program.name("unforgit").description("Unforgit \u2014 repository memory for agents and developers").version(pkg.version).option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--json", "Output results as JSON (for scripting)").hook("preAction", () => {
+  const opts = program.opts();
+  if (opts.quiet) setVerbosity(0);
+  else if (opts.verbose) setVerbosity(2);
+  if (opts.json) setJsonMode(true);
+});
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(recallCommand);
+program.addCommand(promoteCommand);
+program.addCommand(consolidateCommand);
+program.addCommand(deprecateCommand);
+program.addCommand(supersedeCommand);
+program.addCommand(webCommand);
+program.addCommand(linkCommand);
+program.addCommand(unlinkCommand);
+program.addCommand(linksCommand);
+program.addCommand(mergeCommand);
+program.addCommand(remergeCommand);
+program.addCommand(similarCommand);
+program.addCommand(historyCommand);
+program.addCommand(deleteCommand);
+program.addCommand(restoreCommand);
+program.addCommand(autoConsolidateCommand);
+program.addCommand(unconsolidateCommand);
+program.addCommand(statusCommand);
+program.addCommand(pushCommand);
+program.addCommand(pullCommand);
+program.addCommand(remoteCommand);
+program.addCommand(logCommand);
+program.addCommand(diffCommand);
+program.addCommand(keysCommand);
+program.addCommand(authCommand);
+program.addCommand(configCommand);
+program.addCommand(embeddingsCommand);
+program.addCommand(resetCommand);
+program.addCommand(doctorCommand);
+program.addCommand(curateCommand);
+program.addCommand(completionCommand);
+program.parseAsync().catch((err) => {
+  console.error(`fatal: ${err instanceof Error ? err.message : err}`);
+  runCleanup();
+  process.exit(EXIT_ERROR);
+});
+export {
+  registerCleanup,
+  unregisterCleanup
+};
+//# sourceMappingURL=index.js.map