unforgit 0.5.6 → 0.7.0

package/dist/index.js

@@ -17,6 +17,7 @@ import {
   getDbPath,
   getTemplate,
   isInitialized,
+  isOpenAIConfigured,
   loadConfig,
   mergeAndRank,
   parseConfidence,
@@ -24,12 +25,13 @@ import {
   parseThreshold,
   parseTtl,
   persistReviewableSuggestions,
+  resolveEmbeddingProvider,
   resolveLifecycleConfig,
   resolveVisibility,
   runLocalLifecycleMaintenance,
   saveConfig,
   validateMemoryType
-} from "./chunk-CKUDYQYP.js";
+} from "./chunk-TGDR7Y7T.js";
 
 // src/index.ts
 import { Command as Command31 } from "commander";
@@ -808,11 +810,130 @@ Examples:
 });
 
 // src/commands/delete.ts
+import { Command as Command9 } from "commander";
+
+// src/commands/backups.ts
+import fs3 from "fs";
+import path2 from "path";
 import { Command as Command8 } from "commander";
-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", `
+function formatBackupTimestamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace("T", "-").replace(/\.\d{3}Z$/, "");
+}
+function backupRootForDb(dbPath) {
+  return path2.join(path2.dirname(dbPath), "backups");
+}
+function describeBackup(dir) {
+  const files = fs3.readdirSync(dir).filter((file) => file === "local.db" || file === "local.db-wal" || file === "local.db-shm").sort();
+  const sizeBytes = files.reduce((total, file) => total + fs3.statSync(path2.join(dir, file)).size, 0);
+  const stat = fs3.statSync(dir);
+  return {
+    name: path2.basename(dir),
+    dir,
+    files,
+    sizeBytes,
+    createdAt: stat.mtime.toISOString()
+  };
+}
+function resolveBackupDir(backupRoot, backupName) {
+  if (backupName !== path2.basename(backupName)) {
+    throw new Error("Invalid backup name");
+  }
+  const resolvedRoot = path2.resolve(backupRoot);
+  const resolvedBackup = path2.resolve(resolvedRoot, backupName);
+  if (!resolvedBackup.startsWith(`${resolvedRoot}${path2.sep}`)) {
+    throw new Error("Invalid backup name");
+  }
+  return resolvedBackup;
+}
+function createLocalDatabaseBackup(dbPath, prefix, now = /* @__PURE__ */ new Date()) {
+  if (!fs3.existsSync(dbPath)) {
+    return null;
+  }
+  const backupRoot = backupRootForDb(dbPath);
+  const baseName = `${prefix}-${formatBackupTimestamp(now)}`;
+  let backupDir = path2.join(backupRoot, baseName);
+  let suffix = 1;
+  while (fs3.existsSync(backupDir)) {
+    backupDir = path2.join(backupRoot, `${baseName}-${suffix++}`);
+  }
+  fs3.mkdirSync(backupDir, { recursive: true, mode: 448 });
+  for (const source of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (!fs3.existsSync(source)) continue;
+    fs3.copyFileSync(source, path2.join(backupDir, path2.basename(source)));
+  }
+  return describeBackup(backupDir);
+}
+function createLocalResetBackup(dbPath, now = /* @__PURE__ */ new Date()) {
+  return createLocalDatabaseBackup(dbPath, "reset", now);
+}
+function listLocalResetBackups(dbPath) {
+  const backupRoot = backupRootForDb(dbPath);
+  if (!fs3.existsSync(backupRoot)) {
+    return [];
+  }
+  return fs3.readdirSync(backupRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("reset-")).map((entry) => describeBackup(path2.join(backupRoot, entry.name))).filter((backup) => backup.files.includes("local.db")).sort((a, b) => b.name.localeCompare(a.name));
+}
+function restoreLocalResetBackup(dbPath, backupName, now = /* @__PURE__ */ new Date()) {
+  const backupRoot = backupRootForDb(dbPath);
+  const backupDir = resolveBackupDir(backupRoot, backupName);
+  if (!fs3.existsSync(backupDir) || !fs3.statSync(backupDir).isDirectory()) {
+    throw new Error(`Backup not found: ${backupName}`);
+  }
+  const restoredFrom = describeBackup(backupDir);
+  if (!restoredFrom.files.includes("local.db")) {
+    throw new Error(`Backup is missing local.db: ${backupName}`);
+  }
+  const safetyBackup = createLocalResetBackup(dbPath, now);
+  fs3.mkdirSync(path2.dirname(dbPath), { recursive: true });
+  for (const target of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (fs3.existsSync(target)) {
+      fs3.rmSync(target, { force: true });
+    }
+  }
+  for (const file of restoredFrom.files) {
+    fs3.copyFileSync(path2.join(backupDir, file), path2.join(path2.dirname(dbPath), file));
+  }
+  return { restoredFrom, safetyBackup };
+}
+var backupsCommand = new Command8("backups").description("List and restore local reset backups");
+backupsCommand.command("list").description("List local backups created before destructive resets/restores").action(() => {
+  const backups = listLocalResetBackups(getDbPath());
+  if (backups.length === 0) {
+    logger.info("No local reset backups found.");
+    return;
+  }
+  for (const backup of backups) {
+    logger.info(`${backup.name}	${backup.sizeBytes} bytes	${backup.dir}`);
+  }
+});
+backupsCommand.command("restore").argument("<name>", "Backup directory name, for example reset-20260610-123456").description("Restore a local reset backup into the active local database").option("--force", "Skip confirmation prompt").action(async (name, opts) => {
+  if (!opts.force) {
+    const ok = await confirm(
+      "This will replace the active local database after creating a safety backup. Continue?"
+    );
+    if (!ok) {
+      logger.info("Aborted.");
+      return;
+    }
+  }
+  try {
+    const result = restoreLocalResetBackup(getDbPath(), name);
+    logger.info(`Restored local database from ${result.restoredFrom.name}`);
+    if (result.safetyBackup) {
+      logger.info(`Previous local database safety backup: ${result.safetyBackup.dir}`);
+    }
+  } catch (err) {
+    logger.error(err instanceof Error ? err.message : String(err));
+    process.exit(EXIT_ERROR);
+  }
+});
+
+// src/commands/delete.ts
+var deleteCommand = new Command9("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").option("--no-backup", "Skip automatic local database backup before local hard delete").addHelpText("after", `
 Examples:
   unforgit delete abc12345              Soft delete (can be restored)
-  unforgit delete abc12345 --hard       Permanent delete
+  unforgit delete abc12345 --hard       Permanent delete, with local backup by default
+  unforgit delete abc12345 --hard --no-backup
   unforgit delete abc12345 --remote     Delete on remote server`).action(async (id, opts) => {
   if (opts.hard && !opts.force) {
     const confirmed = await confirm(
@@ -838,7 +959,21 @@ Examples:
     }
     return;
   }
-  const store = new LocalStore(getDbPath());
+  const dbPath = getDbPath();
+  if (opts.hard && opts.backup !== false) {
+    try {
+      const backup = createLocalDatabaseBackup(dbPath, "hard-delete");
+      if (backup) {
+        logger.info(`Created local hard-delete backup: ${backup.dir}`);
+      }
+    } catch (err) {
+      logger.error(
+        `Failed to create local hard-delete backup: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(EXIT_ERROR);
+    }
+  }
+  const store = new LocalStore(dbPath);
   try {
     let ok;
     if (opts.hard) {
@@ -859,7 +994,7 @@ Examples:
     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) => {
+var restoreCommand = new Command9("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 = loadConfig();
     const client = new RemoteClient(config.remote.url);
@@ -888,11 +1023,11 @@ var restoreCommand = new Command8("restore").description("Restore a soft-deleted
 });
 
 // src/commands/web.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 import { spawn } from "child_process";
-import path2 from "path";
-import fs3 from "fs";
-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) => {
+import path3 from "path";
+import fs4 from "fs";
+var webCommand = new Command10("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 (!isInitialized(cwd4)) {
     logger.error("Unforgit not initialized in this directory. Run 'unforgit init' first.");
@@ -908,9 +1043,9 @@ var webCommand = new Command9("web").description("Start the Unforgit web dashboa
     UNFORGIT_WORKSPACE: cwd4,
     PORT: opts.port
   };
-  const dotenvPath = path2.join(cwd4, ".env");
-  if (fs3.existsSync(dotenvPath)) {
-    const content = fs3.readFileSync(dotenvPath, "utf-8");
+  const dotenvPath = path3.join(cwd4, ".env");
+  if (fs4.existsSync(dotenvPath)) {
+    const content = fs4.readFileSync(dotenvPath, "utf-8");
     for (const line of content.split("\n")) {
       const match = line.match(/^\s*([^#=]+?)\s*=\s*(.+?)\s*$/);
       if (match) {
@@ -920,11 +1055,11 @@ var webCommand = new Command9("web").description("Start the Unforgit web dashboa
   }
   logger.info(`Starting Unforgit web dashboard on port ${opts.port}...`);
   logger.info(`Workspace: ${cwd4}`);
-  const hasNextBuild = fs3.existsSync(path2.join(webDir, ".next"));
+  const hasNextBuild = fs4.existsSync(path3.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 nextBin = path3.join(webDir, "node_modules", ".bin", "next");
+  const finalCmd = fs4.existsSync(nextBin) ? nextBin : cmd;
   const child = spawn(finalCmd, args, {
     cwd: webDir,
     env,
@@ -947,12 +1082,12 @@ var webCommand = new Command9("web").description("Start the Unforgit web dashboa
 });
 function findWebDir() {
   const candidates = [
-    path2.resolve(import.meta.dirname, "../../../web"),
-    path2.resolve(import.meta.dirname, "../../web"),
-    path2.join(process.cwd(), "web")
+    path3.resolve(import.meta.dirname, "../../../web"),
+    path3.resolve(import.meta.dirname, "../../web"),
+    path3.join(process.cwd(), "web")
   ];
   for (const dir of candidates) {
-    if (fs3.existsSync(dir) && fs3.existsSync(path2.join(dir, "package.json"))) {
+    if (fs4.existsSync(dir) && fs4.existsSync(path3.join(dir, "package.json"))) {
       return dir;
     }
   }
@@ -960,14 +1095,14 @@ function findWebDir() {
 }
 
 // src/commands/link.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 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(
+var linkCommand = new Command11("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", `
@@ -1037,7 +1172,7 @@ Examples:
     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(
+var unlinkCommand = new Command11("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) => {
@@ -1077,7 +1212,7 @@ var unlinkCommand = new Command10("unlink").description("Remove a link between t
     store.close();
   }
 });
-var linksCommand = new Command10("links").description("List all links for a memory").argument("<memory-id>", "Memory ID to get links for").option(
+var linksCommand = new Command11("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) => {
@@ -1147,9 +1282,9 @@ var linksCommand = new Command10("links").description("List all links for a memo
 });
 
 // src/commands/merge.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 var cwd = process.cwd();
-var mergeCommand = new Command11("merge").description(
+var mergeCommand = new Command12("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>",
@@ -1221,7 +1356,7 @@ var mergeCommand = new Command11("merge").description(
     store.close();
   }
 });
-var remergeCommand = new Command11("remerge").description(
+var remergeCommand = new Command12("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>",
@@ -1260,7 +1395,7 @@ var remergeCommand = new Command11("remerge").description(
     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(
+var similarCommand = new Command12("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"
@@ -1324,7 +1459,7 @@ Examples:
     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) => {
+var historyCommand = new Command12("history").description("Show consolidation history for a memory").argument("<memory-id>", "Memory ID to show history for").action(async (memoryId) => {
   if (!isInitialized(cwd)) {
     logger.error("Unforgit not initialized. Run 'unforgit init' first.");
     process.exit(EXIT_CONFIG_ERROR);
@@ -1389,7 +1524,7 @@ var historyCommand = new Command11("history").description("Show consolidation hi
 });
 
 // src/commands/auto-consolidate.ts
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 import * as readline2 from "readline";
 var cwd2 = process.cwd();
 function createReadlineInterface() {
@@ -1405,7 +1540,7 @@ async function askConfirmation(rl, question) {
     });
   });
 }
-var autoConsolidateCommand = new Command12("auto-consolidate").description(
+var autoConsolidateCommand = new Command13("auto-consolidate").description(
   "Automatically find and consolidate similar memories using AI"
 ).option(
   "--threshold <score>",
@@ -1570,8 +1705,8 @@ Original memories are preserved with status 'superseded'.`
 });
 
 // src/commands/unconsolidate.ts
-import { Command as Command13 } from "commander";
-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", `
+import { Command as Command14 } from "commander";
+var unconsolidateCommand = new Command14("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) => {
@@ -1645,8 +1780,8 @@ Examples:
 });
 
 // src/commands/status.ts
-import { Command as Command14 } from "commander";
-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", `
+import { Command as Command15 } from "commander";
+var statusCommand = new Command15("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
@@ -1664,32 +1799,50 @@ Examples:
     const remoteUrl = config.remote.url;
     const remoteName = "origin";
     const pendingPush = store.getPendingPush();
+    const pendingPull = store.getSyncStatesByStatus("pending_pull").map((syncState) => {
+      const memory = store.getById(syncState.memoryId);
+      return memory ? { memory, syncState } : void 0;
+    }).filter((item) => Boolean(item));
     const conflicts = store.getConflicts();
     const untracked = store.getUntrackedMemories(orgId, repoId);
     const summary = store.getSyncSummary(orgId, repoId);
     if (isJsonMode()) {
+      const clean = pendingPush.length === 0 && pendingPull.length === 0 && conflicts.length === 0 && untracked.length === 0;
       outputJson({
         remote: remoteUrl || null,
+        remoteConfigured: Boolean(remoteUrl),
+        synced: summary.synced,
         pendingPush: pendingPush.length,
+        pendingPull: pendingPull.length,
         conflicts: conflicts.length,
         untracked: untracked.length,
-        synced: summary.synced
+        clean,
+        recommendations: buildRecommendations(Boolean(remoteUrl), pendingPush.length, pendingPull.length, conflicts.length, untracked.length),
+        details: {
+          pendingPush: pendingPush.map(toDetailsItem),
+          pendingPull: pendingPull.map(toDetailsItem),
+          conflicts: conflicts.map(toDetailsItem),
+          untracked: untracked.map((memory) => ({ id: memory.id, preview: truncate(memory.text, 80), status: memory.status }))
+        }
       });
       return;
     }
     if (opts.short) {
-      printShortStatus(pendingPush, conflicts, untracked);
+      printShortStatus(pendingPush, pendingPull, conflicts, untracked);
     } else {
-      printLongStatus(remoteName, remoteUrl, pendingPush, conflicts, untracked, summary);
+      printLongStatus(remoteName, remoteUrl, pendingPush, pendingPull, conflicts, untracked, summary);
     }
   } finally {
     store.close();
   }
 });
-function printShortStatus(pendingPush, conflicts, untracked) {
+function printShortStatus(pendingPush, pendingPull, conflicts, untracked) {
   for (const { memory } of pendingPush) {
     logger.info(`M  ${memory.id.slice(0, 8)} ${truncate(memory.text, 50)}`);
   }
+  for (const { memory } of pendingPull) {
+    logger.info(`P  ${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)}`);
   }
@@ -1697,15 +1850,15 @@ function printShortStatus(pendingPush, conflicts, untracked) {
     logger.info(`?? ${memory.id.slice(0, 8)} ${truncate(memory.text, 50)}`);
   }
 }
-function printLongStatus(remoteName, remoteUrl, pendingPush, conflicts, untracked, summary) {
+function printLongStatus(remoteName, remoteUrl, pendingPush, pendingPull, 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 (pendingPush.length === 0 && pendingPull.length === 0 && conflicts.length === 0 && untracked.length === 0) {
+    logger.info("Nothing to push or pull, working tree clean");
     if (summary.synced > 0) {
       logger.info(`  ${summary.synced} memories synced with remote`);
     }
@@ -1721,6 +1874,15 @@ function printLongStatus(remoteName, remoteUrl, pendingPush, conflicts, untracke
     }
     logger.info("");
   }
+  if (pendingPull.length > 0) {
+    logger.info("Changes to be pulled:");
+    logger.info('  (use "unforgit pull" to sync from remote)');
+    logger.info("");
+    for (const { memory } of pendingPull) {
+      logger.info(`        remote update: ${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)');
@@ -1740,13 +1902,43 @@ function printLongStatus(remoteName, remoteUrl, pendingPush, conflicts, untracke
     }
     logger.info("");
   }
-  const total = pendingPush.length + conflicts.length + untracked.length;
+  const total = pendingPush.length + pendingPull.length + conflicts.length + untracked.length;
   logger.info(`${total} change(s) pending`);
 }
+function buildRecommendations(remoteConfigured, pendingPush, pendingPull, conflicts, untracked) {
+  const recommendations = [];
+  if (!remoteConfigured && (pendingPush > 0 || pendingPull > 0 || untracked > 0)) {
+    recommendations.push("Configure a remote with 'unforgit remote add origin <url>' or keep this repository intentionally local-only.");
+    return recommendations;
+  }
+  if (conflicts > 0) {
+    recommendations.push("Review conflicts, then run 'unforgit pull --force' to accept remote or 'unforgit push --force' to keep local.");
+  }
+  if (pendingPush > 0 || untracked > 0) {
+    recommendations.push("Run 'unforgit push' to publish local memory changes.");
+  }
+  if (pendingPull > 0) {
+    recommendations.push("Run 'unforgit pull' to fetch remote memory changes.");
+  }
+  return recommendations;
+}
+function toDetailsItem(item) {
+  const { memory, syncState } = item;
+  return {
+    id: memory.id,
+    preview: truncate(memory.text, 80),
+    status: memory.status,
+    syncStatus: syncState.syncStatus,
+    localVersion: syncState.localVersion,
+    remoteVersion: syncState.remoteVersion,
+    lastPushedAt: syncState.lastPushedAt?.toISOString(),
+    lastPulledAt: syncState.lastPulledAt?.toISOString()
+  };
+}
 
 // src/commands/push.ts
-import { Command as Command15 } from "commander";
-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) => {
+import { Command as Command16 } from "commander";
+var pushCommand = new Command16("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 (!isInitialized()) {
     logger.fatal("not an unforgit repository");
     process.exit(EXIT_CONFIG_ERROR);
@@ -1890,8 +2082,8 @@ Total: ${allToPush.length} memories, ${supersededToSync.length} status updates,
 });
 
 // src/commands/pull.ts
-import { Command as Command16 } from "commander";
-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) => {
+import { Command as Command17 } from "commander";
+var pullCommand = new Command17("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 (!isInitialized()) {
     logger.fatal("not an unforgit repository");
     process.exit(EXIT_CONFIG_ERROR);
@@ -2036,8 +2228,8 @@ Would pull:`);
 });
 
 // src/commands/remote.ts
-import { Command as Command17 } from "commander";
-var remoteCommand = new Command17("remote").description("Manage set of tracked remote repositories").addHelpText("after", `
+import { Command as Command18 } from "commander";
+var remoteCommand = new Command18("remote").description("Manage set of tracked remote repositories").addHelpText("after", `
 Examples:
   unforgit remote                        List remotes
   unforgit remote add origin <url>       Add a remote
@@ -2057,7 +2249,7 @@ Examples:
     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) => {
+var remoteAddCommand = new Command18("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 (!isInitialized()) {
     logger.fatal("not an unforgit repository");
     process.exit(EXIT_CONFIG_ERROR);
@@ -2077,7 +2269,7 @@ var remoteAddCommand = new Command17("add").description("Add a new remote").argu
   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) => {
+var remoteRemoveCommand = new Command18("remove").alias("rm").description("Remove a remote").argument("<name>", "Name of the remote to remove").action((name) => {
   if (!isInitialized()) {
     logger.fatal("not an unforgit repository");
     process.exit(EXIT_CONFIG_ERROR);
@@ -2092,7 +2284,7 @@ var remoteRemoveCommand = new Command17("remove").alias("rm").description("Remov
   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) => {
+var remoteSetUrlCommand = new Command18("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 (!isInitialized()) {
     logger.fatal("not an unforgit repository");
     process.exit(EXIT_CONFIG_ERROR);
@@ -2108,7 +2300,7 @@ var remoteSetUrlCommand = new Command17("set-url").description("Change the URL f
   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) => {
+var remoteShowCommand = new Command18("show").description("Show information about a remote").argument("<name>", "Name of the remote").action((name) => {
   if (!isInitialized()) {
     logger.fatal("not an unforgit repository");
     process.exit(EXIT_CONFIG_ERROR);
@@ -2158,8 +2350,8 @@ function saveRemotes(config, remotes) {
 }
 
 // src/commands/log.ts
-import { Command as Command18 } from "commander";
-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", `
+import { Command as Command19 } from "commander";
+var logCommand = new Command19("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
@@ -2251,8 +2443,8 @@ Examples:
 });
 
 // src/commands/diff.ts
-import { Command as Command19 } from "commander";
-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", `
+import { Command as Command20 } from "commander";
+var diffCommand = new Command20("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
@@ -2418,7 +2610,7 @@ function findFullId(store, partialId, orgId, repoId) {
 }
 
 // src/commands/keys.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 function requireRemote() {
   if (!isInitialized()) {
     logger.fatal("not an unforgit repository");
@@ -2438,7 +2630,7 @@ function requireRemote() {
   }
   return { url: config.remote.url, apiKey };
 }
-var keysCommand = new Command20("keys").description("Manage API keys for remote authentication");
+var keysCommand = new Command21("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
@@ -2507,8 +2699,8 @@ keysCommand.command("revoke").description("Revoke an API key").argument("<id>",
 });
 
 // src/commands/auth.ts
-import { Command as Command21 } from "commander";
-var authCommand = new Command21("auth").description("Check authentication status for remote server and APIs");
+import { Command as Command22 } from "commander";
+var authCommand = new Command22("auth").description("Check authentication status for remote server and APIs");
 authCommand.command("status").description("Check authentication status").action(async () => {
   if (!isInitialized()) {
     logger.fatal("not an unforgit repository");
@@ -2559,8 +2751,8 @@ authCommand.command("status").description("Check authentication status").action(
 });
 
 // src/commands/config.ts
-import { Command as Command22 } from "commander";
-var configCommand = new Command22("config").description("Manage unforgit configuration");
+import { Command as Command23 } from "commander";
+var configCommand = new Command23("config").description("Manage unforgit configuration");
 configCommand.command("list").alias("ls").description("List all configuration values").action(() => {
   if (!isInitialized()) {
     logger.fatal("not an unforgit repository");
@@ -2721,19 +2913,49 @@ function coerceConfigValue(value) {
 }
 
 // src/commands/embeddings.ts
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 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) => {
+function embeddingCoverage(stats) {
+  return stats.total > 0 ? Number((stats.withEmbedding / stats.total * 100).toFixed(1)) : 0;
+}
+function buildBackfillJsonPayload(options) {
+  const statsAfter = options.statsAfter ?? options.statsBefore;
+  const failures = options.failures ?? [];
+  return {
+    dryRun: options.dryRun,
+    model: options.model,
+    ...options.provider ? { provider: options.provider } : {},
+    planned: options.planned,
+    processed: options.processed,
+    errors: failures.length,
+    failures,
+    statsBefore: {
+      ...options.statsBefore,
+      coverage: embeddingCoverage(options.statsBefore)
+    },
+    statsAfter: {
+      ...statsAfter,
+      coverage: embeddingCoverage(statsAfter)
+    },
+    ...options.previews ? { memories: options.previews, truncated: Boolean(options.truncated) } : {}
+  };
+}
+var embeddingsCommand = new Command24("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("--provider <provider>", "Embedding provider: auto, local, openai, disabled").option("--model <model>", "Embedding model (defaults to configured provider model)").action(async (opts) => {
   if (!isInitialized(cwd3)) {
     logger.error("Unforgit not initialized. Run 'unforgit init' first.");
     process.exit(EXIT_CONFIG_ERROR);
   }
   const config = loadConfig(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.");
+  const embeddingConfig = {
+    provider: opts.provider ?? config.embeddings?.provider ?? "auto",
+    model: opts.model ?? config.embeddings?.model,
+    apiKey: process.env.OPENAI_API_KEY
+  };
+  const provider = resolveEmbeddingProvider(embeddingConfig);
+  if (!provider.available && !opts.dryRun) {
+    logger.error(provider.reason ?? "Embedding provider is not available.");
+    logger.error("Use 'unforgit config set embeddings.provider local' for no-key local embeddings.");
     process.exit(EXIT_ERROR);
   }
   const dbPath = getDbPath(cwd3);
@@ -2741,18 +2963,51 @@ embeddingsCommand.command("backfill").description("Generate embeddings for memor
   const orgId = config.remote.orgId || "local";
   const repoId = config.remote.repoId || "local";
   try {
-    const memories = store.getMemoriesWithoutEmbeddings(orgId, repoId);
+    const memories = store.getMemoriesWithoutEmbeddings(orgId, repoId, {
+      model: provider.model,
+      provider: provider.provider,
+      dimensions: provider.dimensions
+    });
     const stats = store.getEmbeddingStats(orgId, repoId);
+    if (isJsonMode() && opts.dryRun) {
+      outputJson(buildBackfillJsonPayload({
+        dryRun: true,
+        model: provider.model,
+        provider: provider.provider,
+        statsBefore: stats,
+        planned: memories.length,
+        processed: 0,
+        previews: memories.slice(0, 10).map((memory) => ({
+          id: memory.id,
+          textPreview: memory.text.slice(0, 80)
+        })),
+        truncated: memories.length > 10
+      }));
+      return;
+    }
     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) {
+      if (isJsonMode()) {
+        outputJson(buildBackfillJsonPayload({
+          dryRun: Boolean(opts.dryRun),
+          model: provider.model,
+          provider: provider.provider,
+          statsBefore: stats,
+          planned: 0,
+          processed: 0
+        }));
+        return;
+      }
       logger.info("All memories already have embeddings.");
       return;
     }
     logger.info(`Found ${memories.length} memories without embeddings.`);
+    logger.info(`Embedding provider: ${provider.provider}`);
+    logger.info(`Embedding model: ${provider.model}`);
     if (opts.dryRun) {
       logger.info("\n[Dry run - no changes made]");
       logger.info("Would generate embeddings for:");
@@ -2767,7 +3022,7 @@ embeddingsCommand.command("backfill").description("Generate embeddings for memor
     const batchSize = parsePositiveInt(opts.batchSize, "batch-size");
     const delay = parsePositiveInt(opts.delay, "delay");
     let processed = 0;
-    let errors = 0;
+    const failures = [];
     logger.info(`
 Generating embeddings (batch size: ${batchSize}, delay: ${delay}ms)...`);
     for (let i = 0; i < memories.length; i += batchSize) {
@@ -2776,15 +3031,19 @@ Generating embeddings (batch size: ${batchSize}, delay: ${delay}ms)...`);
         batch.map(async (memory) => {
           try {
             const result = await generateEmbedding(memory.text, {
-              apiKey,
-              model: opts.model
+              ...embeddingConfig
             });
-            await store.storeEmbedding(memory.id, result.embedding, result.model);
+            await store.storeEmbedding(memory.id, result.embedding, result.model, result.provider);
             processed++;
             logger.progress(processed, memories.length, "embeddings");
           } catch (err) {
-            errors++;
-            logger.error(`${memory.id.slice(0, 8)}: ${err instanceof Error ? err.message : err}`);
+            const message = err instanceof Error ? err.message : String(err);
+            failures.push({
+              id: memory.id,
+              textPreview: memory.text.slice(0, 80),
+              error: message
+            });
+            logger.error(`${memory.id.slice(0, 8)}: ${message}`);
           }
         })
       );
@@ -2795,7 +3054,23 @@ Generating embeddings (batch size: ${batchSize}, delay: ${delay}ms)...`);
     logger.info(`
 Backfill complete:`);
     logger.info(`  Processed: ${processed}`);
-    logger.info(`  Errors: ${errors}`);
+    logger.info(`  Errors: ${failures.length}`);
+    const statsAfter = store.getEmbeddingStats(orgId, repoId);
+    if (isJsonMode()) {
+      outputJson(buildBackfillJsonPayload({
+        dryRun: false,
+        model: provider.model,
+        provider: provider.provider,
+        statsBefore: stats,
+        statsAfter,
+        planned: memories.length,
+        processed,
+        failures
+      }));
+    }
+    if (failures.length > 0) {
+      process.exitCode = EXIT_ERROR;
+    }
   } finally {
     store.close();
   }
@@ -2831,7 +3106,7 @@ Run 'unforgit embeddings backfill' to generate missing embeddings.`);
     store.close();
   }
 });
-embeddingsCommand.command("clear").description("Remove all embeddings (requires regeneration)").option("--yes", "Skip confirmation").action(async (opts) => {
+embeddingsCommand.command("clear").description("Remove all embeddings (requires regeneration)").option("--yes", "Skip confirmation").option("--no-backup", "Skip automatic local database backup before clearing embeddings").action(async (opts) => {
   if (!isInitialized(cwd3)) {
     logger.error("Unforgit not initialized. Run 'unforgit init' first.");
     process.exit(EXIT_CONFIG_ERROR);
@@ -2842,6 +3117,19 @@ embeddingsCommand.command("clear").description("Remove all embeddings (requires
     return;
   }
   const dbPath = getDbPath(cwd3);
+  if (opts.backup !== false) {
+    try {
+      const backup = createLocalDatabaseBackup(dbPath, "embeddings-clear");
+      if (backup) {
+        logger.info(`Created local embeddings backup: ${backup.dir}`);
+      }
+    } catch (err) {
+      logger.error(
+        `Failed to create local embeddings backup: ${err instanceof Error ? err.message : String(err)}`
+      );
+      process.exit(EXIT_ERROR);
+    }
+  }
   const store = new LocalStore(dbPath);
   try {
     const deleted = store.clearEmbeddings();
@@ -2853,121 +3141,6 @@ embeddingsCommand.command("clear").description("Remove all embeddings (requires
 
 // src/commands/reset.ts
 import { Command as Command25 } from "commander";
-
-// src/commands/backups.ts
-import fs4 from "fs";
-import path3 from "path";
-import { Command as Command24 } from "commander";
-function formatBackupTimestamp(date) {
-  return date.toISOString().replace(/[-:]/g, "").replace("T", "-").replace(/\.\d{3}Z$/, "");
-}
-function backupRootForDb(dbPath) {
-  return path3.join(path3.dirname(dbPath), "backups");
-}
-function describeBackup(dir) {
-  const files = fs4.readdirSync(dir).filter((file) => file === "local.db" || file === "local.db-wal" || file === "local.db-shm").sort();
-  const sizeBytes = files.reduce((total, file) => total + fs4.statSync(path3.join(dir, file)).size, 0);
-  const stat = fs4.statSync(dir);
-  return {
-    name: path3.basename(dir),
-    dir,
-    files,
-    sizeBytes,
-    createdAt: stat.mtime.toISOString()
-  };
-}
-function resolveBackupDir(backupRoot, backupName) {
-  if (backupName !== path3.basename(backupName)) {
-    throw new Error("Invalid backup name");
-  }
-  const resolvedRoot = path3.resolve(backupRoot);
-  const resolvedBackup = path3.resolve(resolvedRoot, backupName);
-  if (!resolvedBackup.startsWith(`${resolvedRoot}${path3.sep}`)) {
-    throw new Error("Invalid backup name");
-  }
-  return resolvedBackup;
-}
-function createLocalResetBackup(dbPath, now = /* @__PURE__ */ new Date()) {
-  if (!fs4.existsSync(dbPath)) {
-    return null;
-  }
-  const backupRoot = backupRootForDb(dbPath);
-  const baseName = `reset-${formatBackupTimestamp(now)}`;
-  let backupDir = path3.join(backupRoot, baseName);
-  let suffix = 1;
-  while (fs4.existsSync(backupDir)) {
-    backupDir = path3.join(backupRoot, `${baseName}-${suffix++}`);
-  }
-  fs4.mkdirSync(backupDir, { recursive: true, mode: 448 });
-  for (const source of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (!fs4.existsSync(source)) continue;
-    fs4.copyFileSync(source, path3.join(backupDir, path3.basename(source)));
-  }
-  return describeBackup(backupDir);
-}
-function listLocalResetBackups(dbPath) {
-  const backupRoot = backupRootForDb(dbPath);
-  if (!fs4.existsSync(backupRoot)) {
-    return [];
-  }
-  return fs4.readdirSync(backupRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("reset-")).map((entry) => describeBackup(path3.join(backupRoot, entry.name))).filter((backup) => backup.files.includes("local.db")).sort((a, b) => b.name.localeCompare(a.name));
-}
-function restoreLocalResetBackup(dbPath, backupName, now = /* @__PURE__ */ new Date()) {
-  const backupRoot = backupRootForDb(dbPath);
-  const backupDir = resolveBackupDir(backupRoot, backupName);
-  if (!fs4.existsSync(backupDir) || !fs4.statSync(backupDir).isDirectory()) {
-    throw new Error(`Backup not found: ${backupName}`);
-  }
-  const restoredFrom = describeBackup(backupDir);
-  if (!restoredFrom.files.includes("local.db")) {
-    throw new Error(`Backup is missing local.db: ${backupName}`);
-  }
-  const safetyBackup = createLocalResetBackup(dbPath, now);
-  fs4.mkdirSync(path3.dirname(dbPath), { recursive: true });
-  for (const target of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
-    if (fs4.existsSync(target)) {
-      fs4.rmSync(target, { force: true });
-    }
-  }
-  for (const file of restoredFrom.files) {
-    fs4.copyFileSync(path3.join(backupDir, file), path3.join(path3.dirname(dbPath), file));
-  }
-  return { restoredFrom, safetyBackup };
-}
-var backupsCommand = new Command24("backups").description("List and restore local reset backups");
-backupsCommand.command("list").description("List local backups created before destructive resets/restores").action(() => {
-  const backups = listLocalResetBackups(getDbPath());
-  if (backups.length === 0) {
-    logger.info("No local reset backups found.");
-    return;
-  }
-  for (const backup of backups) {
-    logger.info(`${backup.name}	${backup.sizeBytes} bytes	${backup.dir}`);
-  }
-});
-backupsCommand.command("restore").argument("<name>", "Backup directory name, for example reset-20260610-123456").description("Restore a local reset backup into the active local database").option("--force", "Skip confirmation prompt").action(async (name, opts) => {
-  if (!opts.force) {
-    const ok = await confirm(
-      "This will replace the active local database after creating a safety backup. Continue?"
-    );
-    if (!ok) {
-      logger.info("Aborted.");
-      return;
-    }
-  }
-  try {
-    const result = restoreLocalResetBackup(getDbPath(), name);
-    logger.info(`Restored local database from ${result.restoredFrom.name}`);
-    if (result.safetyBackup) {
-      logger.info(`Previous local database safety backup: ${result.safetyBackup.dir}`);
-    }
-  } catch (err) {
-    logger.error(err instanceof Error ? err.message : String(err));
-    process.exit(EXIT_ERROR);
-  }
-});
-
-// src/commands/reset.ts
 var resetCommand = new Command25("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").option("--no-backup", "Skip automatic local database backup before local reset").addHelpText("after", `
 Examples:
   unforgit reset                Reset both local and remote
@@ -3211,22 +3384,45 @@ var doctorCommand = new Command27("doctor").description("Check system health and
         status: "ok",
         message: `${memoryStats.total} memories (${memoryStats.byType.episodic} episodic, ${memoryStats.byType.semantic} semantic, ${memoryStats.byType.procedural} procedural)`
       });
+      const provider = resolveEmbeddingProvider({
+        provider: config.embeddings?.provider ?? "auto",
+        model: config.embeddings?.model,
+        apiKey: process.env.OPENAI_API_KEY
+      });
+      results.push({
+        check: "embedding-provider",
+        status: provider.available ? "ok" : "warn",
+        message: `${provider.provider} embeddings (${provider.model}, ${provider.dimensions} dimensions)${provider.reason ? `: ${provider.reason}` : ""}`,
+        details: {
+          provider: provider.provider,
+          model: provider.model,
+          dimensions: provider.dimensions,
+          available: provider.available
+        }
+      });
       const stats = store.getEmbeddingStats(orgId, repoId);
+      const incompatibleOrMissing = store.getMemoriesWithoutEmbeddings(orgId, repoId, {
+        model: provider.model,
+        provider: provider.provider,
+        dimensions: provider.dimensions
+      }).length;
       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 if (incompatibleOrMissing === 0) {
+        results.push({ check: "embeddings", status: "ok", message: `All ${stats.total} memories have compatible embeddings` });
       } else {
-        const pct = (stats.withEmbedding / stats.total * 100).toFixed(1);
+        const compatible = stats.total - incompatibleOrMissing;
+        const pct = (compatible / 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'`,
+          message: `${incompatibleOrMissing}/${stats.total} memories lack compatible embeddings for ${provider.provider}/${provider.model} (${pct}% coverage). Run 'unforgit embeddings backfill'`,
           fix: "Run 'unforgit embeddings backfill'."
         });
       }
       const pendingPush = store.getPendingPush();
       const conflicts = store.getConflicts();
+      const syncSummary = store.getSyncSummary(orgId, repoId);
       const unsyncedTombstones = store.getUnsyncedTombstones(orgId, repoId);
       if (unsyncedTombstones.length > 0) {
         results.push({
@@ -3243,16 +3439,22 @@ var doctorCommand = new Command27("doctor").description("Check system health and
           check: "sync",
           status: "warn",
           message: `${conflicts.length} sync conflict(s) need resolution`,
-          fix: "Resolve conflicts with 'unforgit pull --force' or 'unforgit push --force' after reviewing the desired source of truth."
+          fix: "Resolve conflicts with 'unforgit pull --force' or 'unforgit push --force' after reviewing the desired source of truth.",
+          details: syncSummary
         });
-      } else if (pendingPush.length > 0) {
+      } else if (pendingPush.length > 0 || syncSummary.pendingPull > 0) {
+        const parts = [];
+        if (pendingPush.length > 0) parts.push(`${pendingPush.length} memory(s) pending push`);
+        if (syncSummary.pendingPull > 0) parts.push(`${syncSummary.pendingPull} memory(s) pending pull`);
         results.push({
           check: "sync",
-          status: "ok",
-          message: `${pendingPush.length} memory(s) pending push`
+          status: "warn",
+          message: parts.join(", "),
+          fix: "Run 'unforgit push' to publish local memory changes, or configure/disable sync if this repository is intentionally local-only.",
+          details: syncSummary
         });
       } else {
-        results.push({ check: "sync", status: "ok", message: "Sync state clean" });
+        results.push({ check: "sync", status: "ok", message: "Sync state clean", details: syncSummary });
       }
     } finally {
       store.close();
@@ -3300,11 +3502,12 @@ var doctorCommand = new Command27("doctor").description("Check system health and
           });
         }
       } catch (err) {
+        const localhostRemote = isLocalhostUrl(config.remote.url);
         results.push({
           check: "remote",
           status: "error",
-          message: `Cannot connect to ${config.remote.url}: ${err instanceof Error ? err.message : err}`,
-          fix: "Start the Unforgit API server or update remote.url in unforgit.yaml."
+          message: localhostRemote ? `Cannot connect to local remote API at ${config.remote.url}: ${err instanceof Error ? err.message : err}. Local memory and local embeddings still work; only remote sync is unavailable.` : `Cannot connect to ${config.remote.url}: ${err instanceof Error ? err.message : err}`,
+          fix: localhostRemote ? "remote.url points to localhost. Start the Unforgit API server on this machine/port, update remote.url, or disable sync if this repository is intentionally local-only." : "Start the Unforgit API server or update remote.url in unforgit.yaml."
         });
       }
     } else {
@@ -3315,15 +3518,19 @@ var doctorCommand = new Command27("doctor").description("Check system health and
         fix: "Run 'unforgit remote add origin <url>' if this repo should sync remotely."
       });
     }
-    const openaiKey = process.env.OPENAI_API_KEY;
-    if (openaiKey) {
-      results.push({ check: "openai", status: "ok", message: "OpenAI API key configured ([REDACTED])" });
+    if (isOpenAIConfigured()) {
+      results.push({ check: "openai", status: "ok", message: "OpenAI API key configured ([REDACTED]) for optional cloud AI features" });
     } else {
+      const embeddingProvider = resolveEmbeddingProvider({
+        provider: config.embeddings?.provider ?? "auto",
+        model: config.embeddings?.model
+      });
+      const message = embeddingProvider.provider === "local" ? "No OpenAI API key configured; local embeddings are active. OpenAI is only needed for OpenAI-backed embeddings or AI consolidation." : "No OpenAI API key. OpenAI-backed embeddings and AI consolidation require it.";
       results.push({
         check: "openai",
-        status: "warn",
-        message: "No OpenAI API key. Auto-consolidation and embeddings backfill require it.",
-        fix: "Set OPENAI_API_KEY before running embedding backfill or AI consolidation."
+        status: embeddingProvider.provider === "local" ? "ok" : "warn",
+        message,
+        fix: embeddingProvider.provider === "local" ? void 0 : "Set OPENAI_API_KEY or configure embeddings.provider=local."
       });
     }
   } catch (err) {
@@ -3352,6 +3559,14 @@ function summarize(results) {
 function buildPayload(results) {
   return { summary: summarize(results), results };
 }
+function isLocalhostUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
 function exitForResults(results) {
   if (results.some((r) => r.status === "error")) {
     process.exit(EXIT_ERROR);