add-coder 0.3.35 → 0.3.38

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { Command } from "commander";
 
 // src/caijuehub/strategies/detect.strategy.ts
@@ -60,6 +60,24 @@ function magicDirFor(adapter) {
   if (!m) throw new Error(`\u672A\u77E5 adapter: ${adapter}`);
   return m;
 }
+function here() {
+  return import.meta.dirname;
+}
+function resolveMagicDir(cwd) {
+  const fromEnv = process.env.MAGIC_DIR;
+  if (fromEnv) return fromEnv;
+  const base = cwd ?? here();
+  const ide = detectIDE2(base);
+  if (ide !== "auto") {
+    const m = MAGIC_DIR_MAP[ide];
+    if (m && findUpSync(m, { cwd: base, type: "directory" })) return m;
+  }
+  for (const magic of Object.values(MAGIC_DIR_MAP)) {
+    const hit = findUpSync(magic, { cwd: base, type: "directory" });
+    if (hit) return magic;
+  }
+  return MAGIC_DIR_MAP.qoder;
+}
 
 // src/cli/config-loader.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
@@ -200,7 +218,7 @@ async function selectFiles(projectRoot, files) {
     process.stdout.write(renderList(items, selected, scrollIdx, VISIBLE));
   }
   draw();
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     input.on("keypress", (_char, key) => {
       if (!key) return;
       if (key.name === "up") {
@@ -241,7 +259,7 @@ async function selectFiles(projectRoot, files) {
         if (selected.has(idx)) result.set(relPath, content);
         idx++;
       }
-      resolve12(result);
+      resolve14(result);
     });
   });
 }
@@ -1119,7 +1137,7 @@ async function ensureSplitDb(projectRoot, opts) {
     `POSTGRES_DB=${dbName}`,
     "-p",
     `127.0.0.1:${port}:5432`,
-    "docker.io/postgres:16-alpine"
+    "docker.io/pgvector/pgvector:pg16"
   ], { timeout: 6e4 });
   if (r.status !== 0) {
     throw new Error(`\u72EC\u7ACB ADD \u5E93\u5BB9\u5668\u542F\u52A8\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${r.status}\uFF09: ${r.stderr.trim().slice(0, 200)}`);
@@ -1183,7 +1201,7 @@ async function provisionDevUrl(projectRoot) {
     "POSTGRES_DB=dev",
     "-p",
     `127.0.0.1:${port}:5432`,
-    "docker.io/postgres:16-alpine"
+    "docker.io/pgvector/pgvector:pg16"
   ], { timeout: 6e4 });
   if (r.status !== 0) return null;
   const url = `postgresql://postgres:postgres@127.0.0.1:${port}/dev?schema=public`;
@@ -1530,9 +1548,9 @@ async function injectPrisma2(projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync12, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync5 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync13, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync5 } from "fs";
 import { createHash } from "crypto";
-import { resolve as resolve8, dirname as dirname3, join as pathJoin } from "path";
+import { resolve as resolve9, dirname as dirname3, join as pathJoin } from "path";
 import { homedir as homedir2 } from "os";
 import { createConnection as createConnection2 } from "net";
 
@@ -1612,6 +1630,42 @@ async function ensureEmbeddingModel(options) {
   return { status: "downloaded", model, cacheDir };
 }
 
