@narumitw/pi-sync 0.51.1 → 0.52.0

package/dist/chunks/chunk-2GUXI2XT.ts

@@ -0,0 +1,1702 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  clearMergeJournal,
+  conflictArtifactFingerprint,
+  conflictDirectory,
+  conflictGroups,
+  mergeJournalIdentity,
+  readConflictArtifact,
+  readMergeJournal,
+  saveConflictArtifact,
+  writeMergeJournal
+} from "./chunk-ORQRHEEO.ts";
+import {
+  fileHashMap,
+  hasLocalChanges,
+  hasRemoteChanges,
+  sameHashes,
+  syncPolicyChanged
+} from "./chunk-BDB4IDM3.ts";
+import {
+  formatRemoteSelectionStatus,
+  readSnapshotForHead,
+  requireCompatibleRemoteSelection
+} from "./chunk-V6VZ5TLG.ts";
+import {
+  createSyncBackend
+} from "./chunk-QHSQCK7L.ts";
+import {
+  applySnapshotTransaction,
+  recoverPendingSnapshotTransactions,
+  syncMutationParents
+} from "./chunk-ANWNQIR7.ts";
+import {
+  backupLocal,
+  captureMutationOwner,
+  protectedSessionPaths
+} from "./chunk-IJ6VV6FN.ts";
+import {
+  safeTerminalText,
+  snapshotPathLabel
+} from "./chunk-AMJRUXFT.ts";
+import {
+  TEXT_MERGE_WORK_LIMIT,
+  isMergeTextPath,
+  mergeSession,
+  mergeText,
+  pruneMergeBaselines,
+  readMergeAncestor,
+  readMergeAncestors,
+  stageMergeBaseline
+} from "./chunk-QE7NZZWT.ts";
+import {
+  mergePathIdentity,
+  planFileMerge
+} from "./chunk-76NB4R7U.ts";
+import {
+  readStateForConfig,
+  statePathForConfig,
+  syncStateFingerprint,
+  writeStateForConfig
+} from "./chunk-4QVPTIZB.ts";
+import {
+  loadConfig,
+  syncCheckConfigFingerprint,
+  syncConfigReviewIdentity
+} from "./chunk-3B4Z2SKV.ts";
+import {
+  SyncBackendConflictError,
+  expectedRemoteHead
+} from "./chunk-UETBKTDI.ts";
+import {
+  SyncDecisionRequiredError
+} from "./chunk-7D5SF7P3.ts";
+import {
+  overlayLocalFields,
+  portableSnapshot,
+  sameLocalFields
+} from "./chunk-A6HU4ERM.ts";
+import {
+  agentDir,
+  createSnapshot,
+  effectiveSessionRoot,
+  filterSnapshotForConfigPolicy,
+  includeFromSelectionConfig,
+  inspectRemoteSelection,
+  isSessionFilePath,
+  isSessionPath,
+  mergeRemotePreservedFiles,
+  regenerateSnapshotIdentity,
+  requireStableMergeSessionRoot,
+  scanSnapshot,
+  sessionStorageRoot,
+  snapshotIncludesSessions,
+  snapshotOptionsForContext,
+  snapshotTarget
+} from "./chunk-QOFMXPM5.ts";
+import {
+  jsonEqual,
+  parseSettingsDocument,
+  renderSettingsMembers
+} from "./chunk-ZW5ZLGBI.ts";
+import {
+  assertWithinRoot,
+  isDeniedPath,
+  isPathInside,
+  parentPaths,
+  safeJoin,
+  syncDirectory,
+  toPosix
+} from "./chunk-HUZ5CR4W.ts";
+
+// src/ui/merge-review.ts
+import { runDocumentReview } from "@narumitw/pi-tui-kit";
+async function confirmMergeReview(ctx, title, content, signal, isCurrent, confirmationLabel = "Apply merged transfer") {
+  const result = await runDocumentReview(ctx, {
+    title,
+    content,
+    format: { kind: "text" },
+    viewportSize: "adaptive",
+    confirmation: { label: confirmationLabel },
+    hint: "close",
+    signal,
+    isCurrent,
+    onError: () => {
+    }
+  });
+  if (result.kind === "error") throw new Error("Merge review failed; no transfer was performed.");
+  if (result.kind === "unsupported")
+    throw new Error("Merge review requires observable TUI or RPC; review the plan before using --yes.");
+  return result.kind === "confirmed";
+}
+
+// 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 (!Object.hasOwn(localMap, filePath)) {
+      lines.push(`Remote only: ${snapshotPathLabel(filePath)}`);
+      changed += 1;
+    } else if (!Object.hasOwn(remoteMap, filePath)) {
+      lines.push(`Local only: ${snapshotPathLabel(filePath)}`);
+      changed += 1;
+    } else if (localMap[filePath] !== remoteMap[filePath]) {
+      lines.push(`Different: ${snapshotPathLabel(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: ${snapshotPathLabel(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: ${snapshotPathLabel(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 (!Object.hasOwn(beforeMap, filePath)) lines.push(`${labels.add}: ${snapshotPathLabel(filePath)}`);
+    else if (!Object.hasOwn(afterMap, filePath)) lines.push(`${labels.remove}: ${snapshotPathLabel(filePath)}`);
+    else if (beforeMap[filePath] !== afterMap[filePath]) lines.push(`${labels.update}: ${snapshotPathLabel(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/conflict-artifact-ownership.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+async function releaseConflictArtifacts(config, statePath, created) {
+  if (!created.length || statePathForConfig(config) !== statePath) return;
+  try {
+    const state = await readStateForConfig(config);
+    if (statePathForConfig(config) !== statePath) return;
+    const journal = await readMergeJournal(config);
+    if (statePathForConfig(config) !== statePath) return;
+    const referenced = /* @__PURE__ */ new Set([
+      ...(state.unresolved ?? []).map((group) => group.artifact),
+      ...(journal?.progress?.groups ?? []).map((group) => group.artifact)
+    ]);
+    for (const lease of created) {
+      if (referenced.has(lease.token) || lease.target !== path.join(conflictDirectory(config), `${lease.token}.json`))
+        continue;
+      try {
+        const stat = await fs.lstat(lease.target);
+        if (!stat.isFile() || stat.nlink !== 1 || stat.dev !== lease.dev || stat.ino !== lease.ino || stat.size !== lease.size)
+          continue;
+        const artifact = JSON.parse(await fs.readFile(lease.target, "utf8"));
+        if (conflictArtifactFingerprint(artifact) !== lease.fingerprint || statePathForConfig(config) !== statePath)
+          continue;
+        const latest = await fs.lstat(lease.target);
+        if (latest.dev !== lease.dev || latest.ino !== lease.ino || latest.nlink !== 1 || statePathForConfig(config) !== statePath)
+          continue;
+        await fs.unlink(lease.target);
+        await syncDirectory(path.dirname(lease.target));
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+
+// src/sync/conflict-resolution.ts
+async function resolveReviewedGroup(config, backend, state, local, remote, head, plan, resolution, protectedPaths) {
+  const artifact = await readConflictArtifact(config, backend.identity, resolution.token);
+  const group = artifact.groups[resolution.group];
+  if (conflictArtifactFingerprint(artifact) !== resolution.artifactIdentity || !group || plan.kind !== "planned" || !state.unresolved?.some(
+    (item) => item.artifact === resolution.token && JSON.stringify(item.paths) === JSON.stringify(group.paths)
+  ) || syncStateFingerprint(state) !== resolution.stateIdentity || state.lastObservedSnapshot !== head.snapshotId || !state.lastObservedRevision || !backend.sameRevision(state.lastObservedRevision, head.revision))
+    throw new Error("Conflict review is stale; refresh sync and review again.");
+  const ours = fileHashMap(local);
+  const theirs = fileHashMap(remote);
+  const oldOurs = fileHashMap(artifact.local);
+  const oldTheirs = fileHashMap(artifact.remote);
+  if (group.paths.some(
+    (filePath) => ours[filePath] !== oldOurs[filePath] || theirs[filePath] !== oldTheirs[filePath] || state.lastFileHashes[filePath] !== artifact.state.lastFileHashes[filePath]
+  ))
+    throw new Error("Conflict versions changed; no resolution was applied.");
+  if (group.paths.some(
+    (filePath) => [...protectedPaths].some((value) => mergePathIdentity(value) === mergePathIdentity(filePath))
+  ))
+    throw new Error(
+      "Current session conflict cannot be resolved from the loaded session; preserve evidence and close Pi."
+    );
+  const selected = resolution.source === "local" ? local : remote;
+  const paths = new Set(group.paths);
+  for (const snapshot of [selected, local]) {
+    const layout = planFileMerge({
+      baseline: {},
+      local: snapshot.files.filter((file) => paths.has(file.path)),
+      remote: [],
+      selectionCompatible: true
+    });
+    if (layout.kind !== "planned" || layout.conflicts.length)
+      throw new Error(
+        "Selected/current local group still has path collisions; preserve evidence, repair the layout manually and refresh sync."
+      );
+  }
+  const selectedFiles = new Map(selected.files.map((file) => [file.path, file]));
+  const decisions = plan.decisions.map(
+    (item) => paths.has(item.path) ? {
+      kind: "accepted",
+      path: item.path,
+      source: resolution.source,
+      file: selectedFiles.get(item.path)
+    } : item
+  );
+  return {
+    kind: "planned",
+    decisions,
+    conflicts: decisions.filter((item) => item.kind === "conflict")
+  };
+}
+
+// src/sync/conflict-retention.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+async function pruneCompletedConflicts(config, backend, state, local, remote, validate) {
+  validate();
+  const directory = conflictDirectory(config);
+  let names;
+  try {
+    const stat = await fs2.lstat(directory);
+    validate();
+    if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error("Unsafe conflict retention directory.");
+    names = await fs2.readdir(directory);
+    validate();
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  const pinned = new Set(state.unresolved?.map((group) => group.artifact) ?? []);
+  const ours = fileHashMap(local);
+  const theirs = fileHashMap(remote);
+  const completed = [];
+  for (const name of names) {
+    validate();
+    const token = name.replace(/\.json$/u, "");
+    if (!/^[a-f0-9-]{36}\.json$/u.test(name) || pinned.has(token)) continue;
+    try {
+      const artifact = await readConflictArtifact(config, backend, token);
+      validate();
+      const originalLocal = fileHashMap(artifact.local);
+      const originalRemote = fileHashMap(artifact.remote);
+      if (!artifact.groups.every(
+        (group) => group.paths.every(
+          (filePath) => state.lastFileHashes[filePath] === ours[filePath] && ours[filePath] === theirs[filePath] && (ours[filePath] === originalLocal[filePath] || ours[filePath] === originalRemote[filePath])
+        )
+      ))
+        continue;
+      const stat = await fs2.lstat(path2.join(directory, name));
+      validate();
+      if (stat.isFile()) completed.push({ token, modified: stat.mtimeMs });
+    } catch {
+      validate();
+    }
+  }
+  completed.sort((left, right) => right.modified - left.modified || left.token.localeCompare(right.token));
+  for (const entry of completed.slice(32)) {
+    validate();
+    await fs2.rm(path2.join(directory, `${entry.token}.json`));
+    validate();
+  }
+  if (completed.length > 32) {
+    await syncDirectory(directory);
+    validate();
+  }
+}
+
+// src/sync/content-conflicts.ts
+import { createHash } from "node:crypto";
+function snapshotFile(filePath, bytes) {
+  return {
+    path: filePath,
+    contentBase64: bytes.toString("base64"),
+    sha256: createHash("sha256").update(bytes).digest("hex")
+  };
+}
+async function resolveContentConflicts(config, state, local, remote, plan, protectedPaths, options = {}) {
+  if (plan.kind !== "planned" || !config.mergeContent) return plan;
+  options.signal?.throwIfAborted();
+  const budget = options.textBudget ?? { remaining: TEXT_MERGE_WORK_LIMIT };
+  const decisions = [...plan.decisions];
+  let ancestors = [];
+  try {
+    ancestors = await readMergeAncestors(config, state) ?? [];
+  } catch {
+    options.signal?.throwIfAborted();
+    return plan;
+  }
+  options.signal?.throwIfAborted();
+  const oursByPath = new Map(local.files.map((file) => [file.path, file]));
+  const theirsByPath = new Map(remote.files.map((file) => [file.path, file]));
+  const ancestorsByPath = new Map(ancestors.map((file) => [file.path, file]));
+  const decisionIndex = new Map(decisions.map((decision, index) => [decision.path, index]));
+  const protectedKeys = new Set([...protectedPaths].map(mergePathIdentity));
+  for (const conflict of plan.conflicts) {
+    options.signal?.throwIfAborted();
+    if (conflict.reason !== "both-changed" || protectedKeys.has(mergePathIdentity(conflict.path))) continue;
+    const session = conflict.path.startsWith("sessions/") && conflict.path.endsWith(".jsonl");
+    if (!session && (!isMergeTextPath(conflict.path) || budget.remaining === 0)) continue;
+    const ours = oursByPath.get(conflict.path);
+    const theirs = theirsByPath.get(conflict.path);
+    if (!ours || !theirs) continue;
+    const ancestor = ancestorsByPath.get(conflict.path);
+    const base = ancestor ? Buffer.from(ancestor.contentBase64, "base64") : void 0;
+    if (!base) continue;
+    const localBytes = Buffer.from(ours.contentBase64, "base64");
+    const remoteBytes = Buffer.from(theirs.contentBase64, "base64");
+    const bytes = session ? mergeSession(base, localBytes, remoteBytes) : mergeText(base, localBytes, remoteBytes, { budget, signal: options.signal });
+    if (!bytes) continue;
+    const index = decisionIndex.get(conflict.path);
+    if (index === void 0) continue;
+    decisions[index] = {
+      kind: "accepted",
+      path: conflict.path,
+      source: "merged",
+      file: snapshotFile(conflict.path, bytes)
+    };
+  }
+  return {
+    kind: "planned",
+    decisions,
+    conflicts: decisions.filter((item) => item.kind === "conflict")
+  };
+}
+
+// src/sync/merge-apply.ts
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import fs4 from "node:fs/promises";
+import path4 from "node:path";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+
+// src/snapshot/snapshot-apply.ts
+import { createHash as createHash2 } from "node:crypto";
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+function sha256(value) {
+  return createHash2("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;
+  const transactionOptions = {
+    sessionDir,
+    signal: options.signal,
+    validateMutation: options.validateMutation,
+    protectedTargets: [...protectedRelativePaths].map((relative) => snapshotTarget(root, relative, sessionDir)),
+    expectedPreimages: new Map(
+      Object.entries(options.expectedFileHashes ?? {}).map(([relative, hash]) => [
+        snapshotTarget(root, relative, sessionDir),
+        hash === null ? "missing" : `file:${hash}`
+      ])
+    )
+  };
+  options.validateMutation?.();
+  await recoverPendingSnapshotTransactions(transactionOptions);
+  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, options);
+  await applySnapshotTransaction(plan, transactionOptions);
+  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))
+  );
+  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 fs3.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("../") && !path3.posix.isAbsolute(normalized) && path3.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, options = {}) {
+  assertMutationCurrent(options);
+  const deletePaths = new Set(plan.deletes);
+  for (const target of plan.deletes) {
+    await assertNoSymlinkParents(rootForTarget(root, target, sessionDir), target, options);
+    assertMutationCurrent(options);
+  }
+  for (const item of plan.writes) {
+    await prepareSnapshotWrite(rootForTarget(root, item.target, sessionDir), item.target, deletePaths, options);
+    assertMutationCurrent(options);
+  }
+}
+function assertMutationCurrent(options) {
+  options.validateMutation?.();
+  options.signal?.throwIfAborted();
+}
+async function guardedStat(target, options) {
+  assertMutationCurrent(options);
+  let stat;
+  try {
+    stat = await fs3.lstat(target);
+  } catch (error) {
+    assertMutationCurrent(options);
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  assertMutationCurrent(options);
+  return stat;
+}
+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, options) {
+  const parentWillBeReplaced = await ensureSafeDirectory(root, path3.dirname(target), deletePaths, options);
+  assertMutationCurrent(options);
+  if (parentWillBeReplaced) return;
+  const stat = await guardedStat(target, options);
+  assertMutationCurrent(options);
+  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}`);
+  }
+}
+async function ensureSafeDirectory(root, directory, deletePaths, options) {
+  assertMutationCurrent(options);
+  assertWithinRoot(root, directory);
+  const rootPath = path3.resolve(root);
+  const relative = path3.relative(rootPath, path3.resolve(directory));
+  let current = rootPath;
+  for (const part of relative.split(path3.sep).filter(Boolean)) {
+    current = path3.join(current, part);
+    const stat = await guardedStat(current, options);
+    assertMutationCurrent(options);
+    if (stat) {
+      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}`);
+      }
+    } else {
+      await fs3.mkdir(current);
+      assertMutationCurrent(options);
+      await syncDirectory(path3.dirname(current));
+      assertMutationCurrent(options);
+    }
+  }
+  return false;
+}
+async function assertNoSymlinkParents(root, target, options) {
+  assertMutationCurrent(options);
+  assertWithinRoot(root, target);
+  const rootPath = path3.resolve(root);
+  const relative = path3.relative(rootPath, path3.resolve(target));
+  let current = rootPath;
+  const parts = relative.split(path3.sep).filter(Boolean);
+  for (const part of parts.slice(0, -1)) {
+    current = path3.join(current, part);
+    const stat = await guardedStat(current, options);
+    assertMutationCurrent(options);
+    if (!stat) return;
+    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}`);
+  }
+}
+
+// src/sync/merge-apply.ts
+async function preflightMergedTargets(before, after, options, protectedTarget) {
+  const root = agentDir();
+  const beforeHashes = Object.assign(/* @__PURE__ */ Object.create(null), fileHashMap(before));
+  const afterHashes = Object.assign(/* @__PURE__ */ Object.create(null), fileHashMap(after));
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(beforeHashes), ...Object.keys(afterHashes)])].sort();
+  const changed = new Set(paths.filter((item) => beforeHashes[item] !== afterHashes[item]));
+  await assertCanonicalMergedTargets(root, changed, options);
+  await assertDistinctMergedTargets(root, paths, changed, options, protectedTarget, new Set(Object.keys(afterHashes)));
+  const removed = replacementPaths(
+    new Set(paths.filter((item) => changed.has(item) && !afterHashes[item])),
+    afterHashes
+  );
+  const removedTargets = new Set([...removed].map((item) => snapshotTarget(root, item, options.sessionDir)));
+  for (const relative of paths) {
+    if (changed.has(relative)) await assertFilesystemTarget(root, relative, options, removedTargets, beforeHashes);
+  }
+}
+function replacementPaths(removed, afterHashes) {
+  for (const relative of [...removed]) {
+    let parent = path4.posix.dirname(relative);
+    while (parent !== ".") {
+      if (afterHashes[parent]) {
+        for (let directory = path4.posix.dirname(relative); directory !== parent; directory = path4.posix.dirname(directory))
+          removed.add(directory);
+        removed.add(parent);
+        break;
+      }
+      parent = path4.posix.dirname(parent);
+    }
+  }
+  return removed;
+}
+async function assertCanonicalMergedTargets(root, changed, options) {
+  const topLevel = new Map(
+    [...changed].filter((relative) => !relative.includes("/")).map((relative) => [relative.toLowerCase(), relative])
+  );
+  if (topLevel.size === 0) return;
+  options.signal?.throwIfAborted();
+  options.validateMutation?.();
+  let names;
+  try {
+    names = await fs4.readdir(root);
+  } catch (error) {
+    options.signal?.throwIfAborted();
+    options.validateMutation?.();
+    if (error.code !== "ENOENT") throw error;
+    return;
+  }
+  options.signal?.throwIfAborted();
+  options.validateMutation?.();
+  for (const name of names) {
+    const canonical = topLevel.get(name.toLowerCase());
+    if (canonical !== void 0 && name !== canonical)
+      throw new Error(
+        "Merged target has a noncanonical case variant; normalize selected top-level file spelling before retrying. Journal retained if already committed."
+      );
+  }
+}
+async function assertDistinctMergedTargets(root, paths, changed, options, protectedTarget, finalPaths = new Set(paths)) {
+  const protectedKey = protectedTarget ? mergePathIdentity(await resolvedTargetIdentity(path4.resolve(protectedTarget), options)) : void 0;
+  options.signal?.throwIfAborted();
+  options.validateMutation?.();
+  const keys = /* @__PURE__ */ new Map();
+  for (const relative of paths) {
+    options.signal?.throwIfAborted();
+    const target = snapshotTarget(root, relative, options.sessionDir);
+    const key = mergePathIdentity(await resolvedTargetIdentity(target, options));
+    options.signal?.throwIfAborted();
+    options.validateMutation?.();
+    const existing = keys.get(key);
+    if (existing && (mergePathIdentity(existing) !== mergePathIdentity(relative) || finalPaths.has(existing) && finalPaths.has(relative)))
+      throw new Error("Merged paths resolve to the same file; reviewed directional recovery is required.");
+    if (key === protectedKey && changed.has(relative))
+      throw new Error("A merged transfer targets the current session; review is required.");
+    keys.set(key, relative);
+  }
+}
+async function assertReviewedTree(directory, relative, beforeHashes) {
+  for (const name of await fs4.readdir(directory)) {
+    const child = path4.join(directory, name);
+    const childRelative = `${relative}/${name}`;
+    const stat = await fs4.lstat(child);
+    if (stat.isDirectory()) {
+      await assertReviewedTree(child, childRelative, beforeHashes);
+    } else if (stat.isFile() && stat.nlink === 1 && beforeHashes[childRelative] === createHash3("sha256").update(await fs4.readFile(child)).digest("hex")) {
+      continue;
+    } else {
+      throw new Error("Reviewed directory contains unknown or changed files; publication refused.");
+    }
+  }
+}
+function hasBlockingFileAncestor(target, files) {
+  for (let parent = path4.dirname(target); parent !== path4.dirname(parent); parent = path4.dirname(parent))
+    if (files.has(parent)) return true;
+  return false;
+}
+async function resolvedTargetIdentity(target, options) {
+  let ancestor = target;
+  while (true) {
+    options.signal?.throwIfAborted();
+    try {
+      const resolved = await fs4.realpath(ancestor);
+      return path4.resolve(resolved, path4.relative(ancestor, target));
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
+      const parent = path4.dirname(ancestor);
+      if (parent === ancestor) return target;
+      ancestor = parent;
+    }
+  }
+}
+async function assertFilesystemTarget(root, relative, options, removedTargets = /* @__PURE__ */ new Set(), beforeHashes) {
+  const target = snapshotTarget(root, relative, options.sessionDir);
+  const boundary = relative.startsWith("sessions/") && options.sessionDir ? path4.resolve(sessionStorageRoot(root, options.sessionDir)) : path4.resolve(root);
+  for (let parent = path4.dirname(target); mergePathIdentity(parent) !== mergePathIdentity(boundary); parent = path4.dirname(parent)) {
+    options.signal?.throwIfAborted();
+    if (path4.dirname(parent) === parent) throw new Error("Unowned merged target.");
+    try {
+      const stat = await fs4.lstat(parent);
+      if ((!stat.isDirectory() || stat.isSymbolicLink()) && !(stat.isFile() && stat.nlink === 1 && removedTargets.has(parent)))
+        throw new Error("Unsafe merge filesystem layout; review the selected paths before transfer.");
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT") throw error;
+    }
+  }
+  options.signal?.throwIfAborted();
+  try {
+    const stat = await fs4.lstat(target);
+    if (!stat.isFile() && !removedTargets.has(target) || stat.isFile() && stat.nlink > 1)
+      throw new Error("Merge target is non-regular or hard-linked; review a directional operation before transfer.");
+    if (stat.isDirectory() && beforeHashes) await assertReviewedTree(target, relative, beforeHashes);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && !(code === "ENOTDIR" && removedTargets.size > 0)) throw error;
+  }
+}
+async function applyMergedSnapshot(before, after, protectedPaths, options, validate, protectedTarget) {
+  const root = agentDir();
+  const beforeHashes = Object.assign(/* @__PURE__ */ Object.create(null), fileHashMap(before));
+  const afterHashes = Object.assign(/* @__PURE__ */ Object.create(null), fileHashMap(after));
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(beforeHashes), ...Object.keys(afterHashes)])].sort();
+  const replacements = replacementPaths(
+    new Set(paths.filter((item) => beforeHashes[item] && !afterHashes[item])),
+    afterHashes
+  );
+  const intermediateDirectories = [...replacements].filter((item) => !beforeHashes[item] && !afterHashes[item]);
+  const changed = [
+    .../* @__PURE__ */ new Set([...paths.filter((item) => beforeHashes[item] !== afterHashes[item]), ...intermediateDirectories])
+  ].sort();
+  const protectedKeys = new Set([...protectedPaths].map(mergePathIdentity));
+  if (changed.some((item) => protectedKeys.has(mergePathIdentity(item)))) {
+    throw new Error("A merged transfer targets the current session; review is required.");
+  }
+  const targets = changed.map((item) => snapshotTarget(root, item, options.sessionDir));
+  const relativeByTarget = new Map(targets.map((target, index) => [target, changed[index]]));
+  const targetSet = new Set(targets);
+  await assertDistinctMergedTargets(
+    root,
+    paths,
+    new Set(changed),
+    options,
+    protectedTarget,
+    new Set(Object.keys(afterHashes))
+  );
+  async function acquire(index) {
+    const target = targets[index];
+    if (target) return withFileMutationQueue(target, () => acquire(index + 1));
+    await validate();
+    await assertCanonicalMergedTargets(root, changed, options);
+    await validate();
+    const current = await createSnapshot(before.profile, options);
+    const currentHashes = Object.assign(/* @__PURE__ */ Object.create(null), fileHashMap(current));
+    const blockingFiles = new Set(
+      paths.filter(
+        (relative) => beforeHashes[relative] && !afterHashes[relative] || afterHashes[relative] && currentHashes[relative] === afterHashes[relative]
+      ).map((relative) => snapshotTarget(root, relative, options.sessionDir))
+    );
+    for (const item of changed) {
+      if (currentHashes[item] !== beforeHashes[item] && currentHashes[item] !== afterHashes[item]) {
+        throw new Error(
+          "Local content changed during merged transfer; journal retained for review. No newer bytes were replaced."
+        );
+      }
+      const target2 = snapshotTarget(root, item, options.sessionDir);
+      try {
+        const stat = await fs4.lstat(target2);
+        if (!stat.isFile() && !stat.isDirectory() || stat.isFile() && stat.nlink > 1)
+          throw new Error("Merged transfer target is no longer an independent regular file.");
+      } catch (error) {
+        const code = error.code;
+        if (code !== "ENOENT" && !(code === "ENOTDIR" && hasBlockingFileAncestor(target2, blockingFiles))) throw error;
+      }
+    }
+    const plan = preflightSnapshotApply(root, after, current, options);
+    plan.writes = plan.writes.filter((item) => targetSet.has(item.target));
+    plan.deletes = plan.deletes.filter((target2) => targetSet.has(target2));
+    await preflightSnapshotMutations(root, plan, options.sessionDir, options);
+    const deletedTargets = new Set(plan.deletes);
+    for (const relative of intermediateDirectories) {
+      for (let parent = path4.posix.dirname(relative); parent !== "."; parent = path4.posix.dirname(parent)) {
+        if (afterHashes[parent] && deletedTargets.has(snapshotTarget(root, parent, options.sessionDir))) {
+          plan.deletes.push(snapshotTarget(root, relative, options.sessionDir));
+          break;
+        }
+      }
+    }
+    plan.deletes.sort(
+      (left, right) => right.split(path4.sep).length - left.split(path4.sep).length || left.localeCompare(right)
+    );
+    const removed = replacementPaths(
+      new Set(paths.filter((relative) => deletedTargets.has(snapshotTarget(root, relative, options.sessionDir)))),
+      afterHashes
+    );
+    const removedTargets = new Set([...removed].map((item) => snapshotTarget(root, item, options.sessionDir)));
+    await assertCanonicalMergedTargets(root, changed, options);
+    await validate();
+    const revalidateTarget = async (target2) => {
+      await validate();
+      const relative = relativeByTarget.get(target2);
+      if (!relative) throw new Error("Unowned merge target.");
+      await assertFilesystemTarget(root, relative, options, removedTargets, currentHashes);
+      await validate();
+      let hash;
+      try {
+        const stat = await fs4.lstat(target2);
+        if (stat.isDirectory() && removed.has(relative)) {
+          if ((await fs4.readdir(target2)).length)
+            throw new Error("Reviewed directory has remaining contents; journal retained for review.");
+        } else {
+          if (!stat.isFile() || stat.nlink > 1)
+            throw new Error("Merged transfer target is no longer an independent regular file.");
+          hash = createHash3("sha256").update(await fs4.readFile(target2)).digest("hex");
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      options.signal?.throwIfAborted();
+      options.validateMutation?.();
+      if (hash !== beforeHashes[relative] && hash !== afterHashes[relative])
+        throw new Error("Local content changed at the apply boundary; journal retained, newer bytes untouched.");
+    };
+    for (const target2 of plan.deletes) {
+      await revalidateTarget(target2);
+      try {
+        const stat = await fs4.lstat(target2);
+        await validate();
+        if (stat.isDirectory())
+          await fs4.rmdir(target2);
+        else await fs4.rm(target2, { force: true });
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      await syncDirectory(path4.dirname(target2));
+    }
+    for (const item of plan.writes) {
+      await validate();
+      const relative = relativeByTarget.get(item.target);
+      if (!relative) throw new Error("Unowned merge write target.");
+      await assertFilesystemTarget(root, relative, options, /* @__PURE__ */ new Set());
+      await fs4.mkdir(path4.dirname(item.target), { recursive: true });
+      const temporary = path4.join(path4.dirname(item.target), `.pi-sync.json.${randomUUID()}.apply`);
+      let mode = 384;
+      try {
+        mode = (await fs4.stat(item.target)).mode & 511;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+      try {
+        const handle = await fs4.open(temporary, "wx", mode);
+        try {
+          await handle.writeFile(item.content);
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+        await revalidateTarget(item.target);
+        await fs4.rename(temporary, item.target);
+        await syncDirectory(path4.dirname(item.target));
+      } finally {
+        await fs4.rm(temporary, { force: true });
+      }
+    }
+    await syncMutationParents(
+      targets,
+      [root, ...options.sessionDir ? [sessionStorageRoot(root, options.sessionDir)] : []],
+      options
+    );
+    await validate();
+  }
+  await acquire(0);
+}
+
+// src/sync/partial-progress.ts
+function acceptedMergeFiles(decisions, localFiles, withheld) {
+  const localByPath = new Map(localFiles.map((file) => [file.path, file]));
+  return decisions.flatMap((decision) => {
+    const file = withheld.has(decision.path) ? localByPath.get(decision.path) : decision.kind === "accepted" ? decision.file : void 0;
+    return file ? [file] : [];
+  });
+}
+function progressState(config, head, snapshot, progress) {
+  const withheld = new Set(progress.groups.flatMap((group) => group.paths));
+  const current = fileHashMap(snapshot);
+  const hashes = Object.assign(/* @__PURE__ */ Object.create(null), progress.previous.lastFileHashes);
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(hashes), ...Object.keys(current)])) {
+    if (withheld.has(key)) continue;
+    const value = current[key];
+    if (value === void 0) delete hashes[key];
+    else hashes[key] = value;
+  }
+  return {
+    ...progress.previous,
+    version: 3,
+    profile: config.snapshotIdentity,
+    lastFileHashes: hashes,
+    include: [...config.include],
+    localFields: config.localFields,
+    lastObservedSnapshot: head.snapshotId,
+    lastObservedRevision: head.revision,
+    unresolved: progress.groups
+  };
+}
+
+// src/sync/settings-conflicts.ts
+import { createHash as createHash4 } from "node:crypto";
+
+// src/sync/settings-merge.ts
+var COUPLED_FIELDS = [
+  ["defaultProvider", "defaultModel"],
+  ["queueMode", "steeringMode"],
+  ["websockets", "transport"],
+  ["skills", "enableSkillCommands"],
+  ["enableAnalytics", "trackingId"]
+];
+function mergeSettingsJson(ancestor, local, remote) {
+  let documents;
+  try {
+    documents = [ancestor, local, remote].map(parseSettingsDocument);
+  } catch {
+    return { kind: "review", reason: "unsupported-format", fields: [] };
+  }
+  const [base, left, right] = documents;
+  const selected = /* @__PURE__ */ new Map();
+  const fields = new Set(documents.flatMap((document) => [...document.root.members.keys()]));
+  const units = COUPLED_FIELDS.map((group) => [...group]);
+  const coupled = new Set(units.flat());
+  units.push(...[...fields].filter((field) => !coupled.has(field)).map((field) => [field]));
+  const conflicts = [];
+  for (const unit of units) {
+    const equal = (first, second) => unit.every(
+      (field) => jsonEqual(first.root.members.get(field)?.node.value, second.root.members.get(field)?.node.value)
+    );
+    const source = equal(left, right) ? left : equal(left, base) ? right : equal(right, base) ? left : void 0;
+    if (!source) {
+      conflicts.push(...unit.filter((field) => fields.has(field)));
+      continue;
+    }
+    for (const field of unit) {
+      const member = source.root.members.get(field);
+      if (member) selected.set(field, { document: source, node: member.node });
+    }
+  }
+  if (conflicts.length) return { kind: "review", reason: "field-conflict", fields: conflicts };
+  try {
+    return { kind: "merged", content: renderSettingsMembers(left, selected) };
+  } catch {
+    return { kind: "review", reason: "unsupported-format", fields: [] };
+  }
+}
+
+// src/sync/settings-conflicts.ts
+async function resolveSettingsConflicts(config, state, local, remote, plan) {
+  if (plan.kind !== "planned") return { plan, fields: [] };
+  const fields = [];
+  const decisions = [...plan.decisions];
+  for (let index = 0; index < decisions.length; index++) {
+    const decision = decisions[index];
+    if (decision?.kind !== "conflict" || decision.reason !== "both-changed" || decision.path !== "settings.json")
+      continue;
+    const left = local.files.find((file) => file.path === decision.path);
+    const right = remote.files.find((file) => file.path === decision.path);
+    if (!left || !right) continue;
+    const ancestor = await readMergeAncestor(config, state, decision.path);
+    if (!ancestor) continue;
+    const merged = mergeSettingsJson(
+      ancestor,
+      Buffer.from(left.contentBase64, "base64"),
+      Buffer.from(right.contentBase64, "base64")
+    );
+    if (merged.kind === "review") {
+      fields.push(...merged.fields);
+      continue;
+    }
+    decisions[index] = {
+      kind: "accepted",
+      path: decision.path,
+      source: "merged",
+      file: {
+        path: decision.path,
+        contentBase64: merged.content.toString("base64"),
+        sha256: createHash4("sha256").update(merged.content).digest("hex")
+      }
+    };
+  }
+  return {
+    plan: { kind: "planned", decisions, conflicts: decisions.filter((decision) => decision.kind === "conflict") },
+    fields
+  };
+}
+
+// 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";
+}
+
+// src/sync/merged-sync.ts
+var MAX_ATTEMPTS = 3;
+async function mergeSync(ctx, options, factory = createSyncBackend, resolution) {
+  const validateOwner = captureMutationOwner(ctx, options.signal);
+  const isCurrent = () => {
+    try {
+      validateOwner();
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const config = await loadConfig(options.setup);
+  const configToken = syncCheckConfigFingerprint(config);
+  const sessionRoot = config.include.includes("sessions") ? await effectiveSessionRoot(ctx) : void 0;
+  validateOwner();
+  const snapshotOptions = {
+    ...snapshotOptionsForContext(ctx, config),
+    sessionDir: sessionRoot,
+    signal: options.signal
+  };
+  const validate = async () => {
+    validateOwner();
+    const latest = await loadConfig(options.setup);
+    validateOwner();
+    if (configToken !== syncCheckConfigFingerprint(latest))
+      throw new Error("Sync setup or settings changed during transfer; reopen sync.");
+    if (sessionRoot !== void 0) {
+      const currentRoot = await effectiveSessionRoot(ctx);
+      validateOwner();
+      if (currentRoot !== sessionRoot)
+        throw new Error("Session storage root changed during transfer; evidence retained for review.");
+    }
+    if (options.auto && (!latest.automaticTransfer || !ctx.isIdle()))
+      throw new Error("Automatic transfer is no longer authorized at this idle boundary.");
+  };
+  await validate();
+  const backend = await factory(config);
+  await validate();
+  if (options.auto && backend.capability === "read-check-write-verify") {
+    throw new Error(
+      "Automatic transfer requires conditional publication or a lease; this backend supports only read/check/write/verify. Use manual sync."
+    );
+  }
+  const pending = await readMergeJournal(config);
+  await validate();
+  if (pending) {
+    const recovered = await completeJournal(ctx, config, backend, pending, validate, options.signal, options.auto);
+    if (!recovered) {
+      if ((options.auto || !options.silent) && !options.signal?.aborted)
+        ctx.ui.notify(
+          "Interrupted candidate is not active; local content and baseline were unchanged. Evidence was reconciled without retrying publication. Run sync again for a fresh plan.",
+          "warning"
+        );
+      return "cancelled";
+    }
+    if ((options.auto || !options.silent) && !options.signal?.aborted)
+      ctx.ui.notify("Recovered the committed merged transfer. Run sync again to inspect newer changes.", "info");
+    return "applied";
+  }
+  const textBudget = { remaining: TEXT_MERGE_WORK_LIMIT };
+  const createdArtifacts = [];
+  const ownedStatePath = statePathForConfig(config);
+  try {
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      await validate();
+      const state = await readStateForConfig(config);
+      if (state.unresolved?.length && !config.partialSync)
+        throw new Error(
+          "Partial progress remains unresolved; re-enable partial sync or review an explicit force direction."
+        );
+      const localRaw = await createSnapshot(config.snapshotIdentity, snapshotOptions);
+      const local = portableSnapshot(localRaw, config.localFields);
+      if (!sameLocalFields(state.localFields, config.localFields))
+        throw new Error("Local-field rules changed; review and confirm a directional migration first.");
+      const head = await backend.readHead(options.signal);
+      await validate();
+      const rawRemote = head ? await readSnapshotForHead(backend, head, options.signal) : void 0;
+      await validate();
+      if (rawRemote) {
+        const files = [...local.files, ...rawRemote.files];
+        if (files.length > 16384 || files.reduce((bytes, file) => bytes + file.contentBase64.length * 0.75, 0) > 64 * 1024 * 1024) {
+          throw new Error(
+            "Merged transfer exceeds the 64 MiB / 16,384 input-file bound; review an explicit push or pull instead."
+          );
+        }
+      }
+      const remote = rawRemote ? portableSnapshot(filterSnapshotForConfigPolicy(rawRemote, config), rawRemote.localFields) : void 0;
+      if (rawRemote) {
+        requireCompatibleRemoteSelection(config, rawRemote);
+        const validation = planFileMerge({
+          baseline: state.lastFileHashes,
+          local: local.files,
+          remote: rawRemote.files,
+          selectionCompatible: true
+        });
+        const managedPaths = /* @__PURE__ */ new Set([
+          ...Object.keys(state.lastFileHashes),
+          ...[...local.files, ...remote?.files ?? []].map((file) => file.path)
+        ]);
+        if (validation.kind === "planned" && validation.conflicts.some(
+          (item) => item.reason === "path-collision" && (!config.partialSync || !managedPaths.has(item.path))
+        ))
+          throw new Error("Remote snapshot contains path collisions; review a directional recovery before merging.");
+      }
+      const review = (message, kind = "both-changed") => createSyncDecision({
+        kind,
+        config,
+        state,
+        local,
+        remote,
+        localChanged: hasLocalChanges(local, state, config),
+        remoteChanged: remote ? hasRemoteChanges(remote, state, config) : Boolean(state.lastAppliedSnapshot),
+        directMessage: message
+      });
+      if (!state.lastAppliedSnapshot) throw review("Choose the initial source before enabling automatic transfer.");
+      if (syncPolicyChanged(state, config))
+        throw review("Included content changed; review the selection before merging.", "remote-or-policy-changed");
+      if (!head || !remote || !rawRemote)
+        throw review("The established remote is missing; choose an explicit recovery direction.", "remote-empty");
+      const selectionState = inspectRemoteSelection(config.include, rawRemote);
+      const selectionCompatible = selectionState.kind === "same";
+      let plan = planFileMerge({
+        baseline: state.lastFileHashes,
+        local: local.files,
+        remote: remote.files,
+        selectionCompatible,
+        protectedPaths: protectedSessionPaths(ctx, sessionRoot)
+      });
+      let resolved = { plan, fields: [] };
+      if (config.mergeSettings) {
+        try {
+          resolved = await resolveSettingsConflicts(config, state, local, remote, plan);
+        } catch (error) {
+          if (!config.partialSync) throw error;
+        }
+      }
+      await validate();
+      plan = await resolveContentConflicts(
+        config,
+        state,
+        local,
+        remote,
+        resolved.plan,
+        protectedSessionPaths(ctx, sessionRoot),
+        { textBudget, signal: options.signal }
+      );
+      await validate();
+      if (resolution) {
+        plan = await resolveReviewedGroup(
+          config,
+          backend,
+          state,
+          local,
+          remote,
+          head,
+          plan,
+          resolution,
+          protectedSessionPaths(ctx, sessionRoot)
+        );
+        await validate();
+      }
+      if (plan.kind !== "planned" || plan.conflicts.length && (!config.partialSync || options.auto)) {
+        const decision = review(
+          selectionCompatible ? `Conflicting or protected paths require review; no merged transfer was performed. Use /sync diff and an explicit direction.${resolved.fields.length ? ` Settings fields: ${resolved.fields.map(safeTerminalText).join(", ")}` : ""}` : "Remote selection metadata is unavailable; review the included content and choose an explicit direction before merging.",
+          selectionCompatible ? "both-changed" : "remote-or-policy-changed"
+        );
+        if (!selectionCompatible)
+          decision.decision.review += `
+
+${formatRemoteSelectionStatus(selectionState)}
+An explicit direction adopts this setup's included-content policy; no automatic merge was performed.`;
+        throw decision;
+      }
+      if (plan.kind !== "planned") throw new Error("Cannot partition an unverified merge plan.");
+      const groups = conflictGroups(plan, config);
+      const withheld = new Set(groups.flatMap((group) => group.paths));
+      const persistProgress = async () => {
+        if (!groups.length) return;
+        let ancestors = [];
+        try {
+          ancestors = (await readMergeAncestors(config, state) ?? []).filter((file) => withheld.has(file.path));
+        } catch {
+        }
+        await validate();
+        const previousArtifacts = /* @__PURE__ */ new Map();
+        for (const token of new Set(state.unresolved?.map((group) => group.artifact) ?? [])) {
+          try {
+            const artifact2 = await readConflictArtifact(config, backend.identity, token);
+            previousArtifacts.set(token, {
+              artifact: artifact2,
+              local: fileHashMap(artifact2.local),
+              remote: fileHashMap(artifact2.remote)
+            });
+          } catch {
+          }
+          await validate();
+        }
+        const localHashes = fileHashMap(local);
+        const remoteHashes = fileHashMap(remote);
+        const previousGroups = new Map(state.unresolved?.map((item) => [JSON.stringify(item.paths), item]));
+        const pending2 = groups.map((group) => {
+          const previous = previousGroups.get(JSON.stringify(group.paths));
+          const original = previous ? previousArtifacts.get(previous.artifact) : void 0;
+          if (!original || !previous) return { group };
+          return group.paths.every(
+            (filePath) => localHashes[filePath] === original.local[filePath] && remoteHashes[filePath] === original.remote[filePath] && state.lastFileHashes[filePath] === original.artifact.state.lastFileHashes[filePath]
+          ) ? { group, artifact: previous.artifact } : { group };
+        });
+        let artifact;
+        const newGroups = pending2.filter((item) => !item.artifact).map((item) => item.group);
+        const newPaths = new Set(newGroups.flatMap((group) => group.paths));
+        if (newGroups.length)
+          artifact = await saveConflictArtifact(
+            config,
+            backend.identity,
+            {
+              state,
+              local: { ...local, files: local.files.filter((file) => newPaths.has(file.path)) },
+              remote: { ...remote, files: remote.files.filter((file) => newPaths.has(file.path)) },
+              ancestors: ancestors.filter((file) => newPaths.has(file.path)),
+              groups: newGroups,
+              observed: { snapshotId: head.snapshotId, revision: head.revision }
+            },
+            captureMutationOwner(ctx, options.signal),
+            (created) => createdArtifacts.push(created)
+          );
+        await validate();
+        return {
+          previous: state,
+          groups: pending2.map((item) => ({ paths: item.group.paths, artifact: item.artifact ?? artifact ?? "" }))
+        };
+      };
+      let progress;
+      const accepted = regenerateSnapshotIdentity({
+        ...local,
+        files: acceptedMergeFiles(plan.decisions, local.files, withheld)
+      });
+      const after = overlayLocalFields(accepted, localRaw, config.localFields);
+      if (config.include.includes("sessions")) requireStableMergeSessionRoot(localRaw, after);
+      const publication = regenerateSnapshotIdentity({
+        ...accepted,
+        version: config.partialSync ? 3 : accepted.version,
+        files: [
+          ...accepted.files.filter((file) => !withheld.has(file.path)),
+          ...remote.files.filter((file) => withheld.has(file.path))
+        ]
+      });
+      const upload = mergeRemotePreservedFiles(publication, rawRemote, config);
+      const publish = !sameHashes(fileHashMap(publication), fileHashMap(remote)) || Boolean(config.partialSync && rawRemote.version !== 3);
+      const apply = !sameHashes(fileHashMap(localRaw), fileHashMap(after));
+      if (!publish && !apply) {
+        const beforeEvidence = await backend.readHead(options.signal);
+        await validate();
+        if (!beforeEvidence || !backend.sameRevision(beforeEvidence.revision, head.revision))
+          throw new Error("Remote changed before baseline acceptance; retry from a fresh observation.");
+        progress = await persistProgress();
+        await validate();
+        const currentLocal = await createSnapshot(config.snapshotIdentity, snapshotOptions);
+        await validate();
+        if (!sameHashes(fileHashMap(currentLocal), fileHashMap(localRaw)) || syncStateFingerprint(await readStateForConfig(config)) !== syncStateFingerprint(state))
+          throw new Error(
+            "Local content or baseline changed before baseline acceptance; retry from a fresh observation."
+          );
+        await validate();
+        const currentHead = await backend.readHead(options.signal);
+        await validate();
+        if (!currentHead || !backend.sameRevision(currentHead.revision, head.revision))
+          throw new Error("Remote changed before baseline acceptance; retry from a fresh observation.");
+        await writeAcceptedState(config, head, accepted, validate, progress);
+        await pruneMergeBaselines(
+          config,
+          acceptedState(config, head, accepted, progress),
+          captureMutationOwner(ctx, options.signal)
+        );
+        await validate();
+        await pruneCompletedConflicts(
+          config,
+          backend.identity,
+          acceptedState(config, head, accepted, progress),
+          accepted,
+          remote,
+          captureMutationOwner(ctx, options.signal)
+        );
+        await validate();
+        if (!options.silent)
+          ctx.ui.notify(
+            progress ? `No independent transfer required; ${groups.length} conflict groups remain withheld. Review /sync conflicts.` : "Pi Sync is already up to date.",
+            progress ? "warning" : "info"
+          );
+        return "applied";
+      }
+      await preflightMergedTargets(localRaw, after, snapshotOptions, ctx.sessionManager.getSessionFile?.());
+      await validate();
+      if (!config.skipSecretScan && scanSnapshot(upload).length)
+        throw new Error("Refusing to merge possible secrets. Review managed content before syncing.");
+      if (!options.yes && !await confirmMergeReview(
+        ctx,
+        "Merge independent Pi changes?",
+        [
+          `Sync setup: ${safeTerminalText(config.setupName)}`,
+          `Storage location: ${safeTerminalText(backend.destination)}`,
+          `Sessions: ${config.include.includes("sessions") ? "included \u2014 may contain private conversations" : "not included"}`,
+          `Local writes/deletions: ${plan.decisions.filter((item) => item.kind === "accepted" && (item.source === "remote" || item.source === "merged")).length}`,
+          formatApplyPreview(localRaw, after).split("\n").map(safeTerminalText).join("\n"),
+          `Unresolved dependency groups: ${groups.length} (withheld versions stay on each side; baselines do not advance)`,
+          ...groups.flatMap((group) => group.paths.map((filePath) => `Withheld: ${safeTerminalText(filePath)}`)),
+          `Remote publication: ${publish ? "yes" : "no"}`,
+          formatPublicationPreview(rawRemote, upload).split("\n").map(safeTerminalText).join("\n"),
+          `Backend publication: ${backend.capability}`,
+          "The current session is protected. A backup and recovery journal are retained. Resources are not reloaded."
+        ].join("\n"),
+        options.signal,
+        isCurrent
+      ))
+        return "cancelled";
+      await validate();
+      const refreshed = await createSnapshot(config.snapshotIdentity, snapshotOptions);
+      if (!sameHashes(fileHashMap(refreshed), fileHashMap(localRaw)))
+        throw new Error("Local content changed during review; no merged transfer was performed.");
+      if (syncStateFingerprint(await readStateForConfig(config)) !== syncStateFingerprint(state))
+        throw new Error("Sync baseline changed during review; retry from a fresh observation.");
+      await validate();
+      const refreshedHead = await backend.readHead(options.signal);
+      await validate();
+      if (!refreshedHead || !backend.sameRevision(refreshedHead.revision, head.revision))
+        throw new Error("Remote changed during review; no merged transfer was performed.");
+      progress = await persistProgress();
+      await validate();
+      const backup = await backupLocal(config.snapshotIdentity, snapshotOptions, options.signal);
+      await validate();
+      const journal = {
+        version: 1,
+        identity: mergeJournalIdentity(config, backend.identity),
+        before: localRaw,
+        after,
+        accepted,
+        ...progress ? { progress } : {},
+        upload: publish ? upload : rawRemote,
+        expectedHead: head,
+        backup,
+        stateIdentity: syncStateFingerprint(state),
+        ...sessionRoot !== void 0 ? { sessionRoot } : {},
+        ...!publish ? { committedHead: head, applyOnly: true } : {}
+      };
+      await writeMergeJournal(config, journal);
+      const atCommitState = syncStateFingerprint(await readStateForConfig(config));
+      await validate();
+      const atCommit = await createSnapshot(config.snapshotIdentity, snapshotOptions);
+      await validate();
+      if (!sameHashes(fileHashMap(atCommit), fileHashMap(localRaw)) || atCommitState !== journal.stateIdentity) {
+        await validate();
+        await clearMergeJournal(config);
+        throw new Error(
+          "Local content or baseline changed before publication; candidate retired without transfer. Review a fresh sync."
+        );
+      }
+      try {
+        await preflightMergedTargets(atCommit, after, snapshotOptions, ctx.sessionManager.getSessionFile?.());
+        await validate();
+      } catch (error) {
+        await validate();
+        await clearMergeJournal(config);
+        throw error;
+      }
+      try {
+        if (publish) {
+          const result = await backend.publishSnapshot(upload, expectedRemoteHead(head), {
+            signal: options.signal,
+            onCommit: options.onCommit
+          });
+          journal.committedHead = result.head;
+          journal.warnings = result.warnings;
+          await writeMergeJournal(config, journal);
+        } else options.onCommit?.();
+      } catch (error) {
+        if (error instanceof SyncBackendConflictError && error.phase === "before-commit" && !error.candidateMayHaveBeenActive) {
+          await clearMergeJournal(config);
+          if (attempt + 1 < MAX_ATTEMPTS) continue;
+          throw new Error("Remote changed before commit in all three attempts; retry later.", { cause: error });
+        }
+        throw new Error(
+          "Merged transfer interrupted; journal and backup retained. Run /sync sync to reconcile before further mutations.",
+          { cause: error }
+        );
+      }
+      const completed = await completeJournal(ctx, config, backend, journal, validate, options.signal, options.auto);
+      if (!completed) {
+        if (!options.signal?.aborted && (options.auto || !options.silent))
+          ctx.ui.notify(
+            "Remote changed before local apply; candidate retired without transfer. Run sync again.",
+            "warning"
+          );
+        return "cancelled";
+      }
+      if (!options.signal?.aborted && (options.auto || !options.silent))
+        ctx.ui.notify(
+          [
+            `Synced independent changes for \u201C${safeTerminalText(config.setupName)}\u201D. ${apply ? "Local files changed; reload or restart Pi when ready to use changed resources." : "Remote updated."} No automatic reload.`,
+            ...progress ? [
+              `Partial progress: ${groups.length} dependency groups remain unresolved; neither side's withheld versions or baseline hashes were replaced. Review /sync conflicts.`
+            ] : [],
+            ...(journal.warnings ?? []).map(safeTerminalText)
+          ].join("\n"),
+          progress || journal.warnings?.length ? "warning" : "info"
+        );
+      return "applied";
+    }
+  } finally {
+    await releaseConflictArtifacts(config, ownedStatePath, createdArtifacts);
+  }
+}
+async function completeJournal(ctx, config, backend, journal, validate, signal, auto = false) {
+  if (journal.identity !== mergeJournalIdentity(config, backend.identity) || !sameLocalFields(journal.upload.localFields, config.localFields))
+    throw new Error(
+      "Merge journal belongs to a different setup, selection or local-field policy; preserve it for reviewed recovery."
+    );
+  await validate();
+  const sessionRoot = config.include.includes("sessions") ? await effectiveSessionRoot(ctx) : void 0;
+  await validate();
+  if (sessionRoot !== void 0 && journal.sessionRoot !== sessionRoot) {
+    throw new Error(
+      "Merge journal session root is missing or differs from this context; preserve evidence and use reviewed directional recovery."
+    );
+  }
+  const snapshotOptions = { ...snapshotOptionsForContext(ctx, config), sessionDir: sessionRoot, signal };
+  const head = await backend.readHead(signal);
+  if (!journal.committedHead && head && backend.sameRevision(head.revision, journal.expectedHead.revision)) {
+    await validate();
+    const local = await createSnapshot(config.snapshotIdentity, snapshotOptions);
+    if (!sameHashes(fileHashMap(local), fileHashMap(journal.before)) || syncStateFingerprint(await readStateForConfig(config)) !== journal.stateIdentity) {
+      throw new Error(
+        "Uncertain publication is not active, but local content or baseline changed; keep the journal for reviewed recovery."
+      );
+    }
+    await clearMergeJournal(config);
+    return false;
+  }
+  await validate();
+  if (journal.committedHead && (!head || !backend.sameRevision(head.revision, journal.committedHead.revision))) {
+    const state2 = await readStateForConfig(config);
+    await validate();
+    if (matchesAcceptedState(state2, config, journal.committedHead, journal.accepted ?? journal.after, journal.progress)) {
+      await clearMergeJournal(config);
+      await validate();
+      await pruneMergeBaselines(config, state2, captureMutationOwner(ctx, signal));
+      await validate();
+      return true;
+    }
+  }
+  if (journal.applyOnly && (!head || !backend.sameRevision(head.revision, journal.expectedHead.revision))) {
+    const local = await createSnapshot(config.snapshotIdentity, snapshotOptions);
+    const state2 = await readStateForConfig(config);
+    await validate();
+    if (sameHashes(fileHashMap(local), fileHashMap(journal.before)) && syncStateFingerprint(state2) === journal.stateIdentity) {
+      await clearMergeJournal(config);
+      return false;
+    }
+    throw new Error("Apply-only remote head advanced after local changes; preserve the journal for reviewed recovery.");
+  }
+  if (!head || head.snapshotId !== journal.upload.id || journal.committedHead && !backend.sameRevision(head.revision, journal.committedHead.revision)) {
+    throw new Error(
+      "Publication outcome cannot be reconciled with the current remote head. Journal and backup retained; do not retry publication or restore old bytes blindly."
+    );
+  }
+  const observed = await readSnapshotForHead(backend, head, signal);
+  requireCompatibleRemoteSelection(config, observed);
+  if (!sameHashes(fileHashMap(observed), fileHashMap(journal.upload)) || JSON.stringify(observed.selection) !== JSON.stringify(journal.upload.selection))
+    throw new Error("Remote snapshot does not match the recorded merge publication.");
+  const state = await readStateForConfig(config);
+  if (matchesAcceptedState(state, config, head, journal.accepted ?? journal.after, journal.progress)) {
+    await validate();
+    await clearMergeJournal(config);
+    await validate();
+    await pruneMergeBaselines(config, state, captureMutationOwner(ctx, signal));
+    await validate();
+    return true;
+  }
+  if (syncStateFingerprint(state) !== journal.stateIdentity) {
+    throw new Error("Sync baseline changed after the interrupted merge; preserve its journal and review recovery.");
+  }
+  if (inspectRemoteSelection(config.include, observed).kind !== "same")
+    throw new Error(
+      "Pending merge has unavailable remote selection metadata; preserve its journal and choose a reviewed explicit direction."
+    );
+  if (config.include.includes("sessions")) requireStableMergeSessionRoot(journal.before, journal.after);
+  await validate();
+  const validateOwner = captureMutationOwner(ctx, signal);
+  const validateMutation = () => {
+    validateOwner();
+    if (auto && !ctx.isIdle()) throw new Error("Automatic file apply is no longer idle; evidence retained.");
+  };
+  await applyMergedSnapshot(
+    journal.before,
+    journal.after,
+    protectedSessionPaths(ctx, sessionRoot),
+    { ...snapshotOptions, validateMutation },
+    validate,
+    ctx.sessionManager.getSessionFile?.()
+  );
+  await validate();
+  const headAtAcceptance = await backend.readHead(signal);
+  await validate();
+  if (!headAtAcceptance || !backend.sameRevision(headAtAcceptance.revision, head.revision))
+    throw new Error("Remote changed during merged apply; journal and backup retained for review.");
+  await writeAcceptedState(config, head, journal.accepted ?? journal.after, validate, journal.progress);
+  await validate();
+  await clearMergeJournal(config);
+  await validate();
+  await pruneMergeBaselines(
+    config,
+    acceptedState(config, head, journal.accepted ?? journal.after, journal.progress),
+    captureMutationOwner(ctx, signal)
+  );
+  await validate();
+  await pruneCompletedConflicts(
+    config,
+    backend.identity,
+    acceptedState(config, head, journal.accepted ?? journal.after, journal.progress),
+    journal.accepted ?? journal.after,
+    journal.upload,
+    captureMutationOwner(ctx, signal)
+  );
+  await validate();
+  return true;
+}
+function matchesAcceptedState(state, config, head, snapshot, progress) {
+  return [true, false].some(
+    (canonical) => syncStateFingerprint(state) === syncStateFingerprint(acceptedState(config, head, snapshot, progress, canonical))
+  );
+}
+function acceptedState(config, head, snapshot, progress, canonical = true) {
+  if (progress) return progressState(config, head, snapshot, progress);
+  return {
+    version: 1,
+    profile: config.snapshotIdentity,
+    lastAppliedSnapshot: head.snapshotId,
+    lastRemoteRevision: head.revision,
+    lastFileHashes: fileHashMap(canonical ? portableSnapshot(snapshot, config.localFields) : snapshot),
+    include: [...config.include],
+    ...config.localFields !== void 0 ? { localFields: config.localFields } : {}
+  };
+}
+async function writeAcceptedState(config, head, snapshot, validate, progress) {
+  const accepted = portableSnapshot(snapshot, config.localFields);
+  const state = acceptedState(config, head, accepted, progress);
+  await stageMergeBaseline(config, accepted, state, progress?.previous);
+  await validate();
+  await writeStateForConfig(config, state);
+  await validate();
+}
+
+export {
+  confirmMergeReview,
+  formatDiff,
+  formatSnapshotOnlyDiff,
+  formatPushSummary,
+  formatPullSummary,
+  formatRollbackSummary,
+  countPreservedRemoteFiles,
+  publicationCapabilityDescription,
+  applySnapshot,
+  createSyncDecision,
+  mergeSync
+};
+//# sourceMappingURL=chunk-2GUXI2XT.ts.map