@fenglimg/fabric-cli 2.0.0-rc.13 → 2.0.0-rc.21

package/dist/{install-SLS5W27W.js → install-DNZXGFHJ.js}

@@ -1,197 +1,202 @@
 #!/usr/bin/env node
 import {
-  hooksCommand,
-  installHooks
-} from "./chunk-Q72D24BG.js";
+  installMcpClients
+} from "./chunk-KZ2YITOS.js";
 import {
   detectExistingLanguage,
-  detectFramework,
   runInitScan
-} from "./chunk-FDRLV5PL.js";
+} from "./chunk-FNO7CQDG.js";
 import {
-  detectClientSupports,
-  resolveClients
-} from "./chunk-OHWQNSLH.js";
-import {
-  addFabricKnowledgeBaseSection,
   installArchiveHintHook,
   installFabricArchiveSkill,
   installFabricImportSkill,
   installFabricReviewSkill,
+  installHookLibs,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
   mergeClaudeCodeHookConfig,
   mergeCodexHookConfig,
   mergeCursorHookConfig,
-  readFabricLanguagePreference
-} from "./chunk-X7QPY5KH.js";
+  readFabricLanguagePreference,
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeCursorBootstrapManagedBlock,
+  writeFabricAgentsSnapshot
+} from "./chunk-4HC5ZK7H.js";
+import {
+  detectClientSupports
+} from "./chunk-MF3OTILQ.js";
 import {
   displayWidth,
+  hasActionHint,
   padEnd,
-  paint
-} from "./chunk-WWNXR34K.js";
-import {
-  createDebugLogger,
-  resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+  paint,
+  renderFabricError
+} from "./chunk-G2CIOLD4.js";
 import {
   t
 } from "./chunk-6ICJICVU.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-ZSESMG6L.js";
 
 // 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 { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+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 runStep(() => installHookLibs(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)));
