add-coder 0.3.37 → 0.3.38

package/README.en.md

@@ -301,8 +301,22 @@ npx add-coder init
 | Plan | Description |
 |------|-------------|
 | Demo Repo | A full example repository showcasing end-to-end closed-loop practice of Policy-Update-Loop and the Report system |
-| MCP Restructure | MCP toolchain architecture upgrade, improving audit and gateway tool extensibility and standalone deployment capability |
-| Memory Enhancement | ✅ **Delivered in v0.3.35**: idempotent evidence collection + deterministic waypoint recall + hybrid FTS×vector recall (RRF fusion + governed rerank) + Handoff Digest candidates + a ranking calibration foundation; defaults to `shadow` mode (recall runs and is audited, not injected yet) |
+| ~~MCP Restructure~~ | ✅ v0.2.9 MCP toolchain architecture upgrade, improving audit and gateway tool extensibility and standalone deployment capability |
+| ~~Memory Enhancement~~ | ✅ **v0.3.35→v0.3.37 Governance memory**: idempotent evidence collection + deterministic waypoint recall + hybrid FTS×vector recall (RRF fusion + governed rerank) + Handoff Digest candidates + a ranking calibration foundation; native layer (SQLite FTS5 tables + triggers) auto-applied by `init`/`db-ensure` with `memory:reindex` self-heal; defaults to `shadow` mode (recall runs and is audited, not injected yet) |
+
+---
+
+## 🙏 Acknowledgements
+
+A paradigm is worth what people make of it — including the problems they find in it. The **contributor wall** lives in **[CONTRIBUTING.md §贡献者墙](./CONTRIBUTING.md#-贡献者墙)**; the item-by-item detail (in Chinese) lives in **[docs/ACKNOWLEDGEMENTS.md](./docs/ACKNOWLEDGEMENTS.md)**.
+
+| Contributor | Contribution | What it left behind |
+|-------------|--------------|---------------------|
+| [@iopzhu](https://github.com/iopzhu) | Memory rotation on the `memory_cache` branch (`357b215`, 48 files / +5877 −33) | The retrieval and tooling backbone of the memory loop: `retrieval/pipeline`, RRF fusion, governed rerank, dual FTS channels, evidence/snapshot jobs, `tools/memory.ts` (609 lines) plus a 909-line recall evaluation set |
+| [@Milkycoffees](https://github.com/Milkycoffees) | Ecosystem work: [`add-coder-flash`](https://www.npmjs.com/package/add-coder-flash) (npm `1.0.4`, 5 releases, plus a [public GitHub repo](https://github.com/Milkycoffees/add-coder-flash)) | A zero-dependency lightweight distribution: pure-`.mjs` hooks, no database required, assets laid down by `npm install`; auto-generates `.qoder-cn/mcp.json` and fed real constraints back (QoderCN config location, pnpm `allowBuilds`, MCP name length) |
+| [@albertm88](https://github.com/albertm88) | Relentless issue reporting (#5–#7, #10–#20 — 14 issues, all closed) | Cross-session memory, 429 storms, Windows stability, native Codex adaptation, port drift, non-interactive hangs, first-run HITL approval… walking the edge cases so nobody else has to |
+
+> Want on the wall? The criteria live in [CONTRIBUTING.md §贡献者墙](./CONTRIBUTING.md#-贡献者墙) — file an [issue](https://github.com/xiaomingming92/add-coder/issues) (reproducible problems, real logs, platform differences) or open a [PR](https://github.com/xiaomingming92/add-coder/pulls); both count as hard contribution.
 
 ---
 <details id="chinese-readme">

package/README.md

@@ -499,10 +499,10 @@ Tasks (实验性)     双向              ✅ 已实现      长任务持久化
 | 计划 | 说明 |备注|
 |------|------|------|
 | Demo 仓库演示 | 提供完整示例仓库，展示 Policy-Update-Loop 与 Report 体系的端到端闭环实践 |--|
-| MCP 能力重构 | ✅ v0.2.9 MCP 工具链架构升级，提升审计与门禁工具的可扩展性和独立部署能力 | 2026-07/23/add-coder-mcp-restructure-plan-v1.md |
-| Hook 通知升级 | ✅ v0.2.9 Hook 拦截事件 jsonl → fs.watch → record_dev_operation 落库 + Notification + 治理信号 | 2026-07/24/add-coder-hook-notify-upgrade-plan-v1.md |
+| ~~MCP 能力重构~~ | ✅ v0.2.9 MCP 工具链架构升级，提升审计与门禁工具的可扩展性和独立部署能力 | 2026-07/23/add-coder-mcp-restructure-plan-v1.md |
+| ~~Hook 通知升级~~ | ✅ v0.2.9 Hook 拦截事件 jsonl → fs.watch → record_dev_operation 落库 + Notification + 治理信号 | 2026-07/24/add-coder-hook-notify-upgrade-plan-v1.md |
 | ide插件 | 解耦ADD范式代码和被治理项目的代码 |在做了,大家拭目以待吧,让编程更有趣,我的目标其实不在于IDE,我的工作顺手的事情 |
-| 对话记忆增强 | ✅ **v0.3.35 记忆闭环落地**：幂等采证 + 位点确定性召回 + FTS×向量混合召回（RRF 融合 + 治理重排）+ Handoff Digest 候选 + 排序权重校准基座；默认 `shadow` 模式（召回照跑照审计、暂不注入） | 门槛未下调：Hybrid MRR@5 0.4867 < 0.75，由校准线程以数据逼近 |
+| ~~对话记忆增强~~ | ✅ **v0.3.35→v0.3.37 记忆闭环落地**：幂等采证 + 位点确定性召回 + FTS×向量混合召回（RRF 融合 + 治理重排）+ Handoff Digest 候选 + 排序权重校准基座；默认 `shadow` 模式（召回照跑照审计、暂不注入）；v0.3.37 起原生层（SQLite FTS5 虚表 + 触发器）由 init/db-ensure 自动应用，`memory:reindex` 自助修复 | 门槛未下调：Hybrid MRR@5 0.4867 < 0.75，由校准线程以数据逼近 |
 
 ---
 
@@ -970,10 +970,24 @@ npx add-coder stack --clear       # clear tech-stack setting (neutral)
 | Demo Repo | Full example repository showcasing Policy-Update-Loop with Report system end-to-end | 📋 |
 | ~~MCP Restructure~~ | ✅ v0.2.9 3,467-line monolith → 27 modules covering all six MCP primitives | 2026-07/23/... |
 | ~~Hook Notification Upgrade~~ | ✅ v0.2.9 ~36 files: hook intercept → jsonl → fs.watch → record_dev_operation | 2026-07/24/... |
-| Memory Enhancement | Long-term project knowledge memory and plan-level sparse memory | 📋 |
+| ~~Memory Enhancement~~ | ✅ v0.3.35→v0.3.37 **Governance memory**: idempotent evidence collection + deterministic waypoint recall + hybrid FTS×vector recall (RRF fusion + governed rerank) + Handoff Digest candidates + ranking-calibration foundation; SQLite FTS5 native layer auto-applied by `init`/`db-ensure` + `memory:reindex` self-heal; defaults to `shadow` mode | 2026-09/15/... |
 
 ---
 
 My hometown 
 
 <img width="720"  alt="hometown outside" src="https://github.com/user-attachments/assets/7aad93de-9cea-4194-b09d-cbd892d61cc2" />
+
+---
+
+## 🙏 致谢 / Acknowledgements
+
+范式的价值来自把它用出问题的人。**贡献者墙**见 **[CONTRIBUTING.md §贡献者墙](./CONTRIBUTING.md#-贡献者墙)**，逐项明细与证据见 **[docs/ACKNOWLEDGEMENTS.md](./docs/ACKNOWLEDGEMENTS.md)**。
+
+| 贡献者 | 贡献形态 | 留下了什么 |
+|--------|---------|-----------|
+| [@iopzhu](https://github.com/iopzhu) | 记忆轮动（`memory_cache` 分支 `357b215`，48 文件 / +5877 −33） | 记忆闭环的检索层与工具层主体：`retrieval/pipeline`、RRF 融合、治理重排、FTS 双通道、采证与快照作业、`tools/memory.ts`（609 行）+ 评测标注集（909 行） |
+| [@Milkycoffees](https://github.com/Milkycoffees) | 生态贡献：[`add-coder-flash`](https://www.npmjs.com/package/add-coder-flash)（npm `1.0.4` / 5 个版本 + [GitHub 开源](https://github.com/Milkycoffees/add-coder-flash)） | 零依赖轻量发行版：hooks 纯 `.mjs`、不需要数据库，`npm install` 即铺设；自动生成 `.qoder-cn/mcp.json`，并回吐 QoderCN 加载位置、pnpm `allowBuilds`、MCP 名长度等真实约束 |
+| [@albertm88](https://github.com/albertm88) | 持续输出 issue（#5–#7、#10–#20，14 条全部闭环） | 跨会话记忆、429 并发、Windows 稳定性、Codex 原生适配、端口漂移、非交互挂起、HITL 首次审批……把边界条件替所有人先踩了一遍 |
+
+> 想上墙？上榜标准在 [CONTRIBUTING.md §贡献者墙](./CONTRIBUTING.md#-贡献者墙)——提 [Issue](https://github.com/xiaomingming92/add-coder/issues)（可复现的问题、实测日志、平台差异）或 [PR](https://github.com/xiaomingming92/add-coder/pulls) 都算硬贡献。

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);
     });
   });
 }
@@ -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}`);
@@ -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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-coder",
-  "version": "0.3.37",
+  "version": "0.3.38",
   "private": false,
   "description": "[codein2027](https://github.com/xiaomingming92/codein2027) - A complete scaffolding for building the ADD programming paradigm, the implementation layer for AI code governance. Core principle: Audit as Infrastructure. Breaks the black-box programming process and cross-session amnesia, evolving programming paradigms into an auditable, traceable, and convergent new era. npx-ready.\n\n[codein2027](https://github.com/xiaomingming92/codein2027) 快速构建 ADD 编程范式的完整脚手架——AI 代码治理的落地方案。以「审计即基础设施」为核心，彻底打破编程过程黑盒与跨轮失忆，让编程范式进化为可审计、可追溯、可收敛的新时代。npx 即用，人人可体验。",
   "repository": {
@@ -112,9 +112,13 @@
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
     "generate": "tsx src/caijuehub/transcribe/index.ts",
+    "contributors": "tsx scripts/gen-contributors.ts --write",
+    "contributors:check": "tsx scripts/gen-contributors.ts --check",
+    "contributors:audit": "tsx scripts/gen-contributors.ts --check --audit",
     "podman-add-coder-up": "podman-compose --env-file .env.development -f podman-compose.add.yml up -d",
     "podman-add-coder-down": "podman-compose --env-file .env.development -f podman-compose.add.yml down",
     "test": "vitest run",
-    "generate:check": "tsx scripts/generate-idempotency-check.ts"
+    "generate:check": "tsx scripts/generate-idempotency-check.ts",
+    "release:preflight": "tsx scripts/release-preflight.ts"
   }
 }

package/templates/.add-coder-src-hash.json

@@ -1,5 +1,5 @@
 {
-  "_version": "0.3.37",
+  "_version": "0.3.38",
   "adapters/claude/hooks/doc-format-guard.mjs": "b21350a0",
   "adapters/claude/hooks/doc-format-guard.ts": "2abf8013",
   "adapters/claude/hooks/lib/claude-env.ts": "170b40ca",
@@ -229,7 +229,7 @@
   "core/rules/profiles/webapp-profile.md": "e493ae7b",
   "core/rules/project_rules.md": "094821ad",
   "core/rules/theory-practice-map.toml": "b1db99fd",
-  "core/scripts/db-ensure.sh": "8f7ba569",
+  "core/scripts/db-ensure.sh": "d46a43c1",
   "core/scripts/gen-plan-index.sh": "47836bec",
   "core/scripts/mcp-server/elicitation/confirm.ts": "924857b8",
   "core/scripts/mcp-server/elicitation/index.ts": "44c5dc3f",
@@ -280,7 +280,7 @@
   "core/scripts/mcp-server/shared/memory/metrics/stage-words.ts": "a81db64b",
   "core/scripts/mcp-server/shared/memory/retrieval/context-builder.ts": "ea83c131",
   "core/scripts/mcp-server/shared/memory/retrieval/fts/pg.ts": "1275eef4",
-  "core/scripts/mcp-server/shared/memory/retrieval/fts/sqlite-fts5.sql": "8fade96f",
+  "core/scripts/mcp-server/shared/memory/retrieval/fts/sqlite-fts5.sql": "1a439c1a",
   "core/scripts/mcp-server/shared/memory/retrieval/fts/sqlite.ts": "09a6cf59",
   "core/scripts/mcp-server/shared/memory/retrieval/fusion.ts": "c3aa6a4f",
   "core/scripts/mcp-server/shared/memory/retrieval/pipeline.ts": "dbe4a472",
@@ -323,8 +323,8 @@
   "core/scripts/mcp-server/tools/gateway/check_add_route_status.ts": "4caf552c",
   "core/scripts/mcp-server/tools/gateway/check_doc_similarity.ts": "2cba51c5",
   "core/scripts/mcp-server/tools/gateway/check_dps.ts": "f52ef32c",
-  "core/scripts/mcp-server/tools/gateway/check_rahs.ts": "88d2c549",
-  "core/scripts/mcp-server/tools/gateway/check_spec_sync.ts": "75c0d1e3",
+  "core/scripts/mcp-server/tools/gateway/check_rahs.ts": "a786744d",
+  "core/scripts/mcp-server/tools/gateway/check_spec_sync.ts": "adad0b31",
   "core/scripts/mcp-server/tools/gateway/helpers.ts": "f8794a92",
   "core/scripts/mcp-server/tools/gateway/index.ts": "cffe9783",
   "core/scripts/mcp-server/tools/gateway.backup": "65eae393",

package/templates/core/scripts/db-ensure.sh

@@ -37,8 +37,24 @@ EOF
   echo ">>> 已创建 .env.development"
 fi
 
-# ── SQLite：无需容器 ──
-if [ "$ENGINE" = "sqlite" ]; then exit 0; fi
+# ── SQLite：无需容器；但 FTS5 原生层不在 Prisma schema 内，必须显式应用期望态 ──
+#   背景（Plan add-coder-sqlite-memory-flow §3.2）：`prisma db push` 只建 Prisma 表，
+#   `add_memory_fts` 虚表 + 3 个同步触发器是原生 DDL → 此前 sqlite 项目 recall_memory 直接
+#   `no such table`。此处与 init.ts（src/lib/memory-expected-state.ts）消费**同一份** SQL 真源。
+#   失败语义：仅告警不阻断（exit 0 语义不变）——记忆检索是能力项，不该让环境准备硬失败。
+if [ "$ENGINE" = "sqlite" ]; then
+  MAGIC_DIR="${MAGIC_DIR:-.codex}"
+  FTS_SQL="$MAGIC_DIR/scripts/mcp-server/shared/memory/retrieval/fts/sqlite-fts5.sql"
+  if [ -f "$PROJECT_DIR/$FTS_SQL" ]; then
+    echo ">>> 应用记忆 FTS5 期望态（$FTS_SQL）..."
+    # Prisma 7：db execute 的 datasource 由项目 prisma.config.ts 提供，`--schema` 已移除（带=unknown option）
+    (cd "$PROJECT_DIR" && npm exec prisma -- db execute --file "$PROJECT_DIR/$FTS_SQL") \
+      || echo "!!! 记忆 FTS5 期望态应用失败（不阻断）：recall_memory 将按 fts-only 降级；修复入口 add-coder memory:reindex --apply"
+  else
+    echo ">>> 未找到 $FTS_SQL（跳过，不阻断）——请先执行 add-coder sync"
+  fi
+  exit 0
+fi
 
 # ── 自行管理 PostgreSQL ──
 if [ "$CONTAINER" = "none" ] || [ "$CONTAINER" = "manual" ]; then

package/templates/core/scripts/mcp-server/shared/memory/retrieval/fts/sqlite-fts5.sql

@@ -1,3 +1,6 @@
+-- 本文件由 scripts/memory/gen-sqlite-fts-sql.ts 生成（真源：src/lib/memory-fts-objects.ts 的 SQLITE_FTS_OBJECTS）
+-- 请勿手工编辑；新增/修改 DDL 请改真源后重跑生成脚本。
+--
 -- Agent Memory FTS 原生层（SQLite 后端）
 -- Plan §8.3 + §17-3 定案：FTS5 trigram 分词器（CJK 友好，≥3 字符 n-gram 匹配；
 -- 短于 3 字符的查询由 adapter 层回退 LIKE —— 见 retrieval/fts/sqlite.ts）
@@ -6,24 +9,10 @@
 -- （其要求 INTEGER rowid），故采用独立 FTS 表 + 触发器同步。
 -- 幂等：全部 IF NOT EXISTS，可重复应用。
 
-CREATE VIRTUAL TABLE IF NOT EXISTS add_memory_fts USING fts5(
-  memory_id UNINDEXED,
-  topic,
-  content,
-  tokenize = 'trigram'
-);
+CREATE VIRTUAL TABLE IF NOT EXISTS add_memory_fts USING fts5(memory_id UNINDEXED, topic, content, tokenize = 'trigram');
 
-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;
+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;
 
-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;
+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;
 
-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;
+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;

package/templates/core/scripts/mcp-server/tools/gateway/check_rahs.ts

@@ -154,7 +154,8 @@ export function registerCheckRahs(server: ToolRegistrar) {
               arContent.match(/`[^`]+\.(ts|js|sh|md|tsx|json|yml|yaml)`/g) ||
               []
             ).map((f: string) => f.replace(/`/g, "").toLowerCase());
-            const diff = runCommand("git", ["diff", "--name-only"], {
+            // core.quotepath=false：避免非 ASCII 路径被八进制转义后与附录清单比不中（与 check_spec_sync 同修）
+            const diff = runCommand("git", ["-c", "core.quotepath=false", "diff", "--name-only"], {
               cwd: PROJECT_ROOT,
               timeout: 5000,
             });

package/templates/core/scripts/mcp-server/tools/gateway/check_spec_sync.ts

@@ -77,14 +77,18 @@ export function registerCheckSpecSync(server: ToolRegistrar) {
           lines.push(`add-route: ${arFile}`);
           const arContent = (await readFileSafe(join(plansDir, arFile))) || "";
           // 提取 add-route 附录文件清单（toml 纳入：sync-magic-rules.toml 等控制面文件，2026-08-18 修复）
-          const appendixFiles = (arContent.match(/`[^`]+\.(ts|js|sh|md|tsx|json|yml|yaml|toml)`/g) || [])
+          // sql/prisma 纳入（2026-09-16 修复）：原生 DDL 与 schema 是常见交付物，此前不在白名单 →
+          // 附录里明明登记了 `.../sqlite-fts5.sql` 仍被判"不在附录中"（假告警）。
+          const appendixFiles = (arContent.match(/`[^`]+\.(ts|tsx|js|jsx|sh|sql|prisma|md|json|yml|yaml|toml)`/g) || [])
             .map((f: string) => f.replace(/`/g, ""));
           lines.push(`附录文件: ${appendixFiles.length} 个`);
 
           // git diff 变更文件（win32 下 git 为 .cmd → runCommand 自动解析，issue #10 跨端修复）
           let diffFiles: string[] = [];
           try {
-            const diff = runCommand("git", ["diff", "--name-only"], {
+            // core.quotepath=false：默认 git 会把非 ASCII 路径转成 "\346\236..." 八进制转义 →
+            // 与附录里的真实中文路径永远比不中（2026-09-16 修复：架构文档类路径的假告警）。
+            const diff = runCommand("git", ["-c", "core.quotepath=false", "diff", "--name-only"], {
               cwd: PROJECT_ROOT,
               timeout: 5000,
             });