add-coder 0.3.23 → 0.3.24

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync12 } 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((resolve10) => {
+  return new Promise((resolve12) => {
     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++;
       }
-      resolve10(result);
+      resolve12(result);
     });
   });
 }
@@ -645,12 +645,12 @@ function detectPm(projectRoot) {
 }
 
 // src/cli/prisma-injector.ts
-import { resolve as resolve4, dirname as dirname3 } from "path";
+import { resolve as resolve6, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/caijuehub/strategies/prisma.strategy.ts
-import { copyFileSync, existsSync as existsSync7, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { resolve as resolve3 } from "path";
+import { copyFileSync, existsSync as existsSync9, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve5, join as join6, dirname as dirname3 } from "path";
 
 // src/lib/run-command.ts
 import { spawnSync } from "child_process";
@@ -680,6 +680,205 @@ function commandExists(cmd, platform) {
   return !r.error && r.status === 0;
 }
 
+// src/lib/db-backup.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3, readdirSync as readdirSync2, rmSync } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
+var ADD_TABLES = ["AddUser", "DevOperation", "AuditLog", "HitlRecord", "PlanRecord", "ReviewRecord", "CollabContract"];
+function ensureGitignoreRule(projectRoot) {
+  const gitignorePath = resolve3(projectRoot, ".gitignore");
+  if (!existsSync7(gitignorePath)) return;
+  const content = readFileSync5(gitignorePath, "utf-8");
+  if (content.includes(".add/backups/")) return;
+  writeFileSync3(gitignorePath, `${content}${content.endsWith("\n") ? "" : "\n"}
+# add-coder \u6570\u636E\u5E93\u540C\u6B65\u5907\u4EFD
+.add/backups/
+`, "utf-8");
+  console.log("\u{1F4CB} \u5DF2\u6CE8\u5165\u5BBF\u4E3B .gitignore: .add/backups/");
+}
+async function backupBeforeSync(projectRoot, opts) {
+  const dir = resolve3(projectRoot, opts.backupDir);
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const bakDir = join5(dir, ts);
+  ensureGitignoreRule(projectRoot);
+  if (opts.datasource === "sqlite" || opts.dbUrl.startsWith("file:")) {
+    const dbFile = opts.dbUrl.replace(/^file:/, "");
+    if (!existsSync7(dbFile)) return handleBackupFailure(opts, `sqlite \u6587\u4EF6\u4E0D\u5B58\u5728: ${dbFile}`);
+    mkdirSync3(bakDir, { recursive: true });
+    const copy = join5(bakDir, "dev.db");
+    writeFileSync3(copy, readFileSync5(dbFile), "utf-8");
+    writeFileSync3(join5(bakDir, "manifest.json"), JSON.stringify({ createdAt: ts, dbUrl: opts.dbUrl, files: ["dev.db"] }, null, 2), "utf-8");
+    console.log(`\u2705 \u5907\u4EFD\u5B8C\u6210: ${bakDir}`);
+    pruneBackups(dir, opts.backupKeep);
+    return bakDir;
+  }
+  if (!commandExists("pg_dump")) {
+    return handleBackupFailure(opts, "pg_dump \u672A\u5B89\u88C5\uFF08postgresql-client \u7F3A\u5931\uFF09");
+  }
+  mkdirSync3(bakDir, { recursive: true });
+  const schemaFile = join5(bakDir, "schema.sql");
+  const tablesFile = join5(bakDir, "add-tables.sql");
+  const r1 = runCommand("pg_dump", ["--schema-only", "--no-owner", `--dbname=${opts.dbUrl}`], { timeout: 6e4 });
+  if (r1.status !== 0) {
+    return handleBackupFailure(opts, `pg_dump schema \u5931\u8D25: ${r1.stderr.trim().split("\n").slice(0, 3).join(" | ")}`);
+  }
+  writeFileSync3(schemaFile, r1.stdout, "utf-8");
+  const r2 = runCommand("pg_dump", ["--no-owner", "--if-exists", `--dbname=${opts.dbUrl}`, ...ADD_TABLES.map((t) => `--table=${t}`)], { timeout: 6e4 });
+  if (r2.status !== 0) {
+    return handleBackupFailure(opts, `pg_dump ADD \u8868\u5931\u8D25: ${r2.stderr.trim().split("\n").slice(0, 3).join(" | ")}`);
+  }
+  writeFileSync3(tablesFile, r2.stdout, "utf-8");
+  writeFileSync3(join5(bakDir, "manifest.json"), JSON.stringify({ createdAt: ts, dbUrl: opts.dbUrl, files: ["schema.sql", "add-tables.sql"] }, null, 2), "utf-8");
+  console.log(`\u2705 \u5907\u4EFD\u5B8C\u6210: ${bakDir}`);
+  pruneBackups(dir, opts.backupKeep);
+  return bakDir;
+}
+async function handleBackupFailure(opts, reason) {
+  if (opts.yes) {
+    throw new Error(`\u26D4 \u5907\u4EFD\u5931\u8D25\uFF08--yes \u786C\u963B\u65AD\uFF0C\u540C\u6B65\u4E2D\u6B62\uFF09: ${reason}`);
+  }
+  const a = await ask(`
+\u26A0\uFE0F \u5907\u4EFD\u5931\u8D25\uFF08${reason}\uFF09\u3002\u81EA\u62C5\u98CE\u9669\u7EE7\u7EED\u540C\u6B65\uFF1F[y/N] `);
+  if (a !== "y" && a !== "yes") {
+    throw new Error(`\u5907\u4EFD\u5931\u8D25\uFF0C\u5DF2\u4E2D\u6B62\u540C\u6B65: ${reason}`);
+  }
+  console.warn("\u26A0\uFE0F \u7528\u6237\u63A5\u53D7\u81EA\u62C5\u98CE\u9669\u7EE7\u7EED\uFF08manifest \u8BB0 riskAccepted\uFF09");
+  return null;
+}
+function pruneBackups(dir, backupKeep) {
+  if (!existsSync7(dir)) return;
+  const entries = readdirSync2(dir).filter((n) => /^\d{4}-\d{2}-\d{2}T/.test(n)).sort();
+  const excess = entries.length - backupKeep;
+  for (let i = 0; i < excess; i++) {
+    rmSync(join5(dir, entries[i]), { recursive: true, force: true });
+    console.log(`\u{1F9F9} \u6E05\u7406\u65E7\u5907\u4EFD: ${entries[i]}`);
+  }
+}
+
+// src/lib/ports-contract.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync3 } from "fs";
+import { resolve as resolve4, basename } from "path";
+
+// src/caijuehub/strategies/ports.strategy.ts
+var PORTS_CONFIG = {
+  pg: {
+    startHint: 5433,
+    scanLimit: 100
+  },
+  behavior: {
+    reuseRegistered: true,
+    readCrossProject: true,
+    onConflict: "ask"
+  }
+};
+
+// src/lib/ports-contract.ts
+import { createConnection } from "net";
+var PORTS_EXAMPLE_REL = "../templates/core/templates/ports.example.md";
+function ensurePortsContract(projectRoot, config, dryRun = false) {
+  const target = resolve4(projectRoot, "docs", "ports.md");
+  if (existsSync8(target)) return;
+  let content;
+  try {
+    content = readFileSync6(resolve4(import.meta.dirname, PORTS_EXAMPLE_REL), "utf-8");
+  } catch {
+    console.warn(`\u26A0\uFE0F \u7AEF\u53E3\u5951\u7EA6\u6A21\u677F\u7F3A\u5931\uFF08\u8DF3\u8FC7\u751F\u6210 docs/ports.md\uFF09: ${PORTS_EXAMPLE_REL}`);
+    return;
+  }
+  const pn = config.projectName || "add-project";
+  const rendered = render(content, { ...config, projectName: pn });
+  if (dryRun) {
+    console.log("[dry-run] \u5C06\u751F\u6210 docs/ports.md");
+    return;
+  }
+  mkdirSync4(resolve4(projectRoot, "docs"), { recursive: true });
+  writeFileSync4(target, rendered, "utf-8");
+  console.log("\u2705 \u5DF2\u751F\u6210\u7AEF\u53E3\u5951\u7EA6 docs/ports.md\uFF08\u8BF7\u6309\u9879\u76EE\u5B9E\u9645\u767B\u8BB0\u7AEF\u53E3\uFF0C\u793A\u4F8B\u72B6\u6001\u5217\u52FF\u76F4\u63A5\u63D0\u4EA4\uFF09");
+}
+function portInUse(port) {
+  return new Promise((r) => {
+    const s = createConnection({ port, host: "127.0.0.1" }, () => {
+      s.destroy();
+      r(true);
+    });
+    s.on("error", () => r(false));
+  });
+}
+function parseContractPorts(content) {
+  const out = [];
+  const re = /^\|\s*(\d{2,5})\s*\|/gm;
+  let m;
+  while ((m = re.exec(content)) !== null) out.push(parseInt(m[1], 10));
+  return out;
+}
+function readRegisteredPorts(projectRoot) {
+  const p = resolve4(projectRoot, "docs", "ports.md");
+  if (!existsSync8(p)) return /* @__PURE__ */ new Set();
+  return new Set(parseContractPorts(readFileSync6(p, "utf-8")));
+}
+function readCrossProjectPorts(projectRoot) {
+  const ports = /* @__PURE__ */ new Set();
+  const parent = resolve4(projectRoot, "..");
+  let names = [];
+  try {
+    names = readdirSync3(parent, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name !== basename(projectRoot)).map((d) => d.name);
+  } catch {
+    return ports;
+  }
+  for (const name of names) {
+    const p = resolve4(parent, name, "docs", "ports.md");
+    if (existsSync8(p)) {
+      parseContractPorts(readFileSync6(p, "utf-8")).forEach((x) => ports.add(x));
+    }
+  }
+  return ports;
+}
+function scanPodmanPorts() {
+  const ports = /* @__PURE__ */ new Set();
+  if (!commandExists("podman")) return ports;
+  try {
+    const r = runCommand("podman", ["ps", "--format", "{{.Ports}}"]);
+    const re = /(\d{1,5})->\d{1,5}\/tcp/g;
+    let m;
+    while ((m = re.exec(r.stdout)) !== null) ports.add(parseInt(m[1], 10));
+  } catch {
+  }
+  return ports;
+}
+function registerPort(projectRoot, port, svc) {
+  const contract = resolve4(projectRoot, "docs", "ports.md");
+  if (!existsSync8(contract)) return;
+  const env = svc.envKey ? ` \`${svc.envKey}\`` : "";
+  const line = `| ${port} | PostgreSQL\uFF08${svc.containerName}\uFF09 | ${svc.name}\uFF08add-coder \u81EA\u52A8\u767B\u8BB0\uFF09 | \u{1F7E2} \u4F7F\u7528\u4E2D | .env.development${env} |
+`;
+  writeFileSync4(contract, readFileSync6(contract, "utf-8") + line, "utf-8");
+  console.log(`\u{1F4CB} \u7AEF\u53E3\u5951\u7EA6\u767B\u8BB0: ${port}\uFF08${svc.containerName}\uFF09\u2192 docs/ports.md`);
+}
+async function allocatePortsWithContract(projectRoot, services) {
+  const cfg = PORTS_CONFIG;
+  const used = /* @__PURE__ */ new Set();
+  readRegisteredPorts(projectRoot).forEach((p) => used.add(p));
+  if (cfg.behavior.readCrossProject) readCrossProjectPorts(projectRoot).forEach((p) => used.add(p));
+  scanPodmanPorts().forEach((p) => used.add(p));
+  const result = {};
+  for (const svc of services) {
+    let port = 0;
+    for (let p = cfg.pg.startHint; p < cfg.pg.startHint + cfg.pg.scanLimit; p++) {
+      if (used.has(p)) continue;
+      if (await portInUse(p)) {
+        used.add(p);
+        continue;
+      }
+      port = p;
+      break;
+    }
+    if (!port) throw new Error(`\u7AEF\u53E3\u5951\u7EA6\u5206\u914D\u5931\u8D25: ${cfg.pg.startHint}-${cfg.pg.startHint + cfg.pg.scanLimit} \u65E0\u7A7A\u95F2\u7AEF\u53E3\uFF08${svc.name}\uFF09`);
+    used.add(port);
+    result[svc.name] = port;
+    registerPort(projectRoot, port, svc);
+  }
+  return result;
+}
+
 // src/caijuehub/strategies/prisma.strategy.ts
 var PRISMA_CONFIG = {
   onMissing: "ask",
@@ -688,11 +887,295 @@ var PRISMA_CONFIG = {
   autoGenerate: true,
   migrationName: "add_workflow_init",
   schemaArg: "--schema=prisma/",
-  requiresUserModel: true
+  requiresUserModel: true,
+  sync: {
+    strategy: "atlas",
+    addDatabaseUrl: "",
+    atlasDevUrl: "",
+    backupDir: ".add/backups/prisma-sync",
+    backupKeep: 5,
+    backupRequiredForPush: true
+  }
 };
+var ADD_TABLES2 = ["AddUser", "DevOperation", "AuditLog", "HitlRecord", "PlanRecord", "ReviewRecord", "CollabContract"];
+function readEnvValue(projectRoot, key) {
+  const envPath = resolve5(projectRoot, ".env.development");
+  if (!existsSync9(envPath)) return "";
+  const m = readFileSync7(envPath, "utf-8").match(new RegExp(`^${key}=(.*)$`, "m"));
+  return m?.[1]?.trim() || "";
+}
+function appendEnvValue(projectRoot, key, value) {
+  const envPath = resolve5(projectRoot, ".env.development");
+  const existing = existsSync9(envPath) ? readFileSync7(envPath, "utf-8") : "";
+  if (new RegExp(`^${key}=`, "m").test(existing)) return;
+  writeFileSync5(envPath, `${existing}${existing.endsWith("\n") ? "" : "\n"}${key}=${value}
+`, "utf-8");
+}
+async function ensureSplitDb(projectRoot, opts) {
+  const existing = readEnvValue(projectRoot, "ADD_DATABASE_URL");
+  if (existing) {
+    console.log("\u5206\u5E93\u6A21\u5F0F\uFF1A\u68C0\u6D4B\u5230 ADD_DATABASE_URL\uFF0CADD \u6CBB\u7406\u6A21\u578B\u5165\u72EC\u7ACB\u5E93");
+    return true;
+  }
+  if (opts.dryRun) {
+    console.log("[dry-run] \u5C06\u8BE2\u95EE\u662F\u5426\u5206\u5E93\uFF08\u72EC\u7ACB ADD \u6570\u636E\u5E93\uFF0C\u63A8\u8350\uFF09");
+    return false;
+  }
+  let choice = "y";
+  if (!opts.force && !opts.yes) {
+    const a = await ask("\u662F\u5426\u5C06 ADD \u6CBB\u7406\u6A21\u578B\u653E\u5165\u72EC\u7ACB\u6570\u636E\u5E93\uFF08\u63A8\u8350\uFF0C\u9694\u79BB\u4E1A\u52A1\u5E93\uFF09\uFF1F[Y/n] ");
+    if (a === "n" || a === "no") choice = "n";
+  }
+  if (choice === "n") {
+    console.log("\u5171\u5E93\u6A21\u5F0F\uFF1AADD \u6CBB\u7406\u6A21\u578B\u8FDB\u5165\u5BBF\u4E3B\u5E93\uFF08diff \u975E ADD \u8868\u53D8\u66F4\u9ED8\u8BA4\u62D2\u7EDD\uFF09");
+    return false;
+  }
+  const projectName = readEnvValue(projectRoot, "PROJECT_NAME") || "add-project";
+  const dbUser = readEnvValue(projectRoot, "DATABASE_USER") || "admin";
+  const dbPass = readEnvValue(projectRoot, "DATABASE_PASSWORD") || "change-me-in-production";
+  const dbName = `${projectName}-add`;
+  const container = `${projectName}-add-postgres`;
+  const port = (await allocatePortsWithContract(projectRoot, [{ name: "add", containerName: `${projectName}-add-postgres`, envKey: "ADD_DATABASE_URL" }])).add;
+  console.log(`\u542F\u52A8\u72EC\u7ACB ADD \u5E93\u5BB9\u5668 ${container}\uFF08\u7AEF\u53E3 ${port}\uFF09...`);
+  const r = runCommand("podman", [
+    "run",
+    "-d",
+    "--name",
+    container,
+    "--restart",
+    "unless-stopped",
+    "-e",
+    `POSTGRES_USER=${dbUser}`,
+    "-e",
+    `POSTGRES_PASSWORD=${dbPass}`,
+    "-e",
+    `POSTGRES_DB=${dbName}`,
+    "-p",
+    `127.0.0.1:${port}:5432`,
+    "docker.io/postgres:16-alpine"
+  ], { timeout: 6e4 });
+  if (r.status !== 0) {
+    throw new Error(`\u72EC\u7ACB ADD \u5E93\u5BB9\u5668\u542F\u52A8\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${r.status}\uFF09: ${r.stderr.trim().slice(0, 200)}`);
+  }
+  appendEnvValue(projectRoot, "ADD_DATABASE_URL", `postgresql://${dbUser}:${dbPass}@127.0.0.1:${port}/${dbName}?schema=public`);
+  const addPrismaPath = resolve5(projectRoot, "prisma", "add.prisma");
+  if (existsSync9(addPrismaPath)) {
+    const content = readFileSync7(addPrismaPath, "utf-8");
+    if (!content.includes("datasource db")) {
+      writeFileSync5(addPrismaPath, `datasource db {
+  provider = "postgresql"
+  url      = env("ADD_DATABASE_URL")
+}
+
+${content}`, "utf-8");
+    }
+  }
+  console.log(`\u2705 \u5DF2\u521B\u5EFA\u72EC\u7ACB ADD \u5E93 ${container}\uFF08\u7AEF\u53E3 ${port}\uFF09\uFF0CADD_DATABASE_URL \u5DF2\u5199\u5165 .env.development`);
+  return true;
+}
+function prismaDiffArgs(pm, schemaTo, fromUrl) {
+  const base = pm === "pnpm" ? ["dlx", "prisma", "migrate", "diff"] : ["exec", "prisma", "--", "migrate", "diff"];
+  const toFlag = "--to-schema";
+  const args = [...base, "--from-empty", toFlag, schemaTo, "--script"];
+  if (fromUrl) args.splice(args.indexOf("--from-empty"), 1, "--from-url", fromUrl);
+  return args;
+}
+async function provisionDevUrl(projectRoot) {
+  const existing = readEnvValue(projectRoot, "ATLAS_DEV_URL");
+  if (existing) return existing;
+  if (!commandExists("podman")) return null;
+  const projectName = readEnvValue(projectRoot, "PROJECT_NAME") || "add-project";
+  const container = `${projectName}-add-dev`;
+  try {
+    const ps = runCommand("podman", ["ps", "--filter", `name=^/${container}$`, "--format", "{{.Names}}"]);
+    if (ps.stdout.trim()) {
+      const portR = runCommand("podman", ["port", container, "5432/tcp"]);
+      const pm = portR.stdout.match(/127\.0\.0\.1:(\d{2,5})/);
+      if (pm) {
+        const url2 = `postgresql://postgres:postgres@127.0.0.1:${pm[1]}/dev?schema=public`;
+        appendEnvValue(projectRoot, "ATLAS_DEV_URL", url2);
+        return url2;
+      }
+    }
+  } catch {
+  }
+  const ports = await allocatePortsWithContract(projectRoot, [{ name: "dev", containerName: container, envKey: "ATLAS_DEV_URL" }]);
+  const port = ports.dev;
+  const r = runCommand("podman", [
+    "run",
+    "-d",
+    "--name",
+    container,
+    "--restart",
+    "unless-stopped",
+    "-e",
+    "POSTGRES_USER=postgres",
+    "-e",
+    "POSTGRES_PASSWORD=postgres",
+    "-e",
+    "POSTGRES_DB=dev",
+    "-p",
+    `127.0.0.1:${port}:5432`,
+    "docker.io/postgres:16-alpine"
+  ], { timeout: 6e4 });
+  if (r.status !== 0) return null;
+  const url = `postgresql://postgres:postgres@127.0.0.1:${port}/dev?schema=public`;
+  appendEnvValue(projectRoot, "ATLAS_DEV_URL", url);
+  console.log(`\u2705 \u5E38\u9A7B dev \u7A7A\u5E93\u5DF2\u521B\u5EFA: ${container}\uFF08\u7AEF\u53E3 ${port}\uFF0C\u4E0D\u9500\u6BC1\uFF0C\u53EF\u968F\u65F6\u91CD\u7F6E\uFF09`);
+  return url;
+}
+function resolveAtlasBin(projectRoot) {
+  const pkgBin = resolve5(projectRoot, "node_modules", "add-coder", "node_modules", ".bin", "atlas");
+  if (existsSync9(pkgBin)) return pkgBin;
+  const local = resolve5(projectRoot, "node_modules", ".bin", "atlas");
+  if (existsSync9(local)) return local;
+  return commandExists("atlas") ? "atlas" : null;
+}
+function hasNonAddTableChanges(diffSql) {
+  const re = /(?:DROP|ALTER|CREATE)\s+TABLE(?:\s+IF\s+EXISTS)?\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?/gi;
+  let m;
+  while ((m = re.exec(diffSql)) !== null) {
+    if (!ADD_TABLES2.includes(m[1])) return true;
+  }
+  return false;
+}
+function buildExcludeArgs(projectRoot, splitDb) {
+  if (splitDb) return [];
+  const projectName = readEnvValue(projectRoot, "PROJECT_NAME") || "add-project";
+  const dbUser = readEnvValue(projectRoot, "DATABASE_USER") || "admin";
+  try {
+    const r = runCommand("podman", [
+      "exec",
+      `${projectName}-postgres`,
+      "psql",
+      "-U",
+      dbUser,
+      "-d",
+      projectName,
+      "-tAc",
+      "SELECT string_agg('public.' || table_name, ',') FROM information_schema.tables WHERE table_schema='public' AND table_name NOT IN ('AddUser','DevOperation','AuditLog','HitlRecord','PlanRecord','ReviewRecord','CollabContract');"
+    ], { timeout: 3e4 });
+    const tables = r.stdout.trim();
+    return tables ? ["--exclude", tables] : [];
+  } catch {
+    return [];
+  }
+}
+async function runAtlasSync(projectRoot, targetUrl, splitDb, sync, opts) {
+  const pm = detectPm(projectRoot);
+  const schemaTo = splitDb ? resolve5(projectRoot, "prisma", "add.prisma") : resolve5(projectRoot, "prisma");
+  const baselinePath = join6(projectRoot, PRISMA_CONFIG.sync.backupDir, "baseline.sql");
+  mkdirSync5(dirname3(baselinePath), { recursive: true });
+  const diffR = runCommand(pm, prismaDiffArgs(pm, schemaTo, null), { cwd: projectRoot, timeout: 6e4 });
+  if (diffR.status !== 0) {
+    console.warn(`\u26A0\uFE0F baseline \u751F\u6210\u5931\u8D25\uFF08${diffR.stderr.trim().slice(0, 150)}\uFF09\uFF0C\u964D\u7EA7 prisma-diff`);
+    return false;
+  }
+  writeFileSync5(baselinePath, diffR.stdout, "utf-8");
+  const atlasBin = resolveAtlasBin(projectRoot);
+  if (!atlasBin) {
+    console.warn("\u26A0\uFE0F atlas \u4E0D\u53EF\u7528\uFF08\u4F9D\u8D56\u672A\u5B89\u88C5\u6216\u5168\u5C40\u7F3A\u5931\uFF09");
+    return false;
+  }
+  let devUrl = await provisionDevUrl(projectRoot);
+  if (!devUrl && sync.atlasDevUrl) devUrl = sync.atlasDevUrl;
+  if (!devUrl) {
+    console.warn("\u26A0\uFE0F dev-url \u4E0D\u53EF\u7528\uFF08\u65E0 podman \u4E14\u672A\u914D\u7F6E atlas_dev_url\uFF09\uFF0C\u964D\u7EA7 prisma-diff");
+    return false;
+  }
+  {
+    const diffArgs = ["schema", "diff", "--from", targetUrl, "--to", `file://${baselinePath}`, "--dev-url", devUrl, ...buildExcludeArgs(projectRoot, splitDb)];
+    const diffSqlR = runCommand(atlasBin, diffArgs, { cwd: projectRoot, timeout: 6e4 });
+    if (diffSqlR.status !== 0) {
+      console.warn(`\u26A0\uFE0F atlas diff \u5931\u8D25\uFF08${diffSqlR.stderr.trim().slice(0, 150)}\uFF09\uFF0C\u964D\u7EA7 prisma-diff`);
+      return false;
+    }
+    const diffSql = diffSqlR.stdout;
+    const hasSql = /(?:^|\n)\s*(?:CREATE|ALTER|DROP|COMMENT|--\s*(?:Create|Modify|Drop))\b/i.test(diffSql);
+    if (!hasSql) {
+      console.log("\u2705 \u6570\u636E\u5E93\u4E0E\u76EE\u6807 schema \u4E00\u81F4\uFF08\u5E42\u7B49\u51FA\u53E3\uFF09");
+      return true;
+    }
+    if (!splitDb && hasNonAddTableChanges(diffSql)) {
+      console.error("\u26D4 \u5171\u5E93\u6A21\u5F0F\u68C0\u6D4B\u5230\u975E ADD \u8868\u53D8\u66F4\uFF08\u9ED8\u8BA4\u62D2\u7EDD\uFF09\u3002\u8BF7\u4EBA\u5DE5\u5BA1\u6838 diff.sql \u6216\u9009\u62E9\u5206\u5E93\u6A21\u5F0F\u3002");
+      console.error(diffSql.split("\n").slice(0, 30).join("\n"));
+      throw new Error("\u5171\u5E93\u6A21\u5F0F\u975E ADD \u8868\u53D8\u66F4\u9ED8\u8BA4\u62D2\u7EDD\uFF08\u53EF\u7528 --yes \u6216\u5206\u5E93\u6A21\u5F0F\u7ED5\u8FC7\uFF09");
+    }
+    if (!opts.yes) {
+      console.log("=== \u5F85\u5E94\u7528 diff SQL ===");
+      console.log(diffSql.split("\n").slice(0, 60).join("\n"));
+      const c = await ask("\u5E94\u7528\u4EE5\u4E0A schema \u53D8\u66F4\uFF1F[y/N] ");
+      if (c !== "y" && c !== "yes") {
+        console.log("\u5DF2\u53D6\u6D88\uFF0C\u672A\u5E94\u7528");
+        return true;
+      }
+    }
+    const applyArgs = ["schema", "apply", "--url", targetUrl, "--to", `file://${baselinePath}`, "--dev-url", devUrl, ...buildExcludeArgs(projectRoot, splitDb)];
+    const applyR = runCommand(atlasBin, applyArgs, { cwd: projectRoot, timeout: 12e4 });
+    if (applyR.status !== 0) {
+      console.warn(`\u26A0\uFE0F atlas apply \u5931\u8D25\uFF08${applyR.stderr.trim().slice(0, 150)}\uFF09`);
+      return false;
+    }
+    console.log("\u2705 Atlas schema \u540C\u6B65\u5B8C\u6210");
+    return true;
+  }
+}
+function runPrismaDiffSync(projectRoot, targetUrl, splitDb) {
+  const pm = detectPm(projectRoot);
+  const schemaTo = splitDb ? resolve5(projectRoot, "prisma", "add.prisma") : resolve5(projectRoot, "prisma");
+  const diffPath = join6(projectRoot, PRISMA_CONFIG.sync.backupDir, "diff.sql");
+  mkdirSync5(dirname3(diffPath), { recursive: true });
+  const r = runCommand(pm, prismaDiffArgs(pm, schemaTo, targetUrl), { cwd: projectRoot, timeout: 6e4 });
+  if (r.status !== 0) throw new Error(`prisma migrate diff \u5931\u8D25: ${r.stderr.trim().slice(0, 200)}`);
+  writeFileSync5(diffPath, r.stdout, "utf-8");
+  if (!r.stdout.trim()) {
+    console.log("\u2705 \u6570\u636E\u5E93\u4E0E\u76EE\u6807 schema \u4E00\u81F4\uFF08\u5E42\u7B49\u51FA\u53E3\uFF09");
+    return;
+  }
+  const execArgs = pm === "pnpm" ? ["dlx", "prisma", "db", "execute", "--file", diffPath] : ["exec", "prisma", "--", "db", "execute", "--file", diffPath];
+  const e = runCommand(pm, execArgs, { cwd: projectRoot, timeout: 12e4 });
+  if (e.status !== 0) throw new Error(`prisma db execute \u5931\u8D25: ${e.stderr.trim().slice(0, 200)}`);
+  console.log("\u2705 prisma-diff \u540C\u6B65\u5B8C\u6210\uFF08\u514D shadow\uFF09");
+}
+function runDbPush(projectRoot) {
+  const pm = detectPm(projectRoot);
+  const args = pm === "pnpm" ? ["dlx", "prisma", "db", "push"] : ["exec", "prisma", "--", "db", "push"];
+  if (PRISMA_CONFIG.schemaArg) args.push(PRISMA_CONFIG.schemaArg);
+  console.log(`\u6267\u884C ${pm} ${args.join(" ")} ...`);
+  const r = runCommand(pm, args, { cwd: projectRoot });
+  if (r.status !== 0) throw new Error(`prisma db push \u9000\u51FA\u7801: ${r.status}`);
+}
+async function syncDatabase(projectRoot, opts, splitDb) {
+  const sync = PRISMA_CONFIG.sync;
+  const targetUrl = splitDb ? readEnvValue(projectRoot, "ADD_DATABASE_URL") || sync.addDatabaseUrl : readEnvValue(projectRoot, "DATABASE_URL");
+  if (!targetUrl) {
+    console.warn("\u26A0\uFE0F \u672A\u627E\u5230\u76EE\u6807\u5E93\u8FDE\u63A5\u4E32\uFF08\u5206\u5E93\u9700 ADD_DATABASE_URL / \u5171\u5E93\u9700 DATABASE_URL\uFF09\uFF0C\u8DF3\u8FC7\u540C\u6B65");
+    return;
+  }
+  const bak = await backupBeforeSync(projectRoot, { dbUrl: targetUrl, backupDir: sync.backupDir, backupKeep: sync.backupKeep, yes: opts.yes });
+  if (bak === null) {
+    console.warn("\u26A0\uFE0F \u5907\u4EFD\u672A\u5B8C\u6210\uFF08\u7528\u6237\u81EA\u62C5\u98CE\u9669\uFF09\uFF0C\u7EE7\u7EED\u540C\u6B65");
+  }
+  if (sync.strategy === "db-push") {
+    runDbPush(projectRoot);
+    return;
+  }
+  const atlasBin = resolveAtlasBin(projectRoot);
+  if (atlasBin) {
+    const ok = await runAtlasSync(projectRoot, targetUrl, splitDb, sync, opts);
+    if (ok) return;
+  } else {
+    console.warn("\u26A0\uFE0F atlas \u4E0D\u53EF\u7528\u3002add-coder \u4F9D\u8D56\u81EA\u5E26\uFF1A\u9879\u76EE\u5B89\u88C5 @ariga/atlas\uFF08pnpm add -D @ariga/atlas\uFF09\uFF0C\u6216 npm \u5168\u5C40\u5B89\u88C5");
+    if (!opts.yes) {
+      const a = await ask("\u7EE7\u7EED\u964D\u7EA7 prisma-diff\uFF08\u514D shadow\uFF09\uFF1F[Y/n] ");
+      if (a === "n" || a === "no") throw new Error("\u5DF2\u53D6\u6D88\u540C\u6B65\uFF08atlas \u7F3A\u5931\uFF09");
+    }
+  }
+  runPrismaDiffSync(projectRoot, targetUrl, splitDb);
+}
 function ensurePrismaConfig(projectRoot) {
-  const configPath = resolve3(projectRoot, "prisma.config.ts");
-  writeFileSync3(configPath, [
+  const configPath = resolve5(projectRoot, "prisma.config.ts");
+  writeFileSync5(configPath, [
     'import dotenv from "dotenv";',
     'import { existsSync } from "fs";',
     'for (const f of [".env.development.local", ".env.development", ".env.local", ".env"]) {',
@@ -707,20 +1190,6 @@ function ensurePrismaConfig(projectRoot) {
     "});"
   ].join("\n") + "\n", "utf-8");
 }
-function backupAddTables(projectRoot) {
-  if (!commandExists("pg_dump")) return null;
-  const bak = resolve3(projectRoot, `add-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}.sql`);
-  const r = runCommand("pg_dump", ["--table=AddUser", "--table=DevOperation", "--table=AuditLog", "--if-exists"], {
-    cwd: projectRoot,
-    timeout: 3e4
-  });
-  if (r.stdout.length > 0) {
-    writeFileSync3(bak, r.stdout, "utf-8");
-    console.log(`>>> \u5907\u4EFD ADD \u8868\u5230 ${bak}`);
-    return bak;
-  }
-  return null;
-}
 function runPrismaInit(projectRoot, provider, schemaPath) {
   console.log("\u6267\u884C prisma init ...");
   const pm = detectPm(projectRoot);
@@ -732,10 +1201,10 @@ function runPrismaInit(projectRoot, provider, schemaPath) {
     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)) {
+  if (initResult.status !== 0 || !existsSync9(schemaPath)) {
     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 prismaDir = resolve5(projectRoot, "prisma");
+    if (!existsSync9(prismaDir)) mkdirSync5(prismaDir, { recursive: true });
     const content = `generator client {
   provider = "prisma-client-js"
 }
@@ -744,11 +1213,11 @@ datasource db {
   provider = "${provider}"
 }
 `;
-    writeFileSync3(schemaPath, content, "utf-8");
-    const devEnvPath = resolve3(projectRoot, ".env.development");
-    if (!existsSync7(devEnvPath)) {
+    writeFileSync5(schemaPath, content, "utf-8");
+    const devEnvPath = resolve5(projectRoot, ".env.development");
+    if (!existsSync9(devEnvPath)) {
       const defaultUrl = provider === "sqlite" ? 'DATABASE_URL="file:./data/dev.db"' : '# \u8BF7\u7F16\u8F91\u4E3A\u4F60\u7684\u6570\u636E\u5E93\u8FDE\u63A5\u4FE1\u606F\nDATABASE_URL="postgresql://USER:PASSWORD@HOST:PORT/DB?schema=public"';
-      writeFileSync3(devEnvPath, defaultUrl + "\n", "utf-8");
+      writeFileSync5(devEnvPath, defaultUrl + "\n", "utf-8");
       console.log("\u5DF2\u521B\u5EFA .env.development");
     }
     return false;
@@ -756,18 +1225,18 @@ datasource db {
   return true;
 }
 function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
-  const envPath = resolve3(projectRoot, ".env");
-  const devEnvPath = resolve3(projectRoot, ".env.development");
-  if (existsSync7(envPath)) {
-    const envContent = readFileSync5(envPath, "utf-8");
+  const envPath = resolve5(projectRoot, ".env");
+  const devEnvPath = resolve5(projectRoot, ".env.development");
+  if (existsSync9(envPath)) {
+    const envContent = readFileSync7(envPath, "utf-8");
     const dbUrl = envContent.match(/DATABASE_URL=.*/);
     if (dbUrl) {
-      const existing = existsSync7(devEnvPath) ? readFileSync5(devEnvPath, "utf-8") : "";
+      const existing = existsSync9(devEnvPath) ? readFileSync7(devEnvPath, "utf-8") : "";
       if (!existing.includes("DATABASE_URL=")) {
-        writeFileSync3(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
+        writeFileSync5(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
 `, "utf-8");
       }
-      if (existsSync7(envPath)) unlinkSync(envPath);
+      if (existsSync9(envPath)) unlinkSync(envPath);
       console.log("\u5DF2\u5C06 DATABASE_URL \u8FC1\u79FB\u5230 .env.development");
     }
   }
@@ -776,8 +1245,8 @@ function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
   patchGeneratorOutput(schemaPath);
 }
 function patchGeneratorOutput(schemaPath) {
-  if (!existsSync7(schemaPath)) return;
-  let content = readFileSync5(schemaPath, "utf-8");
+  if (!existsSync9(schemaPath)) return;
+  let content = readFileSync7(schemaPath, "utf-8");
   const genBlock = content.match(/generator\s+\w+\s*\{[\s\S]*?\}/);
   if (!genBlock) {
     content += `
@@ -786,23 +1255,23 @@ generator client {
   output = "../src/generated/prisma"
 }
 `;
-    writeFileSync3(schemaPath, content, "utf-8");
+    writeFileSync5(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");
+  writeFileSync5(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;
-  const prismaDir = resolve3(projectRoot, "prisma");
-  const schemaPath = resolve3(prismaDir, "schema.prisma");
-  const destPath = resolve3(prismaDir, "add.prisma");
+  const prismaDir = resolve5(projectRoot, "prisma");
+  const schemaPath = resolve5(prismaDir, "schema.prisma");
+  const destPath = resolve5(prismaDir, "add.prisma");
   let justInited = false;
-  if (!existsSync7(prismaDir) || !existsSync7(schemaPath)) {
+  if (!existsSync9(prismaDir) || !existsSync9(schemaPath)) {
     if (C.onMissing === "skip") {
       console.log("\u8DF3\u8FC7\uFF1A\u7F3A\u5C11 Prisma");
       return true;
@@ -821,7 +1290,7 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath);
     justInited = true;
   }
-  if (existsSync7(destPath) && !justInited) {
+  if (existsSync9(destPath) && !justInited) {
     if (options.dryRun) {
       console.log("[dry-run] \u5DF2\u6709 add.prisma");
       return true;
@@ -838,8 +1307,8 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
         console.log("\u8986\u76D6");
       } else if (choice === "d") {
         copyFileSync(destPath, destPath + ".bak");
-        console.log("=== \u5F53\u524D\uFF08\u5DF2\u5907\u4EFD\uFF09===\n" + readFileSync5(destPath, "utf-8"));
-        console.log("=== \u6A21\u677F ===\n" + readFileSync5(addPrismaTemplate, "utf-8"));
+        console.log("=== \u5F53\u524D\uFF08\u5DF2\u5907\u4EFD\uFF09===\n" + readFileSync7(destPath, "utf-8"));
+        console.log("=== \u6A21\u677F ===\n" + readFileSync7(addPrismaTemplate, "utf-8"));
         if (await ask("\u786E\u8BA4\u8986\u76D6\uFF1F[y/N] ") !== "y") {
           console.log("\u5DF2\u8DF3\u8FC7");
           return true;
@@ -851,19 +1320,14 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     }
   }
   if (options.dryRun) {
-    console.log("[dry-run] \u5C06\u6267\u884C prisma db push");
+    console.log("[dry-run] \u5C06\u6267\u884C\u6570\u636E\u5E93\u540C\u6B65\uFF08v2 Atlas \u5F15\u64CE\uFF09");
     return true;
   }
   if (!justInited) copyFileSync(addPrismaTemplate, destPath);
   try {
     ensurePrismaConfig(projectRoot);
-    backupAddTables(projectRoot);
-    const pm = detectPm(projectRoot);
-    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 = runCommand(pm, args, { cwd: projectRoot });
-    if (r.status !== 0) throw new Error(`prisma db push \u9000\u51FA\u7801: ${r.status}`);
+    const splitDb = await ensureSplitDb(projectRoot, options);
+    await syncDatabase(projectRoot, { yes: options.yes }, splitDb);
   } catch (err) {
     if (C.onMigrateFail === "keep") {
       console.log("\u8FC1\u79FB\u5931\u8D25\uFF0C\u4FDD\u7559\u6587\u4EF6");
@@ -893,36 +1357,36 @@ ${detail}` : ""}`);
 
 // src/cli/prisma-injector.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname3(__filename2);
-var ADD_PRISMA_TEMPLATE = resolve4(__dirname2, "../templates/core/prisma/add.prisma");
+var __dirname2 = dirname4(__filename2);
+var ADD_PRISMA_TEMPLATE = resolve6(__dirname2, "../templates/core/prisma/add.prisma");
 async function injectPrisma2(projectRoot, options = {}) {
   return injectPrisma(projectRoot, ADD_PRISMA_TEMPLATE, options);
 }
 
 // src/cli/commands/init.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync4 } from "fs";
 import { createHash } from "crypto";
-import { resolve as resolve6 } from "path";
-import { createConnection } from "net";
+import { resolve as resolve8 } from "path";
+import { createConnection as createConnection2 } 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 { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join7, resolve as resolve7 } 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")
+  resolve7(import.meta.dirname, "caijuehub/dps-scoring-rules.toml"),
+  resolve7(import.meta.dirname, "../caijuehub/dps-scoring-rules.toml")
 ];
 function resolveEmbeddingModel() {
-  const tomlPath = TOML_CANDIDATES.find((p) => existsSync8(p));
+  const tomlPath = TOML_CANDIDATES.find((p) => existsSync10(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 cfg = parse2(readFileSync8(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`);
@@ -932,8 +1396,8 @@ function resolveEmbeddingModel() {
 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");
+  const home = process.env.HF_HOME || join7(homedir(), ".cache", "huggingface");
+  return join7(home, "hub");
 }
 function modelCacheName(model) {
   const parts = model.split("/");
@@ -943,7 +1407,7 @@ function modelCacheName(model) {
 }
 function isModelCached(model) {
   const cacheDir = resolveCacheDir();
-  return existsSync8(join5(cacheDir, modelCacheName(model), "snapshots"));
+  return existsSync10(join7(cacheDir, modelCacheName(model), "snapshots"));
 }
 async function ensureEmbeddingModel(options) {
   const force = options?.force ?? false;
@@ -956,8 +1420,8 @@ async function ensureEmbeddingModel(options) {
   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)) {
+  const snapshotsDir = join7(cacheDir, modelCacheName(model), "snapshots");
+  if (!force && existsSync10(snapshotsDir)) {
     return { status: "already-cached", model, cacheDir };
   }
   env.remoteHost = "https://hf-mirror.com";
@@ -1001,6 +1465,7 @@ async function initCommand(options) {
   }
   const result = await renderAndWrite(ctx);
   const dbFail = await deployDatabase(ctx);
+  ensurePortsContract(ctx.projectRoot, ctx.config, !!options.dryRun);
   deployDocs(ctx);
   finalize(ctx, result, dbFail);
   if (!options.dryRun) {
@@ -1054,9 +1519,9 @@ async function resolveContainer(force) {
   if (a !== "" && a !== "1" && a !== "podman") console.log("\u8F93\u5165\u65E0\u6CD5\u8BC6\u522B\uFF0C\u9ED8\u8BA4 podman");
   return "podman";
 }
-function portInUse(port) {
+function portInUse2(port) {
   return new Promise((r) => {
-    const s = createConnection({ port, host: "127.0.0.1" }, () => {
+    const s = createConnection2({ port, host: "127.0.0.1" }, () => {
       s.destroy();
       r(true);
     });
@@ -1098,7 +1563,7 @@ async function resolveDbCredentials(force) {
   let port = (await ask(`DATABASE_PORT [${d.port}]: `)).trim() || d.port;
   while (true) {
     const portNum = parseInt(port);
-    if (!isNaN(portNum) && await portInUse(portNum)) {
+    if (!isNaN(portNum) && await portInUse2(portNum)) {
       console.log(`
 \u26A0\uFE0F  \u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528`);
       const choice = (await ask("  [1] \u6362\u7AEF\u53E3  [2] \u8FDE\u63A5\u5DF2\u6709\u5B9E\u4F8B\uFF08\u8F93\u5165\u5176\u7528\u6237/\u5BC6\u7801\uFF09\u2192 ")).trim();
@@ -1152,8 +1617,8 @@ networks:
 `;
 }
 function writeSqliteExportScript(projectRoot, dryRun) {
-  const scriptsDir = resolve6(projectRoot, "scripts");
-  const scriptPath = resolve6(scriptsDir, "export-db.ts");
+  const scriptsDir = resolve8(projectRoot, "scripts");
+  const scriptPath = resolve8(scriptsDir, "export-db.ts");
   const content = `import { PrismaClient } from "@prisma/client";
 import { writeFileSync, mkdirSync, existsSync } from "fs";
 import { resolve } from "path";
@@ -1177,22 +1642,22 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync9(scriptsDir)) mkdirSync4(scriptsDir, { recursive: true });
-  writeFileSync4(scriptPath, content, "utf-8");
+  if (!existsSync11(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 = resolve6(projectRoot, "package.json");
-  if (!existsSync9(pkgPath)) return;
+  const pkgPath = resolve8(projectRoot, "package.json");
+  if (!existsSync11(pkgPath)) return;
   if (dryRun) {
     console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
     return;
   }
-  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
   if (!pkg.scripts) pkg.scripts = {};
   if (!pkg.scripts["db:export"]) {
     pkg.scripts["db:export"] = "npx tsx scripts/export-db.ts";
-    writeFileSync4(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    writeFileSync6(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
     console.log("\u5DF2\u5728 package.json \u6CE8\u5165 db:export");
   }
 }
@@ -1235,17 +1700,17 @@ 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 = resolve6(projectRoot, composeName);
-    if (!options.dryRun && (!existsSync9(composePath) || options.force)) {
-      writeFileSync4(composePath, composeContent(config.projectName || "add-project"), "utf-8");
+    const composePath = resolve8(projectRoot, composeName);
+    if (!options.dryRun && (!existsSync11(composePath) || options.force)) {
+      writeFileSync6(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
-  const devEnvPath = resolve6(projectRoot, ".env.development");
-  if (!options.dryRun && existsSync9(devEnvPath)) {
-    const existing = readFileSync7(devEnvPath, "utf-8");
+  const devEnvPath = resolve8(projectRoot, ".env.development");
+  if (!options.dryRun && existsSync11(devEnvPath)) {
+    const existing = readFileSync9(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
-      writeFileSync4(devEnvPath, existing + `
+      writeFileSync6(devEnvPath, existing + `
 DATABASE_USER=${db.user || "admin"}
 DATABASE_PASSWORD=${db.password || "change-me-in-production"}
 DATABASE_PORT=${db.port || "5433"}
@@ -1282,12 +1747,12 @@ async function renderAndWrite(ctx) {
     console.log(`claude adapter (via Agent Host): ${claudeFiles.size} \u6587\u4EF6`);
   }
   for (const d of [".add", magicDir]) {
-    const reviewsDir = resolve6(projectRoot, d, "reviews");
-    if (!existsSync9(reviewsDir)) {
+    const reviewsDir = resolve8(projectRoot, d, "reviews");
+    if (!existsSync11(reviewsDir)) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
-        mkdirSync4(reviewsDir, { recursive: true });
+        mkdirSync6(reviewsDir, { recursive: true });
       }
     }
   }
@@ -1295,16 +1760,16 @@ async function renderAndWrite(ctx) {
     const hashMap = {};
     let npmVer = "";
     try {
-      npmVer = JSON.parse(readFileSync7(resolve6(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
+      npmVer = JSON.parse(readFileSync9(resolve8(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 = resolve6(projectRoot, magicDir, ".add-coder-hash.json");
-    writeFileSync4(hashOut, JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
+    const hashOut = resolve8(projectRoot, magicDir, ".add-coder-hash.json");
+    writeFileSync6(hashOut, JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
     if (npmVer) {
-      writeFileSync4(resolve6(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
+      writeFileSync6(resolve8(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
     }
     console.log(`hash: ${Object.keys(hashMap).length} entries \u2192 ${magicDir}/.add-coder-hash.json`);
   }
@@ -1315,7 +1780,7 @@ async function deployDatabase(ctx) {
   if (options.dryRun) return null;
   let fail = null;
   if (db.engine === "postgresql" && db.container && db.container !== "manual") {
-    const dbScript = resolve6(projectRoot, magicDir, "scripts", "db-ensure.sh");
+    const dbScript = resolve8(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}) ...`);
@@ -1333,8 +1798,8 @@ ${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
     }
   }
   if (db.engine === "postgresql" && db.container === "manual") {
-    const dbScript = resolve6(projectRoot, magicDir, "scripts", "db-ensure.sh");
-    if (existsSync9(dbScript)) {
+    const dbScript = resolve8(projectRoot, magicDir, "scripts", "db-ensure.sh");
+    if (existsSync11(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 ? `
@@ -1379,17 +1844,17 @@ function deployDocs(ctx) {
   const { projectRoot, options, config } = ctx;
   if (options.dryRun) return;
   const pn = config.projectName || "add-project";
-  const docsBase = resolve6(projectRoot, "docs", pn, "knowledge");
-  const groundingSrc = resolve6(import.meta.dirname, "../templates/core/templates");
+  const docsBase = resolve8(projectRoot, "docs", pn, "knowledge");
+  const groundingSrc = resolve8(import.meta.dirname, "../templates/core/templates");
   for (const d of ["00-\u9700\u6C42", "01-\u67B6\u6784", "02-\u89C4\u8303"]) {
-    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 = resolve6(srcDir, f);
-      const dest = resolve6(destDir, f);
-      if (existsSync9(dest)) continue;
+    const srcDir = resolve8(groundingSrc, d);
+    const destDir = resolve8(docsBase, d);
+    if (!existsSync11(destDir)) mkdirSync6(destDir, { recursive: true });
+    if (!existsSync11(srcDir)) continue;
+    for (const f of readdirSync4(srcDir)) {
+      const src = resolve8(srcDir, f);
+      const dest = resolve8(destDir, f);
+      if (existsSync11(dest)) continue;
       try {
         copyFileSync2(src, dest);
       } catch {
@@ -1405,7 +1870,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(readFileSync7(resolve6(import.meta.dirname, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync9(resolve8(import.meta.dirname, "../package.json"), "utf-8"));
   const peerNames = Object.keys(pkg.peerDependencies || {});
   if (peerNames.length > 0) {
     console.log(`
@@ -1433,8 +1898,8 @@ function finalize(ctx, result, dbFail) {
 }
 
 // src/cli/commands/sync.ts
-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 { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve9, dirname as dirname5 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/lib/path-normalize.ts
@@ -1492,7 +1957,7 @@ function hash8(c) {
 }
 function loadHashFile(root, magic) {
   try {
-    const raw = JSON.parse(readFileSync8(resolve7(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
+    const raw = JSON.parse(readFileSync10(resolve9(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;
@@ -1502,18 +1967,18 @@ function loadHashFile(root, magic) {
 }
 function loadVersionFile(root, magic) {
   try {
-    return readFileSync8(resolve7(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
+    return readFileSync10(resolve9(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
   } catch {
     return "";
   }
 }
 function saveVersionFile(root, magic, version2) {
-  writeFileSync5(resolve7(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
+  writeFileSync7(resolve9(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] = c;
-  writeFileSync5(resolve7(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
+  writeFileSync7(resolve9(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();
@@ -1586,10 +2051,10 @@ async function syncCommand(options = {}) {
       candidates.set(p, c);
     }
     const outHash = loadHashFile(projectRoot, magicDir);
-    const srcHashPath = resolve7(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json");
+    const srcHashPath = resolve9(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json");
     let npmVersion = "";
     try {
-      npmVersion = JSON.parse(readFileSync8(srcHashPath, "utf-8"))._version ?? "";
+      npmVersion = JSON.parse(readFileSync10(srcHashPath, "utf-8"))._version ?? "";
     } catch {
     }
     const installedVersion = loadVersionFile(projectRoot, magicDir);
@@ -1609,13 +2074,13 @@ async function syncCommand(options = {}) {
     let sameCount = 0;
     for (const [relPath, content] of candidates) {
       const key = normalizeRelPath(relPath);
-      const absPath = resolve7(projectRoot, relPath);
-      if (!existsSync10(absPath)) {
+      const absPath = resolve9(projectRoot, relPath);
+      if (!existsSync12(absPath)) {
         missingFiles.set(key, content);
       } else if (establishBaseline) {
         missingFiles.set(key, content);
       } else {
-        const curH = hash8(readFileSync8(absPath, "utf-8"));
+        const curH = hash8(readFileSync10(absPath, "utf-8"));
         const storedH = outHash[key];
         if (storedH && curH === storedH) {
           sameCount++;
@@ -1643,18 +2108,19 @@ async function syncCommand(options = {}) {
     }
     const finalHash = mergeFullHash(
       outHash,
-      [...candidates].map(([relPath]) => ({ relPath, absPath: resolve7(projectRoot, relPath) })),
-      (absPath) => existsSync10(absPath) ? hash8(readFileSync8(absPath, "utf-8")) : null
+      [...candidates].map(([relPath]) => ({ relPath, absPath: resolve9(projectRoot, relPath) })),
+      (absPath) => existsSync12(absPath) ? hash8(readFileSync10(absPath, "utf-8")) : null
     );
     saveHashFile(projectRoot, magicDir, finalHash);
     saveVersionFile(projectRoot, magicDir, npmVersion);
     await checkPrismaDiff(projectRoot, options);
+    ensurePortsContract(projectRoot, config);
     await maybeModelDownload(options);
     return;
   }
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of allFiles) {
-    if (!existsSync10(resolve7(projectRoot, relPath))) {
+    if (!existsSync12(resolve9(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
@@ -1673,11 +2139,12 @@ 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);
+  ensurePortsContract(projectRoot, config);
   await maybeModelDownload(options);
 }
 function printMigrateGuidance(targetPath, changed) {
   const g = SYNC_PRISMA_CONFIG.POST_SYNC;
-  const isManaged = existsSync10(resolve7(dirname4(targetPath), "migrations"));
+  const isManaged = existsSync12(resolve9(dirname5(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) {
@@ -1697,23 +2164,62 @@ function printMigrateGuidance(targetPath, changed) {
   }
   console.log(`     \u26A0\uFE0F  \u6240\u6709\u573A\u666F\u6536\u5C3E: ${g.FINAL}`);
 }
+async function ensureAtlasCapability(projectRoot) {
+  const bin = resolveAtlasBin(projectRoot);
+  if (bin) {
+    console.log(`   \u2705 Atlas \u80FD\u529B\u5C31\u7EEA: ${bin}`);
+    return;
+  }
+  console.warn("   \u26A0\uFE0F  Atlas \u4E0D\u53EF\u7528\u2014\u2014\u6570\u636E\u5E93\u540C\u6B65\uFF08Atlas diff/apply\uFF09\u80FD\u529B\u7F3A\u5931");
+  const a = await ask("   \u662F\u5426\u81EA\u52A8\u5B89\u88C5 @ariga/atlas\uFF08npm \u4F9D\u8D56\uFF0C\u8D70 registry\uFF09\uFF1F[Y/n] ");
+  if (a === "n" || a === "no") {
+    console.log("   \u5DF2\u8DF3\u8FC7\u3002\u6570\u636E\u5E93\u540C\u6B65\u5C06\u964D\u7EA7 prisma-diff\uFF08\u514D shadow\uFF09\uFF1B\u53EF\u968F\u65F6\u8865\u88C5\u6062\u590D Atlas");
+    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 = existsSync12(resolve9(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) {
+    console.error("   \u5B89\u88C5\u5931\u8D25\u3002\u8BF7\u624B\u52A8\u6267\u884C:");
+    console.error(`     ${pm} add -D @ariga/atlas`);
+    console.error("   pnpm 11 \u6CE8\u610F: \u9700\u5728 pnpm-workspace.yaml allowBuilds \u653E\u884C '@ariga/atlas': true");
+    return;
+  }
+  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 (!existsSync12(script)) return;
+  const content = readFileSync10(script, "utf-8");
+  if (content.includes("atlas_sync")) return;
+  console.warn("   \u26A0\uFE0F  \u5BBF\u4E3B scripts/db-ensure.sh \u672A\u5305\u542B Atlas \u540C\u6B65\u6BB5\uFF08\u65E5\u5E38 db-ensure \u5C06\u7F3A\u5C11 ADD \u6CBB\u7406\u6A21\u578B\u540C\u6B65\uFF09");
+  console.warn("      \u804C\u8D23\u8FB9\u754C: add-coder \u53EA\u540C\u6B65 ADD \u6CBB\u7406\u6A21\u578B(7 \u8868)\uFF1B\u5BBF\u4E3B\u4E1A\u52A1\u8868 diff \u63A8\u8350 Atlas \u4F46\u4E0D\u5F3A\u6C42");
+  console.warn("      \u5408\u5165\u4E09\u6B65\uFF1A");
+  console.warn("        \u2460 \u590D\u5236\u6A21\u677F Atlas \u6A21\u5757\u6BB5: sed -n '/# \u2550\u2550\u2550\u2550 Atlas \u58F0\u660E\u5F0F\u540C\u6B65\u6A21\u5757/,/^fi$/p' node_modules/add-coder/templates/core/scripts/db-ensure.sh");
+  console.warn("        \u2461 \u53D8\u91CF\u9002\u914D\uFF08DB_URL\u2192DATABASE_URL \u7B49\uFF0C\u89C1\u6587\u6863\u53D8\u91CF\u5BF9\u7167\u8868\uFF09");
+  console.warn("        \u2462 \u7C98\u8D34\u5230\u811A\u672C\u672B\u5C3E\uFF08\u8FC1\u79FB/generate \u4E4B\u540E\uFF09\uFF0C\u89E6\u53D1: bash scripts/db-ensure.sh <engine> <container> --migrate");
+  console.warn("      \u5BBF\u4E3B\u4E1A\u52A1\u8868\u63A8\u8350\u505A\u6CD5: \u89C1 DEVELOPMENT.md \xA7\u4E5D 9.5\uFF08\u63A8\u8350 Atlas \u53EF\u9009\uFF1B\u4FDD\u6301 migrate dev/deploy \u4EA6\u53EF\uFF09");
+}
 async function checkPrismaDiff(projectRoot, options) {
   if (!options.patch) return;
-  const basePath = resolve7(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
-  const targetPath = resolve7(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
-  if (!existsSync10(basePath)) {
+  const basePath = resolve9(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
+  const targetPath = resolve9(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
+  if (!existsSync12(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`);
     return;
   }
+  await ensureAtlasCapability(projectRoot);
+  checkHostAtlasSegment(projectRoot);
   const result = diffPrisma(basePath, targetPath);
   if (!result.hasDiff) {
     console.log(`
 \u2705 Prisma schema \u4E0E add-coder \u6807\u51C6\u4E00\u81F4\uFF0C\u65E0\u9700\u540C\u6B65\u3002`);
     return;
   }
-  const targetExists = existsSync10(targetPath);
+  const targetExists = existsSync12(targetPath);
   let modifiedCount = 0;
   console.log(`
 \u26A0\uFE0F  Prisma schema \u5DEE\u5F02\u68C0\u6D4B:`);
@@ -1832,8 +2338,8 @@ async function checkPrismaDiff(projectRoot, options) {
   } else {
     console.log(`
   \u76EE\u6807 schema \u6587\u4EF6\u4E0D\u5B58\u5728: ${result.targetPath}`);
-    mkdirSync5(dirname4(targetPath), { recursive: true });
-    writeFileSync5(targetPath, "// add.prisma \u2014 ADD \u6CBB\u7406\u6A21\u578B\n\n", "utf-8");
+    mkdirSync7(dirname5(targetPath), { recursive: true });
+    writeFileSync7(targetPath, "// add.prisma \u2014 ADD \u6CBB\u7406\u6A21\u578B\n\n", "utf-8");
     const n = injectMissingModels(targetPath, result.missing);
     console.log(`  \u2705 \u5DF2\u521B\u5EFA\u5E76\u6CE8\u5165 ${n} \u4E2A\u6A21\u578B/\u679A\u4E3E`);
     if (n > 0) {
@@ -1864,7 +2370,7 @@ async function handleDiffAction(action, ctx) {
   }
 }
 function injectMissingModels(targetPath, models) {
-  let content = readFileSync8(targetPath, "utf-8");
+  let content = readFileSync10(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)}) =====
@@ -1873,11 +2379,11 @@ function injectMissingModels(targetPath, models) {
   for (const m of models) {
     content += m.body + "\n\n";
   }
-  writeFileSync5(targetPath, content, "utf-8");
+  writeFileSync7(targetPath, content, "utf-8");
   return models.length;
 }
 function getBaseFieldLines(basePath, modelName) {
-  const content = readFileSync8(basePath, "utf-8");
+  const content = readFileSync10(basePath, "utf-8");
   const blocks = parseSchemaBlocks(content);
   const block = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
   if (!block) return {};
@@ -1900,7 +2406,7 @@ function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
     console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A${modelName} \u5728\u57FA\u51C6\u4E2D\u672A\u627E\u5230\u5B57\u6BB5\u5B9A\u4E49\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
     return 0;
   }
-  const content = readFileSync8(targetPath, "utf-8");
+  const content = readFileSync10(targetPath, "utf-8");
   const lines = content.split("\n");
   const blocks = parseSchemaBlocks(content);
   const target = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
@@ -1941,13 +2447,13 @@ function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
     ...newFieldLines,
     ...lines.slice(insertIdx)
   ];
-  writeFileSync5(targetPath, merged.join("\n"), "utf-8");
+  writeFileSync7(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 = readFileSync8(targetPath, "utf-8");
+  let content = readFileSync10(targetPath, "utf-8");
   let count = 0;
   for (const { fieldName } of conflicts) {
     const baseLine = baseFields[fieldName];
@@ -1958,13 +2464,13 @@ function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
     content = content.replace(fieldRegex, `${match[1]}${baseLine}`);
     count++;
   }
-  if (count > 0) writeFileSync5(targetPath, content, "utf-8");
+  if (count > 0) writeFileSync7(targetPath, content, "utf-8");
   return count;
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { resolve as resolve10 } from "path";
 async function statusCommand() {
   const projectRoot = process.cwd();
   const config = await loadConfig(projectRoot);
@@ -1973,7 +2479,7 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync11(resolve8(projectRoot, relPath))) {
+    if (existsSync13(resolve10(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
@@ -1991,8 +2497,8 @@ async function statusCommand() {
 }
 
 // src/cli/commands/stack.ts
-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 { readdirSync as readdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync8, existsSync as existsSync14, mkdirSync as mkdirSync8 } from "fs";
+import { resolve as resolve11, join as join8 } 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";
@@ -2009,14 +2515,14 @@ function resolveMagicDir(projectRoot, specified) {
   return MAGIC_DIR_MAP3[adapter];
 }
 function listCustomProfiles(projectRoot, magicDir, registryNames) {
-  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();
+  const dir = resolve11(projectRoot, magicDir, "rules", "profiles");
+  if (!existsSync14(dir)) return [];
+  return readdirSync5(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 existsSync12(resolve9(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
+  return existsSync14(resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
 }
 function stackCommand(sub, name, options = {}) {
   const projectRoot = process.cwd();
@@ -2053,12 +2559,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 = resolve9(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
-    const stat = existsSync12(profilePath) ? readFileSync9(profilePath, "utf-8").length : 0;
+    const profilePath = resolve11(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
+    const stat = existsSync14(profilePath) ? readFileSync11(profilePath, "utf-8").length : 0;
     console.log(`\u6280\u672F\u6808: ${current}`);
-    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync12(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
+    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync14(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
     try {
-      const raw = JSON.parse(readFileSync9(resolve9(projectRoot, magicDir, "stack.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync11(resolve11(projectRoot, magicDir, "stack.json"), "utf-8"));
       if (raw.updatedAt) console.log(`\u66F4\u65B0\u65F6\u95F4: ${raw.updatedAt}`);
     } catch {
     }
@@ -2083,9 +2589,9 @@ function buildConfig(projectRoot, magicDir, stack) {
     stack
   };
   try {
-    const pkgPath = resolve9(projectRoot, "package.json");
-    if (existsSync12(pkgPath)) {
-      const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+    const pkgPath = resolve11(projectRoot, "package.json");
+    if (existsSync14(pkgPath)) {
+      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
       if (pkg.name) config.projectName = pkg.name;
     }
   } catch {
@@ -2111,15 +2617,15 @@ function applyStack(projectRoot, magicDir, name) {
   }
   const hashMap = {};
   try {
-    Object.assign(hashMap, JSON.parse(readFileSync9(resolve9(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
+    Object.assign(hashMap, JSON.parse(readFileSync11(resolve11(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 = resolve9(projectRoot, relPath.replace(/^\.add/, t));
-      mkdirSync6(join6(targetPath, ".."), { recursive: true });
-      writeFileSync6(targetPath, content, "utf-8");
+      const targetPath = resolve11(projectRoot, relPath.replace(/^\.add/, t));
+      mkdirSync8(join8(targetPath, ".."), { recursive: true });
+      writeFileSync8(targetPath, content, "utf-8");
       hashMap[relPath.replace(/^\.add/, t)] = hash82(content);
       written++;
     }
@@ -2130,24 +2636,24 @@ function applyStack(projectRoot, magicDir, name) {
   };
   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") : "";
+  const profilePathMagic = resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`);
+  const profilePathAdd = resolve11(projectRoot, ".add", "rules", "profiles", `${name}-profile.md`);
+  const projectRulesPath = resolve11(projectRoot, magicDir, "rules", "project_rules.md");
+  const projectRulesContent = existsSync14(projectRulesPath) ? readFileSync11(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 (isBuiltin && !existsSync14(profilePathAdd)) fail(`profile \u672A\u5199\u5165 .add: ${profilePathAdd}`);
+  if (!existsSync14(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");
+  writeFileSync8(resolve11(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 ${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(`   ${magicDir}/rules/profiles/${name}-profile.md ${existsSync14(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(`   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(
-  readFileSync10(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync12(new URL("../package.json", import.meta.url), "utf-8")
 );
 async function modelDownloadCommand(options) {
   try {