@fenglimg/fabric-cli 2.0.0 → 2.1.0-rc.2

package/dist/{init-BIRSIOXO.js → install-2HDO5FTQ.js}

@@ -1,444 +1,431 @@
 #!/usr/bin/env node
 import {
-  ClaudeCodeCLIWriter,
-  CursorWriter,
-  addArchiveSkillPointer,
-  createServerEntry,
-  hooksCommand,
+  cleanupDeprecatedSkills,
   installArchiveHintHook,
+  installCitePolicyEvictHook,
   installFabricArchiveSkill,
   installFabricImportSkill,
   installFabricReviewSkill,
-  installHooks,
+  installFabricSyncSkill,
+  installHookLibs,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
+  installSharedSkillLib,
   mergeClaudeCodeHookConfig,
   mergeCodexHookConfig,
   mergeCursorHookConfig,
-  normalizeConfigPath,
-  writeJsonClientConfig
-} from "./chunk-74SZWYPH.js";
-import {
-  detectFramework,
-  runInitScan
-} from "./chunk-EYIDD2YS.js";
+  readFabricLanguagePreference,
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeCursorBootstrapManagedBlock,
+  writeFabricAgentsSnapshot
+} from "./chunk-F46ORPOA.js";
 import {
   displayWidth,
   padEnd,
   paint
 } from "./chunk-WWNXR34K.js";
-import {
-  t
-} from "./chunk-6ICJICVU.js";
 import {
   createDebugLogger,
   resolveDevMode
-} from "./chunk-OBQU6NHO.js";
+} from "./chunk-COI5VDFU.js";
+import {
+  installMcpClients
+} from "./chunk-BATF4PEJ.js";
+import {
+  detectClientSupports
+} from "./chunk-MF3OTILQ.js";
+import {
+  t
+} from "./chunk-PWLW3B57.js";
+import {
+  globalConfigPath,
+  loadGlobalConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig
+} from "./chunk-RYAFBNES.js";
 
-// src/commands/init.ts
-import { randomUUID } from "crypto";
-import { homedir as homedir4 } from "os";
+// src/commands/install.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { homedir } from "os";
 import * as childProcess from "child_process";
