add-coder 0.3.38 → 0.3.40

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { Command } from "commander";
 
 // src/caijuehub/strategies/detect.strategy.ts
@@ -1548,7 +1548,7 @@ async function injectPrisma2(projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync13, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync5 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, existsSync as existsSync14, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync5 } from "fs";
 import { createHash } from "crypto";
 import { resolve as resolve9, dirname as dirname3, join as pathJoin } from "path";
 import { homedir as homedir2 } from "os";
@@ -1666,6 +1666,68 @@ function applyMemoryExpectedState(opts) {
   }
 }
 
+// src/lib/memory-snapshot-install.ts
+import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { join as join10 } from "path";
+var ENV_FILE_CANDIDATES = [".env.development.local", ".env.development", ".env.local", ".env"];
+function readDatabaseUrlFromEnvFiles(projectRoot) {
+  for (const f of ENV_FILE_CANDIDATES) {
+    const p = join10(projectRoot, f);
+    if (!existsSync13(p)) continue;
+    const text = readFileSync10(p, "utf-8");
+    const m = text.match(/^\s*DATABASE_URL\s*=\s*"?([^"\n\r]+)"?\s*$/m);
+    if (m?.[1]) return m[1].trim();
+  }
+  return void 0;
+}
+function memoryJobsScriptRelPath(magicDir) {
+  return `${magicDir}/scripts/memory/memory-jobs.ts`;
+}
+function refreshL1SnapshotOnInstall(opts) {
+  const relScript = memoryJobsScriptRelPath(opts.magicDir);
+  const absScript = join10(opts.projectRoot, opts.magicDir, "scripts", "memory", "memory-jobs.ts");
+  const cmd = `npx tsx ${relScript} refresh-l1`;
+  if (!existsSync13(absScript)) {
+    return {
+      ok: false,
+      relScript,
+      cmd,
+      detail: `\u8BB0\u5FC6\u5165\u53E3\u811A\u672C\u7F3A\u5931: ${relScript}\uFF08\u6A21\u677F\u672A\u5C31\u7EEA\uFF1A\u5148\u6267\u884C add-coder sync\uFF0C\u6216\u786E\u8BA4 add-coder \u7248\u672C \u2265 \u672C Plan \u7248\u672C\uFF09`
+    };
+  }
+  const env = opts.env ?? process.env;
+  const databaseUrl = env.DATABASE_URL || readDatabaseUrlFromEnvFiles(opts.projectRoot);
+  if (!databaseUrl) {
+    return {
+      ok: false,
+      relScript,
+      cmd,
+      detail: `\u672A\u627E\u5230 DATABASE_URL\uFF08\u68C0\u67E5 ${ENV_FILE_CANDIDATES.join(" / ")}\uFF0C\u6216\u5728\u73AF\u5883\u4E2D\u663E\u5F0F\u5BFC\u51FA\uFF09`
+    };
+  }
+  const runner = opts.run ?? ((c, a, o) => runCommand(c, a, o));
+  const result = runner(
+    "npx",
+    ["tsx", absScript, "refresh-l1"],
+    {
+      cwd: opts.projectRoot,
+      env: { ...env, PROJECT_ROOT: opts.projectRoot, MAGIC_DIR: opts.magicDir, DATABASE_URL: databaseUrl },
+      timeout: opts.timeoutMs ?? 12e4
+    }
+  );
+  if (result.status !== 0) {
+    const why = (result.stderr || "").trim().split("\n").slice(0, 4).join(" | ");
+    return {
+      ok: false,
+      relScript,
+      cmd,
+      detail: `memory-jobs refresh-l1 \u9000\u51FA\u7801 ${result.status}${why ? ` \u2014\u2014 ${why}` : "\uFF08\u65E0 stderr \u8F93\u51FA\uFF09"}`,
+      stdout: result.stdout
+    };
+  }
+  return { ok: true, relScript, cmd, stdout: result.stdout };
+}
+
 // src/cli/commands/init.ts
 var ADAPTER_RENDERERS = {
   claude: renderAdapter,
@@ -1697,6 +1759,17 @@ async function initCommand(options) {
   const dbFail = await deployDatabase(ctx);
   ensurePortsContract(ctx.projectRoot, ctx.config, !!options.dryRun);
   deployDocs(ctx);
+  if (!options.dryRun) {
+    const snap = refreshL1SnapshotOnInstall({ projectRoot: ctx.projectRoot, magicDir: ctx.magicDir });
+    if (!snap.ok) {
+      console.error(`
+\u2717 \u8BB0\u5FC6\u5FEB\u7167\u672A\u5C31\u7EEA: ${snap.detail}`);
+      console.error(`  \u590D\u73B0\u547D\u4EE4: ${snap.cmd}`);
+      console.error("  \u4FEE\u590D\u540E\u91CD\u65B0\u8FD0\u884C add-coder init\uFF08\u8BE5\u6B65\u9AA4\u4E3A\u786C\u95E8\u7981\uFF09\u3002");
+      process.exit(1);
+    }
+    console.log(`\u2705 \u8BB0\u5FC6 L1 \u5FEB\u7167\u5DF2\u5237\u65B0: ${snap.relScript}`);
+  }
   finalize(ctx, result, dbFail);
   if (!options.dryRun) {
     try {
@@ -1732,7 +1805,7 @@ async function handleCodexMcpConfig(options) {
       console.log(`[dry-run] \u5C06\u5199\u5165 ${userConfigPath}`);
       return;
     }
-    if (existsSync13(userConfigPath) && readFileSync10(userConfigPath, "utf-8").includes("mcp_servers.add_coder")) {
+    if (existsSync14(userConfigPath) && readFileSync11(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;
     }
@@ -1741,7 +1814,7 @@ async function handleCodexMcpConfig(options) {
       console.log("\u5DF2\u53D6\u6D88\u5199\u5165");
       return;
     }
-    if (existsSync13(userConfigPath)) {
+    if (existsSync14(userConfigPath)) {
       const backup = `${userConfigPath}.bak-${Date.now()}`;
       copyFileSync2(userConfigPath, backup);
       console.log(`\u5DF2\u5907\u4EFD\u539F\u914D\u7F6E \u2192 ${backup}`);
@@ -1917,18 +1990,18 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync13(scriptsDir)) mkdirSync6(scriptsDir, { recursive: true });
+  if (!existsSync14(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 = resolve9(projectRoot, "package.json");
-  if (!existsSync13(pkgPath)) return;
+  if (!existsSync14(pkgPath)) return;
   if (dryRun) {
     console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
     return;
   }
-  const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
   if (!pkg.scripts) pkg.scripts = {};
   if (!pkg.scripts["db:export"]) {
     pkg.scripts["db:export"] = "npx tsx scripts/export-db.ts";
@@ -1976,14 +2049,14 @@ function writeComposeEnv(ctx) {
   if (!db.reuseExisting) {
     const composeName = db.container === "podman" ? "podman-compose.add.yml" : "docker-compose.add.yml";
     const composePath = resolve9(projectRoot, composeName);
-    if (!options.dryRun && (!existsSync13(composePath) || options.force)) {
+    if (!options.dryRun && (!existsSync14(composePath) || options.force)) {
       writeFileSync6(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
   const devEnvPath = resolve9(projectRoot, ".env.development");
-  if (!options.dryRun && existsSync13(devEnvPath)) {
-    const existing = readFileSync10(devEnvPath, "utf-8");
+  if (!options.dryRun && existsSync14(devEnvPath)) {
+    const existing = readFileSync11(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
       writeFileSync6(devEnvPath, existing + `
 DATABASE_USER=${db.user || "admin"}
@@ -2030,7 +2103,7 @@ async function renderAndWrite(ctx) {
   const reviewTargets = target === "codex" ? [magicDir] : [ADD_DIR, magicDir];
   for (const d of reviewTargets) {
     const reviewsDir = resolve9(projectRoot, d, "reviews");
-    if (!existsSync13(reviewsDir)) {
+    if (!existsSync14(reviewsDir)) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
@@ -2042,7 +2115,7 @@ async function renderAndWrite(ctx) {
     const hashMap = {};
     let npmVer = "";
     try {
-      npmVer = JSON.parse(readFileSync10(resolve9(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
+      npmVer = JSON.parse(readFileSync11(resolve9(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
     } catch {
     }
     for (const [rp, c] of allFiles) {
@@ -2081,7 +2154,7 @@ ${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
   }
   if (db.engine === "postgresql" && db.container === "manual") {
     const dbScript = resolve9(projectRoot, magicDir, "scripts", "db-ensure.sh");
-    if (existsSync13(dbScript)) {
+    if (existsSync14(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 ? `
@@ -2139,12 +2212,12 @@ function deployDocs(ctx) {
   for (const d of ["00-\u9700\u6C42", "01-\u67B6\u6784", "02-\u89C4\u8303"]) {
     const srcDir = resolve9(groundingSrc, d);
     const destDir = resolve9(docsBase, d);
-    if (!existsSync13(destDir)) mkdirSync6(destDir, { recursive: true });
-    if (!existsSync13(srcDir)) continue;
+    if (!existsSync14(destDir)) mkdirSync6(destDir, { recursive: true });
+    if (!existsSync14(srcDir)) continue;
     for (const f of readdirSync5(srcDir)) {
       const src = resolve9(srcDir, f);
       const dest = resolve9(destDir, f);
-      if (existsSync13(dest)) continue;
+      if (existsSync14(dest)) continue;
       try {
         copyFileSync2(src, dest);
       } catch {
@@ -2160,7 +2233,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(resolve9(import.meta.dirname, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync11(resolve9(import.meta.dirname, "../package.json"), "utf-8"));
   const peerNames = Object.keys(pkg.peerDependencies || {});
   if (peerNames.length > 0) {
     console.log(`
@@ -2193,7 +2266,7 @@ function finalize(ctx, result, dbFail) {
 }
 
 // src/cli/commands/sync.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
 import { resolve as resolve10, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
 
@@ -2267,7 +2340,7 @@ function resolvePatchConflictMode(yes = false, isTTY = Boolean(process.stdin.isT
 }
 function loadHashFile(root, magic) {
   try {
-    const raw = JSON.parse(readFileSync11(resolve10(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
+    const raw = JSON.parse(readFileSync12(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;
@@ -2277,7 +2350,7 @@ function loadHashFile(root, magic) {
 }
 function loadVersionFile(root, magic) {
   try {
-    return readFileSync11(resolve10(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
+    return readFileSync12(resolve10(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
   } catch {
     return "";
   }
@@ -2293,7 +2366,7 @@ function loadTemplateVersion(root) {
   ];
   for (const candidate of candidates) {
     try {
-      return JSON.parse(readFileSync11(candidate, "utf-8"))._version ?? "";
+      return JSON.parse(readFileSync12(candidate, "utf-8"))._version ?? "";
     } catch {
     }
   }
@@ -2404,13 +2477,13 @@ async function syncCommand(options = {}) {
     for (const [relPath, content] of candidates) {
       const key = normalizeRelPath(relPath);
       const absPath = resolve10(projectRoot, relPath);
-      if (!existsSync14(absPath)) {
+      if (!existsSync15(absPath)) {
         missingFiles.set(key, content);
       } else if (establishBaseline) {
         missingFiles.set(key, content);
       } else {
         const classification = classifyPatchCandidate(
-          readFileSync11(absPath, "utf-8"),
+          readFileSync12(absPath, "utf-8"),
           content,
           outHash[key]
         );
@@ -2451,7 +2524,7 @@ async function syncCommand(options = {}) {
     let finalHash = mergeFullHash(
       outHash,
       [...candidates].map(([relPath]) => ({ relPath, absPath: resolve10(projectRoot, relPath) })),
-      (absPath) => existsSync14(absPath) ? hash8(readFileSync11(absPath, "utf-8")) : null,
+      (absPath) => existsSync15(absPath) ? hash8(readFileSync12(absPath, "utf-8")) : null,
       unresolvedConflictKeys
     );
     if (target === "codex") {
@@ -2462,16 +2535,18 @@ async function syncCommand(options = {}) {
     await checkPrismaDiff(projectRoot, options);
     ensurePortsContract(projectRoot, config);
     await maybeModelDownload(options);
+    refreshSnapshotOrExit(projectRoot, magicDir);
     return;
   }
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of allFiles) {
-    if (!existsSync14(resolve10(projectRoot, relPath))) {
+    if (!existsSync15(resolve10(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
   if (missing.size === 0) {
     console.log(SYNC_CONFIG.PROMPT_FULL);
+    refreshSnapshotOrExit(projectRoot, magicDir);
     return;
   }
   let filesToWrite = missing;
@@ -2487,10 +2562,22 @@ async function syncCommand(options = {}) {
   await checkPrismaDiff(projectRoot, options);
   ensurePortsContract(projectRoot, config);
   await maybeModelDownload(options);
+  refreshSnapshotOrExit(projectRoot, magicDir);
+}
+function refreshSnapshotOrExit(projectRoot, magicDir) {
+  const snap = refreshL1SnapshotOnInstall({ projectRoot, magicDir });
+  if (!snap.ok) {
+    console.error(`
+\u2717 \u8BB0\u5FC6\u5FEB\u7167\u672A\u5C31\u7EEA: ${snap.detail}`);
+    console.error(`  \u590D\u73B0\u547D\u4EE4: ${snap.cmd}`);
+    console.error("  \u4FEE\u590D\u540E\u91CD\u65B0\u8FD0\u884C add-coder sync\uFF08\u8BE5\u6B65\u9AA4\u4E3A\u786C\u95E8\u7981\uFF09\u3002");
+    process.exit(1);
+  }
+  console.log(`\u2705 \u8BB0\u5FC6 L1 \u5FEB\u7167\u5DF2\u5237\u65B0: ${snap.relScript}`);
 }
 function printMigrateGuidance(targetPath, changed) {
   const g = SYNC_PRISMA_CONFIG.POST_SYNC;
-  const isManaged = existsSync14(resolve10(dirname4(targetPath), "migrations"));
+  const isManaged = existsSync15(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) {
@@ -2529,7 +2616,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 = existsSync14(resolve10(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  const pm = existsSync15(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) {
@@ -2542,8 +2629,8 @@ async function ensureAtlasCapability(projectRoot, yes = false) {
 }
 function checkHostAtlasSegment(projectRoot) {
   const script = resolve10(projectRoot, "scripts", "db-ensure.sh");
-  if (!existsSync14(script)) return;
-  const content = readFileSync11(script, "utf-8");
+  if (!existsSync15(script)) return;
+  const content = readFileSync12(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");
   console.warn("      \u804C\u8D23\u8FB9\u754C: add-coder \u53EA\u540C\u6B65 ADD \u6CBB\u7406\u6A21\u578B(7 \u8868)\uFF1B\u5BBF\u4E3B\u4E1A\u52A1\u8868 diff \u63A8\u8350 Atlas \u4F46\u4E0D\u5F3A\u6C42");
@@ -2557,7 +2644,7 @@ async function checkPrismaDiff(projectRoot, options) {
   if (!options.patch) return;
   const basePath = resolve10(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
   const targetPath = resolve10(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
-  if (!existsSync14(basePath)) {
+  if (!existsSync15(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`);
@@ -2571,7 +2658,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 = existsSync14(targetPath);
+  const targetExists = existsSync15(targetPath);
   let modifiedCount = 0;
   console.log(`
 \u26A0\uFE0F  Prisma schema \u5DEE\u5F02\u68C0\u6D4B:`);
@@ -2722,7 +2809,7 @@ async function handleDiffAction(action, ctx) {
   }
 }
 function injectMissingModels(targetPath, models) {
-  let content = readFileSync11(targetPath, "utf-8");
+  let content = readFileSync12(targetPath, "utf-8");
   content = content.replace(/\n*$/, "\n");
   content += `
 // ===== \u7531 add-coder sync --patch \u81EA\u52A8\u6CE8\u5165 (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}) =====
@@ -2735,7 +2822,7 @@ function injectMissingModels(targetPath, models) {
   return models.length;
 }
 function getBaseFieldLines(basePath, modelName) {
-  const content = readFileSync11(basePath, "utf-8");
+  const content = readFileSync12(basePath, "utf-8");
   const blocks = parseSchemaBlocks(content);
   const block = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
   if (!block) return {};
@@ -2758,7 +2845,7 @@ function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
     console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A${modelName} \u5728\u57FA\u51C6\u4E2D\u672A\u627E\u5230\u5B57\u6BB5\u5B9A\u4E49\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
     return 0;
   }
-  const content = readFileSync11(targetPath, "utf-8");
+  const content = readFileSync12(targetPath, "utf-8");
   const lines = content.split("\n");
   const blocks = parseSchemaBlocks(content);
   const target = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
@@ -2805,7 +2892,7 @@ function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
 function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
   const baseFields = getBaseFieldLines(basePath, modelName);
   if (Object.keys(baseFields).length === 0) return 0;
-  let content = readFileSync11(targetPath, "utf-8");
+  let content = readFileSync12(targetPath, "utf-8");
   let count = 0;
   for (const { fieldName } of conflicts) {
     const baseLine = baseFields[fieldName];
@@ -2821,8 +2908,176 @@ function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync15 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join11, resolve as resolve11 } from "path";
+var VIRTUAL_TOOLS_SETTING_KEY = "github.copilot.chat.virtualTools.threshold";
+function stripJsonComments(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i++;
+      out += " ";
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function stripTrailingCommas(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === ",") {
+      let j = i + 1;
+      while (j < text.length && /\s/.test(text[j])) j++;
+      if (text[j] === "}" || text[j] === "]") continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function parseJsonc(text) {
+  return JSON.parse(stripTrailingCommas(stripJsonComments(text)));
+}
+function vscodeSettingsCandidates(input) {
+  const platform = input.platform ?? process.platform;
+  const home = input.homeDir ?? homedir3();
+  const env = input.env ?? process.env;
+  const variants = ["Code", "Code - Insiders"];
+  let userRoots;
+  if (platform === "win32") {
+    const appData = env.APPDATA || join11(home, "AppData", "Roaming");
+    userRoots = variants.map((v) => join11(appData, v, "User"));
+  } else if (platform === "darwin") {
+    userRoots = variants.map((v) => join11(home, "Library", "Application Support", v, "User"));
+  } else {
+    userRoots = variants.map((v) => join11(home, ".config", v, "User"));
+  }
+  return [
+    join11(input.projectRoot, ".vscode", "settings.json"),
+    ...userRoots.map((root) => join11(root, "settings.json"))
+  ];
+}
+function checkVsCodeVirtualTools(input) {
+  const candidates = vscodeSettingsCandidates(input).map((path) => {
+    if (!existsSync16(path)) return { path, exists: false, hasKey: false, threshold: null };
+    let parsed;
+    try {
+      parsed = parseJsonc(readFileSync13(path, "utf-8"));
+    } catch (e) {
+      return {
+        path,
+        exists: true,
+        hasKey: false,
+        threshold: null,
+        parseError: e instanceof Error ? e.message : String(e)
+      };
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      return { path, exists: true, hasKey: false, threshold: null, parseError: "\u9876\u5C42\u4E0D\u662F JSON \u5BF9\u8C61" };
+    }
+    const raw = parsed[VIRTUAL_TOOLS_SETTING_KEY];
+    if (raw === void 0) return { path, exists: true, hasKey: false, threshold: null };
+    return {
+      path,
+      exists: true,
+      hasKey: true,
+      threshold: typeof raw === "number" ? raw : null
+    };
+  });
+  const ok = candidates.some((c) => c.threshold === 0);
+  const state = ok ? "ok" : candidates.some((c) => c.hasKey) ? "non-zero" : "missing";
+  return { state, candidates };
+}
+function isVsCodeTarget(config, projectRoot) {
+  if (config.magicDir === ".vscode" || config.adapters.includes("vscode")) return true;
+  const root = projectRoot || config.projectRoot;
+  if (!root) return false;
+  if (existsSync16(join11(root, ".vscode", "mcp.json"))) return true;
+  const settingsPath = join11(root, ".vscode", "settings.json");
+  if (!existsSync16(settingsPath)) return false;
+  try {
+    const parsed = parseJsonc(readFileSync13(settingsPath, "utf-8"));
+    if (typeof parsed !== "object" || parsed === null) return false;
+    const obj = parsed;
+    if (obj.mcp !== void 0) return true;
+    return Object.keys(obj).some((k) => k.startsWith("github.copilot.chat."));
+  } catch {
+    return false;
+  }
+}
+function virtualToolsNoticeLines(check, ctx) {
+  const lines = [];
+  const describe = (c) => {
+    const where = c.path === join11(ctx.projectRoot, ".vscode", "settings.json") ? "\u5DE5\u4F5C\u533A" : "\u7528\u6237\u7EA7";
+    if (!c.exists) return `${where}: ${c.path}\uFF08\u6587\u4EF6\u4E0D\u5B58\u5728\uFF09`;
+    if (c.parseError) return `${where}: ${c.path}\uFF08\u89E3\u6790\u5931\u8D25: ${c.parseError}\uFF09`;
+    if (!c.hasKey) return `${where}: ${c.path}\uFF08\u952E\u7F3A\u5931\uFF09`;
+    return `${where}: ${c.path}\uFF08\u5F53\u524D\u503C ${c.threshold ?? "\u975E\u6570\u503C"}\uFF09`;
+  };
+  if (check.state === "ok") {
+    const hit = check.candidates.find((c) => c.threshold === 0);
+    lines.push(`  \u2705 VS Code \u865A\u62DF\u5DE5\u5177\u6298\u53E0\u5DF2\u5173\u95ED\uFF08${hit ? hit.path : VIRTUAL_TOOLS_SETTING_KEY + " = 0"}\uFF09`);
+    return lines;
+  }
+  lines.push(`  \u26A0\uFE0F VS Code \u5BBF\u4E3B\u9002\u914D\uFF1A\u672A\u68C0\u6D4B\u5230 "${VIRTUAL_TOOLS_SETTING_KEY}": 0`);
+  check.candidates.forEach((c) => lines.push(`     - ${describe(c)}`));
+  if (check.state === "non-zero") {
+    lines.push("     \u8BE5\u952E\u5B58\u5728\u4F46\u53D6\u503C\u975E 0 \u21D2 \u6298\u53E0\u4ECD\u4F1A\u89E6\u53D1\uFF08\u89E6\u53D1\u7EBF = \u6240\u6709 MCP \u670D\u52A1\u5668\u5DE5\u5177\u603B\u6570 \u2265 \u9608\u503C/2\uFF0C\u9ED8\u8BA4 64\uFF09");
+  } else {
+    lines.push("     \u82E5\u4F60\u7684 Copilot / VS Code \u7248\u672C\u5DF2\u4E0D\u518D\u63D0\u4F9B\u8BE5\u8BBE\u7F6E\u9879\uFF0C\u53EF\u5FFD\u7565\u672C\u544A\u8B66\uFF08\u672C\u9879\u4E3A\u5EFA\u8BAE\u6027\u68C0\u67E5\uFF0C\u4E0D\u5F71\u54CD\u9000\u51FA\u7801\uFF09");
+  }
+  lines.push("     \u4FEE\u590D: \u5728\u7528\u6237\u7EA7\u6216\u5DE5\u4F5C\u533A\u7EA7 settings.json \u52A0\u5165\u4E0B\u9762\u8FD9\u884C\uFF0C\u7136\u540E\u300C\u91CD\u8F7D VS Code \u7A97\u53E3\u300D\uFF08Developer: Reload Window\uFF09");
+  lines.push(`           "${VIRTUAL_TOOLS_SETTING_KEY}": 0`);
+  lines.push('     \u539F\u56E0: \u5DE5\u5177\u88AB\u5BBF\u4E3B\u6298\u53E0\u65F6\uFF0C\u672A\u6FC0\u6D3B\u4EE3\u7406\u5C31\u8C03\u7528\u4F1A\u8BEF\u62A5 "currently disabled by the user"\uFF0C');
+  lines.push("           HITL \u5BA1\u6279\u94FE\uFF08update_hitl/status_hitl\uFF09\u4E0E ADD-7 \u5BA1\u8BA1\u94FE\uFF08record_dev_operation/query_audit_logs\uFF09\u4F1A\u540C\u65F6\u4E2D\u65AD");
+  lines.push(`     \u8BF4\u660E: ${ctx.docPath}\uFF08\u672C\u9879\u4E3A\u5EFA\u8BAE\u6027\u68C0\u67E5\uFF0C\u4E0D\u4F1A\u4FEE\u6539\u4F60\u7684\u8BBE\u7F6E\u6587\u4EF6\uFF09`);
+  return lines;
+}
+function printVirtualToolsCheck(config) {
+  const check = checkVsCodeVirtualTools({ projectRoot: config.projectRoot });
+  const docPath = join11(config.magicDir || ".vscode", "docs", "ADD-governance-vscode-copilot.md");
+  virtualToolsNoticeLines(check, { projectRoot: config.projectRoot, docPath }).forEach(
+    (line) => console.log(line)
+  );
+}
 async function statusCommand() {
   const projectRoot = process.cwd();
   const config = await loadConfig(projectRoot);
@@ -2831,7 +3086,7 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync15(resolve11(projectRoot, relPath))) {
+    if (existsSync16(resolve11(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
@@ -2842,15 +3097,22 @@ async function statusCommand() {
   if (missing.length > 0) {
     console.log(`  \u7F3A\u5931: ${missing.length} \u6587\u4EF6`);
     missing.forEach((f) => console.log(`    - ${f}`));
-    process.exit(1);
   } else {
     console.log("  \u6240\u6709\u6587\u4EF6\u5B8C\u6574\u3002");
   }
+  if (isVsCodeTarget(config, projectRoot)) {
+    console.log("");
+    console.log("\u5BBF\u4E3B\u9002\u914D\u81EA\u68C0\uFF08VS Code Copilot\uFF09:");
+    printVirtualToolsCheck(config);
+  }
+  if (missing.length > 0) {
+    process.exit(1);
+  }
 }
 
 // src/cli/commands/stack.ts
-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 { readdirSync as readdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync8, existsSync as existsSync17, mkdirSync as mkdirSync8 } from "fs";
+import { resolve as resolve12, join as join12 } from "path";
 import { createHash as createHash3 } from "crypto";
 var HASH_OUTPUT_FILE = ".add-coder-hash.json";
 function hash82(c) {
@@ -2866,13 +3128,13 @@ function resolveMagicDir2(projectRoot, specified) {
 }
 function listCustomProfiles(projectRoot, magicDir, registryNames) {
   const dir = resolve12(projectRoot, magicDir, "rules", "profiles");
-  if (!existsSync16(dir)) return [];
+  if (!existsSync17(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 existsSync16(resolve12(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
+  return existsSync17(resolve12(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
 }
 function stackCommand(sub, name, options = {}) {
   const projectRoot = process.cwd();
@@ -2910,11 +3172,11 @@ function stackCommand(sub, name, options = {}) {
       return;
     }
     const profilePath = resolve12(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
-    const stat = existsSync16(profilePath) ? readFileSync12(profilePath, "utf-8").length : 0;
+    const stat = existsSync17(profilePath) ? readFileSync14(profilePath, "utf-8").length : 0;
     console.log(`\u6280\u672F\u6808: ${current}`);
-    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync16(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
+    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync17(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
     try {
-      const raw = JSON.parse(readFileSync12(resolve12(projectRoot, magicDir, "stack.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync14(resolve12(projectRoot, magicDir, "stack.json"), "utf-8"));
       if (raw.updatedAt) console.log(`\u66F4\u65B0\u65F6\u95F4: ${raw.updatedAt}`);
     } catch {
     }
@@ -2940,8 +3202,8 @@ function buildConfig(projectRoot, magicDir, stack) {
   };
   try {
     const pkgPath = resolve12(projectRoot, "package.json");
-    if (existsSync16(pkgPath)) {
-      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+    if (existsSync17(pkgPath)) {
+      const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
       if (pkg.name) config.projectName = pkg.name;
     }
   } catch {
@@ -2968,13 +3230,13 @@ function applyStack(projectRoot, magicDir, name) {
   }
   const hashMap = {};
   try {
-    Object.assign(hashMap, JSON.parse(readFileSync12(resolve12(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
+    Object.assign(hashMap, JSON.parse(readFileSync14(resolve12(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
   } catch {
   }
   let written = 0;
   for (const [relPath, content] of stackRelated) {
     const targetPath = resolve12(projectRoot, relPath);
-    mkdirSync8(join10(targetPath, ".."), { recursive: true });
+    mkdirSync8(join12(targetPath, ".."), { recursive: true });
     writeFileSync8(targetPath, content, "utf-8");
     hashMap[relPath] = hash82(content);
     written++;
@@ -2988,21 +3250,26 @@ function applyStack(projectRoot, magicDir, name) {
   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") : "";
+  const projectRulesContent = existsSync17(projectRulesPath) ? readFileSync14(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 && !existsSync16(profilePathAdd)) fail(`profile \u672A\u5199\u5165 ${ADD_DIR}: ${profilePathAdd}`);
-  if (!existsSync16(profilePathMagic)) fail(`profile \u672A\u5199\u5165 ${magicDir}: ${profilePathMagic}`);
+  if (magicDir !== magicDirFor("codex") && isBuiltin && !existsSync17(profilePathAdd)) fail(`profile \u672A\u5199\u5165 ${ADD_DIR}: ${profilePathAdd}`);
+  if (!existsSync17(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(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 ${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(`   ${magicDir}/rules/profiles/${name}-profile.md ${existsSync17(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_searchText_tsv_idx",
+    kind: "index",
+    ddl: `CREATE INDEX IF NOT EXISTS "AddMemory_searchText_tsv_idx" ON "public"."AddMemory" USING GIN (to_tsvector('simple', "searchText"));`
+  },
   {
     name: "AddMemory_topic_trgm_idx",
     kind: "index",
@@ -3023,17 +3290,17 @@ 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');`
+    ddl: `CREATE VIRTUAL TABLE IF NOT EXISTS add_memory_fts USING fts5(memory_id UNINDEXED, searchText, tokenize = 'unicode61');`
   },
   {
     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;`
+    ddl: `CREATE TRIGGER IF NOT EXISTS add_memory_fts_ai AFTER INSERT ON "AddMemory" BEGIN INSERT INTO add_memory_fts(memory_id, searchText) VALUES (new.id, new.searchText); 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;`
+    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, searchText) VALUES (new.id, new.searchText); END;`
   },
   {
     name: "add_memory_fts_ad",
@@ -3081,12 +3348,73 @@ function parsePgProbeMissing(stderr, expected) {
   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";
+// templates/core/scripts/mcp-server/shared/memory/retrieval/fts-fingerprint.ts
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "fs";
 import { createRequire } from "module";
+import { dirname as dirname5, join as join13 } from "path";
+var TOKENIZATION_CONTRACT_VERSION = 1;
+function computeFtsFingerprint(input) {
+  const userDictPath = input.userDictPath ?? join13(input.projectRoot, input.magicDir, "data", "jieba", "userdict.txt");
+  let userDict = "none";
+  if (existsSync18(userDictPath)) {
+    userDict = createHash4("sha256").update(readFileSync15(userDictPath)).digest("hex").slice(0, 12);
+  }
+  const jieba = input.jiebaVersion ?? detectJiebaVersion();
+  const value = createHash4("sha256").update(`tokenization-v${TOKENIZATION_CONTRACT_VERSION}|${jieba ?? "bigram"}|${userDict}`).digest("hex").slice(0, 12);
+  return { value, parts: { jieba: jieba ?? "bigram", userDict, contract: TOKENIZATION_CONTRACT_VERSION } };
+}
+function detectJiebaVersion() {
+  try {
+    const req = createRequire(import.meta.url);
+    const pkg = req("@node-rs/jieba/package.json");
+    return pkg.version ?? "unknown";
+  } catch {
+    return null;
+  }
+}
+function fingerprintMarkerPath(projectRoot, magicDir) {
+  return join13(projectRoot, magicDir, "memory", "fts-fingerprint.json");
+}
+function readRecordedFingerprint(projectRoot, magicDir) {
+  const p = fingerprintMarkerPath(projectRoot, magicDir);
+  if (!existsSync18(p)) return null;
+  try {
+    return JSON.parse(readFileSync15(p, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeRecordedFingerprint(projectRoot, magicDir, fingerprint, now = /* @__PURE__ */ new Date()) {
+  const p = fingerprintMarkerPath(projectRoot, magicDir);
+  mkdirSync9(dirname5(p), { recursive: true });
+  const payload = {
+    fingerprint: fingerprint.value,
+    recordedAt: now.toISOString(),
+    parts: fingerprint.parts
+  };
+  writeFileSync9(p, JSON.stringify(payload, null, 2) + "\n", "utf-8");
+  return p;
+}
+function checkFtsFingerprint(projectRoot, magicDir) {
+  const current = computeFtsFingerprint({ projectRoot, magicDir });
+  const recorded = readRecordedFingerprint(projectRoot, magicDir);
+  if (!recorded) {
+    return { requiresReindex: true, reason: "\u672A\u8BB0\u5F55\u6307\u7EB9\uFF08\u65E0\u6CD5\u8BC1\u660E\u5386\u53F2 searchText \u4E0E\u5F53\u524D\u5206\u8BCD\u5668\u540C\u6E90\uFF09", current, recorded };
+  }
+  if (recorded.fingerprint !== current.value) {
+    const diff = ["jieba", "userDict", "contract"].filter((k) => recorded.parts?.[k] !== current.parts[k]).map((k) => `${k}: ${String(recorded.parts?.[k])} \u2192 ${String(current.parts[k])}`).join("; ");
+    return { requiresReindex: true, reason: `\u6307\u7EB9\u4E0D\u4E00\u81F4\uFF08${diff}\uFF09`, current, recorded };
+  }
+  return { requiresReindex: false, reason: "\u6307\u7EB9\u4E00\u81F4", current, recorded };
+}
+
+// src/lib/memory-fts-runtime.ts
+import { existsSync as existsSync19, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync2, writeFileSync as writeFileSync10 } from "fs";
+import { createRequire as createRequire2 } from "module";
 import { tmpdir } from "os";
-import { isAbsolute, join as join11, resolve as resolve13 } from "path";
-var requireBuiltin = createRequire(import.meta.url);
+import { isAbsolute, join as join14, resolve as resolve13 } from "path";
+var requireBuiltin = createRequire2(import.meta.url);
 function loadNodeSqlite() {
   return requireBuiltin("node:sqlite");
 }
@@ -3126,7 +3454,7 @@ function sqlitePathCandidates(databaseUrl, projectRoot) {
 }
 function createSqliteAdapter(opts) {
   const candidates = opts.dbPath ? [opts.dbPath] : sqlitePathCandidates(opts.databaseUrl, opts.projectRoot);
-  const dbPath = candidates.find((p) => existsSync17(p));
+  const dbPath = candidates.find((p) => existsSync19(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) {
@@ -3168,8 +3496,8 @@ function createSqliteAdapter(opts) {
 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 (!existsSync19(p)) continue;
+    const m = readFileSync16(p, "utf-8").match(/datasource\s+\w+\s*\{[\s\S]*?provider\s*=\s*"([^"]+)"/);
     if (m) return m[1];
   }
   return null;
@@ -3184,8 +3512,8 @@ 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 (!existsSync19(p)) continue;
+    const m = readFileSync16(p, "utf-8").match(/^\s*DATABASE_URL\s*=\s*["']?([^"'\n]+)["']?\s*$/m);
     if (m) return m[1].trim();
   }
   return null;
@@ -3197,9 +3525,9 @@ function createPrismaCliAdapter(opts) {
   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");
+    const dir = mkdtempSync(join14(tmpdir(), "add-coder-fts-"));
+    const file = join14(dir, `${tag}.sql`);
+    writeFileSync10(file, sql, "utf-8");
     try {
       const r = run([...base, "db", "execute", "--file", file], opts.projectRoot);
       return { status: r.status, stderr: r.stderr ?? "" };
@@ -3272,6 +3600,18 @@ 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`);
+  try {
+    const projectRoot = process.cwd();
+    const check = checkFtsFingerprint(projectRoot, resolveMagicDir(projectRoot));
+    if (check.requiresReindex) {
+      io.log(`  \u26A0\uFE0F \u68C0\u7D22\u6307\u7EB9\uFF1A\u9700\u91CD\u7D22\u5F15 \u2014\u2014 ${check.reason}`);
+      io.log("     \u2192 \u5904\u7F6E\uFF1Aadd-coder memory:reindex --apply \u540E\u7531\u56DE\u586B\u811A\u672C\u91CD\u7B97 searchText\uFF08\u6307\u7EB9\u968F\u91CD\u5EFA\u5199\u5165\uFF09");
+    } else {
+      io.log(`  \u2705 \u68C0\u7D22\u6307\u7EB9\u4E00\u81F4\uFF08${check.current.value}\uFF09`);
+    }
+  } catch (error) {
+    io.log(`  \u26A0\uFE0F \u68C0\u7D22\u6307\u7EB9\uFF1A\u65E0\u6CD5\u5224\u5B9A\uFF08${error instanceof Error ? error.message : String(error)}\uFF09`);
+  }
   if (mode === "apply" && report.rebuilt.length > 0) {
     io.log(`  \u672C\u6B21\u91CD\u5EFA\uFF08${report.rebuilt.length}\uFF09\uFF1A${report.rebuilt.join(", ")}`);
   }
@@ -3293,8 +3633,19 @@ async function memoryReindexCommand(options, deps = {}) {
   try {
     const adapter = resolveAdapter3(projectRoot, options, deps);
     const report = mode === "apply" ? await reindexVia(adapter) : await probeVia(adapter);
+    let fingerprintNote = null;
+    if (mode === "apply" && report.missing.length === 0) {
+      try {
+        const magicDir = resolveMagicDir(projectRoot);
+        const path = writeRecordedFingerprint(projectRoot, magicDir, computeFtsFingerprint({ projectRoot, magicDir }));
+        fingerprintNote = `  \u68C0\u7D22\u6307\u7EB9\uFF1A\u5DF2\u8BB0\u5F55\uFF08${path}\uFF09`;
+      } catch (e) {
+        fingerprintNote = `  \u26A0\uFE0F \u68C0\u7D22\u6307\u7EB9\u5199\u5165\u5931\u8D25\uFF1A${e instanceof Error ? e.message : String(e)}\uFF08\u4E0B\u6B21 probe \u4ECD\u4F1A\u63D0\u793A\u9700\u91CD\u7D22\u5F15\uFF09`;
+      }
+    }
     if (options.json) io.log(JSON.stringify(report, null, 2));
     else printReport(report, mode, io);
+    if (fingerprintNote && !options.json) io.log(fingerprintNote);
     if (mode === "probe") return 0;
     return report.missing.length > 0 ? 1 : 0;
   } catch (e) {
@@ -3309,7 +3660,7 @@ async function memoryReindexCommand(options, deps = {}) {
 
 // src/cli/index.ts
 var { version } = JSON.parse(
-  readFileSync14(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync17(new URL("../package.json", import.meta.url), "utf-8")
 );
 async function modelDownloadCommand(options) {
   try {