@narumitw/pi-sync 0.54.2 → 0.56.0

package/src/sync/settings-merge.ts

@@ -10,7 +10,7 @@ export type SettingsMergeResult =
   | { kind: "merged"; content: Buffer }
   | { kind: "review"; reason: "unsupported-format" | "field-conflict"; fields: string[] };
 
-const COUPLED_FIELDS = [
+export const COUPLED_FIELDS = [
   ["defaultProvider", "defaultModel"],
   ["queueMode", "steeringMode"],
   ["websockets", "transport"],
@@ -19,7 +19,12 @@ const COUPLED_FIELDS = [
 ] as const;
 
 /** Only global settings.json; objects/arrays are atomic units until their invariants are proven. */
-export function mergeSettingsJson(ancestor: Buffer, local: Buffer, remote: Buffer): SettingsMergeResult {
+export function mergeSettingsJson(
+  ancestor: Buffer,
+  local: Buffer,
+  remote: Buffer,
+  selections: ReadonlyMap<string, "local" | "remote"> = new Map(),
+): SettingsMergeResult {
   let documents: JsonDocument[];
   try {
     documents = [ancestor, local, remote].map(parseSettingsDocument);
@@ -38,7 +43,18 @@ export function mergeSettingsJson(ancestor: Buffer, local: Buffer, remote: Buffe
       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 : undefined;
+    const choice = selections.get(unit[0] ?? "");
+    const source = equal(left, right)
+      ? left
+      : equal(left, base)
+        ? right
+        : equal(right, base)
+          ? left
+          : choice === "local"
+            ? left
+            : choice === "remote"
+              ? right
+              : undefined;
     if (!source) {
       conflicts.push(...unit.filter((field) => fields.has(field)));
       continue;

package/src/sync/setup-switch.ts

@@ -5,6 +5,7 @@ import { configuredSyncSetupNames, updateLocalConfig } from "../settings/setting
 import type { OnSwitchAction } from "../settings/settings-types.js";
 import { normalizeOnSwitch } from "../settings/settings-validation.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
+import { throwIfAborted } from "./signals.js";
 import { SetupPullRequiresUiError } from "./sync-errors.js";
 
 export { SetupPullRequiresUiError } from "./sync-errors.js";
@@ -128,8 +129,3 @@ export async function useSyncSetup(
   }
   return { pullApplied: pullOutcome === "applied" };
 }
-
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}

package/src/sync/startup-check.ts

@@ -9,7 +9,10 @@ import { readStateForConfig, syncStateFingerprint } from "../state/sync-state-st
 import type { SyncAttentionController } from "../ui/sync-attention.js";
 import { setSyncStatus } from "../ui/sync-status.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
+import { startupTransferEnabled } from "./agent-policy.js";
+import { withAgentSyncLock } from "./agent-sync.js";
 import { combineSignals, throwIfAborted } from "./signals.js";
+import { createStartupTimings } from "./startup-timings.js";
 import { errorMessage } from "./sync-errors.js";
 import type { SyncLoaders } from "./sync-loaders.js";
 
@@ -41,18 +44,19 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
     },
     start(ctx: ExtensionContext, sessionSignal: AbortSignal, initialConfig?: AnySyncConfig) {
       if (!ctx.hasUI || sessionSignal.aborted) return;
-      if (initialConfig?.automaticTransfer && !ctx.isIdle()) {
+      if (initialConfig && startupTransferEnabled(initialConfig) && !ctx.isIdle()) {
         pending = { ctx, signal: sessionSignal, config: initialConfig };
         return;
       }
       if (active) throw new Error("Previous startup check has not been drained.");
+      const timings = createStartupTimings();
       const controller = new AbortController();
       const signal = combineSignals(sessionSignal, controller.signal);
       const task = {
         controller,
         owner: ctx.sessionManager,
         promise: Promise.resolve(),
-        transfer: Boolean(initialConfig?.automaticTransfer),
+        transfer: Boolean(initialConfig && startupTransferEnabled(initialConfig)),
       };
       active = task;
       const isCurrent = () => !sessionSignal.aborted && active === task && task.owner === ctx.sessionManager;
@@ -62,33 +66,36 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
       );
       let config: AnySyncConfig | undefined;
       let checking = false;
+      let stopped = false;
       // Handle every detached rejection here; Pi's awaited event runner cannot catch it.
       task.promise = Promise.resolve()
         .then(async () => {
           try {
             throwIfAborted(signal);
             config = initialConfig ?? (await loadConfigForCheck());
-            task.transfer = Boolean(config.automaticTransfer);
+            task.transfer = startupTransferEnabled(config);
             throwIfAborted(signal);
-            if (!config.automatic && !config.automaticTransfer) return;
+            if (!config.automatic && !startupTransferEnabled(config)) return;
             const captured = config;
             const identity = syncCheckConfigFingerprint(captured);
             checking = true;
             setSyncStatus(ctx, "sync ...");
-            const { inspectSync } = await loaders.inspection();
+            const { inspectSync } = await timings.measure("inspection import", () => loaders.inspection());
             throwIfAborted(signal);
             const currentConfig = await loadConfigForCheck();
             throwIfAborted(signal);
             if (syncCheckConfigFingerprint(currentConfig) !== identity) return;
             // Lock order: state migration guard → sync operation → backend cache.
             // Read heads may write only private cache data. Never call doctor/syncBoth.
-            const inspection = await withStateDirectoryAccess(() => {
-              throwIfAborted(signal);
-              return withLock("startup-check", () => {
+            const inspection = await timings.measure("inspection and guards", () =>
+              withStateDirectoryAccess(() => {
                 throwIfAborted(signal);
-                return inspectSync(captured, snapshotOptionsForContext(ctx, captured), signal);
-              });
-            });
+                return withLock("startup-check", () => {
+                  throwIfAborted(signal);
+                  return inspectSync(captured, snapshotOptionsForContext(ctx, captured), signal, undefined, timings);
+                });
+              }),
+            );
             throwIfAborted(signal);
             const latest = await loadConfigForCheck();
             throwIfAborted(signal);
@@ -101,34 +108,39 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
               configIdentity: identity,
               checkedAt: new Date().toISOString(),
               inspection,
-              automaticTransfer: captured.automaticTransfer,
+              automaticTransfer: startupTransferEnabled(captured),
             });
             if (
-              captured.automaticTransfer &&
+              startupTransferEnabled(captured) &&
               !inspection.firstSync &&
               inspection.head &&
               inspection.selectionState?.kind === "same"
             ) {
-              const operations = await loaders.operations();
+              const operations = await timings.measure("operations import", () => loaders.operations());
               throwIfAborted(signal);
               if (!isCurrent()) return;
               if (!ctx.isIdle()) {
                 pending = { ctx, signal: sessionSignal, config: captured };
                 return;
               }
-              await withStateDirectoryAccess(() =>
-                withLock("startup-transfer", () =>
-                  operations.syncBoth(ctx, {
-                    args: [],
-                    yes: true,
-                    force: false,
-                    stale: false,
-                    silent: true,
-                    reload: false,
-                    auto: true,
-                    signal,
-                    onCommit: () => attention.clearObservation(),
-                  }),
+              await timings.measure("automatic transfer", () =>
+                withStateDirectoryAccess(() =>
+                  withAgentSyncLock(
+                    ctx,
+                    {
+                      args: [],
+                      yes: true,
+                      force: false,
+                      stale: false,
+                      silent: true,
+                      reload: false,
+                      auto: true,
+                      signal,
+                      startupTimings: timings,
+                      onCommit: () => attention.clearObservation(),
+                    },
+                    (options) => operations.syncBoth(ctx, options),
+                  ),
                 ),
               );
               throwIfAborted(signal);
@@ -141,10 +153,11 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
               configIdentity: identity,
               checkedAt: new Date().toISOString(),
               inspection,
-              automaticTransfer: captured.automaticTransfer,
+              automaticTransfer: startupTransferEnabled(captured),
             });
             if (ctx.mode === "rpc") attention.notifyObservation(ctx);
           } catch (error) {
+            stopped = true;
             if (!isCurrent() || sessionSignal.aborted || isMissingConfigError(error)) return;
             if (signal.aborted && controller.signal.reason?.name !== "TimeoutError") return;
             // A settings edit invalidates failures as well as successful observations.
@@ -154,7 +167,7 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
               if (!latest || syncCheckConfigFingerprint(latest) !== syncCheckConfigFingerprint(config)) return;
             }
             ctx.ui.notify(
-              config?.automaticTransfer
+              config && startupTransferEnabled(config)
                 ? `pi-sync automatic transfer stopped: ${safeTerminalText(errorMessage(error))}. Run /sync to review or reconcile retained recovery evidence. No resources were reloaded.`
                 : `pi-sync startup check skipped: ${safeTerminalText(errorMessage(error))}. Run /sync status to retry. No startup transfer was performed.`,
               "warning",
@@ -177,6 +190,15 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
                 }
               } else setSyncStatus(ctx, undefined);
             }
+            if (isCurrent()) {
+              timings.publish(
+                ctx,
+                config?.debug ?? false,
+                sessionSignal,
+                "background startup",
+                signal.aborted || stopped ? "stopped" : "completed",
+              );
+            }
             if (active === task) active = undefined;
           }
         })

package/src/sync/startup-timings.ts

@@ -0,0 +1,90 @@
+import { performance } from "node:perf_hooks";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+type StartupStage =
+  | "transaction recovery"
+  | "settings read"
+  | "config resolution"
+  | "inspection import"
+  | "inspection and guards"
+  | "backend initialization"
+  | "local snapshot"
+  | "sync state read"
+  | "remote head"
+  | "operations import"
+  | "automatic transfer"
+  | "transfer authorization"
+  | "transfer backend initialization"
+  | "transfer journal read"
+  | "transfer journal recovery"
+  | "transfer state read"
+  | "transfer local snapshot"
+  | "transfer remote head"
+  | "transfer snapshot download"
+  | "transfer unchanged verification"
+  | "transfer merge planning"
+  | "transfer settings merge"
+  | "transfer content merge"
+  | "transfer preflight"
+  | "transfer backup"
+  | "transfer journal write"
+  | "transfer remote publication"
+  | "transfer local apply"
+  | "transfer baseline write"
+  | "transfer cleanup";
+
+/** Fixed labels and durations only: never retain errors, paths, settings, or payloads. */
+export function createStartupTimings() {
+  const started = performance.now();
+  const stages = new Map<StartupStage, { ms: number; calls: number; interrupted: boolean }>();
+  let unchanged = false;
+  return {
+    markUnchanged() {
+      unchanged = true;
+    },
+    async measure<T>(stage: StartupStage, run: () => T | Promise<T>): Promise<T> {
+      const start = performance.now();
+      let completed = false;
+      try {
+        const result = await run();
+        completed = true;
+        return result;
+      } finally {
+        const previous = stages.get(stage);
+        stages.set(stage, {
+          ms: (previous?.ms ?? 0) + performance.now() - start,
+          calls: (previous?.calls ?? 0) + 1,
+          interrupted: Boolean(previous?.interrupted || !completed),
+        });
+      }
+    },
+    publish(
+      ctx: ExtensionContext,
+      enabled: boolean,
+      sessionSignal: AbortSignal,
+      scope: "local initialization" | "background startup",
+      outcome: "completed" | "stopped" = "completed",
+    ) {
+      if (!enabled || !ctx.hasUI || sessionSignal.aborted) return;
+      try {
+        ctx.ui.notify(
+          [
+            `pi-sync debug: ${scope} (${outcome})`,
+            ...Array.from(
+              stages,
+              ([stage, value]) =>
+                `${stage}: ${value.ms.toFixed(1)} ms${value.calls > 1 ? ` (${value.calls} calls)` : ""}${value.interrupted ? " (interrupted)" : ""}`,
+            ),
+            ...(unchanged ? ["transfer result: unchanged (fast path)"] : []),
+            `total: ${(performance.now() - started).toFixed(1)} ms`,
+          ].join("\n"),
+          "info",
+        );
+      } catch {
+        // Diagnostics must not change sync behavior if the UI is unavailable during teardown.
+      }
+    },
+  };
+}
+
+export type StartupTimings = ReturnType<typeof createStartupTimings>;

package/src/sync/sync-inspection.ts

@@ -1,11 +1,13 @@
+import { createHash } from "node:crypto";
 import { createSyncBackend, type SyncBackendFactory } from "../backends/backend-factory.js";
 import type { AnySyncConfig } from "../settings/settings-types.js";
 import { createSnapshot } from "../snapshot/snapshot.js";
 import type { SnapshotOptions } from "../snapshot/snapshot-types.js";
 import { readStateForConfig, syncStateFingerprint } from "../state/sync-state-store.js";
 import { throwIfAborted } from "./signals.js";
+import { createStartupTimings, type StartupTimings } from "./startup-timings.js";
 import { inspectRemoteSelection } from "./sync-policy.js";
-import { hasLocalChanges, remoteChangedSinceState } from "./sync-state.js";
+import { fileHashMap, hasLocalChanges, remoteChangedSinceState } from "./sync-state.js";
 
 /** Advisory baseline-relative observation, never an authorization to transfer files. */
 export async function inspectSync(
@@ -13,17 +15,26 @@ export async function inspectSync(
   options: SnapshotOptions,
   signal?: AbortSignal,
   factory: SyncBackendFactory = createSyncBackend,
+  timings: StartupTimings = createStartupTimings(),
 ) {
   throwIfAborted(signal);
-  const backend = await factory(config);
+  const backend = await timings.measure("backend initialization", () => factory(config));
   throwIfAborted(signal);
-  const local = await createSnapshot(config.snapshotIdentity, { ...options, signal });
+  const local = await timings.measure("local snapshot", () =>
+    createSnapshot(config.snapshotIdentity, { ...options, signal }),
+  );
   throwIfAborted(signal);
-  const state = await readStateForConfig(config);
+  const state = await timings.measure("sync state read", () => readStateForConfig(config));
   throwIfAborted(signal);
-  const head = await backend.readHead(signal);
+  const head = await timings.measure("remote head", () => backend.readHead(signal));
   throwIfAborted(signal);
+  const freshness: { localIdentity?: string } = {
+    localIdentity: createHash("sha256")
+      .update(JSON.stringify(fileHashMap(local)))
+      .digest("hex"),
+  };
   return {
+    ...freshness,
     head,
     selectionState: head ? inspectRemoteSelection(config.include, { selection: head.selection, files: [] }) : undefined,
     localFiles: local.files.length,

package/src/sync/sync-mutations.ts

@@ -23,7 +23,7 @@ import { applySnapshot } from "../snapshot/snapshot-apply.js";
 import type { Snapshot } from "../snapshot/snapshot-types.js";
 import { pruneMergeBaselines } from "../state/merge-baseline-store.js";
 import type { SyncState } from "../state/state-types.js";
-import { readStateForConfig, writeStateForConfig } from "../state/sync-state-store.js";
+import { readStateForConfig, syncStateFingerprint, writeStateForConfig } from "../state/sync-state-store.js";
 import {
   countPreservedRemoteFiles,
   formatPullSummary,
@@ -31,6 +31,9 @@ import {
   formatRollbackSummary,
 } from "../ui/sync-format.js";
 import { setSyncStatus } from "../ui/sync-status.js";
+import { confirmTransferReview } from "../ui/transfer-review.js";
+import { startupTransferEnabled } from "./agent-policy.js";
+import { inspectCaseCleanup, revalidateCaseCleanup } from "./apply-review.js";
 import { confirmFieldMigration } from "./field-migration.js";
 import { overlayLocalFields, portableSnapshot, sameLocalFields, validatePortableSnapshot } from "./local-fields.js";
 import { readMergeJournal, requireNoMergeJournal, retireMergeJournal } from "./merge-journal.js";
@@ -155,7 +158,7 @@ export async function push(
     }
   }
 
-  if (!remoteForUpload && head && config.localFields !== undefined)
+  if (!remoteForUpload && head && (config.localFields !== undefined || !options.yes))
     remoteForUpload = await readSnapshotForHead(backend, head, options.signal);
   if (!(await confirmFieldMigration(ctx, config, state, remoteForUpload, options.force, options.signal))) {
     setSyncStatus(ctx, undefined);
@@ -208,12 +211,15 @@ export async function push(
   if (configIdentity !== syncCheckConfigFingerprint(await loadConfig(options.setup)))
     throw new Error("Settings changed during push review.");
   validateMutation();
-  if (config.localFields !== undefined || (await readMergeJournal(config))) {
+  if (!options.yes || config.localFields !== undefined || (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.");
+      throw new Error("Local content changed during push review; retry from current bytes.");
   }
-  requireResolvedDirectionalProgress(await readStateForConfig(config), options);
+  const currentState = await readStateForConfig(config);
+  if (!options.yes && syncStateFingerprint(currentState) !== syncStateFingerprint(state))
+    throw new Error("Baseline changed during push review.");
+  requireResolvedDirectionalProgress(currentState, options);
   validateMutation();
   const result = await backend.publishSnapshot(upload, expectedRemoteHead(head), {
     signal: options.signal,
@@ -316,11 +322,23 @@ export async function pull(
     });
   }
 
+  const caseCleanup = options.yes ? [] : await inspectCaseCleanup(physical, options.signal);
+  validateMutation();
   if (
     !options.yes &&
-    !(await ctx.ui.confirm(
+    !(await confirmTransferReview(
+      ctx,
       snapshotIncludesSessions(remote) ? "Pull pi settings and sessions?" : "Pull pi settings?",
-      formatPullSummary(config, backend.destination, local, physical, protectedSessionPaths(ctx).size),
+      formatPullSummary(
+        config,
+        backend.destination,
+        local,
+        physical,
+        protectedSessionPaths(ctx),
+        caseCleanup.map((item) => item.path),
+      ),
+      options.signal,
+      validateMutation,
     ))
   ) {
     setSyncStatus(ctx, undefined);
@@ -353,7 +371,11 @@ export async function pull(
   const backup = await backupLocal(config.snapshotIdentity, snapshotOptionsForContext(ctx, config), options.signal);
   const applySessionDir = await sessionDirForApply(ctx, physical);
   if (recoveringMerge) await requireFreshRecovery();
-  requireResolvedDirectionalProgress(await readStateForConfig(config), options);
+  const currentState = await readStateForConfig(config);
+  if (!options.yes && syncStateFingerprint(currentState) !== syncStateFingerprint(state))
+    throw new Error("Baseline changed during pull review.");
+  requireResolvedDirectionalProgress(currentState, options);
+  if (!options.yes) await revalidateCaseCleanup(caseCleanup, physical, options.signal);
   validateMutation();
   options.onCommit?.();
   const lastFileHashes = await applySnapshot(physical, protectedSessionPaths(ctx), {
@@ -408,7 +430,9 @@ export async function syncBoth(
   const validateMutation = captureMutationOwner(ctx, options.signal);
   const config = await loadConfig(options.setup);
   throwIfAborted(options.signal);
-  if (config.include.length > 0 && options.auto && config.automaticTransfer) return mergeSync(ctx, options, factory);
+  options.background?.validate(config);
+  if (config.include.length > 0 && options.auto && startupTransferEnabled(config))
+    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);
@@ -430,15 +454,13 @@ export async function syncBoth(
   throwIfAborted(options.signal);
   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.");
 
+  // Established baselines return through mergeSync above; only initial-source selection remains.
   const portableLocal = portableSnapshot(local, config.localFields);
   const acceptMatchingState = async (snapshot: 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,
       {
@@ -456,7 +478,7 @@ export async function syncBoth(
     await pruneMergeBaselines(config, await readStateForConfig(config), validateMutation);
     validateMutation();
   };
-  if (firstSync && remote && remote.files.length > 0 && local.files.length > 0) {
+  if (remote && remote.files.length > 0 && local.files.length > 0) {
     requireCompatibleRemoteSelection(config, remote);
     const portableRemote = portableSnapshot(remote, config.localFields);
     if (!canPullRemoteSettingsOnFirstSync(portableLocal, portableRemote)) {
@@ -504,18 +526,6 @@ export async function syncBoth(
     if (!options.silent) ctx.ui.notify("pi-sync is already up to date.", "info");
     return;
   }
-  if (localChanged && remoteChanged && state.lastAppliedSnapshot) {
-    throw createSyncDecision({
-      kind: "both-changed",
-      config,
-      state,
-      local,
-      remote,
-      localChanged,
-      remoteChanged,
-      directMessage: "Both local and remote changed. Run /sync diff and resolve with push --force or pull --force.",
-    });
-  }
   if (remoteChanged) {
     await pull(ctx, options, factory);
     return;
@@ -573,11 +583,21 @@ export async function rollback(
   if (!(await confirmFieldMigration(ctx, config, state, currentRemote, true, options.signal))) return;
   validateMutation();
   const physical = overlayLocalFields(remote, local, config.localFields);
+  const caseCleanup = options.yes ? [] : await inspectCaseCleanup(physical, options.signal);
+  validateMutation();
 
   if (!options.yes) {
     const confirmed = await ctx.ui.confirm(
       snapshotIncludesSessions(remote) ? "Rollback pi settings and sessions?" : "Rollback pi settings?",
-      formatRollbackSummary(config, backend.destination, local, physical, target, protectedSessionPaths(ctx).size),
+      formatRollbackSummary(
+        config,
+        backend.destination,
+        local,
+        physical,
+        target,
+        protectedSessionPaths(ctx),
+        caseCleanup.map((item) => item.path),
+      ),
       { signal: options.signal },
     );
     validateMutation();
@@ -599,7 +619,11 @@ export async function rollback(
   throwIfAborted(options.signal);
   const backup = await backupLocal(config.snapshotIdentity, snapshotOptionsForContext(ctx, config), options.signal);
   const applySessionDir = await sessionDirForApply(ctx, remote);
-  requireResolvedDirectionalProgress(await readStateForConfig(config), options, false);
+  const currentState = await readStateForConfig(config);
+  if (!options.yes && syncStateFingerprint(currentState) !== syncStateFingerprint(state))
+    throw new Error("Baseline changed during rollback review.");
+  requireResolvedDirectionalProgress(currentState, options, false);
+  if (!options.yes) await revalidateCaseCleanup(caseCleanup, physical, options.signal);
   validateMutation();
   options.onCommit?.();
   const lastFileHashes = await applySnapshot(physical, protectedSessionPaths(ctx), {
@@ -724,9 +748,12 @@ async function confirmPush(
 ) {
   throwIfAborted(options.signal);
   if (options.yes) return true;
-  const confirmed = await ctx.ui.confirm(
+  const confirmed = await confirmTransferReview(
+    ctx,
     title,
     formatPushSummary(config, backend.destination, upload, head, countPreservedRemoteFiles(local, upload), remote),
+    options.signal,
+    captureMutationOwner(ctx, options.signal),
   );
   throwIfAborted(options.signal);
   if (confirmed) return true;

package/src/sync/sync-queries.ts

@@ -7,6 +7,7 @@ import { snapshotOptionsForContext } from "../snapshot/session-paths.js";
 import { createSnapshot, scanSnapshot } from "../snapshot/snapshot.js";
 import type { SnapshotOptions } from "../snapshot/snapshot-types.js";
 import { inspectLock, isLockGuardHeld, isStaleLock, withLock } from "../state/lock.js";
+import { readStateForConfig } from "../state/sync-state-store.js";
 import { formatDiff, formatSnapshotOnlyDiff, publicationCapabilityDescription } from "../ui/sync-format.js";
 import { setSyncStatus } from "../ui/sync-status.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
@@ -35,6 +36,10 @@ export async function status(
   );
   throwIfAborted(options.signal);
 
+  const continuous = config.continuous
+    ? await (await import("./continuous-record.js")).continuousStatusLines(config)
+    : [];
+  throwIfAborted(options.signal);
   const remoteText = head ? `remote: ${head.snapshotId} from ${head.machine} at ${head.createdAt}` : "remote: empty";
   const warnings = syncSessionsWarnings(config);
   setSyncStatus(ctx, undefined);
@@ -46,6 +51,7 @@ export async function status(
       `publication safety: ${publicationCapabilityDescription(capability)}`,
       `included content: ${config.include.join(", ") || "none"}`,
       `sessions: ${config.include.includes("sessions") ? "included" : "excluded"}`,
+      ...continuous,
       remoteText,
       formatRemoteSelectionStatus(selectionState),
       `local files: ${localFiles}`,
@@ -185,8 +191,15 @@ export async function history(
   const backend = await factory(config);
   const snapshots = (await backend.listHistory(options.signal)).slice(-20).reverse();
   throwIfAborted(options.signal);
+  const lastApplied = await readStateForConfig(config)
+    .then((state) => state.lastAppliedSnapshot)
+    .catch(() => undefined);
+  throwIfAborted(options.signal);
+  const appliedDetails = lastApplied
+    ? `Last applied snapshot ID: ${safeTerminalText(lastApplied)}\nApplication time: unavailable. Snapshot dates are creation times.`
+    : "Last applied snapshot ID: unavailable.";
   if (snapshots.length === 0) {
-    ctx.ui.notify("No remote pi-sync history found.", "info");
+    ctx.ui.notify(`No remote pi-sync history found.\n${appliedDetails}`, "info");
     return;
   }
 
@@ -197,7 +210,7 @@ export async function history(
         `${index + 1}. ${item.createdAt} · ${safeTerminalText(item.machine)} · ${item.snapshotId}${item.snapshotId === currentSnapshot ? " (current)" : ""}${item.syncSessions ? " · sessions" : ""}`,
     );
     const selected = await ctx.ui.select(
-      `History for sync setup “${safeTerminalText(config.setupName)}”\n\nChoose a snapshot to preview rollback.`,
+      `History for sync setup “${safeTerminalText(config.setupName)}”\n\n${appliedDetails}\n\nChoose a snapshot to preview rollback.`,
       [...labels, "Back"],
       { signal: options.signal },
     );
@@ -215,7 +228,10 @@ export async function history(
     return;
   }
   ctx.ui.notify(
-    snapshots.map((item) => `${item.snapshotRef} ${item.createdAt} ${safeTerminalText(item.machine)}`).join("\n"),
+    [
+      appliedDetails,
+      ...snapshots.map((item) => `${item.snapshotRef} ${item.createdAt} ${safeTerminalText(item.machine)}`),
+    ].join("\n"),
     "info",
   );
 }

package/src/sync/text-merge.ts

@@ -30,11 +30,11 @@ export function text(bytes: Buffer) {
     throw new Error("Unsupported text encoding.");
   return decoded;
 }
-type Hunk = { start: number; end: number; lines: string[] };
-function lines(value: string) {
+export type Hunk = { start: number; end: number; lines: string[] };
+export function lines(value: string) {
   return value.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
 }
-function edits(base: string[], next: string[], signal?: AbortSignal): Hunk[] {
+export function edits(base: string[], next: string[], signal?: AbortSignal): Hunk[] {
   const width = next.length + 1;
   if ((base.length + 1) * width > 4_000_000) throw new Error("Text merge complexity bound exceeded.");
   // Intern once so each charged DP cell compares fixed-size IDs, not long line strings.