@narumitw/pi-sync 0.57.9 → 0.57.11

package/src/sync/mutation-owner.ts

@@ -0,0 +1,22 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { agentDir } from "../snapshot/session-paths.js";
+import { throwIfAborted } from "./signals.js";
+
+export function captureMutationOwner(ctx: ExtensionContext | ExtensionCommandContext, signal?: AbortSignal) {
+  const manager = ctx.sessionManager;
+  const file = manager.getSessionFile?.();
+  const id = manager.getSessionId?.();
+  const cwd = manager.getCwd?.();
+  const root = agentDir();
+  return () => {
+    throwIfAborted(signal);
+    if (
+      ctx.sessionManager !== manager ||
+      manager.getSessionFile?.() !== file ||
+      manager.getSessionId?.() !== id ||
+      manager.getCwd?.() !== cwd ||
+      agentDir() !== root
+    )
+      throw new Error("Session changed during file mutation; evidence retained for review.");
+  };
+}

package/src/sync/startup-check.ts

@@ -10,7 +10,6 @@ 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, type StartupTimingPublisher } from "./startup-timings.js";
 import { errorMessage } from "./sync-errors.js";
@@ -122,7 +121,9 @@ export function createStartupCheck(
               inspection.head &&
               inspection.selectionState?.kind === "same"
             ) {
-              const operations = await timings.measure("operations import", () => loaders.operations());
+              const [operations, { withAgentSyncLock }] = await timings.measure("operations import", () =>
+                Promise.all([loaders.operations(), import("./agent-sync.js")]),
+              );
               throwIfAborted(signal);
               if (!isCurrent()) return;
               if (!ctx.isIdle()) {

package/src/sync/sync-loaders.ts

@@ -2,10 +2,12 @@ type SetupSwitchModule = Pick<typeof import("./setup-switch.js"), "useSyncSetup"
 type SnapshotModule = Pick<typeof import("../snapshot/snapshot.js"), "createSnapshot">;
 type SyncStateModule = Pick<typeof import("./sync-state.js"), "hasLocalChanges">;
 type SyncOperations = typeof import("./sync-operations.js");
+type CommandHandlerModule = Pick<typeof import("../commands/command-handler.js"), "handleCommand">;
 
 type SyncInspectionModule = Pick<typeof import("./sync-inspection.js"), "inspectSync">;
 
 export interface SyncDependencies {
+  loadCommandHandler(): Promise<CommandHandlerModule>;
   loadSyncInspection(): Promise<SyncInspectionModule>;
   loadSetupSwitch(): Promise<SetupSwitchModule>;
   loadSnapshot(): Promise<SnapshotModule>;
@@ -14,6 +16,7 @@ export interface SyncDependencies {
 }
 
 export interface SyncLoaders {
+  commands(): Promise<CommandHandlerModule>;
   inspection(): Promise<SyncInspectionModule>;
   setupSwitch(): Promise<SetupSwitchModule>;
   snapshot(): Promise<SnapshotModule>;
@@ -23,6 +26,7 @@ export interface SyncLoaders {
 
 export function createSyncLoaders(dependencies: Partial<SyncDependencies>): SyncLoaders {
   const loaders: SyncLoaders = {
+    commands: cachedModuleLoader(dependencies.loadCommandHandler ?? (() => import("../commands/command-handler.js"))),
     inspection: cachedModuleLoader(dependencies.loadSyncInspection ?? (() => import("./sync-inspection.js"))),
     setupSwitch: cachedModuleLoader(dependencies.loadSetupSwitch ?? (() => import("./setup-switch.js"))),
     snapshot: cachedModuleLoader(dependencies.loadSnapshot ?? (() => import("../snapshot/snapshot.js"))),

package/src/sync/sync-local.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { agentDir, sessionDirFromContext } from "../snapshot/session-paths.js";
+import { sessionDirFromContext } from "../snapshot/session-paths.js";
 import { createSnapshot, sessionSnapshotPathFromAbsolute } from "../snapshot/snapshot.js";
 import { encodeSnapshot } from "../snapshot/snapshot-codec.js";
 import type { SnapshotOptions } from "../snapshot/snapshot-types.js";
@@ -20,24 +20,7 @@ export function protectedSessionPaths(
   return snapshotPath ? new Set([snapshotPath]) : new Set<string>();
 }
 
-export function captureMutationOwner(ctx: ExtensionContext | ExtensionCommandContext, signal?: AbortSignal) {
-  const manager = ctx.sessionManager;
-  const file = manager.getSessionFile?.();
-  const id = manager.getSessionId?.();
-  const cwd = manager.getCwd?.();
-  const root = agentDir();
-  return () => {
-    throwIfAborted(signal);
-    if (
-      ctx.sessionManager !== manager ||
-      manager.getSessionFile?.() !== file ||
-      manager.getSessionId?.() !== id ||
-      manager.getCwd?.() !== cwd ||
-      agentDir() !== root
-    )
-      throw new Error("Session changed during file mutation; evidence retained for review.");
-  };
-}
+export { captureMutationOwner } from "./mutation-owner.js";
 
 export async function backupLocal(profile: string, options: SnapshotOptions = {}, signal?: AbortSignal) {
   throwIfAborted(signal);

package/src/sync-extension.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { completeSyncArguments, splitArgs } from "./commands/command.js";
-import { handleCommand } from "./commands/command-handler.js";
 import type { AnySyncConfig } from "./settings/settings-types.js";
 import { withStateDirectoryAccess } from "./state/state-directory.js";
 import { startupTransferEnabled } from "./sync/agent-policy.js";
@@ -82,8 +81,14 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
           );
           return;
         }
+        const commands = await loaders.commands().catch((error) => {
+          if (!signal.aborted) {
+            ctx.ui.notify(`pi-sync command unavailable: ${safeTerminalText(errorMessage(error))}`, "error");
+          }
+        });
+        if (signal.aborted || !commands) return;
         const run = () =>
-          handleCommand(args, ctx, signal, loaders, attention, (setup) => {
+          commands.handleCommand(args, ctx, signal, loaders, attention, (setup) => {
             retry = { setup };
           });
         // Drain background children before foreground guards. Help remains reachable during repair.

package/src/ui/cancellable-operation.ts

@@ -28,6 +28,7 @@ interface CancellableOperationOptions {
   cancelledMessage?: string | null;
   target?: string;
   signal?: AbortSignal;
+  isCurrent?: () => boolean;
 }
 
 export async function runCancellableOperation(
@@ -37,21 +38,45 @@ export async function runCancellableOperation(
   runRoute: RunRoute,
   options: CancellableOperationOptions = {},
 ): Promise<CancellableOperationResult> {
+  const result = await runCancellableTask(
+    ctx,
+    message,
+    (signal, onCommit, onDialog) => runRoute(route, signal, onCommit, options.target, onDialog),
+    options,
+  );
+  return result.kind === "completed" ? (result.value ?? { kind: "failed" }) : result;
+}
+
+export type CancellableTaskResult<Value> =
+  | { kind: "completed"; value: Value }
+  | { kind: "closed" }
+  | { kind: "cancelled" };
+
+/** Keep non-route work under the same cancellation and drain owner as transfers. */
+export async function runCancellableTask<Value>(
+  ctx: ExtensionContext,
+  message: string,
+  task: (
+    signal: AbortSignal | undefined,
+    onCommit?: () => void,
+    onDialog?: (active: boolean) => void,
+  ) => Promise<Value>,
+  options: Omit<CancellableOperationOptions, "target"> = {},
+): Promise<CancellableTaskResult<Value>> {
   const {
     commitAware = false,
     cancelAcrossDialogs = false,
     cancelledMessage = "Check cancelled; no settings or files were changed.",
-    target,
     signal,
+    isCurrent = () => true,
   } = options;
-  if (ctx.mode !== "tui") {
-    return (await runRoute(route, signal, undefined, target)) ?? { kind: "failed" };
-  }
+  if (signal?.aborted || !isCurrent()) return { kind: "closed" };
+  if (ctx.mode !== "tui") return { kind: "completed", value: await task(signal) };
   let commitStarted = false;
-  let routeResult: RunRouteResult | undefined;
+  let taskResult!: Value;
   const interaction = await runCustomInteraction<{ cancelled?: boolean; error?: unknown }, ExtensionContext>(ctx, {
     signal,
-    isCurrent: () => !signal?.aborted,
+    isCurrent: () => !signal?.aborted && isCurrent(),
     create: ({ tui, theme, keybindings, signal: interactionSignal, complete }) => {
       const loader = new BorderedLoader(tui, theme, message, { cancellable: false });
       const cancelHint = formatInteractionHints(keybindings, [
@@ -80,13 +105,11 @@ export async function runCancellableOperation(
             return cancel(data) ? { consume: true } : undefined;
           })
         : undefined;
-      let pendingRoute: ReturnType<RunRoute>;
+      let pendingTask: Promise<Value>;
       try {
-        pendingRoute = runRoute(
-          route,
+        pendingTask = task(
           interactionSignal,
           commitAware ? () => (commitStarted = true) : undefined,
-          target,
           cancelAcrossDialogs
             ? (active) => {
                 activeDialogs += active ? 1 : -1;
@@ -98,9 +121,9 @@ export async function runCancellableOperation(
         loader.dispose();
         throw error;
       }
-      const operation = pendingRoute.then(
+      const operation = pendingTask.then(
         (result) => {
-          routeResult = result;
+          taskResult = result;
           complete({});
         },
         (error: unknown) => complete({ error }),
@@ -134,7 +157,7 @@ export async function runCancellableOperation(
     return { kind: "cancelled" };
   }
   if (interaction.value.error) throw interaction.value.error;
-  return routeResult ?? { kind: "failed" };
+  return { kind: "completed", value: taskResult };
 }
 
 function hasControlCharacter(value: string) {

package/src/ui/manager-state.ts

@@ -1,5 +1,5 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { loadConfig } from "../settings/config.js";
+import { loadConfig, syncCheckConfigFingerprint } from "../settings/config.js";
 import { activeLocalConfigPath } from "../settings/config-file.js";
 import { readLocalConfigObject } from "../settings/settings-store.js";
 import type { AnySyncConfig } from "../settings/settings-types.js";
@@ -39,6 +39,7 @@ export const MAIN_MENU_ACTIONS = [
 export interface ManagerDescription {
   title: string;
   actions: string[];
+  configReview?: { setupName: string; fingerprint: string };
   operation?: OperationAvailability;
   attention?: SyncAttentionState;
   observation?: StartupObservation;
@@ -176,6 +177,7 @@ export async function describeManagerState(
     return {
       title: (changesBlocked ? ["Manage sync", ...operationStatusLines(operation)] : ordinaryTitle).join("\n"),
       actions: operationActions(operation, noSyncedContent, canSwitch, mainActions),
+      configReview: { setupName: config.setupName, fingerprint: syncCheckConfigFingerprint(config) },
       operation,
       ...(currentObservation ? { observation: currentObservation } : {}),
       ...(currentAttention

package/src/ui/manager-ui.ts

@@ -31,6 +31,15 @@ export async function showSyncManager(
     await runRoute("help");
     return;
   }
+  const validateOwner = captureMutationOwner(ctx, sessionSignal);
+  const isCurrent = () => {
+    try {
+      validateOwner();
+      return true;
+    } catch {
+      return false;
+    }
+  };
   type Screen = "main";
   type Action =
     | "review-attention"
@@ -77,10 +86,11 @@ export async function showSyncManager(
       },
     },
     actions: {
-      "review-attention": async () => {
-        const attention = options.getAttention?.();
+      "review-attention": async ({ state }) => {
+        const attention = state.manager.attention;
+        if (attention && options.getAttention?.() !== attention) return { kind: "stay" };
         if (!attention) {
-          const observation = options.getObservation?.();
+          const observation = state.manager.observation;
           if (!observation) return { kind: "stay" };
           // A head-only observation is not an authoritative decision. Load a fresh
           // snapshot only after the user activates the existing review flow.
@@ -113,24 +123,21 @@ export async function showSyncManager(
         );
         return { kind: disposition };
       },
-      sync: async () => {
+      sync: async ({ state }) => {
         const pendingAttention = options.getAttention?.();
-        if (pendingAttention) {
-          const activeConfig = await loadConfig();
-          if (sessionSignal?.aborted) return { kind: "close" };
-          if (pendingAttention.decision.setupName === activeConfig.setupName) {
-            ctx.ui.notify("Review synced content before starting Sync now.", "warning");
-            return { kind: "stay" };
-          }
+        if (pendingAttention?.decision.setupName === state.manager.configReview?.setupName) {
+          ctx.ui.notify("Review synced content before starting Sync now.", "warning");
+          return { kind: "stay" };
         }
         const result = await runCancellableOperation(ctx, "Checking current sync setup…", "sync", runRoute, {
           commitAware: true,
           signal: sessionSignal,
+          target: state.manager.configReview?.setupName,
         });
         const disposition = await dispatchManagerResult(ctx, result, "sync", runRoute, sessionSignal);
         return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
       },
-      "retry-refusal": async ({ signal: actionSignal }) => {
+      "retry-refusal": async ({ state, signal: actionSignal }) => {
         const signal = sessionSignal ? AbortSignal.any([sessionSignal, actionSignal]) : actionSignal;
         const validate = captureMutationOwner(ctx, signal);
         validate();
@@ -140,6 +147,7 @@ export async function showSyncManager(
           commitAware: true,
           cancelAcrossDialogs: true,
           signal,
+          target: state.manager.configReview?.setupName,
           cancelledMessage: "Model retry cancelled. Submitted requests and committed writes cannot be undone.",
         });
         if (signal.aborted) return { kind: "close" };
@@ -155,23 +163,25 @@ export async function showSyncManager(
         const result = await showSetupSwitcher(ctx, runRoute, undefined, sessionSignal);
         return result === "pull-attempted" || result === "closed" ? { kind: "close" } : { kind: "stay" };
       },
-      settings: async () => {
-        const result = await showSyncSettings(ctx, runRoute, sessionSignal);
+      settings: async ({ state }) => {
+        const result = await showSyncSettings(ctx, runRoute, sessionSignal, state.manager.configReview?.setupName);
         return { kind: result === "exit" ? "close" : "stay" };
       },
-      pull: async () => {
+      pull: async ({ state }) => {
         const result = await runCancellableOperation(ctx, "Checking remote changes…", "pull", runRoute, {
           commitAware: true,
           cancelledMessage: "Pull check cancelled; no local files were changed.",
+          target: state.manager.configReview?.setupName,
           signal: sessionSignal,
         });
         const disposition = await dispatchManagerResult(ctx, result, "pull", runRoute, sessionSignal);
         return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
       },
-      push: async () => {
+      push: async ({ state }) => {
         const result = await runCancellableOperation(ctx, "Preparing push preview…", "push", runRoute, {
           commitAware: true,
           cancelledMessage: "Push preparation cancelled; no remote files were changed.",
+          target: state.manager.configReview?.setupName,
           signal: sessionSignal,
         });
         const disposition = await dispatchManagerResult(ctx, result, "push", runRoute, sessionSignal);
@@ -185,31 +195,34 @@ export async function showSyncManager(
         await showStorageConnections(ctx, sessionSignal);
         return { kind: "stay" };
       },
-      history: async () => {
+      history: async ({ state }) => {
         const result = await runCancellableOperation(ctx, "Loading sync history…", "history", runRoute, {
           signal: sessionSignal,
           commitAware: true,
           cancelAcrossDialogs: true,
+          target: state.manager.configReview?.setupName,
           cancelledMessage: "History review cancelled; no files were changed.",
         });
         return { kind: result.kind === "closed" ? "close" : "stay" };
       },
-      diff: async () => {
+      diff: async ({ state }) => {
         const result = await runCancellableOperation(ctx, "Comparing local and remote…", "diff", runRoute, {
+          target: state.manager.configReview?.setupName,
           signal: sessionSignal,
         });
         return { kind: result.kind === "closed" ? "close" : "stay" };
       },
-      status: async () => {
+      status: async ({ state }) => {
         const result = await runCancellableOperation(ctx, "Checking remote status…", "status", runRoute, {
+          target: state.manager.configReview?.setupName,
           signal: sessionSignal,
         });
         return { kind: result.kind === "closed" ? "close" : "stay" };
       },
-      doctor: async ({ signal: actionSignal }) => {
+      doctor: async ({ state, signal: actionSignal }) => {
         const signal = sessionSignal ? AbortSignal.any([sessionSignal, actionSignal]) : actionSignal;
         const validate = captureMutationOwner(ctx, signal);
-        const config = await loadConfig();
+        const config = await loadConfig(state.manager.configReview?.setupName);
         validate();
         const confirmed = await ctx.ui.confirm(
           "Run diagnostics?",
@@ -241,11 +254,12 @@ export async function showSyncManager(
         return { kind: "close" };
       },
       init: async () => {
-        await runRoute("init");
+        await runRoute("init", sessionSignal);
         return { kind: "stay" };
       },
-      conflicts: async () => {
+      conflicts: async ({ state }) => {
         const result = await runCancellableOperation(ctx, "Reviewing private conflicts…", "conflicts", runRoute, {
+          target: state.manager.configReview?.setupName,
           commitAware: true,
           signal: sessionSignal,
         });
@@ -254,6 +268,44 @@ export async function showSyncManager(
       },
     },
   });
+  // Setup-specific actions must use the configuration shown by this screen, not
+  // an active setup selected by another process while the menu was open.
+  for (const action of [
+    "review-attention",
+    "sync",
+    "retry-refusal",
+    "settings",
+    "pull",
+    "push",
+    "history",
+    "diff",
+    "status",
+    "doctor",
+    "conflicts",
+  ] as const) {
+    const activate = menu.actions[action];
+    menu.actions[action] = async (invocation) => {
+      validateOwner();
+      const review = invocation.state.manager.configReview;
+      let current = false;
+      try {
+        const config = await loadConfig();
+        validateOwner();
+        invocation.signal.throwIfAborted();
+        current = review?.fingerprint === syncCheckConfigFingerprint(config);
+      } catch {
+        if (!isCurrent() || invocation.signal.aborted) return { kind: "close" };
+      }
+      if (!current) {
+        ctx.ui.notify(
+          "Sync setup changed while the manager was open. Review the refreshed setup before continuing.",
+          "warning",
+        );
+        return { kind: "stay" };
+      }
+      return activate(invocation);
+    };
+  }
   const menuContext: ExtensionCommandContext = {
     ...ctx,
     ui: {
@@ -293,7 +345,7 @@ export async function showSyncManager(
       return { manager };
     },
     signal: sessionSignal,
-    isCurrent: () => !sessionSignal?.aborted,
+    isCurrent,
   });
 }