@mp-lb/forum-cli 0.1.5 → 0.1.6

package/dist/index.js

@@ -1753,15 +1753,362 @@ var require_jsx_runtime = __commonJS({
   }
 });
 
+// src/createCheckoutIgnoreMatcher.ts
+import ignore from "ignore";
+
+// src/mapSyncRulePath.ts
+var assertSafeRelativePath = (relativePath) => {
+  const segments2 = relativePath.split("/");
+  if (relativePath.startsWith("/") || segments2.some((segment) => segment === "." || segment === "..")) {
+    throw new Error(`Unsafe checkout path: ${relativePath}`);
+  }
+};
+var toRelativePath = (storePath) => {
+  const relativePath = storePath.replace(/^\/+/, "");
+  assertSafeRelativePath(relativePath);
+  return relativePath;
+};
+var joinRelativePath = (...parts) => parts.flatMap((part) => part.split("/")).filter(Boolean).join("/");
+var addLeadingSlash = (relativePath) => relativePath ? `/${relativePath}` : "/";
+var stripSyncRuleTarget = (localRelativePath, rule) => {
+  if (!rule.target) {
+    return localRelativePath;
+  }
+  if (localRelativePath === rule.target) {
+    return "";
+  }
+  if (!localRelativePath.startsWith(`${rule.target}/`)) {
+    return null;
+  }
+  return localRelativePath.slice(rule.target.length + 1);
+};
+var mapLocalPathToSyncRuleRemotePath = (localStorePath, rule) => {
+  const localRelativePath = toRelativePath(localStorePath);
+  const ruleRelativePath = stripSyncRuleTarget(localRelativePath, rule);
+  if (ruleRelativePath === null) {
+    throw new Error(
+      `Path is outside sync rule target ${rule.target || "."}: ${localRelativePath}`
+    );
+  }
+  return addLeadingSlash(joinRelativePath(rule.path, ruleRelativePath));
+};
+var mapRemotePathToSyncRuleLocalPath = (remoteStorePath, rule) => {
+  const remoteRelativePath = toRelativePath(remoteStorePath);
+  if (rule.path && remoteRelativePath !== rule.path && !remoteRelativePath.startsWith(`${rule.path}/`)) {
+    throw new Error(
+      `Remote path is outside sync rule path ${rule.path}: ${remoteRelativePath}`
+    );
+  }
+  const ruleRelativePath = rule.path ? remoteRelativePath === rule.path ? "" : remoteRelativePath.slice(rule.path.length + 1) : remoteRelativePath;
+  return addLeadingSlash(joinRelativePath(rule.target, ruleRelativePath));
+};
+
+// src/createCheckoutIgnoreMatcher.ts
+var createCheckoutIgnoreMatcher = (rule, sharedPatterns, personalPatterns) => {
+  const matcher = ignore().add([...sharedPatterns, ...personalPatterns]);
+  return {
+    ignores: (candidate) => {
+      const local = candidate.replace(/\/$/, "");
+      if (rule.target && local !== rule.target && !local.startsWith(`${rule.target}/`))
+        return false;
+      const remote = mapLocalPathToSyncRuleRemotePath(local, rule).replace(
+        /^\//,
+        ""
+      );
+      return remote !== "" && matcher.ignores(candidate.endsWith("/") ? `${remote}/` : remote);
+    }
+  };
+};
+
+// src/checkoutIgnore.ts
+import path3 from "path";
+
+// src/sharedIgnoreFile.ts
+import path2 from "path";
+import { readFile } from "fs/promises";
+
+// ../../packages/core/src/storeIgnore.ts
+var segments = (relativePath) => relativePath.split("/").filter(Boolean);
+var basename = (relativePath) => {
+  const parts = segments(relativePath);
+  return parts[parts.length - 1] ?? "";
+};
+var dirRule = (name) => ({
+  label: name,
+  pattern: `${name}/`,
+  matches: (relativePath) => segments(relativePath).slice(0, -1).includes(name)
+});
+var ENV_EXAMPLE_SUFFIXES = [".example", ".sample", ".template", ".dist"];
+var envRule = {
+  label: ".env",
+  pattern: ".env",
+  matches: (relativePath) => {
+    const name = basename(relativePath);
+    if (name !== ".env" && !name.startsWith(".env.")) {
+      return false;
+    }
+    return !ENV_EXAMPLE_SUFFIXES.some((suffix) => name.endsWith(suffix));
+  }
+};
+var logRule = {
+  label: "*.log",
+  pattern: "*.log",
+  matches: (relativePath) => basename(relativePath).endsWith(".log")
+};
+var vitepressRule = {
+  label: ".vitepress/cache",
+  pattern: ".vitepress/cache/",
+  matches: (relativePath) => relativePath.includes(".vitepress/cache/") || relativePath.includes(".vitepress/dist/")
+};
+var KNOWN_JUNK_RULES = [
+  dirRule("node_modules"),
+  dirRule("dist"),
+  dirRule("build"),
+  dirRule(".next"),
+  dirRule(".nuxt"),
+  dirRule(".svelte-kit"),
+  dirRule(".turbo"),
+  dirRule(".cache"),
+  dirRule("coverage"),
+  dirRule("target"),
+  dirRule("__pycache__"),
+  dirRule(".venv"),
+  vitepressRule,
+  envRule,
+  logRule
+];
+var detectJunk = (paths, rules = KNOWN_JUNK_RULES) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const path22 of paths) {
+    const rule = rules.find((candidate) => candidate.matches(path22));
+    if (!rule) continue;
+    const existing = grouped.get(rule);
+    if (existing) existing.push(path22);
+    else grouped.set(rule, [path22]);
+  }
+  return rules.filter((rule) => grouped.has(rule)).map((rule) => ({
+    rule,
+    paths: [...grouped.get(rule) ?? []].sort(
+      (left, right) => left < right ? -1 : left > right ? 1 : 0
+    )
+  }));
+};
+var IGNORE_PROPOSAL_RULES = [
+  { marker: "package.json", markerKind: "file", patterns: ["node_modules/"] },
+  { marker: ".vitepress", markerKind: "dir", patterns: [".vitepress/cache/"] },
+  { marker: "next.config.js", markerKind: "file", patterns: [".next/"] },
+  { marker: "next.config.mjs", markerKind: "file", patterns: [".next/"] },
+  { marker: "Cargo.toml", markerKind: "file", patterns: ["target/"] },
+  {
+    marker: "pyproject.toml",
+    markerKind: "file",
+    patterns: ["__pycache__/", ".venv/"]
+  }
+];
+var analyzeIgnoreSignals = ({
+  presentPaths,
+  presentMarkers,
+  gitignorePatterns = [],
+  rules = KNOWN_JUNK_RULES,
+  proposalRules = IGNORE_PROPOSAL_RULES
+}) => {
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (finding) => {
+    if (seen.has(finding.pattern)) return;
+    seen.add(finding.pattern);
+    findings.push(finding);
+  };
+  for (const group of detectJunk(presentPaths, rules)) {
+    add({
+      source: "present",
+      severity: "imminent",
+      label: group.rule.label,
+      pattern: group.rule.pattern,
+      matchedPaths: group.paths
+    });
+  }
+  for (const rule of proposalRules) {
+    if (!presentMarkers.has(rule.marker)) continue;
+    for (const pattern of rule.patterns) {
+      add({
+        source: "marker",
+        severity: "predicted",
+        label: `${rule.marker} \u2192 ${pattern}`,
+        pattern,
+        matchedPaths: []
+      });
+    }
+  }
+  for (const pattern of gitignorePatterns) {
+    if (!pattern.trim()) continue;
+    findings.push({
+      source: "gitignore",
+      severity: "predicted",
+      label: pattern,
+      pattern,
+      matchedPaths: []
+    });
+  }
+  const maxSeverity = findings.some(
+    (finding) => finding.severity === "imminent"
+  ) ? "imminent" : findings.length > 0 ? "predicted" : null;
+  return {
+    findings,
+    proposedPatterns: findings.map((finding) => finding.pattern),
+    maxSeverity
+  };
+};
+var parseLocalIgnoreFile = (text) => text.split(/\r?\n/).filter((line) => line.length > 0);
+
+// src/atomicWriteTextFile.ts
+import path from "path";
+import { chmod, mkdir, rename, rm, writeFile } from "fs/promises";
+var atomicWriteTextFile = async (filePath, text, isExecutable = false) => {
+  const parentDir = path.dirname(filePath);
+  const tempPath = path.join(
+    parentDir,
+    `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+  );
+  await mkdir(parentDir, { recursive: true });
+  try {
+    await writeFile(tempPath, text, "utf8");
+    await chmod(tempPath, isExecutable ? 493 : 420);
+    await rename(tempPath, filePath);
+  } catch (error51) {
+    await rm(tempPath, { force: true }).catch(() => {
+    });
+    throw error51;
+  }
+};
+
+// src/planSharedIgnore.ts
+var equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+var planSharedIgnore = ({
+  base,
+  local,
+  remote
+}) => {
+  if (local === null) return { action: "restore", patterns: remote };
+  if (equal(local, remote)) return { action: "unchanged", patterns: local };
+  if (base === null) return { action: "conflict", patterns: local };
+  if (equal(local, base)) return { action: "retrieve", patterns: remote };
+  if (equal(remote, base)) return { action: "publish", patterns: local };
+  return { action: "conflict", patterns: local };
+};
+
+// src/sharedIgnoreFile.ts
+var readSharedIgnoreFile = async (filePath) => {
+  try {
+    return parseLocalIgnoreFile(await readFile(filePath, "utf8"));
+  } catch (error51) {
+    if (error51.code === "ENOENT") return null;
+    throw error51;
+  }
+};
+var writeSharedIgnoreFile = async (filePath, patterns) => {
+  await atomicWriteTextFile(
+    filePath,
+    patterns.length ? `${patterns.join("\n")}
+` : ""
+  );
+};
+var readState = async (statePath) => {
+  try {
+    return JSON.parse(await readFile(statePath, "utf8"));
+  } catch (error51) {
+    if (error51.code === "ENOENT") return {};
+    throw error51;
+  }
+};
+var reconcileSharedIgnoreFile = async ({
+  rootDir,
+  sharedFilePath,
+  store,
+  remote,
+  publish,
+  dryRun = false
+}) => {
+  const statePath = path2.join(rootDir, ".forum", "ignore-state.json");
+  const state = await readState(statePath);
+  const local = await readSharedIgnoreFile(sharedFilePath);
+  const plan = planSharedIgnore({ base: state[store] ?? null, local, remote });
+  if (dryRun || plan.action === "conflict") return plan;
+  if (plan.action === "publish") await publish(plan.patterns);
+  if (plan.action === "retrieve" || plan.action === "restore") {
+    await writeSharedIgnoreFile(sharedFilePath, plan.patterns);
+  }
+  if (JSON.stringify(state[store]) !== JSON.stringify(plan.patterns)) {
+    state[store] = plan.patterns;
+    await atomicWriteTextFile(statePath, `${JSON.stringify(state, null, 2)}
+`);
+  }
+  return plan;
+};
+
+// src/checkoutIgnore.ts
+var sharedIgnorePath = (rootDir, store) => path3.join(rootDir, ".forum", "stores", encodeURIComponent(store), "ignore");
+var prepareCheckoutIgnore = async ({
+  rootDir,
+  syncRules,
+  client,
+  dryRun = false
+}) => {
+  const personal = await readSharedIgnoreFile(path3.join(rootDir, ".forum/usr_ignore")) ?? [];
+  const patternsByStore = {};
+  const changes = [];
+  for (const rule of syncRules) {
+    if (patternsByStore[rule.store]) continue;
+    const storeRef = {
+      workspaceSlug: rule.storeOwner,
+      storeSlug: rule.storeSlug
+    };
+    const metadata = await client.readStoreByRef(storeRef);
+    if (!metadata) throw new Error(`Store not found: ${rule.store}`);
+    const sharedFilePath = sharedIgnorePath(rootDir, rule.store);
+    const plan = await reconcileSharedIgnoreFile({
+      rootDir,
+      sharedFilePath,
+      store: rule.store,
+      remote: metadata.ignore ?? [],
+      dryRun,
+      publish: async (patterns) => {
+        await client.syncStoreIgnoreByRef({
+          ...storeRef,
+          expectedIgnore: metadata.ignore ?? [],
+          ignore: patterns
+        });
+      }
+    });
+    patternsByStore[rule.store] = [...plan.patterns, ...personal];
+    if (plan.action !== "unchanged")
+      changes.push({
+        ...plan,
+        relativePath: path3.relative(rootDir, sharedFilePath),
+        store: rule.store
+      });
+  }
+  const matchersByRule = {};
+  for (const rule of syncRules) {
+    const patterns = patternsByStore[rule.store];
+    matchersByRule[rule.id] = createCheckoutIgnoreMatcher(
+      rule,
+      patterns.slice(0, patterns.length - personal.length),
+      personal
+    );
+  }
+  return { patternsByStore, changes, matchersByRule };
+};
+
 // src/index.ts
 import { realpathSync, watch as watch2 } from "fs";
-import path19 from "path";
+import path21 from "path";
 import {
   lstat as lstat2,
-  mkdir as mkdir5,
-  readFile as readFile7,
+  mkdir as mkdir6,
+  readFile as readFile8,
   rename as rename4,
-  rm as rm4,
+  rm as rm5,
   writeFile as writeFile6
 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline/promises";
@@ -2534,10 +2881,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path20) {
-  if (!path20)
+function getElementAtPath(obj, path22) {
+  if (!path22)
     return obj;
-  return path20.reduce((acc, key) => acc?.[key], obj);
+  return path22.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2946,11 +3293,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path20, issues) {
+function prefixIssues(path22, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path20);
+    iss.path.unshift(path22);
     return iss;
   });
 }
@@ -3097,16 +3444,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path20 = []) => {
+  const processError = (error52, path22 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path20, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path20, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -3133,17 +3480,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path20 = []) => {
+  const processError = (error52, path22 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path20, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path20, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3175,8 +3522,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path20) {
+  const path22 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path22) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -15868,13 +16215,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path20 = ref.slice(1).split("/").filter(Boolean);
-  if (path20.length === 0) {
+  const path22 = ref.slice(1).split("/").filter(Boolean);
+  if (path22.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path20[0] === defsKey) {
-    const key = path20[1];
+  if (path22[0] === defsKey) {
+    const key = path22[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17212,8 +17559,8 @@ var normalizeStorePath = (value) => {
   }
   return segments2.length === 0 ? "/" : `/${segments2.join("/")}`;
 };
-var storePathToArray = (path20) => {
-  const normalizedPath = normalizeStorePath(path20);
+var storePathToArray = (path22) => {
+  const normalizedPath = normalizeStorePath(path22);
   return normalizedPath === "/" ? [] : normalizedPath.split("/").filter(Boolean);
 };
 var storePathSchema = external_exports.string().trim().min(1).transform((value) => normalizeStorePath(value));
@@ -18289,7 +18636,7 @@ var storeVisibilityValueSchema = external_exports.union([
 var storeVisibilitySchema = storeVisibilityValueSchema.default(
   WORKSPACE_STORE_VISIBILITY
 );
-var storeIgnorePatternsSchema = external_exports.array(external_exports.string().trim().min(1));
+var storeIgnorePatternsSchema = external_exports.array(external_exports.string().min(1));
 var storeSearchSettingsSchema = external_exports.object({
   enabled: external_exports.boolean().default(false),
   semanticEnabled: external_exports.boolean().default(false),
@@ -18434,10 +18781,15 @@ var pinnedStoreIdsValueSchema = external_exports.array(storePreferenceIdSchema);
 var recentStoresValueSchema = external_exports.array(recentStoreVisitSchema);
 var pinnedStoreIdsSchema = pinnedStoreIdsValueSchema.default([]);
 var recentStoresSchema = recentStoresValueSchema.default([]);
+var createTypeLastUsedAtSchema = external_exports.record(
+  external_exports.string().min(1).max(100),
+  external_exports.string().datetime()
+);
 var userPreferencesSchema = external_exports.object({
   id: storeOwnerIdSchema,
   pinnedStoreIds: pinnedStoreIdsSchema,
   recentStores: recentStoresSchema,
+  createTypeLastUsedAt: createTypeLastUsedAtSchema.default({}),
   recentStoresEnabled: external_exports.boolean().default(true),
   showHomeWelcomeBanner: external_exports.boolean().default(true),
   showHiddenFiles: external_exports.boolean().default(false),
@@ -18457,6 +18809,7 @@ var userPreferencesSchema = external_exports.object({
 var userPreferencesUpdateSchema = external_exports.object({
   pinnedStoreIds: pinnedStoreIdsValueSchema,
   recentStores: recentStoresValueSchema,
+  createTypeLastUsedAt: createTypeLastUsedAtSchema,
   recentStoresEnabled: external_exports.boolean(),
   showHomeWelcomeBanner: external_exports.boolean(),
   showHiddenFiles: external_exports.boolean(),
@@ -19189,21 +19542,21 @@ var isKey = (value) => /^\w*$/.test(value);
 var isUndefined = (val) => val === void 0;
 var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : [];
 var stringToPath = (input) => compact(input.replace(/["|']|\]/g, "").split(/\.|\[/));
-var get = (object2, path20, defaultValue) => {
-  if (!path20 || !isObject2(object2)) {
+var get = (object2, path22, defaultValue) => {
+  if (!path22 || !isObject2(object2)) {
     return defaultValue;
   }
-  const paths = isKey(path20) ? [path20] : stringToPath(path20);
+  const paths = isKey(path22) ? [path22] : stringToPath(path22);
   const result = paths.reduce((result2, key) => {
     return isNullOrUndefined(result2) ? void 0 : result2[key];
   }, object2);
-  return isUndefined(result) || result === object2 ? isUndefined(object2[path20]) ? defaultValue : object2[path20] : result;
+  return isUndefined(result) || result === object2 ? isUndefined(object2[path22]) ? defaultValue : object2[path22] : result;
 };
 var isBoolean = (value) => typeof value === "boolean";
 var isFunction = (value) => typeof value === "function";
-var set2 = (object2, path20, value) => {
+var set2 = (object2, path22, value) => {
   let index = -1;
-  const tempPath = isKey(path20) ? [path20] : stringToPath(path20);
+  const tempPath = isKey(path22) ? [path22] : stringToPath(path22);
   const length = tempPath.length;
   const lastIndex = length - 1;
   while (++index < length) {
@@ -19401,12 +19754,12 @@ function isEmptyArray(obj) {
   }
   return true;
 }
-function unset(object2, path20) {
-  if (isString(path20) && Object.prototype.hasOwnProperty.call(object2, path20)) {
-    delete object2[path20];
+function unset(object2, path22) {
+  if (isString(path22) && Object.prototype.hasOwnProperty.call(object2, path22)) {
+    delete object2[path22];
     return object2;
   }
-  const paths = Array.isArray(path20) ? path20 : isKey(path20) ? [path20] : stringToPath(path20);
+  const paths = Array.isArray(path22) ? path22 : isKey(path22) ? [path22] : stringToPath(path22);
   const childObject = paths.length === 1 ? object2 : baseGet(object2, paths);
   const index = paths.length - 1;
   const key = paths[index];
@@ -23131,7 +23484,7 @@ var publicActionSubmitResultSchema = external_exports.unknown();
 
 // ../../packages/core/src/widgetRuntime.ts
 var widgetRuntimeOutputPathSchema = storePathSchema.refine(
-  (path20) => path20 !== "/",
+  (path22) => path22 !== "/",
   {
     message: "Path must not be the root directory."
   }
@@ -23181,7 +23534,7 @@ var widgetRuntimeCompleteAttachmentUploadInputSchema = storeRefSchema.safeExtend
   treeVisibility: external_exports.enum(["visible", "hidden"]).optional(),
   uploadIntentId: external_exports.string().trim().min(1)
 });
-var widgetRuntimeLinkPathSchema = external_exports.string().trim().min(1).max(2048).refine((path20) => path20.startsWith("/") && !path20.startsWith("//"), {
+var widgetRuntimeLinkPathSchema = external_exports.string().trim().min(1).max(2048).refine((path22) => path22.startsWith("/") && !path22.startsWith("//"), {
   message: "Link path must be a relative application path."
 });
 var widgetRuntimeCreateSigningLinkInputSchema = storeRefSchema.safeExtend({
@@ -23232,168 +23585,10 @@ var storeMemberSchema = external_exports.object({
   createdAt: external_exports.string().datetime().default(() => (/* @__PURE__ */ new Date()).toISOString())
 });
 
-// ../../packages/core/src/storeIgnore.ts
-var segments = (relativePath) => relativePath.split("/").filter(Boolean);
-var basename = (relativePath) => {
-  const parts = segments(relativePath);
-  return parts[parts.length - 1] ?? "";
-};
-var dirRule = (name) => ({
-  label: name,
-  pattern: `${name}/`,
-  matches: (relativePath) => segments(relativePath).slice(0, -1).includes(name)
-});
-var ENV_EXAMPLE_SUFFIXES = [".example", ".sample", ".template", ".dist"];
-var envRule = {
-  label: ".env",
-  pattern: ".env",
-  matches: (relativePath) => {
-    const name = basename(relativePath);
-    if (name !== ".env" && !name.startsWith(".env.")) {
-      return false;
-    }
-    return !ENV_EXAMPLE_SUFFIXES.some((suffix) => name.endsWith(suffix));
-  }
-};
-var logRule = {
-  label: "*.log",
-  pattern: "*.log",
-  matches: (relativePath) => basename(relativePath).endsWith(".log")
-};
-var vitepressRule = {
-  label: ".vitepress/cache",
-  pattern: ".vitepress/cache/",
-  matches: (relativePath) => relativePath.includes(".vitepress/cache/") || relativePath.includes(".vitepress/dist/")
-};
-var KNOWN_JUNK_RULES = [
-  dirRule("node_modules"),
-  dirRule("dist"),
-  dirRule("build"),
-  dirRule(".next"),
-  dirRule(".nuxt"),
-  dirRule(".svelte-kit"),
-  dirRule(".turbo"),
-  dirRule(".cache"),
-  dirRule("coverage"),
-  dirRule("target"),
-  dirRule("__pycache__"),
-  dirRule(".venv"),
-  vitepressRule,
-  envRule,
-  logRule
-];
-var detectJunk = (paths, rules = KNOWN_JUNK_RULES) => {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const path20 of paths) {
-    const rule = rules.find((candidate) => candidate.matches(path20));
-    if (!rule) continue;
-    const existing = grouped.get(rule);
-    if (existing) existing.push(path20);
-    else grouped.set(rule, [path20]);
-  }
-  return rules.filter((rule) => grouped.has(rule)).map((rule) => ({
-    rule,
-    paths: [...grouped.get(rule) ?? []].sort(
-      (left, right) => left < right ? -1 : left > right ? 1 : 0
-    )
-  }));
-};
-var IGNORE_PROPOSAL_RULES = [
-  { marker: "package.json", markerKind: "file", patterns: ["node_modules/"] },
-  { marker: ".vitepress", markerKind: "dir", patterns: [".vitepress/cache/"] },
-  { marker: "next.config.js", markerKind: "file", patterns: [".next/"] },
-  { marker: "next.config.mjs", markerKind: "file", patterns: [".next/"] },
-  { marker: "Cargo.toml", markerKind: "file", patterns: ["target/"] },
-  {
-    marker: "pyproject.toml",
-    markerKind: "file",
-    patterns: ["__pycache__/", ".venv/"]
-  }
-];
-var analyzeIgnoreSignals = ({
-  presentPaths,
-  presentMarkers,
-  gitignorePatterns = [],
-  rules = KNOWN_JUNK_RULES,
-  proposalRules = IGNORE_PROPOSAL_RULES
-}) => {
-  const findings = [];
-  const seen = /* @__PURE__ */ new Set();
-  const add = (finding) => {
-    if (seen.has(finding.pattern)) return;
-    seen.add(finding.pattern);
-    findings.push(finding);
-  };
-  for (const group of detectJunk(presentPaths, rules)) {
-    add({
-      source: "present",
-      severity: "imminent",
-      label: group.rule.label,
-      pattern: group.rule.pattern,
-      matchedPaths: group.paths
-    });
-  }
-  for (const rule of proposalRules) {
-    if (!presentMarkers.has(rule.marker)) continue;
-    for (const pattern of rule.patterns) {
-      add({
-        source: "marker",
-        severity: "predicted",
-        label: `${rule.marker} \u2192 ${pattern}`,
-        pattern,
-        matchedPaths: []
-      });
-    }
-  }
-  for (const pattern of gitignorePatterns) {
-    const trimmed = pattern.trim();
-    if (!trimmed) continue;
-    add({
-      source: "gitignore",
-      severity: "predicted",
-      label: trimmed,
-      pattern: trimmed,
-      matchedPaths: []
-    });
-  }
-  const maxSeverity = findings.some(
-    (finding) => finding.severity === "imminent"
-  ) ? "imminent" : findings.length > 0 ? "predicted" : null;
-  return {
-    findings,
-    proposedPatterns: findings.map((finding) => finding.pattern),
-    maxSeverity
-  };
-};
-var resolveIgnorePatterns = ({
-  bakedIn,
-  storeSetting,
-  localOverride
-}) => {
-  const seen = /* @__PURE__ */ new Set();
-  const resolved = [];
-  for (const pattern of [...bakedIn, ...storeSetting, ...localOverride]) {
-    const trimmed = pattern.trim();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    resolved.push(trimmed);
-  }
-  return resolved;
-};
-var parseLocalIgnoreFile = (text) => {
-  const patterns = [];
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    patterns.push(line);
-  }
-  return patterns;
-};
-
 // ../../packages/store-tree/src/patterns.ts
 var escapeRegex2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var basename2 = (path20) => {
-  const segments2 = path20.split("/").filter(Boolean);
+var basename2 = (path22) => {
+  const segments2 = path22.split("/").filter(Boolean);
   return segments2[segments2.length - 1] ?? "";
 };
 var normalizeStorePathPattern = (pattern) => pattern.trim();
@@ -23411,7 +23606,7 @@ var storePathPatternToRegex = (pattern) => {
   return new RegExp(source, "i");
 };
 var doesStorePathPatternMatch = ({
-  path: path20,
+  path: path22,
   pattern,
   mode = "path"
 }) => {
@@ -23419,7 +23614,7 @@ var doesStorePathPatternMatch = ({
   if (!normalizedPattern) {
     return true;
   }
-  const normalizedPath = normalizeStorePath(path20);
+  const normalizedPath = normalizeStorePath(path22);
   const target = mode === "basename" ? basename2(normalizedPath) : normalizedPath;
   if (patternHasWildcard(normalizedPattern)) {
     return storePathPatternToRegex(normalizedPattern).test(target);
@@ -23507,8 +23702,8 @@ var isIssueRecord = (value) => {
   return isRecord2(value) && typeof value.message === "string";
 };
 var formatIssue = (issue2) => {
-  const path20 = Array.isArray(issue2.path) && issue2.path.length > 0 ? issue2.path.map(String).join(".") : "";
-  return path20 ? `${path20}: ${issue2.message}` : issue2.message;
+  const path22 = Array.isArray(issue2.path) && issue2.path.length > 0 ? issue2.path.map(String).join(".") : "";
+  return path22 ? `${path22}: ${issue2.message}` : issue2.message;
 };
 var formatIssueArray = (issues) => {
   if (!issues.every(isIssueRecord)) {
@@ -23981,7 +24176,7 @@ var buildContentChangedConflictExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} changed both locally and remotely.`,
+        (path22) => `${path22} changed both locally and remotely.`,
         (count) => `${count} files changed both locally and remotely.`
       ),
       "Forum left these files alone because either overwrite direction could lose work."
@@ -24013,7 +24208,7 @@ var buildLocalDeleteRemoteChangeExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} was deleted locally, but the remote file changed.`,
+        (path22) => `${path22} was deleted locally, but the remote file changed.`,
         (count) => `${count} files were deleted locally, but changed remotely.`
       ),
       "Forum did not delete newer remote work automatically."
@@ -24045,7 +24240,7 @@ var buildMoveDestinationConflictExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} is the destination of a remote move, but already exists locally.`,
+        (path22) => `${path22} is the destination of a remote move, but already exists locally.`,
         (count) => `${count} paths are remote move destinations that already exist locally.`
       ),
       "Forum synced unrelated files but left these paths alone."