-import { appendFileSync, existsSync as existsSync6, mkdirSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join5, resolve as resolve5 } from "path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync4, writeFileSync } from "fs";
+import { dirname, isAbsolute as isAbsolute3, join as join6, 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 as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
-import { defineCommand as defineCommand2 } from "citty";
-import { checkLockOrThrow } from "@fenglimg/fabric-server";
-
-// src/commands/config.ts
-import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { resolve as resolve3 } from "path";
-import { fileURLToPath } from "url";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
 import { defineCommand } from "citty";
 
-// src/config/resolver.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-
-// src/config/claude-code.ts
-import { existsSync } from "fs";
-import { join, resolve } from "path";
-import { homedir, platform } from "os";
-function getClaudeDesktopConfigPath() {
-  const os = platform();
-  if (os === "darwin") {
-    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  }
-  if (os === "win32") {
-    return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  }
-  return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
-}
-var ClaudeCodeDesktopWriter = class {
-  clientKind = "ClaudeCodeDesktop";
-  configuredPath;
-  constructor(configuredPath) {
-    this.configuredPath = configuredPath;
-  }
-  async detect(_workspaceRoot, overridePath) {
-    const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
-    return existsSync(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
-  }
-  async write(serverPath, workspaceRoot, overridePath) {
-    const configPath = await this.detect(workspaceRoot, overridePath);
-    if (configPath === null) {
-      return;
+// 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(() => installFabricSyncSkill(normalizedTarget)));
+  results.push(...await runStep(() => installSharedSkillLib(normalizedTarget)));
+  results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
+  results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
+  results.push(...await runStep(() => installKnowledgeHintNarrowHook(normalizedTarget)));
+  results.push(...await runStep(() => installCitePolicyEvictHook(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")
     }
-    await writeJsonClientConfig(configPath, {
-      command: process.execPath,
-      args: [serverPath]
-    });
-  }
-};
-
-// src/config/toml.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir, readFile } from "fs/promises";
-import { dirname, join as join2, resolve as resolve2 } from "path";
-import { homedir as homedir2 } from "os";
-import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-function expandHome(filePath) {
-  if (filePath === "~") {
-    return homedir2();
-  }
-  if (filePath.startsWith("~/")) {
-    return join2(homedir2(), filePath.slice(2));
-  }
-  return filePath;
-}
-function escapeTomlString(value) {
-  return JSON.stringify(value);
-}
-function serializeTomlStringArray(values) {
-  return `[${values.map((value) => escapeTomlString(value)).join(", ")}]`;
-}
-function serializeTomlInlineTable(values) {
-  const entries = Object.entries(values).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key} = ${escapeTomlString(value)}`);
-  return `{ ${entries.join(", ")} }`;
-}
-function serializeCodexServerBlock(serverName, serverEntry) {
-  const lines = [
-    `[mcp_servers.${serverName}]`,
-    `command = ${escapeTomlString(serverEntry.command)}`,
-    `args = ${serializeTomlStringArray(serverEntry.args)}`
   ];
-  if (serverEntry.env !== void 0 && Object.keys(serverEntry.env).length > 0) {
-    lines.push(`env = ${serializeTomlInlineTable(serverEntry.env)}`);
+  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" });
+    }
   }
-  return `${lines.join("\n")}
-`;
-}
-function trimTrailingBlankLines(value) {
-  return value.replace(/\s+$/u, "");
+  return results;
 }
-function upsertCodexServerBlock(rawConfig, serverName, serverEntry) {
-  const block = serializeCodexServerBlock(serverName, serverEntry);
-  const normalized = rawConfig.replace(/\r\n/g, "\n");
-  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
-  const currentPattern = new RegExp(
-    String.raw`\n?\[mcp_servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
-    "g"
-  );
-  const withoutLegacy = normalized.replace(legacyPattern, "");
-  const withoutExisting = withoutLegacy.replace(currentPattern, "");
-  const trimmed = trimTrailingBlankLines(withoutExisting);
-  if (trimmed.length === 0) {
-    return block;
+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 `${trimmed}
-
-${block}`;
 }
-async function readTomlConfigText(configPath) {
+async function runSingleStep(step, fn) {
   try {
-    return await readFile(configPath, "utf8");
+    return await fn();
   } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return "";
+    return {
+      step,
+      path: "",
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function summarizeResults(results) {
+  const installed = [];
+  const skipped = [];
+  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;
     }
-    throw error;
   }
+  return { installed, skipped, errors };
 }
-var CodexTOMLConfigWriter = class {
-  clientKind = "CodexCLI";
-  configuredPath;
-  constructor(configuredPath) {
-    this.configuredPath = configuredPath;
+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 }));
   }
-  async detect(_workspaceRoot, overridePath) {
-    const explicitPath = overridePath ?? this.configuredPath;
-    if (explicitPath !== void 0) {
-      return resolve2(expandHome(explicitPath));
-    }
-    const codexDir = join2(homedir2(), ".codex");
-    return existsSync2(codexDir) ? resolve2(join2(codexDir, "config.toml")) : null;
+}
+
+// src/install/run-global-install.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdirSync, mkdtempSync, renameSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { STORES_ROOT_DIR as STORES_ROOT_DIR2, addMountedStore, readStoreIdentity } from "@fenglimg/fabric-shared";
+
+// src/store/uid.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+function deriveUid() {
+  let email = "";
+  try {
+    email = execFileSync("git", ["config", "user.email"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    email = "";
   }
-  async write(serverPath, workspaceRoot, overridePath) {
-    const configPath = await this.detect(workspaceRoot, overridePath);
-    if (configPath === null) {
-      return;
-    }
-    const rawConfig = await readTomlConfigText(configPath);
-    const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
-    await mkdir(dirname(configPath), { recursive: true });
-    await atomicWriteText(configPath, nextConfig);
+  if (email === "") {
+    return "u-anon";
   }
-};
+  const hash = createHash("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
+  return `u-${hash}`;
+}
 
-// src/config/resolver.ts
-import { clientPathsSchema, fabricConfigSchema } from "@fenglimg/fabric-shared";
-function hasExplicitPath(clientPaths, key) {
-  return typeof clientPaths?.[key] === "string" && clientPaths[key].trim().length > 0;
-}
-function addIfDetected(writers, detected, createWriter, configuredPath) {
-  if (configuredPath !== void 0 || detected) {
-    writers.push(createWriter(configuredPath));
-  }
-}
-function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
-  const clientPaths = fabricConfig.clientPaths;
-  const writers = [];
-  const claudeMcpScope = opts.claudeMcpScope ?? "project";
-  addIfDetected(
-    writers,
-    existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude")),
-    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
-    hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync3(getClaudeDesktopConfigPath()),
-    (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
-    hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync3(join3(workspaceRoot, ".cursor")),
-    (configuredPath) => new CursorWriter(configuredPath),
-    hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync3(join3(homedir3(), ".codex")),
-    (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
-    hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
-  );
-  return writers;
-}
-function detectClientSupports(workspaceRoot, fabricConfig = {}) {
-  const clientPaths = fabricConfig.clientPaths;
-  const claudeDetected = existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude"));
-  const claudeDesktopDetected = existsSync3(getClaudeDesktopConfigPath());
-  const cursorDetected = existsSync3(join3(workspaceRoot, ".cursor"));
-  const codexDetected = existsSync3(join3(homedir3(), ".codex"));
-  return [
-    {
-      clientKind: "ClaudeCodeCLI",
-      label: "Claude Code CLI",
-      detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "project .claude/settings.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: true,
-        skill: true
-      },
-      installedCapabilities: {
-        hook: true,
-        skill: true
+// src/install/install-global.ts
+import { rmSync } from "fs";
+import { join as join2 } from "path";
+import {
+  STORES_ROOT_DIR,
+  globalConfigSchema,
+  initStore
+} from "@fenglimg/fabric-shared";
+
+// src/install/transaction.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runInstallTransaction(steps) {
+  const receipt = { ok: true, steps: [] };
+  const applied = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    try {
+      await step.apply();
+      applied.push(step);
+      receipt.steps.push({ name: step.name, status: "applied" });
+    } catch (error) {
+      receipt.ok = false;
+      receipt.failedStep = step.name;
+      receipt.error = errorMessage(error);
+      receipt.steps.push({ name: step.name, status: "failed", error: errorMessage(error) });
+      for (let j = i + 1; j < steps.length; j++) {
+        receipt.steps.push({ name: steps[j].name, status: "skipped" });
       }
-    },
-    {
-      clientKind: "ClaudeCodeDesktop",
-      label: "Claude Code Desktop",
-      detected: claudeDesktopDetected || hasExplicitPath(clientPaths, "claudeCodeDesktop"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "desktop Claude config",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
+      for (const done of [...applied].reverse()) {
+        const entry = receipt.steps.find((s) => s.name === done.name);
+        try {
+          await done.rollback();
+          if (entry !== void 0) {
+            entry.status = "rolled_back";
+          }
+        } catch (rollbackError) {
+          if (entry !== void 0) {
+            entry.status = "rollback_failed";
+            entry.error = errorMessage(rollbackError);
+          }
+        }
       }
-    },
+      return receipt;
+    }
+  }
+  return receipt;
+}
+
+// src/install/install-global.ts
+async function installGlobalCore(options) {
+  const existing = loadGlobalConfig(options.globalRoot);
+  if (existing !== null) {
+    return {
+      receipt: { ok: true, steps: [{ name: "already-installed", status: "applied" }] },
+      config: existing,
+      alreadyInstalled: true
+    };
+  }
+  const alias = options.personalAlias ?? "personal";
+  const personalDir = join2(options.globalRoot, STORES_ROOT_DIR, options.personalStoreUuid);
+  let config = null;
+  const receipt = await runInstallTransaction([
     {
-      clientKind: "Cursor",
-      label: "Cursor",
-      detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: ".cursor/mcp.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
+      name: "init-personal-store",
+      apply: () => {
+        initStore(
+          personalDir,
+          {
+            store_uuid: options.personalStoreUuid,
+            created_at: options.now,
+            canonical_alias: alias
+          },
+          { git: options.git }
+        );
+      },
+      rollback: () => {
+        rmSync(personalDir, { recursive: true, force: true });
       }
     },
     {
-      clientKind: "CodexCLI",
-      label: "Codex CLI",
-      detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "~/.codex/config.toml",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: true,
-        skill: true
+      name: "write-global-config",
+      apply: () => {
+        const next = globalConfigSchema.parse({
+          uid: options.uid,
+          stores: [{ store_uuid: options.personalStoreUuid, alias, personal: true }]
+        });
+        saveGlobalConfig(next, options.globalRoot);
+        config = next;
       },
-      installedCapabilities: {
-        hook: existsSync3(join3(workspaceRoot, ".codex", "hooks.json")),
-        // v2/rc.2: v1 client-side init skill removed; skill-installation probes
-        // will return once rc.2/3/4 introduce the v2 skills (fabric-archive,
-        // fabric-review, fabric-import). Until then there is nothing to probe.
-        skill: false
+      rollback: () => {
+        rmSync(globalConfigPath(options.globalRoot), { force: true });
       }
     }
-  ];
+  ]);
+  return { receipt, config, alreadyInstalled: false };
 }
 
-// src/commands/config.ts
-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 }));
-    }
-    clients.add(clientKind);
-  }
-  return clients;
+// src/install/run-global-install.ts
+function gitClone(url, dest) {
+  execFileSync2("git", ["clone", url, dest], { stdio: ["ignore", "ignore", "pipe"] });
+}
+function mountStoreFromRemote(url, globalRoot) {
+  const storesRoot = join3(globalRoot, STORES_ROOT_DIR2);
+  mkdirSync(storesRoot, { recursive: true });
+  const tmp = mkdtempSync(join3(tmpdir(), "fabric-clone-"));
+  const cloneDest = join3(tmp, "store");
+  gitClone(url, cloneDest);
+  const identity = readStoreIdentity(cloneDest);
+  if (identity === null) {
+    throw new Error(`cloned store at ${url} has no valid store.json (not a Fabric store)`);
+  }
+  const finalDir = join3(storesRoot, identity.store_uuid);
+  renameSync(cloneDest, finalDir);
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error("global config missing after install");
+  }
+  const alias = identity.canonical_alias ?? "team";
+  saveGlobalConfig(
+    addMountedStore(config, { store_uuid: identity.store_uuid, alias, remote: url }),
+    globalRoot
+  );
+  console.log(`mounted store '${alias}' (${identity.store_uuid}) from ${url}`);
 }
-async function loadFabricConfig(workspaceRoot) {
-  const configPath = resolve3(workspaceRoot, "fabric.config.json");
-  if (!existsSync4(configPath)) {
-    return {};
+async function runGlobalInstall(options = {}, globalRoot = resolveGlobalRoot()) {
+  const uid = options.uid ?? deriveUid();
+  const personalStoreUuid = options.personalStoreUuid ?? randomUUID();
+  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const result = await installGlobalCore({ globalRoot, uid, personalStoreUuid, now });
+  if (!result.receipt.ok) {
+    throw new Error(`global install failed at step '${result.receipt.failedStep}': ${result.receipt.error}`);
   }
-  const parsed = JSON.parse(await readFile2(configPath, "utf8"));
-  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
+  console.log(
+    result.alreadyInstalled ? "global Fabric already installed" : `installed global Fabric (uid ${uid})`
+  );
+  if (options.url !== void 0) {
+    mountStoreFromRemote(options.url, globalRoot);
   }
-  return parsed;
-}
-function resolveServerPath(override) {
-  if (override) return override;
-  if (process.env.FAB_SERVER_PATH) return resolve3(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 }));
+
+// src/lib/detect-language.ts
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
+import { join as join4 } from "path";
+function detectExistingLanguage(target) {
+  const ZH_CN_RATIO_THRESHOLD = 0.3;
+  const samples = [];
+  const readmePath = join4(target, "README.md");
+  if (existsSync2(readmePath)) {
+    try {
+      samples.push(readFileSync(readmePath, "utf8"));
+    } catch {
+    }
+  }
+  const docsDir = join4(target, "docs");
+  if (existsSync2(docsDir)) {
+    try {
+      const stat = statSync2(docsDir);
+      if (stat.isDirectory()) {
+        for (const entry of readdirSync(docsDir, { withFileTypes: true })) {
+          if (!entry.isFile()) continue;
+          if (!/\.(md|mdx|txt)$/iu.test(entry.name)) continue;
+          try {
+            samples.push(readFileSync(join4(docsDir, entry.name), "utf8"));
+          } catch {
           }
         }
       }
-    })
-  }
-});
-async function installMcpClients(target, options = {}) {
-  const workspaceRoot = resolve3(target);
-  const fabricConfig = await loadFabricConfig(workspaceRoot);
-  const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
-  const serverPath = resolveServerPath(options.localServerPath);
-  const writers = resolveClients(workspaceRoot, fabricConfig, { claudeMcpScope: options.claudeMcpScope }).filter(
-    (writer) => selectedClients === null ? true : selectedClients.has(writer.clientKind)
-  );
-  const installed = [];
-  const skipped = [];
-  const details = [];
-  for (const writer of writers) {
-    const configPath = await writer.detect(workspaceRoot);
-    if (configPath === null) {
-      skipped.push(writer.clientKind);
-      details.push({ client: writer.clientKind, path: null, action: "skipped" });
-      continue;
+    } catch {
     }
-    if (options.dryRun) {
-      skipped.push(writer.clientKind);
-      details.push({ client: writer.clientKind, path: configPath, action: "dry-run" });
-      continue;
+  }
+  if (samples.length === 0) {
+    return "en";
+  }
+  let cjkCount = 0;
+  let asciiLetterCount = 0;
+  for (const sample of samples) {
+    for (const ch of sample) {
+      const code = ch.codePointAt(0) ?? 0;
+      if (code >= 19968 && code <= 40959) {
+        cjkCount += 1;
+      } else if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+        asciiLetterCount += 1;
+      }
     }
-    await writer.write(serverPath, workspaceRoot);
-    installed.push(writer.clientKind);
-    details.push({ client: writer.clientKind, path: configPath, action: "wrote" });
   }
-  return { installed, skipped, details };
+  const denominator = cjkCount + asciiLetterCount;
+  if (denominator === 0) {
+    return "en";
+  }
+  const ratio = cjkCount / denominator;
+  return ratio > ZH_CN_RATIO_THRESHOLD ? "zh-CN-hybrid" : "en";
 }
 
 // src/scanner/forensic.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync5, readdirSync, readFileSync, statSync } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute, join as join4, posix, relative, resolve as resolve4, sep } from "path";
+import { basename, extname, isAbsolute as isAbsolute2, join as join5, 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",
@@ -521,7 +508,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);
@@ -533,7 +520,7 @@ async function buildForensicReport(targetInput) {
   const report = {
     version: "1.0",
     generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    generated_by: `fab-cli@${getCliVersion()}`,
+    generated_by: `fabric-cli@${getCliVersion()}`,
     target,
     project_name: readProjectName(target),
     framework,
@@ -557,11 +544,11 @@ async function buildForensicReport(targetInput) {
   }
   return validation.data;
 }
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve4(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 = [];
@@ -573,8 +560,8 @@ function buildTopology(root) {
     if (current === void 0) {
       continue;
     }
-    for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join4(current, entry.name);
+    for (const entry of readdirSync2(current, { withFileTypes: true })) {
+      const absolutePath = join5(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -594,7 +581,7 @@ function buildTopology(root) {
       if (!entry.isFile()) {
         continue;
       }
-      const stats = statSync(absolutePath);
+      const stats = statSync3(absolutePath);
       const extension = extname(entry.name) || "[none]";
       byExt[extension] = (byExt[extension] ?? 0) + 1;
       totalFiles += 1;
@@ -612,8 +599,8 @@ function buildTopology(root) {
     files: files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
   };
 }
-function assertExistingDirectory(target) {
-  if (!existsSync5(target) || !statSync(target).isDirectory()) {
+function assertExistingDirectory2(target) {
+  if (!existsSync3(target) || !statSync3(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -662,7 +649,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 = join4(target, ...entryPoint.path.split("/"));
+    const absolutePath = join5(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -682,7 +669,7 @@ async function buildCodeSamples(target, entryPoints, frameworkKind, topology, pa
 }
 function readFirstLines(path, lineLimit) {
   try {
-    const lines = readFileSync(path, "utf8").split(/\r?\n/);
+    const lines = readFileSync2(path, "utf8").split(/\r?\n/);
     if (lines.at(-1) === "") {
       lines.pop();
     }
@@ -699,12 +686,12 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join4(target, "package.json");
-  if (!existsSync5(packageJsonPath)) {
+  const packageJsonPath = join5(target, "package.json");
+  if (!existsSync3(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
     return new Map([
       ...Object.entries(packageJson.dependencies ?? {}),
       ...Object.entries(packageJson.devDependencies ?? {}),
@@ -717,7 +704,7 @@ function readPackageDependencies(target) {
 }
 function readGitChurnWeight(target, relativePath) {
   try {
-    const output = execFileSync("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
+    const output = execFileSync3("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
       cwd: target,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -1040,16 +1027,16 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join4(target, "README.md");
-  const hasContributing = existsSync5(join4(target, "CONTRIBUTING.md"));
-  if (!existsSync5(readmePath)) {
+  const readmePath = join5(target, "README.md");
+  const hasContributing = existsSync3(join5(target, "CONTRIBUTING.md"));
+  if (!existsSync3(readmePath)) {
     return {
       quality: "missing",
       line_count: 0,
       has_contributing: hasContributing
     };
   }
-  const readme = readFileSync(readmePath, "utf8");
+  const readme = readFileSync2(readmePath, "utf8");
   const wordCount = readme.trim().split(/\s+/).filter(Boolean).length;
   return {
     quality: wordCount >= 200 ? "ok" : "stub",
@@ -1527,10 +1514,10 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join4(target, "package.json");
-  if (existsSync5(packageJsonPath)) {
+  const packageJsonPath = join5(target, "package.json");
+  if (existsSync3(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
         return packageJson.name;
       }
@@ -1541,7 +1528,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0" : "unknown";
+  return true ? "2.1.0-rc.2" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1550,109 +1537,152 @@ function toPosixPath(path) {
   return path.split(sep).join("/");
 }
 
-// src/commands/init.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 = join5("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+// src/commands/install.ts
+var LOCAL_FABRIC_SERVER_PATH = join6("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
     },
+    target: {
+      type: "string",
+      description: t("cli.install.args.target.description")
+    },
     yes: {
       type: "boolean",
-      description: t("cli.init.args.yes.description"),
+      description: t("cli.install.args.yes.description"),
       default: false
     },
-    plan: {
+    "force-skills-only": {
       type: "boolean",
-      description: t("cli.init.args.plan.description"),
+      description: t("cli.install.args.force-skills-only.description"),
       default: false
     },
-    reapply: {
+    "force-hooks-only": {
       type: "boolean",
-      description: t("cli.init.args.reapply.description"),
+      description: t("cli.install.args.force-hooks-only.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: {
+    global: {
       type: "boolean",
-      description: t("cli.init.args.interactive.description"),
-      default: true
-    },
-    "mcp-install": {
-      type: "string",
-      default: "global",
-      description: t("cli.init.mcp.install.prompt")
+      description: "Set up global Fabric (~/.fabric: uid + personal store + config)",
+      default: false
     },
-    scope: {
+    url: {
       type: "string",
-      description: t("cli.init.mcp.scope.description")
+      description: "With --global: clone + mount this shared store remote"
     }
   },
   async run({ args }) {
     await runInitCommand(args);
   }
 });
-var init_default = initCommand;
+var install_default = installCommand;
+async function runSkillsOnlyRefresh(targetInput) {
+  const target = normalizeTarget3(targetInput);
+  const metaPath = join6(target, ".fabric", "agents.meta.json");
+  if (!existsSync4(metaPath)) {
+    const message = t("cli.install.force-skills-only.uninitialised.message");
+    const hint = t("cli.install.force-skills-only.uninitialised.hint");
+    process.stderr.write(`${message}
+${hint}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(formatInitStageHeader(t("cli.install.force-skills-only.banner")));
+  const results = [];
+  results.push(...await cleanupDeprecatedSkills(target));
+  results.push(...await installFabricArchiveSkill(target));
+  results.push(...await installFabricReviewSkill(target));
+  results.push(...await installFabricImportSkill(target));
+  let written = 0;
+  let skipped = 0;
+  let errors = 0;
+  for (const r of results) {
+    if (r.status === "written") written += 1;
+    else if (r.status === "skipped") skipped += 1;
+    else if (r.status === "error") errors += 1;
+  }
+  console.log(
+    t("cli.install.force-skills-only.summary", {
+      written: String(written),
+      skipped: String(skipped),
+      errors: String(errors)
+    })
+  );
+  if (errors > 0) {
+    for (const r of results) {
+      if (r.status === "error") {
+        process.stderr.write(`  ${r.step} ${r.path}: ${r.message ?? "error"}
+`);
+      }
+    }
+    process.exitCode = 1;
+  }
+}
+async function runHooksOnlyRefresh(targetInput) {
+  const target = normalizeTarget3(targetInput);
+  const metaPath = join6(target, ".fabric", "agents.meta.json");
+  if (!existsSync4(metaPath)) {
+    const message = t("cli.install.force-hooks-only.uninitialised.message");
+    const hint = t("cli.install.force-hooks-only.uninitialised.hint");
+    process.stderr.write(`${message}
+${hint}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(formatInitStageHeader(t("cli.install.force-hooks-only.banner")));
+  const result = await installHooks(target);
+  console.log(
+    t("cli.install.force-hooks-only.summary", {
+      written: String(result.installed.length),
+      skipped: String(result.skipped.length),
+      errors: String(result.errors.length)
+    })
+  );
+  if (result.errors.length > 0) {
+    for (const err of result.errors) {
+      process.stderr.write(`  ${err}
+`);
+    }
+    process.exitCode = 1;
+  }
+}
 async function runInitCommand(args) {
   const logger = createDebugLogger(args.debug);
+  if (args.global === true) {
+    await runGlobalInstall({ url: args.url });
+    return;
+  }
   const resolution = resolveDevMode(args.target, process.cwd());
-  const intent = resolveInitCliIntent(args, resolution.target);
-  if (args.reapply === true) {
-    checkLockOrThrow(intent.target, { force: args.force });
+  if (args["force-skills-only"] === true) {
+    await runSkillsOnlyRefresh(resolution.target);
+    return;
+  }
+  if (args["force-hooks-only"] === true) {
+    await runHooksOnlyRefresh(resolution.target);
+    return;
   }
+  const intent = resolveInitCliIntent(args, resolution.target);
   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,
@@ -1662,81 +1692,107 @@ 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;
   }
   const result = await executeInitExecutionPlan(plan);
-  try {
-    await maybeWriteImportSentinel({
-      target: intent.target,
-      planOnly: intent.options.planOnly === true,
-      wizardEnabled: intent.wizardEnabled,
-      terminalInteractive: intent.interactiveSummary
-    });
-  } catch {
-  }
   if (!intent.options.planOnly) {
+    console.log("");
+    console.log(t("cli.install.next-steps"));
+    console.log("");
     console.log(paint.muted("More: docs/surfaces.md explains when to use CLI vs Skill vs MCP."));
   }
   return result;
 }
-async function maybeWriteImportSentinel(opts) {
-  if (opts.planOnly) return;
-  if (process.env.FABRIC_NONINTERACTIVE === "1") return;
-  if (!opts.wizardEnabled || !opts.terminalInteractive) return;
-  if (!Boolean(process.stdin.isTTY)) return;
-  const answer = await confirm({
-    message: "\u4E0B\u6B21\u5F00 AI \u65F6\u8BA9\u6211\u4ECE git log \u62BD\u66F4\u591A\u77E5\u8BC6\u5417?",
-    initialValue: true
-  });
-  if (isCancel(answer) || answer !== true) return;
-  const fabricDir = join5(opts.target, ".fabric");
-  const sentinelPath = join5(fabricDir, ".import-requested");
-  try {
-    if (!existsSync6(fabricDir)) {
-      mkdirSync(fabricDir, { recursive: true });
-    }
-    writeFileSync(sentinelPath, "", "utf8");
-    log.success("\u4E0B\u6B21\u5F00 AI \u4F1A\u770B\u5230\u63D0\u793A");
-  } catch {
-  }
+function writeDefaultFabricConfig(fabricDir, targetRoot) {
+  const target = join6(fabricDir, "fabric-config.json");
+  if (existsSync4(target)) return;
+  const detectedLanguage = detectExistingLanguage(targetRoot);
+  const FABRIC_CONFIG_DEFAULTS = {
+    // Scan/import language policy. Fixated at init time by probing
+    // 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.
+    fabric_language: detectedLanguage,
+    // fabric-hint Stop hook Signal A (archive): time-branch threshold, hours
+    // since last knowledge_proposed event.
+    archive_hint_hours: 24,
+    // fabric-hint Stop hook cooldown after ANY signal fires, in hours.
+    archive_hint_cooldown_hours: 12,
+    // fabric-hint Stop hook Signal B (review): pending-count cutoff.
+    review_hint_pending_count: 10,
+    // fabric-hint Stop hook Signal B (review): pending-age cutoff in days.
+    review_hint_pending_age_days: 7,
+    // fabric-hint Stop hook Signal D (maintenance): days since last doctor.
+    maintenance_hint_days: 14,
+    // fabric-hint Stop hook Signal D (maintenance): cooldown between
+    // reminders, in days.
+    maintenance_hint_cooldown_days: 7,
+    // fabric-hint Stop hook Signal A (archive): edit-count branch threshold;
+    // PreToolUse fires recorded in .fabric/.cache/edit-counter since the
+    // last knowledge_proposed event.
+    archive_edit_threshold: 20,
+    // fabric-hint Stop hook Signal C (import) + doctor lint #22: canonical
+    // knowledge node count below this value flags an underseeded workspace.
+    underseed_node_threshold: 10,
+    // rc.9+ (skill-contract-fix B1): fabric-import first-run git-history
+    // window in months. Default 60 captures the bulk of a mature repo's
+    // signal in one pass; lower to 12-24 for fresh / small repos.
+    import_window_first_run_months: 60,
+    // rc.9+ (skill-contract-fix B1): fabric-import rerun window in months.
+    // Default 2; raise to 6 if the workspace pauses imports for long stretches.
+    import_window_rerun_months: 2,
+    // rc.9+ (skill-contract-fix B1): hard cap on pending entries produced
+    // per fabric-import invocation. Default 10 matches one-sitting triage.
+    import_max_pending_per_run: 10,
+    // rc.9+ (skill-contract-fix B1): hard cap on commits scanned per
+    // fabric-import invocation. Default 500 covers ~2 months of typical churn.
+    import_max_commits_scan: 500,
+    // rc.9+ (skill-contract-fix B1): canonical-node count above which
+    // fabric-import suggests review over importing more. Default 50.
+    import_skip_canonical_threshold: 50,
+    // rc.9+ (skill-contract-fix B1): max candidates per fabric-archive batch.
+    // Default 8 keeps each batch reviewable in one sitting.
+    archive_max_candidates_per_batch: 8,
+    // rc.9+ (skill-contract-fix B1): max recently-touched paths in
+    // fabric-archive's relevance digest. Default 20.
+    archive_max_recent_paths: 20,
+    // rc.9+ (skill-contract-fix B1): max prior fabric-archive sessions
+    // summarised in the digest the skill loads on start. Default 10.
+    archive_digest_max_sessions: 10,
+    // rc.9+ (skill-contract-fix B1): max review results per topic cluster
+    // in fabric-review. Default 8.
+    review_topic_result_cap: 8,
+    // rc.9+ (skill-contract-fix B1): age (days) above which a pending entry
+    // is considered stale by fabric-review. Default 14.
+    review_stale_pending_days: 14
+  };
+  mkdirSync2(fabricDir, { recursive: true });
+  writeFileSync(target, JSON.stringify(FABRIC_CONFIG_DEFAULTS, null, 2) + "\n", "utf8");
+  log.info(
+    `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);
@@ -1773,17 +1829,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),
@@ -1791,6 +1847,17 @@ async function executeInitExecutionPlan(plan) {
       finalSupports: plan.supports
     };
   }
+  if (existsSync4(plan.scaffold.fabricDir) && !statSync4(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;
@@ -1815,6 +1882,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(),
@@ -1824,23 +1896,26 @@ async function executeInitExecutionPlan(plan) {
 }
 var KNOWLEDGE_SUBDIRS = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
 function resolvePersonalFabricRoot() {
-  return process.env.FABRIC_HOME ?? homedir4();
+  return process.env.FABRIC_HOME ?? homedir();
 }
 async function buildInitFabricPlan(target, options) {
-  assertExistingDirectory2(target);
-  const fabricDir = join5(target, ".fabric");
-  const agentsMdPath = join5(target, "AGENTS.md");
-  const agentsMdAction = existsSync6(agentsMdPath) ? "preserved" : "created";
-  const knowledgeDir = join5(fabricDir, "knowledge");
-  const personalKnowledgeDir = join5(resolvePersonalFabricRoot(), ".fabric", "knowledge");
-  const forensicPath = join5(fabricDir, "forensic.json");
-  const eventsPath = join5(fabricDir, "events.jsonl");
-  const metaPath = join5(fabricDir, "agents.meta.json");
+  assertExistingDirectory3(target);
+  const fabricDir = join6(target, ".fabric");
+  const agentsMdPath = join6(target, "AGENTS.md");
+  const agentsMdAction = existsSync4(agentsMdPath) ? "preserved" : "created";
+  const knowledgeDir = join6(fabricDir, "knowledge");
+  const personalKnowledgeDir = join6(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const forensicPath = join6(fabricDir, "forensic.json");
+  const eventsPath = join6(fabricDir, "events.jsonl");
+  const metaPath = join6(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
-  const knowledgeDirAction = existsSync6(knowledgeDir) ? "overwritten" : "created";
-  const metaAction = planFreshPath(metaPath, options);
-  const eventsAction = planFreshPath(eventsPath, options);
-  const forensicAction = planFreshPath(forensicPath, options);
+  const knowledgeDirAction = existsSync4(knowledgeDir) ? "overwritten" : "created";
+  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 {
@@ -1860,60 +1935,63 @@ 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 });
-  if (plan.agentsMdAction === "created" && !existsSync6(plan.agentsMdPath)) {
-    await atomicWriteText2(plan.agentsMdPath, AGENTS_MD_DEFAULT_CONTENT);
+    rmSync2(plan.fabricDir, { force: true });
   }
-  mkdirSync(plan.knowledgeDir, { recursive: true });
+  mkdirSync2(plan.fabricDir, { recursive: true });
+  writeDefaultFabricConfig(plan.fabricDir, plan.target);
+  mkdirSync2(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
-    const teamSubDir = join5(plan.knowledgeDir, sub);
-    mkdirSync(teamSubDir, { recursive: true });
-    const teamGitkeep = join5(teamSubDir, ".gitkeep");
-    if (!existsSync6(teamGitkeep)) {
+    const teamSubDir = join6(plan.knowledgeDir, sub);
+    mkdirSync2(teamSubDir, { recursive: true });
+    const teamGitkeep = join6(teamSubDir, ".gitkeep");
+    if (!existsSync4(teamGitkeep)) {
       writeFileSync(teamGitkeep, "", "utf8");
     }
   }
   try {
-    mkdirSync(plan.personalKnowledgeDir, { recursive: true });
+    mkdirSync2(plan.personalKnowledgeDir, { recursive: true });
     for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync(join5(plan.personalKnowledgeDir, sub), { recursive: true });
+      mkdirSync2(join6(plan.personalKnowledgeDir, sub), { recursive: true });
     }
   } catch {
   }
-  preparePlannedPath(plan.metaPath, plan.metaAction);
-  await atomicWriteJson(plan.metaPath, plan.meta);
-  if (isReapply) {
-    if (!existsSync6(plan.eventsPath)) {
-      mkdirSync(dirname2(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);
+    mkdirSync2(dirname(plan.eventsPath), { recursive: true });
     writeFileSync(plan.eventsPath, "", "utf8");
   }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
   await atomicWriteJson(plan.forensicPath, plan.forensicReport);
-  if (!plan.options?.reapply) {
-    try {
-      await runInitScan(plan.target, { source: "init" });
-    } catch (error) {
-      writeStderr2(
-        `[warn] init-scan failed: ${error instanceof Error ? error.message : String(error)} \u2014 re-run \`fab scan\` to populate baseline knowledge entries.`
-      );
+  if (existsSync4(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);
+      }
     }
-  }
-  if (isReapply) {
-    appendReapplyLedgerEvent(plan.eventsPath, {
-      preserved_ledger: true
-    });
+    appendInstallDiffLedgerEvent(plan.eventsPath, { applied, canonical, drifted });
   }
   return {
     agentsMdPath: plan.agentsMdPath,
@@ -1933,16 +2011,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;
@@ -1980,27 +2058,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)
@@ -2030,27 +2117,32 @@ 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": {
         const installResults = [];
+        installResults.push(...await runBestEffort("skill-deprecated-cleanup", () => cleanupDeprecatedSkills(plan.target)));
         installResults.push(...await runBestEffort("skill-install", () => installFabricArchiveSkill(plan.target)));
         installResults.push(...await runBestEffort("skill-review-install", () => installFabricReviewSkill(plan.target)));
         installResults.push(...await runBestEffort("skill-import-install", () => installFabricImportSkill(plan.target)));
         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)));
-        installResults.push(...await runBestEffort("pointer", () => addArchiveSkillPointer(plan.target)));
+        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;
@@ -2060,15 +2152,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
         });
@@ -2080,7 +2171,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" };
       }
@@ -2088,93 +2179,129 @@ 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) {
-  if (!existsSync6(path)) {
+function shouldReplaceWritableDirectory(path, _options) {
+  if (!existsSync4(path)) {
     return false;
   }
-  if (statSync2(path).isDirectory()) {
+  if (statSync4(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) {
-  if (!existsSync6(path)) {
-    return "created";
+function classifyFreshPath(path, strategy) {
+  if (!existsSync4(path)) {
+    return { path, state: "missing" };
   }
-  if (!options?.force) {
-    throw new Error(t("cli.init.errors.abort-existing", { path }));
+  let stat;
+  try {
+    stat = statSync4(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 = readFileSync3(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(dirname2(path), { recursive: true });
-  if (action === "overwritten" && existsSync6(path)) {
-    rmSync(path, { recursive: true, force: true });
+  mkdirSync2(dirname(path), { recursive: true });
+  if (action === "overwritten" && existsSync4(path)) {
+    rmSync2(path, { recursive: true, force: true });
   }
 }
 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
@@ -2203,23 +2330,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);
@@ -2250,74 +2377,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");
+    return t("cli.install.plan.mode-banner.plan");
   }
-  if (options.reapply) {
-    return t("cli.init.plan.mode-banner.reapply");
-  }
-  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");
+    return t("cli.install.mode.badge.plan");
   }
-  if (options.reapply) {
-    return t("cli.init.mode.badge.reapply");
-  }
-  return t("cli.init.mode.badge.default");
+  return t("cli.install.mode.badge.default");
 }
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve5(process.cwd(), targetInput);
+function normalizeTarget3(targetInput) {
+  return isAbsolute3(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
 }
-function assertExistingDirectory2(target) {
-  if (!existsSync6(target) || !statSync2(target).isDirectory()) {
+function assertExistingDirectory3(target) {
+  if (!existsSync4(target) || !statSync4(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
 function detectPackageManager(cwd) {
-  const workspaceRoot = resolve5(cwd);
-  if (existsSync6(join5(workspaceRoot, "pnpm-lock.yaml"))) {
+  const workspaceRoot = resolve3(cwd);
+  if (existsSync4(join6(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync6(join5(workspaceRoot, "yarn.lock"))) {
+  if (existsSync4(join6(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync6(join5(workspaceRoot, "package-lock.json"))) {
+  if (existsSync4(join6(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, {
@@ -2333,14 +2428,16 @@ function createInitialMeta() {
     counters: defaultAgentsMetaCounters()
   };
 }
-function appendReapplyLedgerEvent(eventsPath, payload) {
+function appendInstallDiffLedgerEvent(eventsPath, payload) {
   const event = {
     kind: "fabric-event",
-    id: `event:${randomUUID()}`,
+    id: `event:${randomUUID2()}`,
     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)}
 `;
@@ -2391,7 +2488,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) {
@@ -2404,11 +2501,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),
@@ -2417,31 +2514,32 @@ 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`);
   console.log(`  - ${target}/.fabric/forensic.json`);
+  console.log(`  - ${target}/.fabric/fabric-config.json`);
 }
 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))),
@@ -2456,11 +2554,13 @@ function printInitCapabilitySummary(supports, stageResults, options) {
   for (const row of rows) {
     console.log(formatCapabilityTableRow(row, widths));
   }
+  console.log("");
+  console.log(t("cli.install.restart-banner"));
 }
 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 {
@@ -2469,14 +2569,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;
@@ -2484,15 +2584,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) {
@@ -2518,21 +2618,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();
@@ -2550,18 +2650,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}
 `);
 }
@@ -2569,13 +2669,15 @@ export {
   buildInitExecutionPlan,
   buildInitFabricPlan,
   createDefaultInitWizardAdapter,
-  init_default as default,
+  install_default as default,
   detectPackageManager,
   executeInitExecutionPlan,
   executeInitFabricPlan,
-  initCommand,
   initFabric,
+  installCommand,
   resolveInitExecutionPlanWithWizard,
+  runHooksOnlyRefresh,
   runInitCommand,
+  runSkillsOnlyRefresh,
   shouldUseInitWizard
 };