@narumitw/pi-sync 0.51.1 → 0.52.0

package/dist/chunks/{sync-operations-AR76EB6C.ts → sync-operations-27VQUDH2.ts}

@@ -1,17 +1,25 @@
 // @generated by scripts/build-runtime.mjs; do not edit.
 // @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
-import {
-  formatRemoteSelectionStatus,
-  readRemoteSnapshot,
-  readSnapshotForHead,
-  requireCompatibleRemoteSelection
-} from "./chunk-Q32CQWPM.ts";
 import {
   inspectSync
-} from "./chunk-DM4X4FIA.ts";
+} from "./chunk-7D6RDCVC.ts";
 import {
-  createSyncBackend
-} from "./chunk-HGJH56KR.ts";
+  applySnapshot,
+  countPreservedRemoteFiles,
+  createSyncDecision,
+  formatDiff,
+  formatPullSummary,
+  formatPushSummary,
+  formatRollbackSummary,
+  formatSnapshotOnlyDiff,
+  mergeSync,
+  publicationCapabilityDescription
+} from "./chunk-2GUXI2XT.ts";
+import {
+  readMergeJournal,
+  requireNoMergeJournal,
+  retireMergeJournal
+} from "./chunk-ORQRHEEO.ts";
 import {
   canPullRemoteSessionsOnFirstSync,
   canPullRemoteSettingsOnFirstSync,
@@ -24,436 +32,112 @@ import {
   snapshotHashesMatchState,
   snapshotsMatch,
   syncPolicyChanged
-} from "./chunk-T56RNRZJ.ts";
+} from "./chunk-BDB4IDM3.ts";
 import {
-  applySnapshotTransaction,
-  recoverPendingSnapshotTransactions
-} from "./chunk-4AIHXRKE.ts";
+  formatRemoteSelectionStatus,
+  readRemoteSnapshot,
+  readSnapshotForHead,
+  requireCompatibleRemoteSelection
+} from "./chunk-V6VZ5TLG.ts";
 import {
+  createSyncBackend
+} from "./chunk-QHSQCK7L.ts";
+import "./chunk-ANWNQIR7.ts";
+import {
+  backupLocal,
+  captureMutationOwner,
   inspectLock,
   isLockGuardHeld,
   isStaleLock,
+  protectedSessionPaths,
   withLock
-} from "./chunk-QLSN7AGX.ts";
+} from "./chunk-IJ6VV6FN.ts";
+import {
+  throwIfAborted
+} from "./chunk-PWMWOJP4.ts";
 import {
   setSyncStatus
 } from "./chunk-K3RIEL6J.ts";
 import {
-  throwIfAborted
-} from "./chunk-PWMWOJP4.ts";
+  safeTerminalText
+} from "./chunk-AMJRUXFT.ts";
+import {
+  pruneMergeBaselines
+} from "./chunk-QE7NZZWT.ts";
+import "./chunk-76NB4R7U.ts";
 import {
   readStateForConfig,
   writeStateForConfig
-} from "./chunk-YPXGU5OR.ts";
-import {
-  safeTerminalText
-} from "./chunk-MSSW6F3R.ts";
+} from "./chunk-4QVPTIZB.ts";
+import "./chunk-BVVP33U5.ts";
 import {
   loadConfig,
-  syncConfigReviewIdentity,
+  syncCheckConfigFingerprint,
   syncSessionsWarnings
-} from "./chunk-4MPIH46N.ts";
+} from "./chunk-3B4Z2SKV.ts";
 import "./chunk-2JZFHNLM.ts";
-import {
-  encodeSnapshot
-} from "./chunk-6NT3YFGY.ts";
-import {
-  stateDir
-} from "./chunk-BVVP33U5.ts";
 import "./chunk-T2SJD3N7.ts";
 import {
   expectedRemoteHead
 } from "./chunk-UETBKTDI.ts";
+import "./chunk-ZX2Q6THB.ts";
 import {
-  SyncDecisionRequiredError,
   errorMessage
 } from "./chunk-7D5SF7P3.ts";
+import {
+  overlayLocalFields,
+  portableSnapshot,
+  sameLocalFields,
+  validatePortableSnapshot
+} from "./chunk-A6HU4ERM.ts";
 import {
   createSnapshot,
   filterSnapshotForConfigPolicy,
-  isSessionFilePath,
-  isSessionPath,
+  inspectRemoteSelection,
   mergeRemotePreservedFiles,
   regenerateSnapshotIdentity,
   scanSnapshot,
-  sessionSnapshotPathFromAbsolute,
+  sessionDirForApply,
   snapshotIncludesSessions,
-  snapshotTarget,
+  snapshotOptionsForContext,
   snapshotWithoutSessions
-} from "./chunk-EEJPYTWE.ts";
-import {
-  sessionStorageRoot
-} from "./chunk-SWUXA3MH.ts";
-import {
-  agentDir,
-  sessionDirForApply,
-  sessionDirFromContext,
-  snapshotOptionsForContext
-} from "./chunk-OVDTF5CH.ts";
-import {
-  assertWithinRoot,
-  includeFromSelectionConfig,
-  inspectRemoteSelection,
-  isDeniedPath,
-  isPathInside,
-  parentPaths,
-  safeJoin,
-  toPosix
-} from "./chunk-IVXEDPAD.ts";
-
-// src/sync/sync-mutations.ts
-import fs2 from "node:fs/promises";
-import path2 from "node:path";
+} from "./chunk-QOFMXPM5.ts";
+import "./chunk-ZW5ZLGBI.ts";
+import "./chunk-HUZ5CR4W.ts";
 