@@ -24080,7 +24275,7 @@ var buildMoveRemoteChangeConflictExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} was involved in a move while the other side changed it.`,
+        (path22) => `${path22} was involved in a move while the other side changed it.`,
         (count) => `${count} files were involved in moves while the other side changed them.`
       ),
       "Forum did not combine the move and content change automatically."
@@ -24112,7 +24307,7 @@ var buildMoveMoveConflictExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} moved locally and remotely to different paths.`,
+        (path22) => `${path22} moved locally and remotely to different paths.`,
         (count) => `${count} files moved locally and remotely to different paths.`
       ),
       "Forum left these moves unresolved because choosing a path automatically could hide work."
@@ -24144,7 +24339,7 @@ var buildDeleteMoveConflictExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} was deleted on one side and moved on the other.`,
+        (path22) => `${path22} was deleted on one side and moved on the other.`,
         (count) => `${count} files were deleted on one side and moved on the other.`
       ),
       "Forum did not choose between delete and move automatically."
@@ -24176,7 +24371,7 @@ var buildReferenceLocalFileConflictExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} is now a remote reference, but the local file has changes.`,
+        (path22) => `${path22} is now a remote reference, but the local file has changes.`,
         (count) => `${count} paths are now remote references, but local files have changes.`
       ),
       "Forum left the local files alone because replacing them would discard local work."
