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

package/dist/install-v2-RINEA24K.js

@@ -0,0 +1,3279 @@
+#!/usr/bin/env node
+import {
+  cleanupDeprecatedSkills,
+  installArchiveHintHook,
+  installCitePolicyEvictHook,
+  installFabricArchiveSkill,
+  installFabricAuditSkill,
+  installFabricConnectSkill,
+  installFabricImportSkill,
+  installFabricReviewSkill,
+  installFabricRouterSkill,
+  installFabricStoreSkill,
+  installFabricSyncSkill,
+  installHookLibs,
+  installKnowledgeHintBroadHook,
+  installKnowledgeHintNarrowHook,
+  installPostTooluseMutationHook,
+  installSessionEndMarkerHook,
+  installSharedSkillLib,
+  mergeClaudeCodeHookConfig,
+  mergeCodexHookConfig,
+  writeClaudeBootstrapThinShell,
+  writeCodexBootstrapManagedBlock,
+  writeFabricAgentsSnapshot
+} from "./chunk-7ZDXBOOU.js";
+import {
+  ensureStoreProjectBinding,
+  migrateRootConfig,
+  normalizeStoreProjectId,
+  suggestStoreProjectId
+} from "./chunk-3D7B2UAZ.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-WA3DYGSY.js";
+import {
+  installMcpClients
+} from "./chunk-2KBCTMID.js";
+import {
+  detectClientSupports
+} from "./chunk-3IOLS5EK.js";
+import {
+  paint
+} from "./chunk-NLNH64A3.js";
+import "./chunk-PTGQAZEW.js";
+import "./chunk-EOT63RDH.js";
+import {
+  storeCreate,
+  storeList,
+  storeProjectList,
+  syncStoreAliasLinks,
+  unboundAvailableStores
+} from "./chunk-QPAW6IYT.js";
+import {
+  loadProjectConfig
+} from "./chunk-QFIVFZRH.js";
+import {
+  globalConfigPath,
+  loadGlobalConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig
+} from "./chunk-FNHDQTPC.js";
+import {
+  getProjectTranslator,
+  refreshLocale,
+  t
+} from "./chunk-HORSMSZL.js";
+
+// src/commands/install-v2.ts
+import { defineCommand } from "citty";
+
+// src/install/run-global-install.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync, mkdirSync, mkdtempSync, renameSync, rmSync as rmSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import {
+  STORES_ROOT_DIR,
+  addMountedStore,
+  deriveMountLabel,
+  disambiguateAlias,
+  globalConfigSchema as globalConfigSchema2,
+  readStoreIdentity,
+  storeRelativePathForMount as storeRelativePathForMount2
+} 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 } from "path";
+import { globalConfigSchema, initStore, storeRelativePathForMount } 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 personalStore = {
+    store_uuid: options.personalStoreUuid,
+    alias,
+    mount_name: alias,
+    personal: true
+  };
+  const personalDir = join(options.globalRoot, storeRelativePathForMount(personalStore));
+  let config = null;
+  const receipt = await runInstallTransaction([
+    {
+      name: "init-personal-store",
+      apply: async () => {
+        await 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: [personalStore]
+        });
+        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 config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new GenericIOError("global config missing \u2014 run `fabric install --global` first", {
+      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 storesRoot = join2(globalRoot, STORES_ROOT_DIR);
+  mkdirSync(storesRoot, { recursive: true });
+  const tmp = mkdtempSync(join2(tmpdir(), "fabric-clone-"));
+  const cloneDest = join2(tmp, "store");
+  gitClone(url, cloneDest);
+  const identity = readStoreIdentity(cloneDest);
+  if (identity === null) {
+    rmSync2(tmp, { recursive: true, force: true });
+    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 alreadyMounted = config.stores.find((s) => s.store_uuid === identity.store_uuid);
+  if (alreadyMounted !== void 0) {
+    rmSync2(tmp, { recursive: true, force: true });
+    console.log(`store '${alreadyMounted.alias}' (${identity.store_uuid}) already mounted; reusing`);
+    return { store_uuid: identity.store_uuid, alias: alreadyMounted.alias };
+  }
+  const desiredAlias = identity.canonical_alias ?? "team";
+  const alias = disambiguateAlias(config.stores.map((s) => s.alias), desiredAlias);
+  const mount_name = deriveMountLabel({ remote: url, alias: desiredAlias, store_uuid: identity.store_uuid });
+  const finalDir = join2(globalRoot, storeRelativePathForMount2({ store_uuid: identity.store_uuid, mount_name }));
+  if (existsSync(finalDir)) {
+    const onDisk = readStoreIdentity(finalDir);
+    rmSync2(tmp, { recursive: true, force: true });
+    if (onDisk === null || onDisk.store_uuid !== identity.store_uuid) {
+      throw new GenericIOError(
+        `cannot mount store from ${url}: a different store already occupies ${finalDir}` + (onDisk === null ? " (no valid store.json there)" : ` (uuid ${onDisk.store_uuid})`),
+        {
+          actionHint: "remove or relocate that directory, then retry \u2014 identity is the intrinsic store_uuid, not the directory name"
+        }
+      );
+    }
+    saveGlobalConfig(
+      addMountedStore(config, { store_uuid: identity.store_uuid, alias, mount_name, remote: url }),
+      globalRoot
+    );
+    syncStoreAliasLinks(globalRoot);
+    console.log(`adopted existing store '${alias}' (${identity.store_uuid}) at ${finalDir}`);
+    return { store_uuid: identity.store_uuid, alias };
+  }
+  mkdirSync(join2(finalDir, ".."), { recursive: true });
+  renameSync(cloneDest, finalDir);
+  rmSync2(tmp, { recursive: true, force: true });
+  saveGlobalConfig(
+    addMountedStore(config, { store_uuid: identity.store_uuid, alias, mount_name, remote: url }),
+    globalRoot
+  );
+  syncStoreAliasLinks(globalRoot);
+  console.log(`mounted store '${alias}' (${identity.store_uuid}) from ${url}`);
+  return { store_uuid: identity.store_uuid, alias };
+}
+function cloneGlobalPersonalFromRemote(url, globalRoot, uid = deriveUid()) {
+  if (loadGlobalConfig(globalRoot) !== null) {
+    throw new GenericIOError("global config already exists; refusing to clone a personal store over it", {
+      actionHint: "this machine already has a personal store; to adopt a remote one, use `fabric store` after install rather than re-running first-touch install"
+    });
+  }
+  const storesRoot = join2(globalRoot, STORES_ROOT_DIR);
+  mkdirSync(storesRoot, { recursive: true });
+  const tmp = mkdtempSync(join2(tmpdir(), "fabric-personal-clone-"));
+  const cloneDest = join2(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 Fabric personal store git repo (it must contain a store.json at its root)"
+    });
+  }
+  const personalStore = {
+    store_uuid: identity.store_uuid,
+    alias: "personal",
+    // D4 — label from the remote repo name; `personal: true` routes it to the
+    // `personal/` group bucket regardless of the label.
+    mount_name: deriveMountLabel({ remote: url, alias: "personal", store_uuid: identity.store_uuid }),
+    personal: true,
+    remote: url
+  };
+  const finalDir = join2(globalRoot, storeRelativePathForMount2(personalStore));
+  mkdirSync(join2(finalDir, ".."), { recursive: true });
+  renameSync(cloneDest, finalDir);
+  saveGlobalConfig(globalConfigSchema2.parse({ uid, stores: [personalStore] }), globalRoot);
+  syncStoreAliasLinks(globalRoot);
+  console.log(`cloned personal store '${identity.store_uuid}' from ${url}`);
+  return { store_uuid: identity.store_uuid };
+}
+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);
+  }
+  syncStoreAliasLinks(globalRoot);
+}
+
+// src/install/pipeline/pipeline.ts
+function stageLabel(name) {
+  return t(`cli.install.pipeline.label.${name}`);
+}
+var STAGE_DESCRIPTION_KEYS = {
+  store: "cli.install.pipeline.desc.store"
+};
+var STAGE_ICONS = {
+  preflight: "\u{1F50D}",
+  env: "\u{1F3D7}\uFE0F",
+  store: "\u{1F4E6}",
+  hooks: "\u{1FA9D}",
+  mcp: "\u{1F50C}",
+  validate: "\u2705",
+  guidance: "\u{1F4D6}"
+};
+var InstallPipeline = class {
+  stages = [];
+  /**
+   * Add a stage to the pipeline.
+   * Stages execute in the order they are added.
+   */
+  addStage(stage) {
+    this.stages.push(stage);
+    return this;
+  }
+  /**
+   * Execute all stages in order.
+   * On failure, executes rollback actions in reverse order.
+   */
+  async execute(initialContext) {
+    const context = initialContext;
+    const totalStages = this.stages.length;
+    const renderer = context.renderer;
+    if (renderer) {
+      renderer.renderSection(t("cli.install.pipeline.title"));
+      renderer.renderInfo(t("cli.install.pipeline.running", { count: String(totalStages) }));
+    } else {
+      console.log(t("cli.install.pipeline.running", { count: String(totalStages) }));
+    }
+    for (let i = 0; i < this.stages.length; i++) {
+      const stage = this.stages[i];
+      const stepNum = i + 1;
+      const stageName = stage.name;
+      if (renderer) {
+        renderer.renderSection(`${STAGE_ICONS[stageName]} ${stageLabel(stageName)}`);
+      } else {
+        console.log(`[${stepNum}/${totalStages}] ${stageLabel(stageName)}`);
+        const descriptionKey = STAGE_DESCRIPTION_KEYS[stageName];
+        if (descriptionKey !== void 0) {
+          console.log(`  ${t(descriptionKey)}`);
+        }
+      }
+      if (renderer) {
+        renderer.renderStep({
+          name: stageLabel(stageName),
+          current: stepNum,
+          total: totalStages,
+          status: "running"
+        });
+      }
+      try {
+        const result = await stage.execute(context);
+        context.stageResults.push(result);
+        if (renderer) {
+          if (result.disposition === "ran") {
+            renderer.renderStep({
+              name: stageLabel(stageName),
+              current: stepNum,
+              total: totalStages,
+              status: "success",
+              detail: result.installed.length > 0 ? `${result.installed.length} installed, ${result.skipped.length} skipped` : void 0
+            });
+          } else if (result.disposition === "skipped") {
+            renderer.renderStep({
+              name: stageLabel(stageName),
+              current: stepNum,
+              total: totalStages,
+              status: "skipped",
+              detail: result.payload && typeof result.payload === "object" && "reason" in result.payload ? String(result.payload.reason) : void 0
+            });
+          } else if (result.disposition === "failed") {
+            renderer.renderStep({
+              name: stageLabel(stageName),
+              current: stepNum,
+              total: totalStages,
+              status: "error",
+              detail: result.errors.join(", ")
+            });
+          }
+        }
+        if (result.disposition === "failed") {
+          await this.rollback(context);
+          if (renderer) {
+            const errorInfo = {
+              title: `${stageLabel(stageName)} ${t("cli.install.stages.failed")}`,
+              message: result.errors.join(", "),
+              hint: "Check the error details above. Run with --debug for more information."
+            };
+            renderer.renderError(errorInfo);
+          }
+          return {
+            success: false,
+            context,
+            error: new Error(`Stage ${stageName} failed: ${result.errors.join(", ")}`)
+          };
+        }
+      } catch (error) {
+        await this.rollback(context);
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (renderer) {
+          renderer.renderError(err);
+        }
+        return {
+          success: false,
+          context,
+          error: err
+        };
+      }
+    }
+    if (renderer) {
+      const summary = this.buildSummary(context);
+      renderer.renderSummaryCard(summary);
+      renderer.renderComplete();
+    }
+    return {
+      success: true,
+      context
+    };
+  }
+  /**
+   * Build summary info from accumulated stage results.
+   */
+  buildSummary(context) {
+    const results = context.stageResults;
+    const successCount = results.filter((r) => r.disposition === "ran").length;
+    const skippedCount = results.filter((r) => r.disposition === "skipped").length;
+    const errorCount = results.filter((r) => r.disposition === "failed").length;
+    const details = results.map((r) => ({
+      label: stageLabel(r.name),
+      value: r.disposition === "ran" ? `${r.installed.length} installed` : r.disposition === "skipped" ? "skipped" : `${r.errors.length} error(s)`,
+      status: r.disposition === "ran" ? "success" : r.disposition === "skipped" ? "skipped" : "error"
+    }));
+    return {
+      title: t("cli.install.pipeline.complete"),
+      successCount,
+      skippedCount,
+      errorCount,
+      details
+    };
+  }
+  /**
+   * Execute rollback actions in reverse order.
+   */
+  async rollback(context) {
+    const rollbackStack = [...context.rollbackStack].reverse();
+    for (const { action } of rollbackStack) {
+      try {
+        await action();
+      } catch {
+      }
+    }
+    for (const stage of [...this.stages].reverse()) {
+      if (stage.rollback) {
+        try {
+          await stage.rollback(context);
+        } catch {
+        }
+      }
+    }
+  }
+};
+function stageRan(name, installed = [], skipped = [], payload) {
+  return {
+    name,
+    disposition: "ran",
+    installed,
+    skipped,
+    errors: [],
+    payload
+  };
+}
+function stageSkipped(name, reason) {
+  return {
+    name,
+    disposition: "skipped",
+    installed: [],
+    skipped: [],
+    errors: [],
+    payload: reason ? { reason } : void 0
+  };
+}
+function stageFailed(name, errors) {
+  return {
+    name,
+    disposition: "failed",
+    installed: [],
+    skipped: [],
+    errors
+  };
+}
+function stageFailedFromError(name, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return stageFailed(name, [message]);
+}
+
+// src/install/pipeline/preflight.stage.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync2, rmSync as rmSync3, statSync, writeFileSync } from "fs";
+import { dirname, isAbsolute, join as join3, resolve } from "path";
+var PreflightStage = class {
+  name = "preflight";
+  async execute(context) {
+    const target = this.normalizeTarget(context.args.target ?? process.cwd());
+    try {
+      this.assertExistingDirectory(target);
+      context.target = target;
+      context.state.globalRoot = this.resolveGlobalRoot();
+      if (context.options.planOnly === true) {
+        this.assertGlobalRootPlannable(context.state.globalRoot);
+      } else {
+        this.assertGlobalRootWritable(context.state.globalRoot);
+        this.assertWritable(target);
+      }
+      if (context.args.url) {
+        this.assertGitAvailable();
+      }
+      return stageRan("preflight", [], [target]);
+    } catch (error) {
+      return stageFailedFromError("preflight", error);
+    }
+  }
+  normalizeTarget(targetInput) {
+    return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+  }
+  assertExistingDirectory(target) {
+    if (!existsSync2(target) || !statSync(target).isDirectory()) {
+      throw new Error(t("cli.shared.target-invalid", { target }));
+    }
+  }
+  resolveGlobalRoot() {
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    if (!home) {
+      throw new Error("Cannot determine home directory for global root");
+    }
+    return resolve(home, ".fabric");
+  }
+  assertGlobalRootWritable(globalRoot) {
+    if (existsSync2(globalRoot)) {
+      if (!statSync(globalRoot).isDirectory()) {
+        throw new Error(`Global Fabric root is not a directory: ${globalRoot}`);
+      }
+      this.assertWritable(globalRoot, "Global Fabric root");
+      return;
+    }
+    const parent = dirname(globalRoot);
+    if (!existsSync2(parent) || !statSync(parent).isDirectory()) {
+      throw new Error(`Global Fabric root parent is not a directory: ${parent}`);
+    }
+    this.assertWritable(parent, "Global Fabric root parent");
+  }
+  assertGlobalRootPlannable(globalRoot) {
+    if (existsSync2(globalRoot)) {
+      if (!statSync(globalRoot).isDirectory()) {
+        throw new Error(`Global Fabric root is not a directory: ${globalRoot}`);
+      }
+      return;
+    }
+    const parent = dirname(globalRoot);
+    if (!existsSync2(parent) || !statSync(parent).isDirectory()) {
+      throw new Error(`Global Fabric root parent is not a directory: ${parent}`);
+    }
+  }
+  assertWritable(path, label = "Target") {
+    const probePath = join3(path, `.fabric-preflight-${process.pid}-${Date.now()}.tmp`);
+    try {
+      writeFileSync(probePath, "", { flag: "wx" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`${label} is not writable: ${path} (${message})`);
+    } finally {
+      rmSync3(probePath, { force: true });
+    }
+  }
+  assertGitAvailable() {
+    try {
+      execFileSync3("git", ["--version"], { stdio: ["ignore", "ignore", "ignore"] });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`git is required for --url installs but was not available: ${message}`);
+    }
+  }
+};
+
+// src/install/pipeline/env.stage.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join5 } from "path";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+import { resolveGlobalLocale } from "@fenglimg/fabric-shared";
+
+// src/scanner/forensic.ts
+import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync3, readdirSync, readFileSync, statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import { basename, extname, isAbsolute as isAbsolute2, join as join4, posix, relative, resolve as resolve2, sep } from "path";
+import {
+  buildScanRecommendations,
+  forensicReportSchema
+} from "@fenglimg/fabric-shared";
+import { detectFramework } from "@fenglimg/fabric-shared/node";
+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 = normalizeTarget(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 normalizeTarget(targetInput) {
+  return isAbsolute2(targetInput) ? targetInput : resolve2(process.cwd(), targetInput);
+}
+function buildTopology(root) {
+  assertExistingDirectory(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 readdirSync(current, { withFileTypes: true })) {
+      const absolutePath = join4(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 = statSync2(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 assertExistingDirectory(target) {
+  if (!existsSync3(target) || !statSync2(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
+    });
+  }
+  const churnByPath = new Map(
+    entryPoints.map((entryPoint) => [entryPoint.path, readGitChurnWeight(target, entryPoint.path)])
+  );
+  return entryPoints.sort(
+    (left, right) => compareCandidateScore(churnByPath.get(right.path) ?? 0, churnByPath.get(left.path) ?? 0)
+  );
+}
+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 = join4(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 = readFileSync(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 = join4(target, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(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 = execFileSync4("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 = join4(target, "README.md");
+  const hasContributing = existsSync3(join4(target, "CONTRIBUTING.md"));
+  if (!existsSync3(readmePath)) {
+    return {
+      quality: "missing",
+      line_count: 0,
+      has_contributing: hasContributing
+    };
+  }
+  const readme = readFileSync(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 = join4(target, "package.json");
+  if (existsSync3(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(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.10" : "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/install/pipeline/env.stage.ts
+var EnvStage = class {
+  name = "env";
+  async execute(context) {
+    const target = context.target;
+    try {
+      const clientSupports = detectClientSupports(target);
+      context.state.clientSupports = clientSupports;
+      const scaffold = await this.buildScaffoldPlan(target, context.options);
+      context.state.scaffold = scaffold;
+      if (context.options.planOnly === true) {
+        const fabricLanguage2 = this.readFabricLanguagePreference(target);
+        context.state.fabricLanguage = fabricLanguage2;
+        return stageSkipped("env", "dry-run: scaffold planned without writing files");
+      }
+      const created = await this.executeScaffold(scaffold, target);
+      const fabricLanguage = this.readFabricLanguagePreference(target);
+      context.state.fabricLanguage = fabricLanguage;
+      const installed = [
+        scaffold.fabricDir,
+        scaffold.eventsPath,
+        scaffold.forensicPath
+      ].filter((p) => existsSync4(p));
+      return stageRan("env", installed, [], created);
+    } catch (error) {
+      return stageFailedFromError("env", error);
+    }
+  }
+  async buildScaffoldPlan(target, _options) {
+    const fabricDir = join5(target, ".fabric");
+    const agentsMdPath = join5(target, "AGENTS.md");
+    const eventsPath = join5(fabricDir, "events.jsonl");
+    const forensicPath = join5(fabricDir, "forensic.json");
+    const eventsState = this.classifyPath(eventsPath, "presence");
+    const forensicState = this.classifyPath(forensicPath, "always-rewrite");
+    const agentsMdAction = existsSync4(agentsMdPath) ? "preserved" : "created";
+    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")}
+`);
+    }
+    return {
+      fabricDir,
+      agentsMdPath,
+      agentsMdAction,
+      eventsPath,
+      eventsAction: this.diffStateToWriteAction(eventsState),
+      eventsState,
+      forensicPath,
+      forensicAction: this.diffStateToWriteAction(forensicState),
+      forensicState,
+      forensicReport
+    };
+  }
+  async executeScaffold(scaffold, target) {
+    mkdirSync2(scaffold.fabricDir, { recursive: true });
+    this.writeDefaultFabricConfig(scaffold.fabricDir, target);
+    migrateRootConfig(target);
+    this.writeDefaultGitignore(scaffold.fabricDir);
+    if (scaffold.eventsState === "missing") {
+      mkdirSync2(dirname2(scaffold.eventsPath), { recursive: true });
+      writeFileSync2(scaffold.eventsPath, "", "utf8");
+    }
+    await atomicWriteJson(scaffold.forensicPath, scaffold.forensicReport);
+    return scaffold;
+  }
+  classifyPath(path, _strategy) {
+    if (!existsSync4(path)) {
+      return "missing";
+    }
+    let stat;
+    try {
+      stat = statSync3(path);
+    } catch {
+      return "user-modified";
+    }
+    if (!stat.isFile()) {
+      return "user-modified";
+    }
+    return "present-canonical";
+  }
+  diffStateToWriteAction(_state) {
+    return "created";
+  }
+  writeDefaultFabricConfig(fabricDir, _targetRoot) {
+    const target = join5(fabricDir, "fabric-config.json");
+    if (existsSync4(target)) return;
+    const FABRIC_CONFIG_DEFAULTS = {
+      archive_hint_hours: 24,
+      archive_hint_cooldown_hours: 12,
+      review_hint_pending_count: 10,
+      review_hint_pending_age_days: 7,
+      maintenance_hint_days: 14,
+      maintenance_hint_cooldown_days: 7,
+      archive_edit_threshold: 20,
+      underseed_node_threshold: 10,
+      import_window_first_run_months: 60,
+      import_window_rerun_months: 2,
+      import_max_pending_per_run: 10,
+      import_max_commits_scan: 500,
+      import_skip_canonical_threshold: 50,
+      archive_max_candidates_per_batch: 8,
+      archive_max_recent_paths: 20,
+      archive_digest_max_sessions: 10,
+      review_topic_result_cap: 8,
+      review_stale_pending_days: 14
+    };
+    mkdirSync2(fabricDir, { recursive: true });
+    writeFileSync2(target, JSON.stringify(FABRIC_CONFIG_DEFAULTS, null, 2) + "\n", "utf8");
+  }
+  writeDefaultGitignore(fabricDir) {
+    const target = join5(fabricDir, ".gitignore");
+    if (existsSync4(target)) return;
+    const 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");
+    mkdirSync2(fabricDir, { recursive: true });
+    writeFileSync2(target, FABRIC_GITIGNORE_CONTENT, "utf8");
+  }
+  readFabricLanguagePreference(_projectRoot) {
+    return resolveGlobalLocale();
+  }
+};
+
+// src/install/pipeline/store.stage.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { initStore as initStore2, resolveGlobalLocale as resolveGlobalLocale2, storeRelativePathForMount as storeRelativePathForMount3 } from "@fenglimg/fabric-shared";
+import { isCancel, select, text } from "@clack/prompts";
+import { join as join6 } from "path";
+var StoreStage = class {
+  name = "store";
+  async execute(context) {
+    try {
+      const globalRoot = resolveGlobalRoot();
+      context.state.globalRoot = globalRoot;
+      if (context.options.planOnly === true) {
+        return stageSkipped("store", "dry-run: store setup planned without global/project writes");
+      }
+      const globalConfig = loadGlobalConfig(globalRoot);
+      const pickedLanguage = context.wizardEnabled && globalConfig?.language === void 0 ? await this.promptLanguage(globalRoot) : void 0;
+      if (globalConfig === null) {
+        const cloned = context.wizardEnabled ? await this.promptPersonalStoreOnboarding(globalRoot) : false;
+        if (!cloned) {
+          await runGlobalInstall({}, globalRoot);
+        }
+        context.state.globalConfigCreated = true;
+      } else {
+        await this.ensurePersonalStore(globalConfig, globalRoot);
+      }
+      this.persistLanguageSelection(globalRoot, pickedLanguage);
+      if (context.args.url) {
+        await this.bindRemoteStoreToProject(
+          context.target,
+          context.args.url,
+          globalRoot,
+          context.interactive
+        );
+        return stageRan("store", [context.args.url], []);
+      }
+      const installed = [];
+      const unboundStores = unboundAvailableStores(context.target);
+      if (!context.wizardEnabled) {
+        if (unboundStores.length > 0) {
+          this.warnUnboundStores(unboundStores);
+        }
+        return stageRan("store", installed, []);
+      }
+      const projectConfig = loadProjectConfig(context.target);
+      const hasWriteStore = typeof projectConfig?.active_write_store === "string" && projectConfig.active_write_store.length > 0;
+      if (hasWriteStore && unboundStores.length === 0) {
+        return stageRan("store", installed, []);
+      }
+      const outcome = await this.promptStoreSetup(context, unboundStores, globalRoot);
+      if (outcome !== null) {
+        installed.push(outcome);
+      }
+      return stageRan("store", installed, []);
+    } catch (error) {
+      return stageFailedFromError("store", error);
+    }
+  }
+  /**
+   * grill-6fixes (D1b): the install-time language selector, surfaced as the
+   * first interactive prompt of the install (see execute()). Returns the picked
+   * tone, or undefined on cancel (resolvers then keep falling back to env
+   * detection until the user picks via `fabric config`). The default
+   * pre-highlight follows the env-detected locale (Chinese shell → zh-CN).
+   * Persistence is deferred to persistLanguageSelection so the pick can be
+   * captured before the global config exists on a first-ever install.
+   */
+  async promptLanguage(globalRoot) {
+    const picked = await select({
+      message: t("cli.install.language.prompt"),
+      options: [
+        { value: "zh-CN", label: t("cli.install.language.option.zh-CN") },
+        { value: "en", label: t("cli.install.language.option.en") }
+      ],
+      initialValue: resolveGlobalLocale2(globalRoot)
+    });
+    if (isCancel(picked)) return void 0;
+    return picked;
+  }
+  /**
+   * Persist the language pick onto the (now-guaranteed) global config and
+   * refresh the process locale so the rest of THIS install run renders in the
+   * chosen tone. No-op when nothing was picked (non-wizard / already set /
+   * cancelled). refreshLocale() runs whenever a pick exists — even if the value
+   * already matched — so the module-level translator, bound to the env locale
+   * before the config carried `language`, picks up the persisted value.
+   */
+  persistLanguageSelection(globalRoot, picked) {
+    if (picked === void 0) return;
+    const config = loadGlobalConfig(globalRoot);
+    if (config !== null && config.language !== picked) {
+      saveGlobalConfig({ ...config, language: picked }, globalRoot);
+    }
+    refreshLocale();
+  }
+  /**
+   * Shared bind tail (DRY): resolve which project this repo binds to inside
+   * `alias` (git-suggested, silent in the common case), then run the ONE
+   * function that mints `project_id`, registers the project in the store, sets
+   * `active_project`, switches the write target, and writes the project
+   * write-route — `ensureStoreProjectBinding`. All three onboarding paths
+   * (join / create / bind-mounted) route through here so the project scope axis
+   * is wired identically; previously only the bind-mounted path did, leaving a
+   * fresh `install --url` / create flow with no `project_id` / `active_project`.
+   *
+   * Returns the resolved project id, or null when the user cancels the
+   * disambiguation prompt (interactive ambiguity only).
+   */
+  async bindStoreToProject(projectRoot, alias, globalRoot, options) {
+    const project = await this.resolveProjectIdWithGuard(
+      projectRoot,
+      alias,
+      globalRoot,
+      options.interactive
+    );
+    if (project === null) {
+      return null;
+    }
+    await ensureStoreProjectBinding(projectRoot, alias, {
+      globalRoot,
+      requestedProjectId: project,
+      ...options.suggestedRemote === void 0 ? {} : { suggestedRemote: options.suggestedRemote }
+    });
+    return project;
+  }
+  async bindRemoteStoreToProject(projectRoot, url, globalRoot, interactive) {
+    const already = storeList(globalRoot).find((store) => store.remote === url);
+    const mounted = already ?? mountStoreFromRemote(url, globalRoot);
+    const bound = await this.bindStoreToProject(projectRoot, mounted.alias, globalRoot, {
+      suggestedRemote: url,
+      interactive
+    });
+    if (bound === null) {
+      this.warnUnboundStores([{ alias: mounted.alias }]);
+      return mounted.alias;
+    }
+    console.log("");
+    console.log(paint.success(t("cli.install.store.bound-success", { alias: mounted.alias })));
+    return mounted.alias;
+  }
+  async bindCreatedStoreToProject(projectRoot, alias, options) {
+    await storeCreate(alias, (/* @__PURE__ */ new Date()).toISOString(), {
+      ...options.remote === void 0 ? {} : { remote: options.remote },
+      globalRoot: options.globalRoot
+    });
+    await this.bindStoreToProject(projectRoot, alias, options.globalRoot, {
+      ...options.remote === void 0 ? {} : { suggestedRemote: options.remote },
+      interactive: options.interactive
+    });
+    console.log("");
+    console.log(paint.success(t("cli.install.store.created-success", { alias })));
+    return alias;
+  }
+  /**
+   * Merged store-setup prompt (Q1/Q2 of the store-onboarding grill): ONE select
+   * whose top options are every mounted-but-unbound store (direct bind, zero
+   * clone), followed by join-from-remote / create-local / skip. Replaces the old
+   * `promptBindMountedStore` + `promptStoreOnboarding` pair — a mounted store can
+   * no longer be invisible in one prompt and then re-cloned in the next.
+   *
+   * Already-bound non-personal stores are surfaced as an info line above the
+   * prompt (pure visibility); the personal store is implicit and never listed.
+   * Returns an install marker (`bound:<alias>` / `created:<alias>`) or null on
+   * skip / cancel.
+   */
+  async promptStoreSetup(context, unboundStores, globalRoot) {
+    const boundAliases = this.boundStoreAliases(context.target, globalRoot);
+    if (boundAliases.length > 0) {
+      console.log(
+        paint.muted(
+          t("cli.install.store.setup.already-bound", {
+            aliases: boundAliases.map((a) => `'${a}'`).join(", ")
+          })
+        )
+      );
+    }
+    const JOIN = "__join__";
+    const CREATE = "__create__";
+    const SKIP = "skip";
+    const choice = await select({
+      message: t("cli.install.store.setup.prompt"),
+      initialValue: unboundStores.length > 0 ? `bind:${unboundStores[0].alias}` : SKIP,
+      options: [
+        ...unboundStores.map((store) => ({
+          value: `bind:${store.alias}`,
+          label: t("cli.install.store.setup.bind-label", { alias: store.alias }),
+          hint: store.remote ?? t("cli.install.store.local-store")
+        })),
+        {
+          value: JOIN,
+          label: t("cli.install.store.onboard.join-label"),
+          hint: t("cli.install.store.onboard.join-hint")
+        },
+        {
+          value: CREATE,
+          label: t("cli.install.store.onboard.create-label"),
+          hint: t("cli.install.store.onboard.create-hint")
+        },
+        {
+          value: SKIP,
+          label: t("cli.install.store.skip-label"),
+          hint: t("cli.install.store.onboard.skip-hint")
+        }
+      ]
+    });
+    if (isCancel(choice) || choice === SKIP || typeof choice !== "string") {
+      if (unboundStores.length > 0) {
+        this.warnUnboundStores(unboundStores);
+      }
+      return null;
+    }
+    if (choice.startsWith("bind:")) {
+      const alias2 = choice.slice("bind:".length);
+      const bound = await this.bindStoreToProject(context.target, alias2, globalRoot, {
+        interactive: true
+      });
+      if (bound === null) {
+        this.warnUnboundStores(unboundStores);
+        return null;
+      }
+      console.log("");
+      console.log(paint.success(t("cli.install.store.bound-success", { alias: alias2 })));
+      return `bound:${alias2}`;
+    }
+    if (choice === JOIN) {
+      const url = await text({
+        message: t("cli.install.store.onboard.join-url"),
+        placeholder: "git@github.com:org/knowledge.git"
+      });
+      if (isCancel(url) || typeof url !== "string" || url.length === 0) {
+        return null;
+      }
+      return `bound:${await this.bindRemoteStoreToProject(context.target, url, globalRoot, true)}`;
+    }
+    const alias = await text({ message: t("cli.install.store.onboard.alias"), initialValue: "team" });
+    if (isCancel(alias) || typeof alias !== "string" || alias.length === 0) {
+      return null;
+    }
+    const remote = await text({
+      message: t("cli.install.store.onboard.remote"),
+      placeholder: "git@github.com:org/knowledge.git"
+    });
+    const remoteStr = !isCancel(remote) && typeof remote === "string" && remote.length > 0 ? remote : void 0;
+    return `created:${await this.bindCreatedStoreToProject(
+      context.target,
+      alias,
+      remoteStr === void 0 ? { globalRoot, interactive: true } : { remote: remoteStr, globalRoot, interactive: true }
+    )}`;
+  }
+  /**
+   * The project's already-bound non-personal store aliases (Q2 visibility line).
+   * Reads `required_stores` from the project config and keeps only those still
+   * mounted as non-personal stores in the global registry.
+   */
+  boundStoreAliases(projectRoot, globalRoot) {
+    const declared = loadProjectConfig(projectRoot)?.required_stores ?? [];
+    if (declared.length === 0) {
+      return [];
+    }
+    const mounted = new Map(
+      storeList(globalRoot).filter((s) => s.personal !== true).flatMap((s) => [
+        [s.alias, s.alias],
+        [s.store_uuid, s.alias]
+      ])
+    );
+    const aliases = /* @__PURE__ */ new Set();
+    for (const entry of declared) {
+      const alias = mounted.get(entry.id);
+      if (alias !== void 0) {
+        aliases.add(alias);
+      }
+    }
+    return [...aliases];
+  }
+  /**
+   * grill-6fixes (D6): pick which project this repo binds to inside `alias`.
+   * Default is the git-repo-derived id, applied SILENTLY in the common case
+   * (the store has no projects yet, or the git id already matches an existing
+   * one). The user is asked ONLY on genuine ambiguity — the store already
+   * enumerates projects AND the git id matches none of them — the one case
+   * where silently auto-creating would fork a parallel project away from the
+   * team's existing one. Returns the resolved project id, or null on cancel.
+   *
+   * `interactive` gates the disambiguation prompt: non-interactive flows (e.g.
+   * `install --url` in CI) never block — they fall back to the deterministic
+   * git-suggested id instead of stalling on a clack prompt with no TTY.
+   */
+  async resolveProjectIdWithGuard(projectRoot, alias, globalRoot, interactive) {
+    const suggested = suggestStoreProjectId(projectRoot);
+    const existing = await storeProjectList(alias, globalRoot);
+    if (existing.length === 0 || existing.some((project) => project.id === suggested)) {
+      return suggested;
+    }
+    if (!interactive) {
+      return suggested;
+    }
+    const NEW_PROJECT = "__new_project__";
+    const picked = await select({
+      message: t("cli.install.store.project-pick.prompt", { store: alias }),
+      initialValue: NEW_PROJECT,
+      options: [
+        ...existing.map((project) => ({
+          value: project.id,
+          label: t("cli.install.store.project-pick.join", {
+            name: project.name ?? project.id,
+            id: project.id
+          })
+        })),
+        { value: NEW_PROJECT, label: t("cli.install.store.project-pick.new", { id: suggested }) }
+      ]
+    });
+    if (isCancel(picked)) return null;
+    if (picked !== NEW_PROJECT) return picked;
+    const entered = await text({
+      message: t("cli.install.store.project-pick.new-name"),
+      initialValue: suggested
+    });
+    if (isCancel(entered) || typeof entered !== "string" || entered.length === 0) {
+      return null;
+    }
+    return normalizeStoreProjectId(entered);
+  }
+  warnUnboundStores(unboundStores) {
+    console.log("");
+    console.log(
+      t("cli.install.store.unbound-note", {
+        aliases: unboundStores.map((s) => `'${s.alias}'`).join(", ")
+      })
+    );
+    console.log(t("cli.install.store.unbound-hint", { first: unboundStores[0].alias }));
+  }
+  /**
+   * C4: first-touch personal-store onboarding. Offers "create local (default)"
+   * vs "clone existing from a remote". Returns true only when it cloned a
+   * personal store AND wrote the global config (so the caller skips the fresh
+   * mint). Default / cancel / clone-failure all return false → caller mints
+   * fresh via runGlobalInstall. Never adds a keystroke to the non-interactive
+   * path (only invoked when wizardEnabled).
+   */
+  async promptPersonalStoreOnboarding(globalRoot) {
+    const choice = await select({
+      message: t("cli.install.store.personal.prompt"),
+      initialValue: "new",
+      options: [
+        {
+          value: "new",
+          label: t("cli.install.store.personal.new-label"),
+          hint: t("cli.install.store.personal.new-hint")
+        },
+        {
+          value: "clone",
+          label: t("cli.install.store.personal.clone-label"),
+          hint: t("cli.install.store.personal.clone-hint")
+        }
+      ]
+    });
+    if (isCancel(choice) || choice !== "clone") {
+      return false;
+    }
+    const url = await text({
+      message: t("cli.install.store.personal.clone-url"),
+      placeholder: "git@github.com:you/fabric-personal.git"
+    });
+    if (isCancel(url) || typeof url !== "string" || url.length === 0) {
+      return false;
+    }
+    try {
+      const { store_uuid } = cloneGlobalPersonalFromRemote(url, globalRoot);
+      console.log("");
+      console.log(paint.success(t("cli.install.store.personal.cloned-success", { uuid: store_uuid })));
+      return true;
+    } catch (error) {
+      console.log(
+        paint.warn(
+          t("cli.install.store.personal.clone-failed", {
+            reason: error instanceof Error ? error.message : String(error)
+          })
+        )
+      );
+      return false;
+    }
+  }
+  async ensurePersonalStore(config, globalRoot) {
+    const personalAlias = config.stores.find((store) => store.alias === "personal");
+    if (personalAlias === void 0) {
+      const uuid = randomUUID2();
+      const mounted = { store_uuid: uuid, alias: "personal", mount_name: "personal", personal: true };
+      await initStore2(
+        join6(globalRoot, storeRelativePathForMount3(mounted)),
+        { store_uuid: uuid, created_at: (/* @__PURE__ */ new Date()).toISOString(), canonical_alias: "personal" }
+      );
+      saveGlobalConfig({ ...config, stores: [mounted, ...config.stores] }, globalRoot);
+      return;
+    }
+    const nextStores = config.stores.map((store) => ({
+      ...store,
+      ...store.alias === "personal" ? { personal: true } : { personal: false }
+    }));
+    if (JSON.stringify(nextStores) !== JSON.stringify(config.stores)) {
+      saveGlobalConfig({ ...config, stores: nextStores }, globalRoot);
+    }
+  }
+};
+
+// src/install/hooks-orchestrator.ts
+import { existsSync as existsSync5, statSync as statSync4 } from "fs";
+import { isAbsolute as isAbsolute3, join as join7, resolve as resolve3 } from "path";
+function validateHookPaths(projectRoot) {
+  const scripts = [
+    { stepSuffix: "", hookFile: "fabric-hint.cjs" },
+    { stepSuffix: "-broad", hookFile: "knowledge-hint-broad.cjs" },
+    { stepSuffix: "-narrow", hookFile: "knowledge-hint-narrow.cjs" },
+    // lifecycle-refactor W2-T2/T3: SessionEnd + PostToolUse marker hooks.
+    { stepSuffix: "-session-end", hookFile: "session-end-marker.cjs" },
+    { stepSuffix: "-post-tooluse", hookFile: "post-tooluse-mutation.cjs" }
+  ];
+  const clients = [
+    {
+      client: "claude",
+      configRel: join7(".claude", "settings.json"),
+      hookDir: join7(".claude", "hooks")
+    },
+    {
+      client: "codex",
+      configRel: join7(".codex", "hooks.json"),
+      hookDir: join7(".codex", "hooks")
+    }
+  ];
+  const results = [];
+  for (const { client, configRel, hookDir } of clients) {
+    const configPath = resolve3(projectRoot, configRel);
+    if (!existsSync5(configPath)) {
+      results.push({
+        step: `hook-validate-${client}`,
+        path: configPath,
+        status: "skipped",
+        message: "missing-config"
+      });
+      continue;
+    }
+    for (const { stepSuffix, hookFile } of scripts) {
+      const expectedHookPath = resolve3(projectRoot, hookDir, hookFile);
+      const expectedHookRel = join7(hookDir, hookFile);
+      const step = `hook-validate-${client}${stepSuffix}`;
+      if (!existsSync5(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;
+}
+
+// src/install/pipeline/hooks.stage.ts
+var HooksStage = class {
+  name = "hooks";
+  async execute(context) {
+    if (context.options.skipHooks) {
+      return stageSkipped("hooks", "skipped via --skipHooks");
+    }
+    if (context.options.planOnly === true) {
+      return stageSkipped("hooks", "dry-run: hook and skill install planned without writing files");
+    }
+    try {
+      const target = context.target;
+      const installResults = [];
+      installResults.push(...await this.runBestEffort("skill-deprecated-cleanup", () => cleanupDeprecatedSkills(target)));
+      installResults.push(...await this.runBestEffort("skill-router-install", () => installFabricRouterSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-install", () => installFabricArchiveSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-review-install", () => installFabricReviewSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-import-install", () => installFabricImportSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-sync-install", () => installFabricSyncSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-store-install", () => installFabricStoreSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-audit-install", () => installFabricAuditSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-connect-install", () => installFabricConnectSkill(target)));
+      installResults.push(...await this.runBestEffort("skill-shared-lib", () => installSharedSkillLib(target)));
+      installResults.push(...await this.runBestEffort("hook-script", () => installArchiveHintHook(target)));
+      installResults.push(...await this.runBestEffort("hook-broad-script", () => installKnowledgeHintBroadHook(target)));
+      installResults.push(...await this.runBestEffort("hook-narrow-script", () => installKnowledgeHintNarrowHook(target)));
+      installResults.push(...await this.runBestEffort("hook-cite-policy-evict-script", () => installCitePolicyEvictHook(target)));
+      installResults.push(...await this.runBestEffort("hook-session-end-script", () => installSessionEndMarkerHook(target)));
+      installResults.push(...await this.runBestEffort("hook-post-tooluse-script", () => installPostTooluseMutationHook(target)));
+      installResults.push(...await this.runBestEffort("hook-lib", () => installHookLibs(target)));
+      installResults.push(await this.runSingleStep("claude-hook-config", () => mergeClaudeCodeHookConfig(target)));
+      installResults.push(await this.runSingleStep("codex-hook-config", () => mergeCodexHookConfig(target)));
+      installResults.push(await this.runSingleStep("bootstrap-snapshot", () => writeFabricAgentsSnapshot(target)));
+      installResults.push(await this.runSingleStep("bootstrap-claude", () => writeClaudeBootstrapThinShell(target)));
+      installResults.push(await this.runSingleStep("bootstrap-codex", () => writeCodexBootstrapManagedBlock(target)));
+      installResults.push(...validateHookPaths(target));
+      for (const result of installResults) {
+        if (result.status === "error") {
+          process.stderr.write(`hooks ${result.step} ${result.path}: ${result.message ?? "unknown error"}
+`);
+        }
+      }
+      const installed = installResults.filter((r) => r.status === "written").map((r) => r.path);
+      const skipped = installResults.filter((r) => r.status === "skipped").map((r) => r.path);
+      const errors = installResults.filter((r) => r.status === "error").map((r) => `${r.step}: ${r.message}`);
+      console.log(this.formatStageHeader(t("cli.install.stages.hooks")));
+      if (errors.length > 0) {
+        console.log(this.formatStageResult("hooks", "failed", installed.length, skipped.length));
+        return {
+          ...stageFailed("hooks", errors),
+          installed,
+          skipped,
+          payload: { installResults }
+        };
+      }
+      console.log(this.formatStageResult("hooks", "completed", installed.length, skipped.length));
+      return stageRan("hooks", installed, skipped);
+    } catch (error) {
+      return stageFailedFromError("hooks", error);
+    }
+  }
+  async runBestEffort(step, fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      return [
+        {
+          step,
+          path: "",
+          status: "error",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ];
+    }
+  }
+  async runSingleStep(step, fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      return {
+        step,
+        path: "",
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  formatStageHeader(message) {
+    const nextLabel = () => paint.ai(t("cli.shared.next"));
+    return `${nextLabel()} ${paint.muted(message)}`;
+  }
+  formatStageResult(stage, status, installedCount, skippedCount) {
+    const completedStageLabel = () => status === "failed" ? paint.error("failed") : paint.success(t("cli.install.stages.completed"));
+    const counts = `installed=${installedCount} skipped=${skippedCount}`;
+    return `${completedStageLabel()} ${stage}: ${counts}`;
+  }
+};
+
+// src/install/pipeline/mcp.stage.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { join as join9 } from "path";
+
+// src/lib/package-manager.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join8, resolve as resolve4 } from "path";
+function detectPackageManager(cwd) {
+  const workspaceRoot = resolve4(cwd);
+  if (existsSync6(join8(workspaceRoot, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync6(join8(workspaceRoot, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (existsSync6(join8(workspaceRoot, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+}
+
+// src/install/pipeline/mcp.stage.ts
+var LOCAL_FABRIC_SERVER_PATH = join9("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
+var McpStage = class {
+  name = "mcp";
+  async execute(context) {
+    if (context.options.skipMcp) {
+      return stageSkipped("mcp", "skipped via --skipMcp");
+    }
+    if (context.options.planOnly === true) {
+      return stageSkipped("mcp", "dry-run: MCP config install planned without writing files");
+    }
+    try {
+      const target = context.target;
+      const mode = context.mcpInstallMode;
+      console.log(this.formatStageHeader(t("cli.install.stages.mcp")));
+      if (mode === "local") {
+        const manager = detectPackageManager(target);
+        process.stderr.write(`${t("cli.install.mcp.install.local")}
+`);
+        process.stderr.write(`${t("cli.install.mcp.local.installing", { manager })}
+`);
+        this.installLocalFabricServer(target, manager);
+        process.stderr.write(`${t("cli.install.mcp.local.installed")}
+`);
+      } else {
+        process.stderr.write(`${t("cli.install.mcp.install.global")}
+`);
+      }
+      const result = await installMcpClients(target, {
+        localServerPath: mode === "local" ? LOCAL_FABRIC_SERVER_PATH : void 0,
+        claudeMcpScope: context.claudeMcpScope
+      });
+      if (result.details.length === 0) {
+        console.log(this.formatStageResult("mcp", "skipped", 0, 0, t("cli.config.install.no-configs")));
+        return stageSkipped("mcp", "no MCP configs to install");
+      }
+      console.log(this.formatStageResult("mcp", "completed", result.installed.length, result.skipped.length));
+      return stageRan("mcp", result.installed, result.skipped);
+    } catch (error) {
+      return stageFailedFromError("mcp", error);
+    }
+  }
+  installLocalFabricServer(target, manager) {
+    const installArgs = manager === "npm" ? ["install", "-D", FABRIC_SERVER_PACKAGE] : ["add", "-D", FABRIC_SERVER_PACKAGE];
+    execFileSync5(manager, installArgs, {
+      cwd: target,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+  }
+  formatStageHeader(message) {
+    const nextLabel = () => paint.ai(t("cli.shared.next"));
+    return `${nextLabel()} ${paint.muted(message)}`;
+  }
+  formatStageResult(stage, status, installedCount, skippedCount, note) {
+    const completedStageLabel = () => paint.success(t("cli.install.stages.completed"));
+    const skippedStageLabel = () => paint.muted(t("cli.install.stages.skipped"));
+    const label = status === "completed" ? completedStageLabel() : skippedStageLabel();
+    const counts = `installed=${installedCount} skipped=${skippedCount}`;
+    const suffix = note ? ` ${paint.muted(`(${note})`)}` : "";
+    return `${label} ${stage}: ${counts}${suffix}`;
+  }
+};
+
+// src/install/pipeline/validate.stage.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join10 } from "path";
+var ValidateStage = class {
+  name = "validate";
+  async execute(context) {
+    if (context.options.planOnly === true) {
+      return stageSkipped("validate", "dry-run: validation skipped because no files were written");
+    }
+    try {
+      const target = context.target;
+      const errors = [];
+      const installed = [];
+      const skipped = [];
+      const hookValidationResults = validateHookPaths(target);
+      for (const result of hookValidationResults) {
+        if (result.status === "error") {
+          errors.push(`${result.step}: ${result.message}`);
+        } else {
+          skipped.push(result.path);
+        }
+      }
+      const fabricDir = join10(target, ".fabric");
+      if (!existsSync7(fabricDir)) {
+        errors.push(".fabric directory missing");
+      } else {
+        installed.push(fabricDir);
+      }
+      const configPath = join10(fabricDir, "fabric-config.json");
+      if (!existsSync7(configPath)) {
+        errors.push("fabric-config.json missing");
+      } else {
+        installed.push(configPath);
+      }
+      const eventsPath = join10(fabricDir, "events.jsonl");
+      if (!existsSync7(eventsPath)) {
+        errors.push("events.jsonl missing");
+      } else {
+        installed.push(eventsPath);
+      }
+      if (errors.length === 0) {
+        console.log(paint.success("Validation passed"));
+      } else {
+        console.log(paint.error(`Validation failed: ${errors.length} error(s)`));
+        for (const error of errors) {
+          console.log(paint.error(`  - ${error}`));
+        }
+      }
+      if (errors.length > 0) {
+        return stageFailedFromError("validate", new Error(errors.join("; ")));
+      }
+      return stageRan("validate", installed, skipped);
+    } catch (error) {
+      return stageFailedFromError("validate", error);
+    }
+  }
+};
+
+// src/install/pipeline/guidance.stage.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import { confirm, isCancel as isCancel2 } from "@clack/prompts";
+
+// src/install/semantic-search.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join11 } from "path";
+var DEFAULT_EMBED_MODEL_PIN = "fast-bge-small-zh-v1.5";
+function enableSemanticSearch(projectRoot, opts = {}) {
+  const model = typeof opts.model === "string" && opts.model.length > 0 ? opts.model : DEFAULT_EMBED_MODEL_PIN;
+  const configPath = join11(projectRoot, ".fabric", "fabric-config.json");
+  let existing = {};
+  if (existsSync8(configPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync2(configPath, "utf8"));
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    } catch {
+      existing = {};
+    }
+  }
+  const alreadyEnabled = existing.embed_enabled === true && existing.embed_model === model;
+  if (alreadyEnabled) {
+    return { configPath, model, alreadyEnabled: true, changed: false };
+  }
+  const merged = { ...existing, embed_enabled: true, embed_model: model };
+  mkdirSync3(dirname3(configPath), { recursive: true });
+  writeFileSync3(configPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  return { configPath, model, alreadyEnabled: false, changed: true };
+}
+function renderSemanticSearchInstructions(model) {
+  return [
+    t("cli.install.semantic.enabled", { model }),
+    ...t("cli.install.semantic.manual-steps").split("\n")
+  ];
+}
+
+// src/install/pipeline/guidance.stage.ts
+var GuidanceStage = class {
+  name = "guidance";
+  async execute(context) {
+    try {
+      const translate = context.translate ?? t;
+      if (context.options.planOnly) {
+        return stageRan("guidance", [], []);
+      }
+      if (context.args["enable-embed"]) {
+        this.enableSemanticSearchAndReport(context.target, context.args["embed-model"]);
+      } else if (context.wizardEnabled) {
+        await this.promptSemanticSearch(context.target);
+      }
+      console.log("");
+      console.log(translate("cli.install.next-steps"));
+      console.log("");
+      console.log(paint.muted("More: docs/surfaces.md explains when to use CLI vs Skill vs MCP."));
+      console.log("");
+      console.log(translate("cli.install.restart-banner"));
+      const finalSupports = detectClientSupports(context.target);
+      this.printCapabilitySummary(finalSupports, context);
+      return stageRan("guidance", [], []);
+    } catch (error) {
+      return stageFailedFromError("guidance", error);
+    }
+  }
+  enableSemanticSearchAndReport(projectRoot, model) {
+    const enabled = enableSemanticSearch(projectRoot, model === void 0 ? {} : { model });
+    console.log("");
+    if (enabled.alreadyEnabled) {
+      console.log(
+        paint.muted(t("cli.install.semantic.already-enabled", { model: enabled.model, path: enabled.configPath }))
+      );
+      return;
+    }
+    for (const line of renderSemanticSearchInstructions(enabled.model)) {
+      console.log(line);
+    }
+  }
+  async promptSemanticSearch(projectRoot) {
+    const enable = await confirm({
+      message: t("cli.install.semantic.prompt"),
+      initialValue: false
+    });
+    if (isCancel2(enable) || !enable) {
+      return;
+    }
+    const enabled = enableSemanticSearch(projectRoot);
+    console.log("");
+    if (enabled.alreadyEnabled) {
+      console.log(
+        paint.muted(t("cli.install.semantic.already-enabled", { model: enabled.model, path: enabled.configPath }))
+      );
+      return;
+    }
+    console.log(t("cli.install.semantic.enabled", { model: enabled.model }));
+    await this.offerInstallFastembed();
+  }
+  async offerInstallFastembed() {
+    const proceed = await confirm({
+      message: t("cli.install.semantic.offer-install"),
+      initialValue: true
+    });
+    if (isCancel2(proceed) || !proceed) {
+      this.printSemanticManualSteps();
+      return;
+    }
+    console.log(t("cli.install.semantic.installing"));
+    try {
+      execFileSync6("npm", ["i", "-g", "fastembed"], { stdio: ["ignore", "inherit", "inherit"] });
+      console.log(paint.success(t("cli.install.semantic.installed")));
+    } catch (error) {
+      console.log(
+        paint.warn(
+          t("cli.install.semantic.install-failed", {
+            reason: error instanceof Error ? error.message : String(error)
+          })
+        )
+      );
+      this.printSemanticManualSteps();
+    }
+  }
+  printSemanticManualSteps() {
+    for (const line of t("cli.install.semantic.manual-steps").split("\n")) {
+      console.log(line);
+    }
+  }
+  printCapabilitySummary(supports, context) {
+    const detected = supports.filter((s) => s.detected);
+    if (detected.length === 0) {
+      console.log(t("cli.install.capabilities.none"));
+      return;
+    }
+    console.log(t("cli.install.capabilities.title"));
+    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(6, ...detected.map((s) => s.label.length)),
+      bootstrap: Math.max(8, 8),
+      mcp: Math.max(3, 3),
+      hook: Math.max(4, 4),
+      skill: Math.max(5, 5),
+      followUp: Math.max(9, 9)
+    };
+    const headerRow = [
+      headers.client.padEnd(widths.client),
+      headers.bootstrap.padEnd(widths.bootstrap),
+      headers.mcp.padEnd(widths.mcp),
+      headers.hook.padEnd(widths.hook),
+      headers.skill.padEnd(widths.skill),
+      headers.followUp.padEnd(widths.followUp)
+    ].join("  ");
+    console.log(headerRow);
+    const divider = [
+      "".padEnd(widths.client, "-"),
+      "".padEnd(widths.bootstrap, "-"),
+      "".padEnd(widths.mcp, "-"),
+      "".padEnd(widths.hook, "-"),
+      "".padEnd(widths.skill, "-"),
+      "".padEnd(widths.followUp, "-")
+    ].join("  ");
+    console.log(divider);
+    for (const support of detected) {
+      const bootstrap = support.capabilities.bootstrap ? this.capabilityStatus(context.options.skipBootstrap ? "skipped" : "ran") : t("cli.install.capabilities.status.na");
+      const mcp = support.capabilities.mcp ? this.capabilityStatus(context.options.skipMcp ? "skipped" : "ran") : t("cli.install.capabilities.status.na");
+      const hook = this.capabilityInstallStatus(support, "hook");
+      const skill = this.capabilityInstallStatus(support, "skill");
+      const followUp = this.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");
+      const row = [
+        support.label.padEnd(widths.client),
+        bootstrap.padEnd(widths.bootstrap),
+        mcp.padEnd(widths.mcp),
+        hook.padEnd(widths.hook),
+        skill.padEnd(widths.skill),
+        followUp.padEnd(widths.followUp)
+      ].join("  ");
+      console.log(row);
+    }
+  }
+  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");
+    }
+  }
+  capabilityInstallStatus(support, capability) {
+    if (!support.capabilities[capability]) {
+      return t("cli.install.capabilities.status.na");
+    }
+    return this.hasInstalledCapability(support, capability) ? t("cli.install.capabilities.status.installed") : t("cli.install.capabilities.status.supported");
+  }
+  hasInstalledCapability(support, capability) {
+    return support.installedCapabilities?.[capability] === true;
+  }
+};
+
+// src/tui/StepCounter.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var statusColors = {
+  pending: "gray",
+  running: "cyan",
+  success: "green",
+  error: "red",
+  skipped: "yellow"
+};
+var statusSymbols = {
+  pending: "\u25CB",
+  running: "\u25CF",
+  success: "\u2713",
+  error: "\u2717",
+  skipped: "\u25CB"
+};
+function StepCounter({
+  current,
+  total,
+  label,
+  status = "running"
+}) {
+  const color = statusColors[status] || "cyan";
+  const symbol = statusSymbols[status] || "\u25CF";
+  return /* @__PURE__ */ jsxs(Box, { gap: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color, bold: true, children: symbol }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "(",
+      current,
+      "/",
+      total,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsx(Text, { bold: true, children: label })
+  ] });
+}
+
+// src/tui/StatusMessage.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var typeColors = {
+  success: "green",
+  error: "red",
+  warning: "yellow",
+  info: "blue"
+};
+var typeLabels = {
+  success: "\u2713",
+  error: "\u2717",
+  warning: "!",
+  info: "\u2139"
+};
+function StatusMessage({
+  message,
+  type,
+  timestamp = false
+}) {
+  const color = typeColors[type] || "white";
+  const label = typeLabels[type] || "\u2022";
+  const timeStr = timestamp ? `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] ` : "";
+  return /* @__PURE__ */ jsxs2(Box2, { gap: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color, bold: true, children: label }),
+    timestamp && /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: timeStr }),
+    /* @__PURE__ */ jsx2(Text2, { color: type === "error" ? "red" : void 0, children: message })
+  ] });
+}
+
+// src/tui/SummaryCard.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function DetailStatus({ status }) {
+  if (!status) return null;
+  const indicators = {
+    success: { symbol: "\u2713", color: "green" },
+    error: { symbol: "\u2717", color: "red" },
+    skipped: { symbol: "\u25CB", color: "yellow" },
+    info: { symbol: "\u2139", color: "blue" }
+  };
+  const { symbol, color } = indicators[status] || { symbol: "\u2022", color: "white" };
+  return /* @__PURE__ */ jsx3(Text3, { color, bold: true, children: symbol });
+}
+function SummaryCard({ summary }) {
+  const { title, successCount, skippedCount = 0, errorCount = 0, details = [] } = summary;
+  const totalCount = successCount + skippedCount + errorCount;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: [
+    /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: "cyan", children: title }) }),
+    /* @__PURE__ */ jsxs3(Box3, { gap: 3, children: [
+      successCount > 0 && /* @__PURE__ */ jsxs3(Box3, { gap: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "green", bold: true, children: "\u2713" }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          successCount,
+          " succeeded"
+        ] })
+      ] }),
+      skippedCount > 0 && /* @__PURE__ */ jsxs3(Box3, { gap: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "yellow", bold: true, children: "\u25CB" }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          skippedCount,
+          " skipped"
+        ] })
+      ] }),
+      errorCount > 0 && /* @__PURE__ */ jsxs3(Box3, { gap: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "red", bold: true, children: "\u2717" }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          errorCount,
+          " failed"
+        ] })
+      ] })
+    ] }),
+    details.length > 0 && /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", marginTop: 1, children: details.map((detail, index) => /* @__PURE__ */ jsxs3(Box3, { gap: 1, children: [
+      /* @__PURE__ */ jsx3(DetailStatus, { status: detail.status }),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        detail.label,
+        ":"
+      ] }),
+      /* @__PURE__ */ jsx3(Text3, { children: detail.value })
+    ] }, index)) }),
+    /* @__PURE__ */ jsx3(Box3, { marginTop: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: totalCount === successCount ? "All steps completed successfully" : errorCount > 0 ? `${errorCount} step${errorCount > 1 ? "s" : ""} failed` : `${successCount}/${totalCount} steps completed` }) })
+  ] });
+}
+
+// src/tui/ErrorBox.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ErrorBox({ error, showStack = false }) {
+  const title = error.title || "Error";
+  const code = "code" in error ? error.code : void 0;
+  const hint = "hint" in error ? error.hint : void 0;
+  const stack = "stack" in error ? error.stack : void 0;
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "red",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsxs4(Box4, { gap: 1, children: [
+          /* @__PURE__ */ jsxs4(Text4, { color: "red", bold: true, children: [
+            "\u2717 ",
+            title
+          ] }),
+          code && /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+            "(",
+            code,
+            ")"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "red", children: error.message }) }),
+        hint && /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "\u{1F4A1} ",
+          hint
+        ] }) }),
+        showStack && stack && /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Stack trace:" }),
+          /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, color: "gray", children: stack.split("\n").slice(0, 5).join("\n") }) })
+        ] })
+      ]
+    }
+  );
+}
+function toErrorInfo(error) {
+  if ("title" in error) {
+    return error;
+  }
+  return {
+    title: error.name || "Error",
+    message: error.message,
+    stack: error.stack
+  };
+}
+
+// src/tui/Spinner.tsx
+import { useState, useEffect } from "react";
+import { Text as Text5 } from "ink";
+import { jsxs as jsxs5 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function Spinner({ label }) {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setFrame((prev) => (prev + 1) % FRAMES.length);
+    }, 80);
+    return () => clearInterval(timer);
+  }, []);
+  return /* @__PURE__ */ jsxs5(Text5, { color: "cyan", children: [
+    FRAMES[frame],
+    " ",
+    label || "Loading..."
+  ] });
+}
+
+// src/tui/ProgressBar.tsx
+import { Box as Box5, Text as Text6 } from "ink";
+import { jsx as jsx5, jsxs as jsxs6 } from "react/jsx-runtime";
+
+// src/tui/SectionHeader.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx6, jsxs as jsxs7 } from "react/jsx-runtime";
+function SectionHeader({ title, subtitle }) {
+  return /* @__PURE__ */ jsxs7(Box6, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx6(Box6, { borderStyle: "classic", borderColor: "gray", children: /* @__PURE__ */ jsx6(Box6, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text7, { bold: true, color: "cyan", children: title }) }) }),
+    subtitle && /* @__PURE__ */ jsx6(Box6, { marginLeft: 2, children: /* @__PURE__ */ jsx6(Text7, { dimColor: true, children: subtitle }) })
+  ] });
+}
+
+// src/tui/StoreWizard.tsx
+import { useState as useState2 } from "react";
+import { Box as Box7, Text as Text8, useInput } from "ink";
+import { jsx as jsx7, jsxs as jsxs8 } from "react/jsx-runtime";
+
+// src/tui/InputField.tsx
+import { useState as useState3 } from "react";
+import { Box as Box8, Text as Text9, useInput as useInput2, useApp } from "ink";
+import { jsx as jsx8, jsxs as jsxs9 } from "react/jsx-runtime";
+
+// src/tui/StoreWizardFlow.tsx
+import { useState as useState4, useCallback } from "react";
+import { render } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+
+// src/tui/InkOutputRenderer.ts
+import { render as render2 } from "ink";
+import React2 from "react";
+var InkOutputRenderer = class {
+  config;
+  currentStep = null;
+  inkInstances = [];
+  constructor(config = {}) {
+    this.config = {
+      colors: true,
+      verbose: false,
+      timestamps: false,
+      ...config
+    };
+  }
+  /**
+   * Render a React component and wait for it to render
+   */
+  renderComponent(node) {
+    const { unmount } = render2(node);
+    this.inkInstances.push({ unmount });
+  }
+  /**
+   * Render a step progress indicator
+   */
+  renderStep(step) {
+    this.currentStep = step;
+    if (step.status === "running") {
+      this.renderComponent(
+        React2.createElement(Spinner, { label: step.name })
+      );
+    } else {
+      this.renderComponent(
+        React2.createElement(StepCounter, {
+          current: step.current,
+          total: step.total,
+          label: step.name,
+          status: step.status
+        })
+      );
+    }
+    if (step.detail) {
+      this.renderComponent(
+        React2.createElement(StatusMessage, {
+          message: step.detail,
+          type: step.status === "error" ? "error" : "info"
+        })
+      );
+    }
+  }
+  /**
+   * Render a success message
+   */
+  renderSuccess(message) {
+    this.renderComponent(
+      React2.createElement(StatusMessage, {
+        message,
+        type: "success"
+      })
+    );
+  }
+  /**
+   * Render an error
+   */
+  renderError(error) {
+    const errorInfo = error instanceof Error ? toErrorInfo(error) : error;
+    this.renderComponent(
+      React2.createElement(ErrorBox, {
+        error: errorInfo,
+        showStack: this.config.verbose
+      })
+    );
+  }
+  /**
+   * Render a warning message
+   */
+  renderWarning(message) {
+    this.renderComponent(
+      React2.createElement(StatusMessage, {
+        message,
+        type: "warning"
+      })
+    );
+  }
+  /**
+   * Render an info message
+   */
+  renderInfo(message) {
+    this.renderComponent(
+      React2.createElement(StatusMessage, {
+        message,
+        type: "info"
+      })
+    );
+  }
+  /**
+   * Render a summary card
+   */
+  renderSummaryCard(summary) {
+    this.renderComponent(
+      React2.createElement(SummaryCard, { summary })
+    );
+  }
+  /**
+   * Render a section header
+   */
+  renderSection(title) {
+    this.renderComponent(
+      React2.createElement(SectionHeader, { title })
+    );
+  }
+  /**
+   * Render a final completion message
+   */
+  renderComplete() {
+    this.renderComponent(
+      React2.createElement(StatusMessage, {
+        message: "Done!",
+        type: "success"
+      })
+    );
+  }
+  /**
+   * Clean up any pending renders
+   */
+  async cleanup() {
+    for (const instance of this.inkInstances) {
+      try {
+        instance.unmount();
+      } catch {
+      }
+    }
+    this.inkInstances = [];
+  }
+};
+function createInkRenderer(config) {
+  return new InkOutputRenderer(config);
+}
+
+// src/commands/install-v2.ts
+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
+    },
+    global: {
+      type: "boolean",
+      description: "Set up global Fabric (~/.fabric: uid + personal store + config)",
+      default: false
+    },
+    url: {
+      type: "string",
+      description: "Clone + mount a shared store remote. In a project install: also binds it to this project and sets it as the write target. With --global: mounts it machine-wide only."
+    },
+    "enable-embed": {
+      type: "boolean",
+      description: t("cli.install.args.enable-embed.description"),
+      default: false
+    },
+    "embed-model": {
+      type: "string",
+      description: t("cli.install.args.embed-model.description")
+    }
+  },
+  async run({ args }) {
+    await runInitCommand(args);
+  }
+});
+var install_v2_default = installCommand;
+async function runInitCommand(args) {
+  const logger = createDebugLogger(args.debug);
+  if (args.global === true) {
+    if (args["dry-run"] === true) {
+      console.log("Fabric install dry run: no global files will be written.");
+      console.log("Planned: ensure global Fabric config and personal store exist.");
+      if (args.url !== void 0) {
+        console.log(`Planned: clone and mount store from ${args.url}.`);
+      }
+      return;
+    }
+    await runGlobalInstall({ url: args.url });
+    return;
+  }
+  const resolution = resolveDevMode(args.target, process.cwd());
+  logger(`init target source: ${resolution.source}`);
+  for (const step of resolution.chain) {
+    logger(step);
+  }
+  const terminalInteractive = isInteractiveInit();
+  const renderer = shouldUseInstallRenderer(args, terminalInteractive) ? createInkRenderer({ verbose: args.debug }) : void 0;
+  const context = createInstallContext(args, resolution.target, renderer);
+  const pipeline = new InstallPipeline().addStage(new PreflightStage()).addStage(new EnvStage()).addStage(new StoreStage()).addStage(new HooksStage()).addStage(new McpStage()).addStage(new ValidateStage()).addStage(new GuidanceStage());
+  const result = await pipeline.execute(context);
+  if (renderer) {
+    await renderer.cleanup();
+  }
+  if (!result.success) {
+    if (result.error && !renderer) {
+      console.error(paint.error(result.error.message));
+    }
+    process.exitCode = 1;
+    return;
+  }
+}
+function createInstallContext(args, target, renderer) {
+  const terminalInteractive = isInteractiveInit();
+  const planOnly = args["dry-run"] === true;
+  return {
+    target,
+    args,
+    options: {
+      planOnly,
+      skipBootstrap: false,
+      skipMcp: false,
+      skipHooks: false
+    },
+    mcpInstallMode: "global",
+    claudeMcpScope: "project",
+    interactive: terminalInteractive && !args.yes,
+    wizardEnabled: terminalInteractive && !args.yes && !planOnly,
+    stageResults: [],
+    rollbackStack: [],
+    state: {},
+    renderer
+  };
+}
+function shouldUseInstallRenderer(args, terminalInteractive) {
+  if (!terminalInteractive) {
+    return false;
+  }
+  return args.yes === true || args["dry-run"] === true;
+}
+function isInteractiveInit() {
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+export {
+  install_v2_default as default,
+  installCommand,
+  runInitCommand,
+  shouldUseInstallRenderer
+};