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

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

@@ -1,47 +1,892 @@
 #!/usr/bin/env node
 import {
-  buildFabricBootstrapGuide,
-  installBootstrap
-} from "./chunk-T2WJF5I3.js";
-import {
+  createScanReport,
   detectFramework
-} from "./chunk-QSAEGVKE.js";
+} from "./chunk-NMMUETVK.js";
 import {
   createDebugLogger,
-  resolveDevMode
-} from "./chunk-AEOYCVBG.js";
-import {
   displayWidth,
   padEnd,
-  paint
-} from "./chunk-WWNXR34K.js";
-import {
-  installMcpClients
-} from "./chunk-BVTMVW5M.js";
-import {
-  detectClientSupports
-} from "./chunk-BEKSXO5N.js";
-import {
-  installHooks
-} from "./chunk-YDZJRLHL.js";
-import {
+  paint,
+  readFabricConfig,
+  resolveDevMode,
   t
-} from "./chunk-6ICJICVU.js";
+} 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, copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
-import { dirname, isAbsolute as isAbsolute2, join as join2, parse, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
+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 } 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",
+  next: "templates/agents-md/variants/next.md"
+};
+var FABRIC_GUIDE_PATH = ".fabric/bootstrap/README.md";
+async function buildFabricBootstrapGuide(target) {
+  const workspaceRoot = normalizeTarget(target);
+  const scanReport = await createScanReport(workspaceRoot);
+  const template = readFileSync(findBootstrapTemplatePath(scanReport.framework.kind), "utf8");
+  const packageName = readPackageName(workspaceRoot) ?? parse(workspaceRoot).base;
+  return ensureTrailingNewline(
+    template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind)
+  );
+}
+async function ensureFabricBootstrapGuide(workspaceRoot, force) {
+  const guidePath = resolve(workspaceRoot, FABRIC_GUIDE_PATH);
+  if (existsSync(guidePath) && !force) {
+    return;
+  }
+  mkdirSync(dirname(guidePath), { recursive: true });
+  await atomicWriteText(guidePath, await buildFabricBootstrapGuide(workspaceRoot));
+}
+function findBootstrapTemplatePath(frameworkKind) {
+  const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
+  return findTemplatePath(relativePath);
+}
+function readPackageName(target) {
+  const packageJsonPath = join(target, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return void 0;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.name;
+  } catch {
+    return void 0;
+  }
+}
+function findTemplatePath(relativePath) {
+  const currentModuleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    ...templateCandidatesFrom(process.cwd(), relativePath),
+    ...templateCandidatesFrom(currentModuleDir, relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
+}
+function templateCandidatesFrom(start, relativePath) {
+  const candidates = [];
+  let current = resolve(start);
+  while (true) {
+    candidates.push(join(current, ...relativePath.split("/")));
+    const parent = dirname(current);
+    if (parent === current || parse(current).root === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates.reverse();
+}
+function ensureTrailingNewline(content) {
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+
+// src/commands/bootstrap.ts
+import { resolve as resolve5 } from "path";
 import { defineCommand } from "citty";
 
+// src/config/resolver.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+
+// src/config/claude-code.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+import { homedir as homedir2, platform } from "os";
+
+// src/config/json.ts
+import { existsSync as existsSync2 } from "fs";
+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) {
+  return {
+    command: process.execPath,
+    args: [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();
+  }
+  if (filePath.startsWith("~/")) {
+    return join2(homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+function normalizeConfigPath(filePath) {
+  return resolve2(expandHome(filePath));
+}
+async function readJsonConfig(configPath) {
+  try {
+    const raw = await readFile(configPath, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`Expected JSON object in ${configPath}`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeJsonClientConfig(configPath, serverEntry) {
+  const existing = await readJsonConfig(configPath);
+  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
+  await mkdir(dirname2(configPath), { recursive: true });
+  await atomicWriteJson(configPath, merged, { indent: 2 });
+}
+var JsonClientConfigWriter = class {
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return normalizeConfigPath(explicitPath);
+    }
+    const configPath = this.defaultPath(workspaceRoot);
+    return configPath === null ? null : normalizeConfigPath(configPath);
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, createServerEntry(serverPath));
+  }
+};
+var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
+  clientKind = "ClaudeCodeCLI";
+  scope;
+  constructor(configuredPath, scope = "project") {
+    super(configuredPath);
+    this.scope = scope;
+  }
+  // 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 this.scope === "user" ? join2(homedir(), ".claude.json") : join2(workspaceRoot, ".mcp.json");
+  }
+};
+var CursorWriter = class extends JsonClientConfigWriter {
+  clientKind = "Cursor";
+  constructor(configuredPath) {
+    super(configuredPath);
+  }
+  defaultPath(workspaceRoot) {
+    const cursorDir = join2(workspaceRoot, ".cursor");
+    return existsSync2(cursorDir) ? join2(cursorDir, "mcp.json") : null;
+  }
+};
+
+// src/config/claude-code.ts
+function getClaudeDesktopConfigPath() {
+  const os = platform();
+  if (os === "darwin") {
+    return join3(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (os === "win32") {
+    return join3(process.env.APPDATA ?? join3(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  }
+  return join3(homedir2(), ".config", "Claude", "claude_desktop_config.json");
+}
+var ClaudeCodeDesktopWriter = class {
+  clientKind = "ClaudeCodeDesktop";
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(_workspaceRoot, overridePath) {
+    const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
+    return existsSync3(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, {
+      command: process.execPath,
+      args: [serverPath]
+    });
+  }
+};
+
+// src/config/toml.ts
+import { existsSync as existsSync4 } from "fs";
+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();
+  }
+  if (filePath.startsWith("~/")) {
+    return join4(homedir3(), filePath.slice(2));
+  }
+  return filePath;
+}
+function escapeTomlString(value) {
+  return JSON.stringify(value);
+}
+function serializeTomlStringArray(values) {
+  return `[${values.map((value) => escapeTomlString(value)).join(", ")}]`;
+}
+function serializeTomlInlineTable(values) {
+  const entries = Object.entries(values).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key} = ${escapeTomlString(value)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+function serializeCodexServerBlock(serverName, serverEntry) {
+  const lines = [
+    `[mcp_servers.${serverName}]`,
+    `command = ${escapeTomlString(serverEntry.command)}`,
+    `args = ${serializeTomlStringArray(serverEntry.args)}`
+  ];
+  if (serverEntry.env !== void 0 && Object.keys(serverEntry.env).length > 0) {
+    lines.push(`env = ${serializeTomlInlineTable(serverEntry.env)}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function trimTrailingBlankLines(value) {
+  return value.replace(/\s+$/u, "");
+}
+function upsertCodexServerBlock(rawConfig, serverName, serverEntry) {
+  const block = serializeCodexServerBlock(serverName, serverEntry);
+  const normalized = rawConfig.replace(/\r\n/g, "\n");
+  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
+  const currentPattern = new RegExp(
+    String.raw`\n?\[mcp_servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const withoutLegacy = normalized.replace(legacyPattern, "");
+  const withoutExisting = withoutLegacy.replace(currentPattern, "");
+  const trimmed = trimTrailingBlankLines(withoutExisting);
+  if (trimmed.length === 0) {
+    return block;
+  }
+  return `${trimmed}
+
+${block}`;
+}
+async function readTomlConfigText(configPath) {
+  try {
+    return await readFile2(configPath, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+var CodexTOMLConfigWriter = class {
+  clientKind = "CodexCLI";
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(_workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return resolve4(expandHome2(explicitPath));
+    }
+    const codexDir = join4(homedir3(), ".codex");
+    return existsSync4(codexDir) ? resolve4(join4(codexDir, "config.toml")) : null;
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    const rawConfig = await readTomlConfigText(configPath);
+    const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
+    await mkdir2(dirname3(configPath), { recursive: true });
+    await atomicWriteText2(configPath, nextConfig);
+  }
+};
+
+// src/config/resolver.ts
+import { clientPathsSchema, fabricConfigSchema } from "@fenglimg/fabric-shared";
+function hasExplicitPath(clientPaths, key) {
+  return typeof clientPaths?.[key] === "string" && clientPaths[key].trim().length > 0;
+}
+function addIfDetected(writers, detected, createWriter, configuredPath) {
+  if (configuredPath !== void 0 || detected) {
+    writers.push(createWriter(configuredPath));
+  }
+}
+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, claudeMcpScope),
+    hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync5(getClaudeDesktopConfigPath()),
+    (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
+    hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync5(join5(workspaceRoot, ".cursor")),
+    (configuredPath) => new CursorWriter(configuredPath),
+    hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync5(join5(homedir4(), ".codex")),
+    (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
+    hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
+  );
+  return writers;
+}
+function detectClientSupports(workspaceRoot, fabricConfig = {}) {
+  const clientPaths = fabricConfig.clientPaths;
+  const claudeDetected = existsSync5(join5(homedir4(), ".claude")) || existsSync5(join5(workspaceRoot, ".claude"));
+  const claudeDesktopDetected = existsSync5(getClaudeDesktopConfigPath());
+  const cursorDetected = existsSync5(join5(workspaceRoot, ".cursor"));
+  const codexDetected = existsSync5(join5(homedir4(), ".codex"));
+  return [
+    {
+      clientKind: "ClaudeCodeCLI",
+      label: "Claude Code CLI",
+      detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "project .claude/settings.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: true,
+        skill: true
+      }
+    },
+    {
+      clientKind: "ClaudeCodeDesktop",
+      label: "Claude Code Desktop",
+      detected: claudeDesktopDetected || hasExplicitPath(clientPaths, "claudeCodeDesktop"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "desktop Claude config",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "Cursor",
+      label: "Cursor",
+      detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: ".cursor/mcp.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "CodexCLI",
+      label: "Codex CLI",
+      detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "~/.codex/config.toml",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: existsSync5(join5(workspaceRoot, ".codex", "hooks.json")),
+        skill: existsSync5(join5(workspaceRoot, ".agents", "skills", "fabric-init", "SKILL.md"))
+      }
+    }
+  ];
+}
+
+// src/commands/bootstrap.ts
+var CLIENT_ALIASES = {
+  claude: "claude",
+  "claude-code": "claude",
+  claudecode: "claude",
+  claudecli: "claude",
+  claudecodecli: "claude",
+  claudedesktop: "claude",
+  claudecodedesktop: "claude",
+  cursor: "cursor",
+  codex: "codex",
+  "codex-cli": "codex",
+  codexcli: "codex"
+};
+var bootstrapCommand = defineCommand({
+  meta: {
+    name: "bootstrap",
+    description: t("cli.bootstrap.description")
+  },
+  subCommands: {
+    install: defineCommand({
+      meta: {
+        name: "install",
+        description: t("cli.bootstrap.install.description")
+      },
+      args: {
+        clients: {
+          type: "string",
+          description: t("cli.bootstrap.install.args.clients.description")
+        }
+      },
+      async run({ args }) {
+        const workspaceRoot = process.cwd();
+        const selectedClients = parseClientFilter(args.clients);
+        const result = await installBootstrap(workspaceRoot, {
+          clients: selectedClients === null ? void 0 : Array.from(selectedClients, mapBootstrapClientToClientKind)
+        });
+        if (result.details.length === 0) {
+          process.stderr.write(
+            `${t("cli.bootstrap.install.no-targets")}
+`
+          );
+          return;
+        }
+        for (const detail of result.details) {
+          if (detail.action === "skipped") {
+            process.stderr.write(`${t("cli.bootstrap.install.skipped-header", { path: detail.path })}
+`);
+            continue;
+          }
+          if (detail.action === "prepended") {
+            process.stderr.write(`${t("cli.bootstrap.install.prepended", { path: detail.path })}
+`);
+            continue;
+          }
+          process.stderr.write(`${t("cli.bootstrap.install.installed", { path: detail.path })}
+`);
+        }
+      }
+    })
+  }
+});
+async function installBootstrap(target, options = {}) {
+  const workspaceRoot = resolve5(target);
+  const fabricConfig = readFabricConfig(workspaceRoot);
+  const targets = resolveBootstrapTargets(workspaceRoot, fabricConfig, options.clients);
+  const installed = [];
+  const skipped = [];
+  const details = [];
+  await ensureFabricBootstrapGuide(workspaceRoot, options.force);
+  for (const bootstrapTarget of targets) {
+    details.push({
+      client: bootstrapTarget.client,
+      path: resolve5(workspaceRoot, FABRIC_GUIDE_PATH),
+      action: "skipped"
+    });
+    skipped.push(bootstrapTarget.client);
+  }
+  return { installed, skipped, details };
+}
+function parseClientFilter(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return null;
+  }
+  const clients = /* @__PURE__ */ new Set();
+  for (const rawClient of value.split(",")) {
+    const alias = rawClient.trim().toLowerCase();
+    const client = CLIENT_ALIASES[alias];
+    if (client === void 0) {
+      throw new Error(t("cli.bootstrap.errors.unknown-client", { client: rawClient }));
+    }
+    clients.add(client);
+  }
+  return clients;
+}
+function resolveBootstrapTargets(workspaceRoot, fabricConfig, selectedClients) {
+  const targets = [];
+  const seenClients = /* @__PURE__ */ new Set();
+  const clientKinds = selectedClients ?? resolveClients(workspaceRoot, fabricConfig).map((writer) => writer.clientKind);
+  for (const clientKind of clientKinds) {
+    const bootstrapClient = mapClientKind(clientKind);
+    if (bootstrapClient === null || seenClients.has(bootstrapClient)) {
+      continue;
+    }
+    seenClients.add(bootstrapClient);
+    targets.push({ client: clientKind, bootstrapClient });
+  }
+  return targets;
+}
+function mapClientKind(clientKind) {
+  switch (clientKind) {
+    case "ClaudeCodeCLI":
+    case "ClaudeCodeDesktop":
+      return "claude";
+    case "Cursor":
+      return "cursor";
+    case "CodexCLI":
+      return "codex";
+    default:
+      return null;
+  }
+}
+function mapBootstrapClientToClientKind(client) {
+  switch (client) {
+    case "claude":
+      return "ClaudeCodeCLI";
+    case "cursor":
+      return "Cursor";
+    case "codex":
+      return "CodexCLI";
+  }
+}
+
+// src/commands/config.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+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 } 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",
+    description: t("cli.hooks.description")
+  },
+  subCommands: {
+    install: defineCommand2({
+      meta: {
+        name: "install",
+        description: t("cli.hooks.install.description")
+      },
+      args: {
+        target: {
+          type: "string",
+          description: t("cli.hooks.install.args.target.description"),
+          default: process.cwd()
+        }
+      },
+      async run({ args }) {
+        const result = await installHooks(args.target);
+        if (result.hookAction === "skipped") {
+          writeStderr(t("cli.hooks.install.hook-skipped", { path: result.hookPath }));
+        } else if (result.hookAction === "appended") {
+          writeStderr(t("cli.hooks.install.hook-appended", { path: result.hookPath }));
+        } else {
+          writeStderr(t("cli.hooks.install.hook-created", { path: result.hookPath }));
+        }
+        if (result.prepareAction === "left") {
+          writeStderr(t("cli.hooks.install.prepare-left", { path: result.packageJsonPath }));
+        } else {
+          writeStderr(t("cli.hooks.install.prepare-added", { path: result.packageJsonPath }));
+        }
+      }
+    })
+  }
+});
+async function installHooks(target, options = {}) {
+  const normalizedTarget = normalizeTarget2(target);
+  assertExistingDirectory(normalizedTarget);
+  const huskyDir = join6(normalizedTarget, ".husky");
+  const hookPath = join6(huskyDir, "pre-commit");
+  const packageJsonPath = join6(normalizedTarget, "package.json");
+  if (!existsSync6(packageJsonPath)) {
+    throw new Error(t("cli.hooks.errors.package-json-required", { path: packageJsonPath }));
+  }
+  mkdirSync2(huskyDir, { recursive: true });
+  const templateContent = readFileSync2(findTemplatePath2("templates/husky/pre-commit"), "utf8");
+  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 : {};
+  const hadPrepare = typeof scripts.prepare === "string" && scripts.prepare.trim().length > 0;
+  let prepareAction = "left";
+  if (!hadPrepare) {
+    scripts.prepare = "husky install";
+    packageJson.scripts = scripts;
+    await atomicWriteJson2(packageJsonPath, packageJson);
+    prepareAction = "added";
+  }
+  const installed = [];
+  const skipped = [];
+  if (hookAction === "skipped") {
+    skipped.push(hookPath);
+  } else {
+    installed.push(hookPath);
+  }
+  if (prepareAction === "left") {
+    skipped.push(packageJsonPath);
+  } else {
+    installed.push(packageJsonPath);
+  }
+  return {
+    installed,
+    skipped,
+    hookPath,
+    packageJsonPath,
+    hookAction,
+    prepareAction
+  };
+}
+function normalizeTarget2(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve6(process.cwd(), targetInput);
+}
+function assertExistingDirectory(target) {
+  if (!existsSync6(target) || !statSync(target).isDirectory()) {
+    throw new Error(t("cli.shared.target-invalid", { target }));
+  }
+}
+async function installHookFile(hookPath, templateContent, force) {
+  if (existsSync6(hookPath)) {
+    if (force) {
+      await atomicWriteText3(hookPath, templateContent);
+      return "overwritten";
+    }
+    const existing = readFileSync2(hookPath, "utf8");
+    if (existing.includes("FAB_BIN=")) {
+      return "skipped";
+    }
+    const fabricBlock = templateContent.replace(/^#!\/bin\/sh\n/, "");
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    await atomicWriteText3(hookPath, `${existing}${separator}# --- Fabric ---
+${fabricBlock}`);
+    return "appended";
+  }
+  await atomicWriteText3(hookPath, templateContent);
+  return "created";
+}
+function findTemplatePath2(relativePath) {
+  const currentModuleDir = dirname4(fileURLToPath2(import.meta.url));
+  const candidates = [
+    ...templateCandidatesFrom2(process.cwd(), relativePath),
+    ...templateCandidatesFrom2(currentModuleDir, relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync6(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
+}
+function templateCandidatesFrom2(start, relativePath) {
+  const candidates = [];
+  let current = resolve6(start);
+  while (true) {
+    candidates.push(join6(current, ...relativePath.split("/")));
+    const parent = dirname4(current);
+    if (parent === current || parse2(current).root === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates.reverse();
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+
+// src/commands/config.ts
+var CLIENT_ALIASES2 = {
+  claude: "ClaudeCodeCLI",
+  claudecodecli: "ClaudeCodeCLI",
+  "claude-code-cli": "ClaudeCodeCLI",
+  claudecli: "ClaudeCodeCLI",
+  claudecodedesktop: "ClaudeCodeDesktop",
+  "claude-code-desktop": "ClaudeCodeDesktop",
+  claudedesktop: "ClaudeCodeDesktop",
+  cursor: "Cursor",
+  codexcli: "CodexCLI",
+  "codex-cli": "CodexCLI",
+  codex: "CodexCLI"
+};
+function parseClientFilter2(value) {
+  if (value === void 0 || value.trim().length === 0) {
+    return null;
+  }
+  const clients = /* @__PURE__ */ new Set();
+  for (const rawClient of value.split(",")) {
+    const alias = rawClient.trim().toLowerCase();
+    const clientKind = CLIENT_ALIASES2[alias];
+    if (clientKind === void 0) {
+      throw new Error(t("cli.config.errors.unknown-client", { client: rawClient }));
+    }
+    clients.add(clientKind);
+  }
+  return clients;
+}
+async function loadFabricConfig(workspaceRoot) {
+  const configPath = resolve7(workspaceRoot, "fabric.config.json");
+  if (!existsSync7(configPath)) {
+    return {};
+  }
+  const parsed = JSON.parse(await readFile3(configPath, "utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+  }
+  return parsed;
+}
+function resolveServerPath(override) {
+  if (override) return override;
+  if (process.env.FAB_SERVER_PATH) return resolve7(process.env.FAB_SERVER_PATH);
+  return fileURLToPath3(import.meta.resolve("@fenglimg/fabric-server"));
+}
+function writeStderr2(message) {
+  process.stderr.write(`${message}
+`);
+}
+var configCmd = defineCommand3({
+  meta: {
+    name: "config",
+    description: t("cli.config.description")
+  },
+  subCommands: {
+    hooks: hooksCommand,
+    install: defineCommand3({
+      meta: {
+        name: "install",
+        description: t("cli.config.install.description")
+      },
+      args: {
+        clients: {
+          type: "string",
+          description: t("cli.config.install.args.clients.description")
+        },
+        "dry-run": {
+          type: "boolean",
+          description: t("cli.config.install.args.dry-run.description"),
+          default: false
+        }
+      },
+      async run({ args }) {
+        const selectedClients = parseClientFilter2(args.clients);
+        const result = await installMcpClients(process.cwd(), {
+          clients: selectedClients === null ? void 0 : Array.from(selectedClients),
+          dryRun: args["dry-run"]
+        });
+        if (result.details.length === 0) {
+          writeStderr2(t("cli.config.install.no-configs"));
+          return;
+        }
+        for (const detail of result.details) {
+          if (detail.action === "skipped") {
+            writeStderr2(t("cli.config.install.no-config-path", { client: detail.client }));
+            continue;
+          }
+          if (detail.action === "dry-run" && detail.path !== null) {
+            writeStderr2(t("cli.config.install.dry-run", { client: detail.client, path: detail.path }));
+            continue;
+          }
+          if (detail.path !== null) {
+            writeStderr2(t("cli.config.install.wrote", { client: detail.client, path: detail.path }));
+          }
+        }
+      }
+    })
+  }
+});
+async function installMcpClients(target, options = {}) {
+  const workspaceRoot = resolve7(target);
+  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, { claudeMcpScope: options.claudeMcpScope }).filter(
+    (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
+  );
+  const installed = [];
+  const skipped = [];
+  const details = [];
+  for (const writer of writers) {
+    const configPath = await writer.detect(workspaceRoot);
+    if (configPath === null) {
+      skipped.push(writer.clientKind);
+      details.push({ client: writer.clientKind, path: null, action: "skipped" });
+      continue;
+    }
+    if (options.dryRun) {
+      skipped.push(writer.clientKind);
+      details.push({ client: writer.clientKind, path: configPath, action: "dry-run" });
+      continue;
+    }
+    await writer.write(serverPath, workspaceRoot);
+    installed.push(writer.clientKind);
+    details.push({ client: writer.clientKind, path: configPath, action: "wrote" });
+  }
+  return { installed, skipped, details };
+}
+
 // src/scanner/forensic.ts
 import { execFileSync } from "child_process";
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute, join, posix, relative, resolve, sep } from "path";
+import { basename, extname, isAbsolute as isAbsolute3, join as join7, posix, relative, resolve as resolve8, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
@@ -127,7 +972,7 @@ var parserInitPromise = null;
 var languagePromiseByKind = {};
 var parserBundlePromiseByKind = {};
 async function buildForensicReport(targetInput) {
-  const target = normalizeTarget(targetInput);
+  const target = normalizeTarget3(targetInput);
   const framework = detectFramework(target);
   const topology = buildTopology(target);
   const entryPoints = collectEntryPoints(target, topology.files);
@@ -163,11 +1008,11 @@ async function buildForensicReport(targetInput) {
   }
   return validation.data;
 }
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+function normalizeTarget3(targetInput) {
+  return isAbsolute3(targetInput) ? targetInput : resolve8(process.cwd(), targetInput);
 }
 function buildTopology(root) {
-  assertExistingDirectory(root);
+  assertExistingDirectory2(root);
   const byExt = {};
   const keyDirs = /* @__PURE__ */ new Set();
   const files = [];
@@ -180,7 +1025,7 @@ function buildTopology(root) {
       continue;
     }
     for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join(current, entry.name);
+      const absolutePath = join7(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -200,7 +1045,7 @@ function buildTopology(root) {
       if (!entry.isFile()) {
         continue;
       }
-      const stats = statSync(absolutePath);
+      const stats = statSync2(absolutePath);
       const extension = extname(entry.name) || "[none]";
       byExt[extension] = (byExt[extension] ?? 0) + 1;
       totalFiles += 1;
@@ -218,8 +1063,8 @@ function buildTopology(root) {
     files: files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
   };
 }
-function assertExistingDirectory(target) {
-  if (!existsSync(target) || !statSync(target).isDirectory()) {
+function assertExistingDirectory2(target) {
+  if (!existsSync8(target) || !statSync2(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -268,7 +1113,7 @@ function getEntryPointReason(relativePath) {
 async function buildCodeSamples(target, entryPoints, frameworkKind, topology, packageDependencies) {
   const samples = [];
   for (const entryPoint of entryPoints.slice(0, SAMPLE_LIMIT)) {
-    const absolutePath = join(target, ...entryPoint.path.split("/"));
+    const absolutePath = join7(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -288,7 +1133,7 @@ async function buildCodeSamples(target, entryPoints, frameworkKind, topology, pa
 }
 function readFirstLines(path, lineLimit) {
   try {
-    const lines = readFileSync(path, "utf8").split(/\r?\n/);
+    const lines = readFileSync3(path, "utf8").split(/\r?\n/);
     if (lines.at(-1) === "") {
       lines.pop();
     }
@@ -305,12 +1150,12 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join(target, "package.json");
-  if (!existsSync(packageJsonPath)) {
+  const packageJsonPath = join7(target, "package.json");
+  if (!existsSync8(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
     return new Map([
       ...Object.entries(packageJson.dependencies ?? {}),
       ...Object.entries(packageJson.devDependencies ?? {}),
@@ -646,16 +1491,16 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join(target, "README.md");
-  const hasContributing = existsSync(join(target, "CONTRIBUTING.md"));
-  if (!existsSync(readmePath)) {
+  const readmePath = join7(target, "README.md");
+  const hasContributing = existsSync8(join7(target, "CONTRIBUTING.md"));
+  if (!existsSync8(readmePath)) {
     return {
       quality: "missing",
       line_count: 0,
       has_contributing: hasContributing
     };
   }
-  const readme = readFileSync(readmePath, "utf8");
+  const readme = readFileSync3(readmePath, "utf8");
   const wordCount = readme.trim().split(/\s+/).filter(Boolean).length;
   return {
     quality: wordCount >= 200 ? "ok" : "stub",
@@ -888,7 +1733,7 @@ function buildDomainAssertion(codeSamples) {
       namedModules.length >= 2 ? "domain-named-components" : null,
       namedSamples.some((sample) => sample.snippet.includes("start():")) ? "lifecycle-hook" : null
     ]),
-    proposedRule: "Preserve domain-specific module names when mirroring structure into AGENTS.md or .fabric/agents/."
+    proposedRule: "Preserve domain-specific module names when mirroring structure into .fabric/rules/."
   });
 }
 function createAssertion(input) {
@@ -1133,10 +1978,10 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join(target, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join7(target, "package.json");
+  if (existsSync8(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
       if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
         return packageJson.name;
       }
@@ -1147,7 +1992,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.6.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)));
@@ -1157,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";
@@ -1165,10 +2010,10 @@ var CODEX_SESSION_START_HOOK_TEMPLATE = "templates/codex-hooks/fabric-session-st
 var CODEX_STOP_HOOK_TEMPLATE = "templates/codex-hooks/fabric-stop-reminder.cjs";
 var CODEX_SESSION_START_COMMAND = ".codex/hooks/fabric-session-start.cjs";
 var CODEX_STOP_COMMAND = ".codex/hooks/fabric-stop-reminder.cjs";
-var LOCAL_FABRIC_SERVER_PATH = join2("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+var LOCAL_FABRIC_SERVER_PATH = join8("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
 var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
 var INIT_WIZARD_GROUP_CANCELLED = /* @__PURE__ */ Symbol("init-wizard-group-cancelled");
-var initCommand = defineCommand({
+var initCommand = defineCommand4({
   meta: {
     name: "init",
     description: t("cli.init.description")
@@ -1227,6 +2072,10 @@ var initCommand = defineCommand({
       type: "string",
       default: "global",
       description: t("cli.init.mcp.install.prompt")
+    },
+    scope: {
+      type: "string",
+      description: t("cli.init.mcp.scope.description")
     }
   },
   async run({ args }) {
@@ -1238,37 +2087,42 @@ 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);
   }
   if (intent.options.planOnly) {
-    writeStderr(t("cli.init.compat.plan"));
+    writeStderr3(t("cli.init.compat.plan"));
   }
   if (args.interactive === false) {
-    writeStderr(t("cli.init.compat.interactive"));
+    writeStderr3(t("cli.init.compat.interactive"));
   }
   if (args.bootstrap === false || args.mcp === false || args.hooks === false) {
-    writeStderr(t("cli.init.compat.legacy-stage-flags"));
+    writeStderr3(t("cli.init.compat.legacy-stage-flags"));
   }
   const supports = detectClientSupports(intent.target);
   const basePlan = await buildInitExecutionPlan({
     target: intent.target,
     options: intent.options,
     mcpInstallMode: intent.mcpInstallMode,
+    claudeMcpScope: intent.claudeMcpScope,
     interactive: intent.interactiveSummary && !intent.wizardEnabled,
     supports
   });
   const plan = intent.wizardEnabled ? await resolveInitExecutionPlanWithWizard(basePlan, args, createDefaultInitWizardAdapter()) : basePlan;
   if (plan === null) {
-    writeStderr(t("cli.init.wizard.cancelled"));
+    writeStderr3(t("cli.init.wizard.cancelled"));
     throw new Error(t("cli.init.wizard.cancelled"));
   }
   return executeInitExecutionPlan(plan);
 }
 function resolveInitCliIntent(args, targetInput) {
-  const target = normalizeTarget2(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;
@@ -1284,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
     },
@@ -1308,6 +2175,7 @@ async function buildInitExecutionPlan(input) {
     target: input.target,
     options,
     mcpInstallMode,
+    claudeMcpScope,
     interactive: input.interactive ?? false,
     supports,
     scaffold,
@@ -1322,10 +2190,10 @@ async function buildInitExecutionPlan(input) {
 }
 async function executeInitExecutionPlan(plan) {
   if (plan.options.force) {
-    writeStderr(t("cli.init.force.warning", { path: plan.target }));
+    writeStderr3(t("cli.init.force.warning", { path: plan.target }));
   }
   if (plan.options.reapply && !plan.options.planOnly && !plan.interactive) {
-    writeStderr(formatInitModeBanner(plan.options));
+    writeStderr3(formatInitModeBanner(plan.options));
   }
   if (plan.interactive) {
     printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
@@ -1347,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":
@@ -1371,28 +2239,28 @@ async function executeInitExecutionPlan(plan) {
   };
 }
 async function buildInitFabricPlan(target, options) {
-  assertExistingDirectory2(target);
-  const fabricDir = join2(target, ".fabric");
-  const bootstrapPath = join2(fabricDir, "bootstrap", "README.md");
-  const forensicPath = join2(fabricDir, "forensic.json");
-  const taxonomyPath = join2(fabricDir, "INITIAL_TAXONOMY.md");
-  const claudeSkillPath = join2(target, ".claude", "skills", "agents-md-init", "SKILL.md");
-  const codexSkillPath = join2(target, ".agents", "skills", "fabric-init", "SKILL.md");
-  const codexSessionStartHookPath = join2(target, ".codex", "hooks", "fabric-session-start.cjs");
-  const codexStopHookPath = join2(target, ".codex", "hooks", "fabric-stop-reminder.cjs");
-  const codexHooksConfigPath = join2(target, ".codex", "hooks.json");
-  const claudeHookPath = join2(target, ".claude", "hooks", "agents-md-init-reminder.cjs");
-  const claudeSettingsPath = join2(target, ".claude", "settings.json");
-  const metaPath = join2(fabricDir, "agents.meta.json");
-  const humanLockPath = join2(fabricDir, "human-lock.json");
+  assertExistingDirectory3(target);
+  const fabricDir = join8(target, ".fabric");
+  const bootstrapPath = join8(fabricDir, "bootstrap", "README.md");
+  const forensicPath = join8(fabricDir, "forensic.json");
+  const taxonomyPath = join8(fabricDir, "INITIAL_TAXONOMY.md");
+  const rulesDir = join8(fabricDir, "rules");
+  const eventsPath = join8(fabricDir, "events.jsonl");
+  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");
+  const codexHooksConfigPath = join8(target, ".codex", "hooks.json");
+  const claudeHookPath = join8(target, ".claude", "hooks", "agents-md-init-reminder.cjs");
+  const claudeSettingsPath = join8(target, ".claude", "settings.json");
+  const metaPath = join8(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
   const bootstrapAction = planFreshPath(bootstrapPath, options);
   const metaAction = planFreshPath(metaPath, options);
   const taxonomyAction = planFreshPath(taxonomyPath, options);
-  const humanLockAction = planFreshPath(humanLockPath, options);
+  const eventsAction = planFreshPath(eventsPath, options);
   const forensicAction = planFreshPath(forensicPath, options);
   const forensicReport = await buildForensicReport(target);
-  const humanLockTemplate = readFileSync2(findTemplatePath("templates/fabric/human-lock.json"), "utf8");
   const bootstrapContent = await buildFabricBootstrapGuide(target);
   const taxonomyContent = buildInitialTaxonomyMarkdown(forensicReport);
   const bootstrapHash = sha256(bootstrapContent);
@@ -1411,62 +2279,79 @@ async function buildInitFabricPlan(target, options) {
     taxonomyPath,
     taxonomyAction,
     taxonomyContent,
-    humanLockPath,
-    humanLockAction,
-    humanLockContent: humanLockTemplate.endsWith("\n") ? humanLockTemplate : `${humanLockTemplate}
-`,
+    rulesDir,
+    eventsPath,
+    eventsAction,
     forensicPath,
     forensicAction,
     forensicReport,
-    claudeSkill: buildOptionalTemplateWritePlan(claudeSkillPath, findTemplatePath(CLAUDE_INIT_SKILL_TEMPLATE), options),
-    codexSkill: buildOptionalTemplateWritePlan(codexSkillPath, findTemplatePath(CODEX_INIT_SKILL_TEMPLATE), options),
+    claudeSkill: buildOptionalTemplateWritePlan(claudeSkillPath, findTemplatePath3(CLAUDE_INIT_SKILL_TEMPLATE), options),
+    codexSkill: buildOptionalTemplateWritePlan(codexSkillPath, findTemplatePath3(CODEX_INIT_SKILL_TEMPLATE), options),
     codexSessionStartHook: buildOptionalTemplateWritePlan(
       codexSessionStartHookPath,
-      findTemplatePath(CODEX_SESSION_START_HOOK_TEMPLATE),
+      findTemplatePath3(CODEX_SESSION_START_HOOK_TEMPLATE),
       options,
       true
     ),
     codexStopHook: buildOptionalTemplateWritePlan(
       codexStopHookPath,
-      findTemplatePath(CODEX_STOP_HOOK_TEMPLATE),
+      findTemplatePath3(CODEX_STOP_HOOK_TEMPLATE),
       options,
       true
     ),
     codexHooksConfig: buildCodexHooksConfigPlan(codexHooksConfigPath, options),
     claudeHook: buildOptionalTemplateWritePlan(
       claudeHookPath,
-      findTemplatePath(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
+      findTemplatePath3(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
       options,
       true
     ),
     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 });
   }
-  mkdirSync(plan.fabricDir, { recursive: true });
-  mkdirSync(dirname(plan.bootstrapPath), { recursive: true });
+  mkdirSync3(plan.fabricDir, { recursive: true });
+  mkdirSync3(dirname5(plan.bootstrapPath), { recursive: true });
   preparePlannedPath(plan.bootstrapPath, plan.bootstrapAction);
-  writeFileSync(plan.bootstrapPath, plan.bootstrapContent, "utf8");
-  preparePlannedPath(plan.metaPath, plan.metaAction);
-  writeFileSync(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);
-  writeFileSync(plan.taxonomyPath, ensureTrailingNewline(plan.taxonomyContent), "utf8");
-  preparePlannedPath(plan.humanLockPath, plan.humanLockAction);
-  writeFileSync(plan.humanLockPath, plan.humanLockContent, "utf8");
+  await atomicWriteText4(plan.taxonomyPath, ensureTrailingNewline2(plan.taxonomyContent));
+  mkdirSync3(plan.rulesDir, { recursive: true });
+  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);
-  writeFileSync(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,
@@ -1474,8 +2359,8 @@ function executeInitFabricPlan(plan) {
     metaAction: plan.metaAction,
     taxonomyPath: plan.taxonomyPath,
     taxonomyAction: plan.taxonomyAction,
-    humanLockPath: plan.humanLockPath,
-    humanLockAction: plan.humanLockAction,
+    eventsPath: plan.eventsPath,
+    eventsAction: plan.eventsAction,
     forensicPath: plan.forensicPath,
     forensicAction: plan.forensicAction,
     claudeSkillPath: plan.claudeSkill.path,
@@ -1495,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;
@@ -1506,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) {
@@ -1520,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
   });
@@ -1537,19 +2424,19 @@ function printInitScaffoldResult(created) {
   console.log(formatInitPathAction(created.bootstrapPath, created.bootstrapAction));
   console.log(formatInitPathAction(created.metaPath, created.metaAction));
   console.log(formatInitPathAction(created.taxonomyPath, created.taxonomyAction));
-  console.log(formatInitPathAction(created.humanLockPath, created.humanLockAction));
+  console.log(formatInitPathAction(created.eventsPath, created.eventsAction));
   console.log(formatInitPathAction(created.forensicPath, created.forensicAction));
-  writeStderr(formatOptionalInitPathAction(created.claudeSkillPath, created.claudeSkillAction));
-  writeStderr(formatOptionalInitPathAction(created.codexSkillPath, created.codexSkillAction));
-  writeStderr(
+  writeStderr3(formatOptionalInitPathAction(created.claudeSkillPath, created.claudeSkillAction));
+  writeStderr3(formatOptionalInitPathAction(created.codexSkillPath, created.codexSkillAction));
+  writeStderr3(
     formatOptionalInitPathAction(created.codexSessionStartHookPath, created.codexSessionStartHookAction)
   );
-  writeStderr(
+  writeStderr3(
     formatOptionalInitPathAction(created.codexStopHookPath, created.codexStopHookAction)
   );
-  writeStderr(formatCodexHooksAction(created.codexHooksConfigPath, created.codexHooksConfigAction));
-  writeStderr(formatOptionalInitPathAction(created.claudeHookPath, created.claudeHookAction));
-  writeStderr(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
+  writeStderr3(formatCodexHooksAction(created.codexHooksConfigPath, created.codexHooksConfigAction));
+  writeStderr3(formatOptionalInitPathAction(created.claudeHookPath, created.claudeHookAction));
+  writeStderr3(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
 }
 function printInitPostSetup(plan, stageResults, finalSupports) {
   if (shouldPrintHooksNextStep(plan.options, stageResults)) {
@@ -1589,8 +2476,8 @@ function buildPlanOnlyScaffoldResult(plan) {
     metaAction: plan.metaAction,
     taxonomyPath: plan.taxonomyPath,
     taxonomyAction: plan.taxonomyAction,
-    humanLockPath: plan.humanLockPath,
-    humanLockAction: plan.humanLockAction,
+    eventsPath: plan.eventsPath,
+    eventsAction: plan.eventsAction,
     forensicPath: plan.forensicPath,
     forensicAction: plan.forensicAction,
     claudeSkillPath: plan.claudeSkill.path,
@@ -1634,16 +2521,17 @@ async function executeInitStagePlan(plan, stageName) {
       case "mcp": {
         if (stage.installMode === "local") {
           const manager = stage.packageManager ?? detectPackageManager(plan.target);
-          writeStderr(t("cli.init.mcp.install.local"));
-          writeStderr(t("cli.init.mcp.local.installing", { manager }));
+          writeStderr3(t("cli.init.mcp.install.local"));
+          writeStderr3(t("cli.init.mcp.local.installing", { manager }));
           installLocalFabricServer(plan.target, manager);
-          writeStderr(t("cli.init.mcp.local.installed"));
+          writeStderr3(t("cli.init.mcp.local.installed"));
         } else {
-          writeStderr(t("cli.init.mcp.install.global"));
+          writeStderr3(t("cli.init.mcp.install.global"));
         }
         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")));
@@ -1661,15 +2549,15 @@ async function executeInitStagePlan(plan, stageName) {
         return exhaustiveInitStagePlan(stage);
     }
   } catch (error) {
-    writeStderr(formatInitStageFailure(stageName, error));
+    writeStderr3(formatInitStageFailure(stageName, error));
     return { name: stageName, disposition: "failed" };
   }
 }
 function shouldReplaceWritableDirectory(path, options) {
-  if (!existsSync2(path)) {
+  if (!existsSync9(path)) {
     return false;
   }
-  if (statSync2(path).isDirectory()) {
+  if (statSync3(path).isDirectory()) {
     return false;
   }
   if (!options?.force) {
@@ -1678,7 +2566,7 @@ function shouldReplaceWritableDirectory(path, options) {
   return true;
 }
 function planFreshPath(path, options) {
-  if (!existsSync2(path)) {
+  if (!existsSync9(path)) {
     return "created";
   }
   if (!options?.force) {
@@ -1687,13 +2575,13 @@ function planFreshPath(path, options) {
   return "overwritten";
 }
 function preparePlannedPath(path, action) {
-  mkdirSync(dirname(path), { recursive: true });
-  if (action === "overwritten" && existsSync2(path)) {
+  mkdirSync3(dirname5(path), { recursive: true });
+  if (action === "overwritten" && existsSync9(path)) {
     rmSync(path, { recursive: true, force: true });
   }
 }
 function buildOptionalTemplateWritePlan(path, templatePath, options, executable = false) {
-  const existed = existsSync2(path);
+  const existed = existsSync9(path);
   if (existed && !options?.force) {
     return { path, action: "skipped", templatePath, executable };
   }
@@ -1708,10 +2596,10 @@ function applyOptionalTemplateWritePlan(plan) {
   if (plan.action === "skipped") {
     return;
   }
-  mkdirSync(dirname(plan.path), { recursive: true });
+  mkdirSync3(dirname5(plan.path), { recursive: true });
   copyFileSync(plan.templatePath, plan.path);
   if (plan.executable) {
-    chmodSync(plan.path, 493);
+    chmodSync2(plan.path, 493);
   }
 }
 function buildCodexHooksConfigValue() {
@@ -1733,48 +2621,48 @@ function buildCodexHooksConfigValue() {
   };
 }
 function buildCodexHooksConfigPlan(configPath, options) {
-  const action = !existsSync2(configPath) ? "created" : options?.force ? "overwritten" : "skipped";
+  const action = !existsSync9(configPath) ? "created" : options?.force ? "overwritten" : "skipped";
   return {
     path: configPath,
     action,
     value: buildCodexHooksConfigValue()
   };
 }
-function applyJsonWritePlan(plan) {
+async function applyJsonWritePlan(plan) {
   if (plan.action === "skipped") {
     return;
   }
-  mkdirSync(dirname(plan.path), { recursive: true });
-  writeJsonAtomically(plan.path, plan.value);
+  mkdirSync3(dirname5(plan.path), { recursive: true });
+  await atomicWriteJson3(plan.path, plan.value);
 }
 function buildClaudeSettingsWritePlan(settingsPath, options) {
   let settings;
   let action = "updated";
-  if (!existsSync2(settingsPath)) {
+  if (!existsSync9(settingsPath)) {
     settings = {};
     action = "created";
   } else {
     try {
-      const parsed = JSON.parse(readFileSync2(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync4(settingsPath, "utf8"));
       if (!isRecord(parsed)) {
-        writeStderr(t("cli.init.claude-settings.invalid-object", { label: skippedLabel(), path: settingsPath }));
+        writeStderr3(t("cli.init.claude-settings.invalid-object", { label: skippedLabel(), path: settingsPath }));
         return { path: settingsPath, action: "skipped-invalid", value: null };
       }
       settings = parsed;
     } catch (error) {
       const reason = error instanceof Error ? error.message : "unknown parse error";
-      writeStderr(t("cli.init.claude-settings.invalid-json", { label: skippedLabel(), path: settingsPath, reason }));
+      writeStderr3(t("cli.init.claude-settings.invalid-json", { label: skippedLabel(), path: settingsPath, reason }));
       return { path: settingsPath, action: "skipped-invalid", value: null };
     }
   }
   if (settings.hooks !== void 0 && !isRecord(settings.hooks)) {
-    writeStderr(t("cli.init.claude-settings.invalid-hooks", { label: skippedLabel(), path: settingsPath }));
+    writeStderr3(t("cli.init.claude-settings.invalid-hooks", { label: skippedLabel(), path: settingsPath }));
     return { path: settingsPath, action: "skipped-invalid", value: null };
   }
   const hooks = settings.hooks ?? {};
   const stopHooksValue = hooks.Stop;
   if (stopHooksValue !== void 0 && !Array.isArray(stopHooksValue)) {
-    writeStderr(t("cli.init.claude-settings.invalid-stop-array", { label: skippedLabel(), path: settingsPath }));
+    writeStderr3(t("cli.init.claude-settings.invalid-stop-array", { label: skippedLabel(), path: settingsPath }));
     return { path: settingsPath, action: "skipped-invalid", value: null };
   }
   const stopHooks = Array.isArray(stopHooksValue) ? stopHooksValue : [];
@@ -1805,12 +2693,12 @@ function buildClaudeSettingsWritePlan(settingsPath, options) {
     value: nextSettings
   };
 }
-function applyClaudeSettingsWritePlan(plan) {
+async function applyClaudeSettingsWritePlan(plan) {
   if (plan.value === null) {
     return;
   }
-  mkdirSync(dirname(plan.path), { recursive: true });
-  writeJsonAtomically(plan.path, plan.value);
+  mkdirSync3(dirname5(plan.path), { recursive: true });
+  await atomicWriteJson3(plan.path, plan.value);
 }
 function createDefaultInitWizardAdapter() {
   return {
@@ -1858,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)
@@ -1924,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) {
@@ -1964,23 +2871,23 @@ function formatInitModeBadge(options) {
   }
   return t("cli.init.mode.badge.default");
 }
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
+function normalizeTarget4(targetInput) {
+  return isAbsolute4(targetInput) ? targetInput : resolve9(process.cwd(), targetInput);
 }
-function assertExistingDirectory2(target) {
-  if (!existsSync2(target) || !statSync2(target).isDirectory()) {
+function assertExistingDirectory3(target) {
+  if (!existsSync9(target) || !statSync3(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
 function detectPackageManager(cwd) {
-  const workspaceRoot = resolve2(cwd);
-  if (existsSync2(join2(workspaceRoot, "pnpm-lock.yaml"))) {
+  const workspaceRoot = resolve9(cwd);
+  if (existsSync9(join8(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync2(join2(workspaceRoot, "yarn.lock"))) {
+  if (existsSync9(join8(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync2(join2(workspaceRoot, "package-lock.json"))) {
+  if (existsSync9(join8(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";
@@ -1989,7 +2896,7 @@ function resolveMcpInstallMode(rawMode) {
   if (rawMode === void 0 || rawMode === "global" || rawMode === "local") {
     return rawMode ?? "global";
   }
-  writeStderr(t("cli.init.mcp.install.invalid", { value: rawMode }));
+  writeStderr3(t("cli.init.mcp.install.invalid", { value: rawMode }));
   return "global";
 }
 function installLocalFabricServer(target, manager) {
@@ -2016,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";
@@ -2066,30 +2988,30 @@ function sanitizeTaxonomyLabel(value) {
   const sanitized = value.replaceAll("\\", "/").split("/").filter(Boolean).join("-").replace(/[^A-Za-z0-9_-]+/gu, "-").replace(/^-+|-+$/gu, "");
   return sanitized === "" ? "General" : sanitized;
 }
-function ensureTrailingNewline(value) {
+function ensureTrailingNewline2(value) {
   return value.endsWith("\n") ? value : `${value}
 `;
 }
-function findTemplatePath(relativePath) {
-  const currentModuleDir = dirname(fileURLToPath(import.meta.url));
+function findTemplatePath3(relativePath) {
+  const currentModuleDir = dirname5(fileURLToPath4(import.meta.url));
   const candidates = [
-    ...templateCandidatesFrom(process.cwd(), relativePath),
-    ...templateCandidatesFrom(currentModuleDir, relativePath)
+    ...templateCandidatesFrom3(process.cwd(), relativePath),
+    ...templateCandidatesFrom3(currentModuleDir, relativePath)
   ];
   for (const candidate of candidates) {
-    if (existsSync2(candidate)) {
+    if (existsSync9(candidate)) {
       return candidate;
     }
   }
   throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
 }
-function templateCandidatesFrom(start, relativePath) {
+function templateCandidatesFrom3(start, relativePath) {
   const candidates = [];
-  let current = resolve2(start);
+  let current = resolve9(start);
   while (true) {
-    candidates.push(join2(current, ...relativePath.split("/")));
-    const parent = dirname(current);
-    if (parent === current || parse(current).root === current) {
+    candidates.push(join8(current, ...relativePath.split("/")));
+    const parent = dirname5(current);
+    if (parent === current || parse3(current).root === current) {
       break;
     }
     current = parent;
@@ -2110,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`;
-  writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-  renameSync(tempPath, path);
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2187,7 +3103,8 @@ function printInitPlanSummary(target, options, mcpInstallMode, supports) {
   console.log(t("cli.init.plan.writes"));
   console.log(`  - ${target}/.fabric/bootstrap/README.md`);
   console.log(`  - ${target}/.fabric/agents.meta.json`);
-  console.log(`  - ${target}/.fabric/human-lock.json`);
+  console.log(`  - ${target}/.fabric/INITIAL_TAXONOMY.md`);
+  console.log(`  - ${target}/.fabric/events.jsonl`);
   console.log(`  - ${target}/.fabric/forensic.json`);
 }
 function printInitCapabilitySummary(supports, stageResults, options) {
@@ -2351,7 +3268,7 @@ function skippedStageLabel() {
 function failedStageLabel() {
   return paint.error(t("cli.init.stages.failed"));
 }
-function writeStderr(message) {
+function writeStderr3(message) {
   process.stderr.write(`${message}
 `);
 }