@fenglimg/fabric-cli 1.8.0-rc.2 → 2.0.0-rc.1

package/dist/{init-CAZN4S4T.js → init-DRHUYHYA.js}

@@ -1,125 +1,50 @@
 #!/usr/bin/env node
 import {
-  createScanReport,
-  detectFramework
-} from "./chunk-NMMUETVK.js";
+  detectFramework,
+  runInitScan
+} from "./chunk-UHNP7T7W.js";
 import {
   createDebugLogger,
   displayWidth,
   padEnd,
   paint,
-  readFabricConfig,
   resolveDevMode,
   t
-} from "./chunk-QPCRBQ5Y.js";
+} from "./chunk-5LOYBXWD.js";
 
 // src/commands/init.ts
-import { createHash, randomUUID } from "crypto";
+import { randomUUID } from "crypto";
+import { homedir as homedir5 } from "os";
 import * as childProcess from "child_process";
-import { appendFileSync, chmodSync as chmodSync2, copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, rmSync, statSync as statSync3, writeFileSync } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join8, parse as parse3, resolve as resolve9 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { appendFileSync, existsSync as existsSync8, mkdirSync, rmSync, statSync as statSync3, writeFileSync } from "fs";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join6, resolve as resolve7 } from "path";
 import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
-import { atomicWriteJson as atomicWriteJson3, atomicWriteText as atomicWriteText4 } from "@fenglimg/fabric-shared/node/atomic-write";
-import { defineCommand as defineCommand4 } from "citty";
+import { defaultAgentsMetaCounters } from "@fenglimg/fabric-shared";
+import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
+import { defineCommand as defineCommand3 } from "citty";
 import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
