@narumitw/pi-sync 0.54.3 → 0.56.0

package/src/sync/merged-sync.ts

@@ -37,6 +37,7 @@ import {
 import { confirmMergeReview } from "../ui/merge-review.js";
 import { mergedSyncSummary } from "../ui/merged-sync-summary.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
+import { startupTransferEnabled } from "./agent-policy.js";
 import { releaseConflictArtifacts } from "./conflict-artifact-ownership.js";
 import {
   type CreatedConflictArtifact,
@@ -82,7 +83,11 @@ export async function mergeSync(
   resolution?: ConflictResolution,
 ) {
   const timings = options.startupTimings ?? createStartupTimings();
-  const validateOwner = captureMutationOwner(ctx, options.signal);
+  const sessionOwner = captureMutationOwner(ctx, options.signal);
+  const validateOwner = (config?: AnySyncConfig) => {
+    sessionOwner();
+    options.background?.validate(config);
+  };
   const isCurrent = () => {
     try {
       validateOwner();
@@ -92,7 +97,9 @@ export async function mergeSync(
     }
   };
   const config = await loadConfig(options.setup);
+  validateOwner(config);
   const configToken = syncCheckConfigFingerprint(config);
+  const modelToken = JSON.stringify(ctx.model);
   const sessionRoot = config.include.includes("sessions") ? await effectiveSessionRoot(ctx) : undefined;
   validateOwner();
   const snapshotOptions = {
@@ -104,7 +111,7 @@ export async function mergeSync(
     timings.measure("transfer authorization", async () => {
       validateOwner();
       const latest = await loadConfig(options.setup);
-      validateOwner();
+      validateOwner(latest);
       if (configToken !== syncCheckConfigFingerprint(latest))
         throw new Error("Sync setup or settings changed during transfer; reopen sync.");
       if (sessionRoot !== undefined) {
@@ -113,22 +120,29 @@ export async function mergeSync(
         if (currentRoot !== sessionRoot)
           throw new Error("Session storage root changed during transfer; evidence retained for review.");
       }
-      if (options.auto && (!latest.automaticTransfer || !ctx.isIdle()))
+      if (config.agentMode && JSON.stringify(ctx.model) !== modelToken)
+        throw new Error("Agent mode paused: selected model changed during transfer.");
+      if (options.auto && (!startupTransferEnabled(latest) || !ctx.isIdle()))
         throw new Error("Automatic transfer is no longer authorized at this idle boundary.");
     });
   await validate();
   const backend = await timings.measure("transfer backend initialization", () => 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 timings.measure("transfer journal read", () => readMergeJournal(config));
   await validate();
   if (pending) {
     const recovered = await timings.measure("transfer journal recovery", () =>
-      completeJournal(ctx, config, backend, pending, validate, timings, options.signal, options.auto),
+      completeJournal(
+        ctx,
+        config,
+        backend,
+        pending,
+        validate,
+        timings,
+        options.signal,
+        options.auto,
+        options.background?.validate,
+      ),
     );
     if (!recovered) {
       if ((options.auto || !options.silent) && !options.signal?.aborted)
@@ -142,6 +156,12 @@ export async function mergeSync(
       ctx.ui.notify("Recovered the committed merged transfer. Run sync again to inspect newer changes.", "info");
     return "applied" as const;
   }
+  // Recovery above never publishes. This gate applies only to new autonomous transfers.
+  if ((options.auto || config.agentMode) && 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. Disable Agent mode and use manual sync.",
+    );
+  }
   const textBudget = { remaining: TEXT_MERGE_WORK_LIMIT };
   const createdArtifacts: CreatedConflictArtifact[] = [];
   const ownedStatePath = statePathForConfig(config);
@@ -300,7 +320,33 @@ export async function mergeSync(
         );
         await validate();
       }
-      if (plan.kind !== "planned" || (plan.conflicts.length && (!config.partialSync || options.auto))) {
+      if (config.agentMode && !resolution) {
+        const { resolveAgentPlan } = await import("./agent-plan.js");
+        await validate();
+        plan = await resolveAgentPlan(
+          ctx,
+          options,
+          config,
+          backend,
+          state,
+          local,
+          localRaw,
+          remote,
+          head,
+          plan,
+          snapshotOptions,
+          validate,
+        );
+        await validate();
+        if (plan.kind !== "planned" || (plan.conflicts.length && !config.partialSync))
+          throw new Error(
+            "Agent mode paused: unsupported or refused conflict groups remain; no transfer was performed.",
+          );
+      }
+      if (
+        plan.kind !== "planned" ||
+        (plan.conflicts.length && (!config.partialSync || (options.auto && !config.agentMode)))
+      ) {
         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(", ")}` : ""}`
@@ -467,7 +513,7 @@ export async function mergeSync(
       await validate();
       if (!config.skipSecretScan && scanSnapshot(upload).length)
         throw new Error("Refusing to merge possible secrets. Review managed content before syncing.");
-      if (!options.yes) {
+      if (!options.yes && !config.agentMode) {
         const summary = mergedSyncSummary({
           setupName: config.setupName,
           destination: backend.destination,
@@ -585,7 +631,17 @@ export async function mergeSync(
         throw mergeTransferError(error, config.backend);
       }
       const completed = await timings.measure("transfer journal recovery", () =>
-        completeJournal(ctx, config, backend, journal, validate, timings, options.signal, options.auto),
+        completeJournal(
+          ctx,
+          config,
+          backend,
+          journal,
+          validate,
+          timings,
+          options.signal,
+          options.auto,
+          options.background?.validate,
+        ),
       );
       if (!completed) {
         if (!options.signal?.aborted && (options.auto || !options.silent))
@@ -624,6 +680,7 @@ async function completeJournal(
   timings: StartupTimings,
   signal?: AbortSignal,
   auto = false,
+  validateBackground?: () => void,
 ) {
   if (
     journal.identity !== mergeJournalIdentity(config, backend.identity) ||
@@ -734,6 +791,7 @@ async function completeJournal(
   const validateOwner = captureMutationOwner(ctx, signal);
   const validateMutation = () => {
     validateOwner();
+    validateBackground?.();
     if (auto && !ctx.isIdle()) throw new Error("Automatic file apply is no longer idle; evidence retained.");
   };
   await timings.measure("transfer local apply", () =>

package/src/sync/remote-snapshot.ts

@@ -5,6 +5,7 @@ import { filterSnapshotForConfigPolicy } from "../snapshot/snapshot.js";
 import type { Snapshot } from "../snapshot/snapshot-types.js";
 import { safeTerminalText } from "../ui/terminal-text.js";
 import { sameLocalFields, validatePortableSnapshot } from "./local-fields.js";
+import { throwIfAborted } from "./signals.js";
 import {
   inspectRemoteSelection,
   type RemoteSelectionState,
@@ -15,9 +16,7 @@ import {
 
 export async function readSnapshotForHead(backend: SyncBackend, head: RemoteHead, signal?: AbortSignal) {
   const snapshot = await backend.readSnapshot(head.snapshotRef, signal);
-  if (signal?.aborted) {
-    throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-  }
+  throwIfAborted(signal);
   validatePortableSnapshot(snapshot);
   if (snapshot.id !== head.snapshotId) {
     throw new Error(`Remote head ${head.snapshotId} resolved to unexpected snapshot ${snapshot.id}.`);

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,6 +9,8 @@ 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";
@@ -42,7 +44,7 @@ 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;
       }
@@ -54,7 +56,7 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
         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;
@@ -71,9 +73,9 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
           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;
@@ -106,10 +108,10 @@ 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"
@@ -123,8 +125,9 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
               }
               await timings.measure("automatic transfer", () =>
                 withStateDirectoryAccess(() =>
-                  withLock("startup-transfer", () =>
-                    operations.syncBoth(ctx, {
+                  withAgentSyncLock(
+                    ctx,
+                    {
                       args: [],
                       yes: true,
                       force: false,
@@ -135,7 +138,8 @@ export function createStartupCheck(loaders: SyncLoaders, attention: SyncAttentio
                       signal,
                       startupTimings: timings,
                       onCommit: () => attention.clearObservation(),
-                    }),
+                    },
+                    (options) => operations.syncBoth(ctx, options),
                   ),
                 ),
               );
@@ -149,7 +153,7 @@ 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) {
@@ -163,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",

package/src/sync/sync-inspection.ts

@@ -1,3 +1,4 @@
+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";
@@ -6,7 +7,7 @@ import { readStateForConfig, syncStateFingerprint } from "../state/sync-state-st
 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(
@@ -27,7 +28,13 @@ export async function inspectSync(
   throwIfAborted(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

@@ -32,6 +32,7 @@ import {
 } 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";
@@ -429,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);
@@ -451,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,
       {
@@ -477,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)) {
@@ -525,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;

package/src/sync/sync-queries.ts

@@ -36,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);
@@ -47,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}`,

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.

package/src/sync-extension.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+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";
@@ -19,6 +19,31 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
   let sessionAbort = new AbortController();
   let shutdownAbort: AbortController | undefined;
   let initialization = Promise.resolve<AnySyncConfig | false | undefined>(undefined);
+  let continuous: ReturnType<typeof import("./sync/continuous-sync.js")["createContinuousSync"]> | undefined;
+  let owner: ExtensionContext["sessionManager"] | undefined;
+  let continuousPossible = false;
+  const foreground = new Map<ExtensionContext["sessionManager"], number>();
+  async function resumeContinuous(ctx: ExtensionContext, signal: AbortSignal, retry?: { setup?: string }) {
+    const isCurrent = () => !signal.aborted && !foreground.has(ctx.sessionManager) && owner === ctx.sessionManager;
+    if (!isCurrent() || !ctx.hasUI) return;
+    try {
+      const { loadConfigForCheck } = await import("./settings/config.js");
+      if (!isCurrent()) return;
+      const config = await loadConfigForCheck();
+      if (!isCurrent()) return;
+      continuousPossible = Boolean(config.continuous && config.agentMode);
+      if (!continuousPossible) {
+        await continuous?.stop(ctx.sessionManager);
+        return;
+      }
+      const { createContinuousSync } = await import("./sync/continuous-sync.js");
+      if (!isCurrent()) return;
+      continuous ??= createContinuousSync(loaders);
+      continuous.start(ctx, signal, Boolean(retry && (retry.setup === undefined || retry.setup === config.setupName)));
+    } catch {
+      /* Existing initialization/command paths report settings errors. */
+    }
+  }
 
   pi.registerCommand("sync", {
     description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
@@ -28,23 +53,39 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
         throw new Error("/sync requires TUI or RPC mode so results and safety prompts are observable.");
       }
       const signal = sessionAbort.signal;
-      const ready = await initialization;
-      if (signal.aborted) return;
-      await check.stop();
-      if (signal.aborted) return;
+      const manager = ctx.sessionManager;
       const command = splitArgs(args)[0];
-      if (ready === false && command !== "help" && command !== "unlock" && command !== "migrate-state") {
-        ctx.ui.notify(
-          "pi-sync recovery required. Repair the startup error, then /reload before syncing. Use /sync help for recovery guidance.",
-          "error",
-        );
-        return;
+      let retry: { setup?: string } | undefined;
+      let mayResume = false;
+      foreground.set(manager, (foreground.get(manager) ?? 0) + 1);
+      try {
+        const ready = await initialization;
+        mayResume = ready !== false;
+        if (signal.aborted) return;
+        await continuous?.stop(manager);
+        if (signal.aborted) return;
+        await check.stop();
+        if (signal.aborted) return;
+        if (ready === false && command !== "help" && command !== "unlock" && command !== "migrate-state") {
+          ctx.ui.notify(
+            "pi-sync recovery required. Repair the startup error, then /reload before syncing. Use /sync help for recovery guidance.",
+            "error",
+          );
+          return;
+        }
+        const run = () =>
+          handleCommand(args, ctx, signal, loaders, attention, (setup) => {
+            retry = { setup };
+          });
+        // Drain background children before foreground guards. Help remains reachable during repair.
+        if (command === "migrate-state" || command === "help") await run();
+        else await withStateDirectoryAccess(run);
+      } finally {
+        const count = (foreground.get(manager) ?? 1) - 1;
+        if (count) foreground.set(manager, count);
+        else foreground.delete(manager);
+        if (mayResume) await resumeContinuous(ctx, signal, retry);
       }
-      const run = () => handleCommand(args, ctx, signal, loaders, attention);
-      // Drain background cache/child cleanup before entering any foreground guard.
-      // Help must remain reachable when the state roots themselves need repair.
-      if (command === "migrate-state" || command === "help") await run();
-      else await withStateDirectoryAccess(run);
     },
   });
 
@@ -54,11 +95,15 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
     sessionAbort.abort(new DOMException("Session replaced", "AbortError"));
     sessionAbort = new AbortController();
     const signal = sessionAbort.signal;
+    owner = ctx.sessionManager;
+    continuousPossible = false;
     attention.reset(ctx);
     const previous = initialization;
     initialization = (async () => {
       await previous;
       if (signal.aborted) return false;
+      await continuous?.stop();
+      if (signal.aborted) return false;
       await check.stop();
       if (signal.aborted) return false;
       try {
@@ -72,18 +117,27 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
       }
     })();
     const ready = await initialization;
-    if (ready && !signal.aborted) check.start(ctx, signal, ready);
+    if (ready && !signal.aborted) {
+      if (ready.continuous && ready.agentMode) await resumeContinuous(ctx, signal);
+      else check.start(ctx, signal, ready);
+    }
   });
 
   pi.on("agent_start", async (_event, ctx) => {
+    await continuous?.stop(ctx.sessionManager);
     await check.interrupt(ctx);
   });
 
-  pi.on("agent_settled", (_event, ctx) => {
-    if (!sessionAbort.signal.aborted) check.settled(ctx);
+  pi.on("agent_settled", async (_event, ctx) => {
+    const signal = sessionAbort.signal;
+    if (!signal.aborted) {
+      check.settled(ctx);
+      if (continuousPossible) await resumeContinuous(ctx, signal);
+    }
   });
 
   pi.on("session_shutdown", async (event, ctx) => {
+    if (continuous && owner && owner !== ctx.sessionManager) return;
     sessionAbort.abort(new DOMException("Session shut down", "AbortError"));
     attention.reset(ctx);
     shutdownAbort?.abort(new DOMException("Session shut down again", "AbortError"));
@@ -94,6 +148,8 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
     try {
       const ready = await initialization;
       if (signal.aborted) return;
+      await continuous?.stop(ctx.sessionManager);
+      if (signal.aborted) return;
       await check.stop();
       if (signal.aborted) return;
       if (ready !== false && reason !== "reload") {