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

package/dist/{install-EKWMFLUU.js → install-74ANPCCP.js}

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
-import {
-  installMcpClients
-} from "./chunk-BATF4PEJ.js";
 import {
   cleanupDeprecatedSkills,
   installArchiveHintHook,
   installCitePolicyEvictHook,
   installFabricArchiveSkill,
+  installFabricAuditSkill,
+  installFabricConnectSkill,
   installFabricImportSkill,
   installFabricReviewSkill,
+  installFabricStoreSkill,
+  installFabricSyncSkill,
   installHookLibs,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
@@ -21,29 +22,39 @@ import {
   writeCodexBootstrapManagedBlock,
   writeCursorBootstrapManagedBlock,
   writeFabricAgentsSnapshot
-} from "./chunk-D25XJ4BC.js";
-import {
-  detectClientSupports
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-2R55HNVD.js";
 import {
   displayWidth,
   padEnd,
   paint
-} from "./chunk-WWNXR34K.js";
+} from "./chunk-BO4XIZWZ.js";
 import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-COI5VDFU.js";
 import {
+  installMcpClients
+} from "./chunk-AOE6AYI7.js";
+import {
+  detectClientSupports
+} from "./chunk-XC5RUHLK.js";
+import {
+  getProjectTranslator,
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
+import {
+  globalConfigPath,
+  loadGlobalConfig,
+  resolveGlobalRoot,
+  saveGlobalConfig
+} from "./chunk-RYAFBNES.js";
 
 // src/commands/install.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { homedir } from "os";
 import * as childProcess from "child_process";
-import { appendFileSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, rmSync, statSync as statSync4, writeFileSync } from "fs";
-import { dirname, isAbsolute as isAbsolute3, join as join4, resolve as resolve3 } from "path";
+import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, statSync as statSync4, writeFileSync } from "fs";
+import { dirname, isAbsolute as isAbsolute3, join as join6, resolve as resolve3 } from "path";
 import { cancel, confirm, group, intro, isCancel, log, note, outro, select } from "@clack/prompts";
 import { defaultAgentsMetaCounters } from "@fenglimg/fabric-shared";
 import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
@@ -59,6 +70,10 @@ async function installHooks(target, _options = {}) {
   results.push(...await runStep(() => installFabricArchiveSkill(normalizedTarget)));
   results.push(...await runStep(() => installFabricReviewSkill(normalizedTarget)));
   results.push(...await runStep(() => installFabricImportSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricSyncSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricStoreSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricAuditSkill(normalizedTarget)));
+  results.push(...await runStep(() => installFabricConnectSkill(normalizedTarget)));
   results.push(...await runStep(() => installSharedSkillLib(normalizedTarget)));
   results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
   results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
@@ -182,20 +197,209 @@ function assertExistingDirectory(target) {
   }
 }
 
+// src/install/run-global-install.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdirSync, mkdtempSync, renameSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { STORES_ROOT_DIR as STORES_ROOT_DIR2, addMountedStore, readStoreIdentity } from "@fenglimg/fabric-shared";
+import { GenericIOError } from "@fenglimg/fabric-shared/errors";
+
+// src/store/uid.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+function deriveUid(opts = {}) {
+  let email = "";
+  try {
+    email = execFileSync("git", ["config", "user.email"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    email = "";
+  }
+  if (email === "") {
+    return "u-anon";
+  }
+  const material = opts.salt !== void 0 && opts.salt.length > 0 ? `${opts.salt}:${email.toLowerCase()}` : email.toLowerCase();
+  const hash = createHash("sha256").update(material).digest("hex").slice(0, 12);
+  return `u-${hash}`;
+}
+
+// src/install/install-global.ts
+import { rmSync } from "fs";
+import { join as join2 } from "path";
+import {
+  STORES_ROOT_DIR,
+  globalConfigSchema,
+  initStore
+} from "@fenglimg/fabric-shared";
+
+// src/install/transaction.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runInstallTransaction(steps) {
+  const receipt = { ok: true, steps: [] };
+  const applied = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    try {
+      await step.apply();
+      applied.push(step);
+      receipt.steps.push({ name: step.name, status: "applied" });
+    } catch (error) {
+      receipt.ok = false;
+      receipt.failedStep = step.name;
+      receipt.error = errorMessage(error);
+      receipt.steps.push({ name: step.name, status: "failed", error: errorMessage(error) });
+      for (let j = i + 1; j < steps.length; j++) {
+        receipt.steps.push({ name: steps[j].name, status: "skipped" });
+      }
+      for (const done of [...applied].reverse()) {
+        const entry = receipt.steps.find((s) => s.name === done.name);
+        try {
+          await done.rollback();
+          if (entry !== void 0) {
+            entry.status = "rolled_back";
+          }
+        } catch (rollbackError) {
+          if (entry !== void 0) {
+            entry.status = "rollback_failed";
+            entry.error = errorMessage(rollbackError);
+          }
+        }
+      }
+      return receipt;
+    }
+  }
+  return receipt;
+}
+
+// src/install/install-global.ts
+async function installGlobalCore(options) {
+  const existing = loadGlobalConfig(options.globalRoot);
+  if (existing !== null) {
+    return {
+      receipt: { ok: true, steps: [{ name: "already-installed", status: "applied" }] },
+      config: existing,
+      alreadyInstalled: true
+    };
+  }
+  const alias = options.personalAlias ?? "personal";
+  const personalDir = join2(options.globalRoot, STORES_ROOT_DIR, options.personalStoreUuid);
+  let config = null;
+  const receipt = await runInstallTransaction([
+    {
+      name: "init-personal-store",
+      apply: () => {
+        initStore(
+          personalDir,
+          {
+            store_uuid: options.personalStoreUuid,
+            created_at: options.now,
+            canonical_alias: alias
+          },
+          { git: options.git }
+        );
+      },
+      rollback: () => {
+        rmSync(personalDir, { recursive: true, force: true });
+      }
+    },
+    {
+      name: "write-global-config",
+      apply: () => {
+        const next = globalConfigSchema.parse({
+          uid: options.uid,
+          stores: [{ store_uuid: options.personalStoreUuid, alias, personal: true }]
+        });
+        saveGlobalConfig(next, options.globalRoot);
+        config = next;
+      },
+      rollback: () => {
+        rmSync(globalConfigPath(options.globalRoot), { force: true });
+      }
+    }
+  ]);
+  return { receipt, config, alreadyInstalled: false };
+}
+
+// src/install/run-global-install.ts
+function gitClone(url, dest) {
+  console.log(`cloning store from ${url} (this may take a while)\u2026`);
+  try {
+    execFileSync2("git", ["clone", "--", url, dest], { stdio: ["ignore", "ignore", "inherit"] });
+  } catch (error) {
+    throw new GenericIOError(`git clone of ${url} failed`, {
+      actionHint: "check the url is reachable and points to a Fabric store git repo (the git error above shows the cause), then re-run `fabric install --global <url>`",
+      details: error
+    });
+  }
+}
+function mountStoreFromRemote(url, globalRoot) {
+  const storesRoot = join3(globalRoot, STORES_ROOT_DIR2);
+  mkdirSync(storesRoot, { recursive: true });
+  const tmp = mkdtempSync(join3(tmpdir(), "fabric-clone-"));
+  const cloneDest = join3(tmp, "store");
+  gitClone(url, cloneDest);
+  const identity = readStoreIdentity(cloneDest);
+  if (identity === null) {
+    throw new GenericIOError(`cloned store at ${url} has no valid store.json (not a Fabric store)`, {
+      actionHint: "verify the url points to a repository created by `fabric` (it must contain a store.json at its root); if you meant to mount a different store, re-run with the correct url"
+    });
+  }
+  const finalDir = join3(storesRoot, identity.store_uuid);
+  renameSync(cloneDest, finalDir);
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new GenericIOError("global config missing after install", {
+      actionHint: "re-run `fabric install --global` to (re)create the global config, then retry mounting the store; if it persists, inspect ~/.fabric for a partial install"
+    });
+  }
+  const alias = identity.canonical_alias ?? "team";
+  saveGlobalConfig(
+    addMountedStore(config, { store_uuid: identity.store_uuid, alias, remote: url }),
+    globalRoot
+  );
+  console.log(`mounted store '${alias}' (${identity.store_uuid}) from ${url}`);
+}
+async function runGlobalInstall(options = {}, globalRoot = resolveGlobalRoot()) {
+  const uid = options.uid ?? deriveUid();
+  const personalStoreUuid = options.personalStoreUuid ?? randomUUID();
+  const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  const result = await installGlobalCore({ globalRoot, uid, personalStoreUuid, now });
+  if (!result.receipt.ok) {
+    throw new GenericIOError(
+      `global install failed at step '${result.receipt.failedStep}': ${result.receipt.error}`,
+      {
+        actionHint: "check write permissions and free space under ~/.fabric, then re-run `fabric install --global` (the install is transactional and rolls back partial state)"
+      }
+    );
+  }
+  console.log(
+    result.alreadyInstalled ? "global Fabric already installed" : `installed global Fabric (uid ${uid})`
+  );
+  if (options.url !== void 0) {
+    mountStoreFromRemote(options.url, globalRoot);
+  }
+}
+
 // src/lib/detect-language.ts
 import { existsSync as existsSync2, readdirSync, readFileSync, statSync as statSync2 } from "fs";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 function detectExistingLanguage(target) {
   const ZH_CN_RATIO_THRESHOLD = 0.3;
   const samples = [];
-  const readmePath = join2(target, "README.md");
+  const readmePath = join4(target, "README.md");
   if (existsSync2(readmePath)) {
     try {
       samples.push(readFileSync(readmePath, "utf8"));
     } catch {
     }
   }
-  const docsDir = join2(target, "docs");
+  const docsDir = join4(target, "docs");
   if (existsSync2(docsDir)) {
     try {
       const stat = statSync2(docsDir);
@@ -204,7 +408,7 @@ function detectExistingLanguage(target) {
           if (!entry.isFile()) continue;
           if (!/\.(md|mdx|txt)$/iu.test(entry.name)) continue;
           try {
-            samples.push(readFileSync(join2(docsDir, entry.name), "utf8"));
+            samples.push(readFileSync(join4(docsDir, entry.name), "utf8"));
           } catch {
           }
         }
@@ -236,11 +440,12 @@ function detectExistingLanguage(target) {
 }
 
 // src/scanner/forensic.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
 import { createRequire } from "module";
-import { basename, extname, isAbsolute as isAbsolute2, join as join3, posix, relative, resolve as resolve2, sep } from "path";
+import { basename, extname, isAbsolute as isAbsolute2, join as join5, posix, relative, resolve as resolve2, sep } from "path";
 import {
+  buildScanRecommendations,
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
 
@@ -358,7 +563,7 @@ async function buildForensicReport(targetInput) {
     candidate_files: candidateFiles,
     sampling_budget: DEFAULT_SAMPLING_BUDGET,
     readme,
-    recommendations_for_skill: buildSkillRecommendations(framework.kind, topology, readme)
+    recommendations_for_skill: buildSkillRecommendations(framework.kind, topology, readme, target)
   };
   const validation = forensicReportSchema.safeParse(report);
   if (!validation.success) {
@@ -383,7 +588,7 @@ function buildTopology(root) {
       continue;
     }
     for (const entry of readdirSync2(current, { withFileTypes: true })) {
-      const absolutePath = join3(current, entry.name);
+      const absolutePath = join5(current, entry.name);
       const relativePath = toPosixPath(relative(root, absolutePath));
       if (relativePath.length === 0) {
         continue;
@@ -471,7 +676,7 @@ function getEntryPointReason(relativePath) {
 async function buildCodeSamples(target, entryPoints, frameworkKind, topology, packageDependencies) {
   const samples = [];
   for (const entryPoint of entryPoints.slice(0, SAMPLE_LIMIT)) {
-    const absolutePath = join3(target, ...entryPoint.path.split("/"));
+    const absolutePath = join5(target, ...entryPoint.path.split("/"));
     const sample = readFirstLines(absolutePath, SAMPLE_LINE_LIMIT);
     const patternAnalysis = await inferPatternHint(entryPoint.path, sample.snippet, {
       frameworkKind,
@@ -508,7 +713,7 @@ function readFirstLines(path, lineLimit) {
   }
 }
 function readPackageDependencies(target) {
-  const packageJsonPath = join3(target, "package.json");
+  const packageJsonPath = join5(target, "package.json");
   if (!existsSync3(packageJsonPath)) {
     return /* @__PURE__ */ new Map();
   }
@@ -526,7 +731,7 @@ function readPackageDependencies(target) {
 }
 function readGitChurnWeight(target, relativePath) {
   try {
-    const output = execFileSync("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
+    const output = execFileSync3("git", ["log", "--follow", "--oneline", "-20", "--", relativePath], {
       cwd: target,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -849,8 +1054,8 @@ function scoreFrameworkConfidence(input) {
   return input.configCount > 0 || input.packageCount > 0 ? "MEDIUM" : "LOW";
 }
 function readReadmeInfo(target) {
-  const readmePath = join3(target, "README.md");
-  const hasContributing = existsSync3(join3(target, "CONTRIBUTING.md"));
+  const readmePath = join5(target, "README.md");
+  const hasContributing = existsSync3(join5(target, "CONTRIBUTING.md"));
   if (!existsSync3(readmePath)) {
     return {
       quality: "missing",
@@ -1313,30 +1518,18 @@ function isDomainFile(relativePath) {
   }
   return !isConfigFile(relativePath) && !isTestFile(relativePath);
 }
-function buildSkillRecommendations(frameworkKind, topology, readme) {
-  const recommendations = [];
-  if (frameworkKind === "cocos-creator") {
-    recommendations.push("\u5EFA\u8BAE\u5411\u7528\u6237\u786E\u8BA4 Cocos Creator Component \u751F\u547D\u5468\u671F(onLoad/onEnable/start)\u987A\u5E8F\u3002");
-    recommendations.push("\u5EFA\u8BAE\u8BE2\u95EE assets/prefabs \u548C assets/scenes \u662F\u5426\u5C5E\u4E8E @HUMAN \u4FDD\u62A4\u533A\u57DF\u3002");
-    if ((topology.by_ext[".meta"] ?? 0) > 0) {
-      recommendations.push("\u68C0\u6D4B\u5230 .meta \u6587\u4EF6,\u5EFA\u8BAE\u5728 @HUMAN \u9501\u5B9A .meta \u4E0D\u88AB AI \u6539\u52A8\u3002");
-    }
-  } else if (frameworkKind === "next") {
-    recommendations.push("\u5EFA\u8BAE\u786E\u8BA4 app/pages \u8DEF\u7531\u8FB9\u754C\u548C\u670D\u52A1\u7AEF\u7EC4\u4EF6\u7EA6\u675F\u3002");
-  } else if (frameworkKind === "vite") {
-    recommendations.push("\u5EFA\u8BAE\u786E\u8BA4 src/main \u5165\u53E3\u3001\u7EC4\u4EF6\u76EE\u5F55\u548C\u6784\u5EFA\u811A\u672C\u7684\u7EF4\u62A4\u8FB9\u754C\u3002");
-  } else if (frameworkKind === "unknown") {
-    recommendations.push("\u672A\u68C0\u6D4B\u5230\u660E\u786E\u6846\u67B6,\u5EFA\u8BAE\u5148\u8BA9\u7528\u6237\u786E\u8BA4\u6280\u672F\u6808\u548C\u4E3B\u8981\u5165\u53E3\u3002");
-  } else {
-    recommendations.push(`\u5EFA\u8BAE\u56F4\u7ED5 ${frameworkKind} \u7684\u4E3B\u8981\u5165\u53E3\u548C\u751F\u6210\u76EE\u5F55\u786E\u8BA4 AGENTS.md \u5206\u5C42\u8FB9\u754C\u3002`);
-  }
-  if (readme.quality !== "ok") {
-    recommendations.push("README \u4FE1\u606F\u4E0D\u8DB3,\u5EFA\u8BAE\u5728\u521D\u59CB\u5316\u8BBF\u8C08\u4E2D\u8865\u9F50\u9879\u76EE\u76EE\u6807\u3001\u8FD0\u884C\u65B9\u5F0F\u548C\u7981\u6539\u533A\u57DF\u3002");
-  }
-  return recommendations;
+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 = join3(target, "package.json");
+  const packageJsonPath = join5(target, "package.json");
   if (existsSync3(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
@@ -1350,7 +1543,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.1" : "unknown";
+  return true ? "2.2.0-rc.1" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1360,7 +1553,7 @@ function toPosixPath(path) {
 }
 
 // src/commands/install.ts
-var LOCAL_FABRIC_SERVER_PATH = join4("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
+var LOCAL_FABRIC_SERVER_PATH = join6("node_modules", "@fenglimg", "fabric-server", "dist", "index.js");
 var FABRIC_SERVER_PACKAGE = "@fenglimg/fabric-server";
 var INIT_WIZARD_GROUP_CANCELLED = /* @__PURE__ */ Symbol("init-wizard-group-cancelled");
 var installCommand = defineCommand({
@@ -1397,6 +1590,15 @@ var installCommand = defineCommand({
       type: "boolean",
       description: t("cli.install.args.force-hooks-only.description"),
       default: false
+    },
+    global: {
+      type: "boolean",
+      description: "Set up global Fabric (~/.fabric: uid + personal store + config)",
+      default: false
+    },
+    url: {
+      type: "string",
+      description: "With --global: clone + mount this shared store remote"
     }
   },
   async run({ args }) {
@@ -1406,7 +1608,7 @@ var installCommand = defineCommand({
 var install_default = installCommand;
 async function runSkillsOnlyRefresh(targetInput) {
   const target = normalizeTarget3(targetInput);
-  const metaPath = join4(target, ".fabric", "agents.meta.json");
+  const metaPath = join6(target, ".fabric", "agents.meta.json");
   if (!existsSync4(metaPath)) {
     const message = t("cli.install.force-skills-only.uninitialised.message");
     const hint = t("cli.install.force-skills-only.uninitialised.hint");
@@ -1422,6 +1624,11 @@ ${hint}
   results.push(...await installFabricArchiveSkill(target));
   results.push(...await installFabricReviewSkill(target));
   results.push(...await installFabricImportSkill(target));
+  results.push(...await installFabricSyncSkill(target));
+  results.push(...await installFabricStoreSkill(target));
+  results.push(...await installFabricAuditSkill(target));
+  results.push(...await installFabricConnectSkill(target));
+  results.push(...await installSharedSkillLib(target));
   let written = 0;
   let skipped = 0;
   let errors = 0;
@@ -1449,7 +1656,7 @@ ${hint}
 }
 async function runHooksOnlyRefresh(targetInput) {
   const target = normalizeTarget3(targetInput);
-  const metaPath = join4(target, ".fabric", "agents.meta.json");
+  const metaPath = join6(target, ".fabric", "agents.meta.json");
   if (!existsSync4(metaPath)) {
     const message = t("cli.install.force-hooks-only.uninitialised.message");
     const hint = t("cli.install.force-hooks-only.uninitialised.hint");
@@ -1478,6 +1685,10 @@ ${hint}
 }
 async function runInitCommand(args) {
   const logger = createDebugLogger(args.debug);
+  if (args.global === true) {
+    await runGlobalInstall({ url: args.url });
+    return;
+  }
   const resolution = resolveDevMode(args.target, process.cwd());
   if (args["force-skills-only"] === true) {
     await runSkillsOnlyRefresh(resolution.target);
@@ -1515,8 +1726,26 @@ async function runInitCommand(args) {
   }
   return result;
 }
+var FABRIC_GITIGNORE_CONTENT = [
+  "# Fabric per-dev activity ledgers & caches \u2014 auto-generated, not shared.",
+  "# Managed by `fabric install`; edit freely (re-install never overwrites this).",
+  "events.jsonl",
+  "metrics.jsonl",
+  "cite-rollup.jsonl",
+  "injections.jsonl",
+  ".cache/",
+  "*.lock",
+  "*.corrupted.*",
+  ""
+].join("\n");
+function writeDefaultGitignore(fabricDir) {
+  const target = join6(fabricDir, ".gitignore");
+  if (existsSync4(target)) return;
+  mkdirSync2(fabricDir, { recursive: true });
+  writeFileSync(target, FABRIC_GITIGNORE_CONTENT, "utf8");
+}
 function writeDefaultFabricConfig(fabricDir, targetRoot) {
-  const target = join4(fabricDir, "fabric-config.json");
+  const target = join6(fabricDir, "fabric-config.json");
   if (existsSync4(target)) return;
   const detectedLanguage = detectExistingLanguage(targetRoot);
   const FABRIC_CONFIG_DEFAULTS = {
@@ -1578,7 +1807,7 @@ function writeDefaultFabricConfig(fabricDir, targetRoot) {
     // is considered stale by fabric-review. Default 14.
     review_stale_pending_days: 14
   };
-  mkdirSync(fabricDir, { recursive: true });
+  mkdirSync2(fabricDir, { recursive: true });
   writeFileSync(target, JSON.stringify(FABRIC_CONFIG_DEFAULTS, null, 2) + "\n", "utf8");
   log.info(
     `Detected and fixated fabric_language = ${detectedLanguage}; edit ${target} to override.`
@@ -1709,14 +1938,14 @@ function resolvePersonalFabricRoot() {
 }
 async function buildInitFabricPlan(target, options) {
   assertExistingDirectory3(target);
-  const fabricDir = join4(target, ".fabric");
-  const agentsMdPath = join4(target, "AGENTS.md");
+  const fabricDir = join6(target, ".fabric");
+  const agentsMdPath = join6(target, "AGENTS.md");
   const agentsMdAction = existsSync4(agentsMdPath) ? "preserved" : "created";
-  const knowledgeDir = join4(fabricDir, "knowledge");
-  const personalKnowledgeDir = join4(resolvePersonalFabricRoot(), ".fabric", "knowledge");
-  const forensicPath = join4(fabricDir, "forensic.json");
-  const eventsPath = join4(fabricDir, "events.jsonl");
-  const metaPath = join4(fabricDir, "agents.meta.json");
+  const knowledgeDir = join6(fabricDir, "knowledge");
+  const personalKnowledgeDir = join6(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const forensicPath = join6(fabricDir, "forensic.json");
+  const eventsPath = join6(fabricDir, "events.jsonl");
+  const metaPath = join6(fabricDir, "agents.meta.json");
   const replaceFabricDir = shouldReplaceWritableDirectory(fabricDir, options);
   const knowledgeDirAction = existsSync4(knowledgeDir) ? "overwritten" : "created";
   const metaClassification = classifyFreshPath(metaPath, "structural");
@@ -1725,7 +1954,16 @@ async function buildInitFabricPlan(target, options) {
   const metaAction = diffStateToWriteAction(metaClassification.state);
   const eventsAction = diffStateToWriteAction(eventsClassification.state);
   const forensicAction = diffStateToWriteAction(forensicClassification.state);
+  const showScanProgress = process.stderr.isTTY === true;
+  if (showScanProgress) {
+    process.stderr.write(`${t("cli.install.scanning")}
+`);
+  }
   const forensicReport = await buildForensicReport(target);
+  if (showScanProgress) {
+    process.stderr.write(`${t("cli.install.scan-complete")}
+`);
+  }
   const meta = createInitialMeta();
   return {
     target,
@@ -1752,23 +1990,24 @@ async function buildInitFabricPlan(target, options) {
 }
 async function executeInitFabricPlan(plan) {
   if (plan.replaceFabricDir) {
-    rmSync(plan.fabricDir, { force: true });
+    rmSync2(plan.fabricDir, { force: true });
   }
-  mkdirSync(plan.fabricDir, { recursive: true });
+  mkdirSync2(plan.fabricDir, { recursive: true });
   writeDefaultFabricConfig(plan.fabricDir, plan.target);
-  mkdirSync(plan.knowledgeDir, { recursive: true });
+  writeDefaultGitignore(plan.fabricDir);
+  mkdirSync2(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
-    const teamSubDir = join4(plan.knowledgeDir, sub);
-    mkdirSync(teamSubDir, { recursive: true });
-    const teamGitkeep = join4(teamSubDir, ".gitkeep");
+    const teamSubDir = join6(plan.knowledgeDir, sub);
+    mkdirSync2(teamSubDir, { recursive: true });
+    const teamGitkeep = join6(teamSubDir, ".gitkeep");
     if (!existsSync4(teamGitkeep)) {
       writeFileSync(teamGitkeep, "", "utf8");
     }
   }
   try {
-    mkdirSync(plan.personalKnowledgeDir, { recursive: true });
+    mkdirSync2(plan.personalKnowledgeDir, { recursive: true });
     for (const sub of KNOWLEDGE_SUBDIRS) {
-      mkdirSync(join4(plan.personalKnowledgeDir, sub), { recursive: true });
+      mkdirSync2(join6(plan.personalKnowledgeDir, sub), { recursive: true });
     }
   } catch {
   }
@@ -1778,7 +2017,7 @@ async function executeInitFabricPlan(plan) {
   }
   if (plan.eventsState === "missing") {
     preparePlannedPath(plan.eventsPath, plan.eventsAction);
-    mkdirSync(dirname(plan.eventsPath), { recursive: true });
+    mkdirSync2(dirname(plan.eventsPath), { recursive: true });
     writeFileSync(plan.eventsPath, "", "utf8");
   }
   preparePlannedPath(plan.forensicPath, plan.forensicAction);
@@ -1935,9 +2174,15 @@ async function executeInitStagePlan(plan, stageName) {
         installResults.push(...await runBestEffort("skill-install", () => installFabricArchiveSkill(plan.target)));
         installResults.push(...await runBestEffort("skill-review-install", () => installFabricReviewSkill(plan.target)));
         installResults.push(...await runBestEffort("skill-import-install", () => installFabricImportSkill(plan.target)));
+        installResults.push(...await runBestEffort("skill-sync-install", () => installFabricSyncSkill(plan.target)));
+        installResults.push(...await runBestEffort("skill-store-install", () => installFabricStoreSkill(plan.target)));
+        installResults.push(...await runBestEffort("skill-audit-install", () => installFabricAuditSkill(plan.target)));
+        installResults.push(...await runBestEffort("skill-connect-install", () => installFabricConnectSkill(plan.target)));
+        installResults.push(...await runBestEffort("skill-shared-lib", () => installSharedSkillLib(plan.target)));
         installResults.push(...await runBestEffort("hook-script", () => installArchiveHintHook(plan.target)));
         installResults.push(...await runBestEffort("hook-broad-script", () => installKnowledgeHintBroadHook(plan.target)));
         installResults.push(...await runBestEffort("hook-narrow-script", () => installKnowledgeHintNarrowHook(plan.target)));
+        installResults.push(...await runBestEffort("hook-cite-policy-evict-script", () => installCitePolicyEvictHook(plan.target)));
         installResults.push(...await runBestEffort("hook-lib", () => installHookLibs(plan.target)));
         installResults.push(await runBestEffortSingle("claude-hook-config", () => mergeClaudeCodeHookConfig(plan.target)));
         installResults.push(await runBestEffortSingle("codex-hook-config", () => mergeCodexHookConfig(plan.target)));
@@ -2050,9 +2295,9 @@ function formatDiffFileState(state) {
   return t(`cli.install.diff.state.${state}`);
 }
 function preparePlannedPath(path, action) {
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync2(dirname(path), { recursive: true });
   if (action === "overwritten" && existsSync4(path)) {
-    rmSync(path, { recursive: true, force: true });
+    rmSync2(path, { recursive: true, force: true });
   }
 }
 function createDefaultInitWizardAdapter() {
@@ -2211,13 +2456,13 @@ function assertExistingDirectory3(target) {
 }
 function detectPackageManager(cwd) {
   const workspaceRoot = resolve3(cwd);
-  if (existsSync4(join4(workspaceRoot, "pnpm-lock.yaml"))) {
+  if (existsSync4(join6(workspaceRoot, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync4(join4(workspaceRoot, "yarn.lock"))) {
+  if (existsSync4(join6(workspaceRoot, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync4(join4(workspaceRoot, "package-lock.json"))) {
+  if (existsSync4(join6(workspaceRoot, "package-lock.json"))) {
     return "npm";
   }
   return "npm";
@@ -2240,7 +2485,7 @@ function createInitialMeta() {
 function appendInstallDiffLedgerEvent(eventsPath, payload) {
   const event = {
     kind: "fabric-event",
-    id: `event:${randomUUID()}`,
+    id: `event:${randomUUID2()}`,
     ts: Date.now(),
     schema_version: 1,
     event_type: "install_diff_applied",