@fenglimg/fabric-cli 2.2.0-rc.1 → 2.2.0-rc.11

package/dist/install-74ANPCCP.js

@@ -1,2737 +0,0 @@
-#!/usr/bin/env node
-import {
-  cleanupDeprecatedSkills,
-  installArchiveHintHook,
-  installCitePolicyEvictHook,
-  installFabricArchiveSkill,
-  installFabricAuditSkill,
-  installFabricConnectSkill,
-  installFabricImportSkill,
-  installFabricReviewSkill,
-  installFabricStoreSkill,
-  installFabricSyncSkill,
-  installHookLibs,
-  installKnowledgeHintBroadHook,
-  installKnowledgeHintNarrowHook,
-  installSharedSkillLib,
-  mergeClaudeCodeHookConfig,
-  mergeCodexHookConfig,
-  mergeCursorHookConfig,
-  readFabricLanguagePreference,
-  writeClaudeBootstrapThinShell,
-  writeCodexBootstrapManagedBlock,
-  writeCursorBootstrapManagedBlock,
-  writeFabricAgentsSnapshot
-} from "./chunk-2R55HNVD.js";
-import {
-  displayWidth,
-  padEnd,
-  paint
-} from "./chunk-BO4XIZWZ.js";
-import {
-  createDebugLogger,
-  resolveDevMode
-} from "./chunk-COI5VDFU.js";
-import {
-  installMcpClients
-} from "./chunk-AOE6AYI7.js";
-import {
-  detectClientSupports
-} from "./chunk-XC5RUHLK.js";
-import {
-  getProjectTranslator,
-  t
-} from "./chunk-2CY4BMTH.js";
-import {
-  globalConfigPath,
-  loadGlobalConfig,
-  resolveGlobalRoot,
-  saveGlobalConfig
-} from "./chunk-RYAFBNES.js";
-
-// src/commands/install.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { homedir } from "os";
-import * as childProcess from "child_process";
-import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync4, writeFileSync } from "fs";
-import { dirname, isAbsolute as isAbsolute3, join as join6, resolve as resolve3 } from "path";
-import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
-import { defaultAgentsMetaCounters } from "@fenglimg/fabric-shared";
-import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
-import { defineCommand } from "citty";
-
-// src/install/hooks-orchestrator.ts
-import { existsSync, statSync } from "fs";
-import { isAbsolute, join, resolve } from "path";
-async function installHooks(target, _options = {}) {
-  const normalizedTarget = normalizeTarget(target);
-  assertExistingDirectory(normalizedTarget);
-  const results = [];
-  results.push(...await runStep(() => installFabricArchiveSkill(normalizedTarget)));
-  results.push(...await runStep(() => installFabricReviewSkill(normalizedTarget)));
-  results.push(...await runStep(() => installFabricImportSkill(normalizedTarget)));
-  results.push(...await runStep(() => installFabricSyncSkill(normalizedTarget)));
-  results.push(...await runStep(() => installFabricStoreSkill(normalizedTarget)));
-  results.push(...await runStep(() => installFabricAuditSkill(normalizedTarget)));
-  results.push(...await runStep(() => installFabricConnectSkill(normalizedTarget)));
-  results.push(...await runStep(() => installSharedSkillLib(normalizedTarget)));
-  results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
-  results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
-  results.push(...await runStep(() => installKnowledgeHintNarrowHook(normalizedTarget)));
-  results.push(...await runStep(() => installCitePolicyEvictHook(normalizedTarget)));
-  results.push(...await runStep(() => installHookLibs(normalizedTarget)));
-  results.push(await runSingleStep("claude-hook-config", () => mergeClaudeCodeHookConfig(normalizedTarget)));
-  results.push(await runSingleStep("codex-hook-config", () => mergeCodexHookConfig(normalizedTarget)));
-  results.push(await runSingleStep("cursor-hook-config", () => mergeCursorHookConfig(normalizedTarget)));
-  results.push(await runSingleStep("bootstrap-snapshot", () => writeFabricAgentsSnapshot(normalizedTarget)));
-  results.push(await runSingleStep("bootstrap-claude", () => writeClaudeBootstrapThinShell(normalizedTarget)));
-  results.push(await runSingleStep("bootstrap-codex", () => writeCodexBootstrapManagedBlock(normalizedTarget)));
-  results.push(await runSingleStep("bootstrap-cursor", () => writeCursorBootstrapManagedBlock(normalizedTarget)));
-  results.push(...validateHookPaths(normalizedTarget));
-  return summarizeResults(results);
-}
-function validateHookPaths(projectRoot) {
-  const scripts = [
-    { stepSuffix: "", hookFile: "fabric-hint.cjs" },
-    { stepSuffix: "-broad", hookFile: "knowledge-hint-broad.cjs" },
-    { stepSuffix: "-narrow", hookFile: "knowledge-hint-narrow.cjs" }
-  ];
-  const clients = [
-    {
-      client: "claude",
-      configRel: join(".claude", "settings.json"),
-      hookDir: join(".claude", "hooks")
-    },
-    {
-      client: "codex",
-      configRel: join(".codex", "hooks.json"),
-      hookDir: join(".codex", "hooks")
-    },
-    {
-      client: "cursor",
-      configRel: join(".cursor", "hooks.json"),
-      hookDir: join(".cursor", "hooks")
-    }
-  ];
-  const results = [];
-  for (const { client, configRel, hookDir } of clients) {
-    const configPath = resolve(projectRoot, configRel);
-    if (!existsSync(configPath)) {
-      results.push({
-        step: `hook-validate-${client}`,
-        path: configPath,
-        status: "skipped",
-        message: "missing-config"
-      });
-      continue;
-    }
-    for (const { stepSuffix, hookFile } of scripts) {
-      const expectedHookPath = resolve(projectRoot, hookDir, hookFile);
-      const expectedHookRel = join(hookDir, hookFile);
-      const step = `hook-validate-${client}${stepSuffix}`;
-      if (!existsSync(expectedHookPath)) {
-        results.push({
-          step,
-          path: expectedHookPath,
-          status: "error",
-          message: `hook script missing: ${expectedHookRel}`
-        });
-        continue;
-      }
-      results.push({ step, path: expectedHookPath, status: "skipped", message: "ok" });
-    }
-  }
-  return results;
-}
-async function runStep(fn) {
-  try {
-    return await fn();
-  } catch (error) {
-    return [
-      {
-        step: "hook-install",
-        path: "",
-        status: "error",
-        message: error instanceof Error ? error.message : String(error)
-      }
-    ];
-  }
-}
-async function runSingleStep(step, fn) {
-  try {
-    return await fn();
-  } catch (error) {
-    return {
-      step,
-      path: "",
-      status: "error",
-      message: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function summarizeResults(results) {
-  const installed = [];
-  const skipped = [];
-  const errors = [];
-  for (const r of results) {
-    switch (r.status) {
-      case "written":
-        installed.push(r.path);
-        break;
-      case "skipped":
-        skipped.push(r.path);
-        break;
-      case "error":
-        errors.push(`${r.step} ${r.path}: ${r.message ?? "unknown error"}`);
-        break;
-    }
-  }
-  return { installed, skipped, errors };
-}
-function normalizeTarget(targetInput) {
-  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
-}
-function assertExistingDirectory(target) {
-  if (!existsSync(target) || !statSync(target).isDirectory()) {
-    throw new Error(t("cli.shared.target-invalid", { target }));
-  }
-}
-
-// src/install/run-global-install.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { randomUUID } from "crypto";
-import { mkdirSync, mkdtempSync, renameSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3 } from "path";
-import { STORES_ROOT_DIR as STORES_ROOT_DIR2, addMountedStore, readStoreIdentity } from "@fenglimg/fabric-shared";
-import { GenericIOError } from "@fenglimg/fabric-shared/errors";
-
-// src/store/uid.ts
-import { execFileSync } from "child_process";
-import { createHash } from "crypto";
-function deriveUid(opts = {}) {
-  let email = "";
-  try {
-    email = execFileSync("git", ["config", "user.email"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-  } catch {
-    email = "";
-  }
-  if (email === "") {
-    return "u-anon";
-  }
-  const material = opts.salt !== void 0 && opts.salt.length > 0 ? `${opts.salt}:${email.toLowerCase()}` : email.toLowerCase();
-  const hash = createHash("sha256").update(material).digest("hex").slice(0, 12);
-  return `u-${hash}`;
-}
-
-// src/install/install-global.ts
-import { rmSync } from "fs";
-import { join as join2 } from "path";
-import {
-  STORES_ROOT_DIR,
-  globalConfigSchema,
-  initStore
-} from "@fenglimg/fabric-shared";
-
-// src/install/transaction.ts
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-async function runInstallTransaction(steps) {
-  const receipt = { ok: true, steps: [] };
-  const applied = [];
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    try {
-      await step.apply();
-      applied.push(step);
-      receipt.steps.push({ name: step.name, status: "applied" });
-    } catch (error) {
-      receipt.ok = false;
-      receipt.failedStep = step.name;
-      receipt.error = errorMessage(error);
-      receipt.steps.push({ name: step.name, status: "failed", error: errorMessage(error) });
-      for (let j = i + 1; j < steps.length; j++) {
-        receipt.steps.push({ name: steps[j].name, status: "skipped" });
-      }
-      for (const done of [...applied].reverse()) {
-        const entry = receipt.steps.find((s) => s.name === done.name);
-        try {
-          await done.rollback();
-          if (entry !== void 0) {
-            entry.status = "rolled_back";
-          }
-        } catch (rollbackError) {
-          if (entry !== void 0) {
-            entry.status = "rollback_failed";
-            entry.error = errorMessage(rollbackError);
-          }
-        }
-      }
-      return receipt;
-    }
-  }
-  return receipt;
-}
-
-// src/install/install-global.ts
-async function installGlobalCore(options) {
-  const existing = loadGlobalConfig(options.globalRoot);
-  if (existing !== null) {
-    return {
-      receipt: { ok: true, steps: [{ name: "already-installed", status: "applied" }] },
-      config: existing,
-      alreadyInstalled: true
-    };
-  }
-  const alias = options.personalAlias ?? "personal";
-  const personalDir = join2(options.globalRoot, STORES_ROOT_DIR, options.personalStoreUuid);
-  let config = null;
-  const receipt = await runInstallTransaction([
-    {
-      name: "init-personal-store",
-      apply: () => {
-        initStore(
-          personalDir,
-          {
-            store_uuid: options.personalStoreUuid,
-            created_at: options.now,
-            canonical_alias: alias
-          },
-          { git: options.git }
-        );
-      },
-      rollback: () => {
-        rmSync(personalDir, { recursive: true, force: true });
-      }
-    },
-    {
-      name: "write-global-config",
-      apply: () => {
-        const next = globalConfigSchema.parse({
-          uid: options.uid,
-          stores: [{ store_uuid: options.personalStoreUuid, alias, personal: true }]
-        });
-        saveGlobalConfig(next, options.globalRoot);
-        config = next;
-      },
-      rollback: () => {
-        rmSync(globalConfigPath(options.globalRoot), { force: true });
-      }
-    }
-  ]);
-  return { receipt, config, alreadyInstalled: false };
-}
-
-// src/install/run-global-install.ts
-function gitClone(url, dest) {
-  console.log(`cloning store from ${url} (this may take a while)\u2026`);
-  try {
-    execFileSync2("git", ["clone", "--", url, dest], { stdio: ["ignore", "ignore", "inherit"] });
-  } catch (error) {
-    throw new GenericIOError(`git clone of ${url} failed`, {
-      actionHint: "check the url is reachable and points to a Fabric store git repo (the git error above shows the cause), then re-run `fabric install --global <url>`",
-      details: error
-    });
-  }
-}
-function mountStoreFromRemote(url, globalRoot) {
-  const storesRoot = join3(globalRoot, STORES_ROOT_DIR2);
-  mkdirSync(storesRoot, { recursive: true });
-  const tmp = mkdtempSync(join3(tmpdir(), "fabric-clone-"));
-  const cloneDest = join3(tmp, "store");
-  gitClone(url, cloneDest);
-  const identity = readStoreIdentity(cloneDest);
-  if (identity === null) {
-    throw new GenericIOError(`cloned store at ${url} has no valid store.json (not a Fabric store)`, {
-      actionHint: "verify the url points to a repository created by `fabric` (it must contain a store.json at its root); if you meant to mount a different store, re-run with the correct url"
-    });
-  }
-  const finalDir = join3(storesRoot, identity.store_uuid);
-  renameSync(cloneDest, finalDir);
-  const config = loadGlobalConfig(globalRoot);
-  if (config === null) {
-    throw new GenericIOError("global config missing after install", {
-      actionHint: "re-run `fabric install --global` to (re)create the global config, then retry mounting the store; if it persists, inspect ~/.fabric for a partial install"
-    });
-  }
-  const alias = identity.canonical_alias ?? "team";
-  saveGlobalConfig(
-    addMountedStore(config, { store_uuid: identity.store_uuid, alias, remote: url }),
-    globalRoot
-  );
-  console.log(`mounted store '${alias}' (${identity.store_uuid}) from ${url}`);
-}
-async function runGlobalInstall(options = {}, globalRoot = resolveGlobalRoot()) {
-  const uid = options.uid ?? deriveUid();
-  const personalStoreUuid = options.personalStoreUuid ?? randomUUID();
-  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
-  const result = await installGlobalCore({ globalRoot, uid, personalStoreUuid, now });
-  if (!result.receipt.ok) {
-    throw new GenericIOError(
-      `global install failed at step '${result.receipt.failedStep}': ${result.receipt.error}`,
-      {
-        actionHint: "check write permissions and free space under ~/.fabric, then re-run `fabric install --global` (the install is transactional and rolls back partial state)"
-      }
-    );
-  }
-  console.log(
-    result.alreadyInstalled ? "global Fabric already installed" : `installed global Fabric (uid ${uid})`
-  );
-  if (options.url !== void 0) {
-    mountStoreFromRemote(options.url, globalRoot);
-  }
-}
-
-// src/lib/detect-language.ts
-import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
-function detectExistingLanguage(target) {
-  const ZH_CN_RATIO_THRESHOLD = 0.3;
-  const samples = [];
-  const readmePath = join4(target, "README.md");
-  if (existsSync2(readmePath)) {
-    try {
-      samples.push(readFileSync(readmePath, "utf8"));
-    } catch {
-    }
-  }
-  const docsDir = join4(target, "docs");
-  if (existsSync2(docsDir)) {
-    try {
-      const stat = statSync2(docsDir);
-      if (stat.isDirectory()) {
-        for (const entry of readdirSync(docsDir, { withFileTypes: true })) {
-          if (!entry.isFile()) continue;
-          if (!/\.(md|mdx|txt)$/iu.test(entry.name)) continue;
-          try {
-            samples.push(readFileSync(join4(docsDir, entry.name), "utf8"));
-          } catch {
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  if (samples.length === 0) {
-    return "en";
-  }
-  let cjkCount = 0;
-  let asciiLetterCount = 0;
-  for (const sample of samples) {
-    for (const ch of sample) {
-      const code = ch.codePointAt(0) ?? 0;
-      if (code >= 19968 && code <= 40959) {
-        cjkCount += 1;
-      } else if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
-        asciiLetterCount += 1;
-      }
-    }
-  }
-  const denominator = cjkCount + asciiLetterCount;
-  if (denominator === 0) {
-    return "en";
-  }
-  const ratio = cjkCount / denominator;
-  return ratio > ZH_CN_RATIO_THRESHOLD ? "zh-CN-hybrid" : "en";
-}
-
-// src/scanner/forensic.ts
-import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
-import { createRequire } from "module";
-import { basename, extname, isAbsolute as isAbsolute2, join as join5, posix, relative, resolve as resolve2, sep } from "path";
-import {
-  buildScanRecommendations,
-  forensicReportSchema
-} from "@fenglimg/fabric-shared";
-
-// src/scanner/detector.ts
-import { detectFramework } from "@fenglimg/fabric-shared/node";
-
-// src/scanner/forensic.ts
-var require2 = createRequire(import.meta.url);
-var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
-  ".fabric",
-  ".git",
-  ".next",
-  ".turbo",
-  "Library",
-  "Temp",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules"
-]);
-var KEY_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
-  "app",
-  "components",
-  "pages",
-  "prefabs",
-  "scenes",
-  "scripts",
-  "src"
-]);
-var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
-var DOMAIN_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".json", ".md"]);
-var EXPECTED_CONFIG_FILES_BY_FRAMEWORK = {
-  "cocos-creator": ["package.json", "project.config.json", "tsconfig.json"],
-  react: ["package.json", "tsconfig.json"],
-  next: ["package.json", "tsconfig.json"],
-  vite: ["package.json", "tsconfig.json"]
-};
-var FRAMEWORK_IMPORT_PROFILES = {
-  "cocos-creator": {
-    pattern: "cocos-component-class",
-    family: "component",
-    statement: "Sampled entry files use Cocos Creator component classes.",
-    proposedRule: "Treat assets/scripts/*.ts and adjacent .meta files as framework-owned structure unless the user says otherwise.",
-    alternatives: ["Generic TypeScript utility module"],
-    rationale: "Cocos framework imports and component markers co-occur in sampled entry files.",
-    packages: ["cc"]
-  },
-  react: {
-    pattern: "react-root",
-    family: "entry",
-    statement: "Sampled entry files import React framework packages.",
-    proposedRule: "Keep root rendering and component composition aligned with React entry conventions.",
-    alternatives: ["Server-rendered route module"],
-    rationale: "AST import declarations reference React packages rather than comments or strings.",
-    packages: ["react", "react-dom", "react/jsx-runtime", "react-dom/client"]
-  },
-  vite: {
-    pattern: "vite-main-entry",
-    family: "entry",
-    statement: "Sampled entry files use the conventional Vite main entrypoint.",
-    proposedRule: "Keep primary bootstrapping logic inside src/main.*.",
-    alternatives: ["Alternative bundler entrypoint"],
-    rationale: "Entry path and framework imports align with a Vite bootstrap surface.",
-    packages: ["@vitejs/plugin-react", "@vitejs/plugin-vue", "vite", "react", "vue"]
-  },
-  next: {
-    pattern: "next-route-component",
-    family: "entry",
-    statement: "Sampled entry files align with Next.js route modules.",
-    proposedRule: "Preserve route-segment boundaries when editing app/ or pages/ files.",
-    alternatives: ["Generic source module"],
-    rationale: "Route placement and Next/React imports anchor these files to the request surface.",
-    packages: ["next", "next/link", "next/navigation", "react"]
-  }
-};
-var SAMPLE_LIMIT = 5;
-var SAMPLE_LINE_LIMIT = 30;
-var ENTRY_FAMILY_LIMIT = 1;
-var FAMILY_LIMIT = 3;
-var CANDIDATE_FILE_LIMIT = 12;
-var DEFAULT_SAMPLING_BUDGET = {
-  max_files: 15,
-  max_lines_per_file: 100
-};
-var treeSitterModulePromise = null;
-var parserInitPromise = null;
-var languagePromiseByKind = {};
-var parserBundlePromiseByKind = {};
-async function buildForensicReport(targetInput) {
-  const target = normalizeTarget2(targetInput);
-  const framework = detectFramework(target);
-  const topology = buildTopology(target);
-  const entryPoints = collectEntryPoints(target, topology.files);
-  const packageDependencies = readPackageDependencies(target);
-  const codeSamples = await buildCodeSamples(target, entryPoints, framework.kind, topology, packageDependencies);
-  const assertions = buildAssertions(framework.kind, topology, codeSamples);
-  const candidateFiles = buildCandidateFiles(topology, codeSamples, entryPoints);
-  const readme = readReadmeInfo(target);
-  const report = {
-    version: "1.0",
-    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
-    generated_by: `fabric-cli@${getCliVersion()}`,
-    target,
-    project_name: readProjectName(target),
-    framework,
-    topology: {
-      total_files: topology.total_files,
-      by_ext: topology.by_ext,
-      key_dirs: topology.key_dirs,
-      max_depth: topology.max_depth
-    },
-    entry_points: entryPoints,
-    code_samples: codeSamples.map(({ pattern_analysis: _patternAnalysis, evidence: _evidence, ...sample }) => sample),
-    assertions,
-    candidate_files: candidateFiles,
-    sampling_budget: DEFAULT_SAMPLING_BUDGET,
-    readme,
-    recommendations_for_skill: buildSkillRecommendations(framework.kind, topology, readme, target)
-  };
-  const validation = forensicReportSchema.safeParse(report);
-  if (!validation.success) {
-    throw new Error(`ForensicReport schema validation failed: ${validation.error.message}`);
-  }
-  return validation.data;
-}
-function normalizeTarget2(targetInput) {
-  return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
-}
-function buildTopology(root) {
-  assertExistingDirectory2(root);
-  const byExt = {};
-  const keyDirs = /* @__PURE__ */ new Set();
-  const files = [];
-  let totalFiles = 0;
-  let maxDepth = 0;
-  const stack = [root];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === void 0) {
-      continue;
-    }
-    for (const entry of readdirSync2(current, { withFileTypes: true })) {
-      const absolutePath = join5(current, entry.name);
-      const relativePath = toPosixPath(relative(root, absolutePath));
-      if (relativePath.length === 0) {
-        continue;
-      }
-      const depth = relativePath.split("/").length;
-      maxDepth = Math.max(maxDepth, depth);
-      if (entry.isDirectory()) {
-        if (IGNORED_DIRECTORIES.has(entry.name)) {
-          continue;
-        }
-        if (isKeyDirectory(relativePath)) {
-          keyDirs.add(relativePath);
-        }
-        stack.push(absolutePath);
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      const stats = statSync3(absolutePath);
-      const extension = extname(entry.name) || "[none]";
-      byExt[extension] = (byExt[extension] ?? 0) + 1;
-      totalFiles += 1;
-      files.push({
-        relativePath,
-        sizeBytes: stats.size
-      });
-    }
-  }
-  return {
-    total_files: totalFiles,
-    by_ext: sortRecord(byExt),
-    key_dirs: [...keyDirs].sort(),
-    max_depth: maxDepth,
-    files: files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))
-  };
-}
-function assertExistingDirectory2(target) {
-  if (!existsSync3(target) || !statSync3(target).isDirectory()) {
-    throw new Error(`Target must be an existing directory: ${target}`);
-  }
-}
-function isKeyDirectory(relativePath) {
-  const name = basename(relativePath);
-  return KEY_DIRECTORY_NAMES.has(name);
-}
-function collectEntryPoints(target, files) {
-  const entryPoints = [];
-  for (const file of files) {
-    const reason = getEntryPointReason(file.relativePath);
-    if (reason === null) {
-      continue;
-    }
-    entryPoints.push({
-      path: file.relativePath,
-      reason,
-      size_bytes: file.sizeBytes
-    });
-  }
-  return entryPoints.sort(
-    (left, right) => compareCandidateScore(readGitChurnWeight(target, right.path), readGitChurnWeight(target, left.path))
-  );
-}
-function getEntryPointReason(relativePath) {
-  if (!SCRIPT_EXTENSIONS.has(extname(relativePath))) {
-    return null;
-  }
-  const directory = posix.dirname(relativePath);
-  const fileName = basename(relativePath);
-  const fileBase = basename(relativePath, extname(relativePath));
-  if (directory === "assets/scripts" || directory === "scripts") {
-    return "top-level script";
-  }
-  if (directory === "src" && /^(App|app|index|main)$/.test(fileBase)) {
-    return "application entry";
-  }
-  if ((directory === "app" || directory.startsWith("app/")) && /^(layout|page|route)$/.test(fileBase)) {
-    return "next app route";
-  }
-  if ((directory === "pages" || directory.startsWith("pages/")) && fileName !== "_app.d.ts") {
-    return "next page route";
-  }
-  return null;
-}
-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 sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
-    const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
-      frameworkKind,
-      topology,
-      packageDependencies
-    });
-    samples.push({
-      path: entryPoint.path,
-      lines: `1-${sample.lineCount}`,
-      snippet: sample.snippet,
-      pattern_hint: patternAnalysis.pattern,
-      pattern_analysis: patternAnalysis,
-      evidence: buildEvidenceAnchors(entryPoint.path, sample.snippet, patternAnalysis.evidence_lines)
-    });
-  }
-  return samples;
-}
-function readFirstLines(path, lineLimit) {
-  try {
-    const lines = readFileSync2(path, "utf8").split(/\r?\n/);
-    if (lines.at(-1) === "") {
-      lines.pop();
-    }
-    const sampledLines = lines.slice(0, lineLimit);
-    return {
-      snippet: sampledLines.join("\n"),
-      lineCount: sampledLines.length
-    };
-  } catch {
-    return {
-      snippet: "",
-      lineCount: 0
-    };
-  }
-}
-function readPackageDependencies(target) {
-  const packageJsonPath = join5(target, "package.json");
-  if (!existsSync3(packageJsonPath)) {
-    return /* @__PURE__ */ new Map();
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-    return new Map([
-      ...Object.entries(packageJson.dependencies ?? {}),
-      ...Object.entries(packageJson.devDependencies ?? {}),
-      ...Object.entries(packageJson.peerDependencies ?? {}),
-      ...Object.entries(packageJson.optionalDependencies ?? {})
-    ]);
-  } catch {
-    return /* @__PURE__ */ new Map();
-  }
-}
-function readGitChurnWeight(target, relativePath) {
-  try {
-    const output = execFileSync3("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
-      cwd: target,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      timeout: 1e3
-    });
-    return output.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
-  } catch {
-    return 0;
-  }
-}
-async function inferPatternHint(relativePath, snippet, options = {}) {
-  const input = {
-    relativePath,
-    snippet,
-    frameworkKind: options.frameworkKind ?? "unknown",
-    topology: options.topology ?? createEmptyTopology(),
-    packageDependencies: options.packageDependencies ?? /* @__PURE__ */ new Map()
-  };
-  const importAnalysis = await analyzeImports(input.relativePath, input.snippet);
-  if (importAnalysis.astLevel) {
-    const astResult = buildAstPatternHint(input, importAnalysis.imports);
-    if (astResult !== null) {
-      return astResult;
-    }
-  }
-  return inferTextPatternHint(input.relativePath, input.snippet);
-}
-function createEmptyTopology() {
-  return {
-    total_files: 0,
-    by_ext: {},
-    key_dirs: [],
-    max_depth: 0,
-    files: []
-  };
-}
-function buildAstPatternHint(input, imports) {
-  const profile = resolveFrameworkImportProfile(input.frameworkKind, input.relativePath, imports);
-  if (profile === null) {
-    return null;
-  }
-  const matchingImports = imports.filter((source) => matchesAnyFrameworkPackage(source, profile.packages));
-  const configFiles = getExpectedConfigFiles(input.frameworkKind).filter((file) => hasFile(input.topology.files, file));
-  const packageMatches = profile.packages.filter((packageName) => input.packageDependencies.has(packageName));
-  const coOccurring = compactPatternNames([
-    ...matchingImports.map((source) => `import:${source}`),
-    ...configFiles.map(normalizeConfigPattern),
-    ...packageMatches.map((packageName) => `package:${packageName}`),
-    input.relativePath.startsWith("app/") ? "app-router" : null,
-    input.relativePath.startsWith("pages/") ? "pages-router" : null,
-    input.relativePath === "src/main.ts" || input.relativePath === "src/main.js" ? "main-entry" : null,
-    input.snippet.includes("@ccclass(") ? "ccclass-decorator" : null,
-    input.snippet.includes("extends Component") ? "component-base" : null
-  ]);
-  return {
-    pattern: profile.pattern,
-    type: "pattern",
-    confidence: scoreFrameworkConfidence({
-      importCount: matchingImports.length,
-      configCount: configFiles.length,
-      packageCount: packageMatches.length,
-      astLevel: true
-    }),
-    evidence_lines: matchingImports.length > 0 ? matchingImports : imports.slice(0, 3),
-    co_occurring: coOccurring,
-    family: profile.family,
-    ast_level: true,
-    statement: profile.statement,
-    proposed_rule: profile.proposedRule,
-    alternatives: profile.alternatives,
-    rationale: profile.rationale
-  };
-}
-function inferTextPatternHint(relativePath, snippet) {
-  const cocosCoOccurring = compactPatternNames([
-    snippet.includes('from "cc"') || snippet.includes("from 'cc'") ? "cc-import" : null,
-    snippet.includes("@ccclass(") || snippet.includes("ccclass(") ? "ccclass-decorator" : null,
-    snippet.includes("extends Component") ? "component-base" : null,
-    snippet.includes("const { ccclass } = _decorator") ? "decorator-destructure" : null
-  ]);
-  if (cocosCoOccurring.length > 0) {
-    return {
-      pattern: "cocos-component-class",
-      type: "pattern",
-      confidence: scoreFrameworkConfidence({
-        importCount: 0,
-        configCount: 0,
-        packageCount: 0,
-        astLevel: false,
-        keywordCount: cocosCoOccurring.length
-      }),
-      evidence_lines: compactPatternNames([
-        snippet.includes("_decorator") ? "_decorator" : null,
-        snippet.includes("@ccclass(") ? "@ccclass(" : null,
-        snippet.includes("extends Component") ? "extends Component" : null
-      ]),
-      co_occurring: cocosCoOccurring,
-      family: "component",
-      ast_level: false,
-      statement: "Sampled entry files use Cocos Creator component classes.",
-      proposed_rule: "Treat assets/scripts/*.ts and adjacent .meta files as framework-owned structure unless the user says otherwise.",
-      alternatives: ["Generic TypeScript utility module"],
-      rationale: "Cocos-specific decorators and Component inheritance co-occur in sampled entry files."
-    };
-  }
-  const reactCoOccurring = compactPatternNames([
-    snippet.includes("createRoot(") ? "create-root" : null,
-    snippet.includes("ReactDOM.render(") ? "react-dom-render" : null,
-    snippet.includes('from "react-dom"') || snippet.includes("from 'react-dom'") ? "react-dom-import" : null
-  ]);
-  if (reactCoOccurring.length > 0) {
-    return {
-      pattern: "react-root",
-      type: "pattern",
-      confidence: scoreFrameworkConfidence({
-        importCount: 0,
-        configCount: 0,
-        packageCount: 0,
-        astLevel: false,
-        keywordCount: reactCoOccurring.length
-      }),
-      evidence_lines: compactPatternNames([
-        snippet.includes("createRoot(") ? "createRoot(" : null,
-        snippet.includes("ReactDOM.render(") ? "ReactDOM.render(" : null
-      ]),
-      co_occurring: reactCoOccurring,
-      family: "entry",
-      ast_level: false,
-      statement: "Sampled entry files bootstrap a React DOM root.",
-      proposed_rule: "Keep root rendering logic in the main application entry file.",
-      alternatives: ["Server-rendered route module"],
-      rationale: "React DOM root markers identify a frontend entrypoint."
-    };
-  }
-  if (relativePath.startsWith("app/") || relativePath.startsWith("pages/")) {
-    const coOccurring = compactPatternNames([
-      relativePath.startsWith("app/") ? "app-router" : null,
-      relativePath.startsWith("pages/") ? "pages-router" : null,
-      snippet.includes("export default") ? "default-export-route" : null
-    ]);
-    return {
-      pattern: "next-route-component",
-      type: "pattern",
-      confidence: scoreFrameworkConfidence({
-        importCount: 0,
-        configCount: 0,
-        packageCount: 0,
-        astLevel: false,
-        keywordCount: coOccurring.length
-      }),
-      evidence_lines: compactPatternNames([
-        relativePath.startsWith("app/") ? "app/" : null,
-        relativePath.startsWith("pages/") ? "pages/" : null
-      ]),
-      co_occurring: coOccurring,
-      family: "entry",
-      ast_level: false,
-      statement: "Sampled entry files align with Next.js route modules.",
-      proposed_rule: "Preserve route-segment boundaries when editing app/ or pages/ files.",
-      alternatives: ["Generic source module"],
-      rationale: "Route directory placement anchors these files to the Next.js request surface."
-    };
-  }
-  if (relativePath === "src/main.ts" || relativePath === "src/main.js") {
-    const coOccurring = compactPatternNames([
-      "main-entry",
-      snippet.includes("import.meta") ? "import-meta" : null,
-      snippet.includes("createRoot(") ? "react-root" : null
-    ]);
-    return {
-      pattern: "vite-main-entry",
-      type: "pattern",
-      confidence: scoreFrameworkConfidence({
-        importCount: 0,
-        configCount: 0,
-        packageCount: 0,
-        astLevel: false,
-        keywordCount: coOccurring.length
-      }),
-      evidence_lines: ["src/main"],
-      co_occurring: coOccurring,
-      family: "entry",
-      ast_level: false,
-      statement: "Sampled entry files use the conventional Vite main entrypoint.",
-      proposed_rule: "Keep primary bootstrapping logic inside src/main.*.",
-      alternatives: ["Alternative bundler entrypoint"],
-      rationale: "src/main.* is the expected Vite bootstrap path."
-    };
-  }
-  return {
-    pattern: "source-entry",
-    type: "pattern",
-    confidence: "LOW",
-    evidence_lines: [basename(relativePath)],
-    co_occurring: [],
-    family: "domain",
-    ast_level: false,
-    statement: "Sampled entry file appears to be a generic source entry.",
-    alternatives: ["Framework-specific entrypoint"],
-    rationale: "No strong framework markers were detected in the sampled snippet."
-  };
-}
-async function analyzeImports(relativePath, snippet) {
-  if (snippet.trim().length === 0) {
-    return { imports: [], astLevel: false };
-  }
-  try {
-    const imports = await extractImports(snippet, getLanguageKindForPath(relativePath));
-    return { imports, astLevel: true };
-  } catch {
-    return { imports: [], astLevel: false };
-  }
-}
-async function extractImports(source, languageKind) {
-  const { parser } = await loadTreeSitter(languageKind);
-  let tree = null;
-  try {
-    tree = parser.parse(source);
-    if (tree === null || tree.rootNode.hasError) {
-      throw new Error("tree-sitter parse failed");
-    }
-    const imports = [];
-    collectImportSources(tree.rootNode, imports);
-    return compactPatternNames(imports);
-  } finally {
-    tree?.delete();
-  }
-}
-async function loadTreeSitter(languageKind) {
-  parserBundlePromiseByKind[languageKind] ??= createTreeSitterParserBundle(languageKind);
-  return parserBundlePromiseByKind[languageKind];
-}
-async function createTreeSitterParserBundle(languageKind) {
-  const treeSitter = await loadTreeSitterModule();
-  await initTreeSitterParser(treeSitter);
-  const language = await loadTreeSitterLanguage(treeSitter, languageKind);
-  const parser = new treeSitter.Parser();
-  parser.setLanguage(language);
-  return { parser, language };
-}
-function loadTreeSitterModule() {
-  treeSitterModulePromise ??= import("web-tree-sitter");
-  return treeSitterModulePromise;
-}
-function initTreeSitterParser(treeSitter) {
-  parserInitPromise ??= treeSitter.Parser.init({
-    locateFile: (scriptName) => scriptName.endsWith(".wasm") ? require2.resolve("web-tree-sitter/web-tree-sitter.wasm") : scriptName
-  });
-  return parserInitPromise;
-}
-function loadTreeSitterLanguage(treeSitter, languageKind) {
-  languagePromiseByKind[languageKind] ??= treeSitter.Language.load(resolveTreeSitterGrammarPath(languageKind));
-  return languagePromiseByKind[languageKind];
-}
-function resolveTreeSitterGrammarPath(languageKind) {
-  switch (languageKind) {
-    case "typescript":
-      return require2.resolve("tree-sitter-typescript/tree-sitter-typescript.wasm");
-    case "tsx":
-      return require2.resolve("tree-sitter-typescript/tree-sitter-tsx.wasm");
-    case "javascript":
-      return require2.resolve("tree-sitter-javascript/tree-sitter-javascript.wasm");
-  }
-}
-function getLanguageKindForPath(relativePath) {
-  const extension = extname(relativePath);
-  if (extension === ".tsx") {
-    return "tsx";
-  }
-  if (extension === ".ts") {
-    return "typescript";
-  }
-  return "javascript";
-}
-function collectImportSources(node, imports) {
-  if (node.type === "import_statement" || node.type === "import_declaration") {
-    const sourceNode = node.childForFieldName("source");
-    if (sourceNode !== null) {
-      const source = stripStringLiteral(sourceNode.text);
-      if (source.length > 0) {
-        imports.push(source);
-      }
-    }
-  }
-  for (let index = 0; index < node.namedChildCount; index += 1) {
-    const child = node.namedChild(index);
-    if (child !== null) {
-      collectImportSources(child, imports);
-    }
-  }
-}
-function stripStringLiteral(value) {
-  return value.replace(/^['"]|['"]$/g, "");
-}
-function resolveFrameworkImportProfile(frameworkKind, relativePath, imports) {
-  const primaryProfile = FRAMEWORK_IMPORT_PROFILES[frameworkKind];
-  if (primaryProfile !== void 0 && imports.some((source) => matchesAnyFrameworkPackage(source, primaryProfile.packages))) {
-    return primaryProfile;
-  }
-  if ((relativePath.startsWith("app/") || relativePath.startsWith("pages/")) && FRAMEWORK_IMPORT_PROFILES.next !== void 0) {
-    return FRAMEWORK_IMPORT_PROFILES.next;
-  }
-  return Object.values(FRAMEWORK_IMPORT_PROFILES).find(
-    (profile) => imports.some((source) => matchesAnyFrameworkPackage(source, profile.packages))
-  ) ?? null;
-}
-function matchesAnyFrameworkPackage(source, packageNames) {
-  return packageNames.some((packageName) => source === packageName || source.startsWith(`${packageName}/`));
-}
-function scoreFrameworkConfidence(input) {
-  if (!input.astLevel) {
-    return (input.keywordCount ?? 0) > 0 ? "MEDIUM" : "LOW";
-  }
-  if (input.importCount > 3) {
-    return "HIGH";
-  }
-  if (input.importCount >= 1 && input.importCount <= 3) {
-    return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "MEDIUM";
-  }
-  return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
-}
-function readReadmeInfo(target) {
-  const readmePath = join5(target, "README.md");
-  const hasContributing = existsSync3(join5(target, "CONTRIBUTING.md"));
-  if (!existsSync3(readmePath)) {
-    return {
-      quality: "missing",
-      line_count: 0,
-      has_contributing: hasContributing
-    };
-  }
-  const readme = readFileSync2(readmePath, "utf8");
-  const wordCount = readme.trim().split(/\s+/).filter(Boolean).length;
-  return {
-    quality: wordCount >= 200 ? "ok" : "stub",
-    line_count: readme.length === 0 ? 0 : readme.split(/\r?\n/).length,
-    has_contributing: hasContributing
-  };
-}
-function buildAssertions(frameworkKind, topology, codeSamples) {
-  const assertions = [
-    buildFrameworkAssertion(frameworkKind, topology, codeSamples),
-    buildDominantPatternAssertion(codeSamples),
-    buildEntryDirectoryAssertion(frameworkKind, codeSamples),
-    buildMetaSidecarAssertion(frameworkKind, topology),
-    buildConfigAssertion(frameworkKind, topology),
-    buildDomainAssertion(codeSamples)
-  ];
-  return assertions.filter((assertion) => assertion !== null);
-}
-function buildCandidateFiles(topology, codeSamples, entryPoints) {
-  const selected = /* @__PURE__ */ new Map();
-  const codeSamplesByPath = new Map(codeSamples.map((sample) => [sample.path, sample]));
-  const configFiles = topology.files.filter((file) => isConfigFile(file.relativePath));
-  const testFiles = topology.files.filter((file) => isTestFile(file.relativePath));
-  const domainFiles = topology.files.filter((file) => isDomainFile(file.relativePath));
-  const componentSamples = codeSamples.filter((sample) => sample.pattern_analysis.family === "component").sort((left, right) => compareCandidateScore(buildComponentCandidateScore(right), buildComponentCandidateScore(left)));
-  addCandidateFamily(
-    selected,
-    entryPoints.map((entryPoint) => ({
-      path: entryPoint.path,
-      family: "entry",
-      rationale: `Representative ${entryPoint.reason} used as an application entry surface.`,
-      score: buildEntryCandidateScore(entryPoint)
-    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
-    ENTRY_FAMILY_LIMIT
-  );
-  addCandidateFamily(
-    selected,
-    componentSamples.map((sample) => ({
-      path: sample.path,
-      family: "component",
-      rationale: sample.pattern_analysis.rationale,
-      score: buildComponentCandidateScore(sample)
-    })),
-    FAMILY_LIMIT
-  );
-  addCandidateFamily(
-    selected,
-    configFiles.map((file) => ({
-      path: file.relativePath,
-      family: "config",
-      rationale: "Bootstrap or compiler configuration file used to infer framework and project boundaries.",
-      score: buildConfigCandidateScore(file.relativePath)
-    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
-    FAMILY_LIMIT
-  );
-  addCandidateFamily(
-    selected,
-    testFiles.map((file) => ({
-      path: file.relativePath,
-      family: "test",
-      rationale: "Existing test coverage surface that captures behavior expectations.",
-      score: file.relativePath.includes("__tests__") ? 2 : 1
-    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
-    FAMILY_LIMIT
-  );
-  addCandidateFamily(
-    selected,
-    domainFiles.filter((file) => !codeSamplesByPath.has(file.relativePath)).map((file) => ({
-      path: file.relativePath,
-      family: "domain",
-      rationale: "Representative domain file outside entry/config/test hotspots.",
-      score: buildDomainCandidateScore(file.relativePath)
-    })).sort((left, right) => compareCandidateScore(right.score, left.score)),
-    FAMILY_LIMIT
-  );
-  return [...selected.values()].slice(0, CANDIDATE_FILE_LIMIT);
-}
-function buildFrameworkAssertion(frameworkKind, topology, codeSamples) {
-  if (frameworkKind === "unknown") {
-    return createAssertion({
-      type: "framework",
-      statement: "Framework could not be determined from the sampled topology.",
-      evidence: codeSamples.flatMap((sample) => sample.evidence).slice(0, 3),
-      matched: 0,
-      total: codeSamples.length,
-      coOccurring: [],
-      alternatives: ["Ask the user to confirm the primary framework"]
-    });
-  }
-  const matchedSamples = codeSamples.filter((sample) => matchesFrameworkPattern(frameworkKind, sample.pattern_analysis.pattern));
-  const coOccurring = compactPatternNames([
-    ...matchedSamples.flatMap((sample) => sample.pattern_analysis.co_occurring),
-    hasFile(topology.files, "project.config.json") ? "project-config-json" : null,
-    (topology.by_ext[".meta"] ?? 0) > 0 ? "meta-sidecars" : null,
-    hasFile(topology.files, "package.json") ? "package-json" : null
-  ]);
-  const evidence = [
-    ...matchedSamples.flatMap((sample) => sample.evidence),
-    ...buildTopologyEvidence(topology, getExpectedConfigFiles(frameworkKind))
-  ].slice(0, 3);
-  return createAssertion({
-    type: "framework",
-    statement: buildFrameworkStatement(frameworkKind),
-    evidence,
-    matched: matchedSamples.length,
-    total: codeSamples.length,
-    coOccurring,
-    astLevel: matchedSamples.some((sample) => sample.pattern_analysis.ast_level),
-    proposedRule: buildFrameworkRule(frameworkKind),
-    alternatives: frameworkKind === "cocos-creator" ? ["Generic TypeScript utility modules"] : ["Alternative framework entry layout"]
-  });
-}
-function buildDominantPatternAssertion(codeSamples) {
-  if (codeSamples.length === 0) {
-    return null;
-  }
-  const counts = /* @__PURE__ */ new Map();
-  for (const sample of codeSamples) {
-    const existing = counts.get(sample.pattern_analysis.pattern) ?? [];
-    existing.push(sample);
-    counts.set(sample.pattern_analysis.pattern, existing);
-  }
-  const dominant = [...counts.entries()].sort((left, right) => right[1].length - left[1].length)[0];
-  if (dominant === void 0) {
-    return null;
-  }
-  const [, samples] = dominant;
-  const first = samples[0];
-  return createAssertion({
-    type: first.pattern_analysis.type,
-    statement: first.pattern_analysis.statement,
-    evidence: samples.flatMap((sample) => sample.evidence).slice(0, 3),
-    matched: samples.length,
-    total: codeSamples.length,
-    coOccurring: compactPatternNames(samples.flatMap((sample) => sample.pattern_analysis.co_occurring)),
-    astLevel: samples.some((sample) => sample.pattern_analysis.ast_level),
-    proposedRule: first.pattern_analysis.proposed_rule,
-    alternatives: first.pattern_analysis.alternatives
-  });
-}
-function buildEntryDirectoryAssertion(frameworkKind, codeSamples) {
-  if (codeSamples.length === 0) {
-    return null;
-  }
-  const directoryGroups = /* @__PURE__ */ new Map();
-  for (const sample of codeSamples) {
-    const directory2 = posix.dirname(sample.path);
-    const existing = directoryGroups.get(directory2) ?? [];
-    existing.push(sample);
-    directoryGroups.set(directory2, existing);
-  }
-  const primaryDirectory = [...directoryGroups.entries()].sort((left, right) => right[1].length - left[1].length)[0];
-  if (primaryDirectory === void 0) {
-    return null;
-  }
-  const [directory, samples] = primaryDirectory;
-  return createAssertion({
-    type: "pattern",
-    statement: `Entry samples are concentrated in ${directory}, indicating a stable primary source boundary.`,
-    evidence: samples.flatMap((sample) => sample.evidence).slice(0, 3),
-    matched: samples.length,
-    total: codeSamples.length,
-    coOccurring: compactPatternNames([
-      directory === "." ? "root-entry" : directory,
-      frameworkKind !== "unknown" ? frameworkKind : null,
-      ...samples.flatMap((sample) => sample.pattern_analysis.co_occurring.slice(0, 1))
-    ]),
-    proposedRule: directory === "." ? "Keep primary entry files at the repository root only if the framework expects it." : `Treat ${directory} as the main execution boundary during initialization.`
-  });
-}
-function buildMetaSidecarAssertion(frameworkKind, topology) {
-  const relevantScripts = topology.files.filter((file) => SCRIPT_EXTENSIONS.has(extname(file.relativePath)));
-  if (relevantScripts.length === 0) {
-    return null;
-  }
-  const matchedScripts = relevantScripts.filter((file) => hasFile(topology.files, `${file.relativePath}.meta`));
-  if (matchedScripts.length === 0 && frameworkKind !== "cocos-creator") {
-    return null;
-  }
-  return createAssertion({
-    type: "invariant",
-    statement: matchedScripts.length > 0 ? "Script files have adjacent .meta sidecars, which should be treated as coupled assets." : "No .meta sidecars were detected for sampled scripts.",
-    evidence: matchedScripts.length > 0 ? matchedScripts.slice(0, 3).map((file) => makeSyntheticEvidence(`${file.relativePath}.meta`, `${file.relativePath}.meta sidecar present`)) : buildTopologyEvidence(topology, relevantScripts.slice(0, 1).map((file) => file.relativePath)),
-    matched: matchedScripts.length,
-    total: relevantScripts.length,
-    coOccurring: compactPatternNames([
-      matchedScripts.length > 0 ? "meta-sidecar" : null,
-      frameworkKind === "cocos-creator" ? "cocos-creator" : null,
-      relevantScripts.some((file) => file.relativePath.startsWith("assets/scripts/")) ? "assets-scripts" : null
-    ]),
-    proposedRule: matchedScripts.length > 0 ? "Do not edit or delete .meta sidecars without explicit user confirmation." : void 0
-  });
-}
-function buildConfigAssertion(frameworkKind, topology) {
-  const expectedFiles = getExpectedConfigFiles(frameworkKind);
-  if (expectedFiles.length === 0) {
-    return null;
-  }
-  const matchedFiles = expectedFiles.filter((file) => hasFile(topology.files, file));
-  return createAssertion({
-    type: "invariant",
-    statement: `Project configuration is anchored by ${expectedFiles.join(", ")}.`,
-    evidence: buildTopologyEvidence(topology, matchedFiles),
-    matched: matchedFiles.length,
-    total: expectedFiles.length,
-    coOccurring: compactPatternNames(matchedFiles.map(normalizeConfigPattern)),
-    proposedRule: "Read bootstrap and compiler config before generating new rules or project structure."
-  });
-}
-function buildDomainAssertion(codeSamples) {
-  if (codeSamples.length === 0) {
-    return null;
-  }
-  const namedSamples = codeSamples.filter((sample) => {
-    const fileBase = basename(sample.path, extname(sample.path));
-    return sample.snippet.includes(`class ${fileBase}`) || sample.snippet.includes(`class ${sanitizeIdentifier(fileBase)}`);
-  });
-  if (namedSamples.length === 0) {
-    return null;
-  }
-  const namedModules = compactPatternNames(namedSamples.map((sample) => basename(sample.path, extname(sample.path))));
-  return createAssertion({
-    type: "domain",
-    statement: `Sampled modules are named as concrete domain concepts (${namedModules.join(", ")}).`,
-    evidence: namedSamples.flatMap((sample) => sample.evidence).slice(0, 3),
-    matched: namedSamples.length,
-    total: codeSamples.length,
-    coOccurring: compactPatternNames([
-      namedSamples.every((sample) => /^[A-Z]/.test(basename(sample.path))) ? "pascal-case-modules" : null,
-      namedModules.length >= 2 ? "domain-named-components" : null,
-      namedSamples.some((sample) => sample.snippet.includes("start():")) ? "lifecycle-hook" : null
-    ]),
-    proposedRule: "Preserve domain-specific module names when authoring knowledge entries that reference these modules."
-  });
-}
-function createAssertion(input) {
-  const coverage = {
-    ratio: input.total === 0 ? 0 : roundCoverageRatio(input.matched / input.total),
-    total: input.total,
-    matched: input.matched,
-    co_occurring_patterns: compactPatternNames(input.coOccurring)
-  };
-  return {
-    type: input.type,
-    statement: input.statement,
-    confidence: determineConfidence(coverage.ratio, coverage.co_occurring_patterns, input.astLevel ?? false),
-    evidence: dedupeEvidence(input.evidence),
-    coverage,
-    proposed_rule: input.proposedRule,
-    alternatives: input.alternatives
-  };
-}
-function buildEvidenceAnchors(relativePath, snippet, evidenceLines) {
-  const lines = snippet.split("\n");
-  const anchors = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const pattern of evidenceLines) {
-    const lineIndex = lines.findIndex((line) => line.includes(pattern));
-    if (lineIndex === -1) {
-      continue;
-    }
-    const key = `${relativePath}:${lineIndex + 1}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    anchors.push({
-      file: relativePath,
-      line: String(lineIndex + 1),
-      snippet: lines[lineIndex]?.trim() ?? ""
-    });
-  }
-  if (anchors.length > 0) {
-    return anchors;
-  }
-  const fallbackIndex = lines.findIndex((line) => line.trim().length > 0);
-  return [
-    {
-      file: relativePath,
-      line: String(fallbackIndex === -1 ? 1 : fallbackIndex + 1),
-      snippet: fallbackIndex === -1 ? "" : lines[fallbackIndex]?.trim() ?? ""
-    }
-  ];
-}
-function addCandidateFamily(selected, candidates, familyLimit) {
-  let added = 0;
-  for (const candidate of candidates) {
-    if (selected.size >= CANDIDATE_FILE_LIMIT || added >= familyLimit || selected.has(candidate.path)) {
-      continue;
-    }
-    selected.set(candidate.path, {
-      path: candidate.path,
-      family: candidate.family,
-      rationale: candidate.rationale
-    });
-    added += 1;
-  }
-}
-function buildTopologyEvidence(topology, preferredPaths) {
-  return preferredPaths.filter((path) => hasFile(topology.files, path)).slice(0, 3).map((path) => makeSyntheticEvidence(path, `${path} present in project topology`));
-}
-function makeSyntheticEvidence(file, snippet) {
-  return {
-    file,
-    line: "1",
-    snippet
-  };
-}
-function dedupeEvidence(evidence) {
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const entry of evidence) {
-    const key = `${entry.file}:${entry.line}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    deduped.push(entry);
-  }
-  return deduped.slice(0, 3);
-}
-function matchesFrameworkPattern(frameworkKind, pattern) {
-  if (frameworkKind === "cocos-creator") {
-    return pattern === "cocos-component-class";
-  }
-  if (frameworkKind === "next") {
-    return pattern === "next-route-component";
-  }
-  if (frameworkKind === "vite") {
-    return pattern === "vite-main-entry" || pattern === "react-root";
-  }
-  return pattern !== "source-entry";
-}
-function buildFrameworkStatement(frameworkKind) {
-  if (frameworkKind === "cocos-creator") {
-    return "Project strongly matches a Cocos Creator TypeScript component layout.";
-  }
-  if (frameworkKind === "next") {
-    return "Project topology and entry samples align with a Next.js route-driven application.";
-  }
-  if (frameworkKind === "vite") {
-    return "Project topology aligns with a Vite-style application bootstrap.";
-  }
-  return `Project surfaces align with ${frameworkKind}.`;
-}
-function buildFrameworkRule(frameworkKind) {
-  if (frameworkKind === "cocos-creator") {
-    return "Preserve Cocos component decorators, lifecycle methods, and paired .meta files during initialization.";
-  }
-  if (frameworkKind === "next") {
-    return "Respect app/pages route boundaries when generating instructions or edits.";
-  }
-  if (frameworkKind === "vite") {
-    return "Keep bootstrap logic centered on src/main.* and surrounding config files.";
-  }
-  return void 0;
-}
-function determineConfidence(ratio, coOccurringPatterns, astLevel, hasConflict = false) {
-  if (hasConflict) {
-    return "LOW";
-  }
-  if (astLevel) {
-    return "HIGH";
-  }
-  if (ratio < 0.5) {
-    return "LOW";
-  }
-  if (ratio >= 0.8 && coOccurringPatterns.length >= 2) {
-    return "HIGH";
-  }
-  return "MEDIUM";
-}
-function compactPatternNames(patterns) {
-  return [...new Set(patterns.filter((pattern) => pattern !== null && pattern !== void 0 && pattern.length > 0))];
-}
-function roundCoverageRatio(value) {
-  return Math.round(value * 1e3) / 1e3;
-}
-function getExpectedConfigFiles(frameworkKind) {
-  return EXPECTED_CONFIG_FILES_BY_FRAMEWORK[frameworkKind] ?? ["package.json"];
-}
-function hasFile(files, relativePath) {
-  return files.some((file) => file.relativePath === relativePath);
-}
-function normalizeConfigPattern(relativePath) {
-  return relativePath.replace(/\./g, "-");
-}
-function sanitizeIdentifier(value) {
-  return value.replace(/[^A-Za-z0-9_$]/g, "");
-}
-function compareCandidateScore(left, right) {
-  return left - right;
-}
-function buildEntryCandidateScore(entryPoint) {
-  let score = 0;
-  if (entryPoint.reason === "application entry") {
-    score += 3;
-  }
-  if (entryPoint.reason.includes("route")) {
-    score += 2;
-  }
-  if ((entryPoint.size_bytes ?? 0) > 0) {
-    score += 1;
-  }
-  return score;
-}
-function buildComponentCandidateScore(sample) {
-  let score = sample.pattern_analysis.co_occurring.length;
-  if (sample.pattern_analysis.ast_level) {
-    score += 3;
-  }
-  if (sample.pattern_analysis.confidence === "HIGH") {
-    score += 2;
-  }
-  return score;
-}
-function buildConfigCandidateScore(relativePath) {
-  if (relativePath === "project.config.json") {
-    return 4;
-  }
-  if (relativePath === "package.json") {
-    return 3;
-  }
-  if (relativePath === "tsconfig.json") {
-    return 2;
-  }
-  return 1;
-}
-function buildDomainCandidateScore(relativePath) {
-  let score = 0;
-  if (relativePath.startsWith("src/") || relativePath.startsWith("assets/")) {
-    score += 2;
-  }
-  if (SCRIPT_EXTENSIONS.has(extname(relativePath))) {
-    score += 1;
-  }
-  if (relativePath.includes("/domain/") || relativePath.includes("/models/")) {
-    score += 1;
-  }
-  return score;
-}
-function isConfigFile(relativePath) {
-  return /(^|\/)(package\.json|project\.config\.json|tsconfig\.json|vite\.config\.[^.]+|next\.config\.[^.]+)$/.test(relativePath);
-}
-function isTestFile(relativePath) {
-  return /(^|\/)(__tests__|tests)(\/|$)/.test(relativePath) || /\.(test|spec)\.[^.]+$/.test(relativePath);
-}
-function isDomainFile(relativePath) {
-  const extension = extname(relativePath);
-  if (!DOMAIN_FILE_EXTENSIONS.has(extension)) {
-    return false;
-  }
-  return !isConfigFile(relativePath) && !isTestFile(relativePath);
-}
-function buildSkillRecommendations(frameworkKind, topology, readme, projectRoot) {
-  return buildScanRecommendations(
-    {
-      frameworkKind,
-      hasMeta: (topology.by_ext[".meta"] ?? 0) > 0,
-      readmeOk: readme.quality === "ok"
-    },
-    getProjectTranslator(projectRoot)
-  );
-}
-function readProjectName(target) {
-  const packageJsonPath = join5(target, "package.json");
-  if (existsSync3(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-      if (packageJson.name !== void 0 && packageJson.name.trim().length > 0) {
-        return packageJson.name;
-      }
-    } catch {
-      return basename(target);
-    }
-  }
-  return basename(target);
-}
-function getCliVersion() {
-  return true ? "2.2.0-rc.1" : "unknown";
-}
-function sortRecord(record) {
-  return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
-}
-function toPosixPath(path) {
-  return path.split(sep).join("/");
-}
-
-// src/commands/install.ts
-var LOCAL_FABRIC_SERVER_PATH = join6("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
-var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
-var INIT_WIZARD_GROUP_CANCELLED = /* @__PURE__ */ Symbol("init-wizard-group-cancelled");
-var installCommand = defineCommand({
-  meta: {
-    name: "install",
-    description: t("cli.install.description")
-  },
-  args: {
-    debug: {
-      type: "boolean",
-      description: t("cli.install.args.debug.description"),
-      default: false
-    },
-    "dry-run": {
-      type: "boolean",
-      description: t("cli.install.args.dry-run.description"),
-      default: false
-    },
-    target: {
-      type: "string",
-      description: t("cli.install.args.target.description")
-    },
-    yes: {
-      type: "boolean",
-      description: t("cli.install.args.yes.description"),
-      default: false
-    },
-    "force-skills-only": {
-      type: "boolean",
-      description: t("cli.install.args.force-skills-only.description"),
-      default: false
-    },
-    "force-hooks-only": {
-      type: "boolean",
-      description: t("cli.install.args.force-hooks-only.description"),
-      default: false
-    },
-    global: {
-      type: "boolean",
-      description: "Set up global Fabric (~/.fabric: uid + personal store + config)",
-      default: false
-    },
-    url: {
-      type: "string",
-      description: "With --global: clone + mount this shared store remote"
-    }
-  },
-  async run({ args }) {
-    await runInitCommand(args);
-  }
-});
-var install_default = installCommand;
-async function runSkillsOnlyRefresh(targetInput) {
-  const target = normalizeTarget3(targetInput);
-  const metaPath = join6(target, ".fabric", "agents.meta.json");
-  if (!existsSync4(metaPath)) {
-    const message = t("cli.install.force-skills-only.uninitialised.message");
-    const hint = t("cli.install.force-skills-only.uninitialised.hint");
-    process.stderr.write(`${message}
-${hint}
-`);
-    process.exitCode = 1;
-    return;
-  }
-  console.log(formatInitStageHeader(t("cli.install.force-skills-only.banner")));
-  const results = [];
-  results.push(...await cleanupDeprecatedSkills(target));
-  results.push(...await installFabricArchiveSkill(target));
-  results.push(...await installFabricReviewSkill(target));
-  results.push(...await installFabricImportSkill(target));
-  results.push(...await installFabricSyncSkill(target));
-  results.push(...await installFabricStoreSkill(target));
-  results.push(...await installFabricAuditSkill(target));
-  results.push(...await installFabricConnectSkill(target));
-  results.push(...await installSharedSkillLib(target));
-  let written = 0;
-  let skipped = 0;
-  let errors = 0;
-  for (const r of results) {
-    if (r.status === "written") written += 1;
-    else if (r.status === "skipped") skipped += 1;
-    else if (r.status === "error") errors += 1;
-  }
-  console.log(
-    t("cli.install.force-skills-only.summary", {
-      written: String(written),
-      skipped: String(skipped),
-      errors: String(errors)
-    })
-  );
-  if (errors > 0) {
-    for (const r of results) {
-      if (r.status === "error") {
-        process.stderr.write(`  ${r.step} ${r.path}: ${r.message ?? "error"}
-`);
-      }
-    }
-    process.exitCode = 1;
-  }
-}
-async function runHooksOnlyRefresh(targetInput) {
-  const target = normalizeTarget3(targetInput);
-  const metaPath = join6(target, ".fabric", "agents.meta.json");
-  if (!existsSync4(metaPath)) {
-    const message = t("cli.install.force-hooks-only.uninitialised.message");
-    const hint = t("cli.install.force-hooks-only.uninitialised.hint");
-    process.stderr.write(`${message}
-${hint}
-`);
-    process.exitCode = 1;
-    return;
-  }
-  console.log(formatInitStageHeader(t("cli.install.force-hooks-only.banner")));
-  const result = await installHooks(target);
-  console.log(
-    t("cli.install.force-hooks-only.summary", {
-      written: String(result.installed.length),
-      skipped: String(result.skipped.length),
-      errors: String(result.errors.length)
-    })
-  );
-  if (result.errors.length > 0) {
-    for (const err of result.errors) {
-      process.stderr.write(`  ${err}
-`);
-    }
-    process.exitCode = 1;
-  }
-}
-async function runInitCommand(args) {
-  const logger = createDebugLogger(args.debug);
-  if (args.global === true) {
-    await runGlobalInstall({ url: args.url });
-    return;
-  }
-  const resolution = resolveDevMode(args.target, process.cwd());
-  if (args["force-skills-only"] === true) {
-    await runSkillsOnlyRefresh(resolution.target);
-    return;
-  }
-  if (args["force-hooks-only"] === true) {
-    await runHooksOnlyRefresh(resolution.target);
-    return;
-  }
-  const intent = resolveInitCliIntent(args, resolution.target);
-  logger(`init target source: ${resolution.source}`);
-  for (const step of resolution.chain) {
-    logger(step);
-  }
-  const supports = detectClientSupports(intent.target);
-  const basePlan = await buildInitExecutionPlan({
-    target: intent.target,
-    options: intent.options,
-    mcpInstallMode: intent.mcpInstallMode,
-    claudeMcpScope: intent.claudeMcpScope,
-    interactive: intent.interactiveSummary && !intent.wizardEnabled,
-    supports
-  });
-  const plan = intent.wizardEnabled ? await resolveInitExecutionPlanWithWizard(basePlan, createDefaultInitWizardAdapter()) : basePlan;
-  if (plan === null) {
-    process.exitCode = 130;
-    return;
-  }
-  const result = await executeInitExecutionPlan(plan);
-  if (!intent.options.planOnly) {
-    console.log("");
-    console.log(t("cli.install.next-steps"));
-    console.log("");
-    console.log(paint.muted("More: docs/surfaces.md explains when to use CLI vs Skill vs MCP."));
-  }
-  return result;
-}
-var FABRIC_GITIGNORE_CONTENT = [
-  "# Fabric per-dev activity ledgers & caches \u2014 auto-generated, not shared.",
-  "# Managed by `fabric install`; edit freely (re-install never overwrites this).",
-  "events.jsonl",
-  "metrics.jsonl",
-  "cite-rollup.jsonl",
-  "injections.jsonl",
-  ".cache/",
-  "*.lock",
-  "*.corrupted.*",
-  ""
-].join("\n");
-function writeDefaultGitignore(fabricDir) {
-  const target = join6(fabricDir, ".gitignore");
-  if (existsSync4(target)) return;
-  mkdirSync2(fabricDir, { recursive: true });
-  writeFileSync(target, FABRIC_GITIGNORE_CONTENT, "utf8");
-}
-function writeDefaultFabricConfig(fabricDir, targetRoot) {
-  const target = join6(fabricDir, "fabric-config.json");
-  if (existsSync4(target)) return;
-  const detectedLanguage = detectExistingLanguage(targetRoot);
-  const FABRIC_CONFIG_DEFAULTS = {
-    // Scan/import language policy. Fixated at init time by probing
-    // README.md + docs/*.md (CJK ratio > 0.3 → "zh-CN", else "en"). Users
-    // can edit `.fabric/fabric-config.json` to override. See
-    // packages/shared/src/schemas/fabric-config.ts for the enum.
-    fabric_language: detectedLanguage,
-    // fabric-hint Stop hook Signal A (archive): time-branch threshold, hours
-    // since last knowledge_proposed event.
-    archive_hint_hours: 24,
-    // fabric-hint Stop hook cooldown after ANY signal fires, in hours.
-    archive_hint_cooldown_hours: 12,
-    // fabric-hint Stop hook Signal B (review): pending-count cutoff.
-    review_hint_pending_count: 10,
-    // fabric-hint Stop hook Signal B (review): pending-age cutoff in days.
-    review_hint_pending_age_days: 7,
-    // fabric-hint Stop hook Signal D (maintenance): days since last doctor.
-    maintenance_hint_days: 14,
-    // fabric-hint Stop hook Signal D (maintenance): cooldown between
-    // reminders, in days.
-    maintenance_hint_cooldown_days: 7,
-    // fabric-hint Stop hook Signal A (archive): edit-count branch threshold;
-    // PreToolUse fires recorded in .fabric/.cache/edit-counter since the
-    // last knowledge_proposed event.
-    archive_edit_threshold: 20,
-    // fabric-hint Stop hook Signal C (import) + doctor lint #22: canonical
-    // knowledge node count below this value flags an underseeded workspace.
-    underseed_node_threshold: 10,
-    // rc.9+ (skill-contract-fix B1): fabric-import first-run git-history
-    // window in months. Default 60 captures the bulk of a mature repo's
-    // signal in one pass; lower to 12-24 for fresh / small repos.
-    import_window_first_run_months: 60,
-    // rc.9+ (skill-contract-fix B1): fabric-import rerun window in months.
-    // Default 2; raise to 6 if the workspace pauses imports for long stretches.
-    import_window_rerun_months: 2,
-    // rc.9+ (skill-contract-fix B1): hard cap on pending entries produced
-    // per fabric-import invocation. Default 10 matches one-sitting triage.
-    import_max_pending_per_run: 10,
-    // rc.9+ (skill-contract-fix B1): hard cap on commits scanned per
-    // fabric-import invocation. Default 500 covers ~2 months of typical churn.
-    import_max_commits_scan: 500,
-    // rc.9+ (skill-contract-fix B1): canonical-node count above which
-    // fabric-import suggests review over importing more. Default 50.
-    import_skip_canonical_threshold: 50,
-    // rc.9+ (skill-contract-fix B1): max candidates per fabric-archive batch.
-    // Default 8 keeps each batch reviewable in one sitting.
-    archive_max_candidates_per_batch: 8,
-    // rc.9+ (skill-contract-fix B1): max recently-touched paths in
-    // fabric-archive's relevance digest. Default 20.
-    archive_max_recent_paths: 20,
-    // rc.9+ (skill-contract-fix B1): max prior fabric-archive sessions
-    // summarised in the digest the skill loads on start. Default 10.
-    archive_digest_max_sessions: 10,
-    // rc.9+ (skill-contract-fix B1): max review results per topic cluster
-    // in fabric-review. Default 8.
-    review_topic_result_cap: 8,
-    // rc.9+ (skill-contract-fix B1): age (days) above which a pending entry
-    // is considered stale by fabric-review. Default 14.
-    review_stale_pending_days: 14
-  };
-  mkdirSync2(fabricDir, { recursive: true });
-  writeFileSync(target, JSON.stringify(FABRIC_CONFIG_DEFAULTS, null, 2) + "\n", "utf8");
-  log.info(
-    `Detected and fixated fabric_language = ${detectedLanguage}; edit ${target} to override.`
-  );
-}
-function resolveInitCliIntent(args, targetInput) {
-  const target = normalizeTarget3(targetInput);
-  const mcpInstallMode = "global";
-  const claudeMcpScope = "project";
-  const terminalInteractive = isInteractiveInit();
-  const planOnly = args["dry-run"] === true;
-  const options = {
-    planOnly
-  };
-  return {
-    target,
-    options,
-    mcpInstallMode,
-    claudeMcpScope,
-    interactiveSummary: terminalInteractive,
-    wizardEnabled: shouldUseInitWizard(args, terminalInteractive) && !planOnly
-  };
-}
-async function buildInitExecutionPlan(input) {
-  const options = input.options ?? {};
-  const scaffold = await buildInitFabricPlan(input.target, options);
-  const supports = input.supports ?? detectClientSupports(input.target);
-  const mcpInstallMode = input.mcpInstallMode ?? "global";
-  const claudeMcpScope = input.claudeMcpScope ?? "project";
-  const stages = [
-    { name: "bootstrap", skipped: Boolean(options.skipBootstrap) },
-    {
-      name: "mcp",
-      skipped: Boolean(options.skipMcp),
-      installMode: mcpInstallMode,
-      claudeMcpScope,
-      localServerPath: mcpInstallMode === "local" ? LOCAL_FABRIC_SERVER_PATH : void 0,
-      packageManager: mcpInstallMode === "local" ? detectPackageManager(input.target) : void 0
-    },
-    { name: "hooks", skipped: Boolean(options.skipHooks) }
-  ];
-  return {
-    target: input.target,
-    options,
-    mcpInstallMode,
-    claudeMcpScope,
-    interactive: input.interactive ?? false,
-    supports,
-    scaffold,
-    stages,
-    steps: [
-      { name: "preflight" },
-      { name: "scaffold" },
-      ...stages.map((stage) => ({ name: stage.name, skipped: stage.skipped })),
-      { name: "post-setup" }
-    ]
-  };
-}
-async function executeInitExecutionPlan(plan) {
-  if (plan.interactive) {
-    printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
-  }
-  const scaffoldStates = [
-    { path: plan.scaffold.metaPath, state: plan.scaffold.metaState },
-    { path: plan.scaffold.eventsPath, state: plan.scaffold.eventsState },
-    { path: plan.scaffold.forensicPath, state: plan.scaffold.forensicState }
-  ];
-  if (plan.options.planOnly) {
-    printInitPlanPreview(plan);
-    printInitDiffStateTable(scaffoldStates);
-    return {
-      plan,
-      created: buildPlanOnlyScaffoldResult(plan.scaffold),
-      stageResults: plan.stages.map((stage) => ({ name: stage.name, disposition: "skipped" })),
-      finalSupports: plan.supports
-    };
-  }
-  if (existsSync4(plan.scaffold.fabricDir) && !statSync4(plan.scaffold.fabricDir).isDirectory()) {
-    throw new Error(
-      t("cli.install.diff.drift-abort", { path: plan.scaffold.fabricDir })
-    );
-  }
-  const drifted = scaffoldStates.find(
-    (entry) => entry.state === "drifted" || entry.state === "user-modified"
-  );
-  if (drifted !== void 0) {
-    throw new Error(t("cli.install.diff.drift-abort", { path: drifted.path }));
-  }
-  let created = null;
-  const stageResults = [];
-  let finalSupports = plan.supports;
-  for (const step of plan.steps) {
-    switch (step.name) {
-      case "preflight":
-        break;
-      case "scaffold":
-        created = await executeInitFabricPlan(plan.scaffold);
-        printInitScaffoldResult(created);
-        break;
-      case "bootstrap":
-      case "mcp":
-      case "hooks":
-        stageResults.push(await executeInitStagePlan(plan, step.name));
-        break;
-      case "post-setup":
-        finalSupports = detectClientSupports(plan.target);
-        printInitPostSetup(plan, stageResults, finalSupports);
-        break;
-      default:
-        exhaustiveInitExecutionStep(step);
-    }
-  }
-  if (scaffoldStates.every((entry) => entry.state === "present-canonical")) {
-    console.log(
-      t("cli.install.diff.canonical", { count: String(scaffoldStates.length) })
-    );
-  }
-  return {
-    plan,
-    created: created ?? unreachableInitScaffold(),
-    stageResults,
-    finalSupports
-  };
-}
-var KNOWLEDGE_SUBDIRS = ["decisions", "pitfalls", "guidelines", "models", "processes", "pending"];
-function resolvePersonalFabricRoot() {
-  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 = existsSync4(agentsMdPath) ? "preserved" : "created";
-  const knowledgeDir = join6(fabricDir, "knowledge");
-  const personalKnowledgeDir = join6(resolvePersonalFabricRoot(), ".fabric", "knowledge");
-  const forensicPath = join6(fabricDir, "forensic.json");
-  const eventsPath = join6(fabricDir, "events.jsonl");
-  const metaPath = join6(fabricDir, "agents.meta.json");
-  const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
-  const knowledgeDirAction = existsSync4(knowledgeDir) ? "overwritten" : "created";
-  const metaClassification = classifyFreshPath(metaPath, "structural");
-  const eventsClassification = classifyFreshPath(eventsPath, "presence");
-  const forensicClassification = classifyFreshPath(forensicPath, "always-rewrite");
-  const metaAction = diffStateToWriteAction(metaClassification.state);
-  const eventsAction = diffStateToWriteAction(eventsClassification.state);
-  const forensicAction = diffStateToWriteAction(forensicClassification.state);
-  const showScanProgress = process.stderr.isTTY === true;
-  if (showScanProgress) {
-    process.stderr.write(`${t("cli.install.scanning")}
-`);
-  }
-  const forensicReport = await buildForensicReport(target);
-  if (showScanProgress) {
-    process.stderr.write(`${t("cli.install.scan-complete")}
-`);
-  }
-  const meta = createInitialMeta();
-  return {
-    target,
-    options,
-    fabricDir,
-    replaceFabricDir,
-    agentsMdPath,
-    agentsMdAction,
-    knowledgeDir,
-    knowledgeDirAction,
-    personalKnowledgeDir,
-    metaPath,
-    metaAction,
-    meta,
-    eventsPath,
-    eventsAction,
-    forensicPath,
-    forensicAction,
-    forensicReport,
-    metaState: metaClassification.state,
-    eventsState: eventsClassification.state,
-    forensicState: forensicClassification.state
-  };
-}
-async function executeInitFabricPlan(plan) {
-  if (plan.replaceFabricDir) {
-    rmSync2(plan.fabricDir, { force: true });
-  }
-  mkdirSync2(plan.fabricDir, { recursive: true });
-  writeDefaultFabricConfig(plan.fabricDir, plan.target);
-  writeDefaultGitignore(plan.fabricDir);
-  mkdirSync2(plan.knowledgeDir, { recursive: true });
-  for (const sub of KNOWLEDGE_SUBDIRS) {
-    const teamSubDir = join6(plan.knowledgeDir, sub);
-    mkdirSync2(teamSubDir, { recursive: true });
-    const teamGitkeep = join6(teamSubDir, ".gitkeep");
-    if (!existsSync4(teamGitkeep)) {
-      writeFileSync(teamGitkeep, "", "utf8");
-    }
-  }
-  try {
-    mkdirSync2(plan.personalKnowledgeDir, { recursive: true });
-    for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync2(join6(plan.personalKnowledgeDir, sub), { recursive: true });
-    }
-  } catch {
-  }
-  if (plan.metaState === "missing") {
-    preparePlannedPath(plan.metaPath, plan.metaAction);
-    await atomicWriteJson(plan.metaPath, plan.meta);
-  }
-  if (plan.eventsState === "missing") {
-    preparePlannedPath(plan.eventsPath, plan.eventsAction);
-    mkdirSync2(dirname(plan.eventsPath), { recursive: true });
-    writeFileSync(plan.eventsPath, "", "utf8");
-  }
-  preparePlannedPath(plan.forensicPath, plan.forensicAction);
-  await atomicWriteJson(plan.forensicPath, plan.forensicReport);
-  if (existsSync4(plan.eventsPath)) {
-    const applied = [];
-    const canonical = [];
-    const drifted = [];
-    for (const entry of [
-      { path: plan.metaPath, state: plan.metaState },
-      { path: plan.eventsPath, state: plan.eventsState },
-      { path: plan.forensicPath, state: plan.forensicState }
-    ]) {
-      if (entry.state === "missing") {
-        applied.push(entry.path);
-      } else if (entry.state === "present-canonical") {
-        canonical.push(entry.path);
-      } else {
-        drifted.push(entry.path);
-      }
-    }
-    appendInstallDiffLedgerEvent(plan.eventsPath, { applied, canonical, drifted });
-  }
-  return {
-    agentsMdPath: plan.agentsMdPath,
-    agentsMdAction: plan.agentsMdAction,
-    knowledgeDir: plan.knowledgeDir,
-    knowledgeDirAction: plan.knowledgeDirAction,
-    personalKnowledgeDir: plan.personalKnowledgeDir,
-    metaPath: plan.metaPath,
-    metaAction: plan.metaAction,
-    eventsPath: plan.eventsPath,
-    eventsAction: plan.eventsAction,
-    forensicPath: plan.forensicPath,
-    forensicAction: plan.forensicAction
-  };
-}
-async function initFabric(target, options) {
-  return await executeInitFabricPlan(await buildInitFabricPlan(target, options));
-}
-function shouldUseInitWizard(args, terminalInteractive = isInteractiveInit()) {
-  return terminalInteractive && args.yes !== true;
-}
-async function resolveInitExecutionPlanWithWizard(basePlan, wizardAdapter) {
-  const selection = await wizardAdapter.run({
-    target: basePlan.target,
-    options: basePlan.options,
-    supports: basePlan.supports,
-    mcpInstallMode: basePlan.mcpInstallMode,
-    claudeMcpScope: basePlan.claudeMcpScope,
-    lockedStages: []
-  });
-  if (selection === null) {
-    return null;
-  }
-  return buildInitExecutionPlan({
-    target: basePlan.target,
-    options: {
-      ...basePlan.options,
-      skipBootstrap: !selection.bootstrap,
-      skipMcp: !selection.mcp,
-      skipHooks: !selection.hooks
-    },
-    mcpInstallMode: selection.mcp ? selection.mcpInstallMode : basePlan.mcpInstallMode,
-    claudeMcpScope: selection.claudeMcpScope,
-    interactive: false,
-    supports: basePlan.supports
-  });
-}
-function unreachableInitScaffold() {
-  throw new Error("Init scaffold step did not execute");
-}
-function exhaustiveInitExecutionStep(value) {
-  throw new Error(`Unsupported init execution step: ${JSON.stringify(value)}`);
-}
-function exhaustiveInitStagePlan(value) {
-  throw new Error(`Unsupported init stage plan: ${JSON.stringify(value)}`);
-}
-function printInitScaffoldResult(created) {
-  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.eventsPath, created.eventsAction));
-  console.log(formatInitPathAction(created.forensicPath, created.forensicAction));
-}
-function printInitPostSetup(plan, stageResults, finalSupports) {
-  if (shouldPrintHooksNextStep(plan.options, stageResults)) {
-    console.log(
-      t("cli.install.next-step", {
-        label: nextLabel(),
-        message: paint.muted(t("cli.install.next-step.message"))
-      })
-    );
-  }
-  console.log(
-    t("cli.install.reason-message", {
-      label: reasonLabel(),
-      message: paint.muted(formatInitReasonMessage(finalSupports))
-    })
-  );
-  printInitStageSummary(stageResults);
-  printInitCapabilitySummary(finalSupports, stageResults, plan.options);
-  const fabricLanguage = readFabricLanguagePreference(plan.target);
-  console.log(
-    paint.muted(t("cli.install.language_preference_hint", { value: fabricLanguage }))
-  );
-}
-function printInitDiffStateTable(entries) {
-  for (const entry of entries) {
-    console.log(`  ${formatDiffFileState(entry.state)}  ${entry.path}`);
-  }
-}
-function printInitPlanPreview(plan) {
-  console.log(t("cli.install.plan.preview-title"));
-  printInitPlanSummary(plan.target, plan.options, plan.mcpInstallMode, plan.supports);
-  console.log(
-    t("cli.install.plan.preview-result", {
-      mode: t("cli.install.mode.default"),
-      bootstrap: yesNoLabel(!plan.options.skipBootstrap),
-      mcp: yesNoLabel(!plan.options.skipMcp),
-      hooks: yesNoLabel(!plan.options.skipHooks)
-    })
-  );
-}
-function buildPlanOnlyScaffoldResult(plan) {
-  return {
-    agentsMdPath: plan.agentsMdPath,
-    agentsMdAction: plan.agentsMdAction,
-    knowledgeDir: plan.knowledgeDir,
-    knowledgeDirAction: plan.knowledgeDirAction,
-    personalKnowledgeDir: plan.personalKnowledgeDir,
-    metaPath: plan.metaPath,
-    metaAction: plan.metaAction,
-    eventsPath: plan.eventsPath,
-    eventsAction: plan.eventsAction,
-    forensicPath: plan.forensicPath,
-    forensicAction: plan.forensicAction
-  };
-}
-async function executeInitStagePlan(plan, stageName) {
-  const stage = plan.stages.find((entry) => entry.name === stageName);
-  if (stage === void 0) {
-    throw new Error(`Missing init stage plan: ${stageName}`);
-  }
-  if (stage.skipped) {
-    return { name: stageName, disposition: "skipped" };
-  }
-  console.log(formatInitStageHeader(t(`cli.install.stages.${stageName}`)));
-  try {
-    switch (stage.name) {
-      case "bootstrap": {
-        const installResults = [];
-        installResults.push(...await runBestEffort("skill-deprecated-cleanup", () => cleanupDeprecatedSkills(plan.target)));
-        installResults.push(...await runBestEffort("skill-install", () => installFabricArchiveSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-review-install", () => installFabricReviewSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-import-install", () => installFabricImportSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-sync-install", () => installFabricSyncSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-store-install", () => installFabricStoreSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-audit-install", () => installFabricAuditSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-connect-install", () => installFabricConnectSkill(plan.target)));
-        installResults.push(...await runBestEffort("skill-shared-lib", () => installSharedSkillLib(plan.target)));
-        installResults.push(...await runBestEffort("hook-script", () => installArchiveHintHook(plan.target)));
-        installResults.push(...await runBestEffort("hook-broad-script", () => installKnowledgeHintBroadHook(plan.target)));
-        installResults.push(...await runBestEffort("hook-narrow-script", () => installKnowledgeHintNarrowHook(plan.target)));
-        installResults.push(...await runBestEffort("hook-cite-policy-evict-script", () => installCitePolicyEvictHook(plan.target)));
-        installResults.push(...await runBestEffort("hook-lib", () => installHookLibs(plan.target)));
-        installResults.push(await runBestEffortSingle("claude-hook-config", () => mergeClaudeCodeHookConfig(plan.target)));
-        installResults.push(await runBestEffortSingle("codex-hook-config", () => mergeCodexHookConfig(plan.target)));
-        installResults.push(await runBestEffortSingle("cursor-hook-config", () => mergeCursorHookConfig(plan.target)));
-        installResults.push(await runBestEffortSingle("bootstrap-snapshot", () => writeFabricAgentsSnapshot(plan.target)));
-        installResults.push(await runBestEffortSingle("bootstrap-claude", () => writeClaudeBootstrapThinShell(plan.target)));
-        installResults.push(await runBestEffortSingle("bootstrap-codex", () => writeCodexBootstrapManagedBlock(plan.target)));
-        installResults.push(await runBestEffortSingle("bootstrap-cursor", () => writeCursorBootstrapManagedBlock(plan.target)));
-        const installedCount = installResults.filter((r) => r.status === "written").length;
-        const skippedCount = installResults.filter((r) => r.status === "skipped").length;
-        const errorCount = installResults.filter((r) => r.status === "error").length;
-        for (const result of installResults) {
-          if (result.status === "error") {
-            writeStderr(`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") {
-          const manager = stage.packageManager ?? detectPackageManager(plan.target);
-          writeStderr(t("cli.install.mcp.install.local"));
-          writeStderr(t("cli.install.mcp.local.installing", { manager }));
-          installLocalFabricServer(plan.target, manager);
-          writeStderr(t("cli.install.mcp.local.installed"));
-        } else {
-          writeStderr(t("cli.install.mcp.install.global"));
-        }
-        const result = await installMcpClients(plan.target, {
-          localServerPath: stage.localServerPath,
-          claudeMcpScope: stage.claudeMcpScope
-        });
-        if (result.details.length === 0) {
-          console.log(formatInitStageResult("mcp", "skipped", 0, 0, t("cli.config.install.no-configs")));
-          return { name: "mcp", disposition: "skipped" };
-        }
-        console.log(formatInitStageResult("mcp", "completed", result.installed.length, result.skipped.length));
-        return { name: "mcp", disposition: "ran" };
-      }
-      case "hooks": {
-        const result = await installHooks(plan.target);
-        console.log(formatInitStageResult("hooks", "completed", result.installed.length, result.skipped.length));
-        return { name: "hooks", disposition: "ran" };
-      }
-      default:
-        return exhaustiveInitStagePlan(stage);
-    }
-  } catch (error) {
-    writeStderr(formatInitStageFailure(stageName, error));
-    return { name: stageName, disposition: "failed" };
-  }
-}
-function shouldReplaceWritableDirectory(path, _options) {
-  if (!existsSync4(path)) {
-    return false;
-  }
-  if (statSync4(path).isDirectory()) {
-    return false;
-  }
-  return false;
-}
-function classifyFreshPath(path, strategy) {
-  if (!existsSync4(path)) {
-    return { path, state: "missing" };
-  }
-  let stat;
-  try {
-    stat = statSync4(path);
-  } catch (error) {
-    return {
-      path,
-      state: "user-modified",
-      reason: error instanceof Error ? error.message : String(error)
-    };
-  }
-  if (!stat.isFile()) {
-    return { path, state: "user-modified", reason: "expected a file" };
-  }
-  if (strategy === "presence" || strategy === "always-rewrite") {
-    return { path, state: "present-canonical" };
-  }
-  try {
-    const raw = readFileSync3(path, "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return { path, state: "user-modified", reason: "not a JSON object" };
-    }
-    const record = parsed;
-    const hasRevision = typeof record["revision"] === "string";
-    const hasNodes = record["nodes"] !== void 0 && record["nodes"] !== null && typeof record["nodes"] === "object" && !Array.isArray(record["nodes"]);
-    const hasCounters = record["counters"] !== void 0 && record["counters"] !== null && typeof record["counters"] === "object" && !Array.isArray(record["counters"]);
-    if (!hasRevision || !hasNodes || !hasCounters) {
-      return { path, state: "drifted", reason: "missing required AgentsMeta fields" };
-    }
-    return { path, state: "present-canonical" };
-  } catch (error) {
-    return {
-      path,
-      state: "user-modified",
-      reason: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function diffStateToWriteAction(_state) {
-  return "created";
-}
-function formatDiffFileState(state) {
-  return t(`cli.install.diff.state.${state}`);
-}
-function preparePlannedPath(path, action) {
-  mkdirSync2(dirname(path), { recursive: true });
-  if (action === "overwritten" && existsSync4(path)) {
-    rmSync2(path, { recursive: true, force: true });
-  }
-}
-function createDefaultInitWizardAdapter() {
-  return {
-    async run(context) {
-      intro(t("cli.install.wizard.intro"));
-      note(
-        t("cli.install.wizard.overview.body", {
-          target: context.target,
-          mode: formatInitModeBadge(context.options)
-        }),
-        t("cli.install.wizard.overview.title")
-      );
-      printInitPlanSummary(context.target, context.options, context.mcpInstallMode, context.supports);
-      log.step(t("cli.install.wizard.step.target"));
-      const continueWithTarget = await confirm({
-        message: t("cli.install.wizard.target.confirm", { target: context.target }),
-        initialValue: true
-      });
-      if (isCancel(continueWithTarget) || !continueWithTarget) {
-        emitInitWizardCancellation();
-        return null;
-      }
-      log.step(t("cli.install.wizard.step.plan"));
-      let groupedSelection;
-      try {
-        groupedSelection = await group(
-          {
-            bootstrap: async () => context.lockedStages.includes("bootstrap") ? false : confirmInGroup({
-              message: t("cli.install.wizard.stage.bootstrap", {
-                defaultValue: formatPromptDefault(!context.options.skipBootstrap)
-              }),
-              initialValue: !context.options.skipBootstrap
-            }),
-            mcp: async () => context.lockedStages.includes("mcp") ? false : confirmInGroup({
-              message: t("cli.install.wizard.stage.mcp", {
-                defaultValue: formatPromptDefault(!context.options.skipMcp)
-              }),
-              initialValue: !context.options.skipMcp
-            }),
-            mcpInstallMode: async ({ results }) => results.mcp ? selectMcpInstallModeInGroup({
-              message: t("cli.install.wizard.mcp-install", { defaultValue: context.mcpInstallMode }),
-              initialValue: context.mcpInstallMode,
-              options: [
-                { value: "global", label: "global", hint: t("cli.install.mcp.install.global") },
-                { value: "local", label: "local", hint: t("cli.install.mcp.install.local") }
-              ]
-            }) : context.mcpInstallMode,
-            claudeMcpScope: async ({ results }) => results.mcp ? selectClaudeMcpScopeInGroup({
-              message: t("cli.install.wizard.mcp-scope", { defaultValue: context.claudeMcpScope }),
-              initialValue: context.claudeMcpScope,
-              options: [
-                { value: "project", label: "project", hint: t("cli.install.mcp.scope.project") },
-                { value: "user", label: "user", hint: t("cli.install.mcp.scope.user") }
-              ]
-            }) : context.claudeMcpScope,
-            hooks: async () => context.lockedStages.includes("hooks") ? false : confirmInGroup({
-              message: t("cli.install.wizard.stage.hooks", {
-                defaultValue: formatPromptDefault(!context.options.skipHooks)
-              }),
-              initialValue: !context.options.skipHooks
-            })
-          },
-          {
-            onCancel() {
-              throw INIT_WIZARD_GROUP_CANCELLED;
-            }
-          }
-        );
-      } catch (error) {
-        if (error === INIT_WIZARD_GROUP_CANCELLED) {
-          emitInitWizardCancellation();
-          return null;
-        }
-        throw error;
-      }
-      if (groupedSelection === null) {
-        emitInitWizardCancellation();
-        return null;
-      }
-      const previewOptions = {
-        ...context.options,
-        skipBootstrap: !groupedSelection.bootstrap,
-        skipMcp: !groupedSelection.mcp,
-        skipHooks: !groupedSelection.hooks
-      };
-      log.step(t("cli.install.wizard.step.review"));
-      printInitPlanSummary(context.target, previewOptions, groupedSelection.mcpInstallMode, context.supports);
-      const confirmed = await confirm({
-        message: t("cli.install.wizard.execute.confirm"),
-        initialValue: true
-      });
-      if (isCancel(confirmed) || !confirmed) {
-        emitInitWizardCancellation();
-        return null;
-      }
-      outro(t("cli.install.wizard.outro"));
-      return groupedSelection;
-    }
-  };
-}
-function emitInitWizardCancellation() {
-  cancel(t("cli.install.wizard.cancelled"));
-}
-async function confirmInGroup(options) {
-  const result = await confirm(options);
-  if (isCancel(result)) {
-    throw INIT_WIZARD_GROUP_CANCELLED;
-  }
-  return result;
-}
-async function selectMcpInstallModeInGroup(options) {
-  const result = await select({
-    message: options.message,
-    initialValue: options.initialValue,
-    options: options.options
-  });
-  if (isCancel(result)) {
-    throw INIT_WIZARD_GROUP_CANCELLED;
-  }
-  return result;
-}
-async function selectClaudeMcpScopeInGroup(options) {
-  const result = await select({
-    message: options.message,
-    initialValue: options.initialValue,
-    options: options.options
-  });
-  if (isCancel(result)) {
-    throw INIT_WIZARD_GROUP_CANCELLED;
-  }
-  return result;
-}
-function formatPromptDefault(value) {
-  return value ? "Y/n" : "y/N";
-}
-function formatInitModeBanner(options) {
-  if (options.planOnly) {
-    return t("cli.install.plan.mode-banner.plan");
-  }
-  return t("cli.install.plan.mode-banner.default");
-}
-function formatInitModeBadge(options) {
-  if (options.planOnly) {
-    return t("cli.install.mode.badge.plan");
-  }
-  return t("cli.install.mode.badge.default");
-}
-function normalizeTarget3(targetInput) {
-  return isAbsolute3(targetInput) ? targetInput : resolve3(process.cwd(), targetInput);
-}
-function assertExistingDirectory3(target) {
-  if (!existsSync4(target) || !statSync4(target).isDirectory()) {
-    throw new Error(`Target must be an existing directory: ${target}`);
-  }
-}
-function detectPackageManager(cwd) {
-  const workspaceRoot = resolve3(cwd);
-  if (existsSync4(join6(workspaceRoot, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (existsSync4(join6(workspaceRoot, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (existsSync4(join6(workspaceRoot, "package-lock.json"))) {
-    return "npm";
-  }
-  return "npm";
-}
-function installLocalFabricServer(target, manager) {
-  const installArgs = manager === "npm" ? ["install", "-D", FABRIC_SERVER_PACKAGE] : ["add", "-D", FABRIC_SERVER_PACKAGE];
-  childProcess.execFileSync(manager, installArgs, {
-    cwd: target,
-    stdio: "inherit",
-    shell: process.platform === "win32"
-  });
-}
-function createInitialMeta() {
-  return {
-    revision: "sha256:initial",
-    nodes: {},
-    counters: defaultAgentsMetaCounters()
-  };
-}
-function appendInstallDiffLedgerEvent(eventsPath, payload) {
-  const event = {
-    kind: "fabric-event",
-    id: `event:${randomUUID2()}`,
-    ts: Date.now(),
-    schema_version: 1,
-    event_type: "install_diff_applied",
-    applied: payload.applied,
-    canonical: payload.canonical,
-    drifted: payload.drifted
-  };
-  const line = `${JSON.stringify(event)}
-`;
-  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)}`;
-}
-function formatInitStageResult(stage, status, installedCount, skippedCount, note2) {
-  const label = status === "completed" ? completedStageLabel() : skippedStageLabel();
-  const counts = `installed=${installedCount} skipped=${skippedCount}`;
-  const suffix = note2 ? ` ${paint.muted(`(${note2})`)}` : "";
-  return `${label} ${stage}: ${counts}${suffix}`;
-}
-function formatInitStageFailure(stage, error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return `${failedStageLabel()} ${stage}: ${message}`;
-}
-function printInitStageSummary(stageResults) {
-  console.log(formatInitStageSummaryLine("ran", collectInitStageNames(stageResults, "ran")));
-  console.log(formatInitStageSummaryLine("skipped", collectInitStageNames(stageResults, "skipped")));
-  console.log(formatInitStageSummaryLine("failed", collectInitStageNames(stageResults, "failed")));
-}
-function formatInitStageSummaryLine(disposition, stages) {
-  const label = disposition === "ran" ? paint.success(t("cli.install.stages.summary.ran")) : disposition === "skipped" ? paint.muted(t("cli.install.stages.summary.skipped")) : paint.error(t("cli.install.stages.summary.failed"));
-  return `${label}: ${stages.length > 0 ? stages.join(", ") : t("cli.shared.none")}`;
-}
-function collectInitStageNames(stageResults, disposition) {
-  return stageResults.filter((stage) => stage.disposition === disposition).map((stage) => stage.name);
-}
-function shouldPrintHooksNextStep(options, stageResults) {
-  return Boolean(options.skipHooks) || stageResults.some((stage) => stage.name === "hooks" && stage.disposition === "failed");
-}
-function isInteractiveInit() {
-  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
-}
-function printInitPlanSummary(target, options, mcpInstallMode, supports) {
-  console.log(t("cli.install.plan.title"));
-  console.log(formatInitModeBanner(options));
-  console.log(t("cli.install.plan.target", { target }));
-  console.log(
-    t("cli.install.plan.actions", {
-      bootstrap: yesNoLabel(!options.skipBootstrap),
-      mcp: yesNoLabel(!options.skipMcp),
-      hooks: yesNoLabel(!options.skipHooks),
-      mcpInstall: mcpInstallMode
-    })
-  );
-  const detected = supports.filter((support) => support.detected);
-  console.log(
-    t("cli.install.plan.detected", {
-      clients: detected.length > 0 ? detected.map((support) => support.label).join(", ") : t("cli.shared.none")
-    })
-  );
-  console.log(t("cli.install.plan.writes"));
-  console.log(`  - ${target}/.fabric/knowledge/{decisions,pitfalls,guidelines,models,processes,pending}/`);
-  console.log(`  - ${target}/.fabric/agents.meta.json`);
-  console.log(`  - ${target}/.fabric/events.jsonl`);
-  console.log(`  - ${target}/.fabric/forensic.json`);
-  console.log(`  - ${target}/.fabric/fabric-config.json`);
-}
-function printInitCapabilitySummary(supports, stageResults, options) {
-  const detected = supports.filter((support) => support.detected);
-  if (detected.length === 0) {
-    console.log(t("cli.install.capabilities.none"));
-    return;
-  }
-  console.log(t("cli.install.capabilities.title"));
-  const rows = detected.map((support) => toCapabilityRow(support, stageResults, options));
-  const headers = {
-    client: t("cli.install.capabilities.header.client"),
-    bootstrap: t("cli.install.capabilities.header.bootstrap"),
-    mcp: t("cli.install.capabilities.header.mcp"),
-    hook: t("cli.install.capabilities.header.hook"),
-    skill: t("cli.install.capabilities.header.skill"),
-    followUp: t("cli.install.capabilities.header.follow-up")
-  };
-  const widths = {
-    client: Math.max(displayWidth(headers.client), ...rows.map((row) => displayWidth(row.client))),
-    bootstrap: Math.max(displayWidth(headers.bootstrap), ...rows.map((row) => displayWidth(row.bootstrap))),
-    mcp: Math.max(displayWidth(headers.mcp), ...rows.map((row) => displayWidth(row.mcp))),
-    hook: Math.max(displayWidth(headers.hook), ...rows.map((row) => displayWidth(row.hook))),
-    skill: Math.max(displayWidth(headers.skill), ...rows.map((row) => displayWidth(row.skill))),
-    followUp: Math.max(displayWidth(headers.followUp), ...rows.map((row) => displayWidth(row.followUp)))
-  };
-  console.log(formatCapabilityTableRow(headers, widths));
-  console.log(formatCapabilityDivider(widths));
-  for (const row of rows) {
-    console.log(formatCapabilityTableRow(row, widths));
-  }
-  console.log("");
-  console.log(t("cli.install.restart-banner"));
-}
-function toCapabilityRow(support, stageResults, options) {
-  const stage = (name) => stageResults.find((entry) => entry.name === name)?.disposition ?? null;
-  const bootstrap = support.capabilities.bootstrap ? capabilityStatus(options.skipBootstrap ? "skipped" : stage("bootstrap")) : t("cli.install.capabilities.status.na");
-  const mcp = support.capabilities.mcp ? capabilityStatus(options.skipMcp ? "skipped" : stage("mcp")) : t("cli.install.capabilities.status.na");
-  const hook = capabilityInstallStatus(support, "hook");
-  const skill = capabilityInstallStatus(support, "skill");
-  return {
-    client: support.label,
-    bootstrap,
-    mcp,
-    hook,
-    skill,
-    followUp: hasInstalledCapability(support, "skill") ? t("cli.install.capabilities.follow-up.ready") : support.capabilities.skill ? t("cli.install.capabilities.follow-up.install") : t("cli.install.capabilities.follow-up.manual")
-  };
-}
-function capabilityInstallStatus(support, capability) {
-  if (!support.capabilities[capability]) {
-    return t("cli.install.capabilities.status.na");
-  }
-  return hasInstalledCapability(support, capability) ? t("cli.install.capabilities.status.installed") : t("cli.install.capabilities.status.supported");
-}
-function hasInstalledCapability(support, capability) {
-  return support.installedCapabilities?.[capability] === true;
-}
-function capabilityStatus(disposition) {
-  switch (disposition) {
-    case "ran":
-      return t("cli.install.capabilities.status.ready");
-    case "skipped":
-      return t("cli.install.capabilities.status.skipped");
-    case "failed":
-      return t("cli.install.capabilities.status.failed");
-    case null:
-      return t("cli.install.capabilities.status.na");
-    default:
-      return t("cli.install.capabilities.status.ready");
-  }
-}
-function formatCapabilityTableRow(row, widths) {
-  return [
-    padEnd(row.client, widths.client),
-    padEnd(row.bootstrap, widths.bootstrap),
-    padEnd(row.mcp, widths.mcp),
-    padEnd(row.hook, widths.hook),
-    padEnd(row.skill, widths.skill),
-    padEnd(row.followUp, widths.followUp)
-  ].join("  ");
-}
-function formatCapabilityDivider(widths) {
-  return [
-    "".padEnd(widths.client, "-"),
-    "".padEnd(widths.bootstrap, "-"),
-    "".padEnd(widths.mcp, "-"),
-    "".padEnd(widths.hook, "-"),
-    "".padEnd(widths.skill, "-"),
-    "".padEnd(widths.followUp, "-")
-  ].join("  ");
-}
-function formatInitReasonMessage(supports) {
-  const detected = supports.filter((support) => support.detected);
-  if (detected.some((support) => support.capabilities.skill)) {
-    return t("cli.install.reason-message.installable-body");
-  }
-  return t("cli.install.reason-message.manual-body");
-}
-function yesNoLabel(value) {
-  return value ? t("cli.shared.yes") : t("cli.shared.no");
-}
-function formatInitPathAction(path, action) {
-  return t("cli.install.created-path", { label: labelForInitWriteAction(action), path });
-}
-function formatAgentsMdAction(path, action) {
-  if (action === "preserved") {
-    return t("cli.install.skipped-existing-path", { label: skippedLabel(), path });
-  }
-  return t("cli.install.created-path", { label: createdLabel(), path });
-}
-function labelForInitWriteAction(action) {
-  return action === "overwritten" ? overwrittenLabel() : createdLabel();
-}
-function createdLabel() {
-  return paint.success(t("cli.shared.created"));
-}
-function skippedLabel() {
-  return paint.muted(t("cli.shared.skipped"));
-}
-function nextLabel() {
-  return paint.ai(t("cli.shared.next"));
-}
-function reasonLabel() {
-  return paint.human(t("cli.shared.reason"));
-}
-function overwrittenLabel() {
-  return paint.warn(t("cli.install.label.overwritten"));
-}
-function completedStageLabel() {
-  return paint.success(t("cli.install.stages.completed"));
-}
-function skippedStageLabel() {
-  return paint.muted(t("cli.install.stages.skipped"));
-}
-function failedStageLabel() {
-  return paint.error(t("cli.install.stages.failed"));
-}
-function writeStderr(message) {
-  process.stderr.write(`${message}
-`);
-}
-export {
-  buildInitExecutionPlan,
-  buildInitFabricPlan,
-  createDefaultInitWizardAdapter,
-  install_default as default,
-  detectPackageManager,
-  executeInitExecutionPlan,
-  executeInitFabricPlan,
-  initFabric,
-  installCommand,
-  resolveInitExecutionPlanWithWizard,
-  runHooksOnlyRefresh,
-  runInitCommand,
-  runSkillsOnlyRefresh,
-  shouldUseInitWizard
-};