@fenglimg/fabric-cli 2.0.0-rc.1 → 2.0.0-rc.10

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

@@ -1,447 +1,59 @@
 #!/usr/bin/env node
+import {
+  hooksCommand,
+  installHooks
+} from "./chunk-WPTA74BY.js";
 import {
   detectFramework,
   runInitScan
-} from "./chunk-UHNP7T7W.js";
+} from "./chunk-MT3R57VG.js";
+import {
+  detectClientSupports,
+  resolveClients
+} from "./chunk-HQLEHH4O.js";
+import {
+  addArchiveSkillPointer,
+  installArchiveHintHook,
+  installFabricArchiveSkill,
+  installFabricImportSkill,
+  installFabricReviewSkill,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig
+} from "./chunk-AW3G7ZH5.js";
 import {
-  createDebugLogger,
   displayWidth,
   padEnd,
-  paint,
-  resolveDevMode,
+  paint
+} from "./chunk-WWNXR34K.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-OBQU6NHO.js";
+import {
   t
-} from "./chunk-5LOYBXWD.js";
+} from "./chunk-6ICJICVU.js";
 
 // src/commands/init.ts
 import { randomUUID } from "crypto";
-import { homedir as homedir5 } from "os";
+import { homedir } from "os";
 import * as childProcess from "child_process";
