add-coder 0.3.18 → 0.3.20-0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { Command } from "commander";
 
 // src/caijuehub/strategies/detect.strategy.ts
@@ -184,7 +184,7 @@ async function selectFiles(projectRoot, files) {
     process.stdout.write(renderList(items, selected, scrollIdx, VISIBLE));
   }
   draw();
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     input.on("keypress", (_char, key) => {
       if (!key) return;
       if (key.name === "up") {
@@ -225,7 +225,7 @@ async function selectFiles(projectRoot, files) {
         if (selected.has(idx)) result.set(relPath, content);
         idx++;
       }
-      resolve9(result);
+      resolve10(result);
     });
   });
 }
@@ -331,13 +331,34 @@ async function writeFiles2(projectRoot, files, options = {}) {
 }
 function parseSchemaBlocks(content) {
   const blocks = /* @__PURE__ */ new Map();
-  const blockRegex = /^(model|enum)\s+(\w+)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const [, type, name, inner] = match;
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const head = lines[i].match(/^(model|enum)\s+(\w+)\s*\{/);
+    if (!head) {
+      i++;
+      continue;
+    }
+    const type = head[1];
+    const name = head[2];
+    const bodyLines = [lines[i]];
+    let depth = 1;
+    let j = i + 1;
+    while (j < lines.length && depth > 0) {
+      const line = lines[j];
+      bodyLines.push(line);
+      const commentless = line.split("//")[0];
+      for (const ch of commentless) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+      }
+      j++;
+    }
+    const body = bodyLines.join("\n");
+    const inner = bodyLines.slice(1, -1).join("\n");
     let fields = [];
     if (type === "enum") {
-      fields = inner.split("\n").map((l) => l.replace(/#.*$/, "").trim()).filter((l) => l.length > 0);
+      fields = inner.split("\n").map((l) => l.replace(/\/\/.*$/, "").replace(/#.*$/, "").trim()).filter((l) => l.length > 0);
     } else {
       const fieldRegex = /^\s*(\w+)\s+(\w+(?:\([^)]*\))?(?:\[\])?\??)/gm;
       let fm;
@@ -345,7 +366,8 @@ function parseSchemaBlocks(content) {
         fields.push(`${fm[1]}:${fm[2]}`);
       }
     }
-    blocks.set(`${type}:${name}`, { type, name, body: match[0], fields });
+    blocks.set(`${type}:${name}`, { type, name, body, fields });
+    i = j;
   }
   return blocks;
 }
@@ -627,9 +649,38 @@ import { resolve as resolve4, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/caijuehub/strategies/prisma.strategy.ts
-import { spawnSync } from "child_process";
 import { copyFileSync, existsSync as existsSync7, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
 import { resolve as resolve3 } from "path";
+
+// src/lib/run-command.ts
+import { spawnSync } from "child_process";
+var CMD_EXTENSIONS = ["npm", "npx", "pnpm", "git"];
+function runCommand(cmd, args, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const needsCmdExt = platform === "win32" && CMD_EXTENSIONS.includes(cmd) && !opts.shell;
+  const effectiveCmd = needsCmdExt ? `${cmd}.cmd` : cmd;
+  const r = spawnSync(effectiveCmd, args, {
+    cwd: opts.cwd,
+    env: opts.env,
+    input: opts.input,
+    timeout: opts.timeout,
+    encoding: "utf-8",
+    shell: opts.shell,
+    stdio: opts.stdio ?? (opts.input !== void 0 ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"])
+  });
+  if (r.error) {
+    throw new Error(`\u547D\u4EE4\u4E0D\u53EF\u7528: ${cmd}\uFF08\u5E73\u53F0: ${platform}\uFF0C${r.error.message}\uFF09`);
+  }
+  return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+}
+function commandExists(cmd, platform) {
+  const p = platform ?? process.platform;
+  const probe = p === "win32" ? "where" : "which";
+  const r = spawnSync(probe, [cmd], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+  return !r.error && r.status === 0;
+}
+
+// src/caijuehub/strategies/prisma.strategy.ts
 var PRISMA_CONFIG = {
   onMissing: "ask",
   onExistingAddPrisma: "ask",
@@ -657,12 +708,10 @@ function ensurePrismaConfig(projectRoot) {
   ].join("\n") + "\n", "utf-8");
 }
 function backupAddTables(projectRoot) {
-  const pgDump = spawnSync("which", ["pg_dump"], { timeout: 2e3 });
-  if (pgDump.status !== 0) return null;
+  if (!commandExists("pg_dump")) return null;
   const bak = resolve3(projectRoot, `add-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}.sql`);
-  const r = spawnSync("pg_dump", ["--table=AddUser", "--table=DevOperation", "--table=AuditLog", "--if-exists"], {
+  const r = runCommand("pg_dump", ["--table=AddUser", "--table=DevOperation", "--table=AuditLog", "--if-exists"], {
     cwd: projectRoot,
-    stdio: ["ignore", "pipe", "pipe"],
     timeout: 3e4
   });
   if (r.stdout.length > 0) {
@@ -673,16 +722,18 @@ function backupAddTables(projectRoot) {
   return null;
 }
 function runPrismaInit(projectRoot, provider, schemaPath) {
-  console.log("\u6267\u884C npx prisma init ...");
+  console.log("\u6267\u884C prisma init ...");
   const pm = detectPm(projectRoot);
-  const initArgs = pm === "pnpm" ? ["dlx", "prisma", "init", "--datasource-provider", provider] : ["prisma", "init", "--datasource-provider", provider];
-  const initResult = spawnSync(pm, initArgs, {
-    cwd: projectRoot,
-    stdio: "inherit",
-    shell: false
-  });
+  const initArgs = pm === "pnpm" ? ["dlx", "prisma", "init", "--datasource-provider", provider] : ["exec", "prisma", "--", "init", "--datasource-provider", provider];
+  let initResult;
+  try {
+    initResult = runCommand(pm, initArgs, { cwd: projectRoot });
+  } catch (e) {
+    console.error(`\u2717 prisma init \u65E0\u6CD5\u6267\u884C: ${e instanceof Error ? e.message : String(e)}`);
+    initResult = { status: null, stdout: "", stderr: "" };
+  }
   if (initResult.status !== 0 || !existsSync7(schemaPath)) {
-    console.log("prisma init \u5931\u8D25\uFF0C\u624B\u52A8\u521B\u5EFA schema.prisma ...");
+    console.error(`\u26A0\uFE0F prisma init \u672A\u5B8C\u6210\uFF08\u9000\u51FA\u7801: ${initResult.status}\uFF09\uFF0C\u56DE\u9000\u624B\u52A8\u521B\u5EFA schema.prisma\u2014\u2014db push \u5C06\u9A8C\u8BC1\u5176\u53EF\u7528\u6027`);
     const prismaDir = resolve3(projectRoot, "prisma");
     if (!existsSync7(prismaDir)) mkdirSync3(prismaDir, { recursive: true });
     const content = `generator client {
@@ -722,6 +773,28 @@ function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
   }
   copyFileSync(addPrismaTemplate, destPath);
   console.log("\u5DF2\u590D\u5236 add.prisma");
+  patchGeneratorOutput(schemaPath);
+}
+function patchGeneratorOutput(schemaPath) {
+  if (!existsSync7(schemaPath)) return;
+  let content = readFileSync5(schemaPath, "utf-8");
+  const genBlock = content.match(/generator\s+\w+\s*\{[\s\S]*?\}/);
+  if (!genBlock) {
+    content += `
+generator client {
+  provider = "prisma-client-js"
+  output = "../src/generated/prisma"
+}
+`;
+    writeFileSync3(schemaPath, content, "utf-8");
+    console.log("\u5DF2\u8FFD\u52A0 generator client\uFF08\u542B output \u2192 src/generated/prisma\uFF09");
+    return;
+  }
+  if (genBlock[0].includes("output")) return;
+  const patched = genBlock[0].replace(/\}\s*$/, `  output = "../src/generated/prisma"
+}`);
+  writeFileSync3(schemaPath, content.replace(genBlock[0], patched), "utf-8");
+  console.log("\u5DF2\u6CE8\u5165 generator output \u2192 src/generated/prisma");
 }
 async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
   const C = PRISMA_CONFIG;
@@ -786,10 +859,10 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     ensurePrismaConfig(projectRoot);
     backupAddTables(projectRoot);
     const pm = detectPm(projectRoot);
-    const args = pm === "pnpm" ? ["dlx", "prisma", "db", "push"] : ["prisma", "db", "push"];
+    const args = pm === "pnpm" ? ["dlx", "prisma", "db", "push"] : ["exec", "prisma", "--", "db", "push"];
     if (C.schemaArg) args.push(C.schemaArg);
     console.log(`\u6267\u884C ${pm} ${args.join(" ")} ...`);
-    const r = spawnSync(pm, args, { cwd: projectRoot, stdio: "inherit", shell: false });
+    const r = runCommand(pm, args, { cwd: projectRoot });
     if (r.status !== 0) throw new Error(`prisma db push \u9000\u51FA\u7801: ${r.status}`);
   } catch (err) {
     if (C.onMigrateFail === "keep") {
@@ -805,8 +878,14 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
   }
   if (C.autoGenerate) {
     const pm = detectPm(projectRoot);
+    const genArgs = pm === "pnpm" ? ["dlx", "prisma", "generate"] : ["exec", "prisma", "--", "generate"];
     console.log("\u6267\u884C prisma generate ...");
-    spawnSync(pm, pm === "pnpm" ? ["dlx", "prisma", "generate"] : ["prisma", "generate"], { cwd: projectRoot, stdio: "inherit", shell: false });
+    const g = runCommand(pm, genArgs, { cwd: projectRoot });
+    if (g.status !== 0) {
+      const detail = g.stderr.trim().split("\n").slice(0, 5).join("\n");
+      throw new Error(`prisma generate \u9000\u51FA\u7801: ${g.status}${detail ? `
+${detail}` : ""}`);
+    }
   }
   console.log("ADD \u6CBB\u7406\u6A21\u578B\u5DF2\u5C31\u7EEA");
   return true;
@@ -821,11 +900,88 @@ async function injectPrisma2(projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
 import { createHash } from "crypto";
-import { resolve as resolve5 } from "path";
-import { spawnSync as spawnSync2 } from "child_process";
+import { resolve as resolve6 } from "path";
 import { createConnection } from "net";
+
+// src/lib/model-predownload.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join5, resolve as resolve5 } from "path";
+import { homedir } from "os";
+import { parse as parse2 } from "smol-toml";
+var DEFAULT_DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+var TOML_CANDIDATES = [
+  resolve5(import.meta.dirname, "caijuehub/dps-scoring-rules.toml"),
+  resolve5(import.meta.dirname, "../caijuehub/dps-scoring-rules.toml")
+];
+function resolveEmbeddingModel() {
+  const tomlPath = TOML_CANDIDATES.find((p) => existsSync8(p));
+  if (!tomlPath) {
+    throw new Error(
+      `dps-scoring-rules.toml \u672A\u627E\u5230\uFF08\u671F\u671B\u8DEF\u5F84: ${TOML_CANDIDATES.join(" \u6216 ")}\uFF09`
+    );
+  }
+  const cfg = parse2(readFileSync6(tomlPath, "utf-8"));
+  const model = cfg.embedding?.model;
+  if (typeof model !== "string" || model.length === 0) {
+    throw new Error(`dps-scoring-rules.toml [embedding] model \u672A\u914D\u7F6E\uFF08${tomlPath}\uFF09`);
+  }
+  return model;
+}
+function resolveCacheDir() {
+  const hubCache = process.env.HF_HUB_CACHE;
+  if (hubCache) return hubCache;
+  const home = process.env.HF_HOME || join5(homedir(), ".cache", "huggingface");
+  return join5(home, "hub");
+}
+function modelCacheName(model) {
+  const parts = model.split("/");
+  const org = parts.length > 1 ? parts[0] : "models";
+  const name = parts[parts.length - 1];
+  return `models--${org}--${name}`;
+}
+function isModelCached(model) {
+  const cacheDir = resolveCacheDir();
+  return existsSync8(join5(cacheDir, modelCacheName(model), "snapshots"));
+}
+async function ensureEmbeddingModel(options) {
+  const force = options?.force ?? false;
+  const skip = options?.skip ?? false;
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
+  if (skip) {
+    return { status: "skipped", model: "", cacheDir: "" };
+  }
+  const model = resolveEmbeddingModel();
+  const { pipeline, env } = await import("@huggingface/transformers");
+  env.cacheDir = resolveCacheDir();
+  const cacheDir = env.cacheDir;
+  const snapshotsDir = join5(cacheDir, modelCacheName(model), "snapshots");
+  if (!force && existsSync8(snapshotsDir)) {
+    return { status: "already-cached", model, cacheDir };
+  }
+  env.remoteHost = "https://hf-mirror.com";
+  env.remotePathTemplate = "{model}/resolve/{revision}/";
+  const run = (async () => {
+    const extractor = await pipeline("feature-extraction", model);
+    await extractor(["\u6D4B\u8BD5"], { pooling: "mean", normalize: true });
+  })();
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`\u6A21\u578B\u4E0B\u8F7D\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09`)),
+      timeoutMs
+    );
+  });
+  try {
+    await Promise.race([run, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  return { status: "downloaded", model, cacheDir };
+}
+
+// src/cli/commands/init.ts
 var ADAPTER_RENDERERS = {
   claude: renderAdapter,
   qoder: renderAdapter2,
@@ -844,9 +1000,17 @@ async function initCommand(options) {
     console.log(`[dry-run] \u5C06\u5199\u5165 ${ctx.magicDir}/stack.json \u2192 ${ctx.stack}`);
   }
   const result = await renderAndWrite(ctx);
-  await deployDatabase(ctx);
+  const dbFail = await deployDatabase(ctx);
   deployDocs(ctx);
-  finalize(ctx, result);
+  finalize(ctx, result, dbFail);
+  if (!options.dryRun) {
+    try {
+      const r = await ensureEmbeddingModel({ skip: options.skipModel });
+      console.log(`\u6A21\u578B\u9884\u4E0B\u8F7D: ${r.status}${r.model ? ` (${r.model})` : ""}`);
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F \u6A21\u578B\u9884\u4E0B\u8F7D\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u4E3B\u6D41\u7A0B\uFF0C\u9996\u6B21 DPS \u8C03\u7528\u4F1A\u81EA\u52A8\u8865\u4E0B\u8F7D\uFF09: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
 }
 async function resolveAdapter(projectRoot, specified) {
   if (specified) {
@@ -901,27 +1065,31 @@ function portInUse(port) {
 }
 function hasPgIsready() {
   try {
-    const containers = spawnSync2("podman", ["ps", "--filter", "publish=5433", "--format", "{{.Names}}"], { timeout: 3e3 });
+    const containers = runCommand("podman", ["ps", "--filter", "publish=5433", "--format", "{{.Names}}"], { timeout: 3e3 });
     const name = containers.stdout.toString().trim().split("\n")[0];
-    if (name && spawnSync2("podman", ["exec", name, "pg_isready", "--version"], { timeout: 2e3 }).status === 0) return true;
+    if (name && runCommand("podman", ["exec", name, "pg_isready", "--version"], { timeout: 2e3 }).status === 0) return true;
   } catch {
   }
-  return spawnSync2("which", ["pg_isready"], { timeout: 2e3 }).status === 0;
+  return commandExists("pg_isready");
 }
 function testPostgresConnection(port, user, password, dbName) {
   if (!hasPgIsready()) {
     console.log("  \u26A0\uFE0F  \u65E0\u6CD5\u9A8C\u8BC1\u51ED\u636E\uFF08\u5BB9\u5668\u672A\u8FD0\u884C\u4E14 pg_isready \u672A\u5B89\u88C5\uFF09\uFF0C\u4FE1\u4EFB\u8F93\u5165");
     return true;
   }
-  const containers = spawnSync2("podman", ["ps", "--filter", "publish=5433", "--format", "{{.Names}}"], { timeout: 3e3 });
-  const containerName = containers.stdout.toString().trim().split("\n")[0];
-  const args = containerName ? ["exec", containerName, "pg_isready", "-U", user, "-d", dbName] : ["-h", "localhost", "-p", port, "-U", user, "-d", dbName];
-  const cmd = containerName ? "podman" : "pg_isready";
-  const r = spawnSync2(cmd, args, {
-    timeout: 5e3,
-    env: containerName ? process.env : { ...process.env, PGPASSWORD: password }
-  });
-  return r.status === 0;
+  try {
+    const containers = runCommand("podman", ["ps", "--filter", "publish=5433", "--format", "{{.Names}}"], { timeout: 3e3 });
+    const containerName = containers.stdout.toString().trim().split("\n")[0];
+    const args = containerName ? ["exec", containerName, "pg_isready", "-U", user, "-d", dbName] : ["-h", "localhost", "-p", port, "-U", user, "-d", dbName];
+    const cmd = containerName ? "podman" : "pg_isready";
+    const r = runCommand(cmd, args, {
+      timeout: 5e3,
+      env: containerName ? void 0 : { ...process.env, PGPASSWORD: password }
+    });
+    return r.status === 0;
+  } catch {
+    return false;
+  }
 }
 async function resolveDbCredentials(force) {
   const d = { user: "admin", password: "change-me-in-production", port: "5433" };
@@ -984,8 +1152,8 @@ networks:
 `;
 }
 function writeSqliteExportScript(projectRoot, dryRun) {
-  const scriptsDir = resolve5(projectRoot, "scripts");
-  const scriptPath = resolve5(scriptsDir, "export-db.ts");
+  const scriptsDir = resolve6(projectRoot, "scripts");
+  const scriptPath = resolve6(scriptsDir, "export-db.ts");
   const content = `import { PrismaClient } from "@prisma/client";
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { resolve } from "path";
@@ -1009,18 +1177,18 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync8(scriptsDir)) mkdirSync4(scriptsDir, { recursive: true });
+  if (!existsSync9(scriptsDir)) mkdirSync4(scriptsDir, { recursive: true });
   writeFileSync4(scriptPath, content, "utf-8");
   console.log("\u5DF2\u751F\u6210 scripts/export-db.ts");
 }
 function injectDbExportScript(projectRoot, dryRun) {
-  const pkgPath = resolve5(projectRoot, "package.json");
-  if (!existsSync8(pkgPath)) return;
+  const pkgPath = resolve6(projectRoot, "package.json");
+  if (!existsSync9(pkgPath)) return;
   if (dryRun) {
     console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
     return;
   }
-  const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
   if (!pkg.scripts) pkg.scripts = {};
   if (!pkg.scripts["db:export"]) {
     pkg.scripts["db:export"] = "npx tsx scripts/export-db.ts";
@@ -1067,15 +1235,15 @@ 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 = resolve5(projectRoot, composeName);
-    if (!options.dryRun && (!existsSync8(composePath) || options.force)) {
+    const composePath = resolve6(projectRoot, composeName);
+    if (!options.dryRun && (!existsSync9(composePath) || options.force)) {
       writeFileSync4(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
-  const devEnvPath = resolve5(projectRoot, ".env.development");
-  if (!options.dryRun && existsSync8(devEnvPath)) {
-    const existing = readFileSync6(devEnvPath, "utf-8");
+  const devEnvPath = resolve6(projectRoot, ".env.development");
+  if (!options.dryRun && existsSync9(devEnvPath)) {
+    const existing = readFileSync7(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
       writeFileSync4(devEnvPath, existing + `
 DATABASE_USER=${db.user || "admin"}
@@ -1114,8 +1282,8 @@ async function renderAndWrite(ctx) {
     console.log(`claude adapter (via Agent Host): ${claudeFiles.size} \u6587\u4EF6`);
   }
   for (const d of [".add", magicDir]) {
-    const reviewsDir = resolve5(projectRoot, d, "reviews");
-    if (!existsSync8(reviewsDir)) {
+    const reviewsDir = resolve6(projectRoot, d, "reviews");
+    if (!existsSync9(reviewsDir)) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
@@ -1127,16 +1295,16 @@ async function renderAndWrite(ctx) {
     const hashMap = {};
     let npmVer = "";
     try {
-      npmVer = JSON.parse(readFileSync6(resolve5(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
+      npmVer = JSON.parse(readFileSync7(resolve6(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 = resolve5(projectRoot, magicDir, ".add-coder-hash.json");
+    const hashOut = resolve6(projectRoot, magicDir, ".add-coder-hash.json");
     writeFileSync4(hashOut, JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
     if (npmVer) {
-      writeFileSync4(resolve5(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
+      writeFileSync4(resolve6(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
     }
     console.log(`hash: ${Object.keys(hashMap).length} entries \u2192 ${magicDir}/.add-coder-hash.json`);
   }
@@ -1144,22 +1312,37 @@ async function renderAndWrite(ctx) {
 }
 async function deployDatabase(ctx) {
   const { projectRoot, options, magicDir, config, db } = ctx;
-  if (options.dryRun) return;
+  if (options.dryRun) return null;
+  let fail = null;
   if (db.engine === "postgresql" && db.container && db.container !== "manual") {
-    const dbScript = resolve5(projectRoot, magicDir, "scripts", "db-ensure.sh");
+    const dbScript = resolve6(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}) ...`);
-    spawnSync2("bash", [dbScript, "postgresql", mode, "--migrate"], { cwd: projectRoot, stdio: "inherit", env: dbEnv });
+    try {
+      const bashRun = runCommand("bash", [dbScript, "postgresql", mode, "--migrate"], { cwd: projectRoot, env: dbEnv, stdio: "inherit" });
+      if (bashRun.status !== 0) fail = `db-ensure.sh \u9000\u51FA\u7801: ${bashRun.status}${bashRun.stderr ? `
+${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
+    } catch (e) {
+      fail = e instanceof Error ? e.message : String(e);
+    }
     try {
       await injectPrisma2(projectRoot, { force: !!options.force });
     } catch (e) {
-      console.log(`Prisma \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+      fail = `Prisma \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`;
     }
   }
   if (db.engine === "postgresql" && db.container === "manual") {
-    const dbScript = resolve5(projectRoot, magicDir, "scripts", "db-ensure.sh");
-    if (existsSync8(dbScript)) spawnSync2("bash", [dbScript, "postgresql", "manual"], { cwd: projectRoot, stdio: "inherit" });
+    const dbScript = resolve6(projectRoot, magicDir, "scripts", "db-ensure.sh");
+    if (existsSync9(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 ? `
+${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
+      } catch (e) {
+        fail = e instanceof Error ? e.message : String(e);
+      }
+    }
     console.log([
       "",
       "\u2501".repeat(30),
@@ -1187,25 +1370,26 @@ async function deployDatabase(ctx) {
     try {
       await injectPrisma2(projectRoot, { force: !!options.force, datasource: "sqlite" });
     } catch (e) {
-      console.log(`SQLite \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+      fail = `SQLite \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`;
     }
   }
+  return fail;
 }
 function deployDocs(ctx) {
   const { projectRoot, options, config } = ctx;
   if (options.dryRun) return;
   const pn = config.projectName || "add-project";
-  const docsBase = resolve5(projectRoot, "docs", pn, "knowledge");
-  const groundingSrc = resolve5(import.meta.dirname, "../templates/core/templates");
+  const docsBase = resolve6(projectRoot, "docs", pn, "knowledge");
+  const groundingSrc = resolve6(import.meta.dirname, "../templates/core/templates");
   for (const d of ["00-\u9700\u6C42", "01-\u67B6\u6784", "02-\u89C4\u8303"]) {
-    const srcDir = resolve5(groundingSrc, d);
-    const destDir = resolve5(docsBase, d);
-    if (!existsSync8(destDir)) mkdirSync4(destDir, { recursive: true });
-    if (!existsSync8(srcDir)) continue;
+    const srcDir = resolve6(groundingSrc, d);
+    const destDir = resolve6(docsBase, d);
+    if (!existsSync9(destDir)) mkdirSync4(destDir, { recursive: true });
+    if (!existsSync9(srcDir)) continue;
     for (const f of readdirSync2(srcDir)) {
-      const src = resolve5(srcDir, f);
-      const dest = resolve5(destDir, f);
-      if (existsSync8(dest)) continue;
+      const src = resolve6(srcDir, f);
+      const dest = resolve6(destDir, f);
+      if (existsSync9(dest)) continue;
       try {
         copyFileSync2(src, dest);
       } catch {
@@ -1213,30 +1397,51 @@ function deployDocs(ctx) {
     }
   }
 }
-function finalize(ctx, result) {
+function finalize(ctx, result, dbFail) {
   const { projectRoot, options, db } = ctx;
-  console.log(`
+  if (options.dryRun) {
+    console.log(`
 \u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}, \u8986\u76D6 ${result.overwritten}`);
-  if (options.dryRun) return;
+    return;
+  }
   if (db.engine === "sqlite") console.log("\u6570\u636E\u5907\u4EFD: npm run db:export \u2192 data/exports/");
-  const pkg = JSON.parse(readFileSync6(resolve5(import.meta.dirname, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync7(resolve6(import.meta.dirname, "../package.json"), "utf-8"));
   const peerNames = Object.keys(pkg.peerDependencies || {});
   if (peerNames.length > 0) {
     console.log(`
 \u5B89\u88C5 peer \u4F9D\u8D56 (${peerNames.join(" ")}) ...`);
     const pm = detectPm(projectRoot);
-    spawnSync2(pm, pm === "pnpm" ? ["add", ...peerNames] : ["install", ...peerNames], { cwd: projectRoot, stdio: "inherit" });
+    const installArgs = pm === "pnpm" ? ["add", ...peerNames] : ["install", ...peerNames];
+    try {
+      const ir = runCommand(pm, installArgs, { cwd: projectRoot });
+      if (ir.status !== 0) console.warn(`\u26A0\uFE0F peer \u4F9D\u8D56\u5B89\u88C5\u5931\u8D25\uFF08\u9000\u51FA\u7801: ${ir.status}\uFF09\uFF0C\u540E\u7EED MCP \u542F\u52A8\u53EF\u80FD\u62A5\u9519`);
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F peer \u4F9D\u8D56\u5B89\u88C5\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+    }
   }
   if (db.engine !== "manual" && (db.engine !== "postgresql" || db.container !== "manual")) {
     console.log("\u63D0\u793A: \u91CD\u542F IDE \u4EE5\u52A0\u8F7D hook \u914D\u7F6E");
   }
+  if (dbFail) {
+    console.error(`
+\u2717 \u6CBB\u7406\u6A21\u578B\u672A\u5C31\u7EEA: ${dbFail}`);
+    console.error("  \u8BF7\u6309\u9519\u8BEF\u63D0\u793A\u4FEE\u590D\u540E\u91CD\u65B0\u8FD0\u884C add-coder init\u3002");
+    process.exit(1);
+  }
+  console.log(`
+\u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}, \u8986\u76D6 ${result.overwritten}`);
 }
 
 // src/cli/commands/sync.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
-import { resolve as resolve6, dirname as dirname4 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve7, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
 
+// src/lib/path-normalize.ts
+function normalizeRelPath(p) {
+  return p.replaceAll("\\", "/");
+}
+
 // src/caijuehub/strategies/sync.strategy.ts
 var SYNC_CONFIG = {
   PATCH_GUARD: [/[/]plans[/]/, /[/]specs[/]/, /[/]reviews[/]/, /[/]rules[/]profiles[/]/],
@@ -1280,32 +1485,65 @@ function resolveAdapter2(projectRoot, specified) {
   return "qoder";
 }
 function isUserData(p) {
-  return SYNC_CONFIG.PATCH_GUARD.some((r) => r.test(p));
+  return SYNC_CONFIG.PATCH_GUARD.some((r) => r.test(normalizeRelPath(p)));
 }
 function hash8(c) {
   return createHash2("sha256").update(c).digest("hex").slice(0, SYNC_CONFIG.HASH_HEX_LENGTH);
 }
 function loadHashFile(root, magic) {
   try {
-    return JSON.parse(readFileSync7(resolve6(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
+    const raw = JSON.parse(readFileSync8(resolve7(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;
   } catch {
     return {};
   }
 }
 function loadVersionFile(root, magic) {
   try {
-    return readFileSync7(resolve6(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
+    return readFileSync8(resolve7(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function saveVersionFile(root, magic, version2) {
-  writeFileSync5(resolve6(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
+  writeFileSync5(resolve7(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
 }
 function saveHashFile(root, magic, files) {
   const m = {};
-  for (const [p, c] of files) m[p] = hash8(c);
-  writeFileSync5(resolve6(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
+  for (const [p, c] of files) m[p] = c;
+  writeFileSync5(resolve7(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
+}
+function mergeFullHash(outHash, candidates, readDiskHash) {
+  const finalHash = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(outHash)) finalHash.set(k, v);
+  for (const { relPath, absPath } of candidates) {
+    const key = normalizeRelPath(relPath);
+    const h = readDiskHash(absPath);
+    if (h !== null) finalHash.set(key, h);
+  }
+  return finalHash;
+}
+async function maybeModelDownload(options) {
+  let model;
+  try {
+    model = resolveEmbeddingModel();
+  } catch (e) {
+    console.warn(`\u26A0\uFE0F \u6A21\u578B\u914D\u7F6E\u7F3A\u5931\uFF08\u8DF3\u8FC7\u68C0\u6D4B\uFF09: ${e instanceof Error ? e.message : String(e)}`);
+    return;
+  }
+  if (isModelCached(model)) return;
+  if (options.model) {
+    try {
+      const r = await ensureEmbeddingModel();
+      console.log(`\u6A21\u578B\u9884\u4E0B\u8F7D: ${r.status} (${r.model})`);
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F \u6A21\u578B\u9884\u4E0B\u8F7D\u5931\u8D25\uFF08\u9996\u6B21 DPS \u8C03\u7528\u4F1A\u81EA\u52A8\u8865\u4E0B\u8F7D\uFF09: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  } else {
+    console.log(`\u6A21\u578B\u672A\u9884\u4E0B\u8F7D: \u8FD0\u884C \`add-coder model:download\` \u63D0\u524D\u4E0B\u8F7D\uFF08\u9996\u6B21 DPS \u8C03\u7528\u4E5F\u4F1A\u81EA\u52A8\u4E0B\u8F7D\uFF09`);
+  }
 }
 async function syncCommand(options = {}) {
   const projectRoot = process.cwd();
@@ -1348,10 +1586,10 @@ async function syncCommand(options = {}) {
       candidates.set(p, c);
     }
     const outHash = loadHashFile(projectRoot, magicDir);
-    const srcHashPath = resolve6(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json");
+    const srcHashPath = resolve7(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json");
     let npmVersion = "";
     try {
-      npmVersion = JSON.parse(readFileSync7(srcHashPath, "utf-8"))._version ?? "";
+      npmVersion = JSON.parse(readFileSync8(srcHashPath, "utf-8"))._version ?? "";
     } catch {
     }
     const installedVersion = loadVersionFile(projectRoot, magicDir);
@@ -1370,18 +1608,19 @@ async function syncCommand(options = {}) {
     const conflictFiles = /* @__PURE__ */ new Map();
     let sameCount = 0;
     for (const [relPath, content] of candidates) {
-      const absPath = resolve6(projectRoot, relPath);
-      if (!existsSync9(absPath)) {
-        missingFiles.set(relPath, content);
+      const key = normalizeRelPath(relPath);
+      const absPath = resolve7(projectRoot, relPath);
+      if (!existsSync10(absPath)) {
+        missingFiles.set(key, content);
       } else if (establishBaseline) {
-        missingFiles.set(relPath, content);
+        missingFiles.set(key, content);
       } else {
-        const curH = hash8(readFileSync7(absPath, "utf-8"));
-        const storedH = outHash[relPath];
+        const curH = hash8(readFileSync8(absPath, "utf-8"));
+        const storedH = outHash[key];
         if (storedH && curH === storedH) {
           sameCount++;
         } else {
-          conflictFiles.set(relPath, content);
+          conflictFiles.set(key, content);
         }
       }
     }
@@ -1402,14 +1641,20 @@ async function syncCommand(options = {}) {
     if (missingFiles.size === 0 && conflictFiles.size === 0) {
       console.log(SYNC_CONFIG.PROMPT_PATCH_DONE);
     }
-    saveHashFile(projectRoot, magicDir, new Map([...missingFiles, ...conflictFiles]));
+    const finalHash = mergeFullHash(
+      outHash,
+      [...candidates].map(([relPath]) => ({ relPath, absPath: resolve7(projectRoot, relPath) })),
+      (absPath) => existsSync10(absPath) ? hash8(readFileSync8(absPath, "utf-8")) : null
+    );
+    saveHashFile(projectRoot, magicDir, finalHash);
     saveVersionFile(projectRoot, magicDir, npmVersion);
     await checkPrismaDiff(projectRoot, options);
+    await maybeModelDownload(options);
     return;
   }
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of allFiles) {
-    if (!existsSync9(resolve6(projectRoot, relPath))) {
+    if (!existsSync10(resolve7(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
@@ -1428,10 +1673,11 @@ async function syncCommand(options = {}) {
   const result = await writeFiles2(projectRoot, filesToWrite, { yes: true });
   console.log(`\u540C\u6B65\u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}`);
   await checkPrismaDiff(projectRoot, options);
+  await maybeModelDownload(options);
 }
 function printMigrateGuidance(targetPath, changed) {
   const g = SYNC_PRISMA_CONFIG.POST_SYNC;
-  const isManaged = existsSync9(resolve6(dirname4(targetPath), "migrations"));
+  const isManaged = existsSync10(resolve7(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) {
@@ -1453,9 +1699,9 @@ function printMigrateGuidance(targetPath, changed) {
 }
 async function checkPrismaDiff(projectRoot, options) {
   if (!options.patch) return;
-  const basePath = resolve6(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
-  const targetPath = resolve6(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
-  if (!existsSync9(basePath)) {
+  const basePath = resolve7(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
+  const targetPath = resolve7(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
+  if (!existsSync10(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`);
@@ -1467,7 +1713,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 = existsSync9(targetPath);
+  const targetExists = existsSync10(targetPath);
   let modifiedCount = 0;
   console.log(`
 \u26A0\uFE0F  Prisma schema \u5DEE\u5F02\u68C0\u6D4B:`);
@@ -1618,7 +1864,7 @@ async function handleDiffAction(action, ctx) {
   }
 }
 function injectMissingModels(targetPath, models) {
-  let content = readFileSync7(targetPath, "utf-8");
+  let content = readFileSync8(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)}) =====
@@ -1631,44 +1877,77 @@ function injectMissingModels(targetPath, models) {
   return models.length;
 }
 function getBaseFieldLines(basePath, modelName) {
-  const content = readFileSync7(basePath, "utf-8");
-  const blockRegex = /^(model|enum)\s+(\w+)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    if (match[2] !== modelName) continue;
-    const fields = {};
-    for (const line of match[3].split("\n")) {
+  const content = readFileSync8(basePath, "utf-8");
+  const blocks = parseSchemaBlocks(content);
+  const block = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
+  if (!block) return {};
+  const fields = {};
+  for (const line of block.body.split("\n")) {
+    const clean = line.replace(/\/\/.*$/, "").trim();
+    if (!clean) continue;
+    if (block.type === "enum") {
+      if (/^\w+$/.test(clean)) fields[clean] = line.trim();
+    } else {
       const fm = line.match(/^\s*(\w+)\s+/);
       if (fm) fields[fm[1]] = line.trim();
     }
-    return fields;
   }
-  return {};
+  return fields;
 }
 function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
   const baseFields = getBaseFieldLines(basePath, modelName);
-  if (Object.keys(baseFields).length === 0) return 0;
-  let content = readFileSync7(targetPath, "utf-8");
-  let count = 0;
+  if (Object.keys(baseFields).length === 0) {
+    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 = readFileSync8(targetPath, "utf-8");
+  const lines = content.split("\n");
+  const blocks = parseSchemaBlocks(content);
+  const target = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
+  if (!target) {
+    console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A\u76EE\u6807\u4E2D\u4E0D\u5B58\u5728 ${modelName} \u5757\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
+    return 0;
+  }
+  const bodyLines = target.body.split("\n");
+  const startIdx = lines.findIndex((l) => l === bodyLines[0]);
+  if (startIdx < 0) {
+    console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A\u65E0\u6CD5\u5B9A\u4F4D ${modelName} \u5757\u4F4D\u7F6E\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
+    return 0;
+  }
+  const endIdx = startIdx + bodyLines.length - 1;
+  const existingNames = new Set(
+    target.fields.map((f) => f.split(":")[0])
+  );
+  const newFieldLines = [];
   for (const key of fieldKeys) {
     const fieldName = key.split(":")[0];
     const fieldLine = baseFields[fieldName];
     if (!fieldLine) continue;
-    const modelRegex = new RegExp(`(model\\s+${modelName}\\s*\\{)([^}]*?)(\\n\\s*\\})`, "m");
-    const m = content.match(modelRegex);
-    if (!m) continue;
-    if (new RegExp(`^\\s*${fieldName}\\s+`, "m").test(m[2])) continue;
-    content = content.replace(modelRegex, `$1$2
-  ${fieldLine}$3`);
-    count++;
+    if (existingNames.has(fieldName)) continue;
+    newFieldLines.push(`  ${fieldLine}`);
   }
-  if (count > 0) writeFileSync5(targetPath, content, "utf-8");
-  return count;
+  if (newFieldLines.length === 0) {
+    if (fieldKeys.length > 0) {
+      console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A${modelName} \u7684 ${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF08\u53EF\u80FD\u5DF2\u5B58\u5728\u6216\u5B9A\u4E49\u4E0D\u5339\u914D\uFF09`);
+    }
+    return 0;
+  }
+  let insertIdx = endIdx;
+  for (let k = startIdx + 1; k < endIdx; k++) {
+    if (/^\s*@@/.test(lines[k])) insertIdx = k;
+  }
+  const merged = [
+    ...lines.slice(0, insertIdx),
+    ...newFieldLines,
+    ...lines.slice(insertIdx)
+  ];
+  writeFileSync5(targetPath, merged.join("\n"), "utf-8");
+  return newFieldLines.length;
 }
 function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
   const baseFields = getBaseFieldLines(basePath, modelName);
   if (Object.keys(baseFields).length === 0) return 0;
-  let content = readFileSync7(targetPath, "utf-8");
+  let content = readFileSync8(targetPath, "utf-8");
   let count = 0;
   for (const { fieldName } of conflicts) {
     const baseLine = baseFields[fieldName];
@@ -1684,8 +1963,8 @@ function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync10 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { resolve as resolve8 } from "path";
 async function statusCommand() {
   const projectRoot = process.cwd();
   const config = await loadConfig(projectRoot);
@@ -1694,7 +1973,7 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync10(resolve7(projectRoot, relPath))) {
+    if (existsSync11(resolve8(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
@@ -1705,14 +1984,15 @@ 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");
   }
 }
 
 // src/cli/commands/stack.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
-import { resolve as resolve8, join as join5 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync12, mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve9, join as join6 } from "path";
 import { createHash as createHash3 } from "crypto";
 var MAGIC_DIR_MAP3 = { claude: ".claude", qoder: ".qoder", vscode: ".vscode", trae: ".trae", codex: ".codex" };
 var HASH_OUTPUT_FILE = ".add-coder-hash.json";
@@ -1729,14 +2009,14 @@ function resolveMagicDir(projectRoot, specified) {
   return MAGIC_DIR_MAP3[adapter];
 }
 function listCustomProfiles(projectRoot, magicDir, registryNames) {
-  const dir = resolve8(projectRoot, magicDir, "rules", "profiles");
-  if (!existsSync11(dir)) return [];
+  const dir = resolve9(projectRoot, magicDir, "rules", "profiles");
+  if (!existsSync12(dir)) return [];
   return readdirSync3(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 existsSync11(resolve8(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
+  return existsSync12(resolve9(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
 }
 function stackCommand(sub, name, options = {}) {
   const projectRoot = process.cwd();
@@ -1773,12 +2053,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 = resolve8(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
-    const stat = existsSync11(profilePath) ? readFileSync8(profilePath, "utf-8").length : 0;
+    const profilePath = resolve9(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
+    const stat = existsSync12(profilePath) ? readFileSync9(profilePath, "utf-8").length : 0;
     console.log(`\u6280\u672F\u6808: ${current}`);
-    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync11(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
+    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync12(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
     try {
-      const raw = JSON.parse(readFileSync8(resolve8(projectRoot, magicDir, "stack.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync9(resolve9(projectRoot, magicDir, "stack.json"), "utf-8"));
       if (raw.updatedAt) console.log(`\u66F4\u65B0\u65F6\u95F4: ${raw.updatedAt}`);
     } catch {
     }
@@ -1803,9 +2083,9 @@ function buildConfig(projectRoot, magicDir, stack) {
     stack
   };
   try {
-    const pkgPath = resolve8(projectRoot, "package.json");
-    if (existsSync11(pkgPath)) {
-      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+    const pkgPath = resolve9(projectRoot, "package.json");
+    if (existsSync12(pkgPath)) {
+      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
       if (pkg.name) config.projectName = pkg.name;
     }
   } catch {
@@ -1814,9 +2094,9 @@ function buildConfig(projectRoot, magicDir, stack) {
 }
 function applyStack(projectRoot, magicDir, name) {
   if (!profileExists(projectRoot, magicDir, name)) {
-    const registry = loadProfileRegistry();
+    const registry2 = loadProfileRegistry();
     console.error(`\u2717 profile \u4E0D\u5B58\u5728: ${name}`);
-    console.error(`  \u5185\u7F6E: ${registry.map((p) => p.name).join(" | ")}\uFF08\u6216\u81EA\u5B9A\u4E49: ${magicDir}/rules/profiles/{name}-profile.md\uFF09`);
+    console.error(`  \u5185\u7F6E: ${registry2.map((p) => p.name).join(" | ")}\uFF08\u6216\u81EA\u5B9A\u4E49: ${magicDir}/rules/profiles/{name}-profile.md\uFF09`);
     process.exit(1);
   }
   const config = buildConfig(projectRoot, magicDir, name);
@@ -1824,42 +2104,69 @@ function applyStack(projectRoot, magicDir, name) {
   const coreFiles = renderCore(config, false);
   const stackRelated = /* @__PURE__ */ new Map();
   for (const [relPath, content] of coreFiles) {
-    if (relPath.includes("/rules/profiles/") || relPath.endsWith("/rules/project_rules.md")) {
-      stackRelated.set(relPath, content);
+    const rp = normalizeRelPath(relPath);
+    if (rp.includes("/rules/profiles/") || rp.endsWith("/rules/project_rules.md")) {
+      stackRelated.set(rp, content);
     }
   }
   const hashMap = {};
   try {
-    Object.assign(hashMap, JSON.parse(readFileSync8(resolve8(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
+    Object.assign(hashMap, JSON.parse(readFileSync9(resolve9(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
   } catch {
   }
   let written = 0;
   for (const [relPath, content] of stackRelated) {
     for (const t of [".add", magicDir]) {
-      const targetPath = resolve8(projectRoot, relPath.replace(/^\.add/, t));
-      mkdirSync6(join5(targetPath, ".."), { recursive: true });
+      const targetPath = resolve9(projectRoot, relPath.replace(/^\.add/, t));
+      mkdirSync6(join6(targetPath, ".."), { recursive: true });
       writeFileSync6(targetPath, content, "utf-8");
       hashMap[relPath.replace(/^\.add/, t)] = hash82(content);
       written++;
     }
   }
-  writeFileSync6(resolve8(projectRoot, magicDir, HASH_OUTPUT_FILE), JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
+  const fail = (msg) => {
+    console.error(`\u2717 stack set \u5931\u8D25: ${msg}`);
+    process.exit(1);
+  };
+  const registry = loadProfileRegistry();
+  const isBuiltin = registry.some((p) => p.name === name);
+  const profilePathMagic = resolve9(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`);
+  const profilePathAdd = resolve9(projectRoot, ".add", "rules", "profiles", `${name}-profile.md`);
+  const projectRulesPath = resolve9(projectRoot, magicDir, "rules", "project_rules.md");
+  const projectRulesContent = existsSync12(projectRulesPath) ? readFileSync9(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 (isBuiltin && !existsSync12(profilePathAdd)) fail(`profile \u672A\u5199\u5165 .add: ${profilePathAdd}`);
+  if (!existsSync12(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`);
+  writeFileSync6(resolve9(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 ${existsSync11(resolve8(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 ${existsSync12(resolve9(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/cli/index.ts
 var { version } = JSON.parse(
-  readFileSync9(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync10(new URL("../package.json", import.meta.url), "utf-8")
 );
+async function modelDownloadCommand(options) {
+  try {
+    const r = await ensureEmbeddingModel({ force: options.force });
+    console.log(`\u6A21\u578B\u9884\u4E0B\u8F7D: ${r.status}${r.model ? ` (${r.model})` : ""}`);
+    if (r.cacheDir) console.log(`\u7F13\u5B58\u4F4D\u7F6E: ${r.cacheDir}`);
+    console.log("\u63D0\u793A: \u8FD0\u884C\u65F6 DPS \u4F7F\u7528\u7684\u6A21\u578B\u914D\u7F6E\u4EE5 `add-coder generate` \u751F\u6210\u7684\u914D\u7F6E\u4E3A\u51C6");
+  } catch (e) {
+    console.error(`\u6A21\u578B\u9884\u4E0B\u8F7D\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }
+}
 var program = new Command();
 program.name("add-coder").description("\u521D\u59CB\u5316 ADD \u8303\u5F0F\u5DE5\u4F5C\u6D41\u6A21\u677F").version(version);
-program.command("init").description("\u521D\u59CB\u5316 ADD \u6A21\u677F\u5230\u5F53\u524D\u9879\u76EE").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("--force", "\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\uFF0C\u4E0D\u4EA4\u4E92").option("--dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4E0D\u5B9E\u9645\u5199\u5165").option("--stack <name>", "\u6280\u672F\u6808\u7EA6\u675F profile \u540D\uFF08\u5982 machineserver\uFF0C\u53EF\u9009\uFF09").action(initCommand);
-program.command("sync").description("\u589E\u91CF\u540C\u6B65\u7F3A\u5931\u6587\u4EF6\uFF08--patch \u8986\u76D6\u5DF2\u6709\u6A21\u677F\uFF09").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--patch", "\u8986\u76D6\u5DF2\u6709\u6A21\u677F\u6587\u4EF6\uFF08\u4E0D\u78B0 plans/specs/reviews\uFF09").option("-i, --interactive", "\u4EA4\u4E92\u5F0F\u9009\u62E9\u8981\u540C\u6B65\u7684\u6587\u4EF6").action(syncCommand);
+program.command("init").description("\u521D\u59CB\u5316 ADD \u6A21\u677F\u5230\u5F53\u524D\u9879\u76EE").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("--force", "\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\uFF0C\u4E0D\u4EA4\u4E92").option("--dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4E0D\u5B9E\u9645\u5199\u5165").option("--stack <name>", "\u6280\u672F\u6808\u7EA6\u675F profile \u540D\uFF08\u5982 machineserver\uFF0C\u53EF\u9009\uFF09").option("--skip-model", "\u8DF3\u8FC7 embedding \u6A21\u578B\u9884\u4E0B\u8F7D").action(initCommand);
+program.command("sync").description("\u589E\u91CF\u540C\u6B65\u7F3A\u5931\u6587\u4EF6\uFF08--patch \u8986\u76D6\u5DF2\u6709\u6A21\u677F\uFF09").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--patch", "\u8986\u76D6\u5DF2\u6709\u6A21\u677F\u6587\u4EF6\uFF08\u4E0D\u78B0 plans/specs/reviews\uFF09").option("-i, --interactive", "\u4EA4\u4E92\u5F0F\u9009\u62E9\u8981\u540C\u6B65\u7684\u6587\u4EF6").option("--model", "\u68C0\u6D4B\u5230\u7F3A\u5931\u65F6\u4E0B\u8F7D embedding \u6A21\u578B").action(syncCommand);
 program.command("status").description("\u68C0\u67E5 ADD \u6A21\u677F\u5B8C\u6574\u6027").action(statusCommand);
 program.command("stack").description("\u7BA1\u7406\u6280\u672F\u6808\u7EA6\u675F profile\uFF08list / set <name> / show / --clear\uFF09").argument("[sub]", "list | set | show").argument("[name]", "set <name>: profile \u540D\uFF08\u5185\u7F6E\u6216\u81EA\u5B9A\u4E49\uFF09").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--clear", "\u6E05\u9664\u6280\u672F\u6808\u8BBE\u7F6E\uFF08\u4E2D\u6027\uFF09").action(
   (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.parse();