add-coder 0.3.26 → 0.3.28

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 import { Command } from "commander";
 
 // src/caijuehub/strategies/detect.strategy.ts
@@ -33,6 +33,13 @@ function detectIDE(projectRoot) {
 }
 
 // src/caijuehub/strategies/adapter.strategy.ts
+var MAGIC_DIR_MAP = {
+  claude: ".claude",
+  qoder: ".qoder",
+  vscode: ".vscode",
+  trae: ".trae",
+  codex: ".codex"
+};
 function resolveAdapters(target) {
   return [target];
 }
@@ -45,6 +52,15 @@ function resolveAdapters2(target) {
   return resolveAdapters(target);
 }
 
+// src/shared/paths.ts
+import { findUpSync } from "find-up";
+var ADD_DIR = ".add";
+function magicDirFor(adapter) {
+  const m = MAGIC_DIR_MAP[adapter];
+  if (!m) throw new Error(`\u672A\u77E5 adapter: ${adapter}`);
+  return m;
+}
+
 // src/cli/config-loader.ts
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { join as join2 } from "path";
@@ -372,8 +388,8 @@ function parseSchemaBlocks(content) {
   return blocks;
 }
 function diffPrisma(basePath, targetPath) {
-  const baseContent = existsSync4(basePath) ? readFileSync3(basePath, "utf-8") : "";
-  const targetContent = existsSync4(targetPath) ? readFileSync3(targetPath, "utf-8") : "";
+  const baseContent = (existsSync4(basePath) ? readFileSync3(basePath, "utf-8") : "").replace(/\r\n/g, "\n");
+  const targetContent = (existsSync4(targetPath) ? readFileSync3(targetPath, "utf-8") : "").replace(/\r\n/g, "\n");
   if (!baseContent) return { hasDiff: false, baseSchema: basePath, targetPath, missing: [], fieldDiffs: [] };
   const baseBlocks = parseSchemaBlocks(baseContent);
   const targetBlocks = parseSchemaBlocks(targetContent);
@@ -425,11 +441,9 @@ function diffPrisma(basePath, targetPath) {
 
 // src/core/renderer.ts
 import { readFileSync as readFileSync4, readdirSync, statSync, existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4, relative, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
+import { join as join4, relative } from "path";
 import { parse } from "smol-toml";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
+var __dirname = import.meta.dirname;
 var PLACEHOLDERS = {
   "{{projectName}}": "projectName",
   "{{projectRoot}}": "projectRoot",
@@ -500,9 +514,14 @@ function render(content, config) {
   result = renderStackPlaceholders(result, config);
   return result;
 }
-var TEMPLATES_ROOT = join4(__dirname, "../templates");
+var TEMPLATES_ROOT = [
+  // Source mode: src/core/renderer.ts → ../../templates
+  join4(__dirname, "../../templates"),
+  // Bundled mode: dist/index.js → ../templates
+  join4(__dirname, "../templates")
+].find(existsSync5) ?? join4(__dirname, "../templates");
 var CORE_DIR = join4(TEMPLATES_ROOT, "core");
-var CORE_TARGET = ".add";
+var CORE_TARGET = ADD_DIR;
 var SKIP_DIRS = /* @__PURE__ */ new Set(["prisma", "profiles"]);
 function loadProfileRegistry() {
   try {
@@ -558,7 +577,7 @@ function renderCore(config, dryRun) {
       const src = join4(CORE_DIR, "rules", "profiles", profile.file);
       if (existsSync5(src)) {
         const rendered = render(readFileSync4(src, "utf-8"), config);
-        files.set(join4(".add", "rules", "profiles", profile.file), rendered);
+        files.set(join4(ADD_DIR, "rules", "profiles", profile.file), rendered);
       }
     }
   }
@@ -567,7 +586,17 @@ function renderCore(config, dryRun) {
   }
   return files;
 }
-function renderAdapterBase(config, magicPath, githubHooksToRoot, dryRun) {
+function renderCoreForTargets(config, dryRun, targets, renderTarget = renderCore) {
+  const files = /* @__PURE__ */ new Map();
+  for (const target of new Set(targets)) {
+    const targetFiles = renderTarget({ ...config, magicDir: target }, dryRun);
+    for (const [relPath, content] of targetFiles) {
+      files.set(relPath.replace(/^\.add/, target), content);
+    }
+  }
+  return files;
+}
+function renderAdapterBase(config, magicPath, githubHooksToRoot, dryRun, includeCoreHooksLib = true) {
   const files = /* @__PURE__ */ new Map();
   const adapterDir = join4(TEMPLATES_ROOT, "adapters", magicPath.replace(".", ""));
   const coreHooksLib = join4(TEMPLATES_ROOT, "core", "hooks", "lib");
@@ -591,8 +620,10 @@ function renderAdapterBase(config, magicPath, githubHooksToRoot, dryRun) {
       }
     }
   }
+  if (includeCoreHooksLib) {
+    walk(coreHooksLib, "", join4(magicPath, "hooks", "lib"));
+  }
   walk(adapterDir, "");
-  walk(coreHooksLib, "", join4(magicPath, "hooks", "lib"));
   if (dryRun) {
     console.log(`[dry-run] ${magicPath} adapter: ${files.size} files`);
   }
@@ -601,34 +632,161 @@ function renderAdapterBase(config, magicPath, githubHooksToRoot, dryRun) {
 
 // src/adapters/claude/renderer.ts
 function renderAdapter(config, targetDir, dryRun, magicDir) {
-  return renderAdapterBase(config, magicDir, magicDir === ".vscode", dryRun);
+  return renderAdapterBase(config, magicDir, magicDir === magicDirFor("vscode"), dryRun, false);
 }
 
 // src/adapters/qoder/renderer.ts
 function renderAdapter2(config, targetDir, dryRun, magicDir) {
-  return renderAdapterBase(config, magicDir, magicDir === ".vscode", dryRun);
+  return renderAdapterBase(config, magicDir, magicDir === magicDirFor("vscode"), dryRun, false);
 }
 
 // src/adapters/vscode/renderer.ts
 function renderAdapter3(config, targetDir, dryRun, magicDir) {
-  return renderAdapterBase(config, magicDir, magicDir === ".vscode", dryRun);
+  return renderAdapterBase(config, magicDir, magicDir === magicDirFor("vscode"), dryRun, false);
 }
 
 // src/adapters/trae/renderer.ts
 function renderAdapter4(config, targetDir, dryRun, magicDir) {
-  return renderAdapterBase(config, magicDir, magicDir === ".vscode", dryRun);
+  return renderAdapterBase(config, magicDir, magicDir === magicDirFor("vscode"), dryRun, false);
 }
 
 // src/adapters/codex/renderer.ts
+import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join5, relative as relative2 } from "path";
+var __dirname2 = import.meta.dirname;
+var CODEX_SERVER_ID = "add_coder";
+function normalizeServerId(name) {
+  return name.replace(/-/g, "_");
+}
+function codexCommandFor(platform) {
+  return platform === "win32" ? "cmd" : "npx";
+}
+function codexLaunchFor(platform, targetDir, magicDir) {
+  const serverPath = join5(targetDir, magicDir, "scripts", "mcp-server.ts");
+  const command = codexCommandFor(platform);
+  const args = platform === "win32" ? ["/c", "npx.cmd", "tsx", serverPath] : ["tsx", serverPath];
+  return { command, args, cwd: targetDir };
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlArray(values) {
+  return `[${values.map(tomlString).join(", ")}]`;
+}
+function renderCodexMcpTemplate(template, targetDir, magicDir, platform = process.platform) {
+  const launch = codexLaunchFor(platform, targetDir, magicDir);
+  return template.replaceAll("{{codexCommandToml}}", tomlString(launch.command)).replaceAll("{{codexArgsToml}}", tomlArray(launch.args)).replaceAll("{{codexProjectRootToml}}", tomlString(launch.cwd));
+}
+function mergeCodexProjectConfig(existing, snippet) {
+  const serverTable = /^\s*\[mcp_servers\.(?:add_coder|["']add_coder["'])\]\s*(?:#.*)?$/m;
+  if (serverTable.test(existing)) return existing;
+  const normalizedSnippet = snippet.trim();
+  if (!existing) return `${normalizedSnippet}
+`;
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  return `${existing}${separator}${normalizedSnippet}
+`;
+}
+function findCoreSkillsDir() {
+  const candidates = [
+    join5(__dirname2, "../../../templates/core/skills"),
+    join5(__dirname2, "../templates/core/skills")
+  ];
+  const found = candidates.find(existsSync6);
+  if (!found) {
+    throw new Error(`[codex adapter] core skills \u771F\u6E90\u7F3A\u5931: ${candidates.join(" | ")}`);
+  }
+  return found;
+}
+function renderCodexSkills(config, skillsRoot = findCoreSkillsDir()) {
+  const files = /* @__PURE__ */ new Map();
+  function walk(dir) {
+    for (const name of readdirSync2(dir).sort()) {
+      const full = join5(dir, name);
+      if (statSync2(full).isDirectory()) {
+        walk(full);
+        continue;
+      }
+      const targetRel = join5(".agents", "skills", relative2(skillsRoot, full));
+      files.set(targetRel, render(readFileSync5(full, "utf-8"), config));
+    }
+  }
+  walk(skillsRoot);
+  return files;
+}
 function renderAdapter5(config, targetDir, dryRun, magicDir) {
-  return renderAdapterBase(config, magicDir, magicDir === ".vscode", dryRun);
+  const files = renderAdapterBase(config, magicDir, magicDir === magicDirFor("vscode"), dryRun, false);
+  const examplePath = join5(magicDir, "config.toml.example");
+  const projectConfigPath = join5(magicDir, "config.toml");
+  const example = files.get(examplePath);
+  if (!example) {
+    throw new Error(`[codex adapter] MCP \u914D\u7F6E\u6A21\u677F\u7F3A\u5931: ${examplePath}`);
+  }
+  const snippet = renderCodexMcpTemplate(example, targetDir, magicDir);
+  files.set(examplePath, snippet);
+  const existingPath = join5(targetDir, projectConfigPath);
+  const existing = existsSync6(existingPath) ? readFileSync5(existingPath, "utf-8") : "";
+  files.set(projectConfigPath, mergeCodexProjectConfig(existing, snippet));
+  for (const [relPath, content] of renderCodexSkills(config)) {
+    files.set(relPath, content);
+  }
+  if (!files.has(join5(".agents", "skills", "add-paradigm", "SKILL.md"))) {
+    throw new Error("[codex adapter] add-paradigm \u672A\u6620\u5C04\u5230 .agents/skills");
+  }
+  if (!files.has(join5(".agents", "skills", "session-init", "SKILL.md"))) {
+    throw new Error("[codex adapter] session-init \u672A\u6620\u5C04\u5230 .agents/skills");
+  }
+  if (normalizeServerId("add-coder") !== CODEX_SERVER_ID || !snippet.includes(`[mcp_servers.${CODEX_SERVER_ID}]`)) {
+    throw new Error(`[codex adapter] MCP server id \u6F02\u79FB: ${CODEX_SERVER_ID}`);
+  }
+  return files;
 }
 
 // src/lib/utils.ts
 import { createInterface as createInterface2 } from "readline";
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve2 } from "path";
-function ask(q) {
+var pipeQueue = null;
+var pipeReady = null;
+function collectPipeAnswers(input) {
+  return new Promise((resolveAnswers) => {
+    const answers = [];
+    let buffer = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      if (buffer.trim()) answers.push(buffer.trim());
+      resolveAnswers(answers);
+    };
+    input.setEncoding("utf-8");
+    input.on("data", (chunk) => {
+      buffer += chunk;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      answers.push(...lines.filter((line) => line.trim() !== ""));
+    });
+    input.once("end", finish);
+    input.once("error", finish);
+    input.resume();
+  });
+}
+function takePipeAnswer(queue) {
+  return (queue.shift() ?? "").trim().toLowerCase();
+}
+function ensurePipeQueue() {
+  if (pipeReady) return pipeReady;
+  if (process.stdin.isTTY) return pipeReady = Promise.resolve();
+  pipeReady = collectPipeAnswers(process.stdin).then((answers) => {
+    pipeQueue = answers;
+  });
+  return pipeReady;
+}
+async function ask(q) {
+  await ensurePipeQueue();
+  if (pipeQueue) {
+    return takePipeAnswer(pipeQueue);
+  }
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
   return new Promise((r) => {
     rl.question(q, (a) => {
@@ -638,16 +796,15 @@ function ask(q) {
   });
 }
 function detectPm(projectRoot) {
-  return existsSync6(resolve2(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  return existsSync7(resolve2(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
 }
 
 // src/cli/prisma-injector.ts
-import { resolve as resolve6, dirname as dirname4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { resolve as resolve6 } from "path";
 
 // src/caijuehub/strategies/prisma.strategy.ts
-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";
+import { copyFileSync, existsSync as existsSync10, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
+import { resolve as resolve5, join as join7, dirname as dirname2 } from "path";
 
 // src/lib/run-command.ts
 import { spawnSync } from "child_process";
@@ -678,32 +835,32 @@ function commandExists(cmd, platform) {
 }
 
 // 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";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3, readdirSync as readdirSync3, rmSync } from "fs";
+import { join as join6, 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;
+  if (!existsSync8(gitignorePath)) return;
+  const content = readFileSync6(gitignorePath, "utf-8");
+  if (content.includes(`${ADD_DIR}/backups/`)) return;
   writeFileSync3(gitignorePath, `${content}${content.endsWith("\n") ? "" : "\n"}
 # add-coder \u6570\u636E\u5E93\u540C\u6B65\u5907\u4EFD
-.add/backups/
+${ADD_DIR}/backups/
 `, "utf-8");
-  console.log("\u{1F4CB} \u5DF2\u6CE8\u5165\u5BBF\u4E3B .gitignore: .add/backups/");
+  console.log(`\u{1F4CB} \u5DF2\u6CE8\u5165\u5BBF\u4E3B .gitignore: ${ADD_DIR}/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);
+  const bakDir = join6(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}`);
+    if (!existsSync8(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");
+    const copy = join6(bakDir, "dev.db");
+    writeFileSync3(copy, readFileSync6(dbFile), "utf-8");
+    writeFileSync3(join6(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;
@@ -712,8 +869,8 @@ async function backupBeforeSync(projectRoot, opts) {
     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 schemaFile = join6(bakDir, "schema.sql");
+  const tablesFile = join6(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(" | ")}`);
@@ -724,7 +881,7 @@ async function backupBeforeSync(projectRoot, opts) {
     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");
+  writeFileSync3(join6(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;
@@ -742,17 +899,17 @@ async function handleBackupFailure(opts, reason) {
   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();
+  if (!existsSync8(dir)) return;
+  const entries = readdirSync3(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 });
+    rmSync(join6(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 { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync4 } from "fs";
 import { resolve as resolve4, basename } from "path";
 
 // src/caijuehub/strategies/ports.strategy.ts
@@ -773,10 +930,10 @@ 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;
+  if (existsSync9(target)) return;
   let content;
   try {
-    content = readFileSync6(resolve4(import.meta.dirname, PORTS_EXAMPLE_REL), "utf-8");
+    content = readFileSync7(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;
@@ -809,22 +966,22 @@ function parseContractPorts(content) {
 }
 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")));
+  if (!existsSync9(p)) return /* @__PURE__ */ new Set();
+  return new Set(parseContractPorts(readFileSync7(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);
+    names = readdirSync4(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));
+    if (existsSync9(p)) {
+      parseContractPorts(readFileSync7(p, "utf-8")).forEach((x) => ports.add(x));
     }
   }
   return ports;
@@ -843,11 +1000,11 @@ function scanPodmanPorts() {
 }
 function registerPort(projectRoot, port, svc) {
   const contract = resolve4(projectRoot, "docs", "ports.md");
-  if (!existsSync8(contract)) return;
+  if (!existsSync9(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");
+  writeFileSync4(contract, readFileSync7(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) {
@@ -897,13 +1054,13 @@ var PRISMA_CONFIG = {
 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"));
+  if (!existsSync10(envPath)) return "";
+  const m = readFileSync8(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") : "";
+  const existing = existsSync10(envPath) ? readFileSync8(envPath, "utf-8") : "";
   if (new RegExp(`^${key}=`, "m").test(existing)) return;
   writeFileSync5(envPath, `${existing}${existing.endsWith("\n") ? "" : "\n"}${key}=${value}
 `, "utf-8");
@@ -956,8 +1113,8 @@ async function ensureSplitDb(projectRoot, opts) {
   }
   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 (existsSync10(addPrismaPath)) {
+    const content = readFileSync8(addPrismaPath, "utf-8");
     if (!content.includes("datasource db")) {
       writeFileSync5(addPrismaPath, `datasource db {
   provider = "postgresql"
@@ -1023,9 +1180,9 @@ async function provisionDevUrl(projectRoot) {
 }
 function resolveAtlasBin(projectRoot) {
   const pkgBin = resolve5(projectRoot, "node_modules", "add-coder", "node_modules", ".bin", "atlas");
-  if (existsSync9(pkgBin)) return pkgBin;
+  if (existsSync10(pkgBin)) return pkgBin;
   const local = resolve5(projectRoot, "node_modules", ".bin", "atlas");
-  if (existsSync9(local)) return local;
+  if (existsSync10(local)) return local;
   return commandExists("atlas") ? "atlas" : null;
 }
 function hasNonAddTableChanges(diffSql) {
@@ -1061,8 +1218,8 @@ function buildExcludeArgs(projectRoot, splitDb) {
 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 baselinePath = join7(projectRoot, PRISMA_CONFIG.sync.backupDir, "baseline.sql");
+  mkdirSync5(dirname2(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`);
@@ -1120,8 +1277,8 @@ async function runAtlasSync(projectRoot, targetUrl, splitDb, sync, opts) {
 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 diffPath = join7(projectRoot, PRISMA_CONFIG.sync.backupDir, "diff.sql");
+  mkdirSync5(dirname2(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");
@@ -1198,10 +1355,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 || !existsSync9(schemaPath)) {
+  if (initResult.status !== 0 || !existsSync10(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 = resolve5(projectRoot, "prisma");
-    if (!existsSync9(prismaDir)) mkdirSync5(prismaDir, { recursive: true });
+    if (!existsSync10(prismaDir)) mkdirSync5(prismaDir, { recursive: true });
     const content = `generator client {
   provider = "prisma-client-js"
 }
@@ -1212,7 +1369,7 @@ datasource db {
 `;
     writeFileSync5(schemaPath, content, "utf-8");
     const devEnvPath = resolve5(projectRoot, ".env.development");
-    if (!existsSync9(devEnvPath)) {
+    if (!existsSync10(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"';
       writeFileSync5(devEnvPath, defaultUrl + "\n", "utf-8");
       console.log("\u5DF2\u521B\u5EFA .env.development");
@@ -1224,16 +1381,16 @@ datasource db {
 function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
   const envPath = resolve5(projectRoot, ".env");
   const devEnvPath = resolve5(projectRoot, ".env.development");
-  if (existsSync9(envPath)) {
-    const envContent = readFileSync7(envPath, "utf-8");
+  if (existsSync10(envPath)) {
+    const envContent = readFileSync8(envPath, "utf-8");
     const dbUrl = envContent.match(/DATABASE_URL=.*/);
     if (dbUrl) {
-      const existing = existsSync9(devEnvPath) ? readFileSync7(devEnvPath, "utf-8") : "";
+      const existing = existsSync10(devEnvPath) ? readFileSync8(devEnvPath, "utf-8") : "";
       if (!existing.includes("DATABASE_URL=")) {
         writeFileSync5(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
 `, "utf-8");
       }
-      if (existsSync9(envPath)) unlinkSync(envPath);
+      if (existsSync10(envPath)) unlinkSync(envPath);
       console.log("\u5DF2\u5C06 DATABASE_URL \u8FC1\u79FB\u5230 .env.development");
     }
   }
@@ -1242,8 +1399,8 @@ function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
   patchGeneratorOutput(schemaPath);
 }
 function patchGeneratorOutput(schemaPath) {
-  if (!existsSync9(schemaPath)) return;
-  let content = readFileSync7(schemaPath, "utf-8");
+  if (!existsSync10(schemaPath)) return;
+  let content = readFileSync8(schemaPath, "utf-8");
   const genBlock = content.match(/generator\s+\w+\s*\{[\s\S]*?\}/);
   if (!genBlock) {
     content += `
@@ -1268,7 +1425,7 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
   const schemaPath = resolve5(prismaDir, "schema.prisma");
   const destPath = resolve5(prismaDir, "add.prisma");
   let justInited = false;
-  if (!existsSync9(prismaDir) || !existsSync9(schemaPath)) {
+  if (!existsSync10(prismaDir) || !existsSync10(schemaPath)) {
     if (C.onMissing === "skip") {
       console.log("\u8DF3\u8FC7\uFF1A\u7F3A\u5C11 Prisma");
       return true;
@@ -1287,7 +1444,7 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath);
     justInited = true;
   }
-  if (existsSync9(destPath) && !justInited) {
+  if (existsSync10(destPath) && !justInited) {
     if (options.dryRun) {
       console.log("[dry-run] \u5DF2\u6709 add.prisma");
       return true;
@@ -1304,8 +1461,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" + readFileSync7(destPath, "utf-8"));
-        console.log("=== \u6A21\u677F ===\n" + readFileSync7(addPrismaTemplate, "utf-8"));
+        console.log("=== \u5F53\u524D\uFF08\u5DF2\u5907\u4EFD\uFF09===\n" + readFileSync8(destPath, "utf-8"));
+        console.log("=== \u6A21\u677F ===\n" + readFileSync8(addPrismaTemplate, "utf-8"));
         if (await ask("\u786E\u8BA4\u8986\u76D6\uFF1F[y/N] ") !== "y") {
           console.log("\u5DF2\u8DF3\u8FC7");
           return true;
@@ -1353,22 +1510,22 @@ ${detail}` : ""}`);
 }
 
 // src/cli/prisma-injector.ts
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname4(__filename2);
-var ADD_PRISMA_TEMPLATE = resolve6(__dirname2, "../templates/core/prisma/add.prisma");
+var __dirname3 = import.meta.dirname;
+var ADD_PRISMA_TEMPLATE = resolve6(__dirname3, "../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 readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync4 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync12, mkdirSync as mkdirSync6, copyFileSync as copyFileSync2, readdirSync as readdirSync5 } from "fs";
 import { createHash } from "crypto";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve8, dirname as dirname3, join as pathJoin } from "path";
+import { homedir as homedir2 } from "os";
 import { createConnection as createConnection2 } from "net";
 
 // src/lib/model-predownload.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { join as join7, resolve as resolve7 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { join as join8, resolve as resolve7 } from "path";
 import { homedir } from "os";
 import { parse as parse2 } from "smol-toml";
 var DEFAULT_DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -1377,13 +1534,13 @@ var TOML_CANDIDATES = [
   resolve7(import.meta.dirname, "../caijuehub/dps-scoring-rules.toml")
 ];
 function resolveEmbeddingModel() {
-  const tomlPath = TOML_CANDIDATES.find((p) => existsSync10(p));
+  const tomlPath = TOML_CANDIDATES.find((p) => existsSync11(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(readFileSync8(tomlPath, "utf-8"));
+  const cfg = parse2(readFileSync9(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`);
@@ -1393,8 +1550,8 @@ function resolveEmbeddingModel() {
 function resolveCacheDir() {
   const hubCache = process.env.HF_HUB_CACHE;
   if (hubCache) return hubCache;
-  const home = process.env.HF_HOME || join7(homedir(), ".cache", "huggingface");
-  return join7(home, "hub");
+  const home = process.env.HF_HOME || join8(homedir(), ".cache", "huggingface");
+  return join8(home, "hub");
 }
 function modelCacheName(model) {
   const parts = model.split("/");
@@ -1404,7 +1561,7 @@ function modelCacheName(model) {
 }
 function isModelCached(model) {
   const cacheDir = resolveCacheDir();
-  return existsSync10(join7(cacheDir, modelCacheName(model), "snapshots"));
+  return existsSync11(join8(cacheDir, modelCacheName(model), "snapshots"));
 }
 async function ensureEmbeddingModel(options) {
   const force = options?.force ?? false;
@@ -1417,8 +1574,8 @@ async function ensureEmbeddingModel(options) {
   const { pipeline, env } = await import("@huggingface/transformers");
   env.cacheDir = resolveCacheDir();
   const cacheDir = env.cacheDir;
-  const snapshotsDir = join7(cacheDir, modelCacheName(model), "snapshots");
-  if (!force && existsSync10(snapshotsDir)) {
+  const snapshotsDir = join8(cacheDir, modelCacheName(model), "snapshots");
+  if (!force && existsSync11(snapshotsDir)) {
     return { status: "already-cached", model, cacheDir };
   }
   env.remoteHost = "https://hf-mirror.com";
@@ -1450,8 +1607,17 @@ var ADAPTER_RENDERERS = {
   trae: renderAdapter4,
   codex: renderAdapter5
 };
-var MAGIC_DIR_MAP = { claude: ".claude", qoder: ".qoder", vscode: ".vscode", trae: ".trae", codex: ".codex" };
+function coreTargetsForAdapter(target, magicDir) {
+  return target === "codex" ? [magicDir] : [ADD_DIR, magicDir];
+}
+function needsClaudeAgentHost(adapters) {
+  return adapters.includes("vscode") || adapters.includes("trae");
+}
 async function initCommand(options) {
+  if (options.printMcpConfig || options.writeUserConfig) {
+    await handleCodexMcpConfig(options);
+    return;
+  }
   const ctx = await prepare(options);
   writeComposeEnv(ctx);
   if (!options.dryRun) {
@@ -1474,9 +1640,54 @@ async function initCommand(options) {
     }
   }
 }
+async function handleCodexMcpConfig(options) {
+  const projectRoot = process.cwd();
+  const magicDir = magicDirFor(options.adapter ?? "codex");
+  const config = await loadConfig(projectRoot, options.config, { force: true });
+  config.projectRoot = projectRoot;
+  config.magicDir = magicDir;
+  const files = renderAdapter5(config, projectRoot, !!options.dryRun, magicDir);
+  const tomlEntry = [...files.entries()].find(
+    ([rel]) => rel.endsWith("config.toml.example") || rel.endsWith("config.toml")
+  );
+  if (!tomlEntry) {
+    console.error("\u2717 config.toml \u6E32\u67D3\u4EA7\u7269\u7F3A\u5931\uFF08\u68C0\u67E5 templates/adapters/codex/config.toml.example\uFF09");
+    process.exit(1);
+  }
+  const toml = tomlEntry[1];
+  if (options.printMcpConfig) {
+    console.log("\n# \u5C06\u4EE5\u4E0B\u7247\u6BB5\u7C98\u8D34\u5230 ~/.codex/config.toml\uFF08\u6216\u4F7F\u7528 --write-user-config \u81EA\u52A8\u5199\u5165\uFF09");
+    console.log(toml);
+  }
+  if (options.writeUserConfig) {
+    const userConfigPath = pathJoin(homedir2(), ".codex", "config.toml");
+    if (options.dryRun) {
+      console.log(`[dry-run] \u5C06\u5199\u5165 ${userConfigPath}`);
+      return;
+    }
+    if (existsSync12(userConfigPath) && readFileSync10(userConfigPath, "utf-8").includes("mcp_servers.add_coder")) {
+      console.log(`\u26A0\uFE0F ${userConfigPath} \u5DF2\u5B58\u5728 mcp_servers.add_coder \u914D\u7F6E\uFF0C\u8DF3\u8FC7\uFF08\u907F\u514D\u91CD\u590D\uFF09`);
+      return;
+    }
+    const answer = await ask(`\u5199\u5165 ${userConfigPath}\uFF1F\uFF08y/N\uFF09 \u2192 `);
+    if (answer.trim().toLowerCase() !== "y") {
+      console.log("\u5DF2\u53D6\u6D88\u5199\u5165");
+      return;
+    }
+    if (existsSync12(userConfigPath)) {
+      const backup = `${userConfigPath}.bak-${Date.now()}`;
+      copyFileSync2(userConfigPath, backup);
+      console.log(`\u5DF2\u5907\u4EFD\u539F\u914D\u7F6E \u2192 ${backup}`);
+    }
+    mkdirSync6(dirname3(userConfigPath), { recursive: true });
+    writeFileSync6(userConfigPath, `
+${toml}`, { flag: "a" });
+    console.log(`\u2705 \u5DF2\u5199\u5165 ${userConfigPath}\uFF0C\u91CD\u542F Codex \u751F\u6548`);
+  }
+}
 async function resolveAdapter(projectRoot, specified) {
   if (specified) {
-    if (!MAGIC_DIR_MAP[specified]) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
+    if (!magicDirFor(specified)) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
     console.log(`\u76EE\u6807 IDE: ${specified} (--adapter)`);
     return specified;
   }
@@ -1639,18 +1850,18 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync11(scriptsDir)) mkdirSync6(scriptsDir, { recursive: true });
+  if (!existsSync12(scriptsDir)) mkdirSync6(scriptsDir, { recursive: true });
   writeFileSync6(scriptPath, content, "utf-8");
   console.log("\u5DF2\u751F\u6210 scripts/export-db.ts");
 }
 function injectDbExportScript(projectRoot, dryRun) {
   const pkgPath = resolve8(projectRoot, "package.json");
-  if (!existsSync11(pkgPath)) return;
+  if (!existsSync12(pkgPath)) return;
   if (dryRun) {
     console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
     return;
   }
-  const pkg = JSON.parse(readFileSync9(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync10(pkgPath, "utf-8"));
   if (!pkg.scripts) pkg.scripts = {};
   if (!pkg.scripts["db:export"]) {
     pkg.scripts["db:export"] = "npx tsx scripts/export-db.ts";
@@ -1677,7 +1888,7 @@ async function resolveStack(options) {
 async function prepare(options) {
   const projectRoot = process.cwd();
   const target = await resolveAdapter(projectRoot, options.adapter);
-  const magicDir = MAGIC_DIR_MAP[target];
+  const magicDir = magicDirFor(target);
   const config = await loadConfig(projectRoot, options.config, { force: options.force });
   config.projectRoot = projectRoot;
   config.magicDir = magicDir;
@@ -1698,14 +1909,14 @@ function writeComposeEnv(ctx) {
   if (!db.reuseExisting) {
     const composeName = db.container === "podman" ? "podman-compose.add.yml" : "docker-compose.add.yml";
     const composePath = resolve8(projectRoot, composeName);
-    if (!options.dryRun && (!existsSync11(composePath) || options.force)) {
+    if (!options.dryRun && (!existsSync12(composePath) || options.force)) {
       writeFileSync6(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
   const devEnvPath = resolve8(projectRoot, ".env.development");
-  if (!options.dryRun && existsSync11(devEnvPath)) {
-    const existing = readFileSync9(devEnvPath, "utf-8");
+  if (!options.dryRun && existsSync12(devEnvPath)) {
+    const existing = readFileSync10(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
       writeFileSync6(devEnvPath, existing + `
 DATABASE_USER=${db.user || "admin"}
@@ -1720,32 +1931,39 @@ PROJECT_NAME=${config.projectName || "add-project"}
 async function renderAndWrite(ctx) {
   const { projectRoot, options, magicDir, config, target } = ctx;
   const dry = !!options.dryRun;
-  const coreFiles = renderCore(config, dry);
-  console.log(`Core \u6A21\u677F: ${coreFiles.size} \u6587\u4EF6`);
-  const allFiles = /* @__PURE__ */ new Map();
-  for (const [relPath, content] of coreFiles) {
-    for (const t of [".add", magicDir]) {
-      const targetPath = relPath.replace(/^\.add/, t);
-      if (!allFiles.has(targetPath)) allFiles.set(targetPath, content);
-    }
-  }
+  const coreTargets = coreTargetsForAdapter(target, magicDir);
+  const allFiles = renderCoreForTargets(config, dry, coreTargets);
+  console.log(`Core \u6A21\u677F: ${allFiles.size} \u4E2A\u5E76\u5217\u76EE\u6807\u6587\u4EF6`);
   const resolved = resolveAdapters2(target);
   for (const adapter of resolved) {
     const renderFn = ADAPTER_RENDERERS[adapter];
     if (renderFn) {
-      const adapterFiles = renderFn(config, projectRoot, dry, magicDir);
+      const adapterMagicDir = magicDirFor(adapter);
+      const adapterFiles = renderFn(
+        { ...config, magicDir: adapterMagicDir },
+        projectRoot,
+        dry,
+        adapterMagicDir
+      );
       for (const [p, c] of adapterFiles) allFiles.set(p, c);
       console.log(`${adapter} adapter: ${adapterFiles.size} \u6587\u4EF6`);
     }
   }
-  if (resolved.includes("vscode") || resolved.includes("trae") || resolved.includes("codex")) {
-    const claudeFiles = renderAdapter(config, projectRoot, dry, ".claude");
+  if (needsClaudeAgentHost(resolved)) {
+    const claudeMagicDir = magicDirFor("claude");
+    const claudeFiles = renderAdapter(
+      { ...config, magicDir: claudeMagicDir },
+      projectRoot,
+      dry,
+      claudeMagicDir
+    );
     for (const [p, c] of claudeFiles) allFiles.set(p, c);
     console.log(`claude adapter (via Agent Host): ${claudeFiles.size} \u6587\u4EF6`);
   }
-  for (const d of [".add", magicDir]) {
+  const reviewTargets = target === "codex" ? [magicDir] : [ADD_DIR, magicDir];
+  for (const d of reviewTargets) {
     const reviewsDir = resolve8(projectRoot, d, "reviews");
-    if (!existsSync11(reviewsDir)) {
+    if (!existsSync12(reviewsDir)) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
@@ -1757,7 +1975,7 @@ async function renderAndWrite(ctx) {
     const hashMap = {};
     let npmVer = "";
     try {
-      npmVer = JSON.parse(readFileSync9(resolve8(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
+      npmVer = JSON.parse(readFileSync10(resolve8(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
     } catch {
     }
     for (const [rp, c] of allFiles) {
@@ -1796,7 +2014,7 @@ ${bashRun.stderr.trim().split("\n").slice(0, 5).join("\n")}` : ""}`;
   }
   if (db.engine === "postgresql" && db.container === "manual") {
     const dbScript = resolve8(projectRoot, magicDir, "scripts", "db-ensure.sh");
-    if (existsSync11(dbScript)) {
+    if (existsSync12(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 ? `
@@ -1846,12 +2064,12 @@ function deployDocs(ctx) {
   for (const d of ["00-\u9700\u6C42", "01-\u67B6\u6784", "02-\u89C4\u8303"]) {
     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)) {
+    if (!existsSync12(destDir)) mkdirSync6(destDir, { recursive: true });
+    if (!existsSync12(srcDir)) continue;
+    for (const f of readdirSync5(srcDir)) {
       const src = resolve8(srcDir, f);
       const dest = resolve8(destDir, f);
-      if (existsSync11(dest)) continue;
+      if (existsSync12(dest)) continue;
       try {
         copyFileSync2(src, dest);
       } catch {
@@ -1867,7 +2085,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(readFileSync9(resolve8(import.meta.dirname, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync10(resolve8(import.meta.dirname, "../package.json"), "utf-8"));
   const peerNames = Object.keys(pkg.peerDependencies || {});
   if (peerNames.length > 0) {
     console.log(`
@@ -1895,8 +2113,8 @@ function finalize(ctx, result, dbFail) {
 }
 
 // src/cli/commands/sync.ts
-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 { existsSync as existsSync13, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
+import { resolve as resolve9, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/lib/path-normalize.ts
@@ -1931,10 +2149,9 @@ var ADAPTER_RENDERERS2 = {
   trae: renderAdapter4,
   codex: renderAdapter5
 };
-var MAGIC_DIR_MAP2 = { claude: ".claude", qoder: ".qoder", vscode: ".vscode", trae: ".trae", codex: ".codex" };
 function resolveAdapter2(projectRoot, specified) {
   if (specified) {
-    if (!MAGIC_DIR_MAP2[specified]) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
+    if (!magicDirFor(specified)) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
     console.log(`\u76EE\u6807 IDE: ${specified} (--adapter)`);
     return specified;
   }
@@ -1952,9 +2169,25 @@ function isUserData(p) {
 function hash8(c) {
   return createHash2("sha256").update(c).digest("hex").slice(0, SYNC_CONFIG.HASH_HEX_LENGTH);
 }
+function classifyPatchCandidate(currentContent, incomingContent, storedHash) {
+  const currentHash = hash8(currentContent);
+  if (currentHash === hash8(incomingContent)) return "same";
+  if (storedHash && currentHash === storedHash) return "update";
+  return "conflict";
+}
+function coreTargetsForAdapter2(target, magicDir = magicDirFor(target)) {
+  return target === "codex" ? [magicDir] : [ADD_DIR, magicDir];
+}
+function needsClaudeAgentHost2(adapters) {
+  return adapters.includes("vscode") || adapters.includes("trae");
+}
+function resolvePatchConflictMode(yes = false, isTTY = Boolean(process.stdin.isTTY)) {
+  if (yes) return "all";
+  return isTTY ? "interactive" : "skip";
+}
 function loadHashFile(root, magic) {
   try {
-    const raw = JSON.parse(readFileSync10(resolve9(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
+    const raw = JSON.parse(readFileSync11(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;
@@ -1964,7 +2197,7 @@ function loadHashFile(root, magic) {
 }
 function loadVersionFile(root, magic) {
   try {
-    return readFileSync10(resolve9(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
+    return readFileSync11(resolve9(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
   } catch {
     return "";
   }
@@ -1972,21 +2205,40 @@ function loadVersionFile(root, magic) {
 function saveVersionFile(root, magic, version2) {
   writeFileSync7(resolve9(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
 }
+function loadTemplateVersion(root) {
+  const candidates = [
+    resolve9(root, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"),
+    resolve9(import.meta.dirname, "../templates/.add-coder-src-hash.json"),
+    resolve9(import.meta.dirname, "../../../templates/.add-coder-src-hash.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(readFileSync11(candidate, "utf-8"))._version ?? "";
+    } catch {
+    }
+  }
+  return "";
+}
 function saveHashFile(root, magic, files) {
   const m = {};
   for (const [p, c] of files) m[p] = c;
   writeFileSync7(resolve9(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
 }
-function mergeFullHash(outHash, candidates, readDiskHash) {
+function mergeFullHash(outHash, candidates, readDiskHash, preserveKeys = /* @__PURE__ */ new Set()) {
   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);
+    if (preserveKeys.has(key)) continue;
     const h = readDiskHash(absPath);
     if (h !== null) finalHash.set(key, h);
   }
   return finalHash;
 }
+function pruneHashToCandidates(hashes, candidatePaths) {
+  const allowed = new Set([...candidatePaths].map(normalizeRelPath));
+  return new Map([...hashes].filter(([key]) => allowed.has(normalizeRelPath(key))));
+}
 async function maybeModelDownload(options) {
   let model;
   try {
@@ -2010,30 +2262,35 @@ async function maybeModelDownload(options) {
 async function syncCommand(options = {}) {
   const projectRoot = process.cwd();
   const target = resolveAdapter2(projectRoot, options.adapter);
-  const magicDir = MAGIC_DIR_MAP2[target];
+  const magicDir = magicDirFor(target);
   const config = await loadConfig(projectRoot);
   config.projectRoot = projectRoot;
   config.magicDir = magicDir;
-  const coreFiles = renderCore(config, false);
-  const CORE_TARGETS = [".add", magicDir];
-  const allFiles = /* @__PURE__ */ new Map();
-  for (const [relPath, content] of coreFiles) {
-    for (const t of CORE_TARGETS) {
-      const targetPath = relPath.replace(/^\.add/, t);
-      if (!allFiles.has(targetPath)) allFiles.set(targetPath, content);
-    }
-  }
+  const coreTargets = coreTargetsForAdapter2(target, magicDir);
+  const allFiles = renderCoreForTargets(config, false, coreTargets);
   const resolved = resolveAdapters2(target);
   for (const adapter of resolved) {
     const renderFn = ADAPTER_RENDERERS2[adapter];
     if (renderFn) {
-      const adapterFiles = renderFn(config, projectRoot, false, magicDir);
+      const adapterMagicDir = magicDirFor(adapter);
+      const adapterFiles = renderFn(
+        { ...config, magicDir: adapterMagicDir },
+        projectRoot,
+        false,
+        adapterMagicDir
+      );
       for (const [p, c] of adapterFiles) allFiles.set(p, c);
       console.log(`${adapter} adapter: ${adapterFiles.size} \u6587\u4EF6`);
     }
   }
-  if (resolved.includes("vscode") || resolved.includes("trae") || resolved.includes("codex")) {
-    const claudeFiles = renderAdapter(config, projectRoot, false, ".claude");
+  if (needsClaudeAgentHost2(resolved)) {
+    const claudeMagicDir = magicDirFor("claude");
+    const claudeFiles = renderAdapter(
+      { ...config, magicDir: claudeMagicDir },
+      projectRoot,
+      false,
+      claudeMagicDir
+    );
     for (const [p, c] of claudeFiles) allFiles.set(p, c);
     console.log(`claude adapter (via Agent Host): ${claudeFiles.size} \u6587\u4EF6`);
   }
@@ -2048,12 +2305,7 @@ async function syncCommand(options = {}) {
       candidates.set(p, c);
     }
     const outHash = loadHashFile(projectRoot, magicDir);
-    const srcHashPath = resolve9(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json");
-    let npmVersion = "";
-    try {
-      npmVersion = JSON.parse(readFileSync10(srcHashPath, "utf-8"))._version ?? "";
-    } catch {
-    }
+    const npmVersion = loadTemplateVersion(projectRoot);
     const installedVersion = loadVersionFile(projectRoot, magicDir);
     const isFirstPatch = !installedVersion;
     const isUpgrade = installedVersion && npmVersion && installedVersion !== npmVersion;
@@ -2072,18 +2324,19 @@ async function syncCommand(options = {}) {
     for (const [relPath, content] of candidates) {
       const key = normalizeRelPath(relPath);
       const absPath = resolve9(projectRoot, relPath);
-      if (!existsSync12(absPath)) {
+      if (!existsSync13(absPath)) {
         missingFiles.set(key, content);
       } else if (establishBaseline) {
         missingFiles.set(key, content);
       } else {
-        const curH = hash8(readFileSync10(absPath, "utf-8"));
-        const storedH = outHash[key];
-        if (storedH && curH === storedH) {
-          sameCount++;
-        } else {
-          conflictFiles.set(key, content);
-        }
+        const classification = classifyPatchCandidate(
+          readFileSync11(absPath, "utf-8"),
+          content,
+          outHash[key]
+        );
+        if (classification === "same") sameCount++;
+        else if (classification === "update") missingFiles.set(key, content);
+        else conflictFiles.set(key, content);
       }
     }
     console.log(`patch: ${allFiles.size} \u2192 skip user ${skipped} | missing ${missingFiles.size} | conflict ${conflictFiles.size} | same ${sameCount}`);
@@ -2091,23 +2344,39 @@ async function syncCommand(options = {}) {
       const r = await writeFiles2(projectRoot, missingFiles, { force: true, yes: true });
       console.log(`  missing: \u65B0\u5EFA ${r.created}`);
     }
+    const unresolvedConflictKeys = /* @__PURE__ */ new Set();
     if (conflictFiles.size > 0) {
-      const sel = await selectFiles(projectRoot, conflictFiles);
+      const conflictMode = resolvePatchConflictMode(options.yes);
+      let sel = /* @__PURE__ */ new Map();
+      if (conflictMode === "all") {
+        sel = conflictFiles;
+      } else if (conflictMode === "interactive") {
+        sel = await selectFiles(projectRoot, conflictFiles);
+      } else {
+        console.warn(`  conflict: \u975E\u4EA4\u4E92\u7EC8\u7AEF\u9ED8\u8BA4\u8DF3\u8FC7 ${conflictFiles.size} \u4E2A\u51B2\u7A81\u6587\u4EF6\uFF1B\u5982\u9700\u5168\u90E8\u8986\u76D6\u8BF7\u91CD\u8DD1\u5E76\u663E\u5F0F\u4F20\u5165 --yes`);
+      }
       if (sel.size > 0) {
         const r = await writeFiles2(projectRoot, sel, { force: true, yes: true });
         console.log(`  conflict: \u8986\u76D6 ${r.overwritten}, \u8DF3\u8FC7 ${conflictFiles.size - sel.size}`);
-      } else {
+      } else if (conflictMode === "interactive") {
         console.log(`  conflict: \u7528\u6237\u53D6\u6D88\uFF0C${conflictFiles.size} \u4E2A\u6587\u4EF6\u672A\u5199\u5165`);
       }
+      for (const key of conflictFiles.keys()) {
+        if (!sel.has(key)) unresolvedConflictKeys.add(key);
+      }
     }
     if (missingFiles.size === 0 && conflictFiles.size === 0) {
       console.log(SYNC_CONFIG.PROMPT_PATCH_DONE);
     }
-    const finalHash = mergeFullHash(
+    let finalHash = mergeFullHash(
       outHash,
       [...candidates].map(([relPath]) => ({ relPath, absPath: resolve9(projectRoot, relPath) })),
-      (absPath) => existsSync12(absPath) ? hash8(readFileSync10(absPath, "utf-8")) : null
+      (absPath) => existsSync13(absPath) ? hash8(readFileSync11(absPath, "utf-8")) : null,
+      unresolvedConflictKeys
     );
+    if (target === "codex") {
+      finalHash = pruneHashToCandidates(finalHash, candidates.keys());
+    }
     saveHashFile(projectRoot, magicDir, finalHash);
     saveVersionFile(projectRoot, magicDir, npmVersion);
     await checkPrismaDiff(projectRoot, options);
@@ -2117,7 +2386,7 @@ async function syncCommand(options = {}) {
   }
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of allFiles) {
-    if (!existsSync12(resolve9(projectRoot, relPath))) {
+    if (!existsSync13(resolve9(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
@@ -2141,7 +2410,7 @@ async function syncCommand(options = {}) {
 }
 function printMigrateGuidance(targetPath, changed) {
   const g = SYNC_PRISMA_CONFIG.POST_SYNC;
-  const isManaged = existsSync12(resolve9(dirname5(targetPath), "migrations"));
+  const isManaged = existsSync13(resolve9(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) {
@@ -2161,20 +2430,26 @@ function printMigrateGuidance(targetPath, changed) {
   }
   console.log(`     \u26A0\uFE0F  \u6240\u6709\u573A\u666F\u6536\u5C3E: ${g.FINAL}`);
 }
-async function ensureAtlasCapability(projectRoot) {
+async function ensureAtlasCapability(projectRoot, yes = false) {
   const bin = resolveAtlasBin(projectRoot);
   if (bin) {
     console.log(`   \u2705 Atlas \u80FD\u529B\u5C31\u7EEA: ${bin}`);
     return;
   }
+  if (process.platform === "win32") {
+    console.warn("   \u26A0\uFE0F  Atlas \u5728 Windows \u4E0D\u53EF\u7528\uFF08@ariga/atlas install.js \u4E0D\u652F\u6301 win32\uFF09");
+    console.log("   \u964D\u7EA7\u8DEF\u5F84\uFF1A\u6570\u636E\u5E93\u540C\u6B65\u4F7F\u7528 prisma-diff\uFF08\u514D shadow\uFF09\uFF1B\u5982\u9700 Atlas \u8BF7\u5728 WSL \u73AF\u5883\u624B\u52A8\u5B89\u88C5");
+    console.log("   \u6587\u6863: README.md \u2192 \u7AE0\u8282\u300CAtlas \u6570\u636E\u5E93\u540C\u6B65\u80FD\u529B\u300D/ DEVELOPMENT.md \xA7\u4E5D");
+    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] ");
+  const a = yes ? "y" : 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";
+  const pm = existsSync13(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) {
@@ -2187,8 +2462,8 @@ async function ensureAtlasCapability(projectRoot) {
 }
 function checkHostAtlasSegment(projectRoot) {
   const script = resolve9(projectRoot, "scripts", "db-ensure.sh");
-  if (!existsSync12(script)) return;
-  const content = readFileSync10(script, "utf-8");
+  if (!existsSync13(script)) return;
+  const content = readFileSync11(script, "utf-8");
   if (content.includes("atlas_sync")) return;
   console.warn("   \u26A0\uFE0F  \u5BBF\u4E3B scripts/db-ensure.sh \u672A\u5305\u542B Atlas \u540C\u6B65\u6BB5\uFF08\u65E5\u5E38 db-ensure \u5C06\u7F3A\u5C11 ADD \u6CBB\u7406\u6A21\u578B\u540C\u6B65\uFF09");
   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");
@@ -2202,13 +2477,13 @@ async function checkPrismaDiff(projectRoot, options) {
   if (!options.patch) return;
   const basePath = resolve9(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
   const targetPath = resolve9(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
-  if (!existsSync12(basePath)) {
+  if (!existsSync13(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);
+  await ensureAtlasCapability(projectRoot, options.yes);
   checkHostAtlasSegment(projectRoot);
   const result = diffPrisma(basePath, targetPath);
   if (!result.hasDiff) {
@@ -2216,7 +2491,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 = existsSync12(targetPath);
+  const targetExists = existsSync13(targetPath);
   let modifiedCount = 0;
   console.log(`
 \u26A0\uFE0F  Prisma schema \u5DEE\u5F02\u68C0\u6D4B:`);
@@ -2235,7 +2510,7 @@ async function checkPrismaDiff(projectRoot, options) {
         }
       },
       async confirm() {
-        const ans = await ask(`
+        const ans = options.yes ? "a" : await ask(`
   \u8F93\u5165\u7F16\u53F7\u9009\u62E9\u6027\u6CE8\u5165\uFF08\u5982 1,3\uFF09\uFF0Ca \u5168\u90E8\u6CE8\u5165\uFF0C\u56DE\u8F66\u8DF3\u8FC7: `);
         if (ans === "a" || ans === "all") {
           selected = [...result.missing];
@@ -2273,7 +2548,7 @@ async function checkPrismaDiff(projectRoot, options) {
             }
           },
           async confirm() {
-            const ans = await ask(`    \u662F\u5426\u7528\u57FA\u51C6\u5B9A\u4E49\u8986\u76D6\u8FD9\u4E9B\u51B2\u7A81\u5B57\u6BB5\uFF1F(y/n): `);
+            const ans = options.yes ? "y" : await ask(`    \u662F\u5426\u7528\u57FA\u51C6\u5B9A\u4E49\u8986\u76D6\u8FD9\u4E9B\u51B2\u7A81\u5B57\u6BB5\uFF1F(y/n): `);
             return ans === "y" || ans === "yes";
           },
           execute() {
@@ -2294,7 +2569,7 @@ async function checkPrismaDiff(projectRoot, options) {
             }
           },
           async confirm() {
-            const ans = await ask(`    \u662F\u5426\u8865\u5145\u8FD9\u4E9B\u7F3A\u5931\u5B57\u6BB5\uFF1F(y/n): `);
+            const ans = options.yes ? "y" : await ask(`    \u662F\u5426\u8865\u5145\u8FD9\u4E9B\u7F3A\u5931\u5B57\u6BB5\uFF1F(y/n): `);
             return ans === "y" || ans === "yes";
           },
           execute() {
@@ -2335,7 +2610,7 @@ async function checkPrismaDiff(projectRoot, options) {
   } else {
     console.log(`
   \u76EE\u6807 schema \u6587\u4EF6\u4E0D\u5B58\u5728: ${result.targetPath}`);
-    mkdirSync7(dirname5(targetPath), { recursive: true });
+    mkdirSync7(dirname4(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`);
@@ -2367,7 +2642,7 @@ async function handleDiffAction(action, ctx) {
   }
 }
 function injectMissingModels(targetPath, models) {
-  let content = readFileSync10(targetPath, "utf-8");
+  let content = readFileSync11(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)}) =====
@@ -2380,7 +2655,7 @@ function injectMissingModels(targetPath, models) {
   return models.length;
 }
 function getBaseFieldLines(basePath, modelName) {
-  const content = readFileSync10(basePath, "utf-8");
+  const content = readFileSync11(basePath, "utf-8");
   const blocks = parseSchemaBlocks(content);
   const block = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
   if (!block) return {};
@@ -2403,7 +2678,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 = readFileSync10(targetPath, "utf-8");
+  const content = readFileSync11(targetPath, "utf-8");
   const lines = content.split("\n");
   const blocks = parseSchemaBlocks(content);
   const target = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
@@ -2450,7 +2725,7 @@ function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
 function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
   const baseFields = getBaseFieldLines(basePath, modelName);
   if (Object.keys(baseFields).length === 0) return 0;
-  let content = readFileSync10(targetPath, "utf-8");
+  let content = readFileSync11(targetPath, "utf-8");
   let count = 0;
   for (const { fieldName } of conflicts) {
     const baseLine = baseFields[fieldName];
@@ -2466,7 +2741,7 @@ function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { resolve as resolve10 } from "path";
 async function statusCommand() {
   const projectRoot = process.cwd();
@@ -2476,7 +2751,7 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync13(resolve10(projectRoot, relPath))) {
+    if (existsSync14(resolve10(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
@@ -2494,32 +2769,30 @@ async function statusCommand() {
 }
 
 // src/cli/commands/stack.ts
-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 { readdirSync as readdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
+import { resolve as resolve11, join as join9 } from "path";
 import { 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";
 function hash82(c) {
   return createHash3("sha256").update(c).digest("hex").slice(0, 8);
 }
 function resolveMagicDir(projectRoot, specified) {
   if (specified) {
-    if (!MAGIC_DIR_MAP3[specified]) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
-    return MAGIC_DIR_MAP3[specified];
+    return magicDirFor(specified);
   }
   const detected = detectIDE2(projectRoot);
   const adapter = detected !== "auto" ? detected : "qoder";
-  return MAGIC_DIR_MAP3[adapter];
+  return magicDirFor(adapter);
 }
 function listCustomProfiles(projectRoot, magicDir, registryNames) {
   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();
+  if (!existsSync15(dir)) return [];
+  return readdirSync6(dir).filter((f) => f.endsWith(".md") && !registryNames.has(f.replace(/-profile\.md$/, ""))).sort();
 }
 function profileExists(projectRoot, magicDir, name) {
   const registry = loadProfileRegistry();
   if (registry.some((p) => p.name === name)) return true;
-  return existsSync14(resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
+  return existsSync15(resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
 }
 function stackCommand(sub, name, options = {}) {
   const projectRoot = process.cwd();
@@ -2557,11 +2830,11 @@ function stackCommand(sub, name, options = {}) {
       return;
     }
     const profilePath = resolve11(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
-    const stat = existsSync14(profilePath) ? readFileSync11(profilePath, "utf-8").length : 0;
+    const stat = existsSync15(profilePath) ? readFileSync12(profilePath, "utf-8").length : 0;
     console.log(`\u6280\u672F\u6808: ${current}`);
-    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync14(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
+    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync15(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
     try {
-      const raw = JSON.parse(readFileSync11(resolve11(projectRoot, magicDir, "stack.json"), "utf-8"));
+      const raw = JSON.parse(readFileSync12(resolve11(projectRoot, magicDir, "stack.json"), "utf-8"));
       if (raw.updatedAt) console.log(`\u66F4\u65B0\u65F6\u95F4: ${raw.updatedAt}`);
     } catch {
     }
@@ -2587,8 +2860,8 @@ function buildConfig(projectRoot, magicDir, stack) {
   };
   try {
     const pkgPath = resolve11(projectRoot, "package.json");
-    if (existsSync14(pkgPath)) {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+    if (existsSync15(pkgPath)) {
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       if (pkg.name) config.projectName = pkg.name;
     }
   } catch {
@@ -2604,7 +2877,8 @@ function applyStack(projectRoot, magicDir, name) {
   }
   const config = buildConfig(projectRoot, magicDir, name);
   saveStack(projectRoot, magicDir, name);
-  const coreFiles = renderCore(config, false);
+  const coreTargets = magicDir === magicDirFor("codex") ? [magicDir] : [ADD_DIR, magicDir];
+  const coreFiles = renderCoreForTargets(config, false, coreTargets);
   const stackRelated = /* @__PURE__ */ new Map();
   for (const [relPath, content] of coreFiles) {
     const rp = normalizeRelPath(relPath);
@@ -2614,18 +2888,16 @@ function applyStack(projectRoot, magicDir, name) {
   }
   const hashMap = {};
   try {
-    Object.assign(hashMap, JSON.parse(readFileSync11(resolve11(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
+    Object.assign(hashMap, JSON.parse(readFileSync12(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 = resolve11(projectRoot, relPath.replace(/^\.add/, t));
-      mkdirSync8(join8(targetPath, ".."), { recursive: true });
-      writeFileSync8(targetPath, content, "utf-8");
-      hashMap[relPath.replace(/^\.add/, t)] = hash82(content);
-      written++;
-    }
+    const targetPath = resolve11(projectRoot, relPath);
+    mkdirSync8(join9(targetPath, ".."), { recursive: true });
+    writeFileSync8(targetPath, content, "utf-8");
+    hashMap[relPath] = hash82(content);
+    written++;
   }
   const fail = (msg) => {
     console.error(`\u2717 stack set \u5931\u8D25: ${msg}`);
@@ -2634,23 +2906,23 @@ function applyStack(projectRoot, magicDir, name) {
   const registry = loadProfileRegistry();
   const isBuiltin = registry.some((p) => p.name === name);
   const profilePathMagic = resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`);
-  const profilePathAdd = resolve11(projectRoot, ".add", "rules", "profiles", `${name}-profile.md`);
+  const profilePathAdd = resolve11(projectRoot, ADD_DIR, "rules", "profiles", `${name}-profile.md`);
   const projectRulesPath = resolve11(projectRoot, magicDir, "rules", "project_rules.md");
-  const projectRulesContent = existsSync14(projectRulesPath) ? readFileSync11(projectRulesPath, "utf-8") : "";
+  const projectRulesContent = existsSync15(projectRulesPath) ? readFileSync12(projectRulesPath, "utf-8") : "";
   if (written === 0) fail(`\u672A\u6E32\u67D3\u4EFB\u4F55 stack \u76F8\u5173\u6587\u4EF6\uFF08${name}\uFF09\u2014\u2014Windows \u8DEF\u5F84\u5339\u914D\u5931\u6548\u9057\u7559\u95EE\u9898`);
-  if (isBuiltin && !existsSync14(profilePathAdd)) fail(`profile \u672A\u5199\u5165 .add: ${profilePathAdd}`);
-  if (!existsSync14(profilePathMagic)) fail(`profile \u672A\u5199\u5165 ${magicDir}: ${profilePathMagic}`);
+  if (magicDir !== magicDirFor("codex") && isBuiltin && !existsSync15(profilePathAdd)) fail(`profile \u672A\u5199\u5165 ${ADD_DIR}: ${profilePathAdd}`);
+  if (!existsSync15(profilePathMagic)) fail(`profile \u672A\u5199\u5165 ${magicDir}: ${profilePathMagic}`);
   if (!projectRulesContent.includes("**\u5F53\u524D\u6280\u672F\u6808**") || !projectRulesContent.includes(name)) fail(`project_rules.md \u672A\u5305\u542B ${name} \u5F15\u7528`);
   writeFileSync8(resolve11(projectRoot, magicDir, HASH_OUTPUT_FILE), JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
   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 ${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(`   ${magicDir}/rules/profiles/${name}-profile.md ${existsSync15(resolve11(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`)) ? "\u5DF2\u5C31\u4F4D" : "\uFF08\u81EA\u5B9A\u4E49 profile\uFF0C\u9879\u76EE\u4FA7\u6587\u4EF6\uFF09"}`);
   console.log(`   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(
-  readFileSync12(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync13(new URL("../package.json", import.meta.url), "utf-8")
 );
 async function modelDownloadCommand(options) {
   try {
@@ -2665,8 +2937,8 @@ async function modelDownloadCommand(options) {
 }
 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").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("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").option("--print-mcp-config", "Codex: stdout \u8F93\u51FA config.toml \u7247\u6BB5\uFF08\u4E0D\u5199\u76D8\uFF0C\u4E0D\u521D\u59CB\u5316\u9879\u76EE\uFF09").option("--write-user-config", "Codex: \u663E\u5F0F\u786E\u8BA4\u540E\u5199\u5165 ~/.codex/config.toml\uFF08\u5148\u5907\u4EFD\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").option("--model", "\u68C0\u6D4B\u5230\u7F3A\u5931\u65F6\u4E0B\u8F7D embedding \u6A21\u578B").option("--yes", "\u5168\u90E8\u786E\u8BA4\u8DF3\u8FC7\u8BE2\u95EE\uFF08RPT-06/#19\uFF09").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)