@fenglimg/fabric-cli 2.2.0-rc.3 → 2.2.0-rc.8

package/dist/store-HOCORVL3.js

@@ -0,0 +1,563 @@
+#!/usr/bin/env node
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-PTGQAZEW.js";
+import "./chunk-EOT63RDH.js";
+import {
+  assertStoreMountable,
+  resolveStoreDir,
+  storeAdd,
+  storeBind,
+  storeCreate,
+  storeExplain,
+  storeGitRemote,
+  storeList,
+  storeProjectCreate,
+  storeProjectList,
+  storeRemove,
+  storeSetWriteRoute,
+  storeSwitchWrite
+} from "./chunk-QPAW6IYT.js";
+import {
+  loadProjectConfig
+} from "./chunk-QFIVFZRH.js";
+import "./chunk-FNHDQTPC.js";
+import {
+  getProjectTranslator
+} from "./chunk-HORSMSZL.js";
+
+// src/commands/store.ts
+import { defineCommand } from "citty";
+import { join as join3 } from "path";
+
+// src/store/scope-backfill.ts
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  STORE_KNOWLEDGE_TYPE_DIRS,
+  isPersonalScope,
+  parseKnowledgeId
+} from "@fenglimg/fabric-shared";
+var FRONTMATTER_RE = /^(?:)?---\r?\n([\s\S]*?)\r?\n---/u;
+function readKey(block, key) {
+  const m = new RegExp(`^${key}:\\s*"?([^"\\n]+?)"?\\s*$`, "mu").exec(block);
+  return m?.[1];
+}
+function setKey(block, key, value, anchorKey) {
+  const lines = block.split(/\r?\n/u);
+  const idx = lines.findIndex((l) => new RegExp(`^${key}:`).test(l));
+  if (idx !== -1) {
+    lines[idx] = `${key}: ${value}`;
+    return lines.join("\n");
+  }
+  const anchorIdx = lines.findIndex((l) => new RegExp(`^${anchorKey}:`).test(l));
+  const at = anchorIdx === -1 ? lines.length - 1 : anchorIdx + 1;
+  lines.splice(at, 0, `${key}: ${value}`);
+  return lines.join("\n");
+}
+function backfillEntryContent(content, visibilityStore) {
+  const match = FRONTMATTER_RE.exec(content);
+  if (match === null) {
+    return null;
+  }
+  const block = match[1] ?? "";
+  const id = readKey(block, "id") ?? null;
+  const parsed = id === null ? null : parseKnowledgeId(id);
+  const declaredLayer = readKey(block, "layer");
+  const layer = parsed?.layer ?? (declaredLayer === "personal" ? "personal" : "team");
+  const semanticScope = layer === "personal" ? "personal" : "team";
+  const visibility = isPersonalScope(semanticScope) ? "personal" : visibilityStore;
+  const changed = [];
+  let newBlock = block;
+  if (declaredLayer !== layer) {
+    newBlock = setKey(newBlock, "layer", layer, "maturity");
+    changed.push("layer");
+  }
+  if (readKey(block, "semantic_scope") !== semanticScope) {
+    newBlock = setKey(newBlock, "semantic_scope", semanticScope, "layer");
+    changed.push("semantic_scope");
+  }
+  if (readKey(block, "visibility_store") !== visibility) {
+    newBlock = setKey(newBlock, "visibility_store", `"${visibility}"`, "semantic_scope");
+    changed.push("visibility_store");
+  }
+  if (changed.length === 0) {
+    return { content, change: { file: "", id, changed } };
+  }
+  const before = content.slice(0, match.index);
+  const after = content.slice(match.index + match[0].length);
+  return {
+    content: `${before}---
+${newBlock}
+---${after}`,
+    change: { file: "", id, changed }
+  };
+}
+function backfillKnowledgeDir(knowledgeDir, options) {
+  const report = { dryRun: options.dryRun === true, unchanged: 0, changes: [], skipped: [] };
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS) {
+    const dir = join(knowledgeDir, type);
+    if (!existsSync(dir)) {
+      continue;
+    }
+    for (const name of readdirSync(dir).filter((n) => n.endsWith(".md")).sort()) {
+      const file = join(dir, name);
+      const result = backfillEntryContent(readFileSync(file, "utf8"), options.visibilityStore);
+      if (result === null) {
+        report.skipped.push(file);
+        continue;
+      }
+      if (result.change.changed.length === 0) {
+        report.unchanged += 1;
+        continue;
+      }
+      result.change.file = file;
+      report.changes.push(result.change);
+      if (options.dryRun !== true) {
+        writeFileSync(file, result.content, "utf8");
+      }
+    }
+  }
+  return report;
+}
+
+// src/store/store-rescope.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import {
+  STORE_KNOWLEDGE_TYPE_DIRS as STORE_KNOWLEDGE_TYPE_DIRS2,
+  STORE_LAYOUT,
+  isPersonalScope as isPersonalScope2,
+  readStoreProjects,
+  scopeCoordinateSchema,
+  scopeRoot
+} from "@fenglimg/fabric-shared";
+async function validateToScope(toScope, storeDir, storeVisibility) {
+  if (!scopeCoordinateSchema.safeParse(toScope).success) {
+    return `invalid scope coordinate '${toScope}'`;
+  }
+  if (isPersonalScope2(toScope) && storeVisibility === "shared") {
+    return "refusing personal scope in a shared store (R5#3 privacy boundary)";
+  }
+  if (scopeRoot(toScope) === "project") {
+    const projectId = toScope.split(":")[1] ?? "";
+    if (projectId.length === 0 || !(await readStoreProjects(storeDir)).some((p) => p.id === projectId)) {
+      return `project '${projectId}' is not registered in this store (run \`fabric store project add ${projectId}\` first)`;
+    }
+  }
+  return null;
+}
+function matchesSelection(options, id, currentScope) {
+  if (options.id !== void 0 && id !== options.id) {
+    return false;
+  }
+  if (options.fromScope !== void 0 && currentScope !== options.fromScope) {
+    return false;
+  }
+  if (options.fromScopeRoot !== void 0 && (currentScope === void 0 || scopeRoot(currentScope) !== options.fromScopeRoot)) {
+    return false;
+  }
+  return true;
+}
+async function rescopeStore(storeDir, toScope, options) {
+  const report = {
+    dryRun: options.dryRun === true,
+    toScope,
+    changes: [],
+    refusals: [],
+    unchanged: 0,
+    skipped: []
+  };
+  const toScopeError = await validateToScope(toScope, storeDir, options.storeVisibility);
+  for (const type of STORE_KNOWLEDGE_TYPE_DIRS2) {
+    const dir = join2(storeDir, STORE_LAYOUT.knowledgeDir, type);
+    if (!existsSync2(dir)) {
+      continue;
+    }
+    for (const name of readdirSync2(dir).filter((n) => n.endsWith(".md")).sort()) {
+      const file = join2(dir, name);
+      const content = readFileSync2(file, "utf8");
+      const match = FRONTMATTER_RE.exec(content);
+      if (match === null) {
+        report.skipped.push(file);
+        continue;
+      }
+      const block = match[1] ?? "";
+      const id = readKey(block, "id") ?? null;
+      const currentScope = readKey(block, "semantic_scope");
+      if (!matchesSelection(options, id, currentScope)) {
+        continue;
+      }
+      if (currentScope === toScope) {
+        report.unchanged += 1;
+        continue;
+      }
+      if (toScopeError !== null) {
+        report.refusals.push({ file, id, reason: toScopeError });
+        continue;
+      }
+      const newBlock = setKey(block, "semantic_scope", toScope, "layer");
+      const before = content.slice(0, match.index);
+      const after = content.slice(match.index + match[0].length);
+      report.changes.push({ file, id, fromScope: currentScope, toScope });
+      if (options.dryRun !== true) {
+        writeFileSync2(file, `${before}---
+${newBlock}
+---${after}`, "utf8");
+      }
+    }
+  }
+  return report;
+}
+async function promoteProjectToTeam(storeDir, options) {
+  const selection = options.projectId !== void 0 ? { fromScope: `project:${options.projectId}`, storeVisibility: options.storeVisibility, dryRun: options.dryRun } : { fromScopeRoot: "project", storeVisibility: options.storeVisibility, dryRun: options.dryRun };
+  return rescopeStore(storeDir, "team", selection);
+}
+
+// src/commands/store.ts
+import {
+  STORE_LAYOUT as STORE_LAYOUT2,
+  loadGlobalConfig,
+  resolveGlobalRoot
+} from "@fenglimg/fabric-shared";
+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.alias);
+      console.log(
+        `${store.alias}	${store.mount_name ?? store.store_uuid}	${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" },
+    "mount-name": { type: "string", description: "Stable local directory under ~/.fabric/stores/" },
+    remote: { type: "string", description: "Git remote locator (omit for local-only)" }
+  },
+  async run({ args }) {
+    assertStoreMountable(args.uuid, void 0, args["mount-name"]);
+    const store = args.remote === void 0 ? {
+      store_uuid: args.uuid,
+      alias: args.alias,
+      ...args["mount-name"] === void 0 ? {} : { mount_name: args["mount-name"] }
+    } : {
+      store_uuid: args.uuid,
+      alias: args.alias,
+      ...args["mount-name"] === void 0 ? {} : { mount_name: args["mount-name"] },
+      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" },
+    "mount-name": { type: "string", description: "Stable local directory under ~/.fabric/stores/" },
+    remote: { type: "string", description: "Git remote to associate (push target; optional)" }
+  },
+  async run({ args }) {
+    const result = await storeCreate(args.alias, (/* @__PURE__ */ new Date()).toISOString(), {
+      ...args["mount-name"] === void 0 ? {} : { mountName: args["mount-name"] },
+      ...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" }
+  },
+  async run({ args }) {
+    const { detached } = storeRemove(args.alias);
+    const t = getProjectTranslator();
+    if (detached === null) {
+      process.exitCode = 1;
+    }
+    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);
+    if (explanation === null) {
+      process.exitCode = 1;
+    }
+    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" },
+    project: {
+      type: "string",
+      description: "Bind this repo to a project:<id> in the store (must already exist)"
+    }
+  },
+  async run({ args }) {
+    const entry = args.remote === void 0 ? { id: args.id } : { id: args.id, suggested_remote: args.remote };
+    const projectRoot = process.cwd();
+    const next = await storeBind(
+      projectRoot,
+      entry,
+      args.project === void 0 ? {} : { project: args.project }
+    );
+    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 default write store for non-personal scopes" },
+  args: {
+    alias: { type: "positional", required: true, description: "Alias of the store to write to" }
+  },
+  async run({ args }) {
+    const projectRoot = process.cwd();
+    storeSwitchWrite(projectRoot, args.alias);
+    regenerateBindingsSnapshot(projectRoot, { now: (/* @__PURE__ */ new Date()).toISOString() });
+    console.log(getProjectTranslator(projectRoot)("cli.store.switch-write", { alias: args.alias }));
+  }
+});
+var routeWriteCommand = defineCommand({
+  meta: { name: "route-write", description: "Route a semantic scope to a writable shared store" },
+  args: {
+    scope: { type: "positional", required: true, description: "Semantic scope, e.g. team or project:fabric-v2" },
+    alias: { type: "positional", required: true, description: "Alias of the shared store to write to" }
+  },
+  run({ args }) {
+    const projectRoot = process.cwd();
+    storeSetWriteRoute(projectRoot, args.scope, args.alias);
+    console.log(`write route: ${args.scope} -> ${args.alias}`);
+  }
+});
+var projectListCommand = defineCommand({
+  meta: { name: "list", description: "List projects registered in a store" },
+  args: {
+    store: { type: "positional", required: true, description: "Store alias/UUID" }
+  },
+  async run({ args }) {
+    const projects = await storeProjectList(args.store);
+    if (projects.length === 0) {
+      console.log(`store '${args.store}' has no registered projects.`);
+      return;
+    }
+    for (const p of projects) {
+      console.log(`${p.id}${p.name === void 0 ? "" : `	${p.name}`}`);
+    }
+  }
+});
+var projectCreateCommand = defineCommand({
+  meta: { name: "create", description: "Register a new project in a store" },
+  args: {
+    store: { type: "positional", required: true, description: "Store alias/UUID" },
+    id: { type: "positional", required: true, description: "Project id (single [a-z0-9_-] segment)" },
+    name: { type: "string", description: "Optional human-facing label" }
+  },
+  async run({ args }) {
+    const project = await storeProjectCreate(args.store, args.id, (/* @__PURE__ */ new Date()).toISOString(), {
+      ...args.name === void 0 ? {} : { name: args.name }
+    });
+    console.log(`registered project '${project.id}' in store '${args.store}'.`);
+  }
+});
+var projectCommand = defineCommand({
+  meta: { name: "project", description: "Manage the projects a store serves" },
+  subCommands: {
+    list: projectListCommand,
+    create: projectCreateCommand
+  }
+});
+var backfillScopeCommand = defineCommand({
+  meta: {
+    name: "backfill-scope",
+    description: "Backfill semantic_scope + visibility_store on existing knowledge (repairs dirty layer)"
+  },
+  args: {
+    store: { type: "string", description: "Backfill a mounted store's knowledge" },
+    "dry-run": { type: "boolean", description: "Preview changes without writing" }
+  },
+  run({ args }) {
+    const dryRun = args["dry-run"] === true;
+    let knowledgeDir;
+    let visibilityStore;
+    const selectedStore = typeof args.store === "string" && args.store.length > 0 ? args.store : loadProjectConfig(process.cwd())?.active_write_store;
+    if (typeof selectedStore !== "string" || selectedStore.length === 0) {
+      console.error(
+        "no store selected for scope backfill; pass --store <alias> or run `fabric store switch-write <alias>`"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    {
+      const storeDir = resolveStoreDir(selectedStore);
+      if (storeDir === null) {
+        console.error(`no mounted store '${selectedStore}'`);
+        process.exitCode = 1;
+        return;
+      }
+      knowledgeDir = join3(storeDir, STORE_LAYOUT2.knowledgeDir);
+      visibilityStore = selectedStore;
+    }
+    const report = backfillKnowledgeDir(knowledgeDir, { visibilityStore, dryRun });
+    if (report.changes.length === 0) {
+      console.log(`scope backfill: nothing to do (${report.unchanged} already consistent).`);
+      return;
+    }
+    console.log(
+      `${dryRun ? "[dry-run] " : ""}scope backfill: ${report.changes.length} entr${report.changes.length === 1 ? "y" : "ies"} updated, ${report.unchanged} unchanged.`
+    );
+    for (const c of report.changes) {
+      console.log(`  ${c.id ?? "(no id)"}  [${c.changed.join(", ")}]`);
+    }
+    const scopeAssigned = report.changes.filter((c) => c.changed.includes("semantic_scope")).length;
+    if (scopeAssigned > 0) {
+      console.error(
+        `${dryRun ? "[dry-run] " : ""}note: ${scopeAssigned} entr${scopeAssigned === 1 ? "y" : "ies"} defaulted to semantic_scope: team. Demote project-specific ones with \`fabric store re-scope <store> --to project:<id> --id <id>\`.`
+      );
+    }
+  }
+});
+function resolveStoreDirAndVisibility(aliasOrUuid) {
+  const dir = resolveStoreDir(aliasOrUuid);
+  if (dir === null) {
+    return null;
+  }
+  const store = loadGlobalConfig(resolveGlobalRoot())?.stores.find(
+    (s) => s.alias === aliasOrUuid || s.store_uuid === aliasOrUuid
+  );
+  return { dir, visibility: store?.personal === true ? "personal" : "shared" };
+}
+function printRescopeReport(report) {
+  const prefix = report.dryRun ? "[dry-run] " : "";
+  if (report.changes.length === 0 && report.refusals.length === 0) {
+    console.log(`re-scope: nothing to do (${report.unchanged} already at '${report.toScope}').`);
+  } else if (report.changes.length > 0) {
+    console.log(
+      `${prefix}re-scope \u2192 ${report.toScope}: ${report.changes.length} entr${report.changes.length === 1 ? "y" : "ies"} updated, ${report.unchanged} unchanged.`
+    );
+    for (const c of report.changes) {
+      console.log(`  ${c.id ?? "(no id)"}  ${c.fromScope ?? "(none)"} \u2192 ${c.toScope}`);
+    }
+  }
+  if (report.refusals.length > 0) {
+    console.error(`${report.refusals.length} entr${report.refusals.length === 1 ? "y" : "ies"} refused:`);
+    for (const r of report.refusals) {
+      console.error(`  ${r.id ?? "(no id)"}: ${r.reason}`);
+    }
+    process.exitCode = 1;
+  }
+}
+var rescopeCommand = defineCommand({
+  meta: {
+    name: "re-scope",
+    description: "Rewrite knowledge entries' semantic_scope coordinate in a store"
+  },
+  args: {
+    store: { type: "positional", required: true, description: "Target store alias or uuid" },
+    to: { type: "string", required: true, description: "New semantic_scope (e.g. team, project:alpha)" },
+    id: { type: "string", description: "Only the entry with this stable_id" },
+    from: { type: "string", description: "Only entries currently at this semantic_scope" },
+    "dry-run": { type: "boolean", description: "Preview changes without writing" }
+  },
+  async run({ args }) {
+    const resolved = resolveStoreDirAndVisibility(args.store);
+    if (resolved === null) {
+      console.error(`no mounted store '${args.store}'`);
+      process.exitCode = 1;
+      return;
+    }
+    printRescopeReport(
+      await rescopeStore(resolved.dir, args.to, {
+        id: args.id,
+        fromScope: args.from,
+        storeVisibility: resolved.visibility,
+        dryRun: args["dry-run"] === true
+      })
+    );
+  }
+});
+var promoteCommand = defineCommand({
+  meta: {
+    name: "promote",
+    description: "Promote project-scoped entries to team scope (project absorption)"
+  },
+  args: {
+    store: { type: "positional", required: true, description: "Target store alias or uuid" },
+    project: { type: "string", description: "Only this project's entries (default: all project:*)" },
+    "dry-run": { type: "boolean", description: "Preview changes without writing" }
+  },
+  async run({ args }) {
+    const resolved = resolveStoreDirAndVisibility(args.store);
+    if (resolved === null) {
+      console.error(`no mounted store '${args.store}'`);
+      process.exitCode = 1;
+      return;
+    }
+    printRescopeReport(
+      await promoteProjectToTeam(resolved.dir, {
+        projectId: args.project,
+        storeVisibility: resolved.visibility,
+        dryRun: args["dry-run"] === true
+      })
+    );
+  }
+});
+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,
+    "route-write": routeWriteCommand,
+    "backfill-scope": backfillScopeCommand,
+    "re-scope": rescopeCommand,
+    promote: promoteCommand,
+    project: projectCommand
+  }
+});
+export {
+  store_default as default
+};