-// src/snapshot/snapshot-apply.ts
-import { createHash } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function fileHashMap2(snapshot) {
-  return Object.fromEntries(snapshot.files.map((file) => [file.path, file.sha256]));
-}
-async function applySnapshot(snapshot, protectedRelativePaths = /* @__PURE__ */ new Set(), options = {}) {
-  const root = agentDir();
-  const { sessionDir } = options;
-  await recoverPendingSnapshotTransactions();
-  const current = await createSnapshot(snapshot.profile, {
-    ...options,
-    ...options.include === void 0 ? { syncSessions: snapshotIncludesSessions(snapshot) } : {},
-    sessionDir
-  });
-  const plan = await addTopLevelCaseVariantDeletes(
-    root,
-    protectSnapshotApplyPlan(
-      root,
-      preflightSnapshotApply(root, snapshot, current, { sessionDir }),
-      protectedRelativePaths,
-      sessionDir
-    ),
-    snapshot
-  );
-  await preflightSnapshotMutations(root, plan, sessionDir);
-  await applySnapshotTransaction(plan, { sessionDir });
-  return appliedFileHashMap(snapshot, current, protectedRelativePaths);
-}
-function preflightSnapshotApply(root, snapshot, current, options = {}) {
-  const seenPaths = /* @__PURE__ */ new Set();
-  const remotePaths = /* @__PURE__ */ new Set();
-  const writes = [];
-  const deletes = [];
-  for (const file of snapshot.files) {
-    const normalized = toPosix(file.path);
-    if (!isSafeSnapshotPath(file.path)) {
-      throw new Error(`Unsafe path in snapshot: ${file.path}`);
-    }
-    if (isSessionPath(normalized) && !isSessionFilePath(normalized)) {
-      throw new Error(`Unsafe session path in snapshot: ${file.path}`);
-    }
-    if (seenPaths.has(normalized)) throw new Error(`Duplicate path in snapshot: ${normalized}`);
-    seenPaths.add(normalized);
-    remotePaths.add(normalized);
-    const target = snapshotTarget(root, normalized, options.sessionDir);
-    const content = decodeBase64Strict(file.contentBase64, normalized);
-    if (sha256(content) !== file.sha256) throw new Error(`Checksum mismatch in snapshot file: ${normalized}`);
-    writes.push({ target, content });
-  }
-  const deletePaths = /* @__PURE__ */ new Set();
-  for (const file of current.files) {
-    const normalized = toPosix(file.path);
-    if (!remotePaths.has(normalized)) {
-      deletePaths.add(snapshotTarget(root, normalized, options.sessionDir));
-    }
-    for (const remotePath of parentPaths(normalized)) {
-      if (remotePaths.has(remotePath)) {
-        deletePaths.add(snapshotTarget(root, remotePath, options.sessionDir));
-      }
-    }
-  }
-  deletes.push(...deletePaths);
-  return { writes, deletes };
-}
-function protectSnapshotApplyPlan(root, plan, protectedRelativePaths, sessionDir) {
-  if (protectedRelativePaths.size === 0) return plan;
-  const protectedTargets = new Set(
-    [...protectedRelativePaths].map((relativePath) => snapshotTarget(root, relativePath, sessionDir))
+// src/sync/field-migration.ts
+async function confirmFieldMigration(ctx, config, state, remote, force, signal) {
+  if (remote?.localFields !== void 0 && config.localFields === void 0)
+    throw new Error(
+      "Portable snapshots require settings version 4 and explicit localFields rules on this machine; older policy must not replace local-only values."
+    );
+  const changed = Boolean(state.lastAppliedSnapshot) && !sameLocalFields(state.localFields, config.localFields) || remote !== void 0 && !sameLocalFields(remote.localFields, config.localFields);
+  if (!changed) return true;
+  if (!force)
+    throw new Error(
+      "Local-field policy changed; review an explicit push --force or pull --force migration. Old remote history is not erased."
+    );
+  const validate = captureMutationOwner(ctx, signal);
+  if (!ctx.hasUI) throw new Error("Local-field migration requires observable TUI/RPC confirmation.");
+  validate();
+  const confirmed = await ctx.ui.confirm(
+    "Migrate portable settings policy?",
+    `New machine-local fields: ${(config.localFields ?? []).map(safeTerminalText).join(", ") || "none"}. Additions remove fields from future snapshots, not old history. Removals make local-only values portable again and a pull may replace them. The selected direction is authoritative; inspect /sync diff first. This confirmation is required even with --yes.`,
+    { signal }
   );
-  return {
-    writes: plan.writes.filter((item) => !protectedTargets.has(item.target)),
-    deletes: plan.deletes.filter((target) => !protectedTargets.has(target))
-  };
-}
-async function addTopLevelCaseVariantDeletes(root, plan, snapshot) {
-  const topLevelPaths = /* @__PURE__ */ new Map();
-  for (const file of snapshot.files) {
-    const normalized = toPosix(file.path);
-    if (!normalized.includes("/") && isSafeSnapshotPath(file.path)) {
-      topLevelPaths.set(normalized.toLowerCase(), normalized);
-    }
-  }
-  if (topLevelPaths.size === 0) return plan;
-  let entries;
-  try {
-    entries = await fs.readdir(root, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT") return plan;
-    throw error;
-  }
-  const deletes = new Set(plan.deletes);
-  for (const entry of entries) {
-    const canonicalPath = topLevelPaths.get(entry.name.toLowerCase());
-    if (canonicalPath && entry.name !== canonicalPath && (entry.isFile() || entry.isSymbolicLink())) {
-      deletes.add(safeJoin(root, entry.name));
-    }
-  }
-  return { ...plan, deletes: [...deletes] };
-}
-function appliedFileHashMap(snapshot, current, protectedRelativePaths) {
-  const hashes = fileHashMap2(snapshot);
-  if (protectedRelativePaths.size === 0) return hashes;
-  const currentHashes = fileHashMap2(current);
-  for (const relativePath of protectedRelativePaths) {
-    const normalized = toPosix(relativePath);
-    if (currentHashes[normalized]) {
-      hashes[normalized] = currentHashes[normalized];
-    } else {
-      delete hashes[normalized];
-    }
-  }
-  return hashes;
-}
-function isSafeSnapshotPath(relativePath) {
-  if (relativePath.includes("\\")) return false;
-  const normalized = toPosix(relativePath);
-  return Boolean(normalized) && normalized !== "." && normalized !== ".." && !normalized.startsWith("../") && !path.posix.isAbsolute(normalized) && path.posix.normalize(normalized) === normalized && !isDeniedPath(normalized);
-}
-function decodeBase64Strict(value, filePath) {
-  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 !== 0) {
-    throw new Error(`Invalid base64 content in snapshot file: ${filePath}`);
-  }
-  return Buffer.from(value, "base64");
-}
-async function preflightSnapshotMutations(root, plan, sessionDir) {
-  const deletePaths = new Set(plan.deletes);
-  for (const target of plan.deletes) {
-    await assertNoSymlinkParents(rootForTarget(root, target, sessionDir), target);
-  }
-  for (const item of plan.writes) {
-    await prepareSnapshotWrite(rootForTarget(root, item.target, sessionDir), item.target, deletePaths);
-  }
-}
-function rootForTarget(root, target, sessionDir) {
-  const sessionRoot = sessionDir ? sessionStorageRoot(root, sessionDir) : void 0;
-  if (sessionRoot && isPathInside(sessionRoot, target)) return sessionRoot;
-  return root;
-}
-async function prepareSnapshotWrite(root, target, deletePaths) {
-  const parentWillBeReplaced = await ensureSafeDirectory(root, path.dirname(target), deletePaths);
-  if (parentWillBeReplaced) return;
-  try {
-    const stat = await fs.lstat(target);
-    if (stat.isSymbolicLink()) throw new Error(`Refusing to overwrite symlink during snapshot apply: ${target}`);
-    if (stat.isDirectory() && !deletePaths.has(target)) {
-      throw new Error(`Refusing to overwrite directory during snapshot apply: ${target}`);
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-}
-async function ensureSafeDirectory(root, directory, deletePaths) {
-  assertWithinRoot(root, directory);
-  const rootPath = path.resolve(root);
-  const relative = path.relative(rootPath, path.resolve(directory));
-  let current = rootPath;
-  for (const part of relative.split(path.sep).filter(Boolean)) {
-    current = path.join(current, part);
-    try {
-      const stat = await fs.lstat(current);
-      if (stat.isSymbolicLink()) throw new Error(`Refusing to follow symlink during snapshot apply: ${current}`);
-      if (!stat.isDirectory()) {
-        if (deletePaths.has(current)) return true;
-        throw new Error(`Snapshot path parent is not a directory: ${current}`);
-      }
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-      await fs.mkdir(current);
-    }
-  }
-  return false;
-}
-async function assertNoSymlinkParents(root, target) {
-  assertWithinRoot(root, target);
-  const rootPath = path.resolve(root);
-  const relative = path.relative(rootPath, path.resolve(target));
-  let current = rootPath;
-  const parts = relative.split(path.sep).filter(Boolean);
-  for (const part of parts.slice(0, -1)) {
-    current = path.join(current, part);
-    try {
-      const stat = await fs.lstat(current);
-      if (stat.isSymbolicLink()) throw new Error(`Refusing to follow symlink during snapshot apply: ${current}`);
-      if (!stat.isDirectory()) throw new Error(`Snapshot path parent is not a directory: ${current}`);
-    } catch (error) {
-      if (error.code === "ENOENT") return;
-      throw error;
-    }
-  }
-}
-
-// src/ui/sync-format.ts
-function formatDiff(local, remote) {
-  const localMap = fileHashMap(local);
-  const remoteMap = fileHashMap(remote);
-  const allPaths = [.../* @__PURE__ */ new Set([...Object.keys(localMap), ...Object.keys(remoteMap)])].sort();
-  const lines = [`local: ${local.files.length} files`, `remote: ${remote.id} (${remote.files.length} files)`, ""];
-  let changed = 0;
-  for (const filePath of allPaths) {
-    if (!localMap[filePath]) {
-      lines.push(`Remote only: ${filePath}`);
-      changed += 1;
-    } else if (!remoteMap[filePath]) {
-      lines.push(`Local only: ${filePath}`);
-      changed += 1;
-    } else if (localMap[filePath] !== remoteMap[filePath]) {
-      lines.push(`Different: ${filePath}`);
-      changed += 1;
-    }
-  }
-  if (changed === 0) lines.push("No file differences.");
-  return lines.join("\n");
-}
-function formatSnapshotOnlyDiff(title, snapshot) {
-  return [`${title}: ${snapshot.id}`, ...snapshot.files.map((file) => `Add: ${file.path}`)].join("\n");
-}
-function formatPushSummary(config, destination, upload, head, preservedRemoteFileCount = 0, remote) {
-  return [
-    `Sync setup: ${safeTerminalText(config.setupName)}`,
-    `Storage location: ${safeTerminalText(destination)}`,
-    `Upload ${upload.files.length} files from ${safeTerminalText(agentDir())}.`,
-    `Sessions: ${upload.syncSessions ? "included \u2014 may contain private conversations" : "not included"}`,
-    head ? `Remote latest: ${head.snapshotId}` : "Remote latest: empty",
-    "Publication effect: the backend's active head will reference the new immutable snapshot.",
-    ...remote && inspectRemoteSelection(config.include, remote).kind === "different" ? ["Included-content policy effect: replace the differing remote selection with this setup's local selection."] : [],
-    formatPublicationPreview(remote, upload),
-    preservedRemoteFileCount > 0 ? `Possible secrets in locally managed files were scanned before this prompt; ${preservedRemoteFileCount} preserved remote file(s) were not rescanned.` : "Possible secrets were scanned before this prompt."
-  ].join("\n");
-}
-function formatApplyPreview(local, remote) {
-  return formatDirectionalChanges(local, remote, {
-    add: "Add locally",
-    update: "Update locally",
-    remove: "Remove locally"
-  });
-}
-function formatPullSummary(config, destination, local, remote, protectedSessionCount) {
-  return [
-    `Sync setup: ${safeTerminalText(config.setupName)}`,
-    `Storage location: ${safeTerminalText(destination)}`,
-    `Snapshot: ${safeTerminalText(remote.id)}`,
-    `Sessions: ${remote.syncSessions ? "included \u2014 may contain private conversations" : "not included"}`,
-    `Protected live sessions: ${protectedSessionCount || "none"}`,
-    formatApplyPreview(local, remote),
-    "A local backup is created before these writes/deletes. The remote active snapshot is unchanged."
-  ].join("\n");
-}
-function formatRollbackSummary(config, destination, local, remote, requestedSnapshot, protectedSessionCount) {
-  return [
-    `Sync setup: ${safeTerminalText(config.setupName)}`,
-    `Storage location: ${safeTerminalText(destination)}`,
-    `Snapshot: ${safeTerminalText(requestedSnapshot)}`,
-    `Sessions: ${remote.syncSessions ? "included \u2014 may contain private conversations" : "not included"}`,
-    `Protected live sessions: ${protectedSessionCount || "none"}`,
-    formatApplyPreview(local, remote),
-    "A local backup is created before applying; the backend's active head will change."
-  ].join("\n");
-}
-function formatPublicationPreview(remote, upload) {
-  if (!remote) {
-    return ["Remote is empty.", ...upload.files.map((file) => `Add remotely: ${file.path}`)].join("\n");
-  }
-  return formatDirectionalChanges(remote, upload, {
-    add: "Add remotely",
-    update: "Update remotely",
-    remove: "Remove remotely"
-  });
-}
-function formatDirectionalChanges(before, after, labels) {
-  const beforeMap = fileHashMap(before);
-  const afterMap = fileHashMap(after);
-  const paths = [.../* @__PURE__ */ new Set([...Object.keys(beforeMap), ...Object.keys(afterMap)])].sort();
-  const lines = [];
-  for (const filePath of paths) {
-    if (!beforeMap[filePath]) lines.push(`${labels.add}: ${filePath}`);
-    else if (!afterMap[filePath]) lines.push(`${labels.remove}: ${filePath}`);
-    else if (beforeMap[filePath] !== afterMap[filePath]) lines.push(`${labels.update}: ${filePath}`);
-  }
-  if (lines.length === 0) lines.push("No file changes.");
-  return lines.join("\n");
-}
-function countPreservedRemoteFiles(local, upload) {
-  const localPaths = new Set(local.files.map((file) => file.path));
-  return upload.files.filter((file) => !localPaths.has(file.path)).length;
-}
-function publicationCapabilityDescription(capability) {
-  switch (capability) {
-    case "lease-protected":
-      return "lease-protected (exact expected-ref update)";
-    case "atomic-conditional":
-      return "atomic-conditional (verified atomic precondition)";
-    case "conditional-required":
-      return "conditional-required (read-only until atomic preconditions are verified)";
-    case "read-check-write-verify":
-      return "read-check-write-verify (visible races rejected; simultaneous unseen races remain possible)";
-  }
-}
-
-// src/sync/sync-decision.ts
-function createSyncDecision(options) {
-  const { config, state, local, remote, kind } = options;
-  const policyChanged = Boolean(state.lastAppliedSnapshot) && syncPolicyChanged(state, config);
-  const previousInclude = includeFromSelectionConfig(state);
-  const currentInclude = [...config.include];
-  const causes = {
-    localChanged: options.localChanged,
-    remoteChanged: options.remoteChanged,
-    policyChanged
-  };
-  const causeLines = kind === "first-sync-settings-diverged" ? ["This machine and the remote have different Pi settings on first sync."] : kind === "first-sync-sessions-diverged" ? ["Pi settings match, but local and remote sessions differ on first sync."] : kind === "remote-empty" ? ["The remote storage location is empty."] : [
-    ...causes.localChanged ? ["Local content changed since the last sync."] : [],
-    ...causes.remoteChanged ? ["Remote content changed since the last sync."] : [],
-    ...causes.policyChanged ? ["Included content changed since the last sync."] : []
-  ];
-  const comparison = remote ? formatDiff(local, remote) : formatSnapshotOnlyDiff("Remote is empty. Local push would upload", local);
-  const review = [
-    `Sync setup: ${safeTerminalText(config.setupName)}`,
-    "",
-    "Why a decision is required:",
-    ...causeLines,
-    ...policyChanged ? ["", `Previously included: ${safeList(previousInclude)}`, `Currently included: ${safeList(currentInclude)}`] : [],
-    "",
-    "Observed differences:",
-    ...comparison.split("\n").map(safeTerminalText)
-  ].join("\n");
-  return new SyncDecisionRequiredError({
-    kind,
-    setupName: config.setupName,
-    configIdentity: syncConfigReviewIdentity(config),
-    causes,
-    ...policyChanged ? { previousInclude: [...previousInclude] } : {},
-    currentInclude,
-    review,
-    directions: kind === "remote-empty" ? ["push"] : ["push", "pull"],
-    directMessage: options.directMessage
-  });
-}
-function safeList(values) {
-  return values.length > 0 ? values.map(safeTerminalText).join(", ") : "none";
+  validate();
+  return confirmed;
 }
 
 // src/sync/sync-mutations.ts
 var VERSION = 1;
 var POST_LOCAL_COMMIT_TIMEOUT_MS = 3e4;
+function requireResolvedDirectionalProgress(state, options, allowForce = true) {
+  if (state.unresolved?.length && (options.auto || !options.force || !allowForce))
+    throw new Error(
+      "Unresolved partial conflicts remain. Review /sync conflicts or explicitly choose push --force or pull --force; automatic transfer and rollback cannot accept unresolved groups."
+    );
+}
 var PublicationStatePersistenceError = class extends Error {
   head;
   backupPath;
@@ -478,13 +162,19 @@ var RollbackPublicationError = class extends Error {
   }
 };
 async function push(ctx, options, input, factory = createSyncBackend) {
+  const validateMutation = captureMutationOwner(ctx, options.signal);
+  const validateCommittedOwner = captureMutationOwner(ctx);
   const config = input?.config ?? await loadConfig(options.setup);
   throwIfAborted(options.signal);
+  await requireNoMergeJournal(config, options);
+  const state = input?.state ?? await readStateForConfig(config);
+  validateMutation();
+  requireResolvedDirectionalProgress(state, options);
   setSyncStatus(ctx, `pushing ${config.setupName}`);
   const backend = input?.backend ?? await factory(config);
-  const state = input?.state ?? await readStateForConfig(config);
   throwIfAborted(options.signal);
-  const local = input?.local ?? await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  const localRaw = input?.local ?? await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  const local = portableSnapshot(localRaw, config.localFields);
   throwIfAborted(options.signal);
   let head = await backend.readHead(options.signal);
   let remoteForUpload = await readRemoteSnapshotForUpload(backend, config, head, state, options.signal);
@@ -509,6 +199,13 @@ async function push(ctx, options, input, factory = createSyncBackend) {
       });
     }
   }
+  if (!remoteForUpload && head && config.localFields !== void 0)
+    remoteForUpload = await readSnapshotForHead(backend, head, options.signal);
+  if (!await confirmFieldMigration(ctx, config, state, remoteForUpload, options.force, options.signal)) {
+    setSyncStatus(ctx, void 0);
+    return "cancelled";
+  }
+  const configIdentity = syncCheckConfigFingerprint(config);
   let upload = await snapshotForUpload(backend, config, local, head, remoteForUpload, options.signal);
   if (!config.skipSecretScan) {
     const secrets = scanSnapshot(local);
@@ -524,7 +221,13 @@ ${secrets.map((s) => `- ${s}`).join("\n")}`);
     const refreshedHead = await backend.readHead(options.signal);
     if (!sameRemoteHead(backend, head, refreshedHead)) {
       head = refreshedHead;
-      remoteForUpload = head ? await backend.readSnapshot(head.snapshotRef, options.signal) : void 0;
+      remoteForUpload = head ? await readSnapshotForHead(backend, head, options.signal) : void 0;
+      validateMutation();
+      if (!await confirmFieldMigration(ctx, config, state, remoteForUpload, options.force, options.signal)) {
+        setSyncStatus(ctx, void 0);
+        return "cancelled";
+      }
+      validateMutation();
       upload = await snapshotForUpload(backend, config, local, head, remoteForUpload, options.signal);
       if (!await confirmPush(
         ctx,
@@ -541,22 +244,42 @@ ${secrets.map((s) => `- ${s}`).join("\n")}`);
       }
     }
   }
