@fenglimg/fabric-cli 1.7.0 → 1.8.0-rc.1

package/dist/{init-WMB3WLXM.js → init-AEO5JU7R.js}

@@ -14,18 +14,21 @@ import {
 } from "./chunk-QPCRBQ5Y.js";
 
 // src/commands/init.ts
-import { createHash } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import * as childProcess from "child_process";
-import { chmodSync as chmodSync2, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync, rmSync, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { appendFileSync, chmodSync as chmodSync2, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, rmSync, statSync as statSync3, writeFileSync } from "fs";
 import { dirname as dirname5, isAbsolute as isAbsolute4, join as join8, parse as parse3, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
+import { atomicWriteJson as atomicWriteJson3, atomicWriteText as atomicWriteText4 } from "@fenglimg/fabric-shared/node/atomic-write";
 import { defineCommand as defineCommand4 } from "citty";
+import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
 // src/bootstrap-guide.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
 import { dirname, isAbsolute, join, parse, resolve } from "path";
 import { fileURLToPath } from "url";
+import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
 var AGENTS_TEMPLATE_BY_FRAMEWORK = {
   "cocos-creator": "templates/agents-md/variants/cocos.md",
   vite: "templates/agents-md/variants/vite.md",
@@ -47,7 +50,7 @@ async function ensureFabricBootstrapGuide(workspaceRoot, force) {
     return;
   }
   mkdirSync(dirname(guidePath), { recursive: true });
-  writeFileSync(guidePath, await buildFabricBootstrapGuide(workspaceRoot), "utf8");
+  await atomicWriteText(guidePath, await buildFabricBootstrapGuide(workspaceRoot));
 }
 function findBootstrapTemplatePath(frameworkKind) {
   const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
@@ -115,9 +118,10 @@ import { homedir as homedir2, platform } from "os";
 
 // src/config/json.ts
 import { existsSync as existsSync2 } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile } from "fs/promises";
 import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
 import { homedir } from "os";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
 
 // src/config/writer.ts
 function createServerEntry(serverPath) {
@@ -128,6 +132,19 @@ function createServerEntry(serverPath) {
 }
 
 // src/config/json.ts
+function deepMerge(target, source) {
+  if (target === null || typeof target !== "object" || Array.isArray(target) || source === null || typeof source !== "object" || Array.isArray(source)) {
+    return source;
+  }
+  const out = { ...target };
+  for (const key of Object.keys(source)) {
+    out[key] = deepMerge(
+      target[key],
+      source[key]
+    );
+  }
+  return out;
+}
 function expandHome(filePath) {
   if (filePath === "~") {
     return homedir();
@@ -159,12 +176,10 @@ async function readJsonConfig(configPath) {
   }
 }
 async function writeJsonClientConfig(configPath, serverEntry) {
-  const config = await readJsonConfig(configPath);
-  const existingServers = config.mcpServers;
-  config.mcpServers = existingServers !== null && typeof existingServers === "object" && !Array.isArray(existingServers) ? { ...existingServers, fabric: serverEntry } : { fabric: serverEntry };
+  const existing = await readJsonConfig(configPath);
+  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
   await mkdir(dirname2(configPath), { recursive: true });
-  await writeFile(configPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
+  await atomicWriteJson(configPath, merged, { indent: 2 });
 }
 var JsonClientConfigWriter = class {
   configuredPath;
@@ -189,18 +204,21 @@ var JsonClientConfigWriter = class {
 };
 var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
   clientKind = "ClaudeCodeCLI";
-  constructor(configuredPath) {
+  scope;
+  constructor(configuredPath, scope = "project") {
     super(configuredPath);
+    this.scope = scope;
   }
-  // Writes to project-level .claude/settings.json so MCP is scoped to the project.
-  // Detection in resolver still checks ~/ to confirm Claude Code is installed.
+  // Writes to project-level .mcp.json (per Claude Code MCP spec) by default,
+  // or ~/.claude.json for user scope.
+  // Detection still checks ~/.claude to confirm Claude Code is installed.
   defaultPath(workspaceRoot) {
     const globalClaudeDir = join2(homedir(), ".claude");
     const projectClaudeDir = join2(workspaceRoot, ".claude");
     if (!existsSync2(globalClaudeDir) && !existsSync2(projectClaudeDir)) {
       return null;
     }
-    return join2(projectClaudeDir, "settings.json");
+    return this.scope === "user" ? join2(homedir(), ".claude.json") : join2(workspaceRoot, ".mcp.json");
   }
 };
 var CursorWriter = class extends JsonClientConfigWriter {
@@ -213,36 +231,6 @@ var CursorWriter = class extends JsonClientConfigWriter {
     return existsSync2(cursorDir) ? join2(cursorDir, "mcp.json") : null;
   }
 };
-var WindsurfWriter = class extends JsonClientConfigWriter {
-  clientKind = "Windsurf";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const windsurfDir = join2(workspaceRoot, ".windsurf");
-    return existsSync2(windsurfDir) ? join2(windsurfDir, "mcp.json") : null;
-  }
-};
-var RooCodeWriter = class extends JsonClientConfigWriter {
-  clientKind = "RooCode";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const rooDir = join2(workspaceRoot, ".roo");
-    return existsSync2(rooDir) ? join2(rooDir, "mcp.json") : null;
-  }
-};
-var GeminiCLIWriter = class extends JsonClientConfigWriter {
-  clientKind = "GeminiCLI";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const geminiDir = join2(homedir(), ".gemini");
-    return existsSync2(geminiDir) || existsSync2(join2(workspaceRoot, "GEMINI.md")) ? join2(geminiDir, "settings.json") : null;
-  }
-};
 
 // src/config/claude-code.ts
 function getClaudeDesktopConfigPath() {
@@ -279,9 +267,10 @@ var ClaudeCodeDesktopWriter = class {
 
 // src/config/toml.ts
 import { existsSync as existsSync4 } from "fs";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
 import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
 import { homedir as homedir3 } from "os";
+import { atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
 function expandHome2(filePath) {
   if (filePath === "~") {
     return homedir3();
@@ -366,7 +355,7 @@ var CodexTOMLConfigWriter = class {
     const rawConfig = await readTomlConfigText(configPath);
     const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
     await mkdir2(dirname3(configPath), { recursive: true });
-    await writeFile2(configPath, nextConfig, "utf8");
+    await atomicWriteText2(configPath, nextConfig);
   }
 };
 
@@ -380,13 +369,14 @@ function addIfDetected(writers, detected, createWriter, configuredPath) {
     writers.push(createWriter(configuredPath));
   }
 }
-function resolveClients(workspaceRoot, fabricConfig = {}) {
+function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
   const clientPaths = fabricConfig.clientPaths;
   const writers = [];
+  const claudeMcpScope = opts.claudeMcpScope ?? "project";
   addIfDetected(
     writers,
     existsSync5(join5(homedir4(), ".claude")) || existsSync5(join5(workspaceRoot, ".claude")),
-    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath),
+    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
     hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
   );
   addIfDetected(
@@ -401,24 +391,6 @@ function resolveClients(workspaceRoot, fabricConfig = {}) {
     (configuredPath) => new CursorWriter(configuredPath),
     hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
   );
-  addIfDetected(
-    writers,
-    existsSync5(join5(workspaceRoot, ".windsurf")),
-    (configuredPath) => new WindsurfWriter(configuredPath),
-    hasExplicitPath(clientPaths, "windsurf") ? clientPaths.windsurf : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync5(join5(workspaceRoot, ".roo")),
-    (configuredPath) => new RooCodeWriter(configuredPath),
-    hasExplicitPath(clientPaths, "rooCode") ? clientPaths.rooCode : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync5(join5(homedir4(), ".gemini")) || existsSync5(join5(workspaceRoot, "GEMINI.md")),
-    (configuredPath) => new GeminiCLIWriter(configuredPath),
-    hasExplicitPath(clientPaths, "geminiCLI") ? clientPaths.geminiCLI : void 0
-  );
   addIfDetected(
     writers,
     existsSync5(join5(homedir4(), ".codex")),
@@ -432,9 +404,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
   const claudeDetected = existsSync5(join5(homedir4(), ".claude")) || existsSync5(join5(workspaceRoot, ".claude"));
   const claudeDesktopDetected = existsSync5(getClaudeDesktopConfigPath());
   const cursorDetected = existsSync5(join5(workspaceRoot, ".cursor"));
-  const windsurfDetected = existsSync5(join5(workspaceRoot, ".windsurf"));
-  const rooDetected = existsSync5(join5(workspaceRoot, ".roo"));
-  const geminiDetected = existsSync5(join5(homedir4(), ".gemini")) || existsSync5(join5(workspaceRoot, "GEMINI.md"));
   const codexDetected = existsSync5(join5(homedir4(), ".codex"));
   return [
     {
@@ -480,45 +449,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
         skill: false
       }
     },
-    {
-      clientKind: "Windsurf",
-      label: "Windsurf",
-      detected: windsurfDetected || hasExplicitPath(clientPaths, "windsurf"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: ".windsurf/mcp.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
-    {
-      clientKind: "RooCode",
-      label: "Roo Code",
-      detected: rooDetected || hasExplicitPath(clientPaths, "rooCode"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: ".roo/mcp.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
-    {
-      clientKind: "GeminiCLI",
-      label: "Gemini CLI",
-      detected: geminiDetected || hasExplicitPath(clientPaths, "geminiCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "~/.gemini/settings.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
     {
       clientKind: "CodexCLI",
       label: "Codex CLI",
@@ -549,13 +479,6 @@ var CLIENT_ALIASES = {
   claudedesktop: "claude",
   claudecodedesktop: "claude",
   cursor: "cursor",
-  windsurf: "windsurf",
-  roo: "roo",
-  "roo-code": "roo",
-  roocode: "roo",
-  gemini: "gemini",
-  "gemini-cli": "gemini",
-  geminicli: "gemini",
   codex: "codex",
   "codex-cli": "codex",
   codexcli: "codex"
@@ -662,12 +585,6 @@ function mapClientKind(clientKind) {
       return "claude";
     case "Cursor":
       return "cursor";
-    case "Windsurf":
-      return "windsurf";
-    case "RooCode":
-      return "roo";
-    case "GeminiCLI":
-      return "gemini";
     case "CodexCLI":
       return "codex";
     default:
@@ -680,12 +597,6 @@ function mapBootstrapClientToClientKind(client) {
       return "ClaudeCodeCLI";
     case "cursor":
       return "Cursor";
-    case "windsurf":
-      return "Windsurf";
-    case "roo":
-      return "RooCode";
-    case "gemini":
-      return "GeminiCLI";
     case "codex":
       return "CodexCLI";
   }
@@ -699,10 +610,11 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 import { defineCommand as defineCommand3 } from "citty";
 
 // src/commands/hooks.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync } from "fs";
 import { dirname as dirname4, isAbsolute as isAbsolute2, join as join6, parse as parse2, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { defineCommand as defineCommand2 } from "citty";
+import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
 var hooksCommand = defineCommand2({
   meta: {
     name: "hooks",
@@ -750,7 +662,7 @@ async function installHooks(target, options = {}) {
   }
   mkdirSync2(huskyDir, { recursive: true });
   const templateContent = readFileSync2(findTemplatePath2("templates/husky/pre-commit"), "utf8");
-  const hookAction = installHookFile(hookPath, templateContent, options.force);
+  const hookAction = await installHookFile(hookPath, templateContent, options.force);
   chmodSync(hookPath, 493);
   const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
   const scripts = packageJson.scripts && typeof packageJson.scripts === "object" && !Array.isArray(packageJson.scripts) ? packageJson.scripts : {};
@@ -759,8 +671,7 @@ async function installHooks(target, options = {}) {
   if (!hadPrepare) {
     scripts.prepare = "husky install";
     packageJson.scripts = scripts;
-    writeFileSync2(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
-`, "utf8");
+    await atomicWriteJson2(packageJsonPath, packageJson);
     prepareAction = "added";
   }
   const installed = [];
@@ -792,10 +703,10 @@ function assertExistingDirectory(target) {
     throw new Error(t("cli.shared.target-invalid", { target }));
   }
 }
-function installHookFile(hookPath, templateContent, force) {
+async function installHookFile(hookPath, templateContent, force) {
   if (existsSync6(hookPath)) {
     if (force) {
-      writeFileSync2(hookPath, templateContent, "utf8");
+      await atomicWriteText3(hookPath, templateContent);
       return "overwritten";
     }
     const existing = readFileSync2(hookPath, "utf8");
@@ -804,11 +715,11 @@ function installHookFile(hookPath, templateContent, force) {
     }
     const fabricBlock = templateContent.replace(/^#!\/bin\/sh\n/, "");
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    writeFileSync2(hookPath, `${existing}${separator}# --- Fabric ---
-${fabricBlock}`, "utf8");
+    await atomicWriteText3(hookPath, `${existing}${separator}# --- Fabric ---
+${fabricBlock}`);
     return "appended";
   }
-  writeFileSync2(hookPath, templateContent, "utf8");
+  await atomicWriteText3(hookPath, templateContent);
   return "created";
 }
 function findTemplatePath2(relativePath) {
@@ -852,13 +763,6 @@ var CLIENT_ALIASES2 = {
   "claude-code-desktop": "ClaudeCodeDesktop",
   claudedesktop: "ClaudeCodeDesktop",
   cursor: "Cursor",
-  windsurf: "Windsurf",
-  roocode: "RooCode",
-  "roo-code": "RooCode",
-  roo: "RooCode",
-  geminicli: "GeminiCLI",
-  "gemini-cli": "GeminiCLI",
-  gemini: "GeminiCLI",
   codexcli: "CodexCLI",
   "codex-cli": "CodexCLI",
   codex: "CodexCLI"
@@ -953,7 +857,7 @@ async function installMcpClients(target, options = {}) {
   const fabricConfig = await loadFabricConfig(workspaceRoot);
   const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
   const serverPath = resolveServerPath(options.localServerPath);
-  const writers = resolveClients(workspaceRoot, fabricConfig).filter(
+  const writers = resolveClients(workspaceRoot, fabricConfig, { claudeMcpScope: options.claudeMcpScope }).filter(
     (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
   );
   const installed = [];
@@ -2088,7 +1992,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.7.0" : "unknown";
+  return true ? "1.8.0-rc.1" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -2098,7 +2002,7 @@ function toPosixPath(path) {
 }
 
 // src/commands/init.ts
-var CLAUDE_INIT_SKILL_TEMPLATE = "templates/claude-skills/agents-md-init/SKILL.md";
+var CLAUDE_INIT_SKILL_TEMPLATE = "templates/claude-skills/fabric-init/SKILL.md";
 var CLAUDE_INIT_REMINDER_HOOK_TEMPLATE = "templates/claude-hooks/agents-md-init-reminder.cjs";
 var CLAUDE_INIT_REMINDER_COMMAND = ".claude/hooks/agents-md-init-reminder.cjs";
 var CODEX_INIT_SKILL_TEMPLATE = "templates/codex-skills/fabric-init/SKILL.md";
@@ -2168,6 +2072,10 @@ var initCommand = defineCommand4({
       type: "string",
       default: "global",
       description: t("cli.init.mcp.install.prompt")
+    },
+    scope: {
+      type: "string",
+      description: t("cli.init.mcp.scope.description")
     }
   },
   async run({ args }) {
@@ -2179,6 +2087,9 @@ async function runInitCommand(args) {
   const logger = createDebugLogger(args.debug);
   const resolution = resolveDevMode(args.target, process.cwd());
   const intent = resolveInitCliIntent(args, resolution.target);
+  if (args.reapply === true) {
+    checkLockOrThrow(intent.target, { force: args.force });
+  }
   logger(`init target source: ${resolution.source}`);
   for (const step of resolution.chain) {
     logger(step);
@@ -2197,6 +2108,7 @@ async function runInitCommand(args) {
     target: intent.target,
     options: intent.options,
     mcpInstallMode: intent.mcpInstallMode,
+    claudeMcpScope: intent.claudeMcpScope,
     interactive: intent.interactiveSummary && !intent.wizardEnabled,
     supports
   });
@@ -2210,6 +2122,7 @@ async function runInitCommand(args) {
 function resolveInitCliIntent(args, targetInput) {
   const target = normalizeTarget4(targetInput);
   const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
+  const claudeMcpScope = resolveClaudeMcpScope(args.scope);
   const terminalInteractive = isInteractiveInit();
   const planOnly = args.plan === true;
   const reapply = args.reapply === true;
@@ -2225,21 +2138,34 @@ function resolveInitCliIntent(args, targetInput) {
     target,
     options,
     mcpInstallMode,
+    claudeMcpScope,
     interactiveSummary: args.interactive !== false && terminalInteractive,
     wizardEnabled: shouldUseInitWizard(args, terminalInteractive) && !planOnly
   };
 }
+function resolveClaudeMcpScope(raw) {
+  if (raw === void 0 || raw === "project") {
+    return "project";
+  }
+  if (raw === "user") {
+    return "user";
+  }
+  writeStderr3(t("cli.init.mcp.scope.invalid", { value: raw }));
+  return "project";
+}
 async function buildInitExecutionPlan(input) {
   const options = input.options ?? {};
   const scaffold = await buildInitFabricPlan(input.target, options);
   const supports = input.supports ?? detectClientSupports(input.target);
   const mcpInstallMode = input.mcpInstallMode ?? "global";
+  const claudeMcpScope = input.claudeMcpScope ?? "project";
   const stages = [
     { name: "bootstrap", skipped: Boolean(options.skipBootstrap) },
     {
       name: "mcp",
       skipped: Boolean(options.skipMcp),
       installMode: mcpInstallMode,
+      claudeMcpScope,
       localServerPath: mcpInstallMode === "local" ? LOCAL_FABRIC_SERVER_PATH : void 0,
       packageManager: mcpInstallMode === "local" ? detectPackageManager(input.target) : void 0
     },
@@ -2249,6 +2175,7 @@ async function buildInitExecutionPlan(input) {
     target: input.target,
     options,
     mcpInstallMode,
+    claudeMcpScope,
     interactive: input.interactive ?? false,
     supports,
     scaffold,
@@ -2288,7 +2215,7 @@ async function executeInitExecutionPlan(plan) {
       case "preflight":
         break;
       case "scaffold":
-        created = executeInitFabricPlan(plan.scaffold);
+        created = await executeInitFabricPlan(plan.scaffold);
         printInitScaffoldResult(created);
         break;
       case "bootstrap":
@@ -2319,7 +2246,7 @@ async function buildInitFabricPlan(target, options) {
   const taxonomyPath = join8(fabricDir, "INITIAL_TAXONOMY.md");
   const rulesDir = join8(fabricDir, "rules");
   const eventsPath = join8(fabricDir, "events.jsonl");
-  const claudeSkillPath = join8(target, ".claude", "skills", "agents-md-init", "SKILL.md");
+  const claudeSkillPath = join8(target, ".claude", "skills", "fabric-init", "SKILL.md");
   const codexSkillPath = join8(target, ".agents", "skills", "fabric-init", "SKILL.md");
   const codexSessionStartHookPath = join8(target, ".codex", "hooks", "fabric-session-start.cjs");
   const codexStopHookPath = join8(target, ".codex", "hooks", "fabric-stop-reminder.cjs");
@@ -2382,32 +2309,49 @@ async function buildInitFabricPlan(target, options) {
     claudeSettings: buildClaudeSettingsWritePlan(claudeSettingsPath, options)
   };
 }
-function executeInitFabricPlan(plan) {
+async function executeInitFabricPlan(plan) {
+  const isReapply = plan.options?.reapply === true;
+  const existingRules = isReapply && existsSync9(plan.rulesDir) ? readdirSync2(plan.rulesDir).filter((f) => f.endsWith(".md")) : [];
+  const preserveMeta = isReapply && existingRules.length > 0;
   if (plan.replaceFabricDir) {
     rmSync(plan.fabricDir, { force: true });
   }
   mkdirSync3(plan.fabricDir, { recursive: true });
   mkdirSync3(dirname5(plan.bootstrapPath), { recursive: true });
   preparePlannedPath(plan.bootstrapPath, plan.bootstrapAction);
-  writeFileSync3(plan.bootstrapPath, plan.bootstrapContent, "utf8");
-  preparePlannedPath(plan.metaPath, plan.metaAction);
-  writeFileSync3(plan.metaPath, `${JSON.stringify(plan.meta, null, 2)}
-`, "utf8");
+  await atomicWriteText4(plan.bootstrapPath, plan.bootstrapContent);
+  if (!preserveMeta) {
+    preparePlannedPath(plan.metaPath, plan.metaAction);
+    await atomicWriteJson3(plan.metaPath, plan.meta);
+  }
   preparePlannedPath(plan.taxonomyPath, plan.taxonomyAction);
-  writeFileSync3(plan.taxonomyPath, ensureTrailingNewline2(plan.taxonomyContent), "utf8");
+  await atomicWriteText4(plan.taxonomyPath, ensureTrailingNewline2(plan.taxonomyContent));
   mkdirSync3(plan.rulesDir, { recursive: true });
-  preparePlannedPath(plan.eventsPath, plan.eventsAction);
-  writeFileSync3(plan.eventsPath, "", "utf8");
+  if (isReapply) {
+    if (!existsSync9(plan.eventsPath)) {
+      mkdirSync3(dirname5(plan.eventsPath), { recursive: true });
+      writeFileSync(plan.eventsPath, "", "utf8");
+    }
+  } else {
+    preparePlannedPath(plan.eventsPath, plan.eventsAction);
+    writeFileSync(plan.eventsPath, "", "utf8");
+  }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
-  writeFileSync3(plan.forensicPath, `${JSON.stringify(plan.forensicReport, null, 2)}
-`, "utf8");
+  await atomicWriteJson3(plan.forensicPath, plan.forensicReport);
   applyOptionalTemplateWritePlan(plan.claudeSkill);
   applyOptionalTemplateWritePlan(plan.codexSkill);
   applyOptionalTemplateWritePlan(plan.codexSessionStartHook);
   applyOptionalTemplateWritePlan(plan.codexStopHook);
-  applyJsonWritePlan(plan.codexHooksConfig);
+  await applyJsonWritePlan(plan.codexHooksConfig);
   applyOptionalTemplateWritePlan(plan.claudeHook);
-  applyClaudeSettingsWritePlan(plan.claudeSettings);
+  await applyClaudeSettingsWritePlan(plan.claudeSettings);
+  if (isReapply) {
+    appendReapplyLedgerEvent(plan.eventsPath, {
+      preserved_ledger: true,
+      preserved_meta: preserveMeta,
+      rules_count: existingRules.length
+    });
+  }
   return {
     bootstrapPath: plan.bootstrapPath,
     bootstrapAction: plan.bootstrapAction,
@@ -2436,7 +2380,7 @@ function executeInitFabricPlan(plan) {
   };
 }
 async function initFabric(target, options) {
-  return executeInitFabricPlan(await buildInitFabricPlan(target, options));
+  return await executeInitFabricPlan(await buildInitFabricPlan(target, options));
 }
 function shouldUseInitWizard(args, terminalInteractive = isInteractiveInit()) {
   return terminalInteractive && args.interactive !== false && args.yes !== true;
@@ -2447,6 +2391,7 @@ async function resolveInitExecutionPlanWithWizard(basePlan, args, wizardAdapter)
     options: basePlan.options,
     supports: basePlan.supports,
     mcpInstallMode: basePlan.mcpInstallMode,
+    claudeMcpScope: basePlan.claudeMcpScope,
     lockedStages: collectLockedWizardStages(args)
   });
   if (selection === null) {
@@ -2461,6 +2406,7 @@ async function resolveInitExecutionPlanWithWizard(basePlan, args, wizardAdapter)
       skipHooks: !selection.hooks
     },
     mcpInstallMode: selection.mcp ? selection.mcpInstallMode : basePlan.mcpInstallMode,
+    claudeMcpScope: selection.claudeMcpScope,
     interactive: false,
     supports: basePlan.supports
   });
@@ -2584,7 +2530,8 @@ async function executeInitStagePlan(plan, stageName) {
         }
         const result = await installMcpClients(plan.target, {
           force: plan.options.force,
-          localServerPath: stage.localServerPath
+          localServerPath: stage.localServerPath,
+          claudeMcpScope: stage.claudeMcpScope
         });
         if (result.details.length === 0) {
           console.log(formatInitStageResult("mcp", "skipped", 0, 0, t("cli.config.install.no-configs")));
@@ -2681,12 +2628,12 @@ function buildCodexHooksConfigPlan(configPath, options) {
     value: buildCodexHooksConfigValue()
   };
 }
-function applyJsonWritePlan(plan) {
+async function applyJsonWritePlan(plan) {
   if (plan.action === "skipped") {
     return;
   }
   mkdirSync3(dirname5(plan.path), { recursive: true });
-  writeJsonAtomically(plan.path, plan.value);
+  await atomicWriteJson3(plan.path, plan.value);
 }
 function buildClaudeSettingsWritePlan(settingsPath, options) {
   let settings;
@@ -2746,12 +2693,12 @@ function buildClaudeSettingsWritePlan(settingsPath, options) {
     value: nextSettings
   };
 }
-function applyClaudeSettingsWritePlan(plan) {
+async function applyClaudeSettingsWritePlan(plan) {
   if (plan.value === null) {
     return;
   }
   mkdirSync3(dirname5(plan.path), { recursive: true });
-  writeJsonAtomically(plan.path, plan.value);
+  await atomicWriteJson3(plan.path, plan.value);
 }
 function createDefaultInitWizardAdapter() {
   return {
@@ -2799,6 +2746,14 @@ function createDefaultInitWizardAdapter() {
                 { value: "local", label: "local", hint: t("cli.init.mcp.install.local") }
               ]
             }) : context.mcpInstallMode,
+            claudeMcpScope: async ({ results }) => results.mcp ? selectClaudeMcpScopeInGroup({
+              message: t("cli.init.wizard.mcp-scope", { defaultValue: context.claudeMcpScope }),
+              initialValue: context.claudeMcpScope,
+              options: [
+                { value: "project", label: "project", hint: t("cli.init.mcp.scope.project") },
+                { value: "user", label: "user", hint: t("cli.init.mcp.scope.user") }
+              ]
+            }) : context.claudeMcpScope,
             hooks: async () => context.lockedStages.includes("hooks") ? false : confirmInGroup({
               message: t("cli.init.wizard.stage.hooks", {
                 defaultValue: formatPromptDefault(!context.options.skipHooks)
@@ -2865,6 +2820,17 @@ async function selectMcpInstallModeInGroup(options) {
   }
   return result;
 }
+async function selectClaudeMcpScopeInGroup(options) {
+  const result = await select({
+    message: options.message,
+    initialValue: options.initialValue,
+    options: options.options
+  });
+  if (isCancel(result)) {
+    throw INIT_WIZARD_GROUP_CANCELLED;
+  }
+  return result;
+}
 function collectLockedWizardStages(args) {
   const lockedStages = [];
   if (args.bootstrap === false) {
@@ -2957,6 +2923,21 @@ function createInitialMeta(agentsHash) {
     }
   };
 }
+function appendReapplyLedgerEvent(eventsPath, payload) {
+  const event = {
+    kind: "fabric-event",
+    id: `event:${randomUUID()}`,
+    ts: Date.now(),
+    schema_version: 1,
+    event_type: "reapply_completed",
+    preserved_ledger: payload.preserved_ledger,
+    preserved_meta: payload.preserved_meta,
+    rules_count: payload.rules_count
+  };
+  const line = `${JSON.stringify(event)}
+`;
+  appendFileSync(eventsPath, line, "utf8");
+}
 function buildInitialTaxonomyMarkdown(forensicReport) {
   const frameworkInfo = forensicReport.framework;
   const framework = [frameworkInfo?.kind ?? "unknown", frameworkInfo?.subkind ?? ""].filter((value) => value.trim() !== "").join(" / ") || "unknown";
@@ -3051,12 +3032,6 @@ function isClaudeInitReminderStopEntry(entry) {
     (hook) => isRecord(hook) && hook.type === "command" && typeof hook.command === "string" && hook.command.includes("agents-md-init-reminder.cjs")
   );
 }
-function writeJsonAtomically(path, value) {
-  const tempPath = `${path}.${process.pid}.tmp`;
-  writeFileSync3(tempPath, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-  renameSync(tempPath, path);
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }