@fenglimg/fabric-cli 2.0.1 → 2.1.0-rc.2

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

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-import {
-  installMcpClients
-} from "./chunk-BATF4PEJ.js";
 import {
   cleanupDeprecatedSkills,
   installArchiveHintHook,
@@ -9,6 +6,7 @@ import {
   installFabricArchiveSkill,
   installFabricImportSkill,
   installFabricReviewSkill,
+  installFabricSyncSkill,
   installHookLibs,
   installKnowledgeHintBroadHook,
   installKnowledgeHintNarrowHook,
@@ -21,10 +19,7 @@ import {
   writeCodexBootstrapManagedBlock,
   writeCursorBootstrapManagedBlock,
   writeFabricAgentsSnapshot
-} from "./chunk-D25XJ4BC.js";
-import {
-  detectClientSupports
-} from "./chunk-MF3OTILQ.js";
+} from "./chunk-F46ORPOA.js";
 import {
   displayWidth,
   padEnd,
@@ -34,16 +29,28 @@ import {
   createDebugLogger,
   resolveDevMode
 } from "./chunk-COI5VDFU.js";
+import {
+  installMcpClients
+} from "./chunk-BATF4PEJ.js";
+import {
+  detectClientSupports
+} from "./chunk-MF3OTILQ.js";
 import {
   t
 } from "./chunk-PWLW3B57.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 +66,7 @@ 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(() => installSharedSkillLib(normalizedTarget)));
   results.push(...await runStep(() => installArchiveHintHook(normalizedTarget)));
   results.push(...await runStep(() => installKnowledgeHintBroadHook(normalizedTarget)));
@@ -182,20 +190,190 @@ 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";
+
+// src/store/uid.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+function deriveUid() {
+  let email = "";
+  try {
+    email = execFileSync("git", ["config", "user.email"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    email = "";
+  }
+  if (email === "") {
+    return "u-anon";
+  }
+  const hash = createHash("sha256").update(email.toLowerCase()).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) {
+  execFileSync2("git", ["clone", url, dest], { stdio: ["ignore", "ignore", "pipe"] });
+}
+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 Error(`cloned store at ${url} has no valid store.json (not a Fabric store)`);
+  }
+  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");
+  }
+  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 Error(`global install failed at step '${result.receipt.failedStep}': ${result.receipt.error}`);
+  }
+  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 +382,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,10 +414,10 @@ 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 {
   forensicReportSchema
 } from "@fenglimg/fabric-shared";
@@ -383,7 +561,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 +649,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 +686,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 +704,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 +1027,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",
@@ -1336,7 +1514,7 @@ function buildSkillRecommendations(frameworkKind, topology, readme) {
   return recommendations;
 }
 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 +1528,7 @@ function readProjectName(target) {
   return basename(target);
 }
 function getCliVersion() {
-  return true ? "2.0.1" : "unknown";
+  return true ? "2.1.0-rc.2" : "unknown";
 }
 function sortRecord(record) {
   return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
@@ -1360,7 +1538,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 +1575,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 +1593,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");
@@ -1449,7 +1636,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 +1665,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);
@@ -1516,7 +1707,7 @@ async function runInitCommand(args) {
   return result;
 }
 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 +1769,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 +1900,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");
@@ -1752,23 +1943,23 @@ 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 });
+  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 +1969,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);
@@ -2050,9 +2241,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 +2402,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 +2431,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",

package/dist/scope-explain-2F2R5URO.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import {
+  scopeExplain
+} from "./chunk-L4Q55UC4.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/scope-explain.ts
+import { defineCommand } from "citty";
+var scope_explain_default = defineCommand({
+  meta: {
+    name: "scope-explain",
+    description: "Explain the resolved read-set and write target for a scope"
+  },
+  args: {
+    scope: {
+      type: "positional",
+      required: true,
+      description: "Scope coordinate (e.g. team, project:x, personal)"
+    }
+  },
+  run({ args }) {
+    const result = scopeExplain(process.cwd(), args.scope);
+    if (result === null) {
+      console.log("no global Fabric config \u2014 run `fabric install --global <url>` first");
+      return;
+    }
+    console.log(JSON.stringify(result, null, 2));
+  }
+});
+export {
+  scope_explain_default as default
+};