+  validateMutation();
+  if (configIdentity !== syncCheckConfigFingerprint(await loadConfig(options.setup)))
+    throw new Error("Settings changed during push review.");
+  validateMutation();
+  if (config.localFields !== void 0 || await readMergeJournal(config)) {
+    const current = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+    if (!sameHashes(fileHashMap(current), fileHashMap(localRaw)))
+      throw new Error("Local content changed during recovery review; retry from current bytes.");
+  }
+  requireResolvedDirectionalProgress(await readStateForConfig(config), options);
+  validateMutation();
   const result = await backend.publishSnapshot(upload, expectedRemoteHead(head), {
     signal: options.signal,
     onCommit: options.onCommit
   });
   try {
-    await writeStateForConfig(config, {
-      version: VERSION,
-      profile: config.snapshotIdentity,
-      lastAppliedSnapshot: result.head.snapshotId,
-      lastRemoteRevision: result.head.revision,
-      lastFileHashes: fileHashMap(local),
-      include: [...config.include]
-    });
+    await writeStateForConfig(
+      config,
+      {
+        version: VERSION,
+        profile: config.snapshotIdentity,
+        lastAppliedSnapshot: result.head.snapshotId,
+        lastRemoteRevision: result.head.revision,
+        lastFileHashes: fileHashMap(local),
+        include: [...config.include],
+        ...config.localFields !== void 0 ? { localFields: config.localFields } : {}
+      },
+      local,
+      validateCommittedOwner
+    );
   } catch (error) {
     throw new PublicationStatePersistenceError(result.head, error);
   }