-// src/bootstrap-guide.ts
-import { existsSync, mkdirSync, readFileSync } from "fs";
-import { dirname, isAbsolute, join, parse, resolve } from "path";
-import { fileURLToPath } from "url";
-import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-var AGENTS_TEMPLATE_BY_FRAMEWORK = {
-  "cocos-creator": "templates/agents-md/variants/cocos.md",
-  vite: "templates/agents-md/variants/vite.md",
-  next: "templates/agents-md/variants/next.md"
-};
-var FABRIC_GUIDE_PATH = ".fabric/bootstrap/README.md";
-async function buildFabricBootstrapGuide(target) {
-  const workspaceRoot = normalizeTarget(target);
-  const scanReport = await createScanReport(workspaceRoot);
-  const template = readFileSync(findBootstrapTemplatePath(scanReport.framework.kind), "utf8");
-  const packageName = readPackageName(workspaceRoot) ?? parse(workspaceRoot).base;
-  return ensureTrailingNewline(
-    template.replaceAll("{ projectName }", packageName).replaceAll("{ frameworkKind }", scanReport.framework.kind)
-  );
-}
-async function ensureFabricBootstrapGuide(workspaceRoot, force) {
-  const guidePath = resolve(workspaceRoot, FABRIC_GUIDE_PATH);
-  if (existsSync(guidePath) && !force) {
-    return;
-  }
-  mkdirSync(dirname(guidePath), { recursive: true });
-  await atomicWriteText(guidePath, await buildFabricBootstrapGuide(workspaceRoot));
-}
-function findBootstrapTemplatePath(frameworkKind) {
-  const relativePath = AGENTS_TEMPLATE_BY_FRAMEWORK[frameworkKind] ?? "templates/agents-md/AGENTS.md.template";
-  return findTemplatePath(relativePath);
-}
-function readPackageName(target) {
-  const packageJsonPath = join(target, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return void 0;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-    return packageJson.name;
-  } catch {
-    return void 0;
-  }
-}
-function findTemplatePath(relativePath) {
-  const currentModuleDir = dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    ...templateCandidatesFrom(process.cwd(), relativePath),
-    ...templateCandidatesFrom(currentModuleDir, relativePath)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
-}
-function templateCandidatesFrom(start, relativePath) {
-  const candidates = [];
-  let current = resolve(start);
-  while (true) {
-    candidates.push(join(current, ...relativePath.split("/")));
-    const parent = dirname(current);
-    if (parent === current || parse(current).root === current) {
-      break;
-    }
-    current = parent;
-  }
-  return candidates.reverse();
-}
-function ensureTrailingNewline(content) {
-  return content.endsWith("\n") ? content : `${content}
-`;
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-
-// src/commands/bootstrap.ts
+// src/commands/config.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
 import { resolve as resolve5 } from "path";
-import { defineCommand } from "citty";
+import { fileURLToPath } from "url";
+import { defineCommand as defineCommand2 } from "citty";
 
 // src/config/resolver.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir4 } from "os";
 
 // src/config/claude-code.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, resolve as resolve3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
 import { homedir as homedir2, platform } from "os";
 
 // src/config/json.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 import { mkdir, readFile } from "fs/promises";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "path";
+import { dirname, join, resolve } from "path";
 import { homedir } from "os";
 import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
 
@@ -150,12 +75,12 @@ function expandHome(filePath) {
     return homedir();
   }
   if (filePath.startsWith("~/")) {
-    return join2(homedir(), filePath.slice(2));
+    return join(homedir(), filePath.slice(2));
   }
   return filePath;
 }
 function normalizeConfigPath(filePath) {
-  return resolve2(expandHome(filePath));
+  return resolve(expandHome(filePath));
 }
 async function readJsonConfig(configPath) {
   try {
@@ -178,7 +103,7 @@ async function readJsonConfig(configPath) {
 async function writeJsonClientConfig(configPath, serverEntry) {
   const existing = await readJsonConfig(configPath);
   const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
-  await mkdir(dirname2(configPath), { recursive: true });
+  await mkdir(dirname(configPath), { recursive: true });
   await atomicWriteJson(configPath, merged, { indent: 2 });
 }
 var JsonClientConfigWriter = class {
@@ -213,12 +138,12 @@ var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
   // or ~/.claude.json for user scope.
   // Detection still checks ~/.claude to confirm Claude Code is installed.
   defaultPath(workspaceRoot) {
-    const globalClaudeDir = join2(homedir(), ".claude");
-    const projectClaudeDir = join2(workspaceRoot, ".claude");
-    if (!existsSync2(globalClaudeDir) && !existsSync2(projectClaudeDir)) {
+    const globalClaudeDir = join(homedir(), ".claude");
+    const projectClaudeDir = join(workspaceRoot, ".claude");
+    if (!existsSync(globalClaudeDir) && !existsSync(projectClaudeDir)) {
       return null;
     }
-    return this.scope === "user" ? join2(homedir(), ".claude.json") : join2(workspaceRoot, ".mcp.json");
+    return this.scope === "user" ? join(homedir(), ".claude.json") : join(workspaceRoot, ".mcp.json");
   }
 };
 var CursorWriter = class extends JsonClientConfigWriter {
@@ -227,8 +152,8 @@ var CursorWriter = class extends JsonClientConfigWriter {
     super(configuredPath);
   }
   defaultPath(workspaceRoot) {
-    const cursorDir = join2(workspaceRoot, ".cursor");
-    return existsSync2(cursorDir) ? join2(cursorDir, "mcp.json") : null;
+    const cursorDir = join(workspaceRoot, ".cursor");
+    return existsSync(cursorDir) ? join(cursorDir, "mcp.json") : null;
   }
 };
 
@@ -236,12 +161,12 @@ var CursorWriter = class extends JsonClientConfigWriter {
 function getClaudeDesktopConfigPath() {
   const os = platform();
   if (os === "darwin") {
-    return join3(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join2(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (os === "win32") {
-    return join3(process.env.APPDATA ?? join3(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    return join2(process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
   }
-  return join3(homedir2(), ".config", "Claude", "claude_desktop_config.json");
+  return join2(homedir2(), ".config", "Claude", "claude_desktop_config.json");
 }
 var ClaudeCodeDesktopWriter = class {
   clientKind = "ClaudeCodeDesktop";
@@ -251,7 +176,7 @@ var ClaudeCodeDesktopWriter = class {
   }
   async detect(_workspaceRoot, overridePath) {
     const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
-    return existsSync3(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
+    return existsSync2(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
   }
   async write(serverPath, workspaceRoot, overridePath) {
     const configPath = await this.detect(workspaceRoot, overridePath);
@@ -266,17 +191,17 @@ var ClaudeCodeDesktopWriter = class {
 };
 
 // src/config/toml.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
 import { homedir as homedir3 } from "os";
-import { atomicWriteText as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
+import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
 function expandHome2(filePath) {
   if (filePath === "~") {
     return homedir3();
   }
   if (filePath.startsWith("~/")) {
-    return join4(homedir3(), filePath.slice(2));
+    return join3(homedir3(), filePath.slice(2));
   }
   return filePath;
 }
@@ -342,10 +267,10 @@ var CodexTOMLConfigWriter = class {
   async detect(_workspaceRoot, overridePath) {
     const explicitPath = overridePath ?? this.configuredPath;
     if (explicitPath !== void 0) {
-      return resolve4(expandHome2(explicitPath));
+      return resolve3(expandHome2(explicitPath));
     }
-    const codexDir = join4(homedir3(), ".codex");
-    return existsSync4(codexDir) ? resolve4(join4(codexDir, "config.toml")) : null;
+    const codexDir = join3(homedir3(), ".codex");
+    return existsSync3(codexDir) ? resolve3(join3(codexDir, "config.toml")) : null;
   }
   async write(serverPath, workspaceRoot, overridePath) {
     const configPath = await this.detect(workspaceRoot, overridePath);
@@ -354,8 +279,8 @@ var CodexTOMLConfigWriter = class {
     }
     const rawConfig = await readTomlConfigText(configPath);
     const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
-    await mkdir2(dirname3(configPath), { recursive: true });
-    await atomicWriteText2(configPath, nextConfig);
+    await mkdir2(dirname2(configPath), { recursive: true });
+    await atomicWriteText(configPath, nextConfig);
   }
 };
 
@@ -375,25 +300,25 @@ function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
   const claudeMcpScope = opts.claudeMcpScope ?? "project";
   addIfDetected(
     writers,
-    existsSync5(join5(homedir4(), ".claude")) || existsSync5(join5(workspaceRoot, ".claude")),
+    existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude")),
     (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
     hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
   );
   addIfDetected(
     writers,
-    existsSync5(getClaudeDesktopConfigPath()),
+    existsSync4(getClaudeDesktopConfigPath()),
     (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
     hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
   );
   addIfDetected(
     writers,
-    existsSync5(join5(workspaceRoot, ".cursor")),
+    existsSync4(join4(workspaceRoot, ".cursor")),
     (configuredPath) => new CursorWriter(configuredPath),
     hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
   );
   addIfDetected(
     writers,
-    existsSync5(join5(homedir4(), ".codex")),
+    existsSync4(join4(homedir4(), ".codex")),
     (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
     hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
   );
@@ -401,10 +326,10 @@ function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
 }
 function detectClientSupports(workspaceRoot, fabricConfig = {}) {
   const clientPaths = fabricConfig.clientPaths;
-  const claudeDetected = existsSync5(join5(homedir4(), ".claude")) || existsSync5(join5(workspaceRoot, ".claude"));
-  const claudeDesktopDetected = existsSync5(getClaudeDesktopConfigPath());
-  const cursorDetected = existsSync5(join5(workspaceRoot, ".cursor"));
-  const codexDetected = existsSync5(join5(homedir4(), ".codex"));
+  const claudeDetected = existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude"));
+  const claudeDesktopDetected = existsSync4(getClaudeDesktopConfigPath());
+  const cursorDetected = existsSync4(join4(workspaceRoot, ".cursor"));
+  const codexDetected = existsSync4(join4(homedir4(), ".codex"));
   return [
     {
       clientKind: "ClaudeCodeCLI",
@@ -462,166 +387,27 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
         skill: true
       },
       installedCapabilities: {
-        hook: existsSync5(join5(workspaceRoot, ".codex", "hooks.json")),
-        skill: existsSync5(join5(workspaceRoot, ".agents", "skills", "fabric-init", "SKILL.md"))
+        hook: existsSync4(join4(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
       }
     }
   ];
 }
 
-// src/commands/bootstrap.ts
-var CLIENT_ALIASES = {
-  claude: "claude",
-  "claude-code": "claude",
-  claudecode: "claude",
-  claudecli: "claude",
-  claudecodecli: "claude",
-  claudedesktop: "claude",
-  claudecodedesktop: "claude",
-  cursor: "cursor",
-  codex: "codex",
-  "codex-cli": "codex",
-  codexcli: "codex"
-};
-var bootstrapCommand = defineCommand({
-  meta: {
-    name: "bootstrap",
-    description: t("cli.bootstrap.description")
-  },
-  subCommands: {
-    install: defineCommand({
-      meta: {
-        name: "install",
-        description: t("cli.bootstrap.install.description")
-      },
-      args: {
-        clients: {
-          type: "string",
-          description: t("cli.bootstrap.install.args.clients.description")
-        }
-      },
-      async run({ args }) {
-        const workspaceRoot = process.cwd();
-        const selectedClients = parseClientFilter(args.clients);
-        const result = await installBootstrap(workspaceRoot, {
-          clients: selectedClients === null ? void 0 : Array.from(selectedClients, mapBootstrapClientToClientKind)
-        });
-        if (result.details.length === 0) {
-          process.stderr.write(
-            `${t("cli.bootstrap.install.no-targets")}
-`
-          );
-          return;
-        }
-        for (const detail of result.details) {
-          if (detail.action === "skipped") {
-            process.stderr.write(`${t("cli.bootstrap.install.skipped-header", { path: detail.path })}
-`);
-            continue;
-          }
-          if (detail.action === "prepended") {
-            process.stderr.write(`${t("cli.bootstrap.install.prepended", { path: detail.path })}
-`);
-            continue;
-          }
-          process.stderr.write(`${t("cli.bootstrap.install.installed", { path: detail.path })}
-`);
-        }
-      }
-    })
-  }
-});
-async function installBootstrap(target, options = {}) {
-  const workspaceRoot = resolve5(target);
-  const fabricConfig = readFabricConfig(workspaceRoot);
-  const targets = resolveBootstrapTargets(workspaceRoot, fabricConfig, options.clients);
-  const installed = [];
-  const skipped = [];
-  const details = [];
-  await ensureFabricBootstrapGuide(workspaceRoot, options.force);
-  for (const bootstrapTarget of targets) {
-    details.push({
-      client: bootstrapTarget.client,
-      path: resolve5(workspaceRoot, FABRIC_GUIDE_PATH),
-      action: "skipped"
-    });
-    skipped.push(bootstrapTarget.client);
-  }
-  return { installed, skipped, details };
-}
-function parseClientFilter(value) {
-  if (value === void 0 || value.trim().length === 0) {
-    return null;
-  }
-  const clients = /* @__PURE__ */ new Set();
-  for (const rawClient of value.split(",")) {
-    const alias = rawClient.trim().toLowerCase();
-    const client = CLIENT_ALIASES[alias];
-    if (client === void 0) {
-      throw new Error(t("cli.bootstrap.errors.unknown-client", { client: rawClient }));
-    }
-    clients.add(client);
-  }
-  return clients;
-}
-function resolveBootstrapTargets(workspaceRoot, fabricConfig, selectedClients) {
-  const targets = [];
-  const seenClients = /* @__PURE__ */ new Set();
-  const clientKinds = selectedClients ?? resolveClients(workspaceRoot, fabricConfig).map((writer) => writer.clientKind);
-  for (const clientKind of clientKinds) {
-    const bootstrapClient = mapClientKind(clientKind);
-    if (bootstrapClient === null || seenClients.has(bootstrapClient)) {
-      continue;
-    }
-    seenClients.add(bootstrapClient);
-    targets.push({ client: clientKind, bootstrapClient });
-  }
-  return targets;
-}
-function mapClientKind(clientKind) {
-  switch (clientKind) {
-    case "ClaudeCodeCLI":
-    case "ClaudeCodeDesktop":
-      return "claude";
-    case "Cursor":
-      return "cursor";
-    case "CodexCLI":
-      return "codex";
-    default:
-      return null;
-  }
-}
-function mapBootstrapClientToClientKind(client) {
-  switch (client) {
-    case "claude":
-      return "ClaudeCodeCLI";
-    case "cursor":
-      return "Cursor";
-    case "codex":
-      return "CodexCLI";
-  }
-}
-
-// src/commands/config.ts
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { resolve as resolve7 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-import { defineCommand as defineCommand3 } from "citty";
-
 // src/commands/hooks.ts
-import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join6, parse as parse2, resolve as resolve6 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { defineCommand as defineCommand2 } from "citty";
-import { atomicWriteJson as atomicWriteJson2, atomicWriteText as atomicWriteText3 } from "@fenglimg/fabric-shared/node/atomic-write";
-var hooksCommand = defineCommand2({
+import { existsSync as existsSync5, statSync } from "fs";
+import { isAbsolute, resolve as resolve4 } from "path";
+import { defineCommand } from "citty";
+var hooksCommand = defineCommand({
   meta: {
     name: "hooks",
     description: t("cli.hooks.description")
   },
   subCommands: {
-    install: defineCommand2({
+    install: defineCommand({
       meta: {
         name: "install",
         description: t("cli.hooks.install.description")
@@ -634,127 +420,29 @@ var hooksCommand = defineCommand2({
         }
       },
       async run({ args }) {
-        const result = await installHooks(args.target);
-        if (result.hookAction === "skipped") {
-          writeStderr(t("cli.hooks.install.hook-skipped", { path: result.hookPath }));
-        } else if (result.hookAction === "appended") {
-          writeStderr(t("cli.hooks.install.hook-appended", { path: result.hookPath }));
-        } else {
-          writeStderr(t("cli.hooks.install.hook-created", { path: result.hookPath }));
-        }
-        if (result.prepareAction === "left") {
-          writeStderr(t("cli.hooks.install.prepare-left", { path: result.packageJsonPath }));
-        } else {
-          writeStderr(t("cli.hooks.install.prepare-added", { path: result.packageJsonPath }));
-        }
+        await installHooks(args.target);
       }
     })
   }
 });
-async function installHooks(target, options = {}) {
-  const normalizedTarget = normalizeTarget2(target);
+async function installHooks(target, _options = {}) {
+  const normalizedTarget = normalizeTarget(target);
   assertExistingDirectory(normalizedTarget);
-  const huskyDir = join6(normalizedTarget, ".husky");
-  const hookPath = join6(huskyDir, "pre-commit");
-  const packageJsonPath = join6(normalizedTarget, "package.json");
-  if (!existsSync6(packageJsonPath)) {
-    throw new Error(t("cli.hooks.errors.package-json-required", { path: packageJsonPath }));
-  }
-  mkdirSync2(huskyDir, { recursive: true });
-  const templateContent = readFileSync2(findTemplatePath2("templates/husky/pre-commit"), "utf8");
-  const hookAction = await installHookFile(hookPath, templateContent, options.force);
-  chmodSync(hookPath, 493);
-  const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-  const scripts = packageJson.scripts && typeof packageJson.scripts === "object" && !Array.isArray(packageJson.scripts) ? packageJson.scripts : {};
-  const hadPrepare = typeof scripts.prepare === "string" && scripts.prepare.trim().length > 0;
-  let prepareAction = "left";
-  if (!hadPrepare) {
-    scripts.prepare = "husky install";
-    packageJson.scripts = scripts;
-    await atomicWriteJson2(packageJsonPath, packageJson);
-    prepareAction = "added";
-  }
-  const installed = [];
-  const skipped = [];
-  if (hookAction === "skipped") {
-    skipped.push(hookPath);
-  } else {
-    installed.push(hookPath);
-  }
-  if (prepareAction === "left") {
-    skipped.push(packageJsonPath);
-  } else {
-    installed.push(packageJsonPath);
-  }
-  return {
-    installed,
-    skipped,
-    hookPath,
-    packageJsonPath,
-    hookAction,
-    prepareAction
-  };
+  throw new Error(
+    `fab hooks install is not available in v2 (husky pre-commit template removed). Use per-client hooks under .claude/ and .codex/ instead. Target: ${normalizedTarget}`
+  );
 }
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve6(process.cwd(), targetInput);
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve4(process.cwd(), targetInput);
 }
 function assertExistingDirectory(target) {
-  if (!existsSync6(target) || !statSync(target).isDirectory()) {
+  if (!existsSync5(target) || !statSync(target).isDirectory()) {
     throw new Error(t("cli.shared.target-invalid", { target }));
   }
 }
-async function installHookFile(hookPath, templateContent, force) {
-  if (existsSync6(hookPath)) {
-    if (force) {
-      await atomicWriteText3(hookPath, templateContent);
-      return "overwritten";
-    }
-    const existing = readFileSync2(hookPath, "utf8");
-    if (existing.includes("FAB_BIN=")) {
-      return "skipped";
-    }
-    const fabricBlock = templateContent.replace(/^#!\/bin\/sh\n/, "");
-    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    await atomicWriteText3(hookPath, `${existing}${separator}# --- Fabric ---
-${fabricBlock}`);
-    return "appended";
-  }
-  await atomicWriteText3(hookPath, templateContent);
-  return "created";
-}
-function findTemplatePath2(relativePath) {
-  const currentModuleDir = dirname4(fileURLToPath2(import.meta.url));
-  const candidates = [
-    ...templateCandidatesFrom2(process.cwd(), relativePath),
-    ...templateCandidatesFrom2(currentModuleDir, relativePath)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync6(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
-}
-function templateCandidatesFrom2(start, relativePath) {
-  const candidates = [];
-  let current = resolve6(start);
-  while (true) {
-    candidates.push(join6(current, ...relativePath.split("/")));
-    const parent = dirname4(current);
-    if (parent === current || parse2(current).root === current) {
-      break;
-    }
-    current = parent;
-  }
-  return candidates.reverse();
-}
-function writeStderr(message) {
-  process.stderr.write(`${message}
-`);
-}
 
 // src/commands/config.ts
-var CLIENT_ALIASES2 = {
+var CLIENT_ALIASES = {
   claude: "ClaudeCodeCLI",
   claudecodecli: "ClaudeCodeCLI",
   "claude-code-cli": "ClaudeCodeCLI",
@@ -767,14 +455,14 @@ var CLIENT_ALIASES2 = {
   "codex-cli": "CodexCLI",
   codex: "CodexCLI"
 };
-function parseClientFilter2(value) {
+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_ALIASES2[alias];
+    const clientKind = CLIENT_ALIASES[alias];
     if (clientKind === void 0) {
       throw new Error(t("cli.config.errors.unknown-client", { client: rawClient }));
     }
@@ -783,8 +471,8 @@ function parseClientFilter2(value) {
   return clients;
 }
 async function loadFabricConfig(workspaceRoot) {
-  const configPath = resolve7(workspaceRoot, "fabric.config.json");
-  if (!existsSync7(configPath)) {
+  const configPath = resolve5(workspaceRoot, "fabric.config.json");
+  if (!existsSync6(configPath)) {
     return {};
   }
   const parsed = JSON.parse(await readFile3(configPath, "utf8"));
@@ -795,21 +483,21 @@ async function loadFabricConfig(workspaceRoot) {
 }
 function resolveServerPath(override) {
   if (override) return override;
-  if (process.env.FAB_SERVER_PATH) return resolve7(process.env.FAB_SERVER_PATH);
-  return fileURLToPath3(import.meta.resolve("@fenglimg/fabric-server"));
+  if (process.env.FAB_SERVER_PATH) return resolve5(process.env.FAB_SERVER_PATH);
+  return fileURLToPath(import.meta.resolve("@fenglimg/fabric-server"));
 }
-function writeStderr2(message) {
+function writeStderr(message) {
   process.stderr.write(`${message}
 `);
 }
-var configCmd = defineCommand3({
+var configCmd = defineCommand2({
   meta: {
     name: "config",
     description: t("cli.config.description")
   },
   subCommands: {
     hooks: hooksCommand,
-    install: defineCommand3({
+    install: defineCommand2({
       meta: {
         name: "install",
         description: t("cli.config.install.description")
@@ -826,26 +514,26 @@ var configCmd = defineCommand3({
         }
       },
       async run({ args }) {
-        const selectedClients = parseClientFilter2(args.clients);
+        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) {
-          writeStderr2(t("cli.config.install.no-configs"));
+          writeStderr(t("cli.config.install.no-configs"));
           return;
         }
         for (const detail of result.details) {
           if (detail.action === "skipped") {
-            writeStderr2(t("cli.config.install.no-config-path", { client: detail.client }));
+            writeStderr(t("cli.config.install.no-config-path", { client: detail.client }));
             continue;
           }
           if (detail.action === "dry-run" && detail.path !== null) {
-            writeStderr2(t("cli.config.install.dry-run", { client: detail.client, path: detail.path }));
+            writeStderr(t("cli.config.install.dry-run", { client: detail.client, path: detail.path }));
             continue;
           }
           if (detail.path !== null) {
-            writeStderr2(t("cli.config.install.wrote", { client: detail.client, path: detail.path }));
+            writeStderr(t("cli.config.install.wrote", { client: detail.client, path: detail.path }));
           }
         }
       }
@@ -853,7 +541,7 @@ var configCmd = defineCommand3({
   }
 });
 async function installMcpClients(target, options = {}) {
-  const workspaceRoot = resolve7(target);
+  const workspaceRoot = resolve5(target);
   const fabricConfig = await loadFabricConfig(workspaceRoot);
   const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
   const serverPath = resolveServerPath(options.localServerPath);
@@ -884,9 +572,9 @@ async function installMcpClients(target, options = {}) {
 
 // src/scanner/forensic.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync7, readdirSync, readFileSync, statSync as statSync2 } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute as isAbsolute3, join as join7, posix, relative, resolve as resolve8, sep } from "path";
+import { basename, extname, isAbsolute as isAbsolute2, join as join5, posix, relative, resolve as resolve6, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
@@ -972,7 +660,7 @@ var parserInitPromise = null;
 var languagePromiseByKind = {};
 var parserBundlePromiseByKind = {};
 async function buildForensicReport(targetInput) {
-  const target = normalizeTarget3(targetInput);
+  const target = normalizeTarget2(targetInput);
   const framework = detectFramework(target);
   const topology = buildTopology(target);
   const entryPoints = collectEntryPoints(target, topology.files);
@@ -1008,8 +696,8 @@ async function buildForensicReport(targetInput) {
   }
   return validation.data;
 }
-function normalizeTarget3(targetInput) {
-  return isAbsolute3(targetInput) ? targetInput : resolve8(process.cwd(), targetInput);
+function normalizeTarget2(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve6(process.cwd(), targetInput);
 }
 function buildTopology(root) {
   assertExistingDirectory2(root);
@@ -1025,7 +713,7 @@ function buildTopology(root) {
       continue;
     }
     for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join7(current, entry.name);
+      const absolutePath = join5(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -1064,7 +752,7 @@ function buildTopology(root) {
   };
 }
 function assertExistingDirectory2(target) {
-  if (!existsSync8(target) || !statSync2(target).isDirectory()) {
+  if (!existsSync7(target) || !statSync2(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -1113,7 +801,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 = join7(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,
@@ -1133,7 +821,7 @@ async function buildCodeSamples(target, entryPoints, frameworkKind, topology, pa
 }
 function readFirstLines(path, lineLimit) {
   try {
-    const lines = readFileSync3(path, "utf8").split(/\r?\n/);
+    const lines = readFileSync(path, "utf8").split(/\r?\n/);
     if (lines.at(-1) === "") {
       lines.pop();
     }
@@ -1150,12 +838,12 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join7(target, "package.json");
-  if (!existsSync8(packageJsonPath)) {
+  const packageJsonPath = join5(target, "package.json");
+  if (!existsSync7(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
   try {
-    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
     return new Map([
       ...Object.entries(packageJson.dependencies ?? {}),
       ...Object.entries(packageJson.devDependencies ?? {}),
@@ -1491,16 +1179,16 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join7(target, "README.md");
-  const hasContributing = existsSync8(join7(target, "CONTRIBUTING.md"));
-  if (!existsSync8(readmePath)) {
+  const readmePath = join5(target, "README.md");
+  const hasContributing = existsSync7(join5(target, "CONTRIBUTING.md"));
+  if (!existsSync7(readmePath)) {
     return {
       quality: "missing",
       line_count: 0,
       has_contributing: hasContributing
     };
   }
-  const readme = readFileSync3(readmePath, "utf8");
+  const readme = readFileSync(readmePath, "utf8");
   const wordCount = readme.trim().split(/\s+/).filter(Boolean).length;
   return {
     quality: wordCount >= 200 ? "ok" : "stub",
@@ -1733,7 +1421,7 @@ function buildDomainAssertion(codeSamples) {
       namedModules.length >= 2 ? "domain-named-components" : null,
       namedSamples.some((sample) => sample.snippet.includes("start():")) ? "lifecycle-hook" : null
     ]),
-    proposedRule: "Preserve domain-specific module names when mirroring structure into .fabric/rules/."
+    proposedRule: "Preserve domain-specific module names when authoring knowledge entries that reference these modules."
   });
 }
 function createAssertion(input) {
@@ -1978,10 +1666,10 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join7(target, "package.json");
-  if (existsSync8(packageJsonPath)) {
+  const packageJsonPath = join5(target, "package.json");
+  if (existsSync7(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
       if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
         return packageJson.name;
       }
@@ -1992,7 +1680,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "1.8.0-rc.2" : "unknown";
+  return true ? "2.0.0-rc.1" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -2002,18 +1690,19 @@ function toPosixPath(path) {
 }
 
 // src/commands/init.ts
-var CLAUDE_INIT_SKILL_TEMPLATE = "templates/claude-skills/fabric-init/SKILL.md";
-var CLAUDE_INIT_REMINDER_HOOK_TEMPLATE = "templates/claude-hooks/fabric-init-reminder.cjs";
-var CLAUDE_INIT_REMINDER_COMMAND = ".claude/hooks/fabric-init-reminder.cjs";
-var CODEX_INIT_SKILL_TEMPLATE = "templates/codex-skills/fabric-init/SKILL.md";
-var CODEX_SESSION_START_HOOK_TEMPLATE = "templates/codex-hooks/fabric-session-start.cjs";
-var CODEX_STOP_HOOK_TEMPLATE = "templates/codex-hooks/fabric-stop-reminder.cjs";
-var CODEX_SESSION_START_COMMAND = ".codex/hooks/fabric-session-start.cjs";
-var CODEX_STOP_COMMAND = ".codex/hooks/fabric-stop-reminder.cjs";
-var LOCAL_FABRIC_SERVER_PATH = join8("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+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 = 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 = defineCommand4({
+var initCommand = defineCommand3({
   meta: {
     name: "init",
     description: t("cli.init.description")
@@ -2095,13 +1784,13 @@ async function runInitCommand(args) {
     logger(step);
   }
   if (intent.options.planOnly) {
-    writeStderr3(t("cli.init.compat.plan"));
+    writeStderr2(t("cli.init.compat.plan"));
   }
   if (args.interactive === false) {
-    writeStderr3(t("cli.init.compat.interactive"));
+    writeStderr2(t("cli.init.compat.interactive"));
   }
   if (args.bootstrap === false || args.mcp === false || args.hooks === false) {
-    writeStderr3(t("cli.init.compat.legacy-stage-flags"));
+    writeStderr2(t("cli.init.compat.legacy-stage-flags"));
   }
   const supports = detectClientSupports(intent.target);
   const basePlan = await buildInitExecutionPlan({
@@ -2120,7 +1809,7 @@ async function runInitCommand(args) {
   return executeInitExecutionPlan(plan);
 }
 function resolveInitCliIntent(args, targetInput) {
-  const target = normalizeTarget4(targetInput);
+  const target = normalizeTarget3(targetInput);
   const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
   const claudeMcpScope = resolveClaudeMcpScope(args.scope);
   const terminalInteractive = isInteractiveInit();
@@ -2150,7 +1839,7 @@ function resolveClaudeMcpScope(raw) {
   if (raw === "user") {
     return "user";
   }
-  writeStderr3(t("cli.init.mcp.scope.invalid", { value: raw }));
+  writeStderr2(t("cli.init.mcp.scope.invalid", { value: raw }));
   return "project";
 }
 async function buildInitExecutionPlan(input) {
@@ -2190,10 +1879,10 @@ async function buildInitExecutionPlan(input) {
 }
 async function executeInitExecutionPlan(plan) {
   if (plan.options.force) {
-    writeStderr3(t("cli.init.force.warning", { path: plan.target }));
+    writeStderr2(t("cli.init.force.warning", { path: plan.target }));
   }
   if (plan.options.reapply && !plan.options.planOnly && !plan.interactive) {
-    writeStderr3(formatInitModeBanner(plan.options));
+    writeStderr2(formatInitModeBanner(plan.options));
   }
   if (plan.interactive) {
     printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
@@ -2238,98 +1927,77 @@ async function executeInitExecutionPlan(plan) {
     finalSupports
   };
 }
+var KNOWLEDGE_SUBDIRS = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
+function resolvePersonalFabricRoot() {
+  return process.env.FABRIC_HOME ?? homedir5();
+}
 async function buildInitFabricPlan(target, options) {
   assertExistingDirectory3(target);
-  const fabricDir = join8(target, ".fabric");
-  const bootstrapPath = join8(fabricDir, "bootstrap", "README.md");
-  const forensicPath = join8(fabricDir, "forensic.json");
-  const taxonomyPath = join8(fabricDir, "INITIAL_TAXONOMY.md");
-  const rulesDir = join8(fabricDir, "rules");
-  const eventsPath = join8(fabricDir, "events.jsonl");
-  const claudeSkillPath = join8(target, ".claude", "skills", "fabric-init", "SKILL.md");
-  const codexSkillPath = join8(target, ".agents", "skills", "fabric-init", "SKILL.md");
-  const codexSessionStartHookPath = join8(target, ".codex", "hooks", "fabric-session-start.cjs");
-  const codexStopHookPath = join8(target, ".codex", "hooks", "fabric-stop-reminder.cjs");
-  const codexHooksConfigPath = join8(target, ".codex", "hooks.json");
-  const claudeHookPath = join8(target, ".claude", "hooks", "fabric-init-reminder.cjs");
-  const claudeSettingsPath = join8(target, ".claude", "settings.json");
-  const metaPath = join8(fabricDir, "agents.meta.json");
+  const fabricDir = join6(target, ".fabric");
+  const agentsMdPath = join6(target, "AGENTS.md");
+  const agentsMdAction = existsSync8(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 bootstrapAction = planFreshPath(bootstrapPath, options);
+  const knowledgeDirAction = existsSync8(knowledgeDir) ? "overwritten" : "created";
   const metaAction = planFreshPath(metaPath, options);
-  const taxonomyAction = planFreshPath(taxonomyPath, options);
   const eventsAction = planFreshPath(eventsPath, options);
   const forensicAction = planFreshPath(forensicPath, options);
   const forensicReport = await buildForensicReport(target);
-  const bootstrapContent = await buildFabricBootstrapGuide(target);
-  const taxonomyContent = buildInitialTaxonomyMarkdown(forensicReport);
-  const bootstrapHash = sha256(bootstrapContent);
-  const meta = createInitialMeta(bootstrapHash);
+  const meta = createInitialMeta();
   return {
     target,
     options,
     fabricDir,
     replaceFabricDir,
-    bootstrapPath,
-    bootstrapAction,
-    bootstrapContent,
+    agentsMdPath,
+    agentsMdAction,
+    knowledgeDir,
+    knowledgeDirAction,
+    personalKnowledgeDir,
     metaPath,
     metaAction,
     meta,
-    taxonomyPath,
-    taxonomyAction,
-    taxonomyContent,
-    rulesDir,
     eventsPath,
     eventsAction,
     forensicPath,
     forensicAction,
-    forensicReport,
-    claudeSkill: buildOptionalTemplateWritePlan(claudeSkillPath, findTemplatePath3(CLAUDE_INIT_SKILL_TEMPLATE), options),
-    codexSkill: buildOptionalTemplateWritePlan(codexSkillPath, findTemplatePath3(CODEX_INIT_SKILL_TEMPLATE), options),
-    codexSessionStartHook: buildOptionalTemplateWritePlan(
-      codexSessionStartHookPath,
-      findTemplatePath3(CODEX_SESSION_START_HOOK_TEMPLATE),
-      options,
-      true
-    ),
-    codexStopHook: buildOptionalTemplateWritePlan(
-      codexStopHookPath,
-      findTemplatePath3(CODEX_STOP_HOOK_TEMPLATE),
-      options,
-      true
-    ),
-    codexHooksConfig: buildCodexHooksConfigPlan(codexHooksConfigPath, options),
-    claudeHook: buildOptionalTemplateWritePlan(
-      claudeHookPath,
-      findTemplatePath3(CLAUDE_INIT_REMINDER_HOOK_TEMPLATE),
-      options,
-      true
-    ),
-    claudeSettings: buildClaudeSettingsWritePlan(claudeSettingsPath, options)
+    forensicReport
   };
 }
 async function executeInitFabricPlan(plan) {
   const isReapply = plan.options?.reapply === true;
-  const existingRules = isReapply && existsSync9(plan.rulesDir) ? readdirSync2(plan.rulesDir).filter((f) => f.endsWith(".md")) : [];
-  const preserveMeta = isReapply && existingRules.length > 0;
   if (plan.replaceFabricDir) {
     rmSync(plan.fabricDir, { force: true });
   }
-  mkdirSync3(plan.fabricDir, { recursive: true });
-  mkdirSync3(dirname5(plan.bootstrapPath), { recursive: true });
-  preparePlannedPath(plan.bootstrapPath, plan.bootstrapAction);
-  await atomicWriteText4(plan.bootstrapPath, plan.bootstrapContent);
-  if (!preserveMeta) {
-    preparePlannedPath(plan.metaPath, plan.metaAction);
-    await atomicWriteJson3(plan.metaPath, plan.meta);
-  }
-  preparePlannedPath(plan.taxonomyPath, plan.taxonomyAction);
-  await atomicWriteText4(plan.taxonomyPath, ensureTrailingNewline2(plan.taxonomyContent));
-  mkdirSync3(plan.rulesDir, { recursive: true });
+  mkdirSync(plan.fabricDir, { recursive: true });
+  if (plan.agentsMdAction === "created" && !existsSync8(plan.agentsMdPath)) {
+    await atomicWriteText2(plan.agentsMdPath, AGENTS_MD_DEFAULT_CONTENT);
+  }
+  mkdirSync(plan.knowledgeDir, { recursive: true });
+  for (const sub of KNOWLEDGE_SUBDIRS) {
+    const teamSubDir = join6(plan.knowledgeDir, sub);
+    mkdirSync(teamSubDir, { recursive: true });
+    const teamGitkeep = join6(teamSubDir, ".gitkeep");
+    if (!existsSync8(teamGitkeep)) {
+      writeFileSync(teamGitkeep, "", "utf8");
+    }
+  }
+  try {
+    mkdirSync(plan.personalKnowledgeDir, { recursive: true });
+    for (const sub of KNOWLEDGE_SUBDIRS) {
+      mkdirSync(join6(plan.personalKnowledgeDir, sub), { recursive: true });
+    }
+  } catch {
+  }
+  preparePlannedPath(plan.metaPath, plan.metaAction);
+  await atomicWriteJson2(plan.metaPath, plan.meta);
   if (isReapply) {
-    if (!existsSync9(plan.eventsPath)) {
-      mkdirSync3(dirname5(plan.eventsPath), { recursive: true });
+    if (!existsSync8(plan.eventsPath)) {
+      mkdirSync(dirname3(plan.eventsPath), { recursive: true });
       writeFileSync(plan.eventsPath, "", "utf8");
     }
   } else {
@@ -2337,46 +2005,33 @@ async function executeInitFabricPlan(plan) {
     writeFileSync(plan.eventsPath, "", "utf8");
   }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
-  await atomicWriteJson3(plan.forensicPath, plan.forensicReport);
-  applyOptionalTemplateWritePlan(plan.claudeSkill);
-  applyOptionalTemplateWritePlan(plan.codexSkill);
-  applyOptionalTemplateWritePlan(plan.codexSessionStartHook);
-  applyOptionalTemplateWritePlan(plan.codexStopHook);
-  await applyJsonWritePlan(plan.codexHooksConfig);
-  applyOptionalTemplateWritePlan(plan.claudeHook);
-  await applyClaudeSettingsWritePlan(plan.claudeSettings);
+  await atomicWriteJson2(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 (isReapply) {
     appendReapplyLedgerEvent(plan.eventsPath, {
-      preserved_ledger: true,
-      preserved_meta: preserveMeta,
-      rules_count: existingRules.length
+      preserved_ledger: true
     });
   }
   return {
-    bootstrapPath: plan.bootstrapPath,
-    bootstrapAction: plan.bootstrapAction,
+    agentsMdPath: plan.agentsMdPath,
+    agentsMdAction: plan.agentsMdAction,
+    knowledgeDir: plan.knowledgeDir,
+    knowledgeDirAction: plan.knowledgeDirAction,
+    personalKnowledgeDir: plan.personalKnowledgeDir,
     metaPath: plan.metaPath,
     metaAction: plan.metaAction,
-    taxonomyPath: plan.taxonomyPath,
-    taxonomyAction: plan.taxonomyAction,
     eventsPath: plan.eventsPath,
     eventsAction: plan.eventsAction,
     forensicPath: plan.forensicPath,
-    forensicAction: plan.forensicAction,
-    claudeSkillPath: plan.claudeSkill.path,
-    claudeSkillAction: plan.claudeSkill.action,
-    codexSkillPath: plan.codexSkill.path,
-    codexSkillAction: plan.codexSkill.action,
-    codexSessionStartHookPath: plan.codexSessionStartHook.path,
-    codexSessionStartHookAction: plan.codexSessionStartHook.action,
-    codexStopHookPath: plan.codexStopHook.path,
-    codexStopHookAction: plan.codexStopHook.action,
-    codexHooksConfigPath: plan.codexHooksConfig.path,
-    codexHooksConfigAction: plan.codexHooksConfig.action,
-    claudeHookPath: plan.claudeHook.path,
-    claudeHookAction: plan.claudeHook.action,
-    claudeSettingsPath: plan.claudeSettings.path,
-    claudeSettingsAction: plan.claudeSettings.action
+    forensicAction: plan.forensicAction
   };
 }
 async function initFabric(target, options) {
@@ -2421,22 +2076,11 @@ function exhaustiveInitStagePlan(value) {
   throw new Error(`Unsupported init stage plan: ${JSON.stringify(value)}`);
 }
 function printInitScaffoldResult(created) {
-  console.log(formatInitPathAction(created.bootstrapPath, created.bootstrapAction));
+  console.log(formatAgentsMdAction(created.agentsMdPath, created.agentsMdAction));
+  console.log(formatInitPathAction(created.knowledgeDir, created.knowledgeDirAction));
   console.log(formatInitPathAction(created.metaPath, created.metaAction));
-  console.log(formatInitPathAction(created.taxonomyPath, created.taxonomyAction));
   console.log(formatInitPathAction(created.eventsPath, created.eventsAction));
   console.log(formatInitPathAction(created.forensicPath, created.forensicAction));
-  writeStderr3(formatOptionalInitPathAction(created.claudeSkillPath, created.claudeSkillAction));
-  writeStderr3(formatOptionalInitPathAction(created.codexSkillPath, created.codexSkillAction));
-  writeStderr3(
-    formatOptionalInitPathAction(created.codexSessionStartHookPath, created.codexSessionStartHookAction)
-  );
-  writeStderr3(
-    formatOptionalInitPathAction(created.codexStopHookPath, created.codexStopHookAction)
-  );
-  writeStderr3(formatCodexHooksAction(created.codexHooksConfigPath, created.codexHooksConfigAction));
-  writeStderr3(formatOptionalInitPathAction(created.claudeHookPath, created.claudeHookAction));
-  writeStderr3(formatClaudeSettingsAction(created.claudeSettingsPath, created.claudeSettingsAction));
 }
 function printInitPostSetup(plan, stageResults, finalSupports) {
   if (shouldPrintHooksNextStep(plan.options, stageResults)) {
@@ -2470,30 +2114,17 @@ function printInitPlanPreview(plan) {
 }
 function buildPlanOnlyScaffoldResult(plan) {
   return {
-    bootstrapPath: plan.bootstrapPath,
-    bootstrapAction: plan.bootstrapAction,
+    agentsMdPath: plan.agentsMdPath,
+    agentsMdAction: plan.agentsMdAction,
+    knowledgeDir: plan.knowledgeDir,
+    knowledgeDirAction: plan.knowledgeDirAction,
+    personalKnowledgeDir: plan.personalKnowledgeDir,
     metaPath: plan.metaPath,
     metaAction: plan.metaAction,
-    taxonomyPath: plan.taxonomyPath,
-    taxonomyAction: plan.taxonomyAction,
     eventsPath: plan.eventsPath,
     eventsAction: plan.eventsAction,
     forensicPath: plan.forensicPath,
-    forensicAction: plan.forensicAction,
-    claudeSkillPath: plan.claudeSkill.path,
-    claudeSkillAction: plan.claudeSkill.action,
-    codexSkillPath: plan.codexSkill.path,
-    codexSkillAction: plan.codexSkill.action,
-    codexSessionStartHookPath: plan.codexSessionStartHook.path,
-    codexSessionStartHookAction: plan.codexSessionStartHook.action,
-    codexStopHookPath: plan.codexStopHook.path,
-    codexStopHookAction: plan.codexStopHook.action,
-    codexHooksConfigPath: plan.codexHooksConfig.path,
-    codexHooksConfigAction: plan.codexHooksConfig.action,
-    claudeHookPath: plan.claudeHook.path,
-    claudeHookAction: plan.claudeHook.action,
-    claudeSettingsPath: plan.claudeSettings.path,
-    claudeSettingsAction: plan.claudeSettings.action
+    forensicAction: plan.forensicAction
   };
 }
 async function executeInitStagePlan(plan, stageName) {
@@ -2508,25 +2139,18 @@ async function executeInitStagePlan(plan, stageName) {
   try {
     switch (stage.name) {
       case "bootstrap": {
-        const result = await installBootstrap(plan.target, { force: plan.options.force });
-        if (result.details.length === 0) {
-          console.log(formatInitStageResult("bootstrap", "skipped", 0, 0, t("cli.bootstrap.install.no-targets")));
-          return { name: "bootstrap", disposition: "skipped" };
-        }
-        console.log(
-          formatInitStageResult("bootstrap", "completed", result.installed.length, result.skipped.length)
-        );
-        return { name: "bootstrap", disposition: "ran" };
+        console.log(formatInitStageResult("bootstrap", "skipped", 0, 0, t("cli.bootstrap.install.no-targets")));
+        return { name: "bootstrap", disposition: "skipped" };
       }
       case "mcp": {
         if (stage.installMode === "local") {
           const manager = stage.packageManager ?? detectPackageManager(plan.target);
-          writeStderr3(t("cli.init.mcp.install.local"));
-          writeStderr3(t("cli.init.mcp.local.installing", { manager }));
+          writeStderr2(t("cli.init.mcp.install.local"));
+          writeStderr2(t("cli.init.mcp.local.installing", { manager }));
           installLocalFabricServer(plan.target, manager);
-          writeStderr3(t("cli.init.mcp.local.installed"));
+          writeStderr2(t("cli.init.mcp.local.installed"));
         } else {
-          writeStderr3(t("cli.init.mcp.install.global"));
+          writeStderr2(t("cli.init.mcp.install.global"));
         }
         const result = await installMcpClients(plan.target, {
           force: plan.options.force,
@@ -2549,12 +2173,12 @@ async function executeInitStagePlan(plan, stageName) {
         return exhaustiveInitStagePlan(stage);
     }
   } catch (error) {
-    writeStderr3(formatInitStageFailure(stageName, error));
+    writeStderr2(formatInitStageFailure(stageName, error));
     return { name: stageName, disposition: "failed" };
   }
 }
 function shouldReplaceWritableDirectory(path, options) {
-  if (!existsSync9(path)) {
+  if (!existsSync8(path)) {
     return false;
   }
   if (statSync3(path).isDirectory()) {
@@ -2566,7 +2190,7 @@ function shouldReplaceWritableDirectory(path, options) {
   return true;
 }
 function planFreshPath(path, options) {
-  if (!existsSync9(path)) {
+  if (!existsSync8(path)) {
     return "created";
   }
   if (!options?.force) {
@@ -2575,131 +2199,11 @@ function planFreshPath(path, options) {
   return "overwritten";
 }
 function preparePlannedPath(path, action) {
-  mkdirSync3(dirname5(path), { recursive: true });
-  if (action === "overwritten" && existsSync9(path)) {
+  mkdirSync(dirname3(path), { recursive: true });
+  if (action === "overwritten" && existsSync8(path)) {
     rmSync(path, { recursive: true, force: true });
   }
 }
-function buildOptionalTemplateWritePlan(path, templatePath, options, executable = false) {
-  const existed = existsSync9(path);
-  if (existed && !options?.force) {
-    return { path, action: "skipped", templatePath, executable };
-  }
-  return {
-    path,
-    action: existed ? "overwritten" : "created",
-    templatePath,
-    executable
-  };
-}
-function applyOptionalTemplateWritePlan(plan) {
-  if (plan.action === "skipped") {
-    return;
-  }
-  mkdirSync3(dirname5(plan.path), { recursive: true });
-  copyFileSync(plan.templatePath, plan.path);
-  if (plan.executable) {
-    chmodSync2(plan.path, 493);
-  }
-}
-function buildCodexHooksConfigValue() {
-  return {
-    hooks: {
-      SessionStart: [
-        {
-          matcher: "*",
-          hooks: [{ type: "command", command: CODEX_SESSION_START_COMMAND }]
-        }
-      ],
-      Stop: [
-        {
-          matcher: "*",
-          hooks: [{ type: "command", command: CODEX_STOP_COMMAND }]
-        }
-      ]
-    }
-  };
-}
-function buildCodexHooksConfigPlan(configPath, options) {
-  const action = !existsSync9(configPath) ? "created" : options?.force ? "overwritten" : "skipped";
-  return {
-    path: configPath,
-    action,
-    value: buildCodexHooksConfigValue()
-  };
-}
-async function applyJsonWritePlan(plan) {
-  if (plan.action === "skipped") {
-    return;
-  }
-  mkdirSync3(dirname5(plan.path), { recursive: true });
-  await atomicWriteJson3(plan.path, plan.value);
-}
-function buildClaudeSettingsWritePlan(settingsPath, options) {
-  let settings;
-  let action = "updated";
-  if (!existsSync9(settingsPath)) {
-    settings = {};
-    action = "created";
-  } else {
-    try {
-      const parsed = JSON.parse(readFileSync4(settingsPath, "utf8"));
-      if (!isRecord(parsed)) {
-        writeStderr3(t("cli.init.claude-settings.invalid-object", { label: skippedLabel(), path: settingsPath }));
-        return { path: settingsPath, action: "skipped-invalid", value: null };
-      }
-      settings = parsed;
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "unknown parse error";
-      writeStderr3(t("cli.init.claude-settings.invalid-json", { label: skippedLabel(), path: settingsPath, reason }));
-      return { path: settingsPath, action: "skipped-invalid", value: null };
-    }
-  }
-  if (settings.hooks !== void 0 && !isRecord(settings.hooks)) {
-    writeStderr3(t("cli.init.claude-settings.invalid-hooks", { label: skippedLabel(), path: settingsPath }));
-    return { path: settingsPath, action: "skipped-invalid", value: null };
-  }
-  const hooks = settings.hooks ?? {};
-  const stopHooksValue = hooks.Stop;
-  if (stopHooksValue !== void 0 && !Array.isArray(stopHooksValue)) {
-    writeStderr3(t("cli.init.claude-settings.invalid-stop-array", { label: skippedLabel(), path: settingsPath }));
-    return { path: settingsPath, action: "skipped-invalid", value: null };
-  }
-  const stopHooks = Array.isArray(stopHooksValue) ? stopHooksValue : [];
-  const hasExistingFabricHook = hasClaudeInitReminderHook(stopHooks);
-  if (hasExistingFabricHook && !options?.force) {
-    return { path: settingsPath, action: "skipped", value: null };
-  }
-  const nextStopHooks = hasExistingFabricHook && options?.force ? removeClaudeInitReminderHook(stopHooks) : [...stopHooks];
-  nextStopHooks.push({
-    matcher: "*",
-    hooks: [
-      {
-        type: "command",
-        command: CLAUDE_INIT_REMINDER_COMMAND
-      }
-    ]
-  });
-  const nextSettings = {
-    ...settings,
-    hooks: {
-      ...hooks,
-      Stop: nextStopHooks
-    }
-  };
-  return {
-    path: settingsPath,
-    action: hasExistingFabricHook && options?.force ? "overwritten" : action,
-    value: nextSettings
-  };
-}
-async function applyClaudeSettingsWritePlan(plan) {
-  if (plan.value === null) {
-    return;
-  }
-  mkdirSync3(dirname5(plan.path), { recursive: true });
-  await atomicWriteJson3(plan.path, plan.value);
-}
 function createDefaultInitWizardAdapter() {
   return {
     async run(context) {
@@ -2871,23 +2375,23 @@ function formatInitModeBadge(options) {
   }
   return t("cli.init.mode.badge.default");
 }
-function normalizeTarget4(targetInput) {
-  return isAbsolute4(targetInput) ? targetInput : resolve9(process.cwd(), targetInput);
+function normalizeTarget3(targetInput) {
+  return isAbsolute3(targetInput) ? targetInput : resolve7(process.cwd(), targetInput);
 }
 function assertExistingDirectory3(target) {
-  if (!existsSync9(target) || !statSync3(target).isDirectory()) {
+  if (!existsSync8(target) || !statSync3(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
 function detectPackageManager(cwd) {
-  const workspaceRoot = resolve9(cwd);
-  if (existsSync9(join8(workspaceRoot, "pnpm-lock.yaml"))) {
+  const workspaceRoot = resolve7(cwd);
+  if (existsSync8(join6(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync9(join8(workspaceRoot, "yarn.lock"))) {
+  if (existsSync8(join6(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync9(join8(workspaceRoot, "package-lock.json"))) {
+  if (existsSync8(join6(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";
@@ -2896,7 +2400,7 @@ function resolveMcpInstallMode(rawMode) {
   if (rawMode === void 0 || rawMode === "global" || rawMode === "local") {
     return rawMode ?? "global";
   }
-  writeStderr3(t("cli.init.mcp.install.invalid", { value: rawMode }));
+  writeStderr2(t("cli.init.mcp.install.invalid", { value: rawMode }));
   return "global";
 }
 function installLocalFabricServer(target, manager) {
@@ -2907,20 +2411,11 @@ function installLocalFabricServer(target, manager) {
     shell: process.platform === "win32"
   });
 }
-function createInitialMeta(agentsHash) {
+function createInitialMeta() {
   return {
-    revision: sha256(agentsHash),
-    nodes: {
-      L0: {
-        file: ".fabric/bootstrap/README.md",
-        scope_glob: "**",
-        deps: [],
-        priority: "high",
-        layer: "L0",
-        topology_type: "mirror",
-        hash: agentsHash
-      }
-    }
+    revision: "sha256:initial",
+    nodes: {},
+    counters: defaultAgentsMetaCounters()
   };
 }
 function appendReapplyLedgerEvent(eventsPath, payload) {
@@ -2930,127 +2425,12 @@ function appendReapplyLedgerEvent(eventsPath, payload) {
     ts: Date.now(),
     schema_version: 1,
     event_type: "reapply_completed",
-    preserved_ledger: payload.preserved_ledger,
-    preserved_meta: payload.preserved_meta,
-    rules_count: payload.rules_count
+    preserved_ledger: payload.preserved_ledger
   };
   const line = `${JSON.stringify(event)}
 `;
   appendFileSync(eventsPath, line, "utf8");
 }
-function buildInitialTaxonomyMarkdown(forensicReport) {
-  const frameworkInfo = forensicReport.framework;
-  const framework = [frameworkInfo?.kind ?? "unknown", frameworkInfo?.subkind ?? ""].filter((value) => value.trim() !== "").join(" / ") || "unknown";
-  const keyDirs = forensicReport.topology?.key_dirs?.slice(0, 8) ?? [];
-  const candidateFiles = forensicReport.candidate_files?.slice(0, 8) ?? [];
-  const generatedAt = forensicReport.generated_at ?? (/* @__PURE__ */ new Date()).toISOString();
-  return `# Fabric Initial Taxonomy
-
-**Date**: ${generatedAt}
-**Base Architecture**: L0/L1/L2 Tiered System
-**Detected Framework**: ${framework}
-
-## Origin Logic
-
-- **L0 \u5224\u5B9A**: \u5168\u5C40\u534F\u4F5C\u7A33\u5B9A\u6027\u89C4\u5219\u3002\u5178\u578B\u6765\u6E90\u5305\u62EC\u4ED3\u5E93\u6839\u914D\u7F6E\u3001package metadata\u3001Fabric \u5185\u90E8\u534F\u8BAE\u548C\u4E0D\u53EF\u968F\u5C40\u90E8\u4E1A\u52A1\u6F02\u79FB\u7684\u7EA6\u675F\u3002
-- **L1 \u5224\u5B9A**: \u9886\u57DF/\u6A21\u5757\u7EA7\u89C4\u5219\u3002\u4F9D\u636E\u6280\u672F\u6808\u3001\u76EE\u5F55\u804C\u8D23\u3001\u6846\u67B6\u7279\u5F81\u548C\u529F\u80FD\u6A21\u5757\u5212\u5206\uFF0C\u800C\u4E0D\u662F\u8DEF\u5F84\u6DF1\u5EA6\u3002
-- **L2 \u5224\u5B9A**: \u5177\u4F53\u811A\u672C\u3001\u8D44\u6E90\u6216\u5C40\u90E8\u4E1A\u52A1\u72B6\u6001\u89C4\u5219\u3002\u7528\u4E8E\u627F\u8F7D\u7279\u5B9A\u6587\u4EF6\u3001\u8D44\u6E90\u3001\u5386\u53F2\u8865\u4E01\u548C\u5C40\u90E8\u5904\u7406\u7EC6\u5219\u3002
-
-## Initial L1 Buckets
-
-${formatInitialL1Buckets(keyDirs)}
-
-## L2 Candidate Signals
-
-${formatInitialL2Signals(candidateFiles)}
-
-## Evolution Guide
-
-- \u6D89\u53CA\u5168\u4ED3\u534F\u4F5C\u7A33\u5B9A\u6027\u7684\u89C4\u5219\u8FDB\u5165 L0\u3002
-- \u6D89\u53CA\u6280\u672F\u9886\u57DF\u3001\u6846\u67B6\u6A21\u5757\u6216\u529F\u80FD\u6A21\u5757\u7684\u89C4\u5219\u8FDB\u5165 L1\u3002
-- \u6D89\u53CA\u5177\u4F53\u6587\u4EF6\u3001\u5177\u4F53\u8D44\u6E90\u6216\u5C40\u90E8\u4E1A\u52A1\u72B6\u6001\u7684\u89C4\u5219\u8FDB\u5165 L2\u3002
-- \u51B2\u7A81\u65F6\u6267\u884C\u89E3\u91CA\u56FA\u5B9A\u4E3A L2 > L1 > L0\uFF1B\u540C\u5C42\u5185\u624D\u4F7F\u7528 priority \u6392\u5E8F\u3002
-`;
-}
-function formatInitialL1Buckets(keyDirs) {
-  if (keyDirs.length === 0) {
-    return "- **L1-General**: \u521D\u59CB\u5316\u65F6\u672A\u68C0\u6D4B\u5230\u7A33\u5B9A\u76EE\u5F55\u8F74\u7EBF\uFF0C\u540E\u7EED\u4F9D\u636E\u6280\u672F\u6808\u548C\u6A21\u5757\u804C\u8D23\u6F14\u8FDB\u3002";
-  }
-  return keyDirs.map((dir) => `- **L1-${sanitizeTaxonomyLabel(dir)}**: \u6302\u8F7D\u4F9D\u636E\u2014\u2014forensic topology detected \`${dir}\`.`).join("\n");
-}
-function formatInitialL2Signals(candidateFiles) {
-  if (candidateFiles.length === 0) {
-    return "- \u6682\u672A\u8BC6\u522B\u660E\u786E L2 \u5019\u9009\u6587\u4EF6\u3002";
-  }
-  return candidateFiles.map((entry) => `- \`${entry.path}\`: ${entry.family} \u2014 ${entry.rationale}`).join("\n");
-}
-function sanitizeTaxonomyLabel(value) {
-  const sanitized = value.replaceAll("\\", "/").split("/").filter(Boolean).join("-").replace(/[^A-Za-z0-9_-]+/gu, "-").replace(/^-+|-+$/gu, "");
-  return sanitized === "" ? "General" : sanitized;
-}
-function ensureTrailingNewline2(value) {
-  return value.endsWith("\n") ? value : `${value}
-`;
-}
-function findTemplatePath3(relativePath) {
-  const currentModuleDir = dirname5(fileURLToPath4(import.meta.url));
-  const candidates = [
-    ...templateCandidatesFrom3(process.cwd(), relativePath),
-    ...templateCandidatesFrom3(currentModuleDir, relativePath)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync9(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(t("cli.shared.template-not-found", { path: relativePath }));
-}
-function templateCandidatesFrom3(start, relativePath) {
-  const candidates = [];
-  let current = resolve9(start);
-  while (true) {
-    candidates.push(join8(current, ...relativePath.split("/")));
-    const parent = dirname5(current);
-    if (parent === current || parse3(current).root === current) {
-      break;
-    }
-    current = parent;
-  }
-  return candidates.reverse();
-}
-function hasClaudeInitReminderHook(stopHooks) {
-  return stopHooks.some((entry) => isClaudeInitReminderStopEntry(entry));
-}
-function removeClaudeInitReminderHook(stopHooks) {
-  return stopHooks.filter((entry) => !isClaudeInitReminderStopEntry(entry));
-}
-function isClaudeInitReminderStopEntry(entry) {
-  if (!isRecord(entry) || !Array.isArray(entry.hooks)) {
-    return false;
-  }
-  return entry.hooks.some(
-    (hook) => isRecord(hook) && hook.type === "command" && typeof hook.command === "string" && (hook.command.includes("fabric-init-reminder.cjs") || hook.command.includes("agents-md-init-reminder.cjs"))
-  );
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function formatClaudeSettingsAction(settingsPath, action) {
-  switch (action) {
-    case "created":
-      return t("cli.init.claude-settings.created", { label: createdLabel(), path: settingsPath });
-    case "updated":
-      return t("cli.init.claude-settings.updated", { label: updatedLabel(), path: settingsPath });
-    case "overwritten":
-      return t("cli.init.claude-settings.updated", { label: overwrittenLabel(), path: settingsPath });
-    case "skipped":
-      return t("cli.init.claude-settings.skipped", { label: skippedLabel(), path: settingsPath });
-    case "skipped-invalid":
-      return t("cli.init.claude-settings.skipped-invalid", { label: skippedLabel(), path: settingsPath });
-    default:
-      return t("cli.init.claude-settings.updated", { label: updatedLabel(), path: settingsPath });
-  }
-}
 function formatInitStageHeader(message) {
   return `${nextLabel()} ${paint.muted(message)}`;
 }
@@ -3101,9 +2481,8 @@ function printInitPlanSummary(target, options, mcpInstallMode, supports) {
     })
   );
   console.log(t("cli.init.plan.writes"));
-  console.log(`  - ${target}/.fabric/bootstrap/README.md`);
+  console.log(`  - ${target}/.fabric/knowledge/{decisions,pitfalls,guidelines,models,processes,pending}/`);
   console.log(`  - ${target}/.fabric/agents.meta.json`);
-  console.log(`  - ${target}/.fabric/INITIAL_TAXONOMY.md`);
   console.log(`  - ${target}/.fabric/events.jsonl`);
   console.log(`  - ${target}/.fabric/forensic.json`);
 }
@@ -3137,18 +2516,6 @@ function printInitCapabilitySummary(supports, stageResults, options) {
     console.log(formatCapabilityTableRow(row, widths));
   }
 }
-function formatCodexHooksAction(configPath, action) {
-  switch (action) {
-    case "created":
-      return t("cli.init.codex-hooks.created", { label: createdLabel(), path: configPath });
-    case "overwritten":
-      return t("cli.init.codex-hooks.updated", { label: overwrittenLabel(), path: configPath });
-    case "skipped":
-      return t("cli.init.codex-hooks.skipped", { label: skippedLabel(), path: configPath });
-    default:
-      return t("cli.init.codex-hooks.updated", { label: updatedLabel(), path: configPath });
-  }
-}
 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");
@@ -3209,18 +2576,6 @@ function formatCapabilityDivider(widths) {
 }
 function formatInitReasonMessage(supports) {
   const detected = supports.filter((support) => support.detected);
-  const installedSkillClients = detected.filter((support) => hasInstalledCapability(support, "skill"));
-  const hasClaudeSkill = installedSkillClients.some((support) => support.clientKind === "ClaudeCodeCLI");
-  const hasCodexSkill = installedSkillClients.some((support) => support.clientKind === "CodexCLI");
-  if (hasClaudeSkill && hasCodexSkill) {
-    return t("cli.init.reason-message.multi-body");
-  }
-  if (hasClaudeSkill) {
-    return t("cli.init.reason-message.claude-body");
-  }
-  if (hasCodexSkill) {
-    return t("cli.init.reason-message.codex-body");
-  }
   if (detected.some((support) => support.capabilities.skill)) {
     return t("cli.init.reason-message.installable-body");
   }
@@ -3232,11 +2587,11 @@ function yesNoLabel(value) {
 function formatInitPathAction(path, action) {
   return t("cli.init.created-path", { label: labelForInitWriteAction(action), path });
 }
-function formatOptionalInitPathAction(path, action) {
-  if (action === "skipped") {
+function formatAgentsMdAction(path, action) {
+  if (action === "preserved") {
     return t("cli.init.skipped-existing-path", { label: skippedLabel(), path });
   }
-  return formatInitPathAction(path, action);
+  return t("cli.init.created-path", { label: createdLabel(), path });
 }
 function labelForInitWriteAction(action) {
   return action === "overwritten" ? overwrittenLabel() : createdLabel();
@@ -3253,9 +2608,6 @@ function nextLabel() {
 function reasonLabel() {
   return paint.human(t("cli.shared.reason"));
 }
-function updatedLabel() {
-  return paint.success(t("cli.shared.updated"));
-}
 function overwrittenLabel() {
   return paint.warn(t("cli.init.force.overwritten"));
 }
@@ -3268,13 +2620,10 @@ function skippedStageLabel() {
 function failedStageLabel() {
   return paint.error(t("cli.init.stages.failed"));
 }
-function writeStderr3(message) {
+function writeStderr2(message) {
   process.stderr.write(`${message}
 `);
 }
-function sha256(content) {
-  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
-}
 export {
   buildInitExecutionPlan,
   buildInitFabricPlan,