+// src/lib/memory-expected-state.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join9, resolve as resolve8 } from "path";
+function expectedStateSqlRelPath(magicDir) {
+  return join9(magicDir, "scripts", "mcp-server", "shared", "memory", "retrieval", "fts", "sqlite-fts5.sql");
+}
+function applyMemoryExpectedState(opts) {
+  const { projectRoot, magicDir, engine } = opts;
+  const relSql = expectedStateSqlRelPath(magicDir);
+  const manualCmd = `npx prisma db execute --file ${relSql}`;
+  if (engine !== "sqlite") return { applicable: false, ok: true, relSql, manualCmd };
+  const absSql = resolve8(projectRoot, relSql);
+  if (!existsSync12(absSql)) {
+    return {
+      applicable: true,
+      ok: false,
+      relSql,
+      manualCmd,
+      detail: `\u671F\u671B\u6001 SQL \u672A\u627E\u5230\uFF08${relSql}\uFF09\u2014\u2014\u8BF7\u5148\u6267\u884C add-coder sync \u540E\u91CD\u8DD1`
+    };
+  }
+  const pm = detectPm(projectRoot);
+  const argv = pm === "pnpm" ? ["exec", "prisma", "db", "execute", "--file", absSql] : ["exec", "prisma", "--", "db", "execute", "--file", absSql];
+  const run = opts.run ?? ((a, cwd) => runCommand(pm, a, { cwd, timeout: opts.timeoutMs ?? 6e4 }));
+  try {
+    const r = run(argv, projectRoot);
+    if (r.status !== 0) {
+      const why = (r.stderr || "").trim().split("\n").slice(0, 2).join(" | ");
+      return { applicable: true, ok: false, relSql, manualCmd, detail: `\u9000\u51FA\u7801 ${r.status}${why ? `: ${why}` : ""}` };
+    }
+    return { applicable: true, ok: true, relSql, manualCmd };
+  } catch (e) {
+    return { applicable: true, ok: false, relSql, manualCmd, detail: e instanceof Error ? e.message : String(e) };
+  }
+}
+
 // src/cli/commands/init.ts
 var ADAPTER_RENDERERS = {
   claude: renderAdapter,
@@ -1678,7 +1732,7 @@ async function handleCodexMcpConfig(options) {
       console.log(`[dry-run] \u5C06\u5199\u5165 ${userConfigPath}`);
       return;
     }
-    if (existsSync12(userConfigPath) && readFileSync10(userConfigPath, "utf-8").includes("mcp_servers.add_coder")) {
+    if (existsSync13(userConfigPath) && readFileSync10(userConfigPath, "utf-8").includes("mcp_servers.add_coder")) {
       console.log(`\u26A0\uFE0F ${userConfigPath} \u5DF2\u5B58\u5728 mcp_servers.add_coder \u914D\u7F6E\uFF0C\u8DF3\u8FC7\uFF08\u907F\u514D\u91CD\u590D\uFF09`);
       return;
     }
@@ -1687,7 +1741,7 @@ async function handleCodexMcpConfig(options) {
       console.log("\u5DF2\u53D6\u6D88\u5199\u5165");
       return;
     }
-    if (existsSync12(userConfigPath)) {
+    if (existsSync13(userConfigPath)) {
       const backup = `${userConfigPath}.bak-${Date.now()}`;
       copyFileSync2(userConfigPath, backup);
       console.log(`\u5DF2\u5907\u4EFD\u539F\u914D\u7F6E \u2192 ${backup}`);
@@ -1810,7 +1864,7 @@ async function resolveDbCredentials(force) {
 function composeContent(projectName) {
   return `services:
   postgres:
-    image: docker.io/postgres:16-alpine
+    image: docker.io/pgvector/pgvector:pg16
     container_name: \${PROJECT_NAME:-${projectName}}-postgres
     restart: unless-stopped
     ports:
@@ -1838,8 +1892,8 @@ networks:
 `;
 }
 function writeSqliteExportScript(projectRoot, dryRun) {
-  const scriptsDir = resolve8(projectRoot, "scripts");
-  const scriptPath = resolve8(scriptsDir, "export-db.ts");
+  const scriptsDir = resolve9(projectRoot, "scripts");
+  const scriptPath = resolve9(scriptsDir, "export-db.ts");
   const content = `import { PrismaClient } from "@prisma/client";
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { resolve } from "path";
@@ -1863,13 +1917,13 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync12(scriptsDir)) mkdirSync6(scriptsDir, { recursive: true });
+  if (!existsSync13(scriptsDir)) mkdirSync6(scriptsDir, { recursive: true });
   writeFileSync6(scriptPath, content, "utf-8");
   console.log("\u5DF2\u751F\u6210 scripts/export-db.ts");
 }
 function injectDbExportScript(projectRoot, dryRun) {
-  const pkgPath = resolve8(projectRoot, "package.json");
-  if (!existsSync12(pkgPath)) return;
+  const pkgPath = resolve9(projectRoot, "package.json");
+  if (!existsSync13(pkgPath)) return;
   if (dryRun) {
     console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
     return;
@@ -1921,14 +1975,14 @@ function writeComposeEnv(ctx) {
   if (db.engine !== "postgresql" || !db.container || db.container === "manual") return;
   if (!db.reuseExisting) {
     const composeName = db.container === "podman" ? "podman-compose.add.yml" : "docker-compose.add.yml";
-    const composePath = resolve8(projectRoot, composeName);
-    if (!options.dryRun && (!existsSync12(composePath) || options.force)) {
+    const composePath = resolve9(projectRoot, composeName);
+    if (!options.dryRun && (!existsSync13(composePath) || options.force)) {
       writeFileSync6(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
-  const devEnvPath = resolve8(projectRoot, ".env.development");
-  if (!options.dryRun && existsSync12(devEnvPath)) {
+  const devEnvPath = resolve9(projectRoot, ".env.development");
+  if (!options.dryRun && existsSync13(devEnvPath)) {
     const existing = readFileSync10(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
       writeFileSync6(devEnvPath, existing + `
@@ -1975,8 +2029,8 @@ async function renderAndWrite(ctx) {
   }
   const reviewTargets = target === "codex" ? [magicDir] : [ADD_DIR, magicDir];
   for (const d of reviewTargets) {
-    const reviewsDir = resolve8(projectRoot, d, "reviews");
-    if (!existsSync12(reviewsDir)) {
+    const reviewsDir = resolve9(projectRoot, d, "reviews");
+    if (!existsSync13(reviewsDir)) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
@@ -1988,16 +2042,16 @@ async function renderAndWrite(ctx) {
     const hashMap = {};
     let npmVer = "";
     try {
-      npmVer = JSON.parse(readFileSync10(resolve8(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
+      npmVer = JSON.parse(readFileSync10(resolve9(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
     } catch {
     }
     for (const [rp, c] of allFiles) {
       hashMap[rp] = createHash("sha256").update(c).digest("hex").slice(0, 8);
     }
-    const hashOut = resolve8(projectRoot, magicDir, ".add-coder-hash.json");
+    const hashOut = resolve9(projectRoot, magicDir, ".add-coder-hash.json");
     writeFileSync6(hashOut, JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
     if (npmVer) {
-      writeFileSync6(resolve8(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
+      writeFileSync6(resolve9(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
     }
     console.log(`hash: ${Object.keys(hashMap).length} entries \u2192 ${magicDir}/.add-coder-hash.json`);
   }
@@ -2008,7 +2062,7 @@ async function deployDatabase(ctx) {
   if (options.dryRun) return null;
   let fail = null;
   if (db.engine === "postgresql" && db.container && db.container !== "manual") {
-    const dbScript = resolve8(projectRoot, magicDir, "scripts", "db-ensure.sh");
+    const dbScript = resolve9(projectRoot, magicDir, "scripts", "db-ensure.sh");
     const dbEnv = { ...process.env, DATABASE_USER: db.user, DATABASE_PASSWORD: db.password, DATABASE_PORT: db.port, PROJECT_NAME: config.projectName };
     const mode = db.reuseExisting ? "manual" : db.container;
     console.log(db.reuseExisting ? "\u590D\u7528\u5DF2\u6709 PostgreSQL ..." : `\u90E8\u7F72\u6570\u636E\u5E93 (${db.container}) ...`);
@@ -2026,8 +2080,8 @@ ${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
     }
   }
   if (db.engine === "postgresql" && db.container === "manual") {
-    const dbScript = resolve8(projectRoot, magicDir, "scripts", "db-ensure.sh");
-    if (existsSync12(dbScript)) {
+    const dbScript = resolve9(projectRoot, magicDir, "scripts", "db-ensure.sh");
+    if (existsSync13(dbScript)) {
       try {
         const bashRun = runCommand("bash", [dbScript, "postgresql", "manual"], { cwd: projectRoot, stdio: "inherit" });
         if (bashRun.status !== 0) fail = `db-ensure.sh \u9000\u51FA\u7801: ${bashRun.status}${bashRun.stderr ? `
@@ -2062,6 +2116,14 @@ ${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
     injectDbExportScript(projectRoot, false);
     try {
       await injectPrisma2(projectRoot, { force: !!options.force, datasource: "sqlite" });
+      const expected = applyMemoryExpectedState({ projectRoot, magicDir, engine: db.engine });
+      if (expected.applicable && !expected.ok) {
+        console.warn(`\u26A0\uFE0F  \u8BB0\u5FC6 FTS5 \u671F\u671B\u6001\u5E94\u7528\u5931\u8D25\uFF08\u4E0D\u963B\u65AD init\uFF09\uFF1A${expected.detail ?? "\u672A\u77E5\u539F\u56E0"}`);
+        console.warn(`   \u540E\u7EED recall_memory \u4F1A\u62A5 sqlite-fts \u4E0D\u53EF\u7528\uFF1B\u624B\u5DE5\u6062\u590D: ${expected.manualCmd}`);
+        console.warn(`   \u6216\u8FD0\u884C: add-coder memory:reindex --apply`);
+      } else if (expected.applicable) {
+        console.log(`\u2705 \u8BB0\u5FC6 FTS5 \u671F\u671B\u6001\u5DF2\u5E94\u7528\uFF08${expected.relSql}\uFF09`);
+      }
     } catch (e) {
       fail = `SQLite \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`;
     }
@@ -2072,17 +2134,17 @@ function deployDocs(ctx) {
   const { projectRoot, options, config } = ctx;
   if (options.dryRun) return;
   const pn = config.projectName || "add-project";
-  const docsBase = resolve8(projectRoot, "docs", pn, "knowledge");
-  const groundingSrc = resolve8(import.meta.dirname, "../templates/core/templates");
+  const docsBase = resolve9(projectRoot, "docs", pn, "knowledge");
+  const groundingSrc = resolve9(import.meta.dirname, "../templates/core/templates");
   for (const d of ["00-\u9700\u6C42", "01-\u67B6\u6784", "02-\u89C4\u8303"]) {
-    const srcDir = resolve8(groundingSrc, d);
-    const destDir = resolve8(docsBase, d);
-    if (!existsSync12(destDir)) mkdirSync6(destDir, { recursive: true });
-    if (!existsSync12(srcDir)) continue;
+    const srcDir = resolve9(groundingSrc, d);
+    const destDir = resolve9(docsBase, d);
+    if (!existsSync13(destDir)) mkdirSync6(destDir, { recursive: true });
+    if (!existsSync13(srcDir)) continue;
     for (const f of readdirSync5(srcDir)) {
-      const src = resolve8(srcDir, f);
-      const dest = resolve8(destDir, f);
-      if (existsSync12(dest)) continue;
+      const src = resolve9(srcDir, f);
+      const dest = resolve9(destDir, f);
+      if (existsSync13(dest)) continue;
       try {
         copyFileSync2(src, dest);
       } catch {
@@ -2098,7 +2160,7 @@ function finalize(ctx, result, dbFail) {
     return;
   }
   if (db.engine === "sqlite") console.log("\u6570\u636E\u5907\u4EFD: npm run db:export \u2192 data/exports/");
-  const pkg = JSON.parse(readFileSync10(resolve8(import.meta.dirname, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync10(resolve9(import.meta.dirname, "../package.json"), "utf-8"));
   const peerNames = Object.keys(pkg.peerDependencies || {});
   if (peerNames.length > 0) {
     console.log(`
@@ -2131,8 +2193,8 @@ function finalize(ctx, result, dbFail) {
 }
 
 // src/cli/commands/sync.ts
-import { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { resolve as resolve9, dirname as dirname4 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve10, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/lib/path-normalize.ts
@@ -2205,7 +2267,7 @@ function resolvePatchConflictMode(yes = false, isTTY = Boolean(process.stdin.isT
 }
 function loadHashFile(root, magic) {
   try {
-    const raw = JSON.parse(readFileSync11(resolve9(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
+    const raw = JSON.parse(readFileSync11(resolve10(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
     const normalized = {};
     for (const [k, v] of Object.entries(raw)) normalized[normalizeRelPath(k)] = v;
     return normalized;
@@ -2215,19 +2277,19 @@ function loadHashFile(root, magic) {
 }
 function loadVersionFile(root, magic) {
   try {
-    return readFileSync11(resolve9(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
+    return readFileSync11(resolve10(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function saveVersionFile(root, magic, version2) {
-  writeFileSync7(resolve9(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
+  writeFileSync7(resolve10(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
 }
 function loadTemplateVersion(root) {
   const candidates = [
-    resolve9(root, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"),
-    resolve9(import.meta.dirname, "../templates/.add-coder-src-hash.json"),
-    resolve9(import.meta.dirname, "../../../templates/.add-coder-src-hash.json")
+    resolve10(root, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"),
+    resolve10(import.meta.dirname, "../templates/.add-coder-src-hash.json"),
+    resolve10(import.meta.dirname, "../../../templates/.add-coder-src-hash.json")
   ];
   for (const candidate of candidates) {
     try {
@@ -2240,7 +2302,7 @@ function loadTemplateVersion(root) {
 function saveHashFile(root, magic, files) {
   const m = {};
   for (const [p, c] of files) m[p] = c;
-  writeFileSync7(resolve9(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
+  writeFileSync7(resolve10(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
 }
 function mergeFullHash(outHash, candidates, readDiskHash, preserveKeys = /* @__PURE__ */ new Set()) {
   const finalHash = /* @__PURE__ */ new Map();
@@ -2341,8 +2403,8 @@ async function syncCommand(options = {}) {
     let sameCount = 0;
     for (const [relPath, content] of candidates) {
       const key = normalizeRelPath(relPath);
-      const absPath = resolve9(projectRoot, relPath);
-      if (!existsSync13(absPath)) {
+      const absPath = resolve10(projectRoot, relPath);
+      if (!existsSync14(absPath)) {
         missingFiles.set(key, content);
       } else if (establishBaseline) {
         missingFiles.set(key, content);
@@ -2388,8 +2450,8 @@ async function syncCommand(options = {}) {
     }
     let finalHash = mergeFullHash(
       outHash,
-      [...candidates].map(([relPath]) => ({ relPath, absPath: resolve9(projectRoot, relPath) })),
-      (absPath) => existsSync13(absPath) ? hash8(readFileSync11(absPath, "utf-8")) : null,
+      [...candidates].map(([relPath]) => ({ relPath, absPath: resolve10(projectRoot, relPath) })),
+      (absPath) => existsSync14(absPath) ? hash8(readFileSync11(absPath, "utf-8")) : null,
       unresolvedConflictKeys
     );
     if (target === "codex") {
@@ -2404,7 +2466,7 @@ async function syncCommand(options = {}) {
   }
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of allFiles) {
-    if (!existsSync13(resolve9(projectRoot, relPath))) {
+    if (!existsSync14(resolve10(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
@@ -2428,7 +2490,7 @@ async function syncCommand(options = {}) {
 }
 function printMigrateGuidance(targetPath, changed) {
   const g = SYNC_PRISMA_CONFIG.POST_SYNC;
-  const isManaged = existsSync13(resolve9(dirname4(targetPath), "migrations"));
+  const isManaged = existsSync14(resolve10(dirname4(targetPath), "migrations"));
   const actions = isManaged ? g.MANAGED_ACTIONS : g.UNMANAGED_ACTIONS;
   console.log(`  \u25B6 \u5DF2\u5199\u5165 ${changed} \u5904\u53D8\u66F4\uFF0C${g.HEADER}`);
   for (const a of actions) {
@@ -2467,7 +2529,7 @@ async function ensureAtlasCapability(projectRoot, yes = false) {
     console.log("   \u6587\u6863: README.md \u2192 \u7AE0\u8282\u300CAtlas \u6570\u636E\u5E93\u540C\u6B65\u80FD\u529B\u300D/ DEVELOPMENT.md \xA7\u4E5D");
     return;
   }
-  const pm = existsSync13(resolve9(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  const pm = existsSync14(resolve10(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
   console.log(`   \u5B89\u88C5 ${pm} add -D @ariga/atlas ...`);
   const r = runCommand(pm, ["add", "-D", "@ariga/atlas"], { cwd: projectRoot, timeout: 18e4 });
   if (r.status !== 0) {
@@ -2479,8 +2541,8 @@ async function ensureAtlasCapability(projectRoot, yes = false) {
   console.log("   \u2705 @ariga/atlas \u5DF2\u5B89\u88C5\uFF0CAtlas \u80FD\u529B\u5C31\u7EEA\uFF08node_modules/.bin/atlas\uFF09");
 }
 function checkHostAtlasSegment(projectRoot) {
-  const script = resolve9(projectRoot, "scripts", "db-ensure.sh");
-  if (!existsSync13(script)) return;
+  const script = resolve10(projectRoot, "scripts", "db-ensure.sh");
+  if (!existsSync14(script)) return;
   const content = readFileSync11(script, "utf-8");
   if (content.includes("atlas_sync")) return;
   console.warn("   \u26A0\uFE0F  \u5BBF\u4E3B scripts/db-ensure.sh \u672A\u5305\u542B Atlas \u540C\u6B65\u6BB5\uFF08\u65E5\u5E38 db-ensure \u5C06\u7F3A\u5C11 ADD \u6CBB\u7406\u6A21\u578B\u540C\u6B65\uFF09");
@@ -2493,9 +2555,9 @@ function checkHostAtlasSegment(projectRoot) {
 }
 async function checkPrismaDiff(projectRoot, options) {
   if (!options.patch) return;
-  const basePath = resolve9(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
-  const targetPath = resolve9(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
-  if (!existsSync13(basePath)) {
+  const basePath = resolve10(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
+  const targetPath = resolve10(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
+  if (!existsSync14(basePath)) {
     console.log(`
 \u26A0\uFE0F  \u57FA\u51C6 schema \u4E0D\u5B58\u5728: ${basePath}`);
     console.log(`  \u8BF7\u786E\u4FDD add-coder \u5DF2\u6B63\u786E\u5B89\u88C5\u3002`);
@@ -2509,7 +2571,7 @@ async function checkPrismaDiff(projectRoot, options) {
 \u2705 Prisma schema \u4E0E add-coder \u6807\u51C6\u4E00\u81F4\uFF0C\u65E0\u9700\u540C\u6B65\u3002`);
     return;
   }
-  const targetExists = existsSync13(targetPath);
+  const targetExists = existsSync14(targetPath);
   let modifiedCount = 0;
   console.log(`
 \u26A0\uFE0F  Prisma schema \u5DEE\u5F02\u68C0\u6D4B:`);
@@ -2759,8 +2821,8 @@ function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync14 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { resolve as resolve11 } from "path";
 async function statusCommand() {
   const projectRoot = process.cwd();
   const config = await loadConfig(projectRoot);
@@ -2769,7 +2831,7 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync14(resolve10(projectRoot, relPath))) {
+    if (existsSync15(resolve11(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
@@ -2787,14 +2849,14 @@ async function statusCommand() {
 }
 
 // src/cli/commands/stack.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
-import { resolve as resolve11, join as join9 } from "path";
+import { readdirSync as readdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync16, mkdirSync as mkdirSync8 } from "fs";
+import { resolve as resolve12, join as join10 } from "path";
 import { createHash as createHash3 } from "crypto";
 var HASH_OUTPUT_FILE = ".add-coder-hash.json";
 function hash82(c) {
   return createHash3("sha256").update(c).digest("hex").slice(0, 8);
 }
-function resolveMagicDir(projectRoot, specified) {
+function resolveMagicDir2(projectRoot, specified) {
   if (specified) {
     return magicDirFor(specified);
   }
@@ -2803,18 +2865,18 @@ function resolveMagicDir(projectRoot, specified) {
   return magicDirFor(adapter);
 }
 function listCustomProfiles(projectRoot, magicDir, registryNames) {
-  const dir = resolve11(projectRoot, magicDir, "rules", "profiles");
-  if (!existsSync15(dir)) return [];
+  const dir = resolve12(projectRoot, magicDir, "rules", "profiles");
+  if (!existsSync16(dir)) return [];
   return readdirSync6(dir).filter((f) => f.endsWith(".md") && !registryNames.has(f.replace(/-profile\.md$/, ""))).sort();
 }
 function profileExists(projectRoot, magicDir, name) {
   const registry = loadProfileRegistry();
   if (registry.some((p) => p.name === name)) return true;
-  return existsSync15(resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
+  return existsSync16(resolve12(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
 }
 function stackCommand(sub, name, options = {}) {
   const projectRoot = process.cwd();
-  const magicDir = resolveMagicDir(projectRoot, options.adapter);
+  const magicDir = resolveMagicDir2(projectRoot, options.adapter);
   const registry = loadProfileRegistry();
   if (options.clear) {
     saveStack(projectRoot, magicDir, "");
@@ -2847,12 +2909,12 @@ function stackCommand(sub, name, options = {}) {
       console.log("\u6280\u672F\u6808: \u672A\u8BBE\u7F6E\uFF08\u4E2D\u6027\uFF0C\u65E0\u6280\u672F\u6808\u5047\u8BBE\uFF09");
       return;
     }
-    const profilePath = resolve11(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
-    const stat = existsSync15(profilePath) ? readFileSync12(profilePath, "utf-8").length : 0;
+    const profilePath = resolve12(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
+    const stat = existsSync16(profilePath) ? readFileSync12(profilePath, "utf-8").length : 0;
     console.log(`\u6280\u672F\u6808: ${current}`);
-    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync15(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
+    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync16(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
     try {
-      const raw = JSON.parse(readFileSync12(resolve11(projectRoot, magicDir, "stack.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync12(resolve12(projectRoot, magicDir, "stack.json"), "utf-8"));
       if (raw.updatedAt) console.log(`\u66F4\u65B0\u65F6\u95F4: ${raw.updatedAt}`);
     } catch {
     }
@@ -2877,8 +2939,8 @@ function buildConfig(projectRoot, magicDir, stack) {
     stack
   };
   try {
-    const pkgPath = resolve11(projectRoot, "package.json");
-    if (existsSync15(pkgPath)) {
+    const pkgPath = resolve12(projectRoot, "package.json");
+    if (existsSync16(pkgPath)) {
       const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.name) config.projectName = pkg.name;
     }
@@ -2906,13 +2968,13 @@ function applyStack(projectRoot, magicDir, name) {
   }
   const hashMap = {};
   try {
-    Object.assign(hashMap, JSON.parse(readFileSync12(resolve11(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
+    Object.assign(hashMap, JSON.parse(readFileSync12(resolve12(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
   } catch {
   }
   let written = 0;
   for (const [relPath, content] of stackRelated) {
-    const targetPath = resolve11(projectRoot, relPath);
-    mkdirSync8(join9(targetPath, ".."), { recursive: true });
+    const targetPath = resolve12(projectRoot, relPath);
+    mkdirSync8(join10(targetPath, ".."), { recursive: true });
     writeFileSync8(targetPath, content, "utf-8");
     hashMap[relPath] = hash82(content);
     written++;
@@ -2923,24 +2985,331 @@ function applyStack(projectRoot, magicDir, name) {
   };
   const registry = loadProfileRegistry();
   const isBuiltin = registry.some((p) => p.name === name);
-  const profilePathMagic = resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`);
-  const profilePathAdd = resolve11(projectRoot, ADD_DIR, "rules", "profiles", `${name}-profile.md`);
-  const projectRulesPath = resolve11(projectRoot, magicDir, "rules", "project_rules.md");
-  const projectRulesContent = existsSync15(projectRulesPath) ? readFileSync12(projectRulesPath, "utf-8") : "";
+  const profilePathMagic = resolve12(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`);
+  const profilePathAdd = resolve12(projectRoot, ADD_DIR, "rules", "profiles", `${name}-profile.md`);
+  const projectRulesPath = resolve12(projectRoot, magicDir, "rules", "project_rules.md");
+  const projectRulesContent = existsSync16(projectRulesPath) ? readFileSync12(projectRulesPath, "utf-8") : "";
   if (written === 0) fail(`\u672A\u6E32\u67D3\u4EFB\u4F55 stack \u76F8\u5173\u6587\u4EF6\uFF08${name}\uFF09\u2014\u2014Windows \u8DEF\u5F84\u5339\u914D\u5931\u6548\u9057\u7559\u95EE\u9898`);
-  if (magicDir !== magicDirFor("codex") && isBuiltin && !existsSync15(profilePathAdd)) fail(`profile \u672A\u5199\u5165 ${ADD_DIR}: ${profilePathAdd}`);
-  if (!existsSync15(profilePathMagic)) fail(`profile \u672A\u5199\u5165 ${magicDir}: ${profilePathMagic}`);
+  if (magicDir !== magicDirFor("codex") && isBuiltin && !existsSync16(profilePathAdd)) fail(`profile \u672A\u5199\u5165 ${ADD_DIR}: ${profilePathAdd}`);
+  if (!existsSync16(profilePathMagic)) fail(`profile \u672A\u5199\u5165 ${magicDir}: ${profilePathMagic}`);
   if (!projectRulesContent.includes("**\u5F53\u524D\u6280\u672F\u6808**") || !projectRulesContent.includes(name)) fail(`project_rules.md \u672A\u5305\u542B ${name} \u5F15\u7528`);
-  writeFileSync8(resolve11(projectRoot, magicDir, HASH_OUTPUT_FILE), JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
+  writeFileSync8(resolve12(projectRoot, magicDir, HASH_OUTPUT_FILE), JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
   console.log(`\u2705 \u6280\u672F\u6808\u5DF2\u8BBE\u7F6E\u4E3A ${name}`);
   console.log(`   ${magicDir}/stack.json \u2192 ${name}`);
-  console.log(`   ${magicDir}/rules/profiles/${name}-profile.md ${existsSync15(resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`)) ? "\u5DF2\u5C31\u4F4D" : "\uFF08\u81EA\u5B9A\u4E49 profile\uFF0C\u9879\u76EE\u4FA7\u6587\u4EF6\uFF09"}`);
+  console.log(`   ${magicDir}/rules/profiles/${name}-profile.md ${existsSync16(resolve12(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`)) ? "\u5DF2\u5C31\u4F4D" : "\uFF08\u81EA\u5B9A\u4E49 profile\uFF0C\u9879\u76EE\u4FA7\u6587\u4EF6\uFF09"}`);
   console.log(`   project_rules.md \u5F15\u7528\u884C\u5DF2\u66F4\u65B0 + hash \u5DF2\u5237\u65B0\uFF08${written} \u4E2A\u6587\u4EF6\uFF09`);
 }
 
+// src/lib/memory-fts-objects.ts
+var PG_FTS_OBJECTS = [
+  { name: "pg_trgm", kind: "extension", ddl: `CREATE EXTENSION IF NOT EXISTS pg_trgm;` },
+  {
+    name: "AddMemory_topic_trgm_idx",
+    kind: "index",
+    ddl: `CREATE INDEX IF NOT EXISTS "AddMemory_topic_trgm_idx" ON "public"."AddMemory" USING GIN ("topic" gin_trgm_ops);`
+  },
+  {
+    name: "AddMemory_content_trgm_idx",
+    kind: "index",
+    ddl: `CREATE INDEX IF NOT EXISTS "AddMemory_content_trgm_idx" ON "public"."AddMemory" USING GIN ("content" gin_trgm_ops);`
+  },
+  {
+    name: "AddMemoryEvidence_excerpt_trgm_idx",
+    kind: "index",
+    ddl: `CREATE INDEX IF NOT EXISTS "AddMemoryEvidence_excerpt_trgm_idx" ON "public"."AddMemoryEvidence" USING GIN ("excerpt" gin_trgm_ops);`
+  }
+];
+var SQLITE_FTS_OBJECTS = [
+  {
+    name: "add_memory_fts",
+    kind: "table",
+    ddl: `CREATE VIRTUAL TABLE IF NOT EXISTS add_memory_fts USING fts5(memory_id UNINDEXED, topic, content, tokenize = 'trigram');`
+  },
+  {
+    name: "add_memory_fts_ai",
+    kind: "trigger",
+    ddl: `CREATE TRIGGER IF NOT EXISTS add_memory_fts_ai AFTER INSERT ON "AddMemory" BEGIN INSERT INTO add_memory_fts(memory_id, topic, content) VALUES (new.id, new.topic, new.content); END;`
+  },
+  {
+    name: "add_memory_fts_au",
+    kind: "trigger",
+    ddl: `CREATE TRIGGER IF NOT EXISTS add_memory_fts_au AFTER UPDATE ON "AddMemory" BEGIN DELETE FROM add_memory_fts WHERE memory_id = old.id; INSERT INTO add_memory_fts(memory_id, topic, content) VALUES (new.id, new.topic, new.content); END;`
+  },
+  {
+    name: "add_memory_fts_ad",
+    kind: "trigger",
+    ddl: `CREATE TRIGGER IF NOT EXISTS add_memory_fts_ad AFTER DELETE ON "AddMemory" BEGIN DELETE FROM add_memory_fts WHERE memory_id = old.id; END;`
+  }
+];
+function resolveFtsObjects(backend) {
+  return backend === "postgres" ? PG_FTS_OBJECTS : SQLITE_FTS_OBJECTS;
+}
+function detectBackend(databaseUrl) {
+  const url = (databaseUrl ?? "").trim().toLowerCase();
+  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) return "postgres";
+  if (url.startsWith("sqlite:") || url.startsWith("file:") || url.endsWith(".db") || url.endsWith(".sqlite")) {
+    return "sqlite";
+  }
+  throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u7684 DATABASE_URL \u540E\u7AEF: ${databaseUrl}`);
+}
+var PG_MISSING_MARKER = "ADDCODER_FTS_MISSING:";
+function renderPgProbeSql(expected) {
+  const values = expected.map((s) => `    ('${s.name.replace(/'/g, "''")}', '${s.kind === "extension" ? "extension" : "relation"}')`).join(",\n");
+  return `-- \u7531 add-coder memory:reindex \u751F\u6210\uFF08\u771F\u6E90\uFF1Asrc/lib/memory-fts-objects.ts \u7684 PG_FTS_OBJECTS\uFF09
+DO $$
+DECLARE missing text;
+BEGIN
+  SELECT string_agg(n.name, ',') INTO missing
+  FROM (VALUES
+${values}
+  ) AS n(name, kind)
+  WHERE NOT (
+    (n.kind = 'extension' AND EXISTS (SELECT 1 FROM pg_extension e WHERE e.extname = n.name))
+    OR (n.kind = 'relation' AND EXISTS (SELECT 1 FROM pg_indexes i WHERE i.indexname = n.name))
+  );
+  IF missing IS NOT NULL THEN
+    RAISE EXCEPTION '${PG_MISSING_MARKER} %', missing;
+  END IF;
+END $$;
+`;
+}
+function parsePgProbeMissing(stderr, expected) {
+  const at = (stderr ?? "").indexOf(PG_MISSING_MARKER);
+  if (at < 0) return [];
+  const tail = stderr.slice(at + PG_MISSING_MARKER.length);
+  const known = new Set(expected.map((s) => s.name));
+  return tail.split(/[\s"',\n]+/).map((s) => s.trim()).filter((s) => known.has(s));
+}
+
+// src/lib/memory-fts-runtime.ts
+import { existsSync as existsSync17, mkdtempSync, readFileSync as readFileSync13, rmSync as rmSync2, writeFileSync as writeFileSync9 } from "fs";
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { isAbsolute, join as join11, resolve as resolve13 } from "path";
+var requireBuiltin = createRequire(import.meta.url);
+function loadNodeSqlite() {
+  return requireBuiltin("node:sqlite");
+}
+async function probeVia(adapter, expected) {
+  const specs = expected ?? resolveFtsObjects(adapter.backend);
+  const existing = await adapter.listExisting();
+  const missing = specs.filter((s) => !existing.has(s.name)).map((s) => s.name);
+  const present = specs.length - missing.length;
+  return {
+    backend: adapter.backend,
+    source: adapter.source,
+    missing,
+    rebuilt: [],
+    present,
+    total: specs.length,
+    progress: specs.length === 0 ? 100 : Math.round(present / specs.length * 100)
+  };
+}
+async function reindexVia(adapter, expected) {
+  const specs = expected ?? resolveFtsObjects(adapter.backend);
+  const first = await probeVia(adapter, specs);
+  const rebuilt = [];
+  for (const name of first.missing) {
+    const spec = specs.find((s) => s.name === name);
+    if (!spec) continue;
+    await adapter.apply(spec.ddl);
+    rebuilt.push(spec.name);
+  }
+  const after = await probeVia(adapter, specs);
+  return { ...after, rebuilt };
+}
+function sqlitePathCandidates(databaseUrl, projectRoot) {
+  const raw = (databaseUrl ?? "").replace(/^file:/, "").replace(/^sqlite:/, "").split("?")[0];
+  if (!raw) return [];
+  if (isAbsolute(raw)) return [raw];
+  return [resolve13(projectRoot, raw), resolve13(projectRoot, "prisma", raw)];
+}
+function createSqliteAdapter(opts) {
+  const candidates = opts.dbPath ? [opts.dbPath] : sqlitePathCandidates(opts.databaseUrl, opts.projectRoot);
+  const dbPath = candidates.find((p) => existsSync17(p));
+  const source = dbPath ?? `${opts.databaseUrl}\uFF08\u672A\u627E\u5230\u5E93\u6587\u4EF6\uFF0C\u5DF2\u8BD5\uFF1A${candidates.join(" / ")}\uFF09`;
+  function withDb(fn) {
+    if (!dbPath) {
+      throw new Error(
+        `SQLite \u5E93\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${opts.databaseUrl}\u3002\u5148\u8FD0\u884C add-coder init\uFF08\u6216\u786E\u8BA4 .env.development \u7684 DATABASE_URL\uFF09\u2014\u2014\u5DF2\u8BD5\uFF1A${candidates.join(" / ")}`
+      );
+    }
+    let sqlite;
+    try {
+      sqlite = loadNodeSqlite();
+    } catch (e) {
+      throw new Error(
+        `\u5F53\u524D Node \u4E0D\u652F\u6301 node:sqlite\uFF08\u9700 \u226522.5\uFF0C\u5B9E\u6D4B ${process.version}\uFF09\uFF1A${e instanceof Error ? e.message : String(e)}\uFF1B\u53EF\u6539\u7528 SQL \u6587\u4EF6\u624B\u5DE5\u5E94\u7528\uFF08npx prisma db execute --file <magicDir>/scripts/mcp-server/shared/memory/retrieval/fts/sqlite-fts5.sql --schema prisma/schema.prisma\uFF09`
+      );
+    }
+    const db = new sqlite.DatabaseSync(dbPath);
+    try {
+      return fn(db);
+    } finally {
+      db.close();
+    }
+  }
+  return {
+    backend: "sqlite",
+    source,
+    listExisting: () => Promise.resolve().then(
+      () => withDb((db) => {
+        const rows = db.prepare("SELECT name FROM sqlite_master WHERE type IN ('table','trigger')").all();
+        return new Set(rows.map((r) => r.name));
+      })
+    ),
+    apply: (ddl) => Promise.resolve().then(
+      () => withDb((db) => {
+        db.exec(ddl);
+      })
+    )
+  };
+}
+function readPrismaDatasourceProvider(projectRoot) {
+  for (const rel of ["prisma/schema.prisma", "prisma/add.prisma"]) {
+    const p = resolve13(projectRoot, rel);
+    if (!existsSync17(p)) continue;
+    const m = readFileSync13(p, "utf-8").match(/datasource\s+\w+\s*\{[\s\S]*?provider\s*=\s*"([^"]+)"/);
+    if (m) return m[1];
+  }
+  return null;
+}
+function backendForProvider(provider) {
+  const p = provider.trim().toLowerCase();
+  if (p === "postgresql" || p === "postgres") return "postgres";
+  if (p === "sqlite") return "sqlite";
+  throw new Error(`\u4E0D\u652F\u6301\u7684 datasource provider: ${provider}\uFF08\u672C\u547D\u4EE4\u4EC5\u652F\u6301 postgresql / sqlite\uFF09`);
+}
+function resolveProjectDatabaseUrl(projectRoot, env = process.env) {
+  if (env.DATABASE_URL) return env.DATABASE_URL;
+  for (const rel of [".env.development", ".env"]) {
+    const p = resolve13(projectRoot, rel);
+    if (!existsSync17(p)) continue;
+    const m = readFileSync13(p, "utf-8").match(/^\s*DATABASE_URL\s*=\s*["']?([^"'\n]+)["']?\s*$/m);
+    if (m) return m[1].trim();
+  }
+  return null;
+}
+function createPrismaCliAdapter(opts) {
+  const expected = opts.expected ?? PG_FTS_OBJECTS;
+  const pm = detectPm(opts.projectRoot);
+  const base = pm === "pnpm" ? ["exec", "prisma"] : ["exec", "prisma", "--"];
+  const run = opts.run ?? ((argv, cwd) => runCommand(pm, argv, { cwd, timeout: opts.timeoutMs ?? 12e4 }));
+  const source = opts.describeSource ?? "prisma db execute\uFF08\u9879\u76EE DATABASE_URL\uFF09";
+  function executeSql(sql, tag) {
+    const dir = mkdtempSync(join11(tmpdir(), "add-coder-fts-"));
+    const file = join11(dir, `${tag}.sql`);
+    writeFileSync9(file, sql, "utf-8");
+    try {
+      const r = run([...base, "db", "execute", "--file", file], opts.projectRoot);
+      return { status: r.status, stderr: r.stderr ?? "" };
+    } finally {
+      rmSync2(dir, { recursive: true, force: true });
+    }
+  }
+  return {
+    backend: "postgres",
+    source,
+    listExisting: () => {
+      const r = executeSql(renderPgProbeSql(expected), "probe");
+      if (r.status === 0) return Promise.resolve(new Set(expected.map((s) => s.name)));
+      const missing = parsePgProbeMissing(r.stderr, expected);
+      if (missing.length > 0) {
+        return Promise.resolve(new Set(expected.map((s) => s.name).filter((n) => !missing.includes(n))));
+      }
+      return Promise.reject(
+        new Error(
+          `PG FTS \u63A2\u6D4B\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${r.status}\uFF09\uFF1A${r.stderr.trim().split("\n").slice(0, 3).join(" | ") || "\u65E0 stderr"}`
+        )
+      );
+    },
+    apply: (ddl) => {
+      const r = executeSql(`${ddl}
+`, "apply");
+      if (r.status === 0) return Promise.resolve();
+      return Promise.reject(
+        new Error(
+          `PG FTS \u671F\u671B\u6001\u5E94\u7528\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${r.status}\uFF09\uFF1A${r.stderr.trim().split("\n").slice(0, 3).join(" | ") || "\u65E0 stderr"}`
+        )
+      );
+    }
+  };
+}
+
+// src/cli/commands/memory-reindex.ts
+function resolveAdapter3(projectRoot, options, deps) {
+  const databaseUrl = resolveProjectDatabaseUrl(projectRoot, deps.env ?? process.env);
+  let backend;
+  if (options.backend) {
+    backend = options.backend;
+  } else {
+    const provider = readPrismaDatasourceProvider(projectRoot);
+    if (provider) backend = backendForProvider(provider);
+    else if (databaseUrl) backend = detectBackend(databaseUrl);
+    else {
+      throw new Error(
+        "\u65E0\u6CD5\u5224\u5B9A\u540E\u7AEF\uFF1A\u672A\u6307\u5B9A --backend\uFF0C\u4E14\u9879\u76EE\u5185\u65E2\u65E0 prisma/schema.prisma \u7684 datasource \u58F0\u660E\uFF0C\u4E5F\u65E0 .env.development \u7684 DATABASE_URL"
+      );
+    }
+  }
+  const magicDir = resolveMagicDir(projectRoot);
+  if (backend === "sqlite") {
+    if (!databaseUrl) {
+      throw new Error(`SQLite \u540E\u7AEF\u9700\u8981 DATABASE_URL\uFF08.env.development \u6216\u8FDB\u7A0B\u73AF\u5883\uFF09\uFF1BmagicDir=${magicDir}`);
+    }
+    return createSqliteAdapter({ databaseUrl, projectRoot });
+  }
+  return createPrismaCliAdapter({
+    projectRoot,
+    run: deps.run,
+    describeSource: databaseUrl ? `prisma db execute\uFF08DATABASE_URL=${maskUrl(databaseUrl)}\uFF09` : "prisma db execute\uFF08schema \u5185 env\uFF09"
+  });
+}
+function maskUrl(url) {
+  return url.replace(/:\/\/([^:/@]+):[^@]*@/, "://$1:***@");
+}
+function printReport(report, mode, io) {
+  const head = mode === "apply" ? "\u8BB0\u5FC6 FTS \u671F\u671B\u6001 \xB7 \u91CD\u5EFA" : "\u8BB0\u5FC6 FTS \u671F\u671B\u6001 \xB7 \u63A2\u6D4B";
+  io.log(`${head}\uFF08backend=${report.backend}\uFF0Csource=${report.source}\uFF09`);
+  io.log(`  \u5B8C\u6210\u5EA6 ${report.present}/${report.total}\uFF08${report.progress}%\uFF09`);
+  if (mode === "apply" && report.rebuilt.length > 0) {
+    io.log(`  \u672C\u6B21\u91CD\u5EFA\uFF08${report.rebuilt.length}\uFF09\uFF1A${report.rebuilt.join(", ")}`);
+  }
+  if (report.missing.length > 0) {
+    io.log(`  \u7F3A\u5931\uFF08${report.missing.length}\uFF09\uFF1A${report.missing.join(", ")}`);
+    io.log(mode === "apply" ? "  \u274C \u91CD\u5EFA\u540E\u4ECD\u7F3A\u5931\u2014\u2014\u8BF7\u68C0\u67E5 DDL \u662F\u5426\u88AB\u62D2\uFF08\u6743\u9650/\u6269\u5C55\u4E0D\u53EF\u7528\uFF09" : "  \u2192 \u4FEE\u590D\uFF1Aadd-coder memory:reindex --apply");
+  } else {
+    io.log("  \u2705 \u671F\u671B\u6001\u5B8C\u6574");
+  }
+}
+async function memoryReindexCommand(options, deps = {}) {
+  const io = deps.io ?? console;
+  const projectRoot = options.cwd ?? process.cwd();
+  if (options.apply && options.probe) {
+    io.error(JSON.stringify({ ok: false, mode: "n/a", reason: "flags-conflict", detail: "--probe \u4E0E --apply \u4E92\u65A5\uFF08\u9ED8\u8BA4 probe\uFF09", exitCode: 2 }));
+    return 2;
+  }
+  const mode = options.apply ? "apply" : "probe";
+  try {
+    const adapter = resolveAdapter3(projectRoot, options, deps);
+    const report = mode === "apply" ? await reindexVia(adapter) : await probeVia(adapter);
+    if (options.json) io.log(JSON.stringify(report, null, 2));
+    else printReport(report, mode, io);
+    if (mode === "probe") return 0;
+    return report.missing.length > 0 ? 1 : 0;
+  } catch (e) {
+    const detail = e instanceof Error ? e.message : String(e);
+    const context = { ok: false, mode, backend: options.backend ?? "auto", exitCode: 2, error: detail };
+    io.error(
+      options.json ? JSON.stringify(context) : `\u8BB0\u5FC6 FTS ${mode === "apply" ? "\u91CD\u5EFA" : "\u63A2\u6D4B"}\u5931\u8D25\uFF1A${detail}\uFF08backend=${context.backend}, exitCode=2\uFF09`
+    );
+    return 2;
+  }
+}
+
 // src/cli/index.ts
 var { version } = JSON.parse(
-  readFileSync13(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync14(new URL("../package.json", import.meta.url), "utf-8")
 );
 async function modelDownloadCommand(options) {
   try {
@@ -2962,4 +3331,13 @@ program.command("stack").description("\u7BA1\u7406\u6280\u672F\u6808\u7EA6\u675F
   (sub, name, options) => stackCommand(sub, name, options)
 );
 program.command("model:download").description("\u9884\u4E0B\u8F7D embedding \u6A21\u578B\uFF08\u9996\u6B21 DPS \u8C03\u7528\u4F1A\u81EA\u52A8\u4E0B\u8F7D\uFF0C\u672C\u547D\u4EE4\u63D0\u524D\u62C9\u53D6\uFF09").option("--force", "\u5F3A\u5236\u91CD\u65B0\u4E0B\u8F7D\uFF08\u5373\u4F7F\u7F13\u5B58\u5DF2\u5B58\u5728\uFF09").action(modelDownloadCommand);
+program.command("memory:reindex").description("\u8BB0\u5FC6 FTS \u671F\u671B\u6001\u63A2\u6D4B/\u91CD\u5EFA\uFF08\u81EA\u52A9\u4FEE\u590D\u5165\u53E3\uFF1A\u7F3A\u5BF9\u8C61\u5219\u8865\u9F50\uFF0C\u53CC\u540E\u7AEF postgres/sqlite\uFF09").option("--probe", "\u53EA\u8BFB\u63A2\u6D4B\u7F3A\u5931\u5BF9\u8C61\uFF08\u9ED8\u8BA4\u884C\u4E3A\uFF09").option("--apply", "\u5E94\u7528\u7F3A\u5931\u5BF9\u8C61\u5E76\u590D\u63A2\uFF08\u4ECD\u6709\u7F3A\u5931\u5219\u9000\u51FA\u7801 1\uFF09").option("--backend <type>", "\u540E\u7AEF: postgres | sqlite\uFF08\u7F3A\u7701\u6309\u9879\u76EE Prisma datasource \u81EA\u52A8\u5224\u5B9A\uFF09").option("--json", "\u4EE5 JSON \u8F93\u51FA\u62A5\u544A\uFF08\u4F9B\u81EA\u52A8\u5316\u6D88\u8D39\uFF09").action(async (options) => {
+  const backend = options.backend === "postgres" || options.backend === "sqlite" ? options.backend : void 0;
+  if (options.backend && !backend) {
+    console.error(`\u672A\u77E5 backend: ${options.backend}\uFF08\u53EF\u9009 postgres | sqlite\uFF09`);
+    process.exitCode = 2;
+    return;
+  }
+  process.exitCode = await memoryReindexCommand({ ...options, backend });
+});
 program.parse();