@fenglimg/fabric-cli 2.0.0-rc.11 → 2.0.0-rc.15

package/dist/{init-C56PWHID.js → install-JLDCHAXV.js}

@@ -1,19 +1,13 @@
 #!/usr/bin/env node
 import {
-  hooksCommand,
-  installHooks
-} from "./chunk-WPTA74BY.js";
+  installMcpClients
+} from "./chunk-AIB54QRT.js";
 import {
   detectExistingLanguage,
-  detectFramework,
   runInitScan
-} from "./chunk-5MQ52F42.js";
+} from "./chunk-AXIFEVAS.js";
 import {
-  detectClientSupports,
-  resolveClients
-} from "./chunk-HQLEHH4O.js";
-import {
-  addArchiveSkillPointer,
+  addFabricKnowledgeBaseSection,
   installArchiveHintHook,
   installFabricArchiveSkill,
   installFabricImportSkill,
@@ -22,175 +16,180 @@ import {
   installKnowledgeHintNarrowHook,
   mergeClaudeCodeHookConfig,
   mergeCodexHookConfig,
-  mergeCursorHookConfig
-} from "./chunk-AW3G7ZH5.js";
+  mergeCursorHookConfig,
+  readFabricLanguagePreference
+} from "./chunk-UTF4YBDN.js";
+import {
+  detectClientSupports
+} from "./chunk-SKSYUHKK.js";
 import {
   displayWidth,
+  hasActionHint,
   padEnd,
-  paint
-} from "./chunk-WWNXR34K.js";
+  paint,
+  renderFabricError
+} from "./chunk-G2CIOLD4.js";
+import {
+  t
+} from "./chunk-6ICJICVU.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-OBQU6NHO.js";
-import {
-  t
-} from "./chunk-6ICJICVU.js";
 
-// src/commands/init.ts
+// src/commands/install.ts
 import { randomUUID } from "crypto";
 import { homedir } from "os";
 import * as childProcess from "child_process";
