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

package/dist/{init-DRHUYHYA.js → init-55WZSUK6.js}

@@ -1,172 +1,77 @@
 #!/usr/bin/env node
+import {
+  ClaudeCodeCLIWriter,
+  CursorWriter,
+  addArchiveSkillPointer,
+  createServerEntry,
+  hooksCommand,
+  installArchiveHintHook,
+  installFabricArchiveSkill,
+  installFabricImportSkill,
+  installFabricReviewSkill,
+  installHooks,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  mergeCursorHookConfig,
+  normalizeConfigPath,
+  writeJsonClientConfig
+} from "./chunk-74SZWYPH.js";
 import {
   detectFramework,
   runInitScan
-} from "./chunk-UHNP7T7W.js";
+} from "./chunk-EYIDD2YS.js";
 import {
-  createDebugLogger,
   displayWidth,
   padEnd,
-  paint,
-  resolveDevMode,
+  paint
+} from "./chunk-WWNXR34K.js";
+import {
   t
-} from "./chunk-5LOYBXWD.js";
+} from "./chunk-6ICJICVU.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-OBQU6NHO.js";
 
 // src/commands/init.ts
 import { randomUUID } from "crypto";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir4 } 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 existsSync6, mkdirSync, rmSync, statSync as statSync2, writeFileSync } from "fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join5, resolve as resolve5 } from "path";
 import { 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 as atomicWriteText2 } from "@fenglimg/fabric-shared/node/atomic-write";
+import { defineCommand as defineCommand2 } from "citty";
 import { checkLockOrThrow } from "@fenglimg/fabric-server";
 
 // src/commands/config.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile3 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
-import { defineCommand as defineCommand2 } from "citty";
+import { defineCommand } from "citty";
 
 // src/config/resolver.ts