@@ -24208,7 +24403,7 @@ var buildUnsupportedLocalEntryExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} is an unsupported local filesystem entry.`,
+        (path22) => `${path22} is an unsupported local filesystem entry.`,
         (count) => `${count} local filesystem entries are unsupported.`
       ),
       "Forum skipped these paths and continued with unrelated files where it could."
@@ -24240,7 +24435,7 @@ var buildReadOnlyLocalChangeExplainer = (issues) => {
     body: [
       pathSubject(
         paths,
-        (path20) => `${path20} has local changes, but its sync rule is read-only.`,
+        (path22) => `${path22} has local changes, but its sync rule is read-only.`,
         (count) => `${count} files have local changes, but their sync rules are read-only.`
       ),
       "Forum left these files alone so remote updates cannot overwrite local work."
@@ -24337,7 +24532,7 @@ var checkoutConflictIssuesFromResult = (result) => checkoutIssuesFromResult(resu
   (issue2) => issue2.type === "conflict"
 );
 var formatCheckoutExplainer = (explainer) => {
-  const pathLines = explainer.paths.length <= 1 ? [] : ["", ...formatPathList(explainer.paths).map((path20) => `  ${path20}`)];
+  const pathLines = explainer.paths.length <= 1 ? [] : ["", ...formatPathList(explainer.paths).map((path22) => `  ${path22}`)];
   const actionLines = explainer.actions.map(
     (action) => `${styleText.bold(`${action.label}:`)} ${action.text}`
   );
@@ -24361,7 +24556,7 @@ var formatCheckoutExplainers = (result) => {
 
 // src/gitIntegration.ts
 import { execFile as execFile2 } from "child_process";
-import path from "path";
+import path4 from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile2);
 var gitErrorMessage = (error51) => {
@@ -24386,7 +24581,7 @@ var runGit = async (cwd, args) => {
 };
 var resolveGitRoot = async (cwd) => {
   const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
-  return path.resolve(cwd, result.stdout.trim());
+  return path4.resolve(cwd, result.stdout.trim());
 };
 var readGitStatusEntries = async (gitRoot) => {
   const result = await runGit(gitRoot, [
@@ -24466,59 +24661,80 @@ var commitGitChanges = async (gitRoot, message) => {
 };
 
 // src/checkoutNaming.ts
-import { existsSync } from "fs";
-import path2 from "path";
-var projectConfigFilenames = [
-  "forum.yaml",
-  "forum.yml",
-  "doctrine.yaml",
-  "doctrine.yml"
-];
-var defaultProjectConfigFilename = "forum.yaml";
-var checkoutStateDirectoryNames = [".forum", ".doctrine"];
+var defaultProjectConfigFilename = ".forum/sync.yaml";
+var projectConfigFilenames = [defaultProjectConfigFilename];
+var checkoutStateDirectoryNames = [".forum"];
 var defaultCheckoutStateDirectoryName = ".forum";
-var resolveCheckoutStateDirectoryName = (rootDir) => {
-  for (const name of checkoutStateDirectoryNames) {
-    if (existsSync(path2.join(rootDir, name))) {
-      return name;
+var resolveCheckoutStateDirectoryName = () => defaultCheckoutStateDirectoryName;
+var isCheckoutStateDirectoryPath = (relativePath) => relativePath.split("/").includes(defaultCheckoutStateDirectoryName);
+
+// src/resolveAmbiguousSyncMoves.ts
+import { rm as rm2 } from "fs/promises";
+import path5 from "path";
+var resolveAmbiguousSyncMoves = async ({
+  conflictPolicy,
+  dryRun,
+  localPath,
+  manifestFiles,
+  snapshot,
+  structuralPreflight
+}) => {
+  const blocked = structuralPreflight.blockedDetails;
+  if (!conflictPolicy || !blocked.length || !blocked.every((detail) => detail.conflict?.type === "ambiguous-local-move"))
+    return [];
+  const details = [];
+  if (conflictPolicy === "remote") {
+    for (const { relativePath } of blocked) {
+      if (manifestFiles[relativePath]) {
+        manifestFiles[relativePath] = {
+          ...manifestFiles[relativePath],
+          remoteRevisionNumber: null
+        };
+      } else {
+        if (!dryRun)
+          await rm2(path5.join(localPath, relativePath), { force: true });
+        snapshot.localFileByPath.delete(relativePath);
+        snapshot.candidatePaths = snapshot.candidatePaths.filter(
+          (candidate) => candidate !== relativePath
+        );
+        details.push({ relativePath, status: "deleted" });
+      }
     }
   }
-  return defaultCheckoutStateDirectoryName;
+  structuralPreflight.blockedDetails = [];
+  return details;
 };
-var isCheckoutStateDirectoryPath = (relativePath) => checkoutStateDirectoryNames.some(
-  (name) => relativePath === name || relativePath.startsWith(`${name}/`)
-);
 
 // src/checkout.ts
 import { createHash as createHash2 } from "crypto";
-import path7 from "path";
+import path9 from "path";
 import {
   lstat,
-  mkdir as mkdir3,
+  mkdir as mkdir4,
   readdir as readdir2,
-  readFile as readFile2,
+  readFile as readFile3,
   rename as rename2,
-  rm as rm2,
+  rm as rm3,
   stat,
   writeFile as writeFile3
 } from "fs/promises";
 import { TextDecoder as TextDecoder2 } from "util";
-import ignore from "ignore";
+import ignore2 from "ignore";
 
 // src/buildCheckoutFileManifestEntry.ts
-var toManifestRemotePath = (path20) => path20.startsWith("/") ? path20 : `/${path20}`;
+var toManifestRemotePath = (path22) => path22.startsWith("/") ? path22 : `/${path22}`;
 var buildCheckoutFileManifestEntry = ({
   storageClass,
   hash: hash2,
   manifestEntry,
-  path: path20,
+  path: path22,
   remoteFile,
   source,
   syncedAt
 }) => {
   const remoteFileId = remoteFile.id ?? remoteFile._id ?? manifestEntry?.remoteFileId;
   if (!remoteFileId) {
-    throw new Error(`Remote file ${path20} did not include a file id`);
+    throw new Error(`Remote file ${path22} did not include a file id`);
   }
   return {
     storageClass,
@@ -24526,7 +24742,7 @@ var buildCheckoutFileManifestEntry = ({
     isExecutable: storageClass === "text" ? remoteFile.isExecutable === true || void 0 : void 0,
     lastSyncedAt: syncedAt,
     remoteFileId,
-    remotePath: remoteFile.path ?? manifestEntry?.remotePath ?? toManifestRemotePath(path20),
+    remotePath: remoteFile.path ?? manifestEntry?.remotePath ?? toManifestRemotePath(path22),
     remoteUpdatedAt: remoteFile.updatedAt ?? null,
     remoteRevisionNumber: remoteFile.revisionNumber ?? null,
     ...source ? { source } : {}
@@ -24628,14 +24844,14 @@ var buildSyncCheckoutSnapshot = ({
 };
 
 // src/checkoutDirectories.ts
-import path3 from "path";
-import { mkdir, readdir, rmdir } from "fs/promises";
+import path6 from "path";
+import { mkdir as mkdir2, readdir, rmdir } from "fs/promises";
 var parentDirectoriesForPath = (relativePath) => {
   const directories = [];
-  let directory = path3.posix.dirname(relativePath);
+  let directory = path6.posix.dirname(relativePath);
   while (directory && directory !== ".") {
     directories.push(directory);
-    directory = path3.posix.dirname(directory);
+    directory = path6.posix.dirname(directory);
   }
   return directories;
 };
@@ -24660,7 +24876,7 @@ var prepareCheckoutDirectories = async ({
   const directories = checkoutParentDirectories(relativePaths);
   await Promise.all(
     directories.map(
-      (directory) => mkdir(path3.join(localPath, directory), { recursive: true })
+      (directory) => mkdir2(path6.join(localPath, directory), { recursive: true })
     )
   );
   return directories;
@@ -24674,7 +24890,7 @@ var cleanupCheckoutDirectories = async ({
     if (checkoutStateDirectoryNames.includes(directory)) {
       continue;
     }
-    const absolutePath = path3.join(localPath, directory);
+    const absolutePath = path6.join(localPath, directory);
     try {
       const entries = await readdir(absolutePath);
       if (entries.length > 0) {
@@ -24697,13 +24913,13 @@ var cleanupCheckoutDirectories = async ({
 };
 
 // src/planRemoteDirectoryCleanup.ts
-import path4 from "path";
+import path7 from "path";
 var ancestorDirectories = (relativePath) => {
   const directories = [];
-  let directory = path4.posix.dirname(relativePath);
+  let directory = path7.posix.dirname(relativePath);
   while (directory && directory !== ".") {
     directories.push(directory);
-    directory = path4.posix.dirname(directory);
+    directory = path7.posix.dirname(directory);
   }
   return directories;
 };
@@ -24720,7 +24936,7 @@ var planRemoteDirectoryCleanup = (removedPaths) => {
 };
 
 // src/cleanupRemoteCheckoutDirectories.ts
-var addLeadingSlash = (relativePath) => relativePath ? `/${relativePath}` : "/";
+var addLeadingSlash2 = (relativePath) => relativePath ? `/${relativePath}` : "/";
 var cleanupRemoteCheckoutDirectories = async ({
   client,
   removedPaths,
@@ -24728,7 +24944,7 @@ var cleanupRemoteCheckoutDirectories = async ({
 }) => {
   const removed = [];
   for (const directory of planRemoteDirectoryCleanup(removedPaths)) {
-    const directoryPath = addLeadingSlash(directory);
+    const directoryPath = addLeadingSlash2(directory);
     try {
       const listing = await client.listDirectoryByRef({
         ...storeRef,
@@ -24751,53 +24967,6 @@ var cleanupRemoteCheckoutDirectories = async ({
   return removed;
 };
 
-// src/mapSyncRulePath.ts
-var assertSafeRelativePath = (relativePath) => {
-  const segments2 = relativePath.split("/");
-  if (relativePath.startsWith("/") || segments2.some((segment) => segment === "." || segment === "..")) {
-    throw new Error(`Unsafe checkout path: ${relativePath}`);
-  }
-};
-var toRelativePath = (storePath) => {
-  const relativePath = storePath.replace(/^\/+/, "");
-  assertSafeRelativePath(relativePath);
-  return relativePath;
-};
-var joinRelativePath = (...parts) => parts.flatMap((part) => part.split("/")).filter(Boolean).join("/");
-var addLeadingSlash2 = (relativePath) => relativePath ? `/${relativePath}` : "/";
-var stripSyncRuleTarget = (localRelativePath, rule) => {
-  if (!rule.target) {
-    return localRelativePath;
-  }
-  if (localRelativePath === rule.target) {
-    return "";
-  }
-  if (!localRelativePath.startsWith(`${rule.target}/`)) {
-    return null;
-  }
-  return localRelativePath.slice(rule.target.length + 1);
-};
-var mapLocalPathToSyncRuleRemotePath = (localStorePath, rule) => {
-  const localRelativePath = toRelativePath(localStorePath);
-  const ruleRelativePath = stripSyncRuleTarget(localRelativePath, rule);
-  if (ruleRelativePath === null) {
-    throw new Error(
-      `Path is outside sync rule target ${rule.target || "."}: ${localRelativePath}`
-    );
-  }
-  return addLeadingSlash2(joinRelativePath(rule.path, ruleRelativePath));
-};
-var mapRemotePathToSyncRuleLocalPath = (remoteStorePath, rule) => {
-  const remoteRelativePath = toRelativePath(remoteStorePath);
-  if (rule.path && remoteRelativePath !== rule.path && !remoteRelativePath.startsWith(`${rule.path}/`)) {
-    throw new Error(
-      `Remote path is outside sync rule path ${rule.path}: ${remoteRelativePath}`
-    );
-  }
-  const ruleRelativePath = rule.path ? remoteRelativePath === rule.path ? "" : remoteRelativePath.slice(rule.path.length + 1) : remoteRelativePath;
-  return addLeadingSlash2(joinRelativePath(rule.target, ruleRelativePath));
-};
-
 // src/planSyncCheckoutPaths.ts
 var detailRelatedPaths = (detail) => [
   detail.relativePath,
@@ -24971,6 +25140,8 @@ var planRemoteRenameBeforePull = ({
 
 // src/planSyncCheckoutFile.ts
 var planSyncCheckoutFile = ({
+  conflictPolicy,
+  resolvedConflict,
   force,
   localIsExecutable = false,
   localHash,
@@ -24983,6 +25154,34 @@ var planSyncCheckoutFile = ({
 }) => {
   const hasLocal = localHash !== null;
   const hasManifest = manifestHash !== null;
+  const localChanged = localHash !== manifestHash || localIsExecutable !== manifestIsExecutable;
+  if (resolvedConflict && remoteKind === "file") {
+    return {
+      type: resolvedConflict === "remote" ? "pullRemote" : hasLocal ? "pushLocal" : "deleteRemote"
+    };
+  }
+  if (conflictPolicy && remoteKind !== "reference") {
+    if (!hasLocal && hasManifest && remoteKind === "file") {
+      return {
+        type: conflictPolicy === "local" || !remoteVersionChanged ? "deleteRemote" : "pullRemote"
+      };
+    }
+    if (hasLocal && !hasManifest && (remoteKind === "file" || remotePathExists) && remoteHash !== localHash) {
+      return { type: conflictPolicy === "local" ? "pushLocal" : "pullRemote" };
+    }
+    if (hasLocal && hasManifest && localChanged) {
+      if (remoteKind === "missing" && !remotePathExists) {
+        return {
+          type: conflictPolicy === "local" ? "pushLocal" : "deleteLocal"
+        };
+      }
+      if (remoteVersionChanged) {
+        return {
+          type: conflictPolicy === "local" ? "pushLocal" : "pullRemote"
+        };
+      }
+    }
+  }
   if (remoteKind === "reference") {
     if (!force && (hasManifest || hasLocal)) {
       return {
@@ -25038,7 +25237,6 @@ var planSyncCheckoutFile = ({
       message: "untracked local file differs from the existing remote file; use fm push --force to keep local (recommended) or fm pull --force to accept remote"
     };
   }
-  const localChanged = localHash !== manifestHash || localIsExecutable !== manifestIsExecutable;
   if (!force && localChanged && remoteVersionChanged) {
     return {
       type: "conflict",
@@ -25081,19 +25279,9 @@ var selectCheckoutFilePathsForSyncRule = ({
 
 // src/projectConfig.ts
 import { createHash } from "crypto";
-import path5 from "path";
-import { access, readFile, writeFile } from "fs/promises";
+import path8 from "path";
+import { access, mkdir as mkdir3, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { parse as parse3, stringify } from "yaml";
-var warnedLegacyIgnorePaths = /* @__PURE__ */ new Set();
-var warnLegacyIgnoreField = (filePath) => {
-  if (warnedLegacyIgnorePaths.has(filePath)) {
-    return;
-  }
-  warnedLegacyIgnorePaths.add(filePath);
-  renderWarning(
-    `ignore in ${filePath} is no longer used; move these to the store with \`fm ignore add\`, or to .forum/ignore`
-  );
-};
 var fileExists = async (filePath) => {
   try {
     await access(filePath);
@@ -25126,7 +25314,9 @@ var parseProjectConfig = (filePath, source) => {
     );
   }
   if (ignore3 !== void 0) {
-    warnLegacyIgnoreField(filePath);
+    throw new Error(
+      `Invalid Forum config at ${filePath}: put shared ignore rules under .forum/stores/ or personal rules in .forum/usr_ignore.`
+    );
   }
   return {
     ...defaultStore ? { defaultStore } : {},
@@ -25207,7 +25397,7 @@ var normalizeSyncPath = ({
   value
 }) => {
   const trimmed = value.trim();
-  if (path5.isAbsolute(trimmed)) {
+  if (path8.isAbsolute(trimmed)) {
     throw new Error(
       `Invalid Forum config at ${filePath}: ${fieldName} must be a relative path.`
     );
@@ -25360,16 +25550,16 @@ var parseQualifiedConfigStore = (filePath, fieldName, store) => {
   return `${segments2[0]}/${segments2[1]}`;
 };
 var findForumProjectConfig = async (startDir = process.cwd()) => {
-  let current = path5.resolve(startDir);
+  let current = path8.resolve(startDir);
   while (true) {
     for (const filename of projectConfigFilenames) {
-      const candidate = path5.join(current, filename);
+      const candidate = path8.join(current, filename);
       if (await fileExists(candidate)) {
-        const source = await readFile(candidate, "utf8");
+        const source = await readFile2(candidate, "utf8");
         return parseProjectConfig(candidate, source);
       }
     }
-    const parent = path5.dirname(current);
+    const parent = path8.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -25404,28 +25594,8 @@ var writeForumProjectConfig = async (filePath, config2) => {
       target: rule.target || "."
     }));
   }
-  await writeFile(filePath, stringify(value), "utf8");
-};
-
-// src/atomicWriteTextFile.ts
-import path6 from "path";
-import { chmod, mkdir as mkdir2, rename, rm, writeFile as writeFile2 } from "fs/promises";
-var atomicWriteTextFile = async (filePath, text, isExecutable = false) => {
-  const parentDir = path6.dirname(filePath);
-  const tempPath = path6.join(
-    parentDir,
-    `.${path6.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
-  );
-  await mkdir2(parentDir, { recursive: true });
-  try {
-    await writeFile2(tempPath, text, "utf8");
-    await chmod(tempPath, isExecutable ? 493 : 420);
-    await rename(tempPath, filePath);
-  } catch (error51) {
-    await rm(tempPath, { force: true }).catch(() => {
-    });
-    throw error51;
-  }
+  await mkdir3(path8.dirname(filePath), { recursive: true });
+  await writeFile2(filePath, stringify(value), "utf8");
 };
 
 // src/markdownStoreLinks.ts
@@ -25500,10 +25670,8 @@ var rewriteRawUrlsToStorePathLinks = ({
 };
 
 // src/checkout.ts
-var reservedRootFiles = new Set(projectConfigFilenames);
-var reservedRootFileNames = [...reservedRootFiles];
 var checkoutFilesManifestFilename = "files.json";
-var localIgnoreFilename = "ignore";
+var localIgnoreFilename = "usr_ignore";
 var gitDirectoryName = ".git";
 var defaultConcurrency = 8;
 var utf8Decoder = new TextDecoder2("utf-8", { fatal: true });
@@ -25672,18 +25840,14 @@ var rewriteMarkdownForRemoteStore = ({
   targets: markdownLinkTargetsFromManifest(manifest),
   text
 }) : text;
-var isReservedCheckoutFile = (relativePath) => {
-  const filename = relativePath.split("/").at(-1) ?? relativePath;
-  return reservedRootFiles.has(filename);
-};
-var isReservedCheckoutMetadataPath = (relativePath) => isReservedCheckoutFile(relativePath) || isCheckoutStateDirectoryPath(relativePath) || // `.git/` is the checkout's own VCS metadata — structurally never content,
+var isReservedCheckoutMetadataPath = (relativePath) => isCheckoutStateDirectoryPath(relativePath) || // `.git/` is the checkout's own VCS metadata — structurally never content,
 // like `.forum/`. It is reserved (not an ignore *rule*): there are no
 // baked-in ignore patterns, but tooling directories are still never synced.
 relativePath === gitDirectoryName || relativePath.startsWith(`${gitDirectoryName}/`);
 var reservedCheckoutMetadataMessage = "reserved checkout metadata path; ignored by local sync";
 var assertSafeRelativePath2 = (relativePath) => {
   const segments2 = relativePath.split("/");
-  if (path7.isAbsolute(relativePath) || segments2.some((segment) => segment === "." || segment === "..")) {
+  if (path9.isAbsolute(relativePath) || segments2.some((segment) => segment === "." || segment === "..")) {
     throw new Error(`Unsafe checkout path: ${relativePath}`);
   }
 };
@@ -25997,8 +26161,8 @@ var createSyncRuleClient = (client, rule) => {
     }
   };
 };
-var syncRuleFileParentPath = (rule) => path7.posix.dirname(addLeadingSlash3(rule.target));
-var syncRuleRemoteFileParentPath = (rule) => path7.posix.dirname(addLeadingSlash3(rule.path));
+var syncRuleFileParentPath = (rule) => path9.posix.dirname(addLeadingSlash3(rule.target));
+var syncRuleRemoteFileParentPath = (rule) => path9.posix.dirname(addLeadingSlash3(rule.path));
 var assertSyncRuleFilePath = (storePath, rule) => {
   const relativePath = toRelativePath2(storePath);
   if (relativePath !== rule.target) {
@@ -26100,7 +26264,7 @@ var classifySyncRuleRemoteRoot = async (client, storeRef, rule) => {
   const listing = await client.listDirectoryByRef({
     ...storeRef,
     includeHidden: rule.includeHidden,
-    directoryPath: path7.posix.dirname(remotePath)
+    directoryPath: path9.posix.dirname(remotePath)
   });
   const entry = listing.entries.find(
     (candidate) => candidate.path === remotePath
@@ -26124,7 +26288,7 @@ var classifySyncRuleLocalTarget = async (rootDir, rule) => {
     return "directory";
   }
   try {
-    const details = await lstat(path7.join(rootDir, rule.target));
+    const details = await lstat(path9.join(rootDir, rule.target));
     if (details.isFile()) {
       return "file";
     }
@@ -26246,34 +26410,32 @@ var normalizeCheckoutIncludePaths = (includePaths) => {
   }
   return normalized;
 };
-var checkoutFilesManifestPath = (rootDir) => path7.join(
+var checkoutFilesManifestPath = (rootDir) => path9.join(
   rootDir,
-  resolveCheckoutStateDirectoryName(rootDir),
+  resolveCheckoutStateDirectoryName(),
   checkoutFilesManifestFilename
 );
 var hashBytes = (bytes) => `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
 var hashText = (text) => hashBytes(Buffer.from(text, "utf8"));
 var hashLocalFile = async (filePath) => {
-  return hashBytes(await readFile2(filePath));
+  return hashBytes(await readFile3(filePath));
 };
 var isExecutableMode = (mode) => (mode & 73) !== 0;
 var emptyCheckoutFilesManifest = () => ({
   files: {},
   references: {},
   syncRules: {},
-  ignorePatterns: [],
   ignoreOnboardedAt: null,
   version: 1
 });
 var readCheckoutFilesManifest = async (rootDir) => {
   try {
-    const raw = await readFile2(checkoutFilesManifestPath(rootDir), "utf8");
+    const raw = await readFile3(checkoutFilesManifestPath(rootDir), "utf8");
     const parsed = JSON.parse(raw);
     return {
       files: parsed.files ?? {},
       references: parsed.references ?? {},
       syncRules: parsed.syncRules ?? {},
-      ignorePatterns: parsed.ignorePatterns ?? [],
       ignoreOnboardedAt: parsed.ignoreOnboardedAt ?? null,
       version: 1
     };
@@ -26286,12 +26448,12 @@ var readCheckoutFilesManifest = async (rootDir) => {
 };
 var writeCheckoutFilesManifest = async (rootDir, manifest) => {
   const filePath = checkoutFilesManifestPath(rootDir);
-  const parentDir = path7.dirname(filePath);
-  const tempPath = path7.join(
+  const parentDir = path9.dirname(filePath);
+  const tempPath = path9.join(
     parentDir,
     `.${checkoutFilesManifestFilename}.${process.pid}.${Date.now()}.tmp`
   );
-  await mkdir3(parentDir, { recursive: true });
+  await mkdir4(parentDir, { recursive: true });
   try {
     await writeFile3(
       tempPath,
@@ -26312,9 +26474,6 @@ var writeCheckoutFilesManifest = async (rootDir, manifest) => {
               ([leftId], [rightId]) => leftId < rightId ? -1 : leftId > rightId ? 1 : 0
             )
           ),
-          ignorePatterns: [...manifest.ignorePatterns].sort(
-            (left, right) => left < right ? -1 : left > right ? 1 : 0
-          ),
           ignoreOnboardedAt: manifest.ignoreOnboardedAt,
           version: 1
         },
@@ -26326,7 +26485,7 @@ var writeCheckoutFilesManifest = async (rootDir, manifest) => {
     );
     await rename2(tempPath, filePath);
   } catch (error51) {
-    await rm2(tempPath, { force: true }).catch(() => {
+    await rm3(tempPath, { force: true }).catch(() => {
     });
     throw error51;
   }
@@ -26377,7 +26536,7 @@ var readFileSnapshot = async (filePath) => {
 };
 var isFileSnapshotEqual = (left, right) => left.size === right.size && left.mtimeMs === right.mtimeMs;
 var createIgnoreMatcher = (patterns) => {
-  const matcher = ignore();
+  const matcher = ignore2();
   matcher.add(patterns);
   return matcher;
 };
@@ -26431,7 +26590,7 @@ var deleteLocalFileIfPresent = async (filePath) => {
     if (!details.isFile()) {
       return false;
     }
-    await rm2(filePath, { force: true });
+    await rm3(filePath, { force: true });
     return true;
   } catch (error51) {
     if (isFileNotFoundError(error51)) {
@@ -26442,7 +26601,7 @@ var deleteLocalFileIfPresent = async (filePath) => {
 };
 var moveLocalFileIfPresent = async (sourcePath, destinationPath) => {
   try {
-    await mkdir3(path7.dirname(destinationPath), { recursive: true });
+    await mkdir4(path9.dirname(destinationPath), { recursive: true });
     await rename2(sourcePath, destinationPath);
     return true;
   } catch (error51) {
@@ -26454,7 +26613,7 @@ var moveLocalFileIfPresent = async (sourcePath, destinationPath) => {
 };
 var readLocalFileHashIfPresent = async (rootDir, relativePath) => {
   try {
-    return await hashLocalFile(path7.join(rootDir, relativePath));
+    return await hashLocalFile(path9.join(rootDir, relativePath));
   } catch (error51) {
     if (isFileNotFoundError(error51)) {
       return null;
@@ -26513,7 +26672,7 @@ var reconcileTrackedRemoteDelete = async ({
     return localFileHash !== null ? "deleted" : "ignored";
   }
   const deletedLocalFile = await deleteLocalFileIfPresent(
-    path7.join(localPath, relativePath)
+    path9.join(localPath, relativePath)
   );
   delete manifest.files[relativePath];
   return deletedLocalFile ? "deleted" : "ignored";
@@ -26593,20 +26752,20 @@ var readOnlyCheckoutChangeResults = (changes) => changes.map((change) => ({
   status: "failed"
 }));
 var resetCheckoutSyncState = async (rootDir) => {
-  await rm2(checkoutFilesManifestPath(rootDir), { force: true });
+  await rm3(checkoutFilesManifestPath(rootDir), { force: true });
 };
 var atomicWriteBinaryFile = async (filePath, bytes) => {
-  const parentDir = path7.dirname(filePath);
-  const tempPath = path7.join(
+  const parentDir = path9.dirname(filePath);
+  const tempPath = path9.join(
     parentDir,
-    `.${path7.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+    `.${path9.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
   );
-  await mkdir3(parentDir, { recursive: true });
+  await mkdir4(parentDir, { recursive: true });
   try {
     await writeFile3(tempPath, bytes);
     await rename2(tempPath, filePath);
   } catch (error51) {
-    await rm2(tempPath, { force: true }).catch(() => {
+    await rm3(tempPath, { force: true }).catch(() => {
     });
     throw error51;
   }
@@ -26644,7 +26803,7 @@ var readStableCheckoutFile = async (absolutePath, relativePath, attempts = 3) =>
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     try {
       const before = await readFileSnapshot(absolutePath);
-      const buffer = await readFile2(absolutePath);
+      const buffer = await readFile3(absolutePath);
       const after = await readFileSnapshot(absolutePath);
       if (!isFileSnapshotEqual(before, after)) {
         sawUnstableRead = true;
@@ -26704,8 +26863,8 @@ var readStableCheckoutFile = async (absolutePath, relativePath, attempts = 3) =>
 var walkLocalCheckoutFiles = async (rootDir, directoryPath, includePaths, matcher, scan) => {
   const entries = await readdir2(directoryPath, { withFileTypes: true });
   for (const entry of entries) {
-    const absolutePath = path7.join(directoryPath, entry.name);
-    const relativePath = path7.relative(rootDir, absolutePath).split(path7.sep).join("/");
+    const absolutePath = path9.join(directoryPath, entry.name);
+    const relativePath = path9.relative(rootDir, absolutePath).split(path9.sep).join("/");
     const classification = classifyCheckoutPath(
       relativePath,
       entry.isDirectory(),
@@ -26803,7 +26962,7 @@ var readRemoteCheckoutEntry = async (client, storeRef, relativePath) => {
   const storePath = toStorePath2(relativePath);
   const listing = await client.listDirectoryByRef({
     ...storeRef,
-    directoryPath: path7.posix.dirname(storePath)
+    directoryPath: path9.posix.dirname(storePath)
   });
   const entry = listing.entries.find(
     (candidate) => candidate.path === storePath
@@ -26817,7 +26976,7 @@ var readRemoteStoreEntry = async (client, storeRef, relativePath) => {
   const storePath = toStorePath2(relativePath);
   const listing = await client.listDirectoryByRef({
     ...storeRef,
-    directoryPath: path7.posix.dirname(storePath)
+    directoryPath: path9.posix.dirname(storePath)
   });
   return listing.entries.find(
     (candidate) => candidate.path === storePath
@@ -26841,7 +27000,7 @@ var readReferenceSourceForPath = async (client, storeRef, relativePath) => {
   return void 0;
 };
 var readLocalCheckoutFile = async (rootDir, relativePath) => {
-  const absolutePath = path7.join(rootDir, relativePath);
+  const absolutePath = path9.join(rootDir, relativePath);
   let details;
   try {
     details = await lstat(absolutePath);
@@ -27291,7 +27450,7 @@ var joinDirectRootPath = (rootPath, relativePath) => {
   if (!relativePath) {
     return rootPath;
   }
-  return path7.posix.join(rootPath, relativePath);
+  return path9.posix.join(rootPath, relativePath);
 };
 var directStorePath = (relativePath) => relativePath ? toStorePath2(relativePath) : "/";
 var relativePathFromDirectRoot = (rootPath, storePath) => {
@@ -27300,7 +27459,7 @@ var relativePathFromDirectRoot = (rootPath, storePath) => {
     return relativePath;
   }
   if (relativePath === rootPath) {
-    return path7.posix.basename(rootPath);
+    return path9.posix.basename(rootPath);
   }
   const prefix = `${rootPath}/`;
   if (!relativePath.startsWith(prefix)) {
@@ -27348,22 +27507,26 @@ var updateFileManifestEntry = ({
   hash: hash2,
   manifest,
   manifestEntry,
-  path: path20,
+  path: path22,
   remoteFile,
   source,
   syncedAt
 }) => {
-  manifest.files[path20] = buildCheckoutFileManifestEntry({
+  manifest.files[path22] = buildCheckoutFileManifestEntry({
     storageClass,
     hash: hash2,
     manifestEntry,
-    path: path20,
+    path: path22,
     remoteFile,
     source,
     syncedAt
   });
 };
 var reconcileRemoteRenamesBeforePull = async ({
+  client,
+  conflictPolicy,
+  localFiles,
+  storeRef,
   dryRun,
   files,
   force,
@@ -27375,7 +27538,8 @@ var reconcileRemoteRenamesBeforePull = async ({
   for (const [relativePath, entry] of Object.entries(manifest.files)) {
     manifestPathByRemoteFileId.set(entry.remoteFileId, relativePath);
   }
-  for (const { entry, relativePath } of files) {
+  for (const remoteFile of files) {
+    const { entry, relativePath } = remoteFile;
     if (!entry.id) {
       continue;
     }
@@ -27383,18 +27547,40 @@ var reconcileRemoteRenamesBeforePull = async ({
     if (!manifestPath || manifestPath === relativePath) {
       continue;
     }
-    const sourcePath = path7.join(localPath, manifestPath);
-    const destinationPath = path7.join(localPath, relativePath);
+    const sourcePath = path9.join(localPath, manifestPath);
+    const destinationPath = path9.join(localPath, relativePath);
     const manifestEntry = manifest.files[manifestPath];
     const destinationExists = await pathExists(destinationPath);
     const localChanged = await hasTrackedLocalChange({
       localPath,
       manifestEntry,
       relativePath: manifestPath
-    });
+    }) || Boolean(conflictPolicy) && !await pathExists(sourcePath);
+    const localMoveCandidates = conflictPolicy && !await pathExists(sourcePath) ? (localFiles ?? []).filter(
+      (file2) => !manifest.files[file2.relativePath] && file2.hash === manifestEntry.hash
+    ) : [];
+    if (conflictPolicy === "local" && (localChanged || destinationExists) && client) {
+      const winnerPath = localMoveCandidates.length === 1 ? localMoveCandidates[0].relativePath : manifestPath;
+      if (!dryRun && relativePath !== winnerPath) {
+        await client.movePathByRef({
+          ...storeRef,
+          sourcePath: toStorePath2(relativePath),
+          destinationPath: toStorePath2(winnerPath)
+        });
+      }
+      manifest.files[winnerPath] = {
+        ...manifestEntry,
+        remotePath: toStorePath2(winnerPath)
+      };
+      if (winnerPath !== manifestPath) delete manifest.files[manifestPath];
+      remoteFile.conflictWinner = "local";
+      remoteFile.relativePath = winnerPath;
+      remoteFile.entry = { ...entry, path: toStorePath2(winnerPath) };
+      continue;
+    }
     const plan = planRemoteRenameBeforePull({
       destinationExists,
-      force,
+      force: force || conflictPolicy === "remote",
       localChanged
     });
     if (plan.type === "conflict") {
@@ -27421,6 +27607,33 @@ var reconcileRemoteRenamesBeforePull = async ({
       );
       continue;
     }
+    if (conflictPolicy === "remote" && (localChanged || destinationExists)) {
+      remoteFile.conflictWinner = "remote";
+      for (const candidate of localMoveCandidates) {
+        if (!dryRun)
+          await deleteLocalFileIfPresent(
+            path9.join(localPath, candidate.relativePath)
+          );
+      }
+    }
+    if (conflictPolicy && localFiles) {
+      const source = localFiles.find(
+        (file2) => file2.relativePath === manifestPath
+      );
+      const remaining = localFiles.filter(
+        (file2) => file2.relativePath !== manifestPath && file2.relativePath !== relativePath && !localMoveCandidates.includes(file2)
+      );
+      if (source && !localChanged && !destinationExists)
+        remaining.push({ ...source, relativePath });
+      localFiles.splice(0, localFiles.length, ...remaining);
+      if (dryRun) {
+        manifest.files[relativePath] = {
+          ...manifestEntry,
+          remotePath: toStorePath2(relativePath)
+        };
+        delete manifest.files[manifestPath];
+      }
+    }
     if (!dryRun) {
       if (plan.shouldDeleteDestination) {
         await deleteLocalFileIfPresent(destinationPath);
@@ -27463,6 +27676,9 @@ var localRenameCandidateDestinations = (relativePath, manifest, localFilesByHash
 var localRenameCandidateSources = (file2, deletePaths, manifest) => deletePaths.filter((relativePath) => manifest.files[relativePath]?.hash === file2.hash).sort();
 var preflightLocalRenamesBeforePush = async ({
   client,
+  conflictPolicy,
+  remoteFiles,
+  localPath,
   deletePaths,
   dryRun,
   localFiles,
@@ -27546,6 +27762,41 @@ var preflightLocalRenamesBeforePush = async ({
     if (!manifestEntry) {
       continue;
     }
+    const remoteFile = remoteFiles?.find(
+      (file2) => file2.entry.id === manifestEntry.remoteFileId
+    );
+    if (conflictPolicy && remoteFile && localPath && remoteFile.entry.revisionNumber !== manifestEntry.remoteRevisionNumber) {
+      remoteFile.conflictWinner = conflictPolicy;
+      if (conflictPolicy === "local") {
+        if (!dryRun)
+          await client.movePathByRef({
+            ...storeRef,
+            sourcePath: toStorePath2(rename5.sourcePath),
+            destinationPath: toStorePath2(rename5.destinationPath)
+          });
+        remoteFile.relativePath = rename5.destinationPath;
+        remoteFile.entry = {
+          ...remoteFile.entry,
+          path: toStorePath2(rename5.destinationPath)
+        };
+        manifest.files[rename5.destinationPath] = {
+          ...manifestEntry,
+          remotePath: toStorePath2(rename5.destinationPath)
+        };
+        delete manifest.files[rename5.sourcePath];
+      } else {
+        if (!dryRun)
+          await moveLocalFileIfPresent(
+            path9.join(localPath, rename5.destinationPath),
+            path9.join(localPath, rename5.sourcePath)
+          );
+        const movedFile = localFiles.find(
+          (file2) => file2.relativePath === rename5.destinationPath
+        );
+        if (movedFile) movedFile.relativePath = rename5.sourcePath;
+      }
+      continue;
+    }
     if (!dryRun) {
       await client.movePathByRef({
         ...storeRef,
@@ -27572,14 +27823,10 @@ var preflightLocalRenamesBeforePush = async ({
     remainingDeletePaths
   };
 };
-var localIgnoreFilePath = (rootDir) => path7.join(
-  rootDir,
-  resolveCheckoutStateDirectoryName(rootDir),
-  localIgnoreFilename
-);
+var localIgnoreFilePath = (rootDir) => path9.join(rootDir, resolveCheckoutStateDirectoryName(), localIgnoreFilename);
 var readLocalIgnorePatterns = async (rootDir) => {
   try {
-    const raw = await readFile2(localIgnoreFilePath(rootDir), "utf8");
+    const raw = await readFile3(localIgnoreFilePath(rootDir), "utf8");
     return parseLocalIgnoreFile(raw);
   } catch (error51) {
     if (errorCode(error51) === "ENOENT") {
@@ -27588,20 +27835,6 @@ var readLocalIgnorePatterns = async (rootDir) => {
     throw error51;
   }
 };
-var readStoreIgnoreCache = async (rootDir) => {
-  const manifest = await readCheckoutFilesManifest(rootDir);
-  return manifest.ignorePatterns;
-};
-var writeStoreIgnoreCache = async (rootDir, storeIgnorePatterns) => {
-  const manifest = await readCheckoutFilesManifest(rootDir);
-  const ignorePatterns = resolveIgnorePatterns({
-    bakedIn: [],
-    storeSetting: storeIgnorePatterns,
-    localOverride: []
-  });
-  await writeCheckoutFilesManifest(rootDir, { ...manifest, ignorePatterns });
-  return ignorePatterns;
-};
 var readIgnoreOnboardedAt = async (rootDir) => {
   const manifest = await readCheckoutFilesManifest(rootDir);
   return manifest.ignoreOnboardedAt;
@@ -27617,22 +27850,29 @@ var resolveCheckoutConfig = async (startDir = process.cwd()) => {
   const config2 = await findForumProjectConfig(startDir);
   if (!config2) {
     throw new Error(
-      "No forum.yaml found. Run fm init <store> or fm clone <store> first."
+      "No .forum/sync.yaml found. Run fm init <store> or fm clone <store> first."
     );
   }
-  const rootDir = path7.dirname(config2.path);
-  const [cachedStoreIgnore, localIgnore] = await Promise.all([
-    readStoreIgnoreCache(rootDir),
-    readLocalIgnorePatterns(rootDir)
-  ]);
-  const ignore3 = resolveIgnorePatterns({
-    bakedIn: [],
-    storeSetting: cachedStoreIgnore,
-    localOverride: localIgnore
-  });
+  const rootDir = path9.dirname(path9.dirname(config2.path));
+  const personal = await readLocalIgnorePatterns(rootDir);
+  const ignorePatternsByStore = {};
+  const ignoreMatchersByRule = {};
+  for (const rule of config2.syncRules) {
+    const shared = await readSharedIgnoreFile(sharedIgnorePath(rootDir, rule.store)) ?? [];
+    ignorePatternsByStore[rule.store] = [...shared, ...personal];
+    ignoreMatchersByRule[rule.id] = createCheckoutIgnoreMatcher(
+      rule,
+      shared,
+      personal
+    );
+  }
+  const stores = Object.keys(ignorePatternsByStore);
+  const ignore3 = stores.length === 1 ? ignorePatternsByStore[stores[0]] : personal;
   return {
     ...config2,
+    ignoreMatchersByRule,
     ignore: ignore3,
+    ignorePatternsByStore,
     configRootDir: rootDir,
     rootDir
   };
@@ -27640,8 +27880,8 @@ var resolveCheckoutConfig = async (startDir = process.cwd()) => {
 var collectLocalCheckoutFiles = async (rootDir, ignorePatterns, syncIncludePaths) => {
   return (await scanLocalCheckoutFiles(rootDir, ignorePatterns, syncIncludePaths)).files;
 };
-var scanLocalCheckoutFiles = async (rootDir, ignorePatterns, syncIncludePaths, progress) => {
-  const matcher = createIgnoreMatcher(ignorePatterns);
+var scanLocalCheckoutFiles = async (rootDir, ignorePatterns, syncIncludePaths, progress, ignoreMatcher) => {
+  const matcher = ignoreMatcher ?? createIgnoreMatcher(ignorePatterns);
   const includePaths = normalizeCheckoutIncludePaths(syncIncludePaths);
   const scan = {
     files: [],
@@ -27663,18 +27903,76 @@ var scanLocalCheckoutFiles = async (rootDir, ignorePatterns, syncIncludePaths, p
   );
   return scan;
 };
+var ignoreSettingDetail = (change) => {
+  const message = change.action === "conflict" ? `Shared ignore rules changed locally and remotely for ${change.store}. Save your local rules, remove ${change.relativePath}, and sync to restore the store baseline. Then apply your merged rules and sync again.` : `Shared ignore settings: ${change.action} (${change.store})`;
+  if (change.action === "conflict")
+    return checkoutConflictFileResult({
+      relativePath: change.relativePath,
+      message,
+      type: "shared-ignore-conflict"
+    });
+  return checkoutFileResultWithDirection(
+    {
+      relativePath: change.relativePath,
+      message,
+      status: "succeeded",
+      changeType: "updated"
+    },
+    change.action === "publish" ? "upload" : "download"
+  );
+};
 var pullCheckout = async ({
   client,
   dryRun = false,
   filePaths,
   force = false,
   ignorePatterns,
+  ignoreMatcher,
+  ignoreMatchersByRule,
+  ignoreSettings,
+  ignorePatternsByStore,
   localPath,
   progress,
   storeRef,
   syncIncludePaths,
   syncRules
 }) => {
+  if (syncRules && ignoreSettings) {
+    const settings = await prepareCheckoutIgnore({
+      rootDir: localPath,
+      syncRules,
+      client,
+      dryRun: dryRun || ignoreSettings === "preview"
+    });
+    const conflicts = settings.changes.filter(
+      (change) => change.action === "conflict"
+    );
+    if (conflicts.length)
+      return checkoutResultFromDetails(conflicts.map(ignoreSettingDetail));
+    const result = await pullCheckout({
+      client,
+      dryRun,
+      filePaths,
+      force,
+      ignorePatterns,
+      localPath,
+      progress,
+      storeRef,
+      syncIncludePaths,
+      syncRules,
+      ignorePatternsByStore: settings.patternsByStore,
+      ignoreMatchersByRule: settings.matchersByRule
+    });
+    const changes = dryRun ? settings.changes.filter((change) => change.action !== "publish") : [];
+    Object.assign(
+      result,
+      checkoutResultFromDetails([
+        ...result.details,
+        ...changes.map(ignoreSettingDetail)
+      ])
+    );
+    return result;
+  }
   const requestedRelativePaths = normalizeCheckoutFilePaths(filePaths);
   if (syncRules) {
     await ensureManifestSyncRules(localPath, syncRules, {
@@ -27715,7 +28013,8 @@ var pullCheckout = async ({
             dryRun,
             filePaths: ruleFilePaths ?? void 0,
             force,
-            ignorePatterns,
+            ignorePatterns: ignorePatternsByStore?.[rule.store] ?? ignorePatterns,
+            ignoreMatcher: ignoreMatchersByRule?.[rule.id],
             localPath,
             progress: checkoutProgressWithSyncRuleRemoteRefs(
               progress,
@@ -27746,7 +28045,7 @@ var pullCheckout = async ({
     );
   }
   const remoteEntries = [];
-  const matcher = createIgnoreMatcher(ignorePatterns);
+  const matcher = ignoreMatcher ?? createIgnoreMatcher(ignorePatterns);
   const includePaths = normalizeCheckoutIncludePaths(syncIncludePaths);
   const manifest = await readCheckoutFilesManifest(localPath);
   const manifestSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -27857,7 +28156,7 @@ var pullCheckout = async ({
           }
           if (!dryRun) {
             const deletedLocalFile = await deleteLocalFileIfPresent(
-              path7.join(localPath, relativePath)
+              path9.join(localPath, relativePath)
             );
             delete manifest.files[relativePath];
             manifest.references[relativePath] = {
@@ -27942,7 +28241,7 @@ var pullCheckout = async ({
           );
         }
         const bytes = new Uint8Array(await response.arrayBuffer());
-        await atomicWriteBinaryFile(path7.join(localPath, relativePath), bytes);
+        await atomicWriteBinaryFile(path9.join(localPath, relativePath), bytes);
         updateFileManifestEntry({
           storageClass: "binary",
           hash: hashBytes(bytes),
@@ -27968,7 +28267,7 @@ var pullCheckout = async ({
         text: remoteFile.content.text
       });
       await atomicWriteTextFile(
-        path7.join(localPath, relativePath),
+        path9.join(localPath, relativePath),
         localText,
         remoteFile.isExecutable === true
       );
@@ -28138,7 +28437,7 @@ var pullStoreFiles = async ({
       if (!remoteFile) {
         throw new Error("remote file disappeared while pulling");
       }
-      const destinationPath = path7.join(localPath, targetPath, relativePath);
+      const destinationPath = path9.join(localPath, targetPath, relativePath);
       const changeType = await localPathExists(destinationPath) ? "updated" : "created";
       if (remoteFileHasBlobContent(remoteFile)) {
         const { downloadUrl } = await client.createFileDownloadUrlByRef({
@@ -28189,12 +28488,52 @@ var pushCheckout = async ({
   filePaths,
   force,
   ignorePatterns,
+  ignoreMatcher,
+  ignoreMatchersByRule,
+  ignoreSettings,
+  ignorePatternsByStore,
   localPath,
   progress,
   storeRef,
   syncIncludePaths,
   syncRules
 }) => {
+  if (syncRules && ignoreSettings) {
+    const settings = await prepareCheckoutIgnore({
+      rootDir: localPath,
+      syncRules,
+      client,
+      dryRun: dryRun || ignoreSettings === "preview"
+    });
+    const conflicts = settings.changes.filter(
+      (change) => change.action === "conflict"
+    );
+    if (conflicts.length)
+      return checkoutResultFromDetails(conflicts.map(ignoreSettingDetail));
+    const result2 = await pushCheckout({
+      client,
+      dryRun,
+      filePaths,
+      force,
+      ignorePatterns,
+      localPath,
+      progress,
+      storeRef,
+      syncIncludePaths,
+      syncRules,
+      ignorePatternsByStore: settings.patternsByStore,
+      ignoreMatchersByRule: settings.matchersByRule
+    });
+    const changes = dryRun ? settings.changes.filter((change) => change.action === "publish") : [];
+    Object.assign(
+      result2,
+      checkoutResultFromDetails([
+        ...result2.details,
+        ...changes.map(ignoreSettingDetail)
+      ])
+    );
+    return result2;
+  }
   const requestedRelativePaths = normalizeCheckoutFilePaths(filePaths);
   if (syncRules) {
     await ensureManifestSyncRules(localPath, syncRules, {
@@ -28235,7 +28574,8 @@ var pushCheckout = async ({
             dryRun,
             filePaths: ruleFilePaths ?? void 0,
             force,
-            ignorePatterns,
+            ignorePatterns: ignorePatternsByStore?.[rule.store] ?? ignorePatterns,
+            ignoreMatcher: ignoreMatchersByRule?.[rule.id],
             localPath,
             progress: checkoutProgressWithSyncRuleRemoteRefs(
               progress,
@@ -28265,14 +28605,20 @@ var pushCheckout = async ({
       "upload"
     );
   }
-  const matcher = createIgnoreMatcher(ignorePatterns);
+  const matcher = ignoreMatcher ?? createIgnoreMatcher(ignorePatterns);
   const includePaths = normalizeCheckoutIncludePaths(syncIncludePaths);
   const scan = requestedRelativePaths ? await scanTargetLocalCheckoutFiles(
     localPath,
     requestedRelativePaths,
     includePaths,
     matcher
-  ) : await scanLocalCheckoutFiles(localPath, ignorePatterns, includePaths);
+  ) : await scanLocalCheckoutFiles(
+    localPath,
+    ignorePatterns,
+    includePaths,
+    void 0,
+    matcher
+  );
   const manifest = await readCheckoutFilesManifest(localPath);
   const manifestSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
   const localPaths = new Set(scan.files.map((file2) => file2.relativePath));
@@ -28532,7 +28878,7 @@ var pullRemoteFileIntoCheckout = async ({
       );
     }
     const bytes = new Uint8Array(await response.arrayBuffer());
-    await atomicWriteBinaryFile(path7.join(localPath, relativePath), bytes);
+    await atomicWriteBinaryFile(path9.join(localPath, relativePath), bytes);
     updateFileManifestEntry({
       storageClass: "binary",
       hash: hashBytes(bytes),
@@ -28558,7 +28904,7 @@ var pullRemoteFileIntoCheckout = async ({
     text: remoteFile.content.text
   });
   await atomicWriteTextFile(
-    path7.join(localPath, relativePath),
+    path9.join(localPath, relativePath),
     localText,
     remoteFile.isExecutable === true
   );
@@ -28651,7 +28997,7 @@ var remoteFileHash = async ({
   client,
   remoteFile,
   storeRef,
-  path: path20
+  path: path22
 }) => {
   const textHash = remoteTextHash(remoteFile);
   if (textHash) {
@@ -28662,7 +29008,7 @@ var remoteFileHash = async ({
   }
   const { downloadUrl } = await client.createFileDownloadUrlByRef({
     ...storeRef,
-    path: path20
+    path: path22
   });
   const response = await fetch(downloadUrl);
   if (!response.ok) {
@@ -28812,6 +29158,7 @@ var deleteRemoteFileFromCheckout = async ({
 };
 var executeSyncCheckoutFiles = async ({
   client,
+  conflictPolicy,
   dryRun,
   force,
   localPath,
@@ -28836,6 +29183,7 @@ var executeSyncCheckoutFiles = async ({
     paths,
     (relativePath) => relativePath,
     async (relativePath) => syncCheckoutFile({
+      conflictPolicy,
       client,
       dryRun,
       force,
@@ -28862,6 +29210,7 @@ var ignoredCheckoutFileResult = (ignored) => ({
 });
 var planSyncCheckoutSession = async ({
   client,
+  conflictPolicy,
   dryRun,
   files,
   force,
@@ -28878,6 +29227,10 @@ var planSyncCheckoutSession = async ({
     remoteFileCount: files.length
   });
   const remoteRenameConflictDetails = await reconcileRemoteRenamesBeforePull({
+    client,
+    conflictPolicy,
+    localFiles: scan.files,
+    storeRef,
     dryRun,
     files,
     force,
@@ -28887,7 +29240,7 @@ var planSyncCheckoutSession = async ({
   const remoteRenameConflictPaths = checkoutDetailPathSet(
     remoteRenameConflictDetails
   );
-  const snapshot = buildSyncCheckoutSnapshot({
+  let snapshot = buildSyncCheckoutSnapshot({
     includePaths,
     isIgnored: (relativePath) => isIgnored(relativePath, false, includePaths, matcher),
     localFiles: scan.files,
@@ -28903,6 +29256,9 @@ var planSyncCheckoutSession = async ({
     phase: "local-rename-preflight"
   });
   const structuralPreflight = await preflightLocalRenamesBeforePush({
+    conflictPolicy,
+    remoteFiles: files,
+    localPath,
     client,
     deletePaths: snapshot.deletePaths,
     dryRun,
@@ -28910,6 +29266,26 @@ var planSyncCheckoutSession = async ({
     manifest,
     storeRef
   });
+  if (conflictPolicy) {
+    snapshot = buildSyncCheckoutSnapshot({
+      includePaths,
+      isIgnored: (relativePath) => isIgnored(relativePath, false, includePaths, matcher),
+      localFiles: scan.files,
+      manifestFiles: Object.keys(manifest.files).map((relativePath) => ({
+        relativePath
+      })),
+      remoteBlockedPaths: remoteRenameConflictPaths,
+      remoteFiles: files
+    });
+  }
+  const policyDetails = await resolveAmbiguousSyncMoves({
+    conflictPolicy,
+    dryRun,
+    localPath,
+    manifestFiles: manifest.files,
+    snapshot,
+    structuralPreflight
+  });
   const preflightDetails = [
     ...scan.ignored.map(ignoredCheckoutFileResult),
     ...scan.unsupported.map(unsupportedCheckoutFileResult)
@@ -28924,6 +29300,7 @@ var planSyncCheckoutSession = async ({
   });
   return {
     explicitDetails: [
+      ...withCheckoutDetailsDirection(policyDetails, "download"),
       ...withCheckoutDetailsDirection(remoteRenameConflictDetails, "download"),
       ...withCheckoutDetailsDirection(
         structuralPreflight.movedDetails,
@@ -28959,6 +29336,7 @@ var readSyncCheckoutRemoteFiles = async ({
 };
 var scanSyncCheckoutLocalFiles = async ({
   ignorePatterns,
+  ignoreMatcher,
   includePaths,
   localPath,
   progress
@@ -28967,7 +29345,8 @@ var scanSyncCheckoutLocalFiles = async ({
     localPath,
     ignorePatterns,
     includePaths,
-    progress
+    progress,
+    ignoreMatcher
   );
   reportCheckoutProgressEvent(
     progress,
@@ -29021,6 +29400,7 @@ var finalizeSyncCheckoutSession = async ({
 };
 var syncCheckoutFile = async ({
   client,
+  conflictPolicy,
   dryRun,
   force,
   isInsideRemoteReference,
@@ -29035,7 +29415,7 @@ var syncCheckoutFile = async ({
   const manifestEntry = manifest.files[relativePath];
   const remoteKind = remoteFile ? isReferenceEntry(remoteFile.entry) ? "reference" : "file" : "missing";
   let remoteVersionChanged = false;
-  if (remoteKind === "file" && remoteFile && localFile && manifestEntry) {
+  if (remoteKind === "file" && remoteFile && manifestEntry) {
     if (typeof remoteFile.entry.revisionNumber === "number") {
       remoteVersionChanged = (manifestEntry.remoteRevisionNumber ?? null) !== remoteFile.entry.revisionNumber;
     } else {
@@ -29049,18 +29429,19 @@ var syncCheckoutFile = async ({
       remoteVersionChanged = (manifestEntry.remoteRevisionNumber ?? null) !== remoteRevisionNumberForConflictCheck(remote);
     }
   }
-  if (isReferenceManifestEntry(manifestEntry)) {
+  if (isReferenceManifestEntry(manifestEntry) && (!conflictPolicy || remoteKind === "missing")) {
     const localHash = localFile?.hash ?? null;
     const localChanged = localHash === null || localHash !== manifestEntry.hash;
     if (remoteKind === "missing") {
-      if (dryRun) {
+      if (dryRun && !conflictPolicy) {
         return withCheckoutWorkerDirection(
           localChanged ? "deleted" : "ignored",
           "download"
         );
       }
       const result = await reconcileTrackedRemoteDelete({
-        force,
+        dryRun,
+        force: force || conflictPolicy === "remote",
         localFileHash: localHash,
         localPath,
         manifest,
@@ -29077,7 +29458,7 @@ var syncCheckoutFile = async ({
         return withCheckoutWorkerDirection(
           await deleteRemoteFileFromCheckout({
             client,
-            force,
+            force: force || conflictPolicy === "local",
             manifest,
             manifestEntry,
             relativePath,
@@ -29107,7 +29488,7 @@ var syncCheckoutFile = async ({
         await pushLocalFileFromCheckout({
           client,
           file: localFile,
-          force,
+          force: force || conflictPolicy === "local",
           manifest,
           manifestEntry,
           manifestSyncedAt,
@@ -29190,6 +29571,8 @@ var syncCheckoutFile = async ({
     }
   }
   const plan = planSyncCheckoutFile({
+    resolvedConflict: remoteFile?.conflictWinner,
+    conflictPolicy,
     force,
     localIsExecutable: localFile?.storageClass === "text" ? localFile.isExecutable : false,
     localHash: localFile?.hash ?? null,
@@ -29233,7 +29616,7 @@ var syncCheckoutFile = async ({
     if (!remoteFile || !isReferenceEntry(remoteFile.entry)) {
       throw new Error("planned reference accept without remote reference");
     }
-    const deletedLocalFile = !dryRun && (localFile || manifestEntry) ? await deleteLocalFileIfPresent(path7.join(localPath, relativePath)) : false;
+    const deletedLocalFile = !dryRun && (localFile || manifestEntry) ? await deleteLocalFileIfPresent(path9.join(localPath, relativePath)) : false;
     if (!dryRun) {
       delete manifest.files[relativePath];
       manifest.references[relativePath] = {
@@ -29252,7 +29635,7 @@ var syncCheckoutFile = async ({
     }
     const result = await reconcileTrackedRemoteDelete({
       dryRun,
-      force,
+      force: force || conflictPolicy === "remote",
       localFileHash: localFile?.hash ?? null,
       localPath,
       manifest,
@@ -29262,7 +29645,11 @@ var syncCheckoutFile = async ({
     return typeof result === "string" || result.status !== "failed" ? withCheckoutWorkerDirection(result, "download") : result;
   }
   if (plan.type === "pullRemote") {
-    if (!remoteFile) {
+    const pullEntry = remoteFile?.entry ?? (remotePathExists ? await client.readFileByRef({
+      ...storeRef,
+      path: toStorePath2(relativePath)
+    }) : null);
+    if (!pullEntry) {
       throw new Error("planned pull without remote file");
     }
     if (dryRun) {
@@ -29277,13 +29664,13 @@ var syncCheckoutFile = async ({
     return withCheckoutWorkerDirection(
       await pullRemoteFileIntoCheckout({
         client,
-        entry: remoteFile.entry,
+        entry: pullEntry,
         localPath,
         manifest,
         manifestEntry,
         manifestSyncedAt,
         relativePath,
-        source: remoteFile.source,
+        source: remoteFile?.source,
         storeRef
       }),
       "download"
@@ -29302,13 +29689,17 @@ var syncCheckoutFile = async ({
         "upload"
       );
     }
+    const pushManifestEntry = conflictPolicy === "local" && manifestEntry?.storageClass === "binary" && remoteFile ? {
+      ...manifestEntry,
+      remoteRevisionNumber: remoteFile.entry.revisionNumber
+    } : manifestEntry;
     return withCheckoutWorkerDirection(
       await pushLocalFileFromCheckout({
         client,
         file: localFile,
-        force,
+        force: force || conflictPolicy === "local",
         manifest,
-        manifestEntry,
+        manifestEntry: pushManifestEntry,
         manifestSyncedAt,
         storeRef
       }),
@@ -29325,7 +29716,7 @@ var syncCheckoutFile = async ({
     return withCheckoutWorkerDirection(
       await deleteRemoteFileFromCheckout({
         client,
-        force,
+        force: force || conflictPolicy === "local",
         manifest,
         manifestEntry,
         relativePath,
@@ -29338,16 +29729,18 @@ var syncCheckoutFile = async ({
 };
 var syncCheckoutRuleFiles = async ({
   client,
+  conflictPolicy,
   dryRun,
   force,
   ignorePatterns,
+  ignoreMatcher,
   localPath,
   progress,
   referenceSyncMode,
   storeRef,
   syncIncludePaths
 }) => {
-  const matcher = createIgnoreMatcher(ignorePatterns);
+  const matcher = ignoreMatcher ?? createIgnoreMatcher(ignorePatterns);
   const includePaths = normalizeCheckoutIncludePaths(syncIncludePaths);
   const manifest = await readCheckoutFilesManifest(localPath);
   const manifestSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -29358,12 +29751,14 @@ var syncCheckoutRuleFiles = async ({
     storeRef
   });
   const scan = await scanSyncCheckoutLocalFiles({
+    ignoreMatcher,
     ignorePatterns,
     includePaths,
     localPath,
     progress
   });
   const sessionPlan = await planSyncCheckoutSession({
+    conflictPolicy,
     client,
     dryRun,
     files,
@@ -29385,6 +29780,7 @@ var syncCheckoutRuleFiles = async ({
   progress?.onTotal?.(explicitDetails.length + paths.length);
   reportCheckoutDetails(progress, explicitDetails);
   const result = await executeSyncCheckoutFiles({
+    conflictPolicy,
     client,
     dryRun,
     force,
@@ -29416,9 +29812,14 @@ var syncCheckoutRuleFiles = async ({
 var syncCheckout = async ({
   beforeRuleApply,
   client,
+  conflictPolicy,
   dryRun = false,
   force,
   ignorePatterns,
+  ignoreMatcher,
+  ignoreMatchersByRule,
+  ignoreSettings,
+  ignorePatternsByStore,
   localPath,
   progress,
   referenceSyncMode = false,
@@ -29426,6 +29827,44 @@ var syncCheckout = async ({
   syncIncludePaths,
   syncRules
 }) => {
+  if (syncRules && ignoreSettings) {
+    const settings = await prepareCheckoutIgnore({
+      rootDir: localPath,
+      syncRules,
+      client,
+      dryRun: dryRun || ignoreSettings === "preview"
+    });
+    const conflicts = settings.changes.filter(
+      (change) => change.action === "conflict"
+    );
+    if (conflicts.length)
+      return checkoutResultFromDetails(conflicts.map(ignoreSettingDetail));
+    const result = await syncCheckout({
+      beforeRuleApply,
+      client,
+      conflictPolicy,
+      dryRun,
+      force,
+      ignorePatterns,
+      localPath,
+      progress,
+      referenceSyncMode,
+      storeRef,
+      syncIncludePaths,
+      syncRules,
+      ignorePatternsByStore: settings.patternsByStore,
+      ignoreMatchersByRule: settings.matchersByRule
+    });
+    const changes = settings.changes;
+    Object.assign(
+      result,
+      checkoutResultFromDetails([
+        ...result.details,
+        ...changes.map(ignoreSettingDetail)
+      ])
+    );
+    return result;
+  }
   if (syncRules) {
     reportCheckoutProgressEvent(progress, "Checking checkout sync rules", {
       phase: "sync-rules",
@@ -29525,15 +29964,18 @@ var syncCheckout = async ({
           client: ruleClient,
           dryRun: true,
           force,
-          ignorePatterns,
+          ignorePatterns: ignorePatternsByStore?.[rule.store] ?? ignorePatterns,
+          ignoreMatcher: ignoreMatchersByRule?.[rule.id],
           localPath,
           storeRef: ruleStoreRef,
           syncIncludePaths: ruleIncludePaths
         }) : await syncCheckoutRuleFiles({
+          conflictPolicy,
           client: ruleClient,
           dryRun: true,
           force,
-          ignorePatterns,
+          ignorePatterns: ignorePatternsByStore?.[rule.store] ?? ignorePatterns,
+          ignoreMatcher: ignoreMatchersByRule?.[rule.id],
           localPath,
           referenceSyncMode: isStoreReferenceRule,
           storeRef: ruleStoreRef,
@@ -29557,16 +29999,19 @@ var syncCheckout = async ({
         client: ruleClient,
         dryRun,
         force,
-        ignorePatterns,
+        ignorePatterns: ignorePatternsByStore?.[rule.store] ?? ignorePatterns,
+        ignoreMatcher: ignoreMatchersByRule?.[rule.id],
         localPath,
         progress: ruleProgress,
         storeRef: ruleStoreRef,
         syncIncludePaths: ruleIncludePaths
       }) : await syncCheckoutRuleFiles({
+        conflictPolicy,
         client: ruleClient,
         dryRun,
         force,
-        ignorePatterns,
+        ignorePatterns: ignorePatternsByStore?.[rule.store] ?? ignorePatterns,
+        ignoreMatcher: ignoreMatchersByRule?.[rule.id],
         localPath,
         progress: ruleProgress,
         referenceSyncMode: isStoreReferenceRule,
@@ -29621,6 +30066,8 @@ var syncCheckout = async ({
     );
   }
   return syncCheckoutRuleFiles({
+    ignoreMatcher,
+    conflictPolicy,
     client,
     dryRun,
     force,
@@ -29633,16 +30080,16 @@ var syncCheckout = async ({
   });
 };
 var ensureCheckoutDirectoryReady = async (directoryPath) => {
-  await mkdir3(directoryPath, { recursive: true });
+  await mkdir4(directoryPath, { recursive: true });
   const entries = await readdir2(directoryPath);
   if (entries.length > 0) {
     throw new Error(`Target directory must be empty: ${directoryPath}`);
   }
 };
 var ensureProjectConfigDoesNotExist = async (directoryPath) => {
-  for (const filename of reservedRootFileNames) {
+  for (const filename of projectConfigFilenames) {
     try {
-      const filePath = path7.join(directoryPath, filename);
+      const filePath = path9.join(directoryPath, filename);
       await stat(filePath);
       throw new Error(`Forum config already exists: ${filePath}`);
     } catch (error51) {
@@ -29655,142 +30102,40 @@ var ensureProjectConfigDoesNotExist = async (directoryPath) => {
 };
 
 // src/ignoreCommand.ts
-import ignore2 from "ignore";
-var toRelative = (storePath) => storePath.replace(/^\/+/, "");
-var sortPaths = (paths) => [...paths].sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
-var planIgnoreAdd = (pattern, currentPatterns, remoteFilePaths) => {
-  const trimmed = pattern.trim();
-  if (!trimmed) {
-    throw new Error("Ignore pattern cannot be empty.");
-  }
-  const alreadyPresent = currentPatterns.includes(trimmed);
-  const nextPatterns = resolveIgnorePatterns({
-    bakedIn: [],
-    storeSetting: currentPatterns,
-    localOverride: [trimmed]
-  });
-  const matcher = ignore2().add([trimmed]);
-  const matchedRemotePaths = sortPaths(
-    remoteFilePaths.filter((storePath) => {
-      const relative = toRelative(storePath);
-      return Boolean(relative) && matcher.ignores(relative);
-    })
-  );
-  return { pattern: trimmed, alreadyPresent, nextPatterns, matchedRemotePaths };
-};
-var collectRemoteFilePaths = async (client, storeRef) => {
-  const listing = await client.listTreeByRef({
-    ...storeRef,
-    directoryPath: "/",
-    includeHidden: true
-  });
-  const entries = listing?.entries ?? [];
-  return sortPaths(
-    entries.filter((entry) => entry.type !== "directory").map((entry) => entry.path)
-  );
-};
-var executeIgnoreAdd = async (client, storeRef, pattern, currentPatterns, io) => {
-  const remoteFilePaths = await collectRemoteFilePaths(client, storeRef);
-  const plan = planIgnoreAdd(pattern, currentPatterns, remoteFilePaths);
-  let settingUpdated = false;
-  if (!plan.alreadyPresent) {
-    await client.upsertStoreByRef({
-      ...storeRef,
-      patch: { ignore: plan.nextPatterns }
-    });
-    settingUpdated = true;
-  }
-  const deletedRemotePaths = [];
-  let deletedRemoteDirectories = [];
-  if (plan.matchedRemotePaths.length > 0 && await io.confirmRemoteDelete(plan)) {
-    for (const storePath of plan.matchedRemotePaths) {
-      await client.deleteFileByRef({ ...storeRef, path: storePath });
-      deletedRemotePaths.push(storePath);
-    }
-    deletedRemoteDirectories = await cleanupRemoteCheckoutDirectories({
-      client,
-      removedPaths: deletedRemotePaths.map(toRelative),
-      storeRef
-    });
-  }
+var planIgnoreAdd = (pattern, currentPatterns) => {
+  if (!pattern.trim()) throw new Error("Ignore pattern cannot be empty.");
+  const alreadyPresent = currentPatterns.at(-1) === pattern;
   return {
-    plan,
-    settingUpdated,
-    deletedRemotePaths,
-    deletedRemoteDirectories
+    pattern,
+    alreadyPresent,
+    nextPatterns: alreadyPresent ? currentPatterns : [...currentPatterns, pattern]
   };
 };
 var removeIgnorePattern = (pattern, currentPatterns) => {
-  const trimmed = pattern.trim();
-  if (!trimmed) {
-    throw new Error("Ignore pattern cannot be empty.");
-  }
-  const nextPatterns = currentPatterns.filter((current) => current !== trimmed);
+  if (!pattern.trim()) throw new Error("Ignore pattern cannot be empty.");
+  const nextPatterns = currentPatterns.filter((current) => current !== pattern);
   return {
     nextPatterns,
     removed: nextPatterns.length !== currentPatterns.length,
-    pattern: trimmed
+    pattern
   };
 };
-var setIgnorePatterns = (patterns) => resolveIgnorePatterns({
-  bakedIn: [],
-  storeSetting: [],
-  localOverride: patterns
-});
+var setIgnorePatterns = (patterns) => {
+  if (patterns.some((pattern) => !pattern.trim()))
+    throw new Error("Ignore pattern cannot be empty.");
+  return patterns;
+};
 
 // src/runIgnoreCommand.ts
 var runAdd = async (deps) => {
-  const {
-    client,
-    storeRef,
-    currentPatterns,
-    pattern,
-    assumeYes,
-    confirmYesNo: confirmYesNo2,
-    renderOutput: renderOutput2,
-    commandNames: commandNames2
-  } = deps;
-  if (!pattern) {
-    throw new Error(`Usage: ${commandNames2} ignore add <pattern>`);
-  }
-  const io = {
-    confirmRemoteDelete: (plan) => confirmYesNo2({
-      assumeYes,
-      nonInteractiveMessage: "Refusing to delete store files without confirmation. Re-run with --yes.",
-      prompt: `Delete ${plan.matchedRemotePaths.length} matching file(s) from the store? [y/N] `
-    })
-  };
-  const result = await executeIgnoreAdd(
-    client,
-    storeRef,
-    pattern,
-    currentPatterns,
-    io
-  );
-  if (result.settingUpdated) {
-    renderOutput2(`Added ignore rule: ${result.plan.pattern}`);
-  } else {
-    renderOutput2(`Ignore rule already present: ${result.plan.pattern}`);
-  }
-  if (result.plan.matchedRemotePaths.length === 0) {
-    renderOutput2("No already-pushed files matched.");
-  } else if (result.deletedRemotePaths.length > 0) {
-    renderOutput2(
-      `Deleted ${result.deletedRemotePaths.length} file(s) from the store.`
-    );
-  } else {
-    renderOutput2("Left already-pushed matches in place.");
-  }
-  if (result.deletedRemoteDirectories.length > 0) {
-    renderOutput2(
-      `Deleted ${result.deletedRemoteDirectories.length} empty director${result.deletedRemoteDirectories.length === 1 ? "y" : "ies"} from the store.`
-    );
-  }
+  const { currentPatterns, pattern, renderOutput: renderOutput2, commandNames: commandNames2 } = deps;
+  if (!pattern) throw new Error(`Usage: ${commandNames2} ignore add <pattern>`);
+  const plan = planIgnoreAdd(pattern, currentPatterns);
+  if (!plan.alreadyPresent) await deps.writePatterns(plan.nextPatterns);
+  renderOutput2(`Added ignore rule: ${plan.pattern}. Run fm sync to publish.`);
 };
 var runList = async (deps) => {
-  const { client, storeRef, renderOutput: renderOutput2 } = deps;
-  const metadata = await client.readStoreByRef(storeRef);
-  const ignore3 = metadata?.ignore ?? [];
+  const { currentPatterns: ignore3, renderOutput: renderOutput2 } = deps;
   if (ignore3.length === 0) {
     renderOutput2("(no ignore rules)");
     return;
@@ -29801,8 +30146,7 @@ var runList = async (deps) => {
 };
 var runRemove = async (deps) => {
   const {
-    client,
-    storeRef,
+    writePatterns,
     currentPatterns,
     pattern,
     renderOutput: renderOutput2,
@@ -29816,14 +30160,11 @@ var runRemove = async (deps) => {
     renderOutput2(`Ignore rule not present: ${result.pattern}`);
     return;
   }
-  await client.upsertStoreByRef({
-    ...storeRef,
-    patch: { ignore: result.nextPatterns }
-  });
+  await writePatterns(result.nextPatterns);
   renderOutput2(`Removed ignore rule: ${result.pattern}`);
 };
 var runSet = async (deps) => {
-  const { client, storeRef, patterns, renderOutput: renderOutput2, commandNames: commandNames2 } = deps;
+  const { writePatterns, patterns, renderOutput: renderOutput2, commandNames: commandNames2 } = deps;
   if (patterns.length === 0) {
     throw new Error(`Usage: ${commandNames2} ignore set <pattern>...`);
   }
@@ -29831,24 +30172,17 @@ var runSet = async (deps) => {
   if (nextPatterns.length === 0) {
     throw new Error("Ignore pattern cannot be empty.");
   }
-  await client.upsertStoreByRef({
-    ...storeRef,
-    patch: { ignore: nextPatterns }
-  });
+  await writePatterns(nextPatterns);
   renderOutput2(`Set ${nextPatterns.length} ignore rule(s).`);
 };
 var runClear = async (deps) => {
-  const { client, storeRef, renderOutput: renderOutput2 } = deps;
-  await client.upsertStoreByRef({
-    ...storeRef,
-    patch: { ignore: [] }
-  });
+  const { writePatterns, renderOutput: renderOutput2 } = deps;
+  await writePatterns([]);
   renderOutput2("Cleared ignore rules.");
 };
 var runAuto = async (deps) => {
   const {
-    client,
-    storeRef,
+    writePatterns,
     currentPatterns,
     assumeYes,
     confirmYesNo: confirmYesNo2,
@@ -29857,9 +30191,9 @@ var runAuto = async (deps) => {
     renderOutput: renderOutput2
   } = deps;
   const analysis = await analyzeLocal();
-  const additions = analysis.proposedPatterns.filter(
-    (proposed) => !currentPatterns.includes(proposed)
-  );
+  const proposed = analysis.proposedPatterns;
+  const alreadyAppended = JSON.stringify(currentPatterns.slice(-proposed.length)) === JSON.stringify(proposed);
+  const additions = alreadyAppended ? [] : proposed;
   if (additions.length === 0) {
     renderOutput2("Nothing to suggest \u2014 no new junk patterns detected.");
     await markOnboarded();
@@ -29872,19 +30206,18 @@ var runAuto = async (deps) => {
   const confirmed = await confirmYesNo2({
     assumeYes,
     nonInteractiveMessage: "Refusing to write ignore rules without confirmation. Re-run with --yes.",
-    prompt: `Add ${additions.length} ignore rule(s) to the store? [Y/n] `
+    prompt: `Add ${additions.length} ignore rule(s) to the shared ignore file? [Y/n] `
   });
   if (!confirmed) {
-    renderOutput2("Left the store setting unchanged.");
+    renderOutput2("Left the shared ignore file unchanged.");
     await markOnboarded();
     return;
   }
-  await client.upsertStoreByRef({
-    ...storeRef,
-    patch: { ignore: [...currentPatterns, ...additions] }
-  });
+  await writePatterns([...currentPatterns, ...additions]);
   await markOnboarded();
-  renderOutput2(`Added ${additions.length} ignore rule(s) to the store.`);
+  renderOutput2(
+    `Added ${additions.length} ignore rule(s) locally. Run fm sync to publish.`
+  );
 };
 var runIgnoreCommand = async (deps) => {
   const { subcommand, commandNames: commandNames2 } = deps;
@@ -29941,8 +30274,7 @@ var warnImminent = (analysis, renderWarning2) => {
 };
 var maybePromptIgnoreSetup = async (deps) => {
   const {
-    client,
-    storeRef,
+    writePatterns,
     currentPatterns,
     analysis,
     onboarded,
@@ -29983,13 +30315,10 @@ var maybePromptIgnoreSetup = async (deps) => {
   }
   const action = await chooseAction(analysis);
   if (action === "auto") {
-    await client.upsertStoreByRef({
-      ...storeRef,
-      patch: { ignore: analysis.proposedPatterns }
-    });
+    await writePatterns(analysis.proposedPatterns);
     await markOnboarded();
     renderOutput2(
-      `Added ${analysis.proposedPatterns.length} ignore rule(s) to the store.`
+      `Added ${analysis.proposedPatterns.length} shared ignore rule(s) locally.`
     );
     return {
       outcome: "auto-applied",
@@ -30016,10 +30345,10 @@ var maybePromptIgnoreSetup = async (deps) => {
 
 // src/collectIgnoreMarkers.ts
 import { stat as stat2 } from "fs/promises";
-import path8 from "path";
+import path10 from "path";
 var exists = async (rootDir, rule) => {
   try {
-    const stats = await stat2(path8.join(rootDir, rule.marker));
+    const stats = await stat2(path10.join(rootDir, rule.marker));
     return rule.markerKind === "dir" ? stats.isDirectory() : stats.isFile();
   } catch {
     return false;
@@ -30038,11 +30367,11 @@ var collectIgnoreMarkers = async (rootDir, rules = IGNORE_PROPOSAL_RULES) => {
 };
 
 // src/readGitignorePatterns.ts
-import { readFile as readFile3 } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile4 } from "fs/promises";
+import path11 from "path";
 var readGitignorePatterns = async (rootDir) => {
   try {
-    const raw = await readFile3(path9.join(rootDir, ".gitignore"), "utf8");
+    const raw = await readFile4(path11.join(rootDir, ".gitignore"), "utf8");
     return parseLocalIgnoreFile(raw);
   } catch {
     return [];
@@ -30106,9 +30435,9 @@ var createHumanWatchSubscriber = ({
         return;
       }
       case "sync.watch.conflict.raised": {
-        const path20 = String(details.path ?? "");
+        const path22 = String(details.path ?? "");
         const suggestions = details.suggestions ?? [];
-        error51(`Conflict: ${path20} \u2014 ${event.message ?? "needs attention"}`);
+        error51(`Conflict: ${path22} \u2014 ${event.message ?? "needs attention"}`);
         if (suggestions.length > 0) {
           error51(`  ${formatSuggestions(suggestions)}`);
         }
@@ -30137,10 +30466,10 @@ import notifier from "node-notifier";
 var createNotifyWatchSubscriber = () => {
   return (event) => {
     if (event.eventType === "sync.watch.conflict.raised") {
-      const path20 = event.details?.path;
+      const path22 = event.details?.path;
       notifier.notify({
         title: "Forum sync conflict",
-        message: typeof path20 === "string" ? `${path20} needs attention` : event.message ?? "A file needs attention"
+        message: typeof path22 === "string" ? `${path22} needs attention` : event.message ?? "A file needs attention"
       });
       return;
     }
@@ -30256,10 +30585,10 @@ var createConflictTracker = () => {
       );
       const raised = current.filter((conflict) => !active.has(conflict.path));
       const cleared = [...active.keys()].filter(
-        (path20) => !currentByPath.has(path20)
+        (path22) => !currentByPath.has(path22)
       );
-      for (const path20 of cleared) {
-        active.delete(path20);
+      for (const path22 of cleared) {
+        active.delete(path22);
       }
       for (const conflict of current) {
         active.set(conflict.path, conflict);
@@ -30270,13 +30599,13 @@ var createConflictTracker = () => {
 };
 
 // src/watch/conflictResolutionHints.ts
-var keepLocal = (path20) => ({
+var keepLocal = (path22) => ({
   label: "Keep local",
-  command: `fm push --force ${path20}`
+  command: `fm push --force ${path22}`
 });
-var acceptRemote = (path20) => ({
+var acceptRemote = (path22) => ({
   label: "Accept remote",
-  command: `fm pull --force ${path20}`
+  command: `fm pull --force ${path22}`
 });
 var review = (label, command) => ({
   label,
@@ -30292,23 +30621,23 @@ var forceResolvableTypes = /* @__PURE__ */ new Set([
   "reference-local-file",
   "read-only-local-change"
 ]);
-var conflictResolutionSuggestions = (conflictType, path20) => {
+var conflictResolutionSuggestions = (conflictType, path22) => {
   if (forceResolvableTypes.has(conflictType)) {
-    return [keepLocal(path20), acceptRemote(path20)];
+    return [keepLocal(path22), acceptRemote(path22)];
   }
-  return [review("Review", `fm status ${path20}`)];
+  return [review("Review", `fm status ${path22}`)];
 };
 
 // src/watch/extractWatchConflicts.ts
 var toWatchConflict = (issue2) => {
-  const { path: path20, message, relatedPaths } = issue2.details.details;
+  const { path: path22, message, relatedPaths } = issue2.details.details;
   const conflictType = issue2.details.type;
   return {
-    path: path20,
+    path: path22,
     conflictType,
     message,
     relatedPaths: relatedPaths ?? [],
-    suggestions: conflictResolutionSuggestions(conflictType, path20)
+    suggestions: conflictResolutionSuggestions(conflictType, path22)
   };
 };
 var extractWatchConflicts = (result) => {
@@ -30399,9 +30728,9 @@ var createCheckoutWatcher = ({
             })
           );
         }
-        for (const path20 of cleared) {
+        for (const path22 of cleared) {
           bus.emit(
-            watchEvent("sync.watch.conflict.cleared", void 0, { path: path20 })
+            watchEvent("sync.watch.conflict.cleared", void 0, { path: path22 })
           );
         }
         bus.emit(
@@ -30619,7 +30948,7 @@ var runSyncWatchDirectory = async (options2) => {
 };
 
 // src/watch/fleetStatusSubscriber.ts
-import path10 from "path";
+import path12 from "path";
 var STATUS_BADGE = {
   starting: "\u2026",
   clean: "\u2713",
@@ -30637,15 +30966,15 @@ var STATUS_COLOR = {
 var deriveLabels = (rootDirs) => {
   const counts = /* @__PURE__ */ new Map();
   for (const dir of rootDirs) {
-    const base = path10.basename(dir);
+    const base = path12.basename(dir);
     counts.set(base, (counts.get(base) ?? 0) + 1);
   }
   const labels = /* @__PURE__ */ new Map();
   for (const dir of rootDirs) {
-    const base = path10.basename(dir);
+    const base = path12.basename(dir);
     labels.set(
       dir,
-      (counts.get(base) ?? 0) > 1 ? path10.join(path10.basename(path10.dirname(dir)), base) : base
+      (counts.get(base) ?? 0) > 1 ? path12.join(path12.basename(path12.dirname(dir)), base) : base
     );
   }
   return labels;
@@ -30744,7 +31073,7 @@ var createFleetStatusSubscriber = (rootDirs, { write, isTty }) => {
 };
 
 // src/watch/discoverCheckouts.ts
-import path11 from "path";
+import path13 from "path";
 import { readdir as readdir3, stat as stat3 } from "fs/promises";
 var pathExists2 = async (candidate) => {
   try {
@@ -30757,7 +31086,7 @@ var pathExists2 = async (candidate) => {
 var isCheckoutDir = async (dir) => {
   let hasStateDirectory = false;
   for (const name of checkoutStateDirectoryNames) {
-    if (await pathExists2(path11.join(dir, name))) {
+    if (await pathExists2(path13.join(dir, name))) {
       hasStateDirectory = true;
       break;
     }
@@ -30766,7 +31095,7 @@ var isCheckoutDir = async (dir) => {
     return false;
   }
   for (const filename of projectConfigFilenames) {
-    if (await pathExists2(path11.join(dir, filename))) {
+    if (await pathExists2(path13.join(dir, filename))) {
       return true;
     }
   }
@@ -30781,10 +31110,10 @@ var readSubdirectories = async (dir) => {
   }
   return entries.filter(
     (entry) => entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules"
-  ).map((entry) => path11.join(dir, entry.name));
+  ).map((entry) => path13.join(dir, entry.name));
 };
 var discoverCheckouts = async (rootPath) => {
-  const root = path11.resolve(rootPath);
+  const root = path13.resolve(rootPath);
   const found = [];
   const visit = async (dir) => {
     if (await isCheckoutDir(dir)) {
@@ -30799,51 +31128,27 @@ var discoverCheckouts = async (rootPath) => {
 };
 
 // src/watch/isIgnoredWatchPath.ts
-import path12 from "path";
-var ignoredWatchSegments = /* @__PURE__ */ new Set([
-  ".forum",
-  ".doctrine",
-  ".git",
-  "node_modules",
-  // Standard build/cache junk — never source content, and the usual offenders
-  // for high-churn writes during a build or test run.
-  ".cache",
-  ".next",
-  ".nuxt",
-  ".turbo",
-  ".svelte-kit",
-  "dist",
-  "build",
-  "coverage",
-  "out"
-]);
-var ignoredRootFiles = /* @__PURE__ */ new Set([
-  "forum.yaml",
-  "forum.yml",
-  "doctrine.yaml",
-  "doctrine.yml"
-]);
+import path14 from "path";
 var isIgnoredWatchPath = (filename) => {
-  if (!filename) {
-    return false;
-  }
-  const relativePath = String(filename).split(path12.sep).join("/");
-  const segments2 = relativePath.split("/").filter((segment) => segment !== "");
-  if (segments2.some((segment) => ignoredWatchSegments.has(segment))) {
-    return true;
-  }
-  return segments2.length === 1 && ignoredRootFiles.has(segments2[0]);
+  if (!filename) return false;
+  const relativePath = String(filename).split(path14.sep).join("/");
+  const segments2 = relativePath.split("/").filter(Boolean);
+  if (segments2.includes(".git")) return true;
+  const metadataIndex = segments2.indexOf(".forum");
+  if (metadataIndex === -1) return false;
+  const metadataPath = segments2.slice(metadataIndex + 1).join("/");
+  return !(metadataPath === "usr_ignore" || metadataPath === "sync.yaml" || /^stores\/[^/]+\/ignore$/.test(metadataPath));
 };
 
 // src/watch/readPathsFile.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 var readPathsFile = async (file2) => {
-  const contents = await readFile4(file2, "utf8");
+  const contents = await readFile5(file2, "utf8");
   return contents.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 };
 
 // src/watch/resolveWatchWorkingSet.ts
-import path13 from "path";
+import path15 from "path";
 var resolveWatchWorkingSet = async ({ watchPaths, pathsFile }, resolvers) => {
   const explicitPaths = [...watchPaths];
   if (pathsFile !== null) {
@@ -30866,7 +31171,7 @@ var resolveWatchWorkingSet = async ({ watchPaths, pathsFile }, resolvers) => {
   const entries = [];
   const errors = [];
   for (const rawPath of explicitPaths) {
-    const resolved = path13.resolve(rawPath);
+    const resolved = path15.resolve(rawPath);
     if (seen.has(resolved)) {
       continue;
     }
@@ -31102,6 +31407,10 @@ var createStoreClient = ({
     createStore: (input) => call("stores.create", () => trpc.stores.create.mutate(input)),
     deleteStore: (input) => call("stores.delete", () => trpc.stores.delete.mutate(input)),
     readStoreByRef: (input) => call("stores.readByRef", () => trpc.stores.readByRef.query(input)),
+    syncStoreIgnoreByRef: (input) => call(
+      "stores.syncIgnoreByRef",
+      () => trpc.stores.syncIgnoreByRef.mutate(input)
+    ),
     upsertStoreByRef: (input) => call("stores.upsertByRef", () => trpc.stores.upsertByRef.mutate(input)),
     deleteFileByRef: (input) => call(
       "files.deleteFileByRef",
@@ -31233,10 +31542,9 @@ var createClient = (config2) => {
 
 // src/state.ts
 import { homedir } from "os";
-import path14 from "path";
-import { access as access2, mkdir as mkdir4, readFile as readFile5, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import path16 from "path";
+import { mkdir as mkdir5, readFile as readFile6, rename as rename3, writeFile as writeFile4 } from "fs/promises";
 var DEFAULT_STATE_DIRNAME = ".forum";
-var LEGACY_STATE_DIRNAME = ".doctrine";
 var DEFAULT_POLL_INTERVAL_MS = 4e3;
 var DEFAULT_API_BASE_URL = "https://api.forumlabs.net";
 var DEFAULT_CONFIG = {
@@ -31244,49 +31552,32 @@ var DEFAULT_CONFIG = {
   pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
   forceWrites: false
 };
-var legacyStateDir = () => path14.join(homedir(), LEGACY_STATE_DIRNAME);
-var defaultStateDir = () => path14.join(homedir(), DEFAULT_STATE_DIRNAME);
-var configPath = (stateDir) => path14.join(stateDir, "config.json");
+var defaultStateDir = () => path16.join(homedir(), DEFAULT_STATE_DIRNAME);
+var configPath = (stateDir) => path16.join(stateDir, "config.json");
 var ensureStateDir = async (stateDir) => {
-  await mkdir4(stateDir, { recursive: true });
+  await mkdir5(stateDir, { recursive: true });
 };
 var readJson = async (filePath, fallback) => {
   try {
-    const raw = await readFile5(filePath, "utf8");
+    const raw = await readFile6(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return fallback;
   }
 };
-var fileExists2 = async (filePath) => {
-  try {
-    await access2(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var readConfigSourcePath = async (stateDir) => {
-  const currentPath = configPath(stateDir);
-  if (stateDir !== defaultStateDir() || await fileExists2(currentPath)) {
-    return currentPath;
-  }
-  const legacyPath = configPath(legacyStateDir());
-  return await fileExists2(legacyPath) ? legacyPath : currentPath;
-};
 var writeJsonAtomic = async (filePath, value) => {
-  const parentDir = path14.dirname(filePath);
-  const tempPath = path14.join(
+  const parentDir = path16.dirname(filePath);
+  const tempPath = path16.join(
     parentDir,
-    `.${path14.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
+    `.${path16.basename(filePath)}.${process.pid}.${Date.now()}.tmp`
   );
-  await mkdir4(parentDir, { recursive: true });
+  await mkdir5(parentDir, { recursive: true });
   await writeFile4(tempPath, JSON.stringify(value, null, 2), "utf8");
   await rename3(tempPath, filePath);
 };
 var readConfig = async (stateDir) => {
   const config2 = await readJson(
-    await readConfigSourcePath(stateDir),
+    configPath(stateDir),
     DEFAULT_CONFIG
   );
   return {
@@ -31301,28 +31592,28 @@ var writeConfig = async (stateDir, config2) => {
 
 // src/skillIntegration.ts
 import { constants } from "fs";
-import { access as access3 } from "fs/promises";
+import { access as access2 } from "fs/promises";
 import os from "os";
-import path17 from "path";
+import path19 from "path";
 import Enquirer from "enquirer";
 
 // src/skillProviders/claude.ts
-import path15 from "path";
+import path17 from "path";
 var claudeSkillProvider = {
   id: "claude",
-  globalRootCandidates: (home) => [path15.join(home, ".claude", "skills")],
-  localRoot: (projectDir) => path15.join(projectDir, ".claude", "skills")
+  globalRootCandidates: (home) => [path17.join(home, ".claude", "skills")],
+  localRoot: (projectDir) => path17.join(projectDir, ".claude", "skills")
 };
 
 // src/skillProviders/codex.ts
-import path16 from "path";
+import path18 from "path";
 var codexSkillProvider = {
   id: "codex",
   globalRootCandidates: (home) => [
-    path16.join(home, ".codex", "skills"),
-    path16.join(home, ".agents", "skills")
+    path18.join(home, ".codex", "skills"),
+    path18.join(home, ".agents", "skills")
   ],
-  localRoot: (projectDir) => path16.join(projectDir, ".codex", "skills")
+  localRoot: (projectDir) => path18.join(projectDir, ".codex", "skills")
 };
 
 // src/skillProviders/registry.ts
@@ -31343,13 +31634,13 @@ var expandHomePath = (input) => {
     return process.env.HOME || os.homedir();
   }
   if (input.startsWith("~/")) {
-    return path17.join(process.env.HOME || os.homedir(), input.slice(2));
+    return path19.join(process.env.HOME || os.homedir(), input.slice(2));
   }
   return input;
 };
 var pathExists3 = async (filePath) => {
   try {
-    await access3(filePath);
+    await access2(filePath);
     return true;
   } catch {
     return false;
@@ -31860,13 +32151,13 @@ var editEncryptedText = async ({
 
 // src/openInEditor.ts
 import { spawn } from "child_process";
-import { mkdtemp, readFile as readFile6, rm as rm3, writeFile as writeFile5 } from "fs/promises";
+import { mkdtemp, readFile as readFile7, rm as rm4, writeFile as writeFile5 } from "fs/promises";
 import { tmpdir } from "os";
-import path18 from "path";
+import path20 from "path";
 var openInEditor = async (currentText, { extension = "" } = {}) => {
   const editor = process.env.EDITOR?.trim() || "vi";
-  const dir = await mkdtemp(path18.join(tmpdir(), "fm-edit-"));
-  const tempPath = path18.join(dir, `edit${extension}`);
+  const dir = await mkdtemp(path20.join(tmpdir(), "fm-edit-"));
+  const tempPath = path20.join(dir, `edit${extension}`);
   try {
     await writeFile5(tempPath, currentText, "utf8");
     const exitCode = await new Promise((resolve, reject) => {
@@ -31881,9 +32172,9 @@ var openInEditor = async (currentText, { extension = "" } = {}) => {
     if (exitCode !== 0) {
       return null;
     }
-    return await readFile6(tempPath, "utf8");
+    return await readFile7(tempPath, "utf8");
   } finally {
-    await rm3(dir, { force: true, recursive: true }).catch(() => {
+    await rm4(dir, { force: true, recursive: true }).catch(() => {
     });
   }
 };
@@ -32025,7 +32316,7 @@ Usage:
   fm push [filePath] [--token <jwt>] [--force] [--yes|-y] [--dry-run|-d] [--verbose|--debug]
   fm status [--token <jwt>] [--json]
   fm s [--token <jwt>] [--json]
-  fm sync [--token <jwt>] [--force] [--yes|-y] [--verbose] [--watch] [--readonly]
+  fm sync [--token <jwt>] [--conflict|-c local|remote] [--force] [--yes|-y] [--verbose] [--watch] [--readonly]
   fm sync --watch [<path>] [--notify] [--json] [--readonly]
   fm sync --watch <path...> [--paths-file <file>] [--notify] [--json]
   fm sync --dry-run|-d [--token <jwt>] [--json]
@@ -32057,7 +32348,7 @@ Usage:
   fm --version
 
 Store creation:
-  fm store create <storeId> creates in defaults.store's workspace from forum.yaml when present, otherwise in the authenticated workspace.
+  fm store create <storeId> creates in defaults.store's workspace from .forum/sync.yaml when present, otherwise in the authenticated workspace.
   fm store create <workspace/storeId> creates in that explicitly selected workspace.
 
 Auth:
@@ -32075,7 +32366,7 @@ Output:
 `;
 var readCliVersion = async () => {
   const packageJson = JSON.parse(
-    await readFile7(new URL("../package.json", import.meta.url), "utf8")
+    await readFile8(new URL("../package.json", import.meta.url), "utf8")
   );
   return typeof packageJson.version === "string" ? packageJson.version : "unknown";
 };
@@ -32116,6 +32407,7 @@ var parseArgvCommandName = (argv) => {
 var parseArgs = (argv) => {
   const positional = [];
   const shouldParseDirectPullMapping = argv.includes("pull") && argv.includes("--direct");
+  const isSyncCommand = parseArgvCommandName(argv) === "sync";
   const isCatCommand = parseArgvCommandName(argv) === "cat";
   let token = null;
   const storeFilters = [];
@@ -32135,6 +32427,7 @@ var parseArgs = (argv) => {
   let stateDir = defaultStateDir();
   let pollIntervalMs = null;
   let dryRun = false;
+  let conflictPolicy;
   let force = false;
   let direct = false;
   let json2 = false;
@@ -32181,7 +32474,7 @@ var parseArgs = (argv) => {
       continue;
     }
     if (current === "--file" || current === "-f") {
-      inputFilePath = next ? path19.resolve(next) : inputFilePath;
+      inputFilePath = next ? path21.resolve(next) : inputFilePath;
       index += 1;
       continue;
     }
@@ -32246,7 +32539,7 @@ var parseArgs = (argv) => {
       if (!next) {
         throw new Error("--target-dir requires a path.");
       }
-      skillTargetDir = path19.resolve(expandHomePath(next));
+      skillTargetDir = path21.resolve(expandHomePath(next));
       index += 1;
       continue;
     }
@@ -32258,7 +32551,7 @@ var parseArgs = (argv) => {
       continue;
     }
     if (current === "--state-dir") {
-      stateDir = path19.resolve(next ?? stateDir);
+      stateDir = path21.resolve(next ?? stateDir);
       index += 1;
       continue;
     }
@@ -32266,12 +32559,12 @@ var parseArgs = (argv) => {
       if (!next) {
         throw new Error("--paths-file requires a file path.");
       }
-      pathsFile = path19.resolve(expandHomePath(next));
+      pathsFile = path21.resolve(expandHomePath(next));
       index += 1;
       continue;
     }
     if (current.startsWith("--paths-file=")) {
-      pathsFile = path19.resolve(
+      pathsFile = path21.resolve(
         expandHomePath(current.slice("--paths-file=".length))
       );
       continue;
@@ -32285,6 +32578,15 @@ var parseArgs = (argv) => {
       openBrowser = false;
       continue;
     }
+    if (isSyncCommand && (current === "-c" || current === "--conflict" || current.startsWith("--conflict="))) {
+      const value = current.startsWith("--conflict=") ? current.slice("--conflict=".length) : next;
+      if (value !== "local" && value !== "remote") {
+        throw new Error("--conflict requires local or remote.");
+      }
+      conflictPolicy = value;
+      if (!current.startsWith("--conflict=")) index += 1;
+      continue;
+    }
     if (current === "--force") {
       force = true;
       continue;
@@ -32337,6 +32639,7 @@ var parseArgs = (argv) => {
   }
   return {
     args: positional,
+    conflictPolicy,
     token,
     storeFilters,
     searchLimit,
@@ -32459,10 +32762,10 @@ var listDirectoryEntries = async (listDirectory, directoryPath) => {
     if (left.type !== "directory" && right.type === "directory") {
       return 1;
     }
-    return path19.basename(left.path).localeCompare(path19.basename(right.path));
+    return path21.basename(left.path).localeCompare(path21.basename(right.path));
   }).forEach((entry) => {
     const suffix = entry.type === "directory" ? "/" : "";
-    renderOutput(`${path19.basename(entry.path)}${suffix}`);
+    renderOutput(`${path21.basename(entry.path)}${suffix}`);
   });
 };
 var listStores = async (listStoresMetadata) => {
@@ -32757,7 +33060,7 @@ var normalizeSkillAgents = (inputs) => {
   return [...new Set(inputs.map(normalizeSkillAgent))];
 };
 var normalizeRemoteSkillPath = (input) => {
-  const normalized = path19.posix.normalize(`/${input.trim()}`);
+  const normalized = path21.posix.normalize(`/${input.trim()}`);
   if (normalized === "/") {
     throw new Error("Skill path must not be the store root.");
   }
@@ -32767,11 +33070,11 @@ var normalizeRemoteSkillPath = (input) => {
   return normalized;
 };
 var parentRemotePath = (filePath) => {
-  const parent = path19.posix.dirname(filePath);
+  const parent = path21.posix.dirname(filePath);
   return parent === "." ? "/" : parent;
 };
 var joinRemotePath = (left, right) => {
-  return path19.posix.join(left, right).replace(/\/+/g, "/");
+  return path21.posix.join(left, right).replace(/\/+/g, "/");
 };
 var readRemoteSkillTextFile = async (filePath, storeRef, client) => {
   const file2 = await client.readFileByRef({ ...storeRef, path: filePath });
@@ -32833,7 +33136,7 @@ var collectRemoteSkillFiles = async ({
         `Skill contains unsupported ${entry.type} entry: ${entry.path}`
       );
     }
-    const relativePath = path19.posix.relative(rootPath, entry.path);
+    const relativePath = path21.posix.relative(rootPath, entry.path);
     if (!relativePath || relativePath.startsWith("..")) {
       throw new Error(
         `Unexpected skill entry outside skill root: ${entry.path}`
@@ -32847,7 +33150,7 @@ var collectRemoteSkillFiles = async ({
 };
 var resolveRemoteSkillRoot = async (inputPath, storeRef, client) => {
   const normalizedPath = normalizeRemoteSkillPath(inputPath);
-  if (path19.posix.basename(normalizedPath) === "SKILL.md") {
+  if (path21.posix.basename(normalizedPath) === "SKILL.md") {
     await readRemoteSkillTextFile(normalizedPath, storeRef, client);
     return {
       rootPath: parentRemotePath(normalizedPath),
@@ -32927,7 +33230,7 @@ var resolveSkillInstallTargets = async ({
       return {
         agent,
         rootDir,
-        targetDir: path19.join(rootDir, skillName)
+        targetDir: path21.join(rootDir, skillName)
       };
     })
   );
@@ -32966,24 +33269,24 @@ var formatSkillTarget = (target, existingTargetDirs) => {
   return `  ${target.agent.padEnd(7)} ${target.targetDir}${suffix}`;
 };
 var writeSkillFiles = async (target, files, replaceExisting) => {
-  const temporaryDirectory = path19.join(
+  const temporaryDirectory = path21.join(
     target.rootDir,
-    `.${path19.basename(target.targetDir)}.tmp-${process.pid}-${Date.now()}`
+    `.${path21.basename(target.targetDir)}.tmp-${process.pid}-${Date.now()}`
   );
-  await rm4(temporaryDirectory, { recursive: true, force: true });
-  await mkdir5(temporaryDirectory, { recursive: true });
+  await rm5(temporaryDirectory, { recursive: true, force: true });
+  await mkdir6(temporaryDirectory, { recursive: true });
   try {
     for (const file2 of files) {
-      const localPath = path19.join(temporaryDirectory, file2.relativePath);
-      await mkdir5(path19.dirname(localPath), { recursive: true });
+      const localPath = path21.join(temporaryDirectory, file2.relativePath);
+      await mkdir6(path21.dirname(localPath), { recursive: true });
       await writeFile6(localPath, file2.bytes);
     }
     if (replaceExisting) {
-      await rm4(target.targetDir, { recursive: true, force: true });
+      await rm5(target.targetDir, { recursive: true, force: true });
     }
     await rename4(temporaryDirectory, target.targetDir);
   } catch (error51) {
-    await rm4(temporaryDirectory, { recursive: true, force: true });
+    await rm5(temporaryDirectory, { recursive: true, force: true });
     throw error51;
   }
 };
@@ -33026,7 +33329,7 @@ var installSkillBundle = async ({
     throw new Error("Aborted skill install.");
   }
   for (const target of targets) {
-    await mkdir5(target.rootDir, { recursive: true });
+    await mkdir6(target.rootDir, { recursive: true });
   }
   for (const target of targets) {
     await writeSkillFiles(
@@ -33058,7 +33361,7 @@ var readRemoteSkillBundle = async ({
     client
   );
   const metadata = parseSkillMetadata(skillMarkdown);
-  const rootName = path19.posix.basename(rootPath);
+  const rootName = path21.posix.basename(rootPath);
   if (metadata.name !== rootName) {
     throw new Error(
       `SKILL.md name "${metadata.name}" must match skill directory "${rootName}".`
@@ -33238,7 +33541,7 @@ var readWriteTextInput = async (inlineText, inputFilePath) => {
     throw new Error("Provide either inline text or --file, not both.");
   }
   if (inputFilePath) {
-    return readFile7(inputFilePath, "utf8");
+    return readFile8(inputFilePath, "utf8");
   }
   return inlineText ?? null;
 };
@@ -33254,7 +33557,7 @@ var readRemoteTextFile = async (filePath, storeRef, client) => {
   return text;
 };
 var normalizeRemotePath = (input) => {
-  const normalized = path19.posix.normalize(`/${input.trim()}`);
+  const normalized = path21.posix.normalize(`/${input.trim()}`);
   if (normalized.includes("\0")) {
     throw new Error("Path contains an invalid null byte.");
   }
@@ -33548,7 +33851,7 @@ var diffRemoteFiles = async ({
   storeRef
 }) => {
   const leftText = await readRemoteTextFile(leftPath, storeRef, client);
-  const rightText = localRight ? await readFile7(path19.resolve(rightPath), "utf8") : await readRemoteTextFile(rightPath, storeRef, client);
+  const rightText = localRight ? await readFile8(path21.resolve(rightPath), "utf8") : await readRemoteTextFile(rightPath, storeRef, client);
   return buildUnifiedDiff({
     leftLabel: leftPath,
     leftText,
@@ -33615,8 +33918,8 @@ var copyRemotePath = async (args, storeRef, client) => {
     (entry) => entry.path.startsWith(`${normalizedSource}/`)
   );
   for (const entry of descendants) {
-    const relativePath = path19.posix.relative(normalizedSource, entry.path);
-    const targetPath = path19.posix.join(normalizedDestination, relativePath);
+    const relativePath = path21.posix.relative(normalizedSource, entry.path);
+    const targetPath = path21.posix.join(normalizedDestination, relativePath);
     if (entry.type === "directory") {
       await createRemoteDirectory(targetPath, storeRef, client);
       continue;
@@ -33811,19 +34114,19 @@ var runDecryptCommand = async (rest, parsed, client) => {
   );
 };
 var runEditCommand = async (rest, parsed, client) => {
-  const filePath = parsed.inputFilePath ?? (rest[0] ? path19.resolve(rest[0]) : null);
+  const filePath = parsed.inputFilePath ?? (rest[0] ? path21.resolve(rest[0]) : null);
   if (!filePath) {
     throw new Error(
       `Usage: ${commandNames} edit (<localPath>|--file|-f <localPath>) [--password <password>] [--token <jwt>]`
     );
   }
-  const encryptedText = await readFile7(filePath, "utf8");
+  const encryptedText = await readFile8(filePath, "utf8");
   const [password, userEncryption] = await Promise.all([
     readEncryptionPassword(parsed),
     readUserEncryption(client)
   ]);
   const result = await editEncryptedText({
-    edit: (currentPlaintext) => openInEditor(currentPlaintext, { extension: path19.extname(filePath) }),
+    edit: (currentPlaintext) => openInEditor(currentPlaintext, { extension: path21.extname(filePath) }),
     encryptedText,
     password,
     userEncryption: userEncryption.userEncryption
@@ -33899,10 +34202,10 @@ var runEncryptAddRecipientCommand = async (rest, parsed, client) => {
 `);
   renderOutput(result.encryptedText);
 };
-var defaultEncryptionMigrationBackupPath = () => path19.resolve(process.cwd(), "doctrine-encryption-migration.json");
-var readEncryptionMigrationBackup = async (backupPath) => JSON.parse(await readFile7(backupPath, "utf8"));
+var defaultEncryptionMigrationBackupPath = () => path21.resolve(process.cwd(), "doctrine-encryption-migration.json");
+var readEncryptionMigrationBackup = async (backupPath) => JSON.parse(await readFile8(backupPath, "utf8"));
 var writeEncryptionMigrationBackup = async (backupPath, backup) => {
-  await mkdir5(path19.dirname(backupPath), { recursive: true });
+  await mkdir6(path21.dirname(backupPath), { recursive: true });
   await writeFile6(backupPath, `${JSON.stringify(backup, null, 2)}
 `, "utf8");
 };
@@ -34190,7 +34493,7 @@ var runEncryptionMigrateCommand = async (rest, parsed, client) => {
       `Usage: ${commandNames} encryption migrate [backup-file] [--store <storeId>] [--password <password>] [--dry-run] [--yes]`
     );
   }
-  const backupPath = path19.resolve(
+  const backupPath = path21.resolve(
     rest[1] ?? defaultEncryptionMigrationBackupPath()
   );
   const password = await readEncryptionPassword(parsed);
@@ -34265,7 +34568,7 @@ var doesRemoteQueryMatchPath = (query, filePath) => {
   if (query.startsWith("/")) {
     return normalizedPath === query;
   }
-  const filename = path19.basename(filePath).toLowerCase();
+  const filename = path21.basename(filePath).toLowerCase();
   return filename === query || normalizedPath === query || filename.includes(query) || normalizedPath.includes(query);
 };
 var queryRemoteFiles = async (query, storeFilters, client) => {
@@ -34337,7 +34640,7 @@ var printRemoteQueryMatches = (matches) => {
   });
 };
 var normalizeRemoteDirectoryPath = (input) => {
-  const normalized = path19.posix.normalize(`/${input.trim()}`);
+  const normalized = path21.posix.normalize(`/${input.trim()}`);
   if (normalized.includes("\0")) {
     throw new Error("Path contains an invalid null byte.");
   }
@@ -34457,12 +34760,12 @@ var labelFromTreeDirectoryPath = (directoryPath) => {
   if (directoryPath === "/") {
     return "./";
   }
-  return `${path19.posix.basename(directoryPath)}/`;
+  return `${path21.posix.basename(directoryPath)}/`;
 };
 var doesTreeFilterMatchDirectory = (filter, directoryPath) => {
   const normalizedFilter = filter.trim().toLowerCase();
   const normalizedPath = directoryPath.toLowerCase();
-  const basename3 = path19.posix.basename(directoryPath).toLowerCase();
+  const basename3 = path21.posix.basename(directoryPath).toLowerCase();
   return basename3.includes(normalizedFilter) || normalizedPath.includes(normalizedFilter);
 };
 var resolveTreeDirectoryPath = async ({
@@ -34517,7 +34820,7 @@ var printRemoteTreeChildren = async ({
     const childPrefix = isLast ? "    " : "\u2502   ";
     const suffix = entry.type === "directory" ? "/" : "";
     lines.push(
-      `${prefix}${connector}${path19.posix.basename(entry.path)}${suffix}`
+      `${prefix}${connector}${path21.posix.basename(entry.path)}${suffix}`
     );
     if (entry.type === "directory") {
       await printRemoteTreeChildren({
@@ -34856,7 +35159,7 @@ var parseRootStorePath = (storePathInput) => {
 var parseNewStorePath = (storePathInput) => {
   return parseRootStorePath(storePathInput);
 };
-var storeCreateSyntaxMessage = "Store ref must be a store ID like 'my-store' or a qualified ref like 'workspace/my-store'. Unqualified store IDs use defaults.store from forum.yaml when present, otherwise the authenticated workspace.";
+var storeCreateSyntaxMessage = "Store ref must be a store ID like 'my-store' or a qualified ref like 'workspace/my-store'. Unqualified store IDs use defaults.store from .forum/sync.yaml when present, otherwise the authenticated workspace.";
 var parseStoreCreateInput = async (storePathInput) => {
   const segments2 = storePathInput.split("/").map((segment) => segment.trim()).filter(Boolean);
   if (segments2.length === 2) {
@@ -35129,9 +35432,9 @@ var shouldPrintCheckoutDetail = (detail, verbose) => {
 var formatCheckoutDetail = (detail, options2) => {
   const status = checkoutStatusLabel(detail, options2);
   const direction = checkoutDirectionLabel(detail);
-  const path20 = formatCheckoutDetailPath(detail, options2.syncRules);
+  const path22 = formatCheckoutDetailPath(detail, options2.syncRules);
   const reason = styleText.dim(checkoutDetailMessage(detail));
-  return direction ? `${direction} ${status} ${path20} ${reason}` : `${status} ${path20} ${reason}`;
+  return direction ? `${direction} ${status} ${path22} ${reason}` : `${status} ${path22} ${reason}`;
 };
 var formatCheckoutDetailPath = (detail, syncRules) => {
   const localPath = formatLocalCheckoutPath(detail.relativePath);
@@ -35343,9 +35646,9 @@ var checkoutReportGroups = (details, options2) => {
   );
 };
 var checkoutReportDetailLine = (detail, options2) => {
-  const path20 = formatCheckoutDetailPath(detail, options2.syncRules);
+  const path22 = formatCheckoutDetailPath(detail, options2.syncRules);
   const message = detail.status === "failed" || detail.status === "skipped" || detail.status === "ignored" ? detail.message ?? checkoutDetailMessage(detail) : "";
-  return message ? `  ${path20}  ${styleText.dim(message)}` : `  ${path20}`;
+  return message ? `  ${path22}  ${styleText.dim(message)}` : `  ${path22}`;
 };
 var checkoutReportGroupBlock = ({
   dryRun,
@@ -35472,13 +35775,13 @@ var statusChangeKind = (detail) => {
 var formatStatusChange = (detail, syncRules) => {
   const kind = statusChangeKind(detail);
   const tone = kind === "deleted" ? "error" : kind === "added" ? "ok" : "warn";
-  const path20 = formatCheckoutDetailPath(detail, syncRules);
-  return `  ${styleText.color(tone, kind.padEnd(8))} ${path20}`;
+  const path22 = formatCheckoutDetailPath(detail, syncRules);
+  return `  ${styleText.color(tone, kind.padEnd(8))} ${path22}`;
 };
 var formatStatusBlock = (detail, syncRules) => {
   const message = detail.message ? ` ${styleText.dim(detail.message)}` : "";
-  const path20 = formatCheckoutDetailPath(detail, syncRules);
-  return `  ${styleText.color("error", "blocked ".padEnd(8))} ${path20}${message}`;
+  const path22 = formatCheckoutDetailPath(detail, syncRules);
+  return `  ${styleText.color("error", "blocked ".padEnd(8))} ${path22}${message}`;
 };
 var actionableStatusDetails = (result) => result.details.filter(
   (detail) => detail.status === "succeeded" || detail.status === "deleted"
@@ -35611,7 +35914,7 @@ var assertCheckoutSyncEnabled = (checkout) => {
     return;
   }
   throw new Error(
-    "Checkout sync is not configured in forum.yaml. Use fm config sync add --target <path> to enable local file sync."
+    "Checkout sync is not configured in .forum/sync.yaml. Use fm config sync add --target <path> to enable local file sync."
   );
 };
 var warnReadonlyCheckoutPush = (checkout, force) => {
@@ -35619,7 +35922,7 @@ var warnReadonlyCheckoutPush = (checkout, force) => {
     return;
   }
   renderWarning(
-    "Warning: forum.yaml has sync.readonly enabled. This manual push can write local files back to the store. Rerun with --force to bypass this reminder."
+    "Warning: .forum/sync.yaml has sync.readonly enabled. This manual push can write local files back to the store. Rerun with --force to bypass this reminder."
   );
 };
 var referenceStructuralChangeLabel = (detail) => {
@@ -35678,20 +35981,26 @@ var confirmCheckoutReferenceStructuralWrites = async ({
   yes
 }) => {
   const result = operation === "sync" ? await syncCheckout({
+    ignoreSettings: "sync",
     client,
     dryRun: true,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     progress,
     storeRef: {},
     syncRules: checkout.syncRules
   }) : await pushCheckout({
+    ignoreSettings: "preview",
     client,
     dryRun: true,
     filePaths,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     progress,
     storeRef: {},
@@ -35736,12 +36045,18 @@ var runCheckoutOperation = async ({
     filePaths,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     progress,
     storeRef: {},
     syncRules: checkout.syncRules
   };
-  const result = operation === "pull" ? await pullCheckout(commonInput) : await pushCheckout({ ...commonInput, dryRun });
+  const result = operation === "pull" ? await pullCheckout({ ...commonInput, ignoreSettings: "preview" }) : await pushCheckout({
+    ignoreSettings: "preview",
+    ...commonInput,
+    dryRun
+  });
   formatCheckoutResult(labels.summaryVerb, result, {
     detailsRendered: Boolean(progress),
     dryRun,
@@ -35835,6 +36150,7 @@ var assertCheckoutReadyForReadOnlyPull = async (checkout) => {
 };
 var runCheckoutPullThenPush = async ({
   checkout,
+  conflictPolicy,
   client,
   force,
   verbose,
@@ -35852,6 +36168,8 @@ var runCheckoutPullThenPush = async ({
   }
   progress?.start?.();
   const result = await syncCheckout({
+    ignoreSettings: "sync",
+    conflictPolicy,
     beforeRuleApply: async ({ result: rulePlan }) => {
       await confirmReferenceStructuralWrites(
         referenceStructuralWriteDetails(rulePlan),
@@ -35861,6 +36179,8 @@ var runCheckoutPullThenPush = async ({
     client,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     progress,
     storeRef: {},
@@ -35887,10 +36207,13 @@ var assertGitSyncHasNoPushPlan = async ({
   force
 }) => {
   const result = await pushCheckout({
+    ignoreSettings: "preview",
     client,
     dryRun: true,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     storeRef: {},
     syncRules: checkout.syncRules
@@ -35914,16 +36237,6 @@ var assertGitSyncHasNoPushPlan = async ({
     ].join("\n")
   );
 };
-var refreshStoreIgnoreCache = async (checkout, client) => {
-  const storeRef = await resolveProjectStoreRef();
-  if (!storeRef) {
-    return null;
-  }
-  const metadata = await client.readStoreByRef(storeRef);
-  const storeIgnore = metadata?.ignore ?? [];
-  await writeStoreIgnoreCache(checkout.rootDir, storeIgnore);
-  return { storeIgnore, storeRef };
-};
 var analyzeLocalIgnore = async (checkout) => {
   const [files, presentMarkers, gitignorePatterns] = await Promise.all([
     collectLocalCheckoutFiles(checkout.rootDir, []),
@@ -35954,17 +36267,30 @@ var promptIgnoreAction = async () => {
 };
 var isInteractiveTty = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
 var runIgnoreSetupGate = async (checkout, client, assumeYes) => {
-  const refreshed = await refreshStoreIgnoreCache(checkout, client);
-  if (!refreshed) {
-    return;
-  }
-  const { storeIgnore, storeRef } = refreshed;
-  if (storeIgnore.length > 0) {
-    return;
+  const storeRef = await resolveProjectStoreRef();
+  if (!storeRef) return;
+  const sharedFilePath = sharedIgnorePath(
+    checkout.rootDir,
+    `${storeRef.workspaceSlug}/${storeRef.storeSlug}`
+  );
+  let storeIgnore = await readSharedIgnoreFile(sharedFilePath);
+  if (storeIgnore === null) {
+    const metadata = await client.readStoreByRef(storeRef);
+    if (!metadata) throw new Error("Store not found for ignore setup.");
+    const restored = await reconcileSharedIgnoreFile({
+      rootDir: checkout.rootDir,
+      sharedFilePath,
+      store: `${storeRef.workspaceSlug}/${storeRef.storeSlug}`,
+      remote: metadata.ignore ?? [],
+      publish: async () => {
+      }
+    });
+    storeIgnore = restored.patterns;
   }
+  if (storeIgnore.length > 0) return;
   await maybePromptIgnoreSetup({
     assumeYes,
-    client,
+    writePatterns: (patterns) => writeSharedIgnoreFile(sharedFilePath, patterns),
     analysis: await analyzeLocalIgnore(checkout),
     onboarded: await readIgnoreOnboardedAt(checkout.rootDir) !== null,
     currentPatterns: storeIgnore,
@@ -35972,11 +36298,11 @@ var runIgnoreSetupGate = async (checkout, client, assumeYes) => {
     chooseAction: promptIgnoreAction,
     markOnboarded: () => markIgnoreOnboarded(checkout.rootDir),
     renderOutput,
-    renderWarning,
-    storeRef
+    renderWarning
   });
 };
 var runCheckoutSyncOnce = async ({
+  conflictPolicy,
   client,
   force,
   verbose,
@@ -35984,17 +36310,27 @@ var runCheckoutSyncOnce = async ({
 }) => {
   const checkout = await resolveCheckoutConfig();
   assertCheckoutSyncEnabled(checkout);
-  await runCheckoutPullThenPush({ checkout, client, force, verbose, yes });
+  await runCheckoutPullThenPush({
+    checkout,
+    client,
+    conflictPolicy,
+    force,
+    verbose,
+    yes
+  });
 };
 var DEFAULT_FULL_SYNC_INTERVAL_MS = 5 * 60 * 1e3;
 var runCheckoutSyncCollecting = async ({
   checkout,
+  conflictPolicy,
   client,
   force,
   yes = false
 }) => {
   assertCheckoutSyncEnabled(checkout);
   return syncCheckout({
+    ignoreSettings: "sync",
+    conflictPolicy,
     beforeRuleApply: async ({ result }) => {
       await confirmReferenceStructuralWrites(
         referenceStructuralWriteDetails(result),
@@ -36004,6 +36340,8 @@ var runCheckoutSyncCollecting = async ({
     client,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     storeRef: {},
     syncRules: checkout.syncRules
@@ -36030,14 +36368,15 @@ var runCheckoutStatus = async ({
 }) => {
   const initialCheckout = await resolveCheckoutConfig();
   assertCheckoutSyncEnabled(initialCheckout);
-  await refreshStoreIgnoreCache(initialCheckout, client);
-  const checkout = await resolveCheckoutConfig();
-  assertCheckoutSyncEnabled(checkout);
+  const checkout = initialCheckout;
   const pullResult = await pullCheckout({
+    ignoreSettings: "preview",
     client,
     dryRun: true,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     storeRef: {},
     syncRules: checkout.syncRules
@@ -36080,10 +36419,13 @@ var runCheckoutStatus = async ({
     return;
   }
   const pushResult = await pushCheckout({
+    ignoreSettings: "preview",
     client,
     dryRun: true,
     force,
     ignorePatterns: checkout.ignore,
+    ignorePatternsByStore: checkout.ignorePatternsByStore,
+    ignoreMatchersByRule: checkout.ignoreMatchersByRule,
     localPath: checkout.rootDir,
     storeRef: {},
     syncRules: checkout.syncRules
@@ -36096,18 +36438,18 @@ var runCheckoutStatus = async ({
   });
 };
 var isCheckoutStateGitPath = isCheckoutStateDirectoryPath;
-var checkoutFilesManifestPath2 = (checkoutRootDir) => `${resolveCheckoutStateDirectoryName(checkoutRootDir)}/files.json`;
+var checkoutFilesManifestPath2 = () => `${resolveCheckoutStateDirectoryName()}/files.json`;
 var isInsideOrEqual = (parentPath, childPath2) => {
-  const relativePath = path19.relative(parentPath, childPath2);
-  return relativePath === "" || !relativePath.startsWith("..") && !path19.isAbsolute(relativePath);
+  const relativePath = path21.relative(parentPath, childPath2);
+  return relativePath === "" || !relativePath.startsWith("..") && !path21.isAbsolute(relativePath);
 };
 var resolveSyncTargetPaths = (checkout) => checkout.syncRules.map(
-  (rule) => path19.resolve(checkout.rootDir, rule.target || ".")
+  (rule) => path21.resolve(checkout.rootDir, rule.target || ".")
 );
-var resolveCheckoutManifestGitPath = (checkout, gitRoot) => path19.relative(
+var resolveCheckoutManifestGitPath = (checkout, gitRoot) => path21.relative(
   gitRoot,
-  path19.join(checkout.rootDir, checkoutFilesManifestPath2(checkout.rootDir))
-) || checkoutFilesManifestPath2(checkout.rootDir);
+  path21.join(checkout.rootDir, checkoutFilesManifestPath2())
+) || checkoutFilesManifestPath2();
 var stageCheckoutManifest = async ({
   checkout,
   gitRoot
@@ -36132,7 +36474,7 @@ var assertGitChangesStayInSyncTargets = async ({
     if (isCheckoutStateGitPath(entry.path)) {
       return false;
     }
-    const absolutePath = path19.resolve(gitRoot, entry.path);
+    const absolutePath = path21.resolve(gitRoot, entry.path);
     return !allowedPaths.some(
       (allowedPath) => isInsideOrEqual(allowedPath, absolutePath)
     );
@@ -36154,7 +36496,7 @@ var stageGitSyncTargets = async ({
 }) => {
   const targetPaths = [];
   for (const targetPath of resolveSyncTargetPaths(checkout)) {
-    const relativePath = path19.relative(gitRoot, targetPath) || ".";
+    const relativePath = path21.relative(gitRoot, targetPath) || ".";
     const tracked = await runGit(gitRoot, ["ls-files", "--", relativePath]);
     if (await pathExists3(targetPath) || tracked.stdout.trim()) {
       targetPaths.push(relativePath);
@@ -36196,7 +36538,7 @@ var runGitSyncCommand = async ({
   assertCheckoutSyncEnabled(checkout);
   if (!checkout.gitSyncCommitMessage) {
     throw new Error(
-      "No Git sync commit message configured. Add git.commit-message to forum.yaml."
+      "No Git sync commit message configured. Add git.commit-message to .forum/sync.yaml."
     );
   }
   const gitRoot = await resolveGitRoot(checkout.rootDir);
@@ -36229,6 +36571,7 @@ var runCheckoutReadOnlyPullOnce = async ({
 };
 var buildCheckoutWatchEntry = ({
   checkout,
+  conflictPolicy,
   client,
   force,
   yes
@@ -36237,10 +36580,17 @@ var buildCheckoutWatchEntry = ({
   rootDir: checkout.rootDir,
   startMessage: `Watching ${checkout.rootDir}`,
   storeRefs: changesFeedStoreRefsForCheckout(checkout),
-  syncOnce: () => runCheckoutSyncCollecting({ checkout, client, force, yes })
+  syncOnce: async () => runCheckoutSyncCollecting({
+    checkout: await resolveCheckoutConfig(checkout.rootDir),
+    client,
+    conflictPolicy,
+    force,
+    yes
+  })
 });
 var resolveExplicitCheckoutEntry = async ({
   checkoutPath,
+  conflictPolicy,
   client,
   force,
   yes
@@ -36248,13 +36598,20 @@ var resolveExplicitCheckoutEntry = async ({
   const checkout = await resolveCheckoutConfig(checkoutPath);
   if (checkout.rootDir !== checkoutPath) {
     throw new Error(
-      `${checkoutPath} is not a Forum checkout (no forum.yaml here).`
+      `${checkoutPath} is not a Forum checkout (no .forum/sync.yaml here).`
     );
   }
   assertCheckoutSyncEnabled(checkout);
-  return buildCheckoutWatchEntry({ checkout, client, force, yes });
+  return buildCheckoutWatchEntry({
+    checkout,
+    client,
+    conflictPolicy,
+    force,
+    yes
+  });
 };
 var resolveDiscoveredCheckoutEntries = async ({
+  conflictPolicy,
   client,
   force,
   rootPath,
@@ -36270,7 +36627,9 @@ var resolveDiscoveredCheckoutEntries = async ({
     if (checkout.syncRules.length === 0) {
       continue;
     }
-    entries.push(buildCheckoutWatchEntry({ checkout, client, force, yes }));
+    entries.push(
+      buildCheckoutWatchEntry({ checkout, client, conflictPolicy, force, yes })
+    );
   }
   if (entries.length === 0) {
     throw new Error(
@@ -36280,6 +36639,7 @@ var resolveDiscoveredCheckoutEntries = async ({
   return entries;
 };
 var runCheckoutSyncWatch = async ({
+  conflictPolicy,
   client,
   force,
   intervalMs,
@@ -36352,12 +36712,30 @@ var runCheckoutSyncWatch = async ({
     { watchPaths, pathsFile },
     {
       readPathsFile,
-      resolveDiscoveredEntries: (rootPath) => resolveDiscoveredCheckoutEntries({ client, force, rootPath, yes }),
-      resolveExplicitEntry: (checkoutPath) => resolveExplicitCheckoutEntry({ checkoutPath, client, force, yes }),
+      resolveDiscoveredEntries: (rootPath) => resolveDiscoveredCheckoutEntries({
+        client,
+        conflictPolicy,
+        force,
+        rootPath,
+        yes
+      }),
+      resolveExplicitEntry: (checkoutPath) => resolveExplicitCheckoutEntry({
+        checkoutPath,
+        client,
+        conflictPolicy,
+        force,
+        yes
+      }),
       resolveSingleCheckoutEntry: async () => {
         const checkout = await resolveCheckoutConfig();
         assertCheckoutSyncEnabled(checkout);
-        return buildCheckoutWatchEntry({ checkout, client, force, yes });
+        return buildCheckoutWatchEntry({
+          checkout,
+          client,
+          conflictPolicy,
+          force,
+          yes
+        });
       }
     }
   );
@@ -36414,11 +36792,11 @@ var resolveReadableStore = async (storeInput, client) => {
 var writeCheckoutConfig = async (directoryPath, metadata, workspaceSlug, options2 = {}) => {
   if (!workspaceSlug) {
     throw new Error(
-      `Store ${metadata.slug} is missing a workspace slug and cannot be written to forum.yaml.`
+      `Store ${metadata.slug} is missing a workspace slug and cannot be written to .forum/sync.yaml.`
     );
   }
   await writeForumProjectConfig(
-    path19.join(directoryPath, defaultProjectConfigFilename),
+    path21.join(directoryPath, defaultProjectConfigFilename),
     {
       syncRules: [
         {
@@ -36434,6 +36812,18 @@ var writeCheckoutConfig = async (directoryPath, metadata, workspaceSlug, options
       ]
     }
   );
+  await reconcileSharedIgnoreFile({
+    rootDir: directoryPath,
+    sharedFilePath: sharedIgnorePath(
+      directoryPath,
+      `${workspaceSlug}/${metadata.slug}`
+    ),
+    store: `${workspaceSlug}/${metadata.slug}`,
+    remote: metadata.ignore ?? [],
+    publish: async () => {
+      throw new Error("Initialization cannot publish ignore rules.");
+    }
+  });
 };
 var normalizeProjectConfigPath = (value, fieldName, allowCurrentDirectory = false) => {
   const trimmed = value.trim().replace(/^\/+/, "").replace(/^\.\/+/, "").replace(/\/+$/, "");
@@ -36443,7 +36833,7 @@ var normalizeProjectConfigPath = (value, fieldName, allowCurrentDirectory = fals
     }
     throw new Error(`${fieldName} must be a non-empty relative path.`);
   }
-  if (path19.isAbsolute(value)) {
+  if (path21.isAbsolute(value)) {
     throw new Error(`${fieldName} must be a relative path.`);
   }
   const segments2 = trimmed.split("/");
@@ -36496,7 +36886,7 @@ var runProjectConfigSyncCommand = async (mode, args) => {
   const projectConfig = await findForumProjectConfig();
   if (!projectConfig) {
     throw new Error(
-      "No forum.yaml found. Run fm init <store> before configuring project sync."
+      "No .forum/sync.yaml found. Run fm init <store> before configuring project sync."
     );
   }
   if (mode === "clear") {
@@ -36599,7 +36989,7 @@ var runProjectConfigSyncCommand = async (mode, args) => {
 var runProjectConfigValidateCommand = async () => {
   const projectConfig = await findForumProjectConfig();
   if (!projectConfig) {
-    throw new Error("No forum.yaml found.");
+    throw new Error("No .forum/sync.yaml found.");
   }
   renderOutput(`Valid Forum config: ${projectConfig.path}`);
   renderOutput(
@@ -36609,7 +36999,7 @@ var runProjectConfigValidateCommand = async () => {
 var runProjectConfigStandardizeCommand = async () => {
   const projectConfig = await findForumProjectConfig();
   if (!projectConfig) {
-    throw new Error("No forum.yaml found.");
+    throw new Error("No .forum/sync.yaml found.");
   }
   await writeForumProjectConfig(projectConfig.path, {
     defaultStore: projectConfig.defaultStore,
@@ -36625,7 +37015,7 @@ var defaultCloneDirectoryName = (storeId) => {
 var fsErrorCode = (error51) => error51 instanceof Error && "code" in error51 ? String(error51.code ?? "") : "";
 var ensureGitMetadataExists = async (directoryPath) => {
   try {
-    await lstat2(path19.join(directoryPath, ".git"));
+    await lstat2(path21.join(directoryPath, ".git"));
   } catch (error51) {
     if (fsErrorCode(error51) === "ENOENT") {
       throw new Error(
@@ -36663,8 +37053,8 @@ var confirmGitMetadataDeletion = async (localPath, assumeYes) => {
       "Refusing to delete .git without interactive confirmation. Rerun with --yes to confirm in a non-interactive shell."
     );
   }
-  const gitPath = path19.join(localPath, ".git");
-  const gitignorePath = path19.join(localPath, ".gitignore");
+  const gitPath = path21.join(localPath, ".git");
+  const gitignorePath = path21.join(localPath, ".gitignore");
   const confirmationPhrase = "DELETE GIT";
   renderWarning("");
   renderWarning("DANGER: Forum is about to remove Git from this checkout.");
@@ -36706,11 +37096,11 @@ var runGitConvertCommand = async ({
   const { created, metadata, workspaceSlug, storeRef } = await resolveOrCreateConversionStore(storeInput, client);
   if (!workspaceSlug) {
     throw new Error(
-      `Store ${metadata.slug} is missing a workspace slug and cannot be written to forum.yaml.`
+      `Store ${metadata.slug} is missing a workspace slug and cannot be written to .forum/sync.yaml.`
     );
   }
   await writeForumProjectConfig(
-    path19.join(localPath, defaultProjectConfigFilename),
+    path21.join(localPath, defaultProjectConfigFilename),
     {
       syncRules: [
         {
@@ -36725,14 +37115,24 @@ var runGitConvertCommand = async ({
       ]
     }
   );
-  if (ignorePatterns.length > 0) {
-    await client.upsertStoreByRef({
-      ...storeRef,
-      patch: { ignore: ignorePatterns }
-    });
-  }
+  await reconcileSharedIgnoreFile({
+    rootDir: localPath,
+    sharedFilePath: sharedIgnorePath(
+      localPath,
+      `${workspaceSlug}/${metadata.slug}`
+    ),
+    store: `${workspaceSlug}/${metadata.slug}`,
+    remote: metadata.ignore ?? [],
+    publish: async () => {
+    }
+  });
+  await writeSharedIgnoreFile(
+    sharedIgnorePath(localPath, `${workspaceSlug}/${metadata.slug}`),
+    [...metadata.ignore ?? [], ...ignorePatterns]
+  );
   const conversionIgnorePatterns = [...ignorePatterns, ".gitignore"];
   await pushCheckout({
+    ignoreSettings: "preview",
     client,
     dryRun: true,
     force,
@@ -36741,6 +37141,7 @@ var runGitConvertCommand = async ({
     storeRef
   });
   const result = await pushCheckout({
+    ignoreSettings: "preview",
     client,
     force,
     ignorePatterns: conversionIgnorePatterns,
@@ -36761,8 +37162,8 @@ var runGitConvertCommand = async ({
       "Aborted before deleting Git metadata. The Forum push completed, but .git and .gitignore were left in place."
     );
   }
-  await rm4(path19.join(localPath, ".gitignore"), { force: true });
-  await rm4(path19.join(localPath, ".git"), { recursive: true, force: true });
+  await rm5(path21.join(localPath, ".gitignore"), { force: true });
+  await rm5(path21.join(localPath, ".git"), { recursive: true, force: true });
   renderOutput(
     `${created ? "Created" : "Using existing"} store ${metadata.slug}`
   );
@@ -36880,7 +37281,7 @@ var main = async (argv = process.argv.slice(2)) => {
   }
   if (command === "hash" && parsed.local) {
     const filePath = rest[0];
-    renderOutput(await hashLocalFile(path19.resolve(filePath)));
+    renderOutput(await hashLocalFile(path21.resolve(filePath)));
     return;
   }
   const config2 = await resolveConfig(parsed);
@@ -37154,26 +37555,45 @@ var main = async (argv = process.argv.slice(2)) => {
     const subcommand = rest[0];
     const checkout = await resolveCheckoutConfig();
     assertCheckoutSyncEnabled(checkout);
-    const storeRef = await resolveProjectStoreRef();
-    if (!storeRef) {
+    const stores = [...new Set(checkout.syncRules.map((rule2) => rule2.store))];
+    const requested = parsed.storeFilters;
+    const candidates = requested.length ? stores.filter(
+      (store2) => requested.includes(store2) || requested.includes(store2.split("/").at(-1))
+    ) : stores;
+    if (candidates.length !== 1)
       throw new Error(
-        "fm ignore needs a single-store checkout (run it inside a fm clone/init)."
+        "Select one configured store with fm ignore --store workspace/store."
       );
+    const store = candidates[0];
+    const rule = checkout.syncRules.find((entry) => entry.store === store);
+    const sharedFilePath = sharedIgnorePath(checkout.rootDir, store);
+    let currentPatterns = await readSharedIgnoreFile(sharedFilePath);
+    if (currentPatterns === null) {
+      const metadata = await client.readStoreByRef({
+        workspaceSlug: rule.storeOwner,
+        storeSlug: rule.storeSlug
+      });
+      if (!metadata) throw new Error(`Store not found: ${store}`);
+      await reconcileSharedIgnoreFile({
+        rootDir: checkout.rootDir,
+        sharedFilePath,
+        store,
+        remote: metadata.ignore ?? [],
+        publish: async () => {
+        }
+      });
+      currentPatterns = metadata.ignore ?? [];
     }
-    const metadata = await client.readStoreByRef(storeRef);
-    const currentPatterns = metadata?.ignore ?? [];
     await runIgnoreCommand({
-      checkout,
-      client,
+      writePatterns: (patterns) => writeSharedIgnoreFile(sharedFilePath, patterns),
       commandNames,
       confirmYesNo,
-      currentPatterns,
+      currentPatterns: currentPatterns ?? [],
       analyzeLocal: () => analyzeLocalIgnore(checkout),
       markOnboarded: () => markIgnoreOnboarded(checkout.rootDir),
       pattern: rest[1],
       patterns: rest.slice(1),
       renderOutput,
-      storeRef,
       subcommand,
       assumeYes: parsed.yes
     });
@@ -37252,7 +37672,7 @@ var main = async (argv = process.argv.slice(2)) => {
     }
     const checkout = await resolveCheckoutConfig();
     assertCheckoutSyncEnabled(checkout);
-    await runIgnoreSetupGate(checkout, client, parsed.yes);
+    if (!parsed.dryRun) await runIgnoreSetupGate(checkout, client, parsed.yes);
     await runCheckoutPush({
       checkout,
       client,
@@ -37265,12 +37685,41 @@ var main = async (argv = process.argv.slice(2)) => {
     return;
   }
   if (command === "sync") {
+    if (parsed.conflictPolicy && (parsed.force || parsed.readonly)) {
+      throw new Error(
+        "--conflict cannot be combined with --force or --readonly."
+      );
+    }
     if (rest[0] === "reset") {
       const checkout = await resolveCheckoutConfig();
       await resetCheckoutSyncState(checkout.rootDir);
       renderOutput("Cleared local checkout sync state.");
       return;
     }
+    if (parsed.dryRun && parsed.conflictPolicy) {
+      const checkout = await resolveCheckoutConfig();
+      assertCheckoutSyncEnabled(checkout);
+      const result = await syncCheckout({
+        ignoreSettings: "sync",
+        client,
+        conflictPolicy: parsed.conflictPolicy,
+        dryRun: true,
+        force: false,
+        ignorePatterns: checkout.ignore,
+        ignorePatternsByStore: checkout.ignorePatternsByStore,
+        ignoreMatchersByRule: checkout.ignoreMatchersByRule,
+        localPath: checkout.rootDir,
+        storeRef: {},
+        syncRules: checkout.syncRules
+      });
+      if (parsed.json) renderOutput({ type: "checkout-sync-plan", ...result });
+      else
+        formatCheckoutResult("Planned", result, {
+          syncRules: checkout.syncRules,
+          verbose: parsed.verbose
+        });
+      return;
+    }
     if (parsed.dryRun) {
       await withActivity(
         "Checking status",
@@ -37284,6 +37733,7 @@ var main = async (argv = process.argv.slice(2)) => {
     }
     if (parsed.watch) {
       await runCheckoutSyncWatch({
+        conflictPolicy: parsed.conflictPolicy,
         client,
         force: parsed.force,
         intervalMs: config2.pollIntervalMs,
@@ -37311,6 +37761,7 @@ var main = async (argv = process.argv.slice(2)) => {
     }
     await runIgnoreSetupGate(await resolveCheckoutConfig(), client, parsed.yes);
     await runCheckoutSyncOnce({
+      conflictPolicy: parsed.conflictPolicy,
       client,
       force: parsed.force,
       verbose: parsed.verbose,
@@ -37352,8 +37803,8 @@ var main = async (argv = process.argv.slice(2)) => {
         `Usage: ${commandNames} clone <storeId> [localPath] [--readonly]`
       );
     }
-    const localPath = path19.resolve(
-      rest[1] ?? path19.join(process.cwd(), defaultCloneDirectoryName(remoteInput))
+    const localPath = path21.resolve(
+      rest[1] ?? path21.join(process.cwd(), defaultCloneDirectoryName(remoteInput))
     );
     const { metadata, workspaceSlug, storeRef } = await resolveReadableStore(
       remoteInput,
@@ -37371,14 +37822,17 @@ var main = async (argv = process.argv.slice(2)) => {
       verbose: parsed.verbose
     });
     const result = await pullCheckout({
+      ignoreSettings: "preview",
       client,
       ignorePatterns: checkout.ignore,
+      ignorePatternsByStore: checkout.ignorePatternsByStore,
+      ignoreMatchersByRule: checkout.ignoreMatchersByRule,
       localPath: checkout.rootDir,
       progress,
       storeRef,
       syncRules: checkout.syncRules
     });
-    renderOutput(`Cloned store ${metadata.slug} to ${path19.resolve(localPath)}`);
+    renderOutput(`Cloned store ${metadata.slug} to ${path21.resolve(localPath)}`);
     formatCheckoutResult("Pulled", result, {
       detailsRendered: Boolean(progress),
       verbose: parsed.verbose