-import { appendFileSync, existsSync as existsSync3, mkdirSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
-import { dirname, isAbsolute as isAbsolute2, join as join2, resolve as resolve3 } from "path";
+import { appendFileSync, existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync, statSync as statSync3, writeFileSync } from "fs";
+import { dirname, isAbsolute as isAbsolute3, join as join3, resolve as resolve3 } from "path";
 import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
 import { defaultAgentsMetaCounters } from "@fenglimg/fabric-shared";
 import { atomicWriteJson, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-import { defineCommand as defineCommand2 } from "citty";
+import { defineCommand } from "citty";
 import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
-// src/commands/config.ts
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { resolve } from "path";
-import { fileURLToPath } from "url";
-import { defineCommand } from "citty";
-var CLIENT_ALIASES = {
-  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 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 clientKind = CLIENT_ALIASES[alias];
-    if (clientKind === void 0) {
-      throw new Error(t("cli.config.errors.unknown-client", { client: rawClient }));
+// src/install/hooks-orchestrator.ts
+import { existsSync, statSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+async function installHooks(target, _options = {}) {
+  const normalizedTarget = normalizeTarget(target);
+  assertExistingDirectory(normalizedTarget);
+  const results = [];
+  results.push(...await runStep(() => installFabricArchiveSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricReviewSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricImportSkill(normalizedTarget)));
+  results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
+  results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
+  results.push(...await runStep(() => installKnowledgeHintNarrowHook(normalizedTarget)));
+  results.push(await runSingleStep("claude-hook-config", () => mergeClaudeCodeHookConfig(normalizedTarget)));
+  results.push(await runSingleStep("codex-hook-config", () => mergeCodexHookConfig(normalizedTarget)));
+  results.push(await runSingleStep("cursor-hook-config", () => mergeCursorHookConfig(normalizedTarget)));
+  const fabricLanguage = readFabricLanguagePreference(normalizedTarget);
+  results.push(...await runStep(() => addFabricKnowledgeBaseSection(normalizedTarget, fabricLanguage)));
+  results.push(...validateHookPaths(normalizedTarget));
+  return summarizeResults(results);
+}
+function validateHookPaths(projectRoot) {
+  const scripts = [
+    { stepSuffix: "", hookFile: "fabric-hint.cjs" },
+    { stepSuffix: "-broad", hookFile: "knowledge-hint-broad.cjs" },
+    { stepSuffix: "-narrow", hookFile: "knowledge-hint-narrow.cjs" }
+  ];
+  const clients = [
+    {
+      client: "claude",
+      configRel: join(".claude", "settings.json"),
+      hookDir: join(".claude", "hooks")
+    },
+    {
+      client: "codex",
+      configRel: join(".codex", "hooks.json"),
+      hookDir: join(".codex", "hooks")
+    },
+    {
+      client: "cursor",
+      configRel: join(".cursor", "hooks.json"),
+      hookDir: join(".cursor", "hooks")
+    }
+  ];
+  const results = [];
+  for (const { client, configRel, hookDir } of clients) {
+    const configPath = resolve(projectRoot, configRel);
+    if (!existsSync(configPath)) {
+      results.push({
+        step: `hook-validate-${client}`,
+        path: configPath,
+        status: "skipped",
+        message: "missing-config"
+      });
+      continue;
+    }
+    for (const { stepSuffix, hookFile } of scripts) {
+      const expectedHookPath = resolve(projectRoot, hookDir, hookFile);
+      const expectedHookRel = join(hookDir, hookFile);
+      const step = `hook-validate-${client}${stepSuffix}`;
+      if (!existsSync(expectedHookPath)) {
+        results.push({
+          step,
+          path: expectedHookPath,
+          status: "error",
+          message: `hook script missing: ${expectedHookRel}`
+        });
+        continue;
+      }
+      results.push({ step, path: expectedHookPath, status: "skipped", message: "ok" });
     }
-    clients.add(clientKind);
   }
-  return clients;
+  return results;
 }
-async function loadFabricConfig(workspaceRoot) {
-  const configPath = resolve(workspaceRoot, "fabric.config.json");
-  if (!existsSync(configPath)) {
-    return {};
-  }
-  const parsed = JSON.parse(await readFile(configPath, "utf8"));
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+async function runStep(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return [
+      {
+        step: "hook-install",
+        path: "",
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    ];
   }
-  return parsed;
-}
-function resolveServerPath(override) {
-  if (override) return override;
-  if (process.env.FAB_SERVER_PATH) return resolve(process.env.FAB_SERVER_PATH);
-  return fileURLToPath(import.meta.resolve("@fenglimg/fabric-server"));
-}
-function writeStderr(message) {
-  process.stderr.write(`${message}
-`);
 }
-var configCmd = defineCommand({
-  meta: {
-    name: "config",
-    description: t("cli.config.description")
-  },
-  subCommands: {
-    hooks: hooksCommand,
-    install: defineCommand({
-      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 = parseClientFilter(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) {
-          writeStderr(t("cli.config.install.no-configs"));
-          return;
-        }
-        for (const detail of result.details) {
-          if (detail.action === "skipped") {
-            writeStderr(t("cli.config.install.no-config-path", { client: detail.client }));
-            continue;
-          }
-          if (detail.action === "dry-run" && detail.path !== null) {
-            writeStderr(t("cli.config.install.dry-run", { client: detail.client, path: detail.path }));
-            continue;
-          }
-          if (detail.path !== null) {
-            writeStderr(t("cli.config.install.wrote", { client: detail.client, path: detail.path }));
-          }
-        }
-      }
-    })
+async function runSingleStep(step, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return {
+      step,
+      path: "",
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
   }
-});
-async function installMcpClients(target, options = {}) {
-  const workspaceRoot = resolve(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)
-  );
+}
+function summarizeResults(results) {
   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;
+  const errors = [];
+  for (const r of results) {
+    switch (r.status) {
+      case "written":
+        installed.push(r.path);
+        break;
+      case "skipped":
+        skipped.push(r.path);
+        break;
+      case "error":
+        errors.push(`${r.step} ${r.path}: ${r.message ?? "unknown error"}`);
+        break;
     }
-    await writer.write(serverPath, workspaceRoot);
-    installed.push(writer.clientKind);
-    details.push({ client: writer.clientKind, path: configPath, action: "wrote" });
   }
-  return { installed, skipped, details };
+  return { installed, skipped, errors };
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function assertExistingDirectory(target) {
+  if (!existsSync(target) || !statSync(target).isDirectory()) {
+    throw new Error(t("cli.shared.target-invalid", { target }));
+  }
 }
 
 // src/scanner/forensic.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "fs";
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute, join, posix, relative, resolve as resolve2, sep } from "path";
+import { basename, extname, isAbsolute as isAbsolute2, join as join2, posix, relative, resolve as resolve2, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
+
+// src/scanner/detector.ts
+import { detectFramework } from "@fenglimg/fabric-shared/node";
+
+// src/scanner/forensic.ts
 var require2 = createRequire(import.meta.url);
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
   ".fabric",
@@ -273,7 +272,7 @@ var parserInitPromise = null;
 var languagePromiseByKind = {};
 var parserBundlePromiseByKind = {};
 async function buildForensicReport(targetInput) {
-  const target = normalizeTarget(targetInput);
+  const target = normalizeTarget2(targetInput);
   const framework = detectFramework(target);
   const topology = buildTopology(target);
   const entryPoints = collectEntryPoints(target, topology.files);
@@ -309,11 +308,11 @@ async function buildForensicReport(targetInput) {
   }
   return validation.data;
 }
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
+function normalizeTarget2(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
 }
 function buildTopology(root) {
-  assertExistingDirectory(root);
+  assertExistingDirectory2(root);
   const byExt = {};
   const keyDirs = /* @__PURE__ */ new Set();
   const files = [];
@@ -326,7 +325,7 @@ function buildTopology(root) {
       continue;
     }
     for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join(current, entry.name);
+      const absolutePath = join2(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -346,7 +345,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;
@@ -364,8 +363,8 @@ function buildTopology(root) {
     files: files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
   };
 }
-function assertExistingDirectory(target) {
-  if (!existsSync2(target) || !statSync(target).isDirectory()) {
+function assertExistingDirectory2(target) {
+  if (!existsSync2(target) || !statSync2(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -414,7 +413,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 = join2(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -451,7 +450,7 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join(target, "package.json");
+  const packageJsonPath = join2(target, "package.json");
   if (!existsSync2(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
@@ -792,8 +791,8 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join(target, "README.md");
-  const hasContributing = existsSync2(join(target, "CONTRIBUTING.md"));
+  const readmePath = join2(target, "README.md");
+  const hasContributing = existsSync2(join2(target, "CONTRIBUTING.md"));
   if (!existsSync2(readmePath)) {
     return {
       quality: "missing",
@@ -1279,7 +1278,7 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join(target, "package.json");
+  const packageJsonPath = join2(target, "package.json");
   if (existsSync2(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
@@ -1293,7 +1292,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.11" : "unknown";
+  return true ? "2.0.0-rc.15" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1302,7 +1301,7 @@ function toPosixPath(path) {
   return path.split(sep).join("/");
 }
 
-// src/commands/init.ts
+// src/commands/install.ts
 var AGENTS_MD_DEFAULT_CONTENT = `# Project Knowledge
 
 This project uses [Fabric](https://github.com/fenglimg/fabric) for cross-client AI knowledge management.
@@ -1312,99 +1311,60 @@ Run \`fabric doctor\` to verify state.
 
 See \`.fabric/knowledge/\` for project decisions, pitfalls, guidelines, models, and processes.
 `;
-var LOCAL_FABRIC_SERVER_PATH = join2("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+var LOCAL_FABRIC_SERVER_PATH = join3("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 = defineCommand2({
+var installCommand = defineCommand({
   meta: {
-    name: "init",
-    description: t("cli.init.description")
+    name: "install",
+    description: t("cli.install.description")
   },
   args: {
-    target: {
-      type: "string",
-      description: t("cli.init.args.target.description")
-    },
     debug: {
       type: "boolean",
-      description: t("cli.init.args.debug.description"),
+      description: t("cli.install.args.debug.description"),
       default: false
     },
-    force: {
+    "dry-run": {
       type: "boolean",
-      description: t("cli.init.args.force.description"),
+      description: t("cli.install.args.dry-run.description"),
       default: false
     },
-    yes: {
-      type: "boolean",
-      description: t("cli.init.args.yes.description"),
-      default: false
-    },
-    plan: {
-      type: "boolean",
-      description: t("cli.init.args.plan.description"),
-      default: false
+    target: {
+      type: "string",
+      description: t("cli.install.args.target.description")
     },
-    reapply: {
+    yes: {
       type: "boolean",
-      description: t("cli.init.args.reapply.description"),
+      description: t("cli.install.args.yes.description"),
       default: false
-    },
-    bootstrap: {
-      type: "boolean",
-      default: true,
-      negativeDescription: t("cli.init.args.no-bootstrap.description")
-    },
-    mcp: {
-      type: "boolean",
-      default: true,
-      negativeDescription: t("cli.init.args.no-mcp.description")
-    },
-    hooks: {
-      type: "boolean",
-      default: true,
-      negativeDescription: t("cli.init.args.no-hooks.description")
-    },
-    interactive: {
-      type: "boolean",
-      description: t("cli.init.args.interactive.description"),
-      default: true
-    },
-    "mcp-install": {
-      type: "string",
-      default: "global",
-      description: t("cli.init.mcp.install.prompt")
-    },
-    scope: {
-      type: "string",
-      description: t("cli.init.mcp.scope.description")
     }
   },
   async run({ args }) {
     await runInitCommand(args);
   }
 });
-var init_default = initCommand;
+var install_default = installCommand;
 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 });
+  const fabricInitialized = existsSync3(join3(intent.target, ".fabric", "events.jsonl"));
+  if (fabricInitialized) {
+    try {
+      checkLockOrThrow(intent.target);
+    } catch (err) {
+      if (hasActionHint(err)) {
+        renderFabricError(err);
+        process.exit(1);
+      }
+      throw err;
+    }
   }
   logger(`init target source: ${resolution.source}`);
   for (const step of resolution.chain) {
     logger(step);
   }
-  if (intent.options.planOnly) {
-    writeStderr2(t("cli.init.compat.plan"));
-  }
-  if (args.interactive === false) {
-    writeStderr2(t("cli.init.compat.interactive"));
-  }
-  if (args.bootstrap === false || args.mcp === false || args.hooks === false) {
-    writeStderr2(t("cli.init.compat.legacy-stage-flags"));
-  }
   const supports = detectClientSupports(intent.target);
   const basePlan = await buildInitExecutionPlan({
     target: intent.target,
@@ -1414,7 +1374,7 @@ async function runInitCommand(args) {
     interactive: intent.interactiveSummary && !intent.wizardEnabled,
     supports
   });
-  const plan = intent.wizardEnabled ? await resolveInitExecutionPlanWithWizard(basePlan, args, createDefaultInitWizardAdapter()) : basePlan;
+  const plan = intent.wizardEnabled ? await resolveInitExecutionPlanWithWizard(basePlan, createDefaultInitWizardAdapter()) : basePlan;
   if (plan === null) {
     process.exitCode = 130;
     return;
@@ -1426,7 +1386,7 @@ async function runInitCommand(args) {
   return result;
 }
 function writeDefaultFabricConfig(fabricDir, targetRoot) {
-  const target = join2(fabricDir, "fabric-config.json");
+  const target = join3(fabricDir, "fabric-config.json");
   if (existsSync3(target)) return;
   const detectedLanguage = detectExistingLanguage(targetRoot);
   const FABRIC_CONFIG_DEFAULTS = {
@@ -1434,7 +1394,7 @@ function writeDefaultFabricConfig(fabricDir, targetRoot) {
     // README.md + docs/*.md (CJK ratio > 0.3 → "zh-CN", else "en"). Users
     // can edit `.fabric/fabric-config.json` to override. See
     // packages/shared/src/schemas/fabric-config.ts for the enum.
-    knowledge_language: detectedLanguage,
+    fabric_language: detectedLanguage,
     // fabric-hint Stop hook Signal A (archive): time-branch threshold, hours
     // since last knowledge_proposed event.
     archive_hint_hours: 24,
@@ -1491,43 +1451,27 @@ function writeDefaultFabricConfig(fabricDir, targetRoot) {
   mkdirSync(fabricDir, { recursive: true });
   writeFileSync(target, JSON.stringify(FABRIC_CONFIG_DEFAULTS, null, 2) + "\n", "utf8");
   log.info(
-    `Detected and fixated knowledge_language = ${detectedLanguage}; edit ${target} to override.`
+    `Detected and fixated fabric_language = ${detectedLanguage}; edit ${target} to override.`
   );
 }
 function resolveInitCliIntent(args, targetInput) {
-  const target = normalizeTarget2(targetInput);
-  const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
-  const claudeMcpScope = resolveClaudeMcpScope(args.scope);
+  const target = normalizeTarget3(targetInput);
+  const mcpInstallMode = "global";
+  const claudeMcpScope = "project";
   const terminalInteractive = isInteractiveInit();
-  const planOnly = args.plan === true;
-  const reapply = args.reapply === true;
+  const planOnly = args["dry-run"] === true;
   const options = {
-    force: reapply ? true : args.force,
-    skipBootstrap: args.bootstrap === false ? true : args.skipBootstrap,
-    skipMcp: args.mcp === false ? true : args.skipMcp,
-    skipHooks: args.hooks === false ? true : args.skipHooks,
-    planOnly,
-    reapply
+    planOnly
   };
   return {
     target,
     options,
     mcpInstallMode,
     claudeMcpScope,
-    interactiveSummary: args.interactive !== false && terminalInteractive,
+    interactiveSummary: terminalInteractive,
     wizardEnabled: shouldUseInitWizard(args, terminalInteractive) && !planOnly
   };
 }
-function resolveClaudeMcpScope(raw) {
-  if (raw === void 0 || raw === "project") {
-    return "project";
-  }
-  if (raw === "user") {
-    return "user";
-  }
-  writeStderr2(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);
@@ -1564,17 +1508,17 @@ async function buildInitExecutionPlan(input) {
   };
 }
 async function executeInitExecutionPlan(plan) {
-  if (plan.options.force) {
-    writeStderr2(t("cli.init.force.warning", { path: plan.target }));
-  }
-  if (plan.options.reapply && !plan.options.planOnly && !plan.interactive) {
-    writeStderr2(formatInitModeBanner(plan.options));
-  }
   if (plan.interactive) {
     printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
   }
+  const scaffoldStates = [
+    { path: plan.scaffold.metaPath, state: plan.scaffold.metaState },
+    { path: plan.scaffold.eventsPath, state: plan.scaffold.eventsState },
+    { path: plan.scaffold.forensicPath, state: plan.scaffold.forensicState }
+  ];
   if (plan.options.planOnly) {
     printInitPlanPreview(plan);
+    printInitDiffStateTable(scaffoldStates);
     return {
       plan,
       created: buildPlanOnlyScaffoldResult(plan.scaffold),
@@ -1582,6 +1526,17 @@ async function executeInitExecutionPlan(plan) {
       finalSupports: plan.supports
     };
   }
+  if (existsSync3(plan.scaffold.fabricDir) && !statSync3(plan.scaffold.fabricDir).isDirectory()) {
+    throw new Error(
+      t("cli.install.diff.drift-abort", { path: plan.scaffold.fabricDir })
+    );
+  }
+  const drifted = scaffoldStates.find(
+    (entry) => entry.state === "drifted" || entry.state === "user-modified"
+  );
+  if (drifted !== void 0) {
+    throw new Error(t("cli.install.diff.drift-abort", { path: drifted.path }));
+  }
   let created = null;
   const stageResults = [];
   let finalSupports = plan.supports;
@@ -1606,6 +1561,11 @@ async function executeInitExecutionPlan(plan) {
         exhaustiveInitExecutionStep(step);
     }
   }
+  if (scaffoldStates.every((entry) => entry.state === "present-canonical")) {
+    console.log(
+      t("cli.install.diff.canonical", { count: String(scaffoldStates.length) })
+    );
+  }
   return {
     plan,
     created: created ?? unreachableInitScaffold(),
@@ -1618,20 +1578,23 @@ function resolvePersonalFabricRoot() {
   return process.env.FABRIC_HOME ?? homedir();
 }
 async function buildInitFabricPlan(target, options) {
-  assertExistingDirectory2(target);
-  const fabricDir = join2(target, ".fabric");
-  const agentsMdPath = join2(target, "AGENTS.md");
+  assertExistingDirectory3(target);
+  const fabricDir = join3(target, ".fabric");
+  const agentsMdPath = join3(target, "AGENTS.md");
   const agentsMdAction = existsSync3(agentsMdPath) ? "preserved" : "created";
-  const knowledgeDir = join2(fabricDir, "knowledge");
-  const personalKnowledgeDir = join2(resolvePersonalFabricRoot(), ".fabric", "knowledge");
-  const forensicPath = join2(fabricDir, "forensic.json");
-  const eventsPath = join2(fabricDir, "events.jsonl");
-  const metaPath = join2(fabricDir, "agents.meta.json");
+  const knowledgeDir = join3(fabricDir, "knowledge");
+  const personalKnowledgeDir = join3(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const forensicPath = join3(fabricDir, "forensic.json");
+  const eventsPath = join3(fabricDir, "events.jsonl");
+  const metaPath = join3(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
   const knowledgeDirAction = existsSync3(knowledgeDir) ? "overwritten" : "created";
-  const metaAction = planFreshPath(metaPath, options);
-  const eventsAction = planFreshPath(eventsPath, options);
-  const forensicAction = planFreshPath(forensicPath, options);
+  const metaClassification = classifyFreshPath(metaPath, "structural");
+  const eventsClassification = classifyFreshPath(eventsPath, "presence");
+  const forensicClassification = classifyFreshPath(forensicPath, "always-rewrite");
+  const metaAction = diffStateToWriteAction(metaClassification.state);
+  const eventsAction = diffStateToWriteAction(eventsClassification.state);
+  const forensicAction = diffStateToWriteAction(forensicClassification.state);
   const forensicReport = await buildForensicReport(target);
   const meta = createInitialMeta();
   return {
@@ -1651,11 +1614,13 @@ async function buildInitFabricPlan(target, options) {
     eventsAction,
     forensicPath,
     forensicAction,
-    forensicReport
+    forensicReport,
+    metaState: metaClassification.state,
+    eventsState: eventsClassification.state,
+    forensicState: forensicClassification.state
   };
 }
 async function executeInitFabricPlan(plan) {
-  const isReapply = plan.options?.reapply === true;
   if (plan.replaceFabricDir) {
     rmSync(plan.fabricDir, { force: true });
   }
@@ -1666,9 +1631,9 @@ async function executeInitFabricPlan(plan) {
   }
   mkdirSync(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
-    const teamSubDir = join2(plan.knowledgeDir, sub);
+    const teamSubDir = join3(plan.knowledgeDir, sub);
     mkdirSync(teamSubDir, { recursive: true });
-    const teamGitkeep = join2(teamSubDir, ".gitkeep");
+    const teamGitkeep = join3(teamSubDir, ".gitkeep");
     if (!existsSync3(teamGitkeep)) {
       writeFileSync(teamGitkeep, "", "utf8");
     }
@@ -1676,36 +1641,49 @@ async function executeInitFabricPlan(plan) {
   try {
     mkdirSync(plan.personalKnowledgeDir, { recursive: true });
     for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync(join2(plan.personalKnowledgeDir, sub), { recursive: true });
+      mkdirSync(join3(plan.personalKnowledgeDir, sub), { recursive: true });
     }
   } catch {
   }
-  preparePlannedPath(plan.metaPath, plan.metaAction);
-  await atomicWriteJson(plan.metaPath, plan.meta);
-  if (isReapply) {
-    if (!existsSync3(plan.eventsPath)) {
-      mkdirSync(dirname(plan.eventsPath), { recursive: true });
-      writeFileSync(plan.eventsPath, "", "utf8");
-    }
-  } else {
+  if (plan.metaState === "missing") {
+    preparePlannedPath(plan.metaPath, plan.metaAction);
+    await atomicWriteJson(plan.metaPath, plan.meta);
+  }
+  if (plan.eventsState === "missing") {
     preparePlannedPath(plan.eventsPath, plan.eventsAction);
+    mkdirSync(dirname(plan.eventsPath), { recursive: true });
     writeFileSync(plan.eventsPath, "", "utf8");
   }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
   await atomicWriteJson(plan.forensicPath, plan.forensicReport);
-  if (!plan.options?.reapply) {
+  const wasCanonicalReRun = plan.metaState === "present-canonical" && plan.eventsState === "present-canonical";
+  if (!wasCanonicalReRun) {
     try {
       await runInitScan(plan.target, { source: "init" });
     } catch (error) {
-      writeStderr2(
+      writeStderr(
         `[warn] init-scan failed: ${error instanceof Error ? error.message : String(error)} \u2014 re-run \`fab scan\` to populate baseline knowledge entries.`
       );
     }
   }
-  if (isReapply) {
-    appendReapplyLedgerEvent(plan.eventsPath, {
-      preserved_ledger: true
-    });
+  if (existsSync3(plan.eventsPath)) {
+    const applied = [];
+    const canonical = [];
+    const drifted = [];
+    for (const entry of [
+      { path: plan.metaPath, state: plan.metaState },
+      { path: plan.eventsPath, state: plan.eventsState },
+      { path: plan.forensicPath, state: plan.forensicState }
+    ]) {
+      if (entry.state === "missing") {
+        applied.push(entry.path);
+      } else if (entry.state === "present-canonical") {
+        canonical.push(entry.path);
+      } else {
+        drifted.push(entry.path);
+      }
+    }
+    appendInstallDiffLedgerEvent(plan.eventsPath, { applied, canonical, drifted });
   }
   return {
     agentsMdPath: plan.agentsMdPath,
@@ -1725,16 +1703,16 @@ async function initFabric(target, options) {
   return await executeInitFabricPlan(await buildInitFabricPlan(target, options));
 }
 function shouldUseInitWizard(args, terminalInteractive = isInteractiveInit()) {
-  return terminalInteractive && args.interactive !== false && args.yes !== true;
+  return terminalInteractive && args.yes !== true;
 }
-async function resolveInitExecutionPlanWithWizard(basePlan, args, wizardAdapter) {
+async function resolveInitExecutionPlanWithWizard(basePlan, wizardAdapter) {
   const selection = await wizardAdapter.run({
     target: basePlan.target,
     options: basePlan.options,
     supports: basePlan.supports,
     mcpInstallMode: basePlan.mcpInstallMode,
     claudeMcpScope: basePlan.claudeMcpScope,
-    lockedStages: collectLockedWizardStages(args)
+    lockedStages: []
   });
   if (selection === null) {
     return null;
@@ -1772,27 +1750,36 @@ function printInitScaffoldResult(created) {
 function printInitPostSetup(plan, stageResults, finalSupports) {
   if (shouldPrintHooksNextStep(plan.options, stageResults)) {
     console.log(
-      t("cli.init.next-step", {
+      t("cli.install.next-step", {
         label: nextLabel(),
-        message: paint.muted(t("cli.init.next-step.message"))
+        message: paint.muted(t("cli.install.next-step.message"))
       })
     );
   }
   console.log(
-    t("cli.init.reason-message", {
+    t("cli.install.reason-message", {
       label: reasonLabel(),
       message: paint.muted(formatInitReasonMessage(finalSupports))
     })
   );
   printInitStageSummary(stageResults);
   printInitCapabilitySummary(finalSupports, stageResults, plan.options);
+  const fabricLanguage = readFabricLanguagePreference(plan.target);
+  console.log(
+    paint.muted(t("cli.install.language_preference_hint", { value: fabricLanguage }))
+  );
+}
+function printInitDiffStateTable(entries) {
+  for (const entry of entries) {
+    console.log(`  ${formatDiffFileState(entry.state)}  ${entry.path}`);
+  }
 }
 function printInitPlanPreview(plan) {
-  console.log(t("cli.init.plan.preview-title"));
+  console.log(t("cli.install.plan.preview-title"));
   printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
   console.log(
-    t("cli.init.plan.preview-result", {
-      mode: plan.options.reapply ? t("cli.init.mode.reapply") : t("cli.init.mode.default"),
+    t("cli.install.plan.preview-result", {
+      mode: t("cli.install.mode.default"),
       bootstrap: yesNoLabel(!plan.options.skipBootstrap),
       mcp: yesNoLabel(!plan.options.skipMcp),
       hooks: yesNoLabel(!plan.options.skipHooks)
@@ -1822,7 +1809,7 @@ async function executeInitStagePlan(plan, stageName) {
   if (stage.skipped) {
     return { name: stageName, disposition: "skipped" };
   }
-  console.log(formatInitStageHeader(t(`cli.init.stages.${stageName}`)));
+  console.log(formatInitStageHeader(t(`cli.install.stages.${stageName}`)));
   try {
     switch (stage.name) {
       case "bootstrap": {
@@ -1836,13 +1823,14 @@ async function executeInitStagePlan(plan, stageName) {
         installResults.push(await runBestEffortSingle("claude-hook-config", () => mergeClaudeCodeHookConfig(plan.target)));
         installResults.push(await runBestEffortSingle("codex-hook-config", () => mergeCodexHookConfig(plan.target)));
         installResults.push(await runBestEffortSingle("cursor-hook-config", () => mergeCursorHookConfig(plan.target)));
-        installResults.push(...await runBestEffort("pointer", () => addArchiveSkillPointer(plan.target)));
+        const fabricLanguage = readFabricLanguagePreference(plan.target);
+        installResults.push(...await runBestEffort("section", () => addFabricKnowledgeBaseSection(plan.target, fabricLanguage)));
         const installedCount = installResults.filter((r) => r.status === "written").length;
         const skippedCount = installResults.filter((r) => r.status === "skipped").length;
         const errorCount = installResults.filter((r) => r.status === "error").length;
         for (const result of installResults) {
           if (result.status === "error") {
-            writeStderr2(`bootstrap ${result.step} ${result.path}: ${result.message ?? "unknown error"}`);
+            writeStderr(`bootstrap ${result.step} ${result.path}: ${result.message ?? "unknown error"}`);
           }
         }
         const note2 = errorCount > 0 ? `errors=${errorCount}` : void 0;
@@ -1852,15 +1840,14 @@ async function executeInitStagePlan(plan, stageName) {
       case "mcp": {
         if (stage.installMode === "local") {
           const manager = stage.packageManager ?? detectPackageManager(plan.target);
-          writeStderr2(t("cli.init.mcp.install.local"));
-          writeStderr2(t("cli.init.mcp.local.installing", { manager }));
+          writeStderr(t("cli.install.mcp.install.local"));
+          writeStderr(t("cli.install.mcp.local.installing", { manager }));
           installLocalFabricServer(plan.target, manager);
-          writeStderr2(t("cli.init.mcp.local.installed"));
+          writeStderr(t("cli.install.mcp.local.installed"));
         } else {
-          writeStderr2(t("cli.init.mcp.install.global"));
+          writeStderr(t("cli.install.mcp.install.global"));
         }
         const result = await installMcpClients(plan.target, {
-          force: plan.options.force,
           localServerPath: stage.localServerPath,
           claudeMcpScope: stage.claudeMcpScope
         });
@@ -1872,7 +1859,7 @@ async function executeInitStagePlan(plan, stageName) {
         return { name: "mcp", disposition: "ran" };
       }
       case "hooks": {
-        const result = await installHooks(plan.target, { force: plan.options.force });
+        const result = await installHooks(plan.target);
         console.log(formatInitStageResult("hooks", "completed", result.installed.length, result.skipped.length));
         return { name: "hooks", disposition: "ran" };
       }
@@ -1880,30 +1867,66 @@ async function executeInitStagePlan(plan, stageName) {
         return exhaustiveInitStagePlan(stage);
     }
   } catch (error) {
-    writeStderr2(formatInitStageFailure(stageName, error));
+    writeStderr(formatInitStageFailure(stageName, error));
     return { name: stageName, disposition: "failed" };
   }
 }
-function shouldReplaceWritableDirectory(path, options) {
+function shouldReplaceWritableDirectory(path, _options) {
   if (!existsSync3(path)) {
     return false;
   }
-  if (statSync2(path).isDirectory()) {
+  if (statSync3(path).isDirectory()) {
     return false;
   }
-  if (!options?.force) {
-    throw new Error(t("cli.init.errors.abort-existing", { path }));
-  }
-  return true;
+  return false;
 }
-function planFreshPath(path, options) {
+function classifyFreshPath(path, strategy) {
   if (!existsSync3(path)) {
-    return "created";
+    return { path, state: "missing" };
+  }
+  let stat;
+  try {
+    stat = statSync3(path);
+  } catch (error) {
+    return {
+      path,
+      state: "user-modified",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (!stat.isFile()) {
+    return { path, state: "user-modified", reason: "expected a file" };
+  }
+  if (strategy === "presence" || strategy === "always-rewrite") {
+    return { path, state: "present-canonical" };
   }
-  if (!options?.force) {
-    throw new Error(t("cli.init.errors.abort-existing", { path }));
+  try {
+    const raw = readFileSync2(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { path, state: "user-modified", reason: "not a JSON object" };
+    }
+    const record = parsed;
+    const hasRevision = typeof record["revision"] === "string";
+    const hasNodes = record["nodes"] !== void 0 && record["nodes"] !== null && typeof record["nodes"] === "object" && !Array.isArray(record["nodes"]);
+    const hasCounters = record["counters"] !== void 0 && record["counters"] !== null && typeof record["counters"] === "object" && !Array.isArray(record["counters"]);
+    if (!hasRevision || !hasNodes || !hasCounters) {
+      return { path, state: "drifted", reason: "missing required AgentsMeta fields" };
+    }
+    return { path, state: "present-canonical" };
+  } catch (error) {
+    return {
+      path,
+      state: "user-modified",
+      reason: error instanceof Error ? error.message : String(error)
+    };
   }
-  return "overwritten";
+}
+function diffStateToWriteAction(_state) {
+  return "created";
+}
+function formatDiffFileState(state) {
+  return t(`cli.install.diff.state.${state}`);
 }
 function preparePlannedPath(path, action) {
   mkdirSync(dirname(path), { recursive: true });
@@ -1914,59 +1937,59 @@ function preparePlannedPath(path, action) {
 function createDefaultInitWizardAdapter() {
   return {
     async run(context) {
-      intro(t("cli.init.wizard.intro"));
+      intro(t("cli.install.wizard.intro"));
       note(
-        t("cli.init.wizard.overview.body", {
+        t("cli.install.wizard.overview.body", {
           target: context.target,
           mode: formatInitModeBadge(context.options)
         }),
-        t("cli.init.wizard.overview.title")
+        t("cli.install.wizard.overview.title")
       );
       printInitPlanSummary(context.target, context.options, context.mcpInstallMode, context.supports);
-      log.step(t("cli.init.wizard.step.target"));
+      log.step(t("cli.install.wizard.step.target"));
       const continueWithTarget = await confirm({
-        message: t("cli.init.wizard.target.confirm", { target: context.target }),
+        message: t("cli.install.wizard.target.confirm", { target: context.target }),
         initialValue: true
       });
       if (isCancel(continueWithTarget) || !continueWithTarget) {
         emitInitWizardCancellation();
         return null;
       }
-      log.step(t("cli.init.wizard.step.plan"));
+      log.step(t("cli.install.wizard.step.plan"));
       let groupedSelection;
       try {
         groupedSelection = await group(
           {
             bootstrap: async () => context.lockedStages.includes("bootstrap") ? false : confirmInGroup({
-              message: t("cli.init.wizard.stage.bootstrap", {
+              message: t("cli.install.wizard.stage.bootstrap", {
                 defaultValue: formatPromptDefault(!context.options.skipBootstrap)
               }),
               initialValue: !context.options.skipBootstrap
             }),
             mcp: async () => context.lockedStages.includes("mcp") ? false : confirmInGroup({
-              message: t("cli.init.wizard.stage.mcp", {
+              message: t("cli.install.wizard.stage.mcp", {
                 defaultValue: formatPromptDefault(!context.options.skipMcp)
               }),
               initialValue: !context.options.skipMcp
             }),
             mcpInstallMode: async ({ results }) => results.mcp ? selectMcpInstallModeInGroup({
-              message: t("cli.init.wizard.mcp-install", { defaultValue: context.mcpInstallMode }),
+              message: t("cli.install.wizard.mcp-install", { defaultValue: context.mcpInstallMode }),
               initialValue: context.mcpInstallMode,
               options: [
-                { value: "global", label: "global", hint: t("cli.init.mcp.install.global") },
-                { value: "local", label: "local", hint: t("cli.init.mcp.install.local") }
+                { value: "global", label: "global", hint: t("cli.install.mcp.install.global") },
+                { value: "local", label: "local", hint: t("cli.install.mcp.install.local") }
               ]
             }) : context.mcpInstallMode,
             claudeMcpScope: async ({ results }) => results.mcp ? selectClaudeMcpScopeInGroup({
-              message: t("cli.init.wizard.mcp-scope", { defaultValue: context.claudeMcpScope }),
+              message: t("cli.install.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") }
+                { value: "project", label: "project", hint: t("cli.install.mcp.scope.project") },
+                { value: "user", label: "user", hint: t("cli.install.mcp.scope.user") }
               ]
             }) : context.claudeMcpScope,
             hooks: async () => context.lockedStages.includes("hooks") ? false : confirmInGroup({
-              message: t("cli.init.wizard.stage.hooks", {
+              message: t("cli.install.wizard.stage.hooks", {
                 defaultValue: formatPromptDefault(!context.options.skipHooks)
               }),
               initialValue: !context.options.skipHooks
@@ -1995,23 +2018,23 @@ function createDefaultInitWizardAdapter() {
         skipMcp: !groupedSelection.mcp,
         skipHooks: !groupedSelection.hooks
       };
-      log.step(t("cli.init.wizard.step.review"));
+      log.step(t("cli.install.wizard.step.review"));
       printInitPlanSummary(context.target, previewOptions, groupedSelection.mcpInstallMode, context.supports);
       const confirmed = await confirm({
-        message: t("cli.init.wizard.execute.confirm"),
+        message: t("cli.install.wizard.execute.confirm"),
         initialValue: true
       });
       if (isCancel(confirmed) || !confirmed) {
         emitInitWizardCancellation();
         return null;
       }
-      outro(t("cli.init.wizard.outro"));
+      outro(t("cli.install.wizard.outro"));
       return groupedSelection;
     }
   };
 }
 function emitInitWizardCancellation() {
-  cancel(t("cli.init.wizard.cancelled"));
+  cancel(t("cli.install.wizard.cancelled"));
 }
 async function confirmInGroup(options) {
   const result = await confirm(options);
@@ -2042,74 +2065,42 @@ async function selectClaudeMcpScopeInGroup(options) {
   }
   return result;
 }
-function collectLockedWizardStages(args) {
-  const lockedStages = [];
-  if (args.bootstrap === false) {
-    lockedStages.push("bootstrap");
-  }
-  if (args.mcp === false) {
-    lockedStages.push("mcp");
-  }
-  if (args.hooks === false) {
-    lockedStages.push("hooks");
-  }
-  return lockedStages;
-}
 function formatPromptDefault(value) {
   return value ? "Y/n" : "y/N";
 }
 function formatInitModeBanner(options) {
-  if (options.planOnly && options.reapply) {
-    return t("cli.init.plan.mode-banner.plan-reapply");
-  }
   if (options.planOnly) {
-    return t("cli.init.plan.mode-banner.plan");
-  }
-  if (options.reapply) {
-    return t("cli.init.plan.mode-banner.reapply");
+    return t("cli.install.plan.mode-banner.plan");
   }
-  return t("cli.init.plan.mode-banner.default");
+  return t("cli.install.plan.mode-banner.default");
 }
 function formatInitModeBadge(options) {
-  if (options.planOnly && options.reapply) {
-    return t("cli.init.mode.badge.plan-reapply");
-  }
   if (options.planOnly) {
-    return t("cli.init.mode.badge.plan");
-  }
-  if (options.reapply) {
-    return t("cli.init.mode.badge.reapply");
+    return t("cli.install.mode.badge.plan");
   }
-  return t("cli.init.mode.badge.default");
+  return t("cli.install.mode.badge.default");
 }
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
+function normalizeTarget3(targetInput) {
+  return isAbsolute3(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
 }
-function assertExistingDirectory2(target) {
-  if (!existsSync3(target) || !statSync2(target).isDirectory()) {
+function assertExistingDirectory3(target) {
+  if (!existsSync3(target) || !statSync3(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
 function detectPackageManager(cwd) {
   const workspaceRoot = resolve3(cwd);
-  if (existsSync3(join2(workspaceRoot, "pnpm-lock.yaml"))) {
+  if (existsSync3(join3(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync3(join2(workspaceRoot, "yarn.lock"))) {
+  if (existsSync3(join3(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync3(join2(workspaceRoot, "package-lock.json"))) {
+  if (existsSync3(join3(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";
 }
-function resolveMcpInstallMode(rawMode) {
-  if (rawMode === void 0 || rawMode === "global" || rawMode === "local") {
-    return rawMode ?? "global";
-  }
-  writeStderr2(t("cli.init.mcp.install.invalid", { value: rawMode }));
-  return "global";
-}
 function installLocalFabricServer(target, manager) {
   const installArgs = manager === "npm" ? ["install", "-D", FABRIC_SERVER_PACKAGE] : ["add", "-D", FABRIC_SERVER_PACKAGE];
   childProcess.execFileSync(manager, installArgs, {
@@ -2125,14 +2116,16 @@ function createInitialMeta() {
     counters: defaultAgentsMetaCounters()
   };
 }
-function appendReapplyLedgerEvent(eventsPath, payload) {
+function appendInstallDiffLedgerEvent(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
+    event_type: "install_diff_applied",
+    applied: payload.applied,
+    canonical: payload.canonical,
+    drifted: payload.drifted
   };
   const line = `${JSON.stringify(event)}
 `;
@@ -2183,7 +2176,7 @@ function printInitStageSummary(stageResults) {
   console.log(formatInitStageSummaryLine("failed", collectInitStageNames(stageResults, "failed")));
 }
 function formatInitStageSummaryLine(disposition, stages) {
-  const label = disposition === "ran" ? paint.success(t("cli.init.stages.summary.ran")) : disposition === "skipped" ? paint.muted(t("cli.init.stages.summary.skipped")) : paint.error(t("cli.init.stages.summary.failed"));
+  const label = disposition === "ran" ? paint.success(t("cli.install.stages.summary.ran")) : disposition === "skipped" ? paint.muted(t("cli.install.stages.summary.skipped")) : paint.error(t("cli.install.stages.summary.failed"));
   return `${label}: ${stages.length > 0 ? stages.join(", ") : t("cli.shared.none")}`;
 }
 function collectInitStageNames(stageResults, disposition) {
@@ -2196,11 +2189,11 @@ function isInteractiveInit() {
   return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
 }
 function printInitPlanSummary(target, options, mcpInstallMode, supports) {
-  console.log(t("cli.init.plan.title"));
+  console.log(t("cli.install.plan.title"));
   console.log(formatInitModeBanner(options));
-  console.log(t("cli.init.plan.target", { target }));
+  console.log(t("cli.install.plan.target", { target }));
   console.log(
-    t("cli.init.plan.actions", {
+    t("cli.install.plan.actions", {
       bootstrap: yesNoLabel(!options.skipBootstrap),
       mcp: yesNoLabel(!options.skipMcp),
       hooks: yesNoLabel(!options.skipHooks),
@@ -2209,11 +2202,11 @@ function printInitPlanSummary(target, options, mcpInstallMode, supports) {
   );
   const detected = supports.filter((support) => support.detected);
   console.log(
-    t("cli.init.plan.detected", {
+    t("cli.install.plan.detected", {
       clients: detected.length > 0 ? detected.map((support) => support.label).join(", ") : t("cli.shared.none")
     })
   );
-  console.log(t("cli.init.plan.writes"));
+  console.log(t("cli.install.plan.writes"));
   console.log(`  - ${target}/.fabric/knowledge/{decisions,pitfalls,guidelines,models,processes,pending}/`);
   console.log(`  - ${target}/.fabric/agents.meta.json`);
   console.log(`  - ${target}/.fabric/events.jsonl`);
@@ -2223,18 +2216,18 @@ function printInitPlanSummary(target, options, mcpInstallMode, supports) {
 function printInitCapabilitySummary(supports, stageResults, options) {
   const detected = supports.filter((support) => support.detected);
   if (detected.length === 0) {
-    console.log(t("cli.init.capabilities.none"));
+    console.log(t("cli.install.capabilities.none"));
     return;
   }
-  console.log(t("cli.init.capabilities.title"));
+  console.log(t("cli.install.capabilities.title"));
   const rows = detected.map((support) => toCapabilityRow(support, stageResults, options));
   const headers = {
-    client: t("cli.init.capabilities.header.client"),
-    bootstrap: t("cli.init.capabilities.header.bootstrap"),
-    mcp: t("cli.init.capabilities.header.mcp"),
-    hook: t("cli.init.capabilities.header.hook"),
-    skill: t("cli.init.capabilities.header.skill"),
-    followUp: t("cli.init.capabilities.header.follow-up")
+    client: t("cli.install.capabilities.header.client"),
+    bootstrap: t("cli.install.capabilities.header.bootstrap"),
+    mcp: t("cli.install.capabilities.header.mcp"),
+    hook: t("cli.install.capabilities.header.hook"),
+    skill: t("cli.install.capabilities.header.skill"),
+    followUp: t("cli.install.capabilities.header.follow-up")
   };
   const widths = {
     client: Math.max(displayWidth(headers.client), ...rows.map((row) => displayWidth(row.client))),
@@ -2252,8 +2245,8 @@ function printInitCapabilitySummary(supports, stageResults, options) {
 }
 function toCapabilityRow(support, stageResults, options) {
   const stage = (name) => stageResults.find((entry) => entry.name === name)?.disposition ?? null;
-  const bootstrap = support.capabilities.bootstrap ? capabilityStatus(options.skipBootstrap ? "skipped" : stage("bootstrap")) : t("cli.init.capabilities.status.na");
-  const mcp = support.capabilities.mcp ? capabilityStatus(options.skipMcp ? "skipped" : stage("mcp")) : t("cli.init.capabilities.status.na");
+  const bootstrap = support.capabilities.bootstrap ? capabilityStatus(options.skipBootstrap ? "skipped" : stage("bootstrap")) : t("cli.install.capabilities.status.na");
+  const mcp = support.capabilities.mcp ? capabilityStatus(options.skipMcp ? "skipped" : stage("mcp")) : t("cli.install.capabilities.status.na");
   const hook = capabilityInstallStatus(support, "hook");
   const skill = capabilityInstallStatus(support, "skill");
   return {
@@ -2262,14 +2255,14 @@ function toCapabilityRow(support, stageResults, options) {
     mcp,
     hook,
     skill,
-    followUp: hasInstalledCapability(support, "skill") ? t("cli.init.capabilities.follow-up.ready") : support.capabilities.skill ? t("cli.init.capabilities.follow-up.install") : t("cli.init.capabilities.follow-up.manual")
+    followUp: hasInstalledCapability(support, "skill") ? t("cli.install.capabilities.follow-up.ready") : support.capabilities.skill ? t("cli.install.capabilities.follow-up.install") : t("cli.install.capabilities.follow-up.manual")
   };
 }
 function capabilityInstallStatus(support, capability) {
   if (!support.capabilities[capability]) {
-    return t("cli.init.capabilities.status.na");
+    return t("cli.install.capabilities.status.na");
   }
-  return hasInstalledCapability(support, capability) ? t("cli.init.capabilities.status.installed") : t("cli.init.capabilities.status.supported");
+  return hasInstalledCapability(support, capability) ? t("cli.install.capabilities.status.installed") : t("cli.install.capabilities.status.supported");
 }
 function hasInstalledCapability(support, capability) {
   return support.installedCapabilities?.[capability] === true;
@@ -2277,15 +2270,15 @@ function hasInstalledCapability(support, capability) {
 function capabilityStatus(disposition) {
   switch (disposition) {
     case "ran":
-      return t("cli.init.capabilities.status.ready");
+      return t("cli.install.capabilities.status.ready");
     case "skipped":
-      return t("cli.init.capabilities.status.skipped");
+      return t("cli.install.capabilities.status.skipped");
     case "failed":
-      return t("cli.init.capabilities.status.failed");
+      return t("cli.install.capabilities.status.failed");
     case null:
-      return t("cli.init.capabilities.status.na");
+      return t("cli.install.capabilities.status.na");
     default:
-      return t("cli.init.capabilities.status.ready");
+      return t("cli.install.capabilities.status.ready");
   }
 }
 function formatCapabilityTableRow(row, widths) {
@@ -2311,21 +2304,21 @@ function formatCapabilityDivider(widths) {
 function formatInitReasonMessage(supports) {
   const detected = supports.filter((support) => support.detected);
   if (detected.some((support) => support.capabilities.skill)) {
-    return t("cli.init.reason-message.installable-body");
+    return t("cli.install.reason-message.installable-body");
   }
-  return t("cli.init.reason-message.manual-body");
+  return t("cli.install.reason-message.manual-body");
 }
 function yesNoLabel(value) {
   return value ? t("cli.shared.yes") : t("cli.shared.no");
 }
 function formatInitPathAction(path, action) {
-  return t("cli.init.created-path", { label: labelForInitWriteAction(action), path });
+  return t("cli.install.created-path", { label: labelForInitWriteAction(action), path });
 }
 function formatAgentsMdAction(path, action) {
   if (action === "preserved") {
-    return t("cli.init.skipped-existing-path", { label: skippedLabel(), path });
+    return t("cli.install.skipped-existing-path", { label: skippedLabel(), path });
   }
-  return t("cli.init.created-path", { label: createdLabel(), path });
+  return t("cli.install.created-path", { label: createdLabel(), path });
 }
 function labelForInitWriteAction(action) {
   return action === "overwritten" ? overwrittenLabel() : createdLabel();
@@ -2343,18 +2336,18 @@ function reasonLabel() {
   return paint.human(t("cli.shared.reason"));
 }
 function overwrittenLabel() {
-  return paint.warn(t("cli.init.force.overwritten"));
+  return paint.warn(t("cli.install.label.overwritten"));
 }
 function completedStageLabel() {
-  return paint.success(t("cli.init.stages.completed"));
+  return paint.success(t("cli.install.stages.completed"));
 }
 function skippedStageLabel() {
-  return paint.muted(t("cli.init.stages.skipped"));
+  return paint.muted(t("cli.install.stages.skipped"));
 }
 function failedStageLabel() {
-  return paint.error(t("cli.init.stages.failed"));
+  return paint.error(t("cli.install.stages.failed"));
 }
-function writeStderr2(message) {
+function writeStderr(message) {
   process.stderr.write(`${message}
 `);
 }
@@ -2362,12 +2355,12 @@ export {
   buildInitExecutionPlan,
   buildInitFabricPlan,
   createDefaultInitWizardAdapter,
-  init_default as default,
+  install_default as default,
   detectPackageManager,
   executeInitExecutionPlan,
   executeInitFabricPlan,
-  initCommand,
   initFabric,
+  installCommand,
   resolveInitExecutionPlanWithWizard,
   runInitCommand,
   shouldUseInitWizard