+  await retireMergeJournal(config);
+  await pruneMergeBaselines(config, await readStateForConfig(config), validateCommittedOwner);
+  validateCommittedOwner();
   if (options.signal?.aborted) return;
   setSyncStatus(ctx, void 0);
   if (!options.silent) {
@@ -571,12 +294,16 @@ ${secrets.map((s) => `- ${s}`).join("\n")}`);
   return "applied";
 }
 async function pull(ctx, options, factory = createSyncBackend) {
+  const validateMutation = captureMutationOwner(ctx, options.signal);
+  const validateCommittedOwner = captureMutationOwner(ctx);
   const config = await loadConfig(options.setup);
   throwIfAborted(options.signal);
+  await requireNoMergeJournal(config, options);
   setSyncStatus(ctx, `pulling ${config.setupName}`);
   const backend = await factory(config);
   const state = await readStateForConfig(config);
-  throwIfAborted(options.signal);
+  validateMutation();
+  requireResolvedDirectionalProgress(state, options);
   const local = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
   throwIfAborted(options.signal);
   const { head, snapshot: remote } = await readRemoteSnapshot(backend, config, options.signal);
@@ -593,6 +320,19 @@ async function pull(ctx, options, factory = createSyncBackend) {
       directMessage: "Remote is empty. Run /sync push from a configured machine first."
     });
   }
+  if (!sameLocalFields(config.localFields, remote.localFields)) {
+    setSyncStatus(ctx, void 0);
+    throw new Error(
+      "Pull requires the configured local-field policy to match the remote. To change the remote policy, review push --force from the authoritative machine first, then pull using matching rules; old history is not erased."
+    );
+  }
+  if (!await confirmFieldMigration(ctx, config, state, remote, options.force, options.signal)) {
+    setSyncStatus(ctx, void 0);
+    return "cancelled";
+  }
+  const configIdentity = syncCheckConfigFingerprint(config);
+  const logical = portableSnapshot(remote, config.localFields);
+  const physical = overlayLocalFields(logical, local, config.localFields);
   const remoteChanged = hasRemoteChanges(remote, state, config, protectedSessionPaths(ctx));
   if (localChanged && remoteChanged && state.lastAppliedSnapshot && !options.force) {
     throw createSyncDecision({
@@ -608,29 +348,65 @@ async function pull(ctx, options, factory = createSyncBackend) {
   }
   if (!options.yes && !await ctx.ui.confirm(
     snapshotIncludesSessions(remote) ? "Pull pi settings and sessions?" : "Pull pi settings?",
-    formatPullSummary(config, backend.destination, local, remote, protectedSessionPaths(ctx).size)
+    formatPullSummary(config, backend.destination, local, physical, protectedSessionPaths(ctx).size)
   )) {
     setSyncStatus(ctx, void 0);
     ctx.ui.notify("Pull cancelled.", "info");
     return "cancelled";
   }
   throwIfAborted(options.signal);
+  const recoveringMerge = Boolean(await readMergeJournal(config));
+  const requireFreshRecovery = async () => {
+    validateMutation();
+    const currentHead = await backend.readHead(options.signal);
+    validateMutation();
+    const current = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+    validateMutation();
+    if (!sameHashes(fileHashMap(current), fileHashMap(local)) || !sameRemoteHead(backend, head, currentHead)) {
+      throw new Error("Local or remote content changed during recovery review; retry from a fresh diff.");
+    }
+  };
+  if (recoveringMerge) await requireFreshRecovery();
+  if (configIdentity !== syncCheckConfigFingerprint(await loadConfig(options.setup)))
+    throw new Error("Settings changed during pull review.");
+  validateMutation();
+  const refreshed = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  if (!sameHashes(fileHashMap(local), fileHashMap(refreshed)))
+    throw new Error("Local bytes changed during pull review.");
+  if (!sameRemoteHead(backend, head, await backend.readHead(options.signal)))
+    throw new Error("Remote changed during pull review.");
+  validateMutation();
   const backup = await backupLocal(config.snapshotIdentity, snapshotOptionsForContext(ctx, config), options.signal);
-  const applySessionDir = await sessionDirForApply(ctx, remote);
-  throwIfAborted(options.signal);
+  const applySessionDir = await sessionDirForApply(ctx, physical);
+  if (recoveringMerge) await requireFreshRecovery();
+  requireResolvedDirectionalProgress(await readStateForConfig(config), options);
+  validateMutation();
   options.onCommit?.();
-  const lastFileHashes = await applySnapshot(remote, protectedSessionPaths(ctx), {
+  const lastFileHashes = await applySnapshot(physical, protectedSessionPaths(ctx), {
     include: config.include,
-    sessionDir: applySessionDir
-  });
-  await writeStateForConfig(config, {
-    version: VERSION,
-    profile: config.snapshotIdentity,
-    lastAppliedSnapshot: remote.id,
-    lastRemoteRevision: head?.revision,
-    lastFileHashes,
-    include: [...config.include]
+    sessionDir: applySessionDir,
+    signal: options.signal,
+    validateMutation,
+    expectedFileHashes: config.localFields?.length ? { "settings.json": fileHashMap(local)["settings.json"] ?? null } : void 0
   });
+  validateCommittedOwner();
+  await writeStateForConfig(
+    config,
+    {
+      version: VERSION,
+      profile: config.snapshotIdentity,
+      lastAppliedSnapshot: remote.id,
+      lastRemoteRevision: head?.revision,
+      lastFileHashes: config.localFields?.length ? { ...lastFileHashes, "settings.json": fileHashMap(logical)["settings.json"] } : lastFileHashes,
+      include: [...config.include],
+      ...config.localFields !== void 0 ? { localFields: config.localFields } : {}
+    },
+    logical,
+    validateCommittedOwner
+  );
+  await retireMergeJournal(config);
+  await pruneMergeBaselines(config, await readStateForConfig(config), validateCommittedOwner);
+  validateCommittedOwner();
   if (options.signal?.aborted) return "applied";
   setSyncStatus(ctx, void 0);
   if (!options.silent) {
@@ -641,15 +417,20 @@ async function pull(ctx, options, factory = createSyncBackend) {
       "warning"
     );
   }
-  if (options.reload) await maybeReload(ctx, options.signal);
+  if (options.reload) await maybeReload(ctx, options.signal, validateMutation);
   return "applied";
 }
 async function syncBoth(ctx, options, factory = createSyncBackend) {
+  const validateMutation = captureMutationOwner(ctx, options.signal);
   const config = await loadConfig(options.setup);
   throwIfAborted(options.signal);
-  const backend = await factory(config);
+  if (config.include.length > 0 && options.auto && config.automaticTransfer) return mergeSync(ctx, options, factory);
+  if (!options.auto && config.include.length > 0 && await readMergeJournal(config))
+    return mergeSync(ctx, options, factory);
   const state = await readStateForConfig(config);
   throwIfAborted(options.signal);
+  if (!options.auto && config.include.length > 0 && state.lastAppliedSnapshot) return mergeSync(ctx, options, factory);
+  const backend = await factory(config);
   const local = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
   throwIfAborted(options.signal);
   if (config.include.length === 0) {
@@ -666,8 +447,34 @@ async function syncBoth(ctx, options, factory = createSyncBackend) {
   const localChanged = hasLocalChanges(local, state, config);
   const remoteChanged = remote ? hasRemoteChanges(remote, state, config, protectedSessionPaths(ctx)) : false;
   const firstSync = !state.lastAppliedSnapshot;
+  if (options.auto) throw new Error("Automatic transfer is not authorized by the current settings.");
+  const portableLocal = portableSnapshot(local, config.localFields);
+  const acceptMatchingState = async (snapshot) => {
+    requireCompatibleRemoteSelection(config, snapshot);
+    const accepted = portableSnapshot(snapshot, config.localFields);
+    if (state.lastAppliedSnapshot && !sameLocalFields(state.localFields, config.localFields))
+      throw new Error("Local-field rules changed; review and confirm a directional migration first.");
+    await writeStateForConfig(
+      config,
+      {
+        version: VERSION,
+        profile: config.snapshotIdentity,
+        lastAppliedSnapshot: snapshot.id,
+        lastRemoteRevision: head?.revision,
+        lastFileHashes: fileHashMap(accepted),
+        include: [...config.include],
+        ...config.localFields !== void 0 ? { localFields: config.localFields } : {}
+      },
+      accepted,
+      validateMutation
+    );
+    await pruneMergeBaselines(config, await readStateForConfig(config), validateMutation);
+    validateMutation();
+  };
   if (firstSync && remote && remote.files.length > 0 && local.files.length > 0) {
-    if (!canPullRemoteSettingsOnFirstSync(local, remote)) {
+    requireCompatibleRemoteSelection(config, remote);
+    const portableRemote = portableSnapshot(remote, config.localFields);
+    if (!canPullRemoteSettingsOnFirstSync(portableLocal, portableRemote)) {
       throw createSyncDecision({
         kind: "first-sync-settings-diverged",
         config,
@@ -679,8 +486,8 @@ async function syncBoth(ctx, options, factory = createSyncBackend) {
         directMessage: "Remote settings exist and this machine has different local Pi settings. Run /sync diff, then manually choose /sync pull or /sync push."
       });
     }
-    if (!sameHashes(fileHashMap(local), fileHashMap(remote))) {
-      if (!canPullRemoteSessionsOnFirstSync(local, remote)) {
+    if (!sameHashes(fileHashMap(portableLocal), fileHashMap(portableRemote))) {
+      if (!canPullRemoteSessionsOnFirstSync(portableLocal, portableRemote)) {
         throw createSyncDecision({
           kind: "first-sync-sessions-diverged",
           config,
@@ -695,26 +502,13 @@ async function syncBoth(ctx, options, factory = createSyncBackend) {
       await pull(ctx, options, factory);
       return;
     }
-    await writeStateForConfig(config, {
-      version: VERSION,
-      profile: config.snapshotIdentity,
-      lastAppliedSnapshot: remote.id,
-      lastRemoteRevision: head?.revision,
-      lastFileHashes: fileHashMap(remote),
-      include: [...config.include]
-    });
+    await acceptMatchingState(remote);
     if (!options.silent) ctx.ui.notify("pi-sync state initialized; local settings already match remote.", "info");
     return;
   }
-  if (localChanged && remoteChanged && remote && snapshotsMatch(local, remote)) {
-    await writeStateForConfig(config, {
-      version: VERSION,
-      profile: config.snapshotIdentity,
-      lastAppliedSnapshot: remote.id,
-      lastRemoteRevision: head?.revision,
-      lastFileHashes: fileHashMap(remote),
-      include: [...config.include]
-    });
+  if (localChanged && remoteChanged && remote && snapshotsMatch(portableLocal, portableSnapshot(remote, remote.localFields))) {
+    requireCompatibleRemoteSelection(config, remote);
+    await acceptMatchingState(remote);
     if (!options.silent) ctx.ui.notify("pi-sync is already up to date.", "info");
     return;
   }
@@ -739,18 +533,13 @@ async function syncBoth(ctx, options, factory = createSyncBackend) {
     return;
   }
   if (shouldRefreshSyncedState(remote, head, state, config, (left, right) => backend.sameRevision(left, right))) {
-    await writeStateForConfig(config, {
-      version: VERSION,
-      profile: config.snapshotIdentity,
-      lastAppliedSnapshot: remote.id,
-      lastRemoteRevision: head?.revision,
-      lastFileHashes: fileHashMap(remote),
-      include: [...config.include]
-    });
+    await acceptMatchingState(remote);
   }
   if (!options.silent) ctx.ui.notify("pi-sync is already up to date.", "info");
 }
 async function rollback(ctx, options, factory = createSyncBackend, expectedSelection) {
+  const validateMutation = captureMutationOwner(ctx, options.signal);
+  const validateCommittedOwner = captureMutationOwner(ctx);
   const target = options.args[0];
   if (!target) throw new Error("Usage: /sync rollback <snapshot-id> [--yes]");
   const config = await loadConfig(options.setup);
@@ -759,37 +548,63 @@ async function rollback(ctx, options, factory = createSyncBackend, expectedSelec
   if (expectedSelection && (backend.identity !== expectedSelection.backendIdentity || config.setupName !== expectedSelection.setup)) {
     throw new Error("Sync setup or storage location changed while history was open; reopen history and retry.");
   }
+  await requireNoMergeJournal(config);
+  const state = await readStateForConfig(config);
+  validateMutation();
+  requireResolvedDirectionalProgress(state, options, false);
   const decoded = await backend.readSnapshot(target, options.signal);
+  validatePortableSnapshot(decoded);
+  if (!sameLocalFields(decoded.localFields, config.localFields))
+    throw new Error(
+      "Rollback requires the historical snapshot local-field policy to match the configured rules. Review push --force from current local bytes to migrate policy first; choose matching history afterward."
+    );
   const selected = filterSnapshotForConfigPolicy(
     config.include.includes("sessions") ? decoded : snapshotWithoutSessions(decoded),
     config
   );
-  const remote = regenerateSnapshotIdentity(selected);
+  const remote = portableSnapshot(regenerateSnapshotIdentity(selected), config.localFields);
   const local = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
   const expectedHead = await backend.readHead(options.signal);
-  throwIfAborted(options.signal);
+  const currentRemote = expectedHead ? await readSnapshotForHead(backend, expectedHead, options.signal) : void 0;
+  validateMutation();
+  if (!await confirmFieldMigration(ctx, config, state, currentRemote, true, options.signal)) return;
+  validateMutation();
+  const physical = overlayLocalFields(remote, local, config.localFields);
   if (!options.yes && !await ctx.ui.confirm(
     snapshotIncludesSessions(remote) ? "Rollback pi settings and sessions?" : "Rollback pi settings?",
-    formatRollbackSummary(config, backend.destination, local, remote, target, protectedSessionPaths(ctx).size)
+    formatRollbackSummary(config, backend.destination, local, physical, target, protectedSessionPaths(ctx).size)
   )) {
     ctx.ui.notify("Rollback cancelled.", "info");
     return;
   }
+  validateMutation();
+  const currentLocal = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  if (!sameHashes(fileHashMap(currentLocal), fileHashMap(local)))
+    throw new Error("Local bytes changed during rollback review.");
+  if (syncCheckConfigFingerprint(config) !== syncCheckConfigFingerprint(await loadConfig(options.setup)))
+    throw new Error("Settings changed during rollback review.");
+  if (!sameRemoteHead(backend, expectedHead, await backend.readHead(options.signal)))
+    throw new Error("Remote changed during rollback review.");
+  validateMutation();
   throwIfAborted(options.signal);
   const backup = await backupLocal(config.snapshotIdentity, snapshotOptionsForContext(ctx, config), options.signal);
   const applySessionDir = await sessionDirForApply(ctx, remote);
-  throwIfAborted(options.signal);
+  requireResolvedDirectionalProgress(await readStateForConfig(config), options, false);
+  validateMutation();
   options.onCommit?.();
-  const lastFileHashes = await applySnapshot(remote, protectedSessionPaths(ctx), {
+  const lastFileHashes = await applySnapshot(physical, protectedSessionPaths(ctx), {
     include: config.include,
-    sessionDir: applySessionDir
+    sessionDir: applySessionDir,
+    signal: options.signal,
+    validateMutation,
+    expectedFileHashes: config.localFields?.length ? { "settings.json": fileHashMap(local)["settings.json"] ?? null } : void 0
   });
+  validateCommittedOwner();
   let result;
   try {
     const completionSignal = AbortSignal.timeout(POST_LOCAL_COMMIT_TIMEOUT_MS);
-    const upload = await snapshotForUpload(backend, config, remote, expectedHead, void 0, completionSignal, {
-      ignoreUnreadableRemote: true
-    });
+    const upload = await snapshotForUpload(backend, config, remote, expectedHead, currentRemote, completionSignal);
+    validateCommittedOwner();
     result = await backend.publishSnapshot(upload, expectedRemoteHead(expectedHead), {
       signal: completionSignal
     });
@@ -797,17 +612,26 @@ async function rollback(ctx, options, factory = createSyncBackend, expectedSelec
     throw new RollbackPublicationError(backup, error);
   }
   try {
-    await writeStateForConfig(config, {
-      version: VERSION,
-      profile: config.snapshotIdentity,
-      lastAppliedSnapshot: result.head.snapshotId,
-      lastRemoteRevision: result.head.revision,
-      lastFileHashes,
-      include: [...config.include]
-    });
+    await writeStateForConfig(
+      config,
+      {
+        version: VERSION,
+        profile: config.snapshotIdentity,
+        lastAppliedSnapshot: result.head.snapshotId,
+        lastRemoteRevision: result.head.revision,
+        lastFileHashes: config.localFields?.length ? { ...lastFileHashes, "settings.json": fileHashMap(remote)["settings.json"] } : lastFileHashes,
+        include: [...config.include],
+        ...config.localFields !== void 0 ? { localFields: config.localFields } : {}
+      },
+      remote,
+      validateCommittedOwner
+    );
   } catch (error) {
     throw new PublicationStatePersistenceError(result.head, error, backup);
   }
+  await retireMergeJournal(config);
+  await pruneMergeBaselines(config, await readStateForConfig(config), validateCommittedOwner);
+  validateCommittedOwner();
   if (options.signal?.aborted) return;
   ctx.ui.notify(
     [
@@ -816,22 +640,17 @@ async function rollback(ctx, options, factory = createSyncBackend, expectedSelec
     ].filter(Boolean).join("\n"),
     result.warnings.length > 0 ? "warning" : "info"
   );
-  await maybeReload(ctx, options.signal);
-}
-function protectedSessionPaths(ctx) {
-  const getSessionFile = ctx.sessionManager.getSessionFile;
-  if (typeof getSessionFile !== "function") return /* @__PURE__ */ new Set();
-  const sessionFile = getSessionFile.call(ctx.sessionManager);
-  const snapshotPath = sessionFile ? sessionSnapshotPathFromAbsolute(sessionFile, sessionDirFromContext(ctx)) : void 0;
-  return snapshotPath ? /* @__PURE__ */ new Set([snapshotPath]) : /* @__PURE__ */ new Set();
+  await maybeReload(ctx, options.signal, validateMutation);
 }
-async function maybeReload(ctx, signal) {
+async function maybeReload(ctx, signal, validateMutation = captureMutationOwner(ctx, signal)) {
   if (signal?.aborted || !("reload" in ctx)) return;
+  validateMutation();
   if (ctx.hasUI && await ctx.ui.confirm(
     "Reload Pi resources now?",
     "This reloads extensions, skills, prompts, themes, and context files."
   )) {
     if (signal?.aborted) return;
+    validateMutation();
     await ctx.reload();
   }
 }
@@ -839,19 +658,11 @@ async function readRemoteSnapshotForUpload(backend, config, head, state, signal)
   if (!head || head.snapshotId === state.lastAppliedSnapshot && !syncPolicyChanged(state, config) && (!state.lastRemoteRevision || backend.sameRevision(head.revision, state.lastRemoteRevision))) {
     return void 0;
   }
-  return backend.readSnapshot(head.snapshotRef, signal);
+  return readSnapshotForHead(backend, head, signal);
 }
-async function snapshotForUpload(backend, config, local, head, remote, signal, options = {}) {
+async function snapshotForUpload(backend, config, local, head, remote, signal) {
   if (!head) return local;
-  let snapshot = remote;
-  if (!snapshot) {
-    try {
-      snapshot = await backend.readSnapshot(head.snapshotRef, signal);
-    } catch (error) {
-      if (options.ignoreUnreadableRemote) return local;
-      throw error;
-    }
-  }
+  const snapshot = remote ?? await readSnapshotForHead(backend, head, signal);
   return mergeRemotePreservedFiles(local, snapshot, config);
 }
 async function confirmPush(ctx, options, config, backend, local, upload, head, remote, title = snapshotIncludesSessions(upload) ? "Push pi settings and sessions?" : "Push pi settings?") {
@@ -871,19 +682,6 @@ function sameRemoteHead(backend, left, right) {
   if (!left || !right) return left === right;
   return backend.sameRevision(left.revision, right.revision);
 }
-async function backupLocal(profile, options = {}, signal) {
-  throwIfAborted(signal);
-  const snapshot = await createSnapshot(profile, options);
-  throwIfAborted(signal);
-  const backupDirectory = path2.join(stateDir(), "backups");
-  await fs2.mkdir(backupDirectory, { recursive: true });
-  throwIfAborted(signal);
-  const backupPath = path2.join(backupDirectory, `${snapshot.id}.json.gz`);
-  const encoded = await encodeSnapshot(snapshot);
-  throwIfAborted(signal);
-  await fs2.writeFile(backupPath, encoded, { signal });
-  return backupPath;
-}
 
 // src/sync/sync-queries.ts
 var DEFAULT_PROFILE = "default";
@@ -924,7 +722,10 @@ async function diff(ctx, options, factory = createSyncBackend) {
   throwIfAborted(options.signal);
   setSyncStatus(ctx, `checking ${config.setupName}`);
   const backend = await factory(config);
-  const local = await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config));
+  const local = portableSnapshot(
+    await createSnapshot(config.snapshotIdentity, snapshotOptionsForContext(ctx, config)),
+    config.localFields
+  );
   throwIfAborted(options.signal);
   const { snapshot: remote, selectionState } = await readRemoteSnapshot(backend, config, options.signal, {
     allowSelectionDifference: true
@@ -950,7 +751,7 @@ ${formatSnapshotOnlyDiff("Remote is empty. Local push would upload", local)}`, l
   }
   ctx.ui.notify(`${header}
 
-${formatDiff(local, remote)}`, level);
+${formatDiff(local, portableSnapshot(remote, remote.localFields))}`, level);
 }
 async function doctor(ctx, options, factory = createSyncBackend) {
   const messages = [];
@@ -1075,4 +876,4 @@ export {
   status,
   syncBoth
 };
-//# sourceMappingURL=sync-operations-AR76EB6C.ts.map
+//# sourceMappingURL=sync-operations-27VQUDH2.ts.map