@narumitw/pi-sync 0.51.1 → 0.52.0

package/src/sync/sync-state.ts

@@ -8,6 +8,7 @@ import {
 } from "../snapshot/snapshot.js";
 import type { Snapshot } from "../snapshot/snapshot-types.js";
 import type { SyncState } from "../state/state-types.js";
+import { portableSnapshot, sameLocalFields } from "./local-fields.js";
 import {
   customIncludePathsByLower,
   includeFromSelectionConfig,
@@ -15,10 +16,13 @@ import {
   type SyncSelectionConfig,
 } from "./sync-policy.js";
 
-type SyncPolicyConfig = SyncSelectionConfig;
+type SyncPolicyConfig = SyncSelectionConfig & { localFields?: string[] };
 
 export function hasLocalChanges(local: Snapshot, state: SyncState, config: SyncPolicyConfig) {
-  return !sameHashes(fileHashMap(local), stateHashMapForConfig(state, config));
+  return (
+    (Boolean(state.lastAppliedSnapshot) && !sameLocalFields(state.localFields, config.localFields)) ||
+    !sameHashes(fileHashMap(portableSnapshot(local, config.localFields)), stateHashMapForConfig(state, config))
+  );
 }
 
 export function remoteChangedSinceState(
@@ -30,7 +34,7 @@ export function remoteChangedSinceState(
   if (!head) return Boolean(state.lastAppliedSnapshot);
   if (head.snapshotId !== state.lastAppliedSnapshot) return true;
   if (state.lastRemoteRevision && !sameRevision(head.revision, state.lastRemoteRevision)) return true;
-  if (syncIncludeChanged(state, config)) return true;
+  if (syncPolicyChanged(state, config)) return true;
   return (
     includeFromSelectionConfig(config).includes("sessions") && !state.include?.includes("sessions") && head.syncSessions
   );
@@ -43,7 +47,12 @@ export function hasRemoteChanges(
   ignoredPaths = new Set<string>(),
 ) {
   if (remote.id === state.lastAppliedSnapshot && !syncPolicyChanged(state, config)) return false;
-  return !snapshotHashesMatchState(filterSnapshotForConfigPolicy(remote, config), state, config, ignoredPaths);
+  return !snapshotHashesMatchState(
+    portableSnapshot(filterSnapshotForConfigPolicy(remote, config), remote.localFields),
+    state,
+    config,
+    ignoredPaths,
+  );
 }
 
 export function sameHashes(left: Record<string, string>, right: Record<string, string>) {
@@ -87,7 +96,7 @@ function withoutHashPaths(hashes: Record<string, string>, ignoredPaths: Set<stri
 }
 
 export function syncPolicyChanged(state: SyncState, config: SyncPolicyConfig) {
-  return syncIncludeChanged(state, config);
+  return syncIncludeChanged(state, config) || !sameLocalFields(state.localFields, config.localFields);
 }
 
 export function shouldRefreshSyncedState(

package/src/sync/text-merge.ts

@@ -0,0 +1,133 @@
+import path from "node:path";
+export const TEXT_LIMIT = 1024 * 1024;
+export const TEXT_MERGE_WORK_LIMIT = 8_000_000;
+export interface TextMergeBudget {
+  remaining: number;
+}
+export interface TextMergeOptions {
+  budget?: TextMergeBudget;
+  signal?: AbortSignal;
+}
+function charge(budget: TextMergeBudget, work: number) {
+  if (work > budget.remaining) throw new Error("Text merge operation complexity bound exceeded.");
+  budget.remaining -= work;
+}
+export function isMergeTextPath(filePath: string) {
+  return (
+    filePath === "AGENTS.md" ||
+    (/\.(?:md|txt)$/u.test(filePath) &&
+      ["prompts", "skills"].includes(filePath.split("/")[0] ?? "") &&
+      path.posix.basename(filePath) !== "keybindings.json")
+  );
+}
+export function text(bytes: Buffer) {
+  if (bytes.length > TEXT_LIMIT) throw new Error("Text merge bound exceeded.");
+  const decoded = bytes.toString("utf8");
+  if (
+    !Buffer.from(decoded).equals(bytes) ||
+    bytes.some((byte) => (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) || byte === 127)
+  )
+    throw new Error("Unsupported text encoding.");
+  return decoded;
+}
+type Hunk = { start: number; end: number; lines: string[] };
+function lines(value: string) {
+  return value.match(/[^\n]*\n|[^\n]+$/gu) ?? [];
+}
+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.
+  const ids = new Map<string, number>();
+  const intern = (line: string) => {
+    let id = ids.get(line);
+    if (id === undefined) {
+      id = ids.size;
+      ids.set(line, id);
+    }
+    return id;
+  };
+  const baseIds = base.map(intern);
+  const nextIds = next.map(intern);
+  const grid = new Uint32Array((base.length + 1) * width);
+  for (let i = base.length - 1; i >= 0; i--) {
+    signal?.throwIfAborted();
+    for (let j = next.length - 1; j >= 0; j--)
+      grid[i * width + j] =
+        baseIds[i] === nextIds[j]
+          ? 1 + (grid[(i + 1) * width + j + 1] ?? 0)
+          : Math.max(grid[(i + 1) * width + j] ?? 0, grid[i * width + j + 1] ?? 0);
+  }
+  const result: Hunk[] = [];
+  let i = 0;
+  let j = 0;
+  let active: Hunk | undefined;
+  while (i < base.length || j < next.length) {
+    if (i < base.length && j < next.length && baseIds[i] === nextIds[j]) {
+      if (active) {
+        result.push(active);
+        active = undefined;
+      }
+      i++;
+      j++;
+      continue;
+    }
+    active ??= { start: i, end: i, lines: [] };
+    if (j < next.length && (i === base.length || (grid[i * width + j + 1] ?? 0) >= (grid[(i + 1) * width + j] ?? 0)))
+      active.lines.push(next[j++] ?? "");
+    else active.end = ++i;
+  }
+  if (active) result.push(active);
+  return result;
+}
+export function mergeText(
+  baseBytes: Buffer,
+  localBytes: Buffer,
+  remoteBytes: Buffer,
+  options: TextMergeOptions = {},
+): Buffer | undefined {
+  const budget = options.budget ?? { remaining: TEXT_MERGE_WORK_LIMIT };
+  try {
+    options.signal?.throwIfAborted();
+    const base = lines(text(baseBytes));
+    const ours = lines(text(localBytes));
+    const theirs = lines(text(remoteBytes));
+    const cells = [ours, theirs].map((next) => (base.length + 1) * (next.length + 1));
+    if (cells.some((count) => count > 4_000_000)) return;
+    charge(budget, (cells[0] ?? 0) + (cells[1] ?? 0));
+    const local = edits(base, ours, options.signal);
+    const remote = edits(base, theirs, options.signal);
+    const combined = [...local];
+    for (const right of remote) {
+      let same = false;
+      for (const left of local) {
+        options.signal?.throwIfAborted();
+        charge(budget, 1);
+        if (left.start === right.start && left.end === right.end && left.lines.join("") === right.lines.join("")) {
+          same = true;
+          continue;
+        }
+        const overlap =
+          left.start === left.end || right.start === right.end
+            ? left.start <= right.end && right.start <= left.end
+            : left.start < right.end && right.start < left.end;
+        if (overlap) return;
+      }
+      if (!same) combined.push(right);
+    }
+    combined.sort((left, right) => left.start - right.start || left.end - right.end);
+    let cursor = 0;
+    const output: string[] = [];
+    for (const edit of combined) {
+      output.push(...base.slice(cursor, edit.start), ...edit.lines);
+      cursor = edit.end;
+    }
+    output.push(...base.slice(cursor));
+    const result = Buffer.from(output.join(""));
+    text(result);
+    return result;
+  } catch {
+    options.signal?.throwIfAborted();
+    return;
+  }
+}

package/src/sync-extension.ts

@@ -75,6 +75,14 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
     if (ready && !signal.aborted) check.start(ctx, signal, ready);
   });
 
+  pi.on("agent_start", async (_event, ctx) => {
+    await check.interrupt(ctx);
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (!sessionAbort.signal.aborted) check.settled(ctx);
+  });
+
   pi.on("session_shutdown", async (event, ctx) => {
     sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
     attention.reset(ctx);

package/src/ui/manager-state.ts

@@ -72,7 +72,11 @@ export async function describeManagerState(
     };
   }
   const configuredTargets = ownRecord(raw.syncSetups);
-  if (raw.version === 3 && configuredTargets && Object.keys(configuredTargets).length === 0) {
+  if (
+    (raw.version === 3 || raw.version === 4 || raw.version === 5) &&
+    configuredTargets &&
+    Object.keys(configuredTargets).length === 0
+  ) {
     return {
       title: [
         "Manage sync",
@@ -129,7 +133,14 @@ export async function describeManagerState(
       `Storage: ${backendStorageDescription(config)}`,
       `Included: ${selection.builtIns.length} built-in group${selection.builtIns.length === 1 ? "" : "s"} · ${selection.custom.length} extra path${selection.custom.length === 1 ? "" : "s"} · Sessions ${selection.sessions ? "on" : "off"}`,
       `Automatic sync: ${automaticSyncSummary(config.automatic)}`,
+      `Automatic transfer at startup: ${config.automaticTransfer ? "On — upload/replace/delete at idle; no reload" : "Off"}`,
       `Last applied: ${lastAppliedSnapshot}`,
+      ...(syncState?.unresolved?.length
+        ? [
+            `Unresolved: ${syncState.unresolved.length} dependency groups · review History & recovery`,
+            `Last observed: ${safeTerminalText(syncState.lastObservedSnapshot ?? "unknown")}`,
+          ]
+        : []),
       ...(currentAttention
         ? [
             currentAttention.decision.setupName === config.setupName

package/src/ui/manager-ui.ts

@@ -40,6 +40,7 @@ export async function showSyncManager(
     | "setups"
     | "connections"
     | "history"
+    | "conflicts"
     | "doctor"
     | "unlock"
     | "recover"
@@ -96,6 +97,7 @@ export async function showSyncManager(
         title: "History & recovery",
         items: [
           { id: "history", label: "Browse history", action: "history" },
+          { id: "conflicts", label: "Review unresolved conflicts", action: "conflicts" },
           {
             id: "doctor",
             label: "Check setup",
@@ -232,6 +234,14 @@ export async function showSyncManager(
         await runRoute("init");
         return { kind: "stay" };
       },
+      conflicts: async () => {
+        const result = await runCancellableOperation(ctx, "Reviewing private conflicts…", "conflicts", runRoute, {
+          commitAware: true,
+          signal: sessionSignal,
+        });
+        const disposition = await dispatchManagerResult(ctx, result, "sync", runRoute, sessionSignal);
+        return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
+      },
       back: async () => ({ kind: "back" }),
     },
   });

package/src/ui/merge-review.ts

@@ -0,0 +1,28 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { runDocumentReview } from "@narumitw/pi-tui-kit";
+
+/** Cell-exact scrolling in TUI and paginated observable confirmation in RPC. */
+export async function confirmMergeReview(
+  ctx: ExtensionCommandContext | ExtensionContext,
+  title: string,
+  content: string,
+  signal: AbortSignal | undefined,
+  isCurrent: () => boolean,
+  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";
+}

package/src/ui/remote-selection-ui.ts

@@ -239,6 +239,7 @@ async function showSelectionDifference(
             setupName: state.decision.setupName,
             include: [...state.decision.remoteInclude],
             automatic: review.config.automatic,
+            automaticTransfer: review.config.automaticTransfer,
             onSwitch: review.config.onSwitch,
             showStatus: review.config.showStatus,
           };

package/src/ui/settings-ui.ts

@@ -4,12 +4,14 @@ import { loadConfig } from "../settings/config.js";
 import { localConfigPath } from "../settings/config-file.js";
 import { updateSyncSetup } from "../settings/settings-management.js";
 import { updateLocalConfig } from "../settings/settings-store.js";
+import { normalizeLocalFields, sameLocalFields } from "../sync/local-fields.js";
 import {
   SETUP_SWITCH_ACTION_OPTIONS,
   saveOnSwitch,
   setupSwitchActionFromLabel,
   setupSwitchActionLabel,
 } from "../sync/setup-switch.js";
+import { captureMutationOwner } from "../sync/sync-local.js";
 import type { RunRoute } from "./cancellable-operation.js";
 import { dispatchManagerResult } from "./manager-result-dispatcher.js";
 import { AUTOMATIC_SYNC_DESCRIPTION } from "./setup/setup-prompts.js";
@@ -30,7 +32,17 @@ export async function showSyncSettings(
   const initial = await loadConfig();
   if (signal?.aborted) return;
   const setupName = initial.setupName;
-  type Action = "automatic" | "skip-secret-scan" | "show-status" | "on-switch" | "include" | "remote-include";
+  type Action =
+    | "automatic"
+    | "automatic-transfer"
+    | "merge-settings"
+    | "local-fields"
+    | "content-policy"
+    | "skip-secret-scan"
+    | "show-status"
+    | "on-switch"
+    | "include"
+    | "remote-include";
   const menu = defineMenu<Awaited<ReturnType<typeof loadConfig>>, "settings", Action, ExtensionCommandContext>({
     start: "settings",
     screens: {
@@ -87,10 +99,158 @@ export async function showSyncSettings(
             currentValue: "Review",
             action: "remote-include",
           },
+          {
+            id: "automaticTransfer",
+            label: "Automatic transfer at startup",
+            description:
+              "May upload, replace, or delete selected files once at idle startup in TUI/RPC. Requires a baseline and conditional/lease publication; never reloads resources. Turning off cancels pending work.",
+            currentValue: state.automaticTransfer ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "automatic-transfer",
+          },
+          {
+            id: "mergeSettings",
+            label: "Settings field merge (experimental)",
+            description:
+              "Combine independent global settings.json fields using a verified private ancestor; arrays and nested objects remain atomic. No reload.",
+            currentValue: state.mergeSettings ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "merge-settings",
+          },
+          {
+            id: "localFields",
+            label: "Machine-local settings fields",
+            description:
+              "Root field names omitted from future portable snapshots. Policy changes require directional migration; old history remains.",
+            currentValue: `${state.localFields?.length ?? 0} fields · Edit`,
+            action: "local-fields",
+          },
+          {
+            id: "contentPolicy",
+            label: "Content / partial sync (experimental)",
+            description:
+              "Version-5 opt-in: bounded text and prefix-only sessions; partial progress keeps full withheld versions and old baseline hashes.",
+            currentValue: state.mergeContent
+              ? state.partialSync
+                ? "Content & partial"
+                : "Content only"
+              : state.partialSync
+                ? "Partial only"
+                : "Off",
+            values: ["Off", "Content only", "Content & partial", "Partial only"],
+            action: "content-policy",
+          },
         ],
       }),
     },
     actions: {
+      "content-policy": async ({ value, signal: actionSignal }) => {
+        const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        const validate = captureMutationOwner(ctx, mutationSignal);
+        try {
+          const previous = await loadConfig(setupName);
+          validate();
+          const mergeContent = value === "Content only" || value === "Content & partial";
+          const partialSync = value === "Partial only" || value === "Content & partial";
+          if (
+            !(await ctx.ui.confirm(
+              "Save experimental content policy?",
+              "This explicitly upgrades settings to version 5; partial snapshots use version 3 and older clients must refuse them. Text/session merge is conservative. Partial sync preserves withheld versions and old baselines. Disabling does not clear unresolved groups or recovery evidence. Review a directional migration first if portable policy changes.",
+              { signal: mutationSignal },
+            ))
+          )
+            return { kind: "rejected" };
+          validate();
+          await updateLocalConfig((current) => {
+            validate();
+            const setup = current.syncSetups[setupName];
+            if (
+              !setup ||
+              Boolean(setup.sync.mergeContent) !== Boolean(previous.mergeContent) ||
+              Boolean(setup.sync.partialSync) !== Boolean(previous.partialSync)
+            )
+              throw new Error("Content policy changed during review.");
+            return {
+              ...current,
+              version: 5,
+              syncSetups: {
+                ...current.syncSetups,
+                [setupName]: { ...setup, sync: { ...setup.sync, mergeContent, partialSync } },
+              },
+            };
+          }, mutationSignal);
+          validate();
+          return { kind: "stay" };
+        } catch (error) {
+          if (!mutationSignal.aborted) notifySaveFailure(ctx, error);
+          return { kind: "rejected" };
+        }
+      },
+      "merge-settings": async ({ value, signal: actionSignal }) => {
+        const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        const validate = captureMutationOwner(ctx, mutationSignal);
+        try {
+          validate();
+          await updateSyncSetup(
+            setupName,
+            (setup) => ({ ...setup, sync: { ...setup.sync, mergeSettings: value === "On" } }),
+            { signal: mutationSignal },
+          );
+          validate();
+          return { kind: "stay" };
+        } catch (error) {
+          if (!mutationSignal.aborted) notifySaveFailure(ctx, error);
+          return { kind: "rejected" };
+        }
+      },
+      "local-fields": async ({ signal: actionSignal }) => {
+        const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        const validate = captureMutationOwner(ctx, mutationSignal);
+        try {
+          const previous = await loadConfig(setupName);
+          validate();
+          const input = await ctx.ui.input(
+            "Machine-local settings.json root fields (JSON string array)",
+            JSON.stringify(previous.localFields ?? []),
+            { signal: mutationSignal },
+          );
+          validate();
+          if (input === undefined) return { kind: "rejected" };
+          let fields: string[];
+          try {
+            fields = normalizeLocalFields(JSON.parse(input));
+          } catch {
+            throw new Error("Invalid localFields JSON array; no policy was changed.");
+          }
+          if (sameLocalFields(previous.localFields, fields)) return { kind: "stay" };
+          const confirmed = await ctx.ui.confirm(
+            "Save portable field policy?",
+            "This opts into settings/snapshot version 4/2; older clients must refuse them. Future snapshots omit these fields, but old remote history is NOT erased. Review an explicit force push/pull migration before further sync. Removed rules can expose or replace local-only values.",
+            { signal: mutationSignal },
+          );
+          validate();
+          if (!confirmed) return { kind: "rejected" };
+          await updateLocalConfig((current) => {
+            validate();
+            const setup = current.syncSetups[setupName];
+            if (!setup || !sameLocalFields(setup.sync.localFields, previous.localFields))
+              throw new Error("Field policy changed while under review; reopen settings.");
+            return {
+              ...current,
+              version: current.version === 5 ? 5 : 4,
+              syncSetups: {
+                ...current.syncSetups,
+                [setupName]: { ...setup, sync: { ...setup.sync, localFields: fields } },
+              },
+            };
+          }, mutationSignal);
+          validate();
+          return { kind: "stay" };
+        } catch (error) {
+          if (!mutationSignal.aborted) notifySaveFailure(ctx, error);
+          return { kind: "rejected" };
+        }
+      },
       automatic: async ({ value, signal: actionSignal }) => {
         const automatic = value === "On";
         const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
@@ -112,6 +272,24 @@ export async function showSyncSettings(
           return { kind: "rejected" };
         }
       },
+      "automatic-transfer": async ({ value, signal: actionSignal }) => {
+        const automaticTransfer = value === "On";
+        const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        try {
+          await updateSyncSetup(setupName, (setup) => ({ ...setup, sync: { ...setup.sync, automaticTransfer } }), {
+            signal: mutationSignal,
+          });
+          if (mutationSignal.aborted) return { kind: "rejected" };
+          ctx.ui.notify(
+            `Automatic startup transfer ${automaticTransfer ? "enabled for the next session start" : "disabled"}. Completed transfers are not undone.`,
+            "info",
+          );
+          return { kind: "stay" };
+        } catch (error) {
+          if (!mutationSignal.aborted) notifySaveFailure(ctx, error);
+          return { kind: "rejected" };
+        }
+      },
       "skip-secret-scan": async ({ value, signal: actionSignal }) => {
         const skipSecretScan = value === "On";
         const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
@@ -192,5 +370,8 @@ export async function showSyncSettings(
 }
 
 function notifySaveFailure(ctx: ExtensionCommandContext, error: unknown) {
-  ctx.ui.notify(`Pi Sync settings save failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+  ctx.ui.notify(
+    `Pi Sync settings save failed: ${safeTerminalText(error instanceof Error ? error.message : String(error))}`,
+    "error",
+  );
 }

package/src/ui/setup/setup-actions.ts

@@ -40,7 +40,7 @@ async function showAddTarget(ctx: ExtensionCommandContext, signal?: AbortSignal)
   let raw = await readLocalConfigObject();
   if (signal?.aborted) return;
   if (!raw) return void ctx.ui.notify("Set up the first sync setup before adding another.", "info");
-  if (raw.version !== 3) {
+  if (raw.version !== 3 && raw.version !== 4 && raw.version !== 5) {
     ctx.ui.notify("Version 1 and version 2 settings are unsupported and are never migrated.", "error");
     return;
   }
@@ -88,7 +88,7 @@ async function showEditTarget(ctx: ExtensionCommandContext, name: string, signal
   const partial = await loadPartialConfig(name);
   if (signal?.aborted) return;
   if (!partial.setupName) {
-    ctx.ui.notify("Create version 3 settings before editing a named sync setup.", "info");
+    ctx.ui.notify("Create supported pi-sync settings before editing a named sync setup.", "info");
     return;
   }
   if (partial.storageKind === "webdav") {

package/src/ui/setup/setup-switcher.ts

@@ -78,7 +78,7 @@ export async function showSetupSwitcher(
 ) {
   const raw = await readLocalConfigObject();
   if (signal?.aborted) return false;
-  if (raw?.version !== 3) {
+  if (raw?.version !== 3 && raw?.version !== 4 && raw?.version !== 5) {
     ctx.ui.notify("Add a second sync setup before switching setups.", "info");
     return false;
   }
@@ -128,6 +128,7 @@ export async function showSetupSwitcher(
       `Storage: ${backendStorageDescription(config)}`,
       `Included content: ${config.include.length} paths`,
       `Automatic sync: ${automaticSyncSummary(config.automatic)} · Sessions: ${config.include.includes("sessions") ? "On" : "Off"}`,
+      `Automatic transfer at startup: ${config.automaticTransfer ? "On — may upload, replace, or delete selected files; no reload" : "Off"}`,
       "",
       switchEffect,
     ].join("\n"),

package/src/ui/storage-connections-ui.ts

@@ -31,10 +31,10 @@ export async function showStorageConnections(ctx: ExtensionCommandContext, signa
         return {
           kind: "actions",
           title: "Storage connections",
-          lines: state.version3
+          lines: state.supportedVersion
             ? ["Server addresses and sign-in details, reusable across sync setups."]
-            : ["Create version 3 settings before managing storage connections."],
-          items: state.version3
+            : ["Create supported pi-sync settings before managing storage connections."],
+          items: state.supportedVersion
             ? [
                 { id: "add", label: "Add storage connection", action: "add" as const },
                 ...names.map((name, index) => {
@@ -136,11 +136,15 @@ async function loadStorageMenuState(selectedName: string | undefined, signal?: A
   const profiles = ownRecord(raw?.storageConnections) ?? {};
   const profile = selectedName ? ownRecord(profiles[selectedName]) : undefined;
   if (!selectedName || !profile) {
-    return { version3: raw?.version === 3, profiles, selected: undefined };
+    return {
+      supportedVersion: raw?.version === 3 || raw?.version === 4 || raw?.version === 5,
+      profiles,
+      selected: undefined,
+    };
   }
   const usedBy = referencingSetups(raw, selectedName);
   return {
-    version3: raw?.version === 3,
+    supportedVersion: raw?.version === 3 || raw?.version === 4 || raw?.version === 5,
     profiles,
     selected: {
       name: selectedName,
@@ -175,7 +179,7 @@ async function editStorageConnection(
 ) {
   if (ctx.mode !== "tui") {
     ctx.ui.notify(
-      "Editing storage connections requires TUI mode for safe credential handling. Edit the private version 3 settings file instead.",
+      "Editing storage connections requires TUI mode for safe credential handling. Edit the private pi-sync settings file instead.",
       "warning",
     );
     return;
@@ -250,7 +254,7 @@ async function editStorageConnection(
 export async function showAddStorageConnection(ctx: ExtensionCommandContext, signal?: AbortSignal) {
   if (ctx.mode !== "tui") {
     ctx.ui.notify(
-      "Adding storage connections requires TUI mode for safe credential handling. Edit the private version 3 settings file instead.",
+      "Adding storage connections requires TUI mode for safe credential handling. Edit the private pi-sync settings file instead.",
       "warning",
     );
     return false;

package/src/ui/sync-attention.ts

@@ -153,6 +153,8 @@ export function observationSummary(observation: StartupObservation) {
   if (result.firstSync)
     return result.head ? "No sync baseline; review remote and local content" : "Remote empty; no sync baseline";
   if (!result.head) return "Remote snapshot missing; review needed";
+  if (observation.automaticTransfer && result.selectionState?.kind === "legacy")
+    return "Legacy remote has no authoritative content list; review /sync and choose an explicit direction to adopt policy";
   if (result.localChanged && result.remoteChanged) return "Local and remote changed since last sync; review needed";
   if (result.remoteChanged) return "Remote changed since last sync";
   if (result.localChanged) return "Local content changed since last sync";
@@ -171,6 +173,7 @@ export function classifyObservation(observation: StartupObservation): Observatio
   if (result.selectionState?.kind === "different") return "review";
   if (result.firstSync) return result.head ? "review" : "guidance";
   if (!result.head || (result.localChanged && result.remoteChanged)) return "review";
+  if (observation.automaticTransfer && result.selectionState?.kind === "legacy") return "review";
   if (result.localChanged || result.remoteChanged) return "status";
   // Legacy metadata alone requires no scope confirmation in transfer operations.
   return "none";