package/dist/{sync-EA5HZMXM.js → sync-DT5UJMMR.js}

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
+import {
+  paint
+} from "./chunk-NLNH64A3.js";
 import {
   regenerateBindingsSnapshot
-} from "./chunk-H3FE6VIK.js";
+} from "./chunk-PTGQAZEW.js";
 import "./chunk-EOT63RDH.js";
-import {
-  getProjectTranslator
-} from "./chunk-2CY4BMTH.js";
+import "./chunk-QFIVFZRH.js";
 import {
   loadGlobalConfig,
   resolveGlobalRoot
-} from "./chunk-XCBVSGCS.js";
+} from "./chunk-FNHDQTPC.js";
+import {
+  getProjectTranslator
+} from "./chunk-HORSMSZL.js";
 
 // src/commands/sync.ts
 import { defineCommand } from "citty";
@@ -18,7 +22,7 @@ import { defineCommand } from "citty";
 import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
 import { join } from "path";
-import { GLOBAL_STATE_DIR, storeRelativePath } from "@fenglimg/fabric-shared";
+import { GLOBAL_STATE_DIR, storeRelativePathForMount } from "@fenglimg/fabric-shared";
 import { GenericIOError } from "@fenglimg/fabric-shared/errors";
 
 // src/sync/state-machine.ts
