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

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/{plan-context-hint-FC6P3WFE.js → plan-context-hint-CHVZGOZ5.js}

@@ -56,16 +56,29 @@ async function runPlanContextHint(opts) {
   const targetPaths = all ? [ALL_PATHS_SENTINEL] : explicitPaths.length > 0 ? explicitPaths : [ALL_PATHS_SENTINEL];
   const resolution = resolveDevMode(opts.target, process.cwd());
   const result = await planContext(resolution.target, {
-    paths: targetPaths
+    paths: targetPaths,
+    // lifecycle-refactor W3-T2 (§7 图谱消费 / §5): default-enable graph二阶召回 for
+    // the hint path. planContext appends the one-hop `related` neighbours that
+    // ranked outside top_k of the surfaced set and reports them in
+    // `related_appended` (appended id → source id). Honest no-op when the
+    // surfaced set declares no in-corpus related edge.
+    include_related: true
   });
   const candidates = result.candidates;
-  const entries = candidates.map((item) => ({
-    id: item.stable_id,
-    type: item.description.knowledge_type ?? "",
-    maturity: item.description.maturity ?? "",
-    summary: item.description.summary,
-    relevance_scope: item.description.relevance_scope ?? "broad"
-  }));
+  const relatedAppended = result.related_appended ?? {};
+  const entries = candidates.map((item) => {
+    const relatedTo = relatedAppended[item.stable_id];
+    return {
+      id: item.stable_id,
+      type: item.description.knowledge_type ?? "",
+      maturity: item.description.maturity ?? "",
+      summary: item.description.summary,
+      relevance_scope: item.description.relevance_scope ?? "broad",
+      // Only set when this entry was pulled in via a graph edge — its presence
+      // is the honest signal, never synthesized for ordinarily-ranked entries.
+      ...typeof relatedTo === "string" ? { related_to: relatedTo } : {}
+    };
+  });
   let narrow_count = 0;
   let broad_only_count = 0;
   for (const e of entries) {

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

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import {
   scopeExplain
-} from "./chunk-L4Q55UC4.js";
-import "./chunk-LFIKMVY7.js";
-import "./chunk-RYAFBNES.js";
+} from "./chunk-EOT63RDH.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
 
 // src/commands/scope-explain.ts
 import { defineCommand } from "citty";
+import { FabricError } from "@fenglimg/fabric-shared/errors";
 var scope_explain_default = defineCommand({
   meta: {
     name: "scope-explain",
@@ -20,9 +22,21 @@ var scope_explain_default = defineCommand({
     }
   },
   run({ args }) {
-    const result = scopeExplain(process.cwd(), args.scope);
+    const projectRoot = process.cwd();
+    let result;
+    try {
+      result = scopeExplain(projectRoot, args.scope);
+    } catch (error) {
+      if (error instanceof FabricError) {
+        console.error(`${error.message}
+\u2192 ${error.actionHint}`);
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
     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/{status-GLQWLWH6.js → status-PANEGKU2.js}

@@ -1,18 +1,29 @@
 #!/usr/bin/env node
 import {
-  projectStatus
-} from "./chunk-T5RPGCCM.js";
-import "./chunk-LFIKMVY7.js";
-import "./chunk-RYAFBNES.js";
+  projectStatus,
+  warnUnknownFlags
+} from "./chunk-5LQIHYFC.js";
+import "./chunk-5ZUMLCD5.js";
+import "./chunk-XCBVSGCS.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() {
+  args: {
+    // F27: `--json` machine-readable output (was silently ignored pre-F27).
+    json: { type: "boolean", description: "Emit machine-readable JSON instead of text" }
+  },
+  run({ args }) {
+    warnUnknownFlags(["json"]);
     const status = projectStatus(process.cwd());
+    if (args.json === true) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
     console.log(`uid:            ${status.uid ?? "(no global config)"}`);
-    console.log(`project_id:     ${status.project_id ?? "(not a Fabric project)"}`);
+    const projectIdLabel = status.project_id ?? (status.is_fabric_project ? "(unset)" : "(not a Fabric project)");
+    console.log(`project_id:     ${projectIdLabel}`);
     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)"}`);

package/dist/store-66NK2FTQ.js

@@ -0,0 +1,443 @@
+#!/usr/bin/env node
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-H3FE6VIK.js";
+import "./chunk-EOT63RDH.js";
+import {
+  getProjectTranslator
+} from "./chunk-2CY4BMTH.js";
+import {
+  assertStoreMountable,
+  storeAdd,
+  storeBind,
+  storeCreate,
+  storeExplain,
+  storeGitRemote,
+  storeList,
+  storeRemove,
+  storeSwitchWrite
+} from "./chunk-5ZUMLCD5.js";
+import {
+  loadGlobalConfig
+} from "./chunk-XCBVSGCS.js";
+
+// src/commands/store.ts
+import { defineCommand } from "citty";
+
+// src/store/store-migrate.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import {
+  STORE_KNOWLEDGE_TYPE_DIRS,
+  STORE_LAYOUT,
+  STORE_PENDING_DIR,
+  buildStoreResolveInput,
+  createStoreResolver,
+  formatKnowledgeId,
+  parseKnowledgeId,
+  resolveGlobalRoot,
+  storeRelativePath
+} from "@fenglimg/fabric-shared";
+function resolveTargetStore(layer, projectRoot, globalRoot) {
+  const input = buildStoreResolveInput(projectRoot, globalRoot);
+  if (input === null) {
+    return null;
+  }
+  const scope = layer === "personal" ? "personal" : "team";
+  const { target } = createStoreResolver().resolveWriteTarget(input, scope);
+  if (target === null) {
+    return null;
+  }
+  const alias = loadGlobalConfig(globalRoot)?.stores.find((s) => s.store_uuid === target.store_uuid)?.alias ?? target.store_uuid;
+  return {
+    uuid: target.store_uuid,
+    alias,
+    dir: join(globalRoot, storeRelativePath(target.store_uuid))
+  };
+}
+function listMd(dir) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  return readdirSync(dir).filter((name) => name.endsWith(".md")).sort();
+}
+function readId(content) {
+  const match = content.match(/^id:\s*(\S+)\s*$/mu);
+  return match ? match[1] : null;
+}
+function slugSuffix(fileName, oldId) {
+  const stem = fileName.replace(/\.md$/u, "");
+  if (oldId !== null && stem.startsWith(`${oldId}--`)) {
+    return stem.slice(oldId.length);
+  }
+  return "";
+}
+function buildStoreIdIndex(storeDir) {
+  const existing = /* @__PURE__ */ new Set();
+  const maxCounter = /* @__PURE__ */ new Map();
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    const dir = join(storeDir, STORE_LAYOUT.knowledgeDir, type);
+    for (const file of listMd(dir)) {
+      const content = readFileSync(join(dir, file), "utf8");
+      const id = readId(content) ?? file.replace(/\.md$/u, "").split("--")[0];
+      const parsed = parseKnowledgeId(id);
+      if (parsed === null) {
+        continue;
+      }
+      existing.add(id);
+      const key = id.slice(0, id.lastIndexOf("-"));
+      maxCounter.set(key, Math.max(maxCounter.get(key) ?? 0, parsed.counter));
+    }
+  }
+  return { existing, maxCounter };
+}
+function nextId(index, layer, type) {
+  const probe = formatKnowledgeId(layer, type, 1);
+  const key = probe.slice(0, probe.lastIndexOf("-"));
+  let counter = (index.maxCounter.get(key) ?? 0) + 1;
+  let id = formatKnowledgeId(layer, type, counter);
+  while (index.existing.has(id)) {
+    counter += 1;
+    id = formatKnowledgeId(layer, type, counter);
+  }
+  index.existing.add(id);
+  index.maxCounter.set(key, counter);
+  return id;
+}
+function typeDirToKnowledgeType(typeDir) {
+  return STORE_KNOWLEDGE_TYPE_DIRS.includes(typeDir) ? typeDir : null;
+}
+function migrateProjectKnowledge(projectRoot, options = {}) {
+  const dryRun = options.dryRun ?? false;
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const runGit = options.git ?? true;
+  const items = [];
+  const skips = [];
+  const remap = {};
+  const targets = {};
+  const sourceRoots = {
+    team: join(projectRoot, ".fabric", "knowledge"),
+    personal: join(globalRoot, "knowledge")
+  };
+  const layerState = {};
+  for (const layer of ["team", "personal"]) {
+    if (!existsSync(sourceRoots[layer])) {
+      continue;
+    }
+    const target = resolveTargetStore(layer, projectRoot, globalRoot);
+    if (target === null) {
+      continue;
+    }
+    targets[layer] = { uuid: target.uuid, dir: target.dir };
+    layerState[layer] = { target, index: buildStoreIdIndex(target.dir) };
+  }
+  for (const layer of ["team", "personal"]) {
+    const root = sourceRoots[layer];
+    if (!existsSync(root)) {
+      continue;
+    }
+    const state = layerState[layer];
+    for (const typeDir of STORE_KNOWLEDGE_TYPE_DIRS) {
+      const dir = join(root, typeDir);
+      for (const file of listMd(dir)) {
+        const source = join(dir, file);
+        if (state === void 0) {
+          skips.push({
+            source,
+            reason: `no ${layer} write-target store \u2014 run \`fabric install --global\` then \`fabric store bind <alias>\`${layer === "team" ? " + `fabric store switch-write <alias>`" : ""}`
+          });
+          continue;
+        }
+        const content = readFileSync(source, "utf8");
+        const oldId = readId(content);
+        const knowledgeType = typeDirToKnowledgeType(typeDir);
+        let newId = null;
+        if (oldId !== null && state.index.existing.has(oldId) && knowledgeType !== null) {
+          const parsed = parseKnowledgeId(oldId);
+          const idLayer = parsed?.layer ?? layer;
+          newId = nextId(state.index, idLayer, knowledgeType);
+          remap[oldId] = newId;
+        } else if (oldId !== null) {
+          state.index.existing.add(oldId);
+          const parsed = parseKnowledgeId(oldId);
+          if (parsed !== null) {
+            const key = oldId.slice(0, oldId.lastIndexOf("-"));
+            state.index.maxCounter.set(
+              key,
+              Math.max(state.index.maxCounter.get(key) ?? 0, parsed.counter)
+            );
+          }
+        }
+        const effectiveId = newId ?? oldId;
+        const targetName = newId !== null && effectiveId !== null ? `${effectiveId}${slugSuffix(file, oldId)}.md` : file;
+        const targetFile = join(state.target.dir, STORE_LAYOUT.knowledgeDir, typeDir, targetName);
+        items.push({
+          source,
+          layer,
+          type: typeDir,
+          oldId,
+          newId,
+          target: targetFile,
+          storeUuid: state.target.uuid,
+          alias: state.target.alias
+        });
+      }
+    }
+    const pendingRoot = join(root, STORE_PENDING_DIR);
+    for (const sub of [".", "decisions", "guidelines", "pitfalls", "models", "processes"]) {
+      const dir = sub === "." ? pendingRoot : join(pendingRoot, sub);
+      for (const file of listMd(dir)) {
+        const source = join(dir, file);
+        if (state === void 0) {
+          skips.push({ source, reason: `no ${layer} write-target store` });
+          continue;
+        }
+        const rel = sub === "." ? file : join(sub, file);
+        const targetFile = join(
+          state.target.dir,
+          STORE_LAYOUT.knowledgeDir,
+          STORE_PENDING_DIR,
+          rel
+        );
+        if (existsSync(targetFile)) {
+          skips.push({ source, reason: `pending already present in store: ${basename(targetFile)}` });
+          continue;
+        }
+        items.push({
+          source,
+          layer,
+          type: STORE_PENDING_DIR,
+          oldId: null,
+          newId: null,
+          target: targetFile,
+          storeUuid: state.target.uuid,
+          alias: state.target.alias
+        });
+      }
+    }
+  }
+  if (dryRun || items.length === 0) {
+    return { dryRun, committed: false, items, skips, remap, targets };
+  }
+  for (const item of items) {
+    let content = readFileSync(item.source, "utf8");
+    if (item.newId !== null && item.oldId !== null) {
+      content = content.replace(/^id:\s*\S+\s*$/mu, `id: ${item.newId}`);
+    }
+    content = rewriteRelated(content, remap);
+    mkdirSync(join(item.target, ".."), { recursive: true });
+    writeFileSync(item.target, content, "utf8");
+  }
+  for (const item of items) {
+    rmSync(item.source, { force: true });
+  }
+  let committed = false;
+  if (runGit) {
+    for (const [layer, info] of Object.entries(targets)) {
+      const moved = items.filter((i) => i.layer === layer).length;
+      if (moved === 0) {
+        continue;
+      }
+      committed = gitCommitStore(info.dir, moved) || committed;
+    }
+  }
+  return { dryRun, committed, items, skips, remap, targets };
+}
+function rewriteRelated(content, remap) {
+  if (Object.keys(remap).length === 0) {
+    return content;
+  }
+  return content.replace(/^related:\s*\[(.*)\]\s*$/mu, (line, inner) => {
+    const rewritten = inner.split(",").map((token) => {
+      const trimmed = token.trim();
+      return remap[trimmed] ?? trimmed;
+    }).join(", ");
+    return `related: [${rewritten}]`;
+  });
+}
+function gitCommitStore(storeDir, count) {
+  if (!existsSync(join(storeDir, ".git"))) {
+    return false;
+  }
+  try {
+    execFileSync("git", ["add", "-A"], { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] });
+    execFileSync(
+      "git",
+      ["commit", "-m", `chore(migrate): import ${count} entries from project dual-root`],
+      { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/store.ts
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List mounted knowledge stores" },
+  run() {
+    const t = getProjectTranslator();
+    const stores = storeList();
+    if (stores.length === 0) {
+      console.log(t("cli.store.none-mounted"));
+      return;
+    }
+    const localOnly = t("cli.shared.local-only");
+    for (const store of stores) {
+      const realRemote = storeGitRemote(store.store_uuid);
+      console.log(`${store.alias}	${store.store_uuid}	${realRemote ?? localOnly}`);
+    }
+  }
+});
+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 }) {
+    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);
+    const t = getProjectTranslator();
+    console.log(
+      t("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({
+  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);
+    const t = getProjectTranslator();
+    console.log(
+      detached === null ? t("cli.store.no-alias", { alias: args.alias }) : t("cli.store.detached", { alias: args.alias })
+    );
+  }
+});
+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 ? getProjectTranslator()("cli.store.no-alias", { alias: 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 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({
+  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 }) {
+    const projectRoot = process.cwd();
+    storeSwitchWrite(projectRoot, args.alias);
+    console.log(getProjectTranslator(projectRoot)("cli.store.switch-write", { alias: args.alias }));
+  }
+});
+var migrateCommand = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Move project-local (dual-root) knowledge into the resolved write-target stores"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Preview the move without writing anything"
+    }
+  },
+  run({ args }) {
+    const projectRoot = process.cwd();
+    const t = getProjectTranslator(projectRoot);
+    const dryRun = args["dry-run"] === true;
+    const report = migrateProjectKnowledge(projectRoot, { dryRun });
+    if (report.items.length === 0 && report.skips.length === 0) {
+      console.log(t("cli.store.migrate.none"));
+      return;
+    }
+    console.log(
+      dryRun ? t("cli.store.migrate.dry-run-header") : t("cli.store.migrate.applied-header", { count: String(report.items.length) })
+    );
+    for (const item of report.items) {
+      const id = item.newId ?? item.oldId ?? "(draft)";
+      console.log(`  ${item.layer}/${item.type}  ${id}  \u2192  ${item.alias}`);
+      if (item.newId !== null && item.oldId !== null) {
+        console.log(
+          t("cli.store.migrate.remap-note", { oldId: item.oldId, newId: item.newId })
+        );
+      }
+    }
+    if (report.skips.length > 0) {
+      console.log(t("cli.store.migrate.skips-header", { count: String(report.skips.length) }));
+      for (const skip of report.skips) {
+        console.log(`  ${skip.source}: ${skip.reason}`);
+      }
+    }
+    if (report.committed) {
+      console.log(t("cli.store.migrate.committed"));
+    }
+  }
+});
+var store_default = defineCommand({
+  meta: { name: "store", description: "Manage mounted Fabric knowledge stores" },
+  subCommands: {
+    list: listCommand,
+    create: createCommand,
+    add: addCommand,
+    remove: removeCommand,
+    explain: explainCommand,
+    bind: bindCommand,
+    "switch-write": switchWriteCommand,
+    migrate: migrateCommand
+  }
+});
+export {
+  store_default as default
+};