-import { existsSync as existsSync4 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
 
 // src/config/claude-code.ts
-import { existsSync 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
+import { join, resolve } from "path";
+import { homedir, platform } from "os";
 function getClaudeDesktopConfigPath() {
   const os = platform();
   if (os === "darwin") {
-    return join2(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join(homedir(), "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 join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
   }
-  return join2(homedir2(), ".config", "Claude", "claude_desktop_config.json");
+  return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
 }
 var ClaudeCodeDesktopWriter = class {
   clientKind = "ClaudeCodeDesktop";
@@ -176,7 +81,7 @@ var ClaudeCodeDesktopWriter = class {
   }
   async detect(_workspaceRoot, overridePath) {
     const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
-    return existsSync2(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
+    return existsSync(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
   }
   async write(serverPath, workspaceRoot, overridePath) {
     const configPath = await this.detect(workspaceRoot, overridePath);
@@ -191,17 +96,17 @@ var ClaudeCodeDesktopWriter = class {
 };
 
 // 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 { existsSync as existsSync2 } from "fs";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2 } from "os";
 import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-function expandHome2(filePath) {
+function expandHome(filePath) {
   if (filePath === "~") {
-    return homedir3();
+    return homedir2();
   }
   if (filePath.startsWith("~/")) {
-    return join3(homedir3(), filePath.slice(2));
+    return join2(homedir2(), filePath.slice(2));
   }
   return filePath;
 }
@@ -250,7 +155,7 @@ ${block}`;
 }
 async function readTomlConfigText(configPath) {
   try {
-    return await readFile2(configPath, "utf8");
+    return await readFile(configPath, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return "";
@@ -267,10 +172,10 @@ var CodexTOMLConfigWriter = class {
   async detect(_workspaceRoot, overridePath) {
     const explicitPath = overridePath ?? this.configuredPath;
     if (explicitPath !== void 0) {
-      return resolve3(expandHome2(explicitPath));
+      return resolve2(expandHome(explicitPath));
     }
-    const codexDir = join3(homedir3(), ".codex");
-    return existsSync3(codexDir) ? resolve3(join3(codexDir, "config.toml")) : null;
+    const codexDir = join2(homedir2(), ".codex");
+    return existsSync2(codexDir) ? resolve2(join2(codexDir, "config.toml")) : null;
   }
   async write(serverPath, workspaceRoot, overridePath) {
     const configPath = await this.detect(workspaceRoot, overridePath);
@@ -279,7 +184,7 @@ var CodexTOMLConfigWriter = class {
     }
     const rawConfig = await readTomlConfigText(configPath);
     const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
-    await mkdir2(dirname2(configPath), { recursive: true });
+    await mkdir(dirname(configPath), { recursive: true });
     await atomicWriteText(configPath, nextConfig);
   }
 };
@@ -300,25 +205,25 @@ function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
   const claudeMcpScope = opts.claudeMcpScope ?? "project";
   addIfDetected(
     writers,
-    existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude")),
+    existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude")),
     (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
     hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
   );
   addIfDetected(
     writers,
-    existsSync4(getClaudeDesktopConfigPath()),
+    existsSync3(getClaudeDesktopConfigPath()),
     (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
     hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
   );
   addIfDetected(
     writers,
-    existsSync4(join4(workspaceRoot, ".cursor")),
+    existsSync3(join3(workspaceRoot, ".cursor")),
     (configuredPath) => new CursorWriter(configuredPath),
     hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
   );
   addIfDetected(
     writers,
-    existsSync4(join4(homedir4(), ".codex")),
+    existsSync3(join3(homedir3(), ".codex")),
     (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
     hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
   );
@@ -326,10 +231,10 @@ function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
 }
 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"));
+  const claudeDetected = existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude"));
+  const claudeDesktopDetected = existsSync3(getClaudeDesktopConfigPath());
+  const cursorDetected = existsSync3(join3(workspaceRoot, ".cursor"));
+  const codexDetected = existsSync3(join3(homedir3(), ".codex"));
   return [
     {
       clientKind: "ClaudeCodeCLI",
@@ -387,7 +292,7 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
         skill: true
       },
       installedCapabilities: {
-        hook: existsSync4(join4(workspaceRoot, ".codex", "hooks.json")),
+        hook: existsSync3(join3(workspaceRoot, ".codex", "hooks.json")),
         // v2/rc.2: v1 client-side init skill removed; skill-installation probes
         // will return once rc.2/3/4 introduce the v2 skills (fabric-archive,
         // fabric-review, fabric-import). Until then there is nothing to probe.
@@ -397,50 +302,6 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
   ];
 }
 
-// src/commands/hooks.ts
-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: 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",
@@ -471,11 +332,11 @@ function parseClientFilter(value) {
   return clients;
 }
 async function loadFabricConfig(workspaceRoot) {
-  const configPath = resolve5(workspaceRoot, "fabric.config.json");
-  if (!existsSync6(configPath)) {
+  const configPath = resolve3(workspaceRoot, "fabric.config.json");
+  if (!existsSync4(configPath)) {
     return {};
   }
-  const parsed = JSON.parse(await readFile3(configPath, "utf8"));
+  const parsed = JSON.parse(await readFile2(configPath, "utf8"));
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(t("cli.config.errors.expected-object", { path: configPath }));
   }
@@ -483,21 +344,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 resolve3(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 +402,7 @@ var configCmd = defineCommand2({
   }
 });
 async function installMcpClients(target, options = {}) {
-  const workspaceRoot = resolve5(target);
+  const workspaceRoot = resolve3(target);
   const fabricConfig = await loadFabricConfig(workspaceRoot);
   const selectedClients = options.clients === void 0 ? null : new Set(options.clients);
   const serverPath = resolveServerPath(options.localServerPath);
@@ -572,9 +433,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 existsSync5, 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 as join4, posix, relative, resolve as resolve4, sep } from "path";
 import {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
@@ -660,7 +521,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 +557,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 : resolve4(process.cwd(), targetInput);
 }
 function buildTopology(root) {
-  assertExistingDirectory2(root);
+  assertExistingDirectory(root);
   const byExt = {};
   const keyDirs = /* @__PURE__ */ new Set();
   const files = [];
@@ -713,7 +574,7 @@ function buildTopology(root) {
       continue;
     }
     for (const entry of readdirSync(current, { withFileTypes: true })) {
-      const absolutePath = join5(current, entry.name);
+      const absolutePath = join4(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -733,7 +594,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 +612,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 (!existsSync5(target) || !statSync(target).isDirectory()) {
     throw new Error(`Target must be an existing directory: ${target}`);
   }
 }
@@ -801,7 +662,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 = join4(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -838,8 +699,8 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join5(target, "package.json");
-  if (!existsSync7(packageJsonPath)) {
+  const packageJsonPath = join4(target, "package.json");
+  if (!existsSync5(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
   try {
@@ -1179,9 +1040,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 = join4(target, "README.md");
+  const hasContributing = existsSync5(join4(target, "CONTRIBUTING.md"));
+  if (!existsSync5(readmePath)) {
     return {
       quality: "missing",
       line_count: 0,
@@ -1666,8 +1527,8 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 function readProjectName(target) {
-  const packageJsonPath = join5(target, "package.json");
-  if (existsSync7(packageJsonPath)) {
+  const packageJsonPath = join4(target, "package.json");
+  if (existsSync5(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
       if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
@@ -1680,7 +1541,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.0-rc.1" : "unknown";
+  return true ? "2.0.0-rc.8" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1699,10 +1560,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 = join5("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 +1667,44 @@ async function runInitCommand(args) {
     process.exitCode = 130;
     return;
   }
-  return executeInitExecutionPlan(plan);
+  const result = await executeInitExecutionPlan(plan);
+  try {
+    await maybeWriteImportSentinel({
+      target: intent.target,
+      planOnly: intent.options.planOnly === true,
+      wizardEnabled: intent.wizardEnabled,
+      terminalInteractive: intent.interactiveSummary
+    });
+  } catch {
+  }
+  if (!intent.options.planOnly) {
+    console.log(paint.muted("More: docs/surfaces.md explains when to use CLI vs Skill vs MCP."));
+  }
+  return result;
+}
+async function maybeWriteImportSentinel(opts) {
+  if (opts.planOnly) return;
+  if (process.env.FABRIC_NONINTERACTIVE === "1") return;
+  if (!opts.wizardEnabled || !opts.terminalInteractive) return;
+  if (!Boolean(process.stdin.isTTY)) return;
+  const answer = await confirm({
+    message: "\u4E0B\u6B21\u5F00 AI \u65F6\u8BA9\u6211\u4ECE git log \u62BD\u66F4\u591A\u77E5\u8BC6\u5417?",
+    initialValue: true
+  });
+  if (isCancel(answer) || answer !== true) return;
+  const fabricDir = join5(opts.target, ".fabric");
+  const sentinelPath = join5(fabricDir, ".import-requested");
+  try {
+    if (!existsSync6(fabricDir)) {
+      mkdirSync(fabricDir, { recursive: true });
+    }
+    writeFileSync(sentinelPath, "", "utf8");
+    log.success("\u4E0B\u6B21\u5F00 AI \u4F1A\u770B\u5230\u63D0\u793A");
+  } catch {
+  }
 }
 function 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 +1824,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 ?? homedir4();
 }
 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 = join5(target, ".fabric");
+  const agentsMdPath = join5(target, "AGENTS.md");
+  const agentsMdAction = existsSync6(agentsMdPath) ? "preserved" : "created";
+  const knowledgeDir = join5(fabricDir, "knowledge");
+  const personalKnowledgeDir = join5(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const forensicPath = join5(fabricDir, "forensic.json");
+  const eventsPath = join5(fabricDir, "events.jsonl");
+  const metaPath = join5(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
-  const knowledgeDirAction = existsSync8(knowledgeDir) ? "overwritten" : "created";
+  const knowledgeDirAction = existsSync6(knowledgeDir) ? "overwritten" : "created";
   const metaAction = planFreshPath(metaPath, options);
   const eventsAction = planFreshPath(eventsPath, options);
   const forensicAction = planFreshPath(forensicPath, options);
@@ -1974,30 +1869,30 @@ async function executeInitFabricPlan(plan) {
     rmSync(plan.fabricDir, { force: true });
   }
   mkdirSync(plan.fabricDir, { recursive: true });
-  if (plan.agentsMdAction === "created" && !existsSync8(plan.agentsMdPath)) {
+  if (plan.agentsMdAction === "created" && !existsSync6(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);
+    const teamSubDir = join5(plan.knowledgeDir, sub);
     mkdirSync(teamSubDir, { recursive: true });
-    const teamGitkeep = join6(teamSubDir, ".gitkeep");
-    if (!existsSync8(teamGitkeep)) {
+    const teamGitkeep = join5(teamSubDir, ".gitkeep");
+    if (!existsSync6(teamGitkeep)) {
       writeFileSync(teamGitkeep, "", "utf8");
     }
   }
   try {
     mkdirSync(plan.personalKnowledgeDir, { recursive: true });
     for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync(join6(plan.personalKnowledgeDir, sub), { recursive: true });
+      mkdirSync(join5(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 (!existsSync6(plan.eventsPath)) {
+      mkdirSync(dirname2(plan.eventsPath), { recursive: true });
       writeFileSync(plan.eventsPath, "", "utf8");
     }
   } else {
@@ -2005,7 +1900,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 +2034,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 +2093,10 @@ async function executeInitStagePlan(plan, stageName) {
   }
 }
 function shouldReplaceWritableDirectory(path, options) {
-  if (!existsSync8(path)) {
+  if (!existsSync6(path)) {
     return false;
   }
-  if (statSync3(path).isDirectory()) {
+  if (statSync2(path).isDirectory()) {
     return false;
   }
   if (!options?.force) {
@@ -2190,7 +2105,7 @@ function shouldReplaceWritableDirectory(path, options) {
   return true;
 }
 function planFreshPath(path, options) {
-  if (!existsSync8(path)) {
+  if (!existsSync6(path)) {
     return "created";
   }
   if (!options?.force) {
@@ -2199,8 +2114,8 @@ function planFreshPath(path, options) {
   return "overwritten";
 }
 function preparePlannedPath(path, action) {
-  mkdirSync(dirname3(path), { recursive: true });
-  if (action === "overwritten" && existsSync8(path)) {
+  mkdirSync(dirname2(path), { recursive: true });
+  if (action === "overwritten" && existsSync6(path)) {
     rmSync(path, { recursive: true, force: true });
   }
 }
@@ -2375,23 +2290,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 : resolve5(process.cwd(), targetInput);
 }
-function assertExistingDirectory3(target) {
-  if (!existsSync8(target) || !statSync3(target).isDirectory()) {
+function assertExistingDirectory2(target) {
+  if (!existsSync6(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 = resolve5(cwd);
+  if (existsSync6(join5(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync8(join6(workspaceRoot, "yarn.lock"))) {
+  if (existsSync6(join5(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync8(join6(workspaceRoot, "package-lock.json"))) {
+  if (existsSync6(join5(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";
@@ -2431,6 +2346,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)}`;
 }