@@ -273,7 +277,7 @@ function runStartSync(options) {
   const session = planSync(
     syncable.map((store) => ({ alias: store.alias, store_uuid: store.store_uuid }))
   );
-  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  const storeDirOf = makeStoreDirResolver(globalRoot, config.stores);
   const pushableAliases = pushableAliasesOf(config);
   const walked = walkPending(
     session,
@@ -290,6 +294,16 @@ function pushableAliasesOf(config) {
     config.stores.filter((store) => store.remote !== void 0 && (store.writable ?? true)).map((store) => store.alias)
   );
 }
+function makeStoreDirResolver(globalRoot, stores) {
+  return (status) => join(
+    globalRoot,
+    storeRelativePathForMount(
+      stores.find((store) => store.store_uuid === status.store_uuid) ?? {
+        store_uuid: status.store_uuid
+      }
+    )
+  );
+}
 function runContinueSync(options) {
   const globalRoot = options.globalRoot ?? resolveGlobalRoot();
   const session = loadSession(globalRoot);
@@ -304,9 +318,10 @@ function runContinueSync(options) {
       actionHint: "The sync is not paused on a conflict; there is nothing to resume."
     });
   }
-  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  const resumeConfig = loadGlobalConfig(globalRoot) ?? { stores: [] };
+  const storeDirOf = makeStoreDirResolver(globalRoot, resumeConfig.stores);
   (options.rebaseContinue ?? defaultRebaseContinue)(storeDirOf(conflicted));