+  results.push(await runSingleStep("bootstrap-snapshot", () => writeFabricAgentsSnapshot(normalizedTarget)));
+  results.push(await runSingleStep("bootstrap-claude", () => writeClaudeBootstrapThinShell(normalizedTarget)));
+  results.push(await runSingleStep("bootstrap-codex", () => writeCodexBootstrapManagedBlock(normalizedTarget)));
+  results.push(await runSingleStep("bootstrap-cursor", () => writeCursorBootstrapManagedBlock(normalizedTarget)));
+  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",
@@ -274,7 +279,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);
@@ -310,11 +315,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 = [];
@@ -327,7 +332,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;
@@ -347,7 +352,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;
@@ -365,8 +370,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}`);
   }
 }
@@ -415,7 +420,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,
@@ -452,7 +457,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();
   }
@@ -793,8 +798,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",
@@ -1280,7 +1285,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"));
@@ -1294,7 +1299,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.13" : "unknown";
+  return true ? "2.0.0-rc.21" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1304,81 +1309,33 @@ function toPosixPath(path) {
 }
 
 // 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.
-
-Knowledge entries live in \`.fabric/knowledge/\` (team) and \`~/.fabric/knowledge/\` (personal).
-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 installCommand = defineCommand2({
+var installCommand = defineCommand({
   meta: {
     name: "install",
     description: t("cli.install.description")
   },
   args: {
-    target: {
-      type: "string",
-      description: t("cli.install.args.target.description")
-    },
     debug: {
       type: "boolean",
       description: t("cli.install.args.debug.description"),
       default: false
     },
-    force: {
+    "dry-run": {
       type: "boolean",
-      description: t("cli.install.args.force.description"),
+      description: t("cli.install.args.dry-run.description"),
       default: false
     },
+    target: {
+      type: "string",
+      description: t("cli.install.args.target.description")
+    },
     yes: {
       type: "boolean",
       description: t("cli.install.args.yes.description"),
       default: false
-    },
-    plan: {
-      type: "boolean",
-      description: t("cli.install.args.plan.description"),
-      default: false
-    },
-    reapply: {
-      type: "boolean",
-      description: t("cli.install.args.reapply.description"),
-      default: false
-    },
-    bootstrap: {
-      type: "boolean",
-      default: true,
-      negativeDescription: t("cli.install.args.no-bootstrap.description")
-    },
-    mcp: {
-      type: "boolean",
-      default: true,
-      negativeDescription: t("cli.install.args.no-mcp.description")
-    },
-    hooks: {
-      type: "boolean",
-      default: true,
-      negativeDescription: t("cli.install.args.no-hooks.description")
-    },
-    interactive: {
-      type: "boolean",
-      description: t("cli.install.args.interactive.description"),
-      default: true
-    },
-    "mcp-install": {
-      type: "string",
-      default: "global",
-      description: t("cli.install.mcp.install.prompt")
-    },
-    scope: {
-      type: "string",
-      description: t("cli.install.mcp.scope.description")
     }
   },
   async run({ args }) {
@@ -1390,22 +1347,22 @@ 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.install.compat.plan"));
-  }
-  if (args.interactive === false) {
-    writeStderr2(t("cli.install.compat.interactive"));
-  }
-  if (args.bootstrap === false || args.mcp === false || args.hooks === false) {
-    writeStderr2(t("cli.install.compat.legacy-stage-flags"));
-  }
   const supports = detectClientSupports(intent.target);
   const basePlan = await buildInitExecutionPlan({
     target: intent.target,
@@ -1415,7 +1372,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;
@@ -1427,7 +1384,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 = {
@@ -1496,39 +1453,23 @@ function writeDefaultFabricConfig(fabricDir, targetRoot) {
   );
 }
 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.install.mcp.scope.invalid", { value: raw }));
-  return "project";
-}
 async function buildInitExecutionPlan(input) {
   const options = input.options ?? {};
   const scaffold = await buildInitFabricPlan(input.target, options);
@@ -1565,17 +1506,17 @@ async function buildInitExecutionPlan(input) {
   };
 }
 async function executeInitExecutionPlan(plan) {
-  if (plan.options.force) {
-    writeStderr2(t("cli.install.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),
@@ -1583,6 +1524,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;
@@ -1607,6 +1559,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(),
@@ -1619,20 +1576,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 {
@@ -1652,24 +1612,23 @@ 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 });
   }
   mkdirSync(plan.fabricDir, { recursive: true });
   writeDefaultFabricConfig(plan.fabricDir, plan.target);
-  if (plan.agentsMdAction === "created" && !existsSync3(plan.agentsMdPath)) {
-    await atomicWriteText(plan.agentsMdPath, AGENTS_MD_DEFAULT_CONTENT);
-  }
   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");
     }
@@ -1677,36 +1636,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,
@@ -1726,16 +1698,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;
@@ -1792,12 +1764,17 @@ function printInitPostSetup(plan, stageResults, finalSupports) {
     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.install.plan.preview-title"));
   printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
   console.log(
     t("cli.install.plan.preview-result", {
-      mode: plan.options.reapply ? t("cli.install.mode.reapply") : t("cli.install.mode.default"),
+      mode: t("cli.install.mode.default"),
       bootstrap: yesNoLabel(!plan.options.skipBootstrap),
       mcp: yesNoLabel(!plan.options.skipMcp),
       hooks: yesNoLabel(!plan.options.skipHooks)
@@ -1838,17 +1815,20 @@ async function executeInitStagePlan(plan, stageName) {
         installResults.push(...await runBestEffort("hook-script", () => installArchiveHintHook(plan.target)));
         installResults.push(...await runBestEffort("hook-broad-script", () => installKnowledgeHintBroadHook(plan.target)));
         installResults.push(...await runBestEffort("hook-narrow-script", () => installKnowledgeHintNarrowHook(plan.target)));
+        installResults.push(...await runBestEffort("hook-lib", () => installHookLibs(plan.target)));
         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)));
-        const fabricLanguage = readFabricLanguagePreference(plan.target);
-        installResults.push(...await runBestEffort("section", () => addFabricKnowledgeBaseSection(plan.target, fabricLanguage)));
+        installResults.push(await runBestEffortSingle("bootstrap-snapshot", () => writeFabricAgentsSnapshot(plan.target)));
+        installResults.push(await runBestEffortSingle("bootstrap-claude", () => writeClaudeBootstrapThinShell(plan.target)));
+        installResults.push(await runBestEffortSingle("bootstrap-codex", () => writeCodexBootstrapManagedBlock(plan.target)));
+        installResults.push(await runBestEffortSingle("bootstrap-cursor", () => writeCursorBootstrapManagedBlock(plan.target)));
         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;
@@ -1858,15 +1838,14 @@ async function executeInitStagePlan(plan, stageName) {
       case "mcp": {
         if (stage.installMode === "local") {
           const manager = stage.packageManager ?? detectPackageManager(plan.target);
-          writeStderr2(t("cli.install.mcp.install.local"));
-          writeStderr2(t("cli.install.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.install.mcp.local.installed"));
+          writeStderr(t("cli.install.mcp.local.installed"));
         } else {
-          writeStderr2(t("cli.install.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
         });
@@ -1878,7 +1857,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" };
       }
@@ -1886,30 +1865,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.install.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" };
   }
-  if (!options?.force) {
-    throw new Error(t("cli.install.errors.abort-existing", { path }));
+  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" };
+  }
+  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 });
@@ -2048,74 +2063,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.install.plan.mode-banner.plan-reapply");
-  }
   if (options.planOnly) {
     return t("cli.install.plan.mode-banner.plan");
   }
-  if (options.reapply) {
-    return t("cli.install.plan.mode-banner.reapply");
-  }
   return t("cli.install.plan.mode-banner.default");
 }
 function formatInitModeBadge(options) {
-  if (options.planOnly && options.reapply) {
-    return t("cli.install.mode.badge.plan-reapply");
-  }
   if (options.planOnly) {
     return t("cli.install.mode.badge.plan");
   }
-  if (options.reapply) {
-    return t("cli.install.mode.badge.reapply");
-  }
   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.install.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, {
@@ -2131,14 +2114,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)}
 `;
@@ -2349,7 +2334,7 @@ function reasonLabel() {
   return paint.human(t("cli.shared.reason"));
 }
 function overwrittenLabel() {
-  return paint.warn(t("cli.install.force.overwritten"));
+  return paint.warn(t("cli.install.label.overwritten"));
 }
 function completedStageLabel() {
   return paint.success(t("cli.install.stages.completed"));
@@ -2360,7 +2345,7 @@ function skippedStageLabel() {
 function failedStageLabel() {
   return paint.error(t("cli.install.stages.failed"));
 }
-function writeStderr2(message) {
+function writeStderr(message) {
   process.stderr.write(`${message}
 `);
 }