-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 { appendFileSync, existsSync as existsSync3, mkdirSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
+import { dirname, isAbsolute as isAbsolute2, join as join2, resolve as resolve3 } from "path";
 import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
 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 { atomicWriteJson, atomicWriteText } 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 existsSync6 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { resolve as resolve5 } from "path";
-import { fileURLToPath } from "url";
-import { defineCommand as defineCommand2 } from "citty";
-
-// src/config/resolver.ts
-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 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 } from "fs";
-import { mkdir, readFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
-import { homedir } from "os";
-import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
-
-// src/config/writer.ts
-function createServerEntry(serverPath) {
-  return {
-    command: process.execPath,
-    args: [serverPath]
-  };
-}
-
-// src/config/json.ts
-function deepMerge(target, source) {
-  if (target === null || typeof target !== "object" || Array.isArray(target) || source === null || typeof source !== "object" || Array.isArray(source)) {
-    return source;
-  }
-  const out = { ...target };
-  for (const key of Object.keys(source)) {
-    out[key] = deepMerge(
-      target[key],
-      source[key]
-    );
-  }
-  return out;
-}
-function expandHome(filePath) {
-  if (filePath === "~") {
-    return homedir();
-  }
-  if (filePath.startsWith("~/")) {
-    return join(homedir(), filePath.slice(2));
-  }
-  return filePath;
-}
-function normalizeConfigPath(filePath) {
-  return resolve(expandHome(filePath));
-}
-async function readJsonConfig(configPath) {
-  try {
-    const raw = await readFile(configPath, "utf8");
-    if (raw.trim().length === 0) {
-      return {};
-    }
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      throw new Error(`Expected JSON object in ${configPath}`);
-    }
-    return parsed;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return {};
-    }
-    throw error;
-  }
-}
-async function writeJsonClientConfig(configPath, serverEntry) {
-  const existing = await readJsonConfig(configPath);
-  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
-  await mkdir(dirname(configPath), { recursive: true });
-  await atomicWriteJson(configPath, merged, { indent: 2 });
-}
-var JsonClientConfigWriter = class {
-  configuredPath;
-  constructor(configuredPath) {
-    this.configuredPath = configuredPath;
-  }
-  async detect(workspaceRoot, overridePath) {
-    const explicitPath = overridePath ?? this.configuredPath;
-    if (explicitPath !== void 0) {
-      return normalizeConfigPath(explicitPath);
-    }
-    const configPath = this.defaultPath(workspaceRoot);
-    return configPath === null ? null : normalizeConfigPath(configPath);
-  }
-  async write(serverPath, workspaceRoot, overridePath) {
-    const configPath = await this.detect(workspaceRoot, overridePath);
-    if (configPath === null) {
-      return;
-    }
-    await writeJsonClientConfig(configPath, createServerEntry(serverPath));
-  }
-};
-var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
-  clientKind = "ClaudeCodeCLI";
-  scope;
-  constructor(configuredPath, scope = "project") {
-    super(configuredPath);
-    this.scope = scope;
-  }
-  // Writes to project-level .mcp.json (per Claude Code MCP spec) by default,
-  // or ~/.claude.json for user scope.
-  // Detection still checks ~/.claude to confirm Claude Code is installed.
-  defaultPath(workspaceRoot) {
-    const globalClaudeDir = join(homedir(), ".claude");
-    const projectClaudeDir = join(workspaceRoot, ".claude");
-    if (!existsSync(globalClaudeDir) && !existsSync(projectClaudeDir)) {
-      return null;
-    }
-    return this.scope === "user" ? join(homedir(), ".claude.json") : join(workspaceRoot, ".mcp.json");
-  }
-};
-var CursorWriter = class extends JsonClientConfigWriter {
-  clientKind = "Cursor";
-  constructor(configuredPath) {
-    super(configuredPath);
-  }
-  defaultPath(workspaceRoot) {
-    const cursorDir = join(workspaceRoot, ".cursor");
-    return existsSync(cursorDir) ? join(cursorDir, "mcp.json") : null;
-  }
-};
-
-// src/config/claude-code.ts
-function getClaudeDesktopConfigPath() {
-  const os = platform();
-  if (os === "darwin") {
-    return join2(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
-  }
-  if (os === "win32") {
-    return join2(process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-  }
-  return join2(homedir2(), ".config", "Claude", "claude_desktop_config.json");
-}
-var ClaudeCodeDesktopWriter = class {
-  clientKind = "ClaudeCodeDesktop";
-  configuredPath;
-  constructor(configuredPath) {
-    this.configuredPath = configuredPath;
-  }
-  async detect(_workspaceRoot, overridePath) {
-    const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
-    return existsSync2(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
-  }
-  async write(serverPath, workspaceRoot, overridePath) {
-    const configPath = await this.detect(workspaceRoot, overridePath);
-    if (configPath === null) {
-      return;
-    }
-    await writeJsonClientConfig(configPath, {
-      command: process.execPath,
-      args: [serverPath]
-    });
-  }
-};
-
-// src/config/toml.ts
-import { existsSync as existsSync3 } from "fs";
-import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
-import { homedir as homedir3 } from "os";
-import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-function expandHome2(filePath) {
-  if (filePath === "~") {
-    return homedir3();
-  }
-  if (filePath.startsWith("~/")) {
-    return join3(homedir3(), filePath.slice(2));
-  }
-  return filePath;
-}
-function escapeTomlString(value) {
-  return JSON.stringify(value);
-}
-function serializeTomlStringArray(values) {
-  return `[${values.map((value) => escapeTomlString(value)).join(", ")}]`;
-}
-function serializeTomlInlineTable(values) {
-  const entries = Object.entries(values).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key} = ${escapeTomlString(value)}`);
-  return `{ ${entries.join(", ")} }`;
-}
-function serializeCodexServerBlock(serverName, serverEntry) {
-  const lines = [
-    `[mcp_servers.${serverName}]`,
-    `command = ${escapeTomlString(serverEntry.command)}`,
-    `args = ${serializeTomlStringArray(serverEntry.args)}`
-  ];
-  if (serverEntry.env !== void 0 && Object.keys(serverEntry.env).length > 0) {
-    lines.push(`env = ${serializeTomlInlineTable(serverEntry.env)}`);
-  }
-  return `${lines.join("\n")}
-`;
-}
-function trimTrailingBlankLines(value) {
-  return value.replace(/\s+$/u, "");
-}
-function upsertCodexServerBlock(rawConfig, serverName, serverEntry) {
-  const block = serializeCodexServerBlock(serverName, serverEntry);
-  const normalized = rawConfig.replace(/\r\n/g, "\n");
-  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
-  const currentPattern = new RegExp(
-    String.raw`\n?\[mcp_servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
-    "g"
-  );
-  const withoutLegacy = normalized.replace(legacyPattern, "");
-  const withoutExisting = withoutLegacy.replace(currentPattern, "");
-  const trimmed = trimTrailingBlankLines(withoutExisting);
-  if (trimmed.length === 0) {
-    return block;
-  }
-  return `${trimmed}
-
-${block}`;
-}
-async function readTomlConfigText(configPath) {
-  try {
-    return await readFile2(configPath, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return "";
-    }
-    throw error;
-  }
-}
-var CodexTOMLConfigWriter = class {
-  clientKind = "CodexCLI";
-  configuredPath;
-  constructor(configuredPath) {
-    this.configuredPath = configuredPath;
-  }
-  async detect(_workspaceRoot, overridePath) {
-    const explicitPath = overridePath ?? this.configuredPath;
-    if (explicitPath !== void 0) {
-      return resolve3(expandHome2(explicitPath));
-    }
-    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);
-    if (configPath === null) {
-      return;
-    }
-    const rawConfig = await readTomlConfigText(configPath);
-    const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
-    await mkdir2(dirname2(configPath), { recursive: true });
-    await atomicWriteText(configPath, nextConfig);
-  }
-};
-
-// src/config/resolver.ts
-import { clientPathsSchema, fabricConfigSchema } from "@fenglimg/fabric-shared";
-function hasExplicitPath(clientPaths, key) {
-  return typeof clientPaths?.[key] === "string" && clientPaths[key].trim().length > 0;
-}
-function addIfDetected(writers, detected, createWriter, configuredPath) {
-  if (configuredPath !== void 0 || detected) {
-    writers.push(createWriter(configuredPath));
-  }
-}
-function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
-  const clientPaths = fabricConfig.clientPaths;
-  const writers = [];
-  const claudeMcpScope = opts.claudeMcpScope ?? "project";
-  addIfDetected(
-    writers,
-    existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude")),
-    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
-    hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync4(getClaudeDesktopConfigPath()),
-    (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
-    hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync4(join4(workspaceRoot, ".cursor")),
-    (configuredPath) => new CursorWriter(configuredPath),
-    hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
-  );
-  addIfDetected(
-    writers,
-    existsSync4(join4(homedir4(), ".codex")),
-    (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
-    hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
-  );
-  return writers;
-}
-function detectClientSupports(workspaceRoot, fabricConfig = {}) {
-  const clientPaths = fabricConfig.clientPaths;
-  const claudeDetected = 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",
-      label: "Claude Code CLI",
-      detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "project .claude/settings.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: true,
-        skill: true
-      },
-      installedCapabilities: {
-        hook: true,
-        skill: true
-      }
-    },
-    {
-      clientKind: "ClaudeCodeDesktop",
-      label: "Claude Code Desktop",
-      detected: claudeDesktopDetected || hasExplicitPath(clientPaths, "claudeCodeDesktop"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "desktop Claude config",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
-    {
-      clientKind: "Cursor",
-      label: "Cursor",
-      detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: ".cursor/mcp.json",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: false,
-        skill: false
-      }
-    },
-    {
-      clientKind: "CodexCLI",
-      label: "Codex CLI",
-      detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
-      bootstrapTargetPath: ".fabric/bootstrap/README.md",
-      configPath: "~/.codex/config.toml",
-      capabilities: {
-        bootstrap: true,
-        mcp: true,
-        hook: true,
-        skill: true
-      },
-      installedCapabilities: {
-        hook: 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/hooks.ts
-import { existsSync as existsSync5, statSync } from "fs";
-import { isAbsolute, resolve as resolve4 } from "path";
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
 import { defineCommand } from "citty";
-var hooksCommand = defineCommand({
-  meta: {
-    name: "hooks",
-    description: t("cli.hooks.description")
-  },
-  subCommands: {
-    install: defineCommand({
-      meta: {
-        name: "install",
-        description: t("cli.hooks.install.description")
-      },
-      args: {
-        target: {
-          type: "string",
-          description: t("cli.hooks.install.args.target.description"),
-          default: process.cwd()
-        }
-      },
-      async run({ args }) {
-        await installHooks(args.target);
-      }
-    })
-  }
-});
-async function installHooks(target, _options = {}) {
-  const normalizedTarget = normalizeTarget(target);
-  assertExistingDirectory(normalizedTarget);
-  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 normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve4(process.cwd(), targetInput);
-}
-function assertExistingDirectory(target) {
-  if (!existsSync5(target) || !statSync(target).isDirectory()) {
-    throw new Error(t("cli.shared.target-invalid", { target }));
-  }
-}
-
-// src/commands/config.ts
 var CLIENT_ALIASES = {
   claude: "ClaudeCodeCLI",
   claudecodecli: "ClaudeCodeCLI",
@@ -471,11 +83,11 @@ function parseClientFilter(value) {
   return clients;
 }
 async function loadFabricConfig(workspaceRoot) {
-  const configPath = resolve5(workspaceRoot, "fabric.config.json");
-  if (!existsSync6(configPath)) {
+  const configPath = resolve(workspaceRoot, "fabric.config.json");
+  if (!existsSync(configPath)) {
     return {};
   }
-  const parsed = JSON.parse(await readFile3(configPath, "utf8"));
+  const parsed = JSON.parse(await readFile(configPath, "utf8"));
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
   }
@@ -483,21 +95,21 @@ async function loadFabricConfig(workspaceRoot) {
 }
 function resolveServerPath(override) {
   if (override) return override;
-  if (process.env.FAB_SERVER_PATH) return resolve5(process.env.FAB_SERVER_PATH);
+  if (process.env.FAB_SERVER_PATH) return resolve(process.env.FAB_SERVER_PATH);
   return fileURLToPath(import.meta.resolve("@fenglimg/fabric-server"));
 }
 function writeStderr(message) {
   process.stderr.write(`${message}
 `);
 }
-var configCmd = defineCommand2({
+var configCmd = defineCommand({
   meta: {
     name: "config",
     description: t("cli.config.description")
   },
   subCommands: {
     hooks: hooksCommand,
-    install: defineCommand2({
+    install: defineCommand({
       meta: {
         name: "install",
         description: t("cli.config.install.description")
@@ -541,7 +153,7 @@ var configCmd = defineCommand2({
   }
 });
 async function installMcpClients(target, options = {}) {
-  const workspaceRoot = resolve5(target);
+  const workspaceRoot = resolve(target);
   const fabricConfig = await loadFabricConfig(workspaceRoot);
   const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
   const serverPath = resolveServerPath(options.localServerPath);
@@ -572,9 +184,9 @@ async function installMcpClients(target, options = {}) {
 
 // src/scanner/forensic.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync7, readdirSync, readFileSync, statSync as statSync2 } from "fs";
+import { existsSync as existsSync2, readdirSync, readFileSync, statSync } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute as isAbsolute2, join as join5, posix, relative, resolve as resolve6, sep } from "path";
+import { basename, extname, isAbsolute, join, posix, relative, resolve as resolve2, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
@@ -660,7 +272,7 @@ var parserInitPromise = null;
 var languagePromiseByKind = {};
 var parserBundlePromiseByKind = {};
 async function buildForensicReport(targetInput) {
-  const target = normalizeTarget2(targetInput);
+  const target = normalizeTarget(targetInput);
   const framework = detectFramework(target);
   const topology = buildTopology(target);
   const entryPoints = collectEntryPoints(target, topology.files);
@@ -696,11 +308,11 @@ async function buildForensicReport(targetInput) {
   }
   return validation.data;
 }
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve6(process.cwd(), targetInput);
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
 }
 function buildTopology(root) {
-  assertExistingDirectory2(root);
+  assertExistingDirectory(root);
   const byExt = {};
   const keyDirs = /* @__PURE__ */ new Set();
   const files = [];
@@ -713,7 +325,7 @@ function buildTopology(root) {
       continue;
     }
     for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join5(current, entry.name);
+      const absolutePath = join(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -733,7 +345,7 @@ function buildTopology(root) {
       if (!entry.isFile()) {
         continue;
       }
-      const stats = statSync2(absolutePath);
+      const stats = statSync(absolutePath);
       const extension = extname(entry.name) || "[none]";
       byExt[extension] = (byExt[extension] ?? 0) + 1;
       totalFiles += 1;
@@ -751,8 +363,8 @@ function buildTopology(root) {
     files: files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
   };
 }
-function assertExistingDirectory2(target) {
-  if (!existsSync7(target) || !statSync2(target).isDirectory()) {
+function assertExistingDirectory(target) {
+  if (!existsSync2(target) || !statSync(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -801,7 +413,7 @@ function getEntryPointReason(relativePath) {
 async function buildCodeSamples(target, entryPoints, frameworkKind, topology, packageDependencies) {
   const samples = [];
   for (const entryPoint of entryPoints.slice(0, SAMPLE_LIMIT)) {
-    const absolutePath = join5(target, ...entryPoint.path.split("/"));
+    const absolutePath = join(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -838,8 +450,8 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join5(target, "package.json");
-  if (!existsSync7(packageJsonPath)) {
+  const packageJsonPath = join(target, "package.json");
+  if (!existsSync2(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
   try {
@@ -1179,9 +791,9 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join5(target, "README.md");
-  const hasContributing = existsSync7(join5(target, "CONTRIBUTING.md"));
-  if (!existsSync7(readmePath)) {
+  const readmePath = join(target, "README.md");
+  const hasContributing = existsSync2(join(target, "CONTRIBUTING.md"));
+  if (!existsSync2(readmePath)) {
     return {
       quality: "missing",
       line_count: 0,
@@ -1666,8 +1278,8 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join5(target, "package.json");
-  if (existsSync7(packageJsonPath)) {
+  const packageJsonPath = join(target, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
       if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
@@ -1680,7 +1292,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.1" : "unknown";
+  return true ? "2.0.0-rc.10" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1699,10 +1311,10 @@ 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 LOCAL_FABRIC_SERVER_PATH = join2("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 = defineCommand3({
+var initCommand = defineCommand2({
   meta: {
     name: "init",
     description: t("cli.init.description")
@@ -1806,10 +1418,47 @@ async function runInitCommand(args) {
     process.exitCode = 130;
     return;
   }
-  return executeInitExecutionPlan(plan);
+  const result = await executeInitExecutionPlan(plan);
+  if (!intent.options.planOnly) {
+    console.log(paint.muted("More: docs/surfaces.md explains when to use CLI vs Skill vs MCP."));
+  }
+  return result;
+}
+function writeDefaultFabricConfig(fabricDir) {
+  const target = join2(fabricDir, "fabric-config.json");
+  if (existsSync3(target)) return;
+  const FABRIC_CONFIG_DEFAULTS = {
+    // Scan/import language policy. `match-existing` lets init resolve the
+    // effective language from project content; explicit `zh-CN` / `en`
+    // lock the policy. See packages/shared/src/schemas/fabric-config.ts.
+    knowledge_language: "match-existing",
+    // 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
+  };
+  mkdirSync(fabricDir, { recursive: true });
+  writeFileSync(target, JSON.stringify(FABRIC_CONFIG_DEFAULTS, null, 2) + "\n", "utf8");
 }
 function resolveInitCliIntent(args, targetInput) {
-  const target = normalizeTarget3(targetInput);
+  const target = normalizeTarget2(targetInput);
   const mcpInstallMode = resolveMcpInstallMode(args["mcp-install"]);
   const claudeMcpScope = resolveClaudeMcpScope(args.scope);
   const terminalInteractive = isInteractiveInit();
@@ -1929,20 +1578,20 @@ async function executeInitExecutionPlan(plan) {
 }
 var KNOWLEDGE_SUBDIRS = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
 function resolvePersonalFabricRoot() {
-  return process.env.FABRIC_HOME ?? homedir5();
+  return process.env.FABRIC_HOME ?? homedir();
 }
 async function buildInitFabricPlan(target, options) {
-  assertExistingDirectory3(target);
-  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");
+  assertExistingDirectory2(target);
+  const fabricDir = join2(target, ".fabric");
+  const agentsMdPath = join2(target, "AGENTS.md");
+  const agentsMdAction = existsSync3(agentsMdPath) ? "preserved" : "created";
+  const knowledgeDir = join2(fabricDir, "knowledge");
+  const personalKnowledgeDir = join2(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const forensicPath = join2(fabricDir, "forensic.json");
+  const eventsPath = join2(fabricDir, "events.jsonl");
+  const metaPath = join2(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
-  const knowledgeDirAction = existsSync8(knowledgeDir) ? "overwritten" : "created";
+  const knowledgeDirAction = existsSync3(knowledgeDir) ? "overwritten" : "created";
   const metaAction = planFreshPath(metaPath, options);
   const eventsAction = planFreshPath(eventsPath, options);
   const forensicAction = planFreshPath(forensicPath, options);
@@ -1974,30 +1623,31 @@ async function executeInitFabricPlan(plan) {
     rmSync(plan.fabricDir, { force: true });
   }
   mkdirSync(plan.fabricDir, { recursive: true });
-  if (plan.agentsMdAction === "created" && !existsSync8(plan.agentsMdPath)) {
-    await atomicWriteText2(plan.agentsMdPath, AGENTS_MD_DEFAULT_CONTENT);
+  writeDefaultFabricConfig(plan.fabricDir);
+  if (plan.agentsMdAction === "created" && !existsSync3(plan.agentsMdPath)) {
+    await atomicWriteText(plan.agentsMdPath, AGENTS_MD_DEFAULT_CONTENT);
   }
   mkdirSync(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
-    const teamSubDir = join6(plan.knowledgeDir, sub);
+    const teamSubDir = join2(plan.knowledgeDir, sub);
     mkdirSync(teamSubDir, { recursive: true });
-    const teamGitkeep = join6(teamSubDir, ".gitkeep");
-    if (!existsSync8(teamGitkeep)) {
+    const teamGitkeep = join2(teamSubDir, ".gitkeep");
+    if (!existsSync3(teamGitkeep)) {
       writeFileSync(teamGitkeep, "", "utf8");
     }
   }
   try {
     mkdirSync(plan.personalKnowledgeDir, { recursive: true });
     for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync(join6(plan.personalKnowledgeDir, sub), { recursive: true });
+      mkdirSync(join2(plan.personalKnowledgeDir, sub), { recursive: true });
     }
   } catch {
   }
   preparePlannedPath(plan.metaPath, plan.metaAction);
-  await atomicWriteJson2(plan.metaPath, plan.meta);
+  await atomicWriteJson(plan.metaPath, plan.meta);
   if (isReapply) {
-    if (!existsSync8(plan.eventsPath)) {
-      mkdirSync(dirname3(plan.eventsPath), { recursive: true });
+    if (!existsSync3(plan.eventsPath)) {
+      mkdirSync(dirname(plan.eventsPath), { recursive: true });
       writeFileSync(plan.eventsPath, "", "utf8");
     }
   } else {
@@ -2005,7 +1655,7 @@ async function executeInitFabricPlan(plan) {
     writeFileSync(plan.eventsPath, "", "utf8");
   }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
-  await atomicWriteJson2(plan.forensicPath, plan.forensicReport);
+  await atomicWriteJson(plan.forensicPath, plan.forensicReport);
   if (!plan.options?.reapply) {
     try {
       await runInitScan(plan.target, { source: "init" });
@@ -2139,8 +1789,28 @@ async function executeInitStagePlan(plan, stageName) {
   try {
     switch (stage.name) {
       case "bootstrap": {
-        console.log(formatInitStageResult("bootstrap", "skipped", 0, 0, t("cli.bootstrap.install.no-targets")));
-        return { name: "bootstrap", disposition: "skipped" };
+        const installResults = [];
+        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 runBestEffortSingle("claude-hook-config", () => mergeClaudeCodeHookConfig(plan.target)));
+        installResults.push(await runBestEffortSingle("codex-hook-config", () => mergeCodexHookConfig(plan.target)));
+        installResults.push(await runBestEffortSingle("cursor-hook-config", () => mergeCursorHookConfig(plan.target)));
+        installResults.push(...await runBestEffort("pointer", () => addArchiveSkillPointer(plan.target)));
+        const 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"}`);
+          }
+        }
+        const note2 = errorCount > 0 ? `errors=${errorCount}` : void 0;
+        console.log(formatInitStageResult("bootstrap", "completed", installedCount, skippedCount, note2));
+        return { name: "bootstrap", disposition: "ran" };
       }
       case "mcp": {
         if (stage.installMode === "local") {
@@ -2178,10 +1848,10 @@ async function executeInitStagePlan(plan, stageName) {
   }
 }
 function shouldReplaceWritableDirectory(path, options) {
-  if (!existsSync8(path)) {
+  if (!existsSync3(path)) {
     return false;
   }
-  if (statSync3(path).isDirectory()) {
+  if (statSync2(path).isDirectory()) {
     return false;
   }
   if (!options?.force) {
@@ -2190,7 +1860,7 @@ function shouldReplaceWritableDirectory(path, options) {
   return true;
 }
 function planFreshPath(path, options) {
-  if (!existsSync8(path)) {
+  if (!existsSync3(path)) {
     return "created";
   }
   if (!options?.force) {
@@ -2199,8 +1869,8 @@ function planFreshPath(path, options) {
   return "overwritten";
 }
 function preparePlannedPath(path, action) {
-  mkdirSync(dirname3(path), { recursive: true });
-  if (action === "overwritten" && existsSync8(path)) {
+  mkdirSync(dirname(path), { recursive: true });
+  if (action === "overwritten" && existsSync3(path)) {
     rmSync(path, { recursive: true, force: true });
   }
 }
@@ -2375,23 +2045,23 @@ function formatInitModeBadge(options) {
   }
   return t("cli.init.mode.badge.default");
 }
-function normalizeTarget3(targetInput) {
-  return isAbsolute3(targetInput) ? targetInput : resolve7(process.cwd(), targetInput);
+function normalizeTarget2(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
 }
-function assertExistingDirectory3(target) {
-  if (!existsSync8(target) || !statSync3(target).isDirectory()) {
+function assertExistingDirectory2(target) {
+  if (!existsSync3(target) || !statSync2(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
 function detectPackageManager(cwd) {
-  const workspaceRoot = resolve7(cwd);
-  if (existsSync8(join6(workspaceRoot, "pnpm-lock.yaml"))) {
+  const workspaceRoot = resolve3(cwd);
+  if (existsSync3(join2(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync8(join6(workspaceRoot, "yarn.lock"))) {
+  if (existsSync3(join2(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync8(join6(workspaceRoot, "package-lock.json"))) {
+  if (existsSync3(join2(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";
@@ -2431,6 +2101,32 @@ function appendReapplyLedgerEvent(eventsPath, payload) {
 `;
   appendFileSync(eventsPath, line, "utf8");
 }
+async function runBestEffort(step, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return [
+      {
+        step,
+        path: "",
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      }
+    ];
+  }
+}
+async function runBestEffortSingle(step, fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return {
+      step,
+      path: "",
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function formatInitStageHeader(message) {
   return `${nextLabel()} ${paint.muted(message)}`;
 }
@@ -2485,6 +2181,7 @@ function printInitPlanSummary(target, options, mcpInstallMode, supports) {
   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);