-  const pushableAliases = pushableAliasesOf(loadGlobalConfig(globalRoot) ?? { stores: [] });
+  const pushableAliases = pushableAliasesOf(resumeConfig);
   const push = options.push ?? defaultPush;
   let advanced;
   if (pushableAliases.has(conflicted.alias)) {
@@ -343,9 +358,10 @@ function runAbortSync(options) {
       actionHint: "The sync is not paused on a conflict; there is nothing to resume."
     });
   }
-  const storeDirOf = (status) => join(globalRoot, storeRelativePath(status.store_uuid));
+  const resumeConfig = loadGlobalConfig(globalRoot) ?? { stores: [] };
+  const storeDirOf = makeStoreDirResolver(globalRoot, resumeConfig.stores);
   (options.rebaseAbort ?? defaultRebaseAbort)(storeDirOf(conflicted));
-  const pushableAliases = pushableAliasesOf(loadGlobalConfig(globalRoot) ?? { stores: [] });
+  const pushableAliases = pushableAliasesOf(resumeConfig);
   const resumed = walkPending(
     abortSync(session),
     storeDirOf,
@@ -370,7 +386,7 @@ function report(result, projectRoot) {
     console.log(t("cli.sync.paused"));
   }
 }
-var sync_default = defineCommand({
+var syncCommand = defineCommand({
   meta: { name: "sync", description: "Pull --rebase + push every mounted store; resume conflicts" },
   args: {
     continue: { type: "boolean", description: "Resume after resolving a rebase conflict" },
@@ -378,6 +394,11 @@ var sync_default = defineCommand({
   },
   run({ args }) {
     const projectRoot = process.cwd();
+    if (args.continue === true && args.abort === true) {
+      console.error(paint.error("fabric sync: --continue and --abort cannot be used together"));
+      process.exitCode = 1;
+      return;
+    }
     const options = { projectRoot, now: (/* @__PURE__ */ new Date()).toISOString() };
     if (args.continue === true) {
       report(runContinueSync(options), projectRoot);
@@ -390,6 +411,8 @@ var sync_default = defineCommand({
     report(runStartSync(options), projectRoot);
   }
 });
+var sync_default = syncCommand;
 export {
-  sync_default as default
+  sync_default as default,
+  syncCommand
 };