@fenglimg/fabric-cli 2.1.0-rc.2 → 2.2.0-rc.1

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

@@ -4,8 +4,11 @@ import {
   installArchiveHintHook,
   installCitePolicyEvictHook,
   installFabricArchiveSkill,
+  installFabricAuditSkill,
+  installFabricConnectSkill,
   installFabricImportSkill,
   installFabricReviewSkill,
+  installFabricStoreSkill,
   installFabricSyncSkill,
   installHookLibs,
   installKnowledgeHintBroadHook,
@@ -19,25 +22,26 @@ import {
   writeCodexBootstrapManagedBlock,
   writeCursorBootstrapManagedBlock,
   writeFabricAgentsSnapshot
-} from "./chunk-F46ORPOA.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-BATF4PEJ.js";
+} from "./chunk-AOE6AYI7.js";
 import {
   detectClientSupports
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-XC5RUHLK.js";
 import {
+  getProjectTranslator,
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
 import {
   globalConfigPath,
   loadGlobalConfig,
@@ -67,6 +71,9 @@ async function installHooks(target, _options = {}) {
   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)));
@@ -197,11 +204,12 @@ 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() {
+function deriveUid(opts = {}) {
   let email = "";
   try {
     email = execFileSync("git", ["config", "user.email"], {
@@ -214,7 +222,8 @@ function deriveUid() {
   if (email === "") {
     return "u-anon";
   }
-  const hash = createHash("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
+  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}`;
 }
 
@@ -319,7 +328,15 @@ async function installGlobalCore(options) {
 
 // src/install/run-global-install.ts
 function gitClone(url, dest) {
-  execFileSync2("git", ["clone", url, dest], { stdio: ["ignore", "ignore", "pipe"] });
+  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);
@@ -329,13 +346,17 @@ function mountStoreFromRemote(url, globalRoot) {
   gitClone(url, cloneDest);
   const identity = readStoreIdentity(cloneDest);
   if (identity === null) {
-    throw new Error(`cloned store at ${url} has no valid store.json (not a Fabric store)`);
+    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 Error("global config missing after install");
+    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(
@@ -350,7 +371,12 @@ async function runGlobalInstall(options = {}, globalRoot = resolveGlobalRoot())
   const now = options.now ?? (/* @__PURE__ */ new Date()).toISOString();
   const result = await installGlobalCore({ globalRoot, uid, personalStoreUuid, now });
   if (!result.receipt.ok) {
-    throw new Error(`global install failed at step '${result.receipt.failedStep}': ${result.receipt.error}`);
+    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})`
@@ -419,6 +445,7 @@ import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as
 import { createRequire } from "module";
 import { basename, extname, isAbsolute as isAbsolute2, join as join5, posix, relative, resolve as resolve2, sep } from "path";
 import {
+  buildScanRecommendations,
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
 
@@ -536,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) {
@@ -1491,27 +1518,15 @@ 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 = join5(target, "package.json");
@@ -1528,7 +1543,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.1.0-rc.2" : "unknown";
+  return true ? "2.2.0-rc.1" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1609,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;
@@ -1706,6 +1726,24 @@ 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 = join6(fabricDir, "fabric-config.json");
   if (existsSync4(target)) return;
@@ -1916,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,
@@ -1947,6 +1994,7 @@ async function executeInitFabricPlan(plan) {
   }
   mkdirSync2(plan.fabricDir, { recursive: true });
   writeDefaultFabricConfig(plan.fabricDir, plan.target);
+  writeDefaultGitignore(plan.fabricDir);
   mkdirSync2(plan.knowledgeDir, { recursive: true });
   for (const sub of KNOWLEDGE_SUBDIRS) {
     const teamSubDir = join6(plan.knowledgeDir, sub);
@@ -2126,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)));

package/dist/{metrics-ACEQFPDU.js → metrics-RER6NLFC.js}

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/metrics.ts
 import { resolve } from "path";
 import { defineCommand } from "citty";
 import { readMetrics } from "@fenglimg/fabric-server";
-function parseSinceArg(raw) {
+function parseSinceArg(raw, t) {
   if (raw === void 0 || raw.length === 0) return 0;
   const match = /^(\d+)([smhd]?)$/u.exec(raw);
   if (match === null) {
-    throw new Error(`--since: invalid duration "${raw}" (expected e.g. 24h, 7d, 30m)`);
+    throw new Error(t("cli.metrics.invalid-since", { raw }));
   }
   const n = Number.parseInt(match[1], 10);
   const unit = match[2] ?? "s";
@@ -36,6 +39,8 @@ function aggregate(rows, sinceMs, now) {
     }
   }
   return {
+    // Stable token (NOT localized) so the --json contract is locale-independent;
+    // renderText localizes "all-time" at presentation time only.
     windowDescription: sinceMs > 0 ? formatDuration(sinceMs) : "all-time",
     rowCount: filtered.length,
     totals,
@@ -50,17 +55,24 @@ function formatDuration(ms) {
   if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
   return `${Math.round(ms / 1e3)}s`;
 }
-function renderText(agg) {
+function renderText(agg, t) {
   const lines = [];
-  lines.push(`Fabric metrics \u2014 window: ${agg.windowDescription}`);
+  const windowDisplay = agg.windowDescription === "all-time" ? t("cli.metrics.window-all-time") : agg.windowDescription;
+  lines.push(t("cli.metrics.window", { window: windowDisplay }));
   if (agg.rangeStart && agg.rangeEnd) {
-    lines.push(`  rows: ${agg.rowCount} (${agg.rangeStart} \u2192 ${agg.rangeEnd})`);
+    lines.push(
+      t("cli.metrics.rows-range", {
+        count: String(agg.rowCount),
+        start: agg.rangeStart,
+        end: agg.rangeEnd
+      })
+    );
   } else {
-    lines.push(`  rows: ${agg.rowCount}`);
+    lines.push(t("cli.metrics.rows", { count: String(agg.rowCount) }));
   }
   lines.push("");
   if (Object.keys(agg.totals).length === 0) {
-    lines.push("  (no counter activity in window \u2014 server may be idle or just started)");
+    lines.push(t("cli.metrics.no-activity"));
     return lines.join("\n");
   }
   lines.push("  counter                              total");
@@ -103,14 +115,15 @@ var metricsCommand = defineCommand({
   },
   async run({ args }) {
     const projectRoot = resolve(args.target ?? process.cwd());
-    const sinceMs = parseSinceArg(args.since);
+    const t = getProjectTranslator(projectRoot);
+    const sinceMs = parseSinceArg(args.since, t);
     const rows = await readMetrics(projectRoot);
     const aggregated = aggregate(rows, sinceMs, /* @__PURE__ */ new Date());
     if (args.json === true) {
       process.stdout.write(`${JSON.stringify(aggregated)}
 `);
     } else {
-      process.stdout.write(`${renderText(aggregated)}
+      process.stdout.write(`${renderText(aggregated, t)}
 `);
     }
   }

package/dist/{onboard-coverage-MFCAEBDO.js → onboard-coverage-JWQWDZW7.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/onboard-coverage.ts
 import { existsSync, readdirSync, readFileSync } from "fs";

package/dist/{scope-explain-2F2R5URO.js → scope-explain-CDIZESP5.js}

@@ -2,6 +2,9 @@
 import {
   scopeExplain
 } from "./chunk-L4Q55UC4.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
 import "./chunk-LFIKMVY7.js";
 import "./chunk-RYAFBNES.js";
 
@@ -20,9 +23,10 @@ var scope_explain_default = defineCommand({
     }
   },
   run({ args }) {
-    const result = scopeExplain(process.cwd(), args.scope);
+    const projectRoot = process.cwd();
+    const result = scopeExplain(projectRoot, args.scope);
     if (result === null) {
-      console.log("no global Fabric config \u2014 run `fabric install --global <url>` first");
+      console.log(getProjectTranslator(projectRoot)("cli.cmd.no-global-config"));
       return;
     }
     console.log(JSON.stringify(result, null, 2));

package/dist/{store-XTSE5TY6.js → store-XB3ADT65.js}

@@ -1,16 +1,21 @@
 #!/usr/bin/env node
 import {
+  assertStoreMountable,
   storeAdd,
   storeBind,
+  storeCreate,
   storeExplain,
   storeList,
   storeRemove,
   storeSwitchWrite
-} from "./chunk-HFQVXY6P.js";
+} from "./chunk-4R2CYEA4.js";
 import {
   regenerateBindingsSnapshot
 } from "./chunk-WU6GAPKH.js";
 import "./chunk-L4Q55UC4.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
 import "./chunk-LFIKMVY7.js";
 import "./chunk-RYAFBNES.js";
 
@@ -19,13 +24,15 @@ import { defineCommand } from "citty";
 var listCommand = defineCommand({
   meta: { name: "list", description: "List mounted knowledge stores" },
   run() {
+    const t = getProjectTranslator();
     const stores = storeList();
     if (stores.length === 0) {
-      console.log("(no stores mounted)");
+      console.log(t("cli.store.none-mounted"));
       return;
     }
+    const localOnly = t("cli.shared.local-only");
     for (const store of stores) {
-      console.log(`${store.alias}	${store.store_uuid}	${store.remote ?? "(local-only)"}`);
+      console.log(`${store.alias}	${store.store_uuid}	${store.remote ?? localOnly}`);
     }
   }
 });
@@ -37,9 +44,32 @@ var addCommand = defineCommand({
     remote: { type: "string", description: "Git remote locator (omit for local-only)" }
   },
   run({ args }) {
+    assertStoreMountable(args.uuid);
     const store = args.remote === void 0 ? { store_uuid: args.uuid, alias: args.alias } : { store_uuid: args.uuid, alias: args.alias, remote: args.remote };
     const next = storeAdd(store);
-    console.log(`mounted '${args.alias}' (${next.stores.length} store(s) total)`);
+    console.log(
+      getProjectTranslator()("cli.store.mounted", {
+        alias: args.alias,
+        count: String(next.stores.length)
+      })
+    );
+  }
+});
+var createCommand = defineCommand({
+  meta: { name: "create", description: "Create a brand-new local knowledge store and mount it" },
+  args: {
+    alias: { type: "string", required: true, description: "Local alias for the new store" },
+    remote: { type: "string", description: "Git remote to associate (push target; optional)" }
+  },
+  run({ args }) {
+    const result = storeCreate(args.alias, (/* @__PURE__ */ new Date()).toISOString(), {
+      ...args.remote === void 0 ? {} : { remote: args.remote }
+    });
+    const t = getProjectTranslator();
+    console.log(
+      t("cli.store.created", { alias: args.alias, uuid: result.store_uuid, dir: result.storeDir }) + (args.remote === void 0 ? `
+${t("cli.store.created-local-hint")}` : "")
+    );
   }
 });
 var removeCommand = defineCommand({
@@ -49,8 +79,9 @@ var removeCommand = defineCommand({
   },
   run({ args }) {
     const { detached } = storeRemove(args.alias);
+    const t = getProjectTranslator();
     console.log(
-      detached === null ? `no store aliased '${args.alias}'` : `detached '${args.alias}' \u2014 on-disk store tree left intact (detach \u2260 delete)`
+      detached === null ? t("cli.store.no-alias", { alias: args.alias }) : t("cli.store.detached", { alias: args.alias })
     );
   }
 });
@@ -62,7 +93,7 @@ var explainCommand = defineCommand({
   run({ args }) {
     const explanation = storeExplain(args.alias);
     console.log(
-      explanation === null ? `no store aliased '${args.alias}'` : JSON.stringify(explanation, null, 2)
+      explanation === null ? getProjectTranslator()("cli.store.no-alias", { alias: args.alias }) : JSON.stringify(explanation, null, 2)
     );
   }
 });
@@ -74,9 +105,15 @@ var bindCommand = defineCommand({
   },
   run({ args }) {
     const entry = args.remote === void 0 ? { id: args.id } : { id: args.id, suggested_remote: args.remote };
-    const next = storeBind(process.cwd(), entry);
-    console.log(`bound required store '${args.id}' (${next.required_stores?.length ?? 0} required)`);
-    regenerateBindingsSnapshot(process.cwd(), { now: (/* @__PURE__ */ new Date()).toISOString() });
+    const projectRoot = process.cwd();
+    const next = storeBind(projectRoot, entry);
+    console.log(
+      getProjectTranslator(projectRoot)("cli.store.bound", {
+        id: args.id,
+        count: String(next.required_stores?.length ?? 0)
+      })
+    );
+    regenerateBindingsSnapshot(projectRoot, { now: (/* @__PURE__ */ new Date()).toISOString() });
   }
 });
 var switchWriteCommand = defineCommand({
@@ -85,14 +122,16 @@ var switchWriteCommand = defineCommand({
     alias: { type: "positional", required: true, description: "Alias of the store to write to" }
   },
   run({ args }) {
-    storeSwitchWrite(process.cwd(), args.alias);
-    console.log(`active write store set to '${args.alias}' for this project`);
+    const projectRoot = process.cwd();
+    storeSwitchWrite(projectRoot, args.alias);
+    console.log(getProjectTranslator(projectRoot)("cli.store.switch-write", { alias: args.alias }));
   }
 });
 var store_default = defineCommand({
   meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
   subCommands: {
     list: listCommand,
+    create: createCommand,
     add: addCommand,
     remove: removeCommand,
     explain: explainCommand,

package/dist/{sync-BJCWDPNC.js → sync-UJ4BBCZJ.js}

@@ -3,6 +3,9 @@ import {
   regenerateBindingsSnapshot
 } from "./chunk-WU6GAPKH.js";
 import "./chunk-L4Q55UC4.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
 import "./chunk-LFIKMVY7.js";
 import {
   loadGlobalConfig,
@@ -17,6 +20,7 @@ import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { join } from "path";
 import { GLOBAL_STATE_DIR, storeRelativePath } from "@fenglimg/fabric-shared";
+import { GenericIOError } from "@fenglimg/fabric-shared/errors";
 
 // src/sync/state-machine.ts
 function syncTransition(state, event) {
@@ -112,7 +116,11 @@ function defaultPull(storeDir) {
     )) {
       return "offline";
     }
-    throw error;
+    const gitMessage = detail.trim().length > 0 ? detail.trim() : "unknown git error";
+    throw new GenericIOError(`git pull --rebase failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: "resolve the git issue above (e.g. authentication, a dirty working tree, or a detached HEAD), then re-run `fabric sync`",
+      details: error
+    });
   }
 }
 function gitErrText(error, key) {
@@ -206,19 +214,16 @@ function runAbortSync(options) {
 }
 
 // src/commands/sync.ts
-function report(result) {
+function report(result, projectRoot) {
+  const t = getProjectTranslator(projectRoot);
   for (const store of result.session.stores) {
     console.log(`${store.alias}	${store.state}`);
   }
   if (result.deferred.length > 0) {
-    console.log(
-      `${result.deferred.length} store(s) offline \u2014 push deferred; re-run \`fabric sync\` when online`
-    );
+    console.log(t("cli.sync.deferred", { count: String(result.deferred.length) }));
   }
   if (!result.settled) {
-    console.log(
-      "sync paused on a conflict \u2014 resolve it, then run `fabric sync --continue` (or `--abort`)"
-    );
+    console.log(t("cli.sync.paused"));
   }
 }
 var sync_default = defineCommand({
@@ -228,16 +233,17 @@ var sync_default = defineCommand({
     abort: { type: "boolean", description: "Abort the conflicted store's rebase" }
   },
   run({ args }) {
-    const options = { projectRoot: process.cwd(), now: (/* @__PURE__ */ new Date()).toISOString() };
+    const projectRoot = process.cwd();
+    const options = { projectRoot, now: (/* @__PURE__ */ new Date()).toISOString() };
     if (args.continue === true) {
-      report(runContinueSync(options));
+      report(runContinueSync(options), projectRoot);
       return;
     }
     if (args.abort === true) {
-      report(runAbortSync(options));
+      report(runAbortSync(options), projectRoot);
       return;
     }
-    report(runStartSync(options));
+    report(runStartSync(options), projectRoot);
   }
 });
 export {

package/dist/{uninstall-TAXSUSKH.js → uninstall-C3QXKOO6.js}

@@ -7,10 +7,10 @@ import {
   HOOK_SCRIPT_DESTINATIONS,
   SKILL_DESTINATIONS,
   fabricAgentsSnapshotPath
-} from "./chunk-F46ORPOA.js";
+} from "./chunk-2R55HNVD.js";
 import {
   paint
-} from "./chunk-WWNXR34K.js";
+} from "./chunk-BO4XIZWZ.js";
 import {
   createDebugLogger,
   resolveDevMode
@@ -18,10 +18,10 @@ import {
 import {
   detectClientSupports,
   resolveClients
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-XC5RUHLK.js";
 import {
   t
-} from "./chunk-PWLW3B57.js";
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/uninstall.ts
 import { existsSync as existsSync2, statSync } from "fs";
@@ -49,6 +49,12 @@ async function uninstallFabricImportSkill(projectRoot) {
 async function uninstallFabricSyncSkill(projectRoot) {
   return removeSkill("skill-sync", SKILL_DESTINATIONS.fabricSync, projectRoot);
 }
+async function uninstallFabricAuditSkill(projectRoot) {
+  return removeSkill("skill-audit", SKILL_DESTINATIONS.fabricAudit, projectRoot);
+}
+async function uninstallFabricConnectSkill(projectRoot) {
+  return removeSkill("skill-connect", SKILL_DESTINATIONS.fabricConnect, projectRoot);
+}
 async function removeSkill(step, rels, projectRoot) {
   const results = [];
   for (const rel of rels) {
@@ -75,6 +81,13 @@ async function removeKnowledgeHintNarrowHook(projectRoot) {
     projectRoot
   );
 }
+async function removeCitePolicyEvictHook(projectRoot) {
+  return removeHookScripts(
+    "hook-cite-policy-evict-script",
+    HOOK_SCRIPT_DESTINATIONS.citePolicyEvict,
+    projectRoot
+  );
+}
 async function removeHookScripts(step, rels, projectRoot) {
   const results = [];
   for (const rel of rels) {
@@ -304,6 +317,24 @@ async function uninstallBootstrapStage(projectRoot, _opts = {}) {
     projectRoot,
     () => removeArchiveHintHook(projectRoot)
   );
+  await runAndCollect(
+    results,
+    "hook-cite-policy-evict-script",
+    projectRoot,
+    () => removeCitePolicyEvictHook(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-connect",
+    projectRoot,
+    () => uninstallFabricConnectSkill(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-audit",
+    projectRoot,
+    () => uninstallFabricAuditSkill(projectRoot)
+  );
   await runAndCollect(
     results,
     "skill-sync",