package/dist/status-GLQWLWH6.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import {
+  projectStatus
+} from "./chunk-T5RPGCCM.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/status.ts
+import { defineCommand } from "citty";
+var status_default = defineCommand({
+  meta: { name: "status", description: "Show this project's Fabric store status" },
+  run() {
+    const status = projectStatus(process.cwd());
+    console.log(`uid:            ${status.uid ?? "(no global config)"}`);
+    console.log(`project_id:     ${status.project_id ?? "(not a Fabric project)"}`);
+    console.log(`mounted stores: ${status.mounted.length > 0 ? status.mounted.join(", ") : "(none)"}`);
+    console.log(`required:       ${status.required.length > 0 ? status.required.join(", ") : "(none)"}`);
+    console.log(`active write:   ${status.active_write_store ?? "(none \u2014 personal scope only)"}`);
+  }
+});
+export {
+  status_default as default
+};

package/dist/store-XTSE5TY6.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import {
+  storeAdd,
+  storeBind,
+  storeExplain,
+  storeList,
+  storeRemove,
+  storeSwitchWrite
+} from "./chunk-HFQVXY6P.js";
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-WU6GAPKH.js";
+import "./chunk-L4Q55UC4.js";
+import "./chunk-LFIKMVY7.js";
+import "./chunk-RYAFBNES.js";
+
+// src/commands/store.ts
+import { defineCommand } from "citty";
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List mounted knowledge stores" },
+  run() {
+    const stores = storeList();
+    if (stores.length === 0) {
+      console.log("(no stores mounted)");
+      return;
+    }
+    for (const store of stores) {
+      console.log(`${store.alias}	${store.store_uuid}	${store.remote ?? "(local-only)"}`);
+    }
+  }
+});
+var addCommand = defineCommand({
+  meta: { name: "add", description: "Mount a knowledge store into the global registry" },
+  args: {
+    uuid: { type: "string", required: true, description: "Intrinsic store UUID" },
+    alias: { type: "string", required: true, description: "Local alias for this store" },
+    remote: { type: "string", description: "Git remote locator (omit for local-only)" }
+  },
+  run({ args }) {
+    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)`);
+  }
+});
+var removeCommand = defineCommand({
+  meta: { name: "remove", description: "Detach a store from the registry (does NOT delete it)" },
+  args: {
+    alias: { type: "positional", required: true, description: "Alias to detach" }
+  },
+  run({ args }) {
+    const { detached } = storeRemove(args.alias);
+    console.log(
+      detached === null ? `no store aliased '${args.alias}'` : `detached '${args.alias}' \u2014 on-disk store tree left intact (detach \u2260 delete)`
+    );
+  }
+});
+var explainCommand = defineCommand({
+  meta: { name: "explain", description: "Explain how a store alias resolves" },
+  args: {
+    alias: { type: "positional", required: true, description: "Alias to explain" }
+  },
+  run({ args }) {
+    const explanation = storeExplain(args.alias);
+    console.log(
+      explanation === null ? `no store aliased '${args.alias}'` : JSON.stringify(explanation, null, 2)
+    );
+  }
+});
+var bindCommand = defineCommand({
+  meta: { name: "bind", description: "Declare a required store on this project's config" },
+  args: {
+    id: { type: "positional", required: true, description: "Store alias/UUID to require" },
+    remote: { type: "string", description: "Suggested remote for clone onboarding" }
+  },
+  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() });
+  }
+});
+var switchWriteCommand = defineCommand({
+  meta: { name: "switch-write", description: "Set the active write store for non-personal scopes" },
+  args: {
+    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`);
+  }
+});
+var store_default = defineCommand({
+  meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
+  subCommands: {
+    list: listCommand,
+    add: addCommand,
+    remove: removeCommand,
+    explain: explainCommand,
+    bind: bindCommand,
+    "switch-write": switchWriteCommand
+  }
+});
+export {
+  store_default as default
+};