@narumitw/pi-sync 0.54.3 → 0.57.0

package/src/backends/git/git-backend.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { posixJoin } from "../../paths.js";
 import type { Snapshot, SnapshotFile } from "../../snapshot/snapshot-types.js";
 import { stateDir } from "../../state/state-directory.js";
+import { throwIfAborted } from "../../sync/signals.js";
 import { syncErrorGuidance } from "../../sync/sync-error-guidance.js";
 import type { ResolvedGitBackend } from "../backend-types.js";
 import {
@@ -781,7 +782,3 @@ function sha256(value: Buffer) {
 function abortReason(signal: AbortSignal) {
   return signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
 }
-
-function throwIfAborted(signal?: AbortSignal) {
-  if (signal?.aborted) throw abortReason(signal);
-}

package/src/backends/git/git-runner.ts

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import process from "node:process";
+import { throwIfAborted } from "../../sync/signals.js";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_OUTPUT_LIMIT = 1024 * 1024;
@@ -252,8 +253,3 @@ export async function readGitBlobs(
   });
   return parseGitBlobBatch(result.stdout, objects.length, options.maxOutputBytes);
 }
-
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}

package/src/backends/s3/s3-backend.ts

@@ -4,9 +4,11 @@ import { sessionTokenWarnings } from "../../settings/config.js";
 import { decodeSnapshot, encodeSnapshot } from "../../snapshot/snapshot-codec.js";
 import type { Snapshot } from "../../snapshot/snapshot-types.js";
 import { validatePortableSnapshot } from "../../sync/local-fields.js";
+import { throwIfAborted } from "../../sync/signals.js";
 import { syncErrorGuidance } from "../../sync/sync-error-guidance.js";
 import { portableSnapshotSelection } from "../../sync/sync-policy.js";
 import type { LatestPointer, RemoteObject, ResolvedS3Backend } from "../backend-types.js";
+import { createLatestPointer, remoteHistoryEntry } from "../snapshot-pointer.js";
 import {
   type BackendDiagnostic,
   type ExpectedRemoteHead,
@@ -318,16 +320,7 @@ export function storageRoot(config: ResolvedS3Backend) {
 }
 
 export function pointerFor(config: ResolvedS3Backend, snapshot: Snapshot, checksum: string): LatestPointer {
-  return {
-    version: VERSION,
-    profile: config.destination.namespace,
-    snapshot: snapshot.id,
-    sha256: checksum,
-    createdAt: snapshot.createdAt,
-    machine: snapshot.machine,
-    syncSessions: snapshot.syncSessions === true || snapshot.files.some((file) => file.path.startsWith("sessions/")),
-    ...(snapshot.selection === undefined ? {} : { selection: snapshot.selection }),
-  };
+  return createLatestPointer(config.destination.namespace, snapshot, checksum);
 }
 
 export function s3BackendIdentity(config: ResolvedS3Backend) {
@@ -365,16 +358,6 @@ function trimSlashes(value: string) {
   return value.replace(/^\/+|\/+$/g, "");
 }
 
-function remoteHistoryEntry(pointer: LatestPointer): RemoteHistoryEntry {
-  return {
-    snapshotRef: pointer.snapshot,
-    snapshotId: pointer.snapshot,
-    createdAt: pointer.createdAt,
-    machine: pointer.machine,
-    syncSessions: pointer.syncSessions === true,
-  };
-}
-
 function remoteHead(pointer: LatestPointer, identity: string, etag?: string): RemoteHead {
   return {
     snapshotRef: pointer.snapshot,
@@ -529,11 +512,6 @@ function hasControlCharacter(value: string) {
   });
 }
 
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}
-
 function sha256(value: Buffer) {
   return createHash("sha256").update(value).digest("hex");
 }

package/src/backends/s3/s3-client.ts

@@ -1,6 +1,7 @@
 import { createHash, createHmac } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 import { encodeKey, posixJoin } from "../../paths.js";
+import { retryAfter } from "../../sync/continuous-errors.js";
 import type { RemoteObject, ResolvedS3Backend } from "../backend-types.js";
 
 const MAX_JSON_RESPONSE_BYTES = 1024 * 1024;
@@ -34,6 +35,7 @@ export class S3HttpError extends Error {
   constructor(
     message: string,
     readonly status: number,
+    readonly retryAfterMs?: number,
   ) {
     super(message);
     this.name = "S3HttpError";
@@ -81,7 +83,11 @@ export class S3Client {
       const object = await this.request("GET", key);
       if (object.status === 404) return { missing: true };
       if (!object.ok) {
-        throw new S3HttpError(`S3 GET failed (${object.status}): ${await this.readErrorText(object)}`, object.status);
+        throw new S3HttpError(
+          `S3 GET failed (${object.status}): ${await this.readErrorText(object)}`,
+          object.status,
+          retryAfter(object),
+        );
       }
       const body = await readBoundedText(object, MAX_JSON_RESPONSE_BYTES, "S3 JSON response");
       // R2 can intermittently return an empty 200 body (read-after-write
@@ -111,7 +117,11 @@ export class S3Client {
       const object = await this.request("GET", key);
       if (object.status === 404) return { missing: true };
       if (!object.ok) {
-        throw new S3HttpError(`S3 GET failed (${object.status}): ${await this.readErrorText(object)}`, object.status);
+        throw new S3HttpError(
+          `S3 GET failed (${object.status}): ${await this.readErrorText(object)}`,
+          object.status,
+          retryAfter(object),
+        );
       }
       const buffer = await readBoundedBuffer(object, MAX_SNAPSHOT_RESPONSE_BYTES, "S3 snapshot response");
       // R2 can intermittently return an empty 200 body on a long-lived
@@ -158,6 +168,7 @@ export class S3Client {
       throw new S3HttpError(
         `S3 PUT failed (${response.status}): ${await this.readErrorText(response)}`,
         response.status,
+        retryAfter(response),
       );
     }
     await response.body?.cancel();
@@ -169,6 +180,7 @@ export class S3Client {
       throw new S3HttpError(
         `S3 DELETE failed (${response.status}): ${await this.readErrorText(response)}`,
         response.status,
+        retryAfter(response),
       );
     }
     await response.body?.cancel();

package/src/backends/snapshot-pointer.ts

@@ -0,0 +1,27 @@
+import type { Snapshot } from "../snapshot/snapshot-types.js";
+import type { LatestPointer } from "./backend-types.js";
+import type { RemoteHistoryEntry } from "./sync-backend.js";
+
+/** Shared latest/history metadata for the S3 and WebDAV object-store format. */
+export function createLatestPointer(namespace: string, snapshot: Snapshot, checksum: string): LatestPointer {
+  return {
+    version: 1,
+    profile: namespace,
+    snapshot: snapshot.id,
+    sha256: checksum,
+    createdAt: snapshot.createdAt,
+    machine: snapshot.machine,
+    syncSessions: snapshot.syncSessions === true || snapshot.files.some((file) => file.path.startsWith("sessions/")),
+    ...(snapshot.selection === undefined ? {} : { selection: snapshot.selection }),
+  };
+}
+
+export function remoteHistoryEntry(pointer: LatestPointer): RemoteHistoryEntry {
+  return {
+    snapshotRef: pointer.snapshot,
+    snapshotId: pointer.snapshot,
+    createdAt: pointer.createdAt,
+    machine: pointer.machine,
+    syncSessions: pointer.syncSessions === true,
+  };
+}

package/src/backends/webdav/webdav-backend.ts

@@ -2,9 +2,11 @@ import { createHash, randomUUID } from "node:crypto";
 import { decodeSnapshot, encodeSnapshot } from "../../snapshot/snapshot-codec.js";
 import type { Snapshot } from "../../snapshot/snapshot-types.js";
 import { validatePortableSnapshot } from "../../sync/local-fields.js";
+import { throwIfAborted } from "../../sync/signals.js";
 import { syncErrorGuidance } from "../../sync/sync-error-guidance.js";
 import { portableSnapshotSelection } from "../../sync/sync-policy.js";
 import type { LatestPointer, RemoteObject, ResolvedWebDavBackend } from "../backend-types.js";
+import { createLatestPointer, remoteHistoryEntry } from "../snapshot-pointer.js";
 import {
   type BackendDiagnostic,
   type ExpectedRemoteHead,
@@ -84,7 +86,7 @@ export class WebDavSyncBackend implements SyncBackend {
     await client.ensureCollection(snapshotsPath(this.config));
     const encoded = await encodeSnapshot(snapshot);
     throwIfAborted(options.signal);
-    const pointer = pointerFor(this.config, snapshot, sha256(encoded));
+    const pointer = createLatestPointer(this.config.destination.namespace, snapshot, sha256(encoded));
     const stagedPath = snapshotPath(this.config, snapshot.id);
     try {
       await client.putBuffer(stagedPath, encoded, "application/gzip", { ifAbsent: true });
@@ -392,19 +394,6 @@ function webDavStorageLocation(config: ResolvedWebDavBackend) {
   return `${url.host} · ${config.destination.path}`;
 }
 
-function pointerFor(config: ResolvedWebDavBackend, snapshot: Snapshot, checksum: string): LatestPointer {
-  return {
-    version: VERSION,
-    profile: config.destination.namespace,
-    snapshot: snapshot.id,
-    sha256: checksum,
-    createdAt: snapshot.createdAt,
-    machine: snapshot.machine,
-    syncSessions: snapshot.syncSessions === true || snapshot.files.some((file) => file.path.startsWith("sessions/")),
-    ...(snapshot.selection === undefined ? {} : { selection: snapshot.selection }),
-  };
-}
-
 function remoteHead(pointer: LatestPointer, identity: string, etag?: string): RemoteHead {
   return {
     snapshotRef: pointer.snapshot,
@@ -490,16 +479,6 @@ function requireHistory(value: { version: number; snapshots: LatestPointer[] } |
   return pointers;
 }
 
-function remoteHistoryEntry(pointer: LatestPointer): RemoteHistoryEntry {
-  return {
-    snapshotRef: pointer.snapshot,
-    snapshotId: pointer.snapshot,
-    createdAt: pointer.createdAt,
-    machine: pointer.machine,
-    syncSessions: pointer.syncSessions === true,
-  };
-}
-
 function assertSnapshotIdentity(snapshot: Snapshot, namespace: string) {
   validatePortableSnapshot(snapshot);
   if (
@@ -637,11 +616,6 @@ function sha256(value: Buffer) {
   return createHash("sha256").update(value).digest("hex");
 }
 
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}
-
 function errorMessage(error: unknown) {
   if (error instanceof WebDavHttpError) return error.message;
   return error instanceof Error ? error.message : String(error);

package/src/backends/webdav/webdav-client.ts

@@ -1,4 +1,6 @@
 import { XMLParser } from "fast-xml-parser";
+import { ContinuousError, continuousFailure, retryAfter } from "../../sync/continuous-errors.js";
+import { throwIfAborted } from "../../sync/signals.js";
 import type { RemoteObject, ResolvedWebDavBackend } from "../backend-types.js";
 
 const JSON_LIMIT = 1024 * 1024;
@@ -24,6 +26,7 @@ export class WebDavHttpError extends Error {
     message: string,
     readonly status: number,
     options?: ErrorOptions,
+    readonly retryAfterMs?: number,
   ) {
     super(message, options);
     this.name = "WebDavHttpError";
@@ -231,7 +234,12 @@ export class WebDavClient {
       .replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ")
       .trim();
     const detail = body ? `: ${redactText(body, this.config)}` : "";
-    throw new WebDavHttpError(`WebDAV ${action} failed with HTTP ${response.status}${detail}`, response.status);
+    throw new WebDavHttpError(
+      `WebDAV ${action} failed with HTTP ${response.status}${detail}`,
+      response.status,
+      undefined,
+      retryAfter(response),
+    );
   }
 }
 
@@ -342,7 +350,8 @@ function safeUrl(url: URL) {
 
 function redactError(error: unknown, config: ResolvedWebDavBackend) {
   const message = error instanceof Error ? error.message : String(error);
-  return new Error(redactText(message, config));
+  const failure = continuousFailure(error);
+  return new ContinuousError(failure.kind, redactText(message, config), failure.delay);
 }
 
 function redactText(value: string, config: ResolvedWebDavBackend) {
@@ -359,8 +368,3 @@ function redactText(value: string, config: ResolvedWebDavBackend) {
 function escapeRegExp(value: string) {
   return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}

package/src/commands/command-execution.ts

@@ -5,6 +5,7 @@ import { localConfigTemplate, readLocalConfigObject } from "../settings/settings
 import type { AnySyncConfig } from "../settings/settings-types.js";
 import { unlock, withLock } from "../state/lock.js";
 import { migrateLegacyStateDirectory, stateDirectoryMigrationNotice } from "../state/state-directory.js";
+import { withAgentSyncLock } from "../sync/agent-sync.js";
 import { throwIfAborted } from "../sync/signals.js";
 import { syncErrorGuidance } from "../sync/sync-error-guidance.js";
 import { isSyncDecisionRequiredError, SetupPullRequiresUiError } from "../sync/sync-errors.js";
@@ -49,7 +50,7 @@ export async function executeRecoveryCommand(
       const outcome = await withLock("pull", () => operations.pull(ctx, options));
       return { kind: "completed", ...(outcome ? { outcome } : {}) };
     }
-    await withLock("sync", () => operations.syncBoth(ctx, options));
+    await withAgentSyncLock(ctx, options, (current) => operations.syncBoth(ctx, current));
     return { kind: "completed" };
   } catch (error) {
     if (signal?.aborted) return { kind: "failed" };
@@ -156,7 +157,7 @@ export async function executeCommand(
       case "sync": {
         const operations = await loaders.operations();
         throwIfAborted(options.signal);
-        await withLock("sync", () => operations.syncBoth(ctx, options));
+        await withAgentSyncLock(ctx, options, (current) => operations.syncBoth(ctx, current));
         return { kind: "completed" };
       }
       case "history": {
@@ -258,6 +259,8 @@ async function showConfig(ctx: ExtensionCommandContext, options: CommandOptions)
       `settings field merge: ${config.mergeSettings ? "On (experimental)" : "Off"}`,
       `machine-local settings.json fields: ${(config.localFields ?? []).map(safeTerminalText).join(", ") || "none"}`,
       `startup transfer: ${startupTransferSummary(config)}`,
+      `agent mode: ${config.agentMode ? "On (experimental)" : "Off"}`,
+      `continuous sync: ${config.continuous ? (config.agentMode ? "On (experimental)" : "paused; Agent mode is Off") : "Off"}`,
       `included content: ${config.include.join(", ") || "none"}`,
       `sessions: ${config.include.includes("sessions") ? "included" : "not included"}`,
       `settings file: ${localConfigPath()}`,

package/src/commands/command-handler.ts

@@ -13,7 +13,7 @@ import {
   syncAttentionMatchesConfig,
 } from "../ui/sync-attention.js";
 import { setSyncStatus } from "../ui/sync-status.js";
-import { parseOptions, splitArgs } from "./command.js";
+import { parseOptions, splitArgs, validateCommandOptions } from "./command.js";
 import { executeCommand, executeRecoveryCommand } from "./command-execution.js";
 
 export async function handleCommand(
@@ -22,6 +22,7 @@ export async function handleCommand(
   sessionSignal: AbortSignal,
   loaders: SyncLoaders,
   attention: SyncAttentionController,
+  onExplicitSync?: (setup?: string) => void,
 ) {
   await reconcileObservation(attention, sessionSignal);
   if (sessionSignal.aborted) return;
@@ -31,8 +32,18 @@ export async function handleCommand(
     onCommit?: () => void,
     target?: string,
     onDialog?: (active: boolean) => void,
-  ) =>
-    executeCommand(
+  ) => {
+    const [command, ...args] = splitArgs(route);
+    if (command === "sync") {
+      try {
+        const options = parseOptions(args);
+        validateCommandOptions("sync", options);
+        onExplicitSync?.(target ?? options.setup);
+      } catch {
+        /* Invalid routes do not request an automatic retry. */
+      }
+    }
+    return executeCommand(
       route,
       ctx,
       combineSignals(sessionSignal, signal),
@@ -41,6 +52,7 @@ export async function handleCommand(
       target,
       onDialog,
     );
+  };
   if (!rawArgs.trim()) {
     try {
       const { showSyncManager } = await import("../ui/manager-ui.js");

package/src/commands/command-types.ts

@@ -1,3 +1,5 @@
+import type { AnySyncConfig } from "../settings/settings-types.js";
+import type { AgentAcceptance } from "../sync/agent-request.js";
 import type { StartupTimings } from "../sync/startup-timings.js";
 
 export interface CommandOptions {
@@ -12,6 +14,10 @@ export interface CommandOptions {
   onCommit?: () => void;
   /** In-memory startup diagnostics only; never persisted or sent to a backend. */
   startupTimings?: StartupTimings;
+  /** Internal validated resolver result; never parsed from command arguments. */
+  agentAcceptance?: AgentAcceptance;
+  /** Internal cycle authorization, ownership and durable request reservation; never command arguments. */
+  background?: { validate(config?: AnySyncConfig): void; reserve(key: string): Promise<void> };
   args: string[];
 }
 

package/src/commands/command.ts

@@ -236,6 +236,7 @@ export function usage() {
     `Automatic sync: ${AUTOMATIC_SYNC_DESCRIPTION}`,
     `Startup transfer: ${STARTUP_TRANSFER_DESCRIPTION}`,
     "Automatic transfer at startup is a separate opt-in: one conflict-free established-baseline transfer at idle in TUI/RPC, with conditional/lease publication and no resource reload.",
+    "Experimental Continuous sync is a separate default-Off opt-in in Settings. It requires Agent mode, monitors while Pi is open, and can incur recurring network/model costs. Safety blocks and durable automatic request limits remain.",
     "Settings: use /sync init or edit storage connections and sync setups in ~/.pi/agent/pi-sync.json (or the configured Pi agent directory). Version 1 and version 2 settings are unsupported and are never rewritten.",
   ].join("\n");
 }

package/src/settings/config.ts

@@ -80,6 +80,8 @@ export async function loadPartialConfig(setupName?: string): Promise<PartialConf
     include: [...config.include],
     automatic: config.automatic,
     automaticTransfer: config.automaticTransfer ?? false,
+    agentMode: config.agentMode ?? false,
+    continuous: config.continuous ?? false,
     onSwitch: config.onSwitch,
     showStatus: config.showStatus,
   };
@@ -115,10 +117,13 @@ export function syncConfigReviewIdentity(config: AnySyncConfig) {
     config.include,
     config.automatic,
     config.automaticTransfer ?? false,
+    config.agentMode ?? false,
     config.localFields,
     config.mergeSettings ?? false,
     config.mergeContent ?? false,
     config.partialSync ?? false,
+    // Preserve existing Off identities and cached candidates across the upgrade.
+    ...(config.continuous ? ["continuous"] : []),
   ]);
 }
 
@@ -166,6 +171,8 @@ function resolveSyncConfig(
     include,
     automatic: setup.sync.automatic,
     automaticTransfer: setup.sync.automaticTransfer ?? false,
+    agentMode: setup.sync.agentMode ?? false,
+    continuous: setup.sync.continuous ?? false,
     localFields: setup.sync.localFields === undefined ? undefined : normalizeLocalFields(setup.sync.localFields),
     mergeSettings: setup.sync.mergeSettings ?? false,
     mergeContent: setup.sync.mergeContent ?? false,

package/src/settings/settings-store.ts

@@ -1,6 +1,3 @@
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
 import { localConfigPath, readMigratingLocalConfigDocument, updateLocalConfigDocument } from "./config-file.js";
 import type { OnSwitchAction, PiSyncSettingsV3 } from "./settings-types.js";
 import { DEFAULT_ON_SWITCH, validateSettingsDocument } from "./settings-validation.js";
@@ -63,34 +60,3 @@ export function updateLocalConfig(update: (current: PiSyncSettingsV3) => PiSyncS
 async function performLocalConfigUpdate(update: (current: PiSyncSettingsV3) => PiSyncSettingsV3, signal?: AbortSignal) {
   return updateLocalConfigDocument(localConfigTemplate(), update, validateSettingsDocument, signal);
 }
-
-export async function writeLocalConfigObject(value: PiSyncSettingsV3 | Record<string, unknown>) {
-  validateSettingsDocument(value as Record<string, unknown>);
-  const configPath = localConfigPath();
-  await fs.mkdir(path.dirname(configPath), { recursive: true });
-  try {
-    const stat = await fs.lstat(configPath);
-    if (stat.isSymbolicLink()) throw new Error(`Refusing to overwrite symlinked pi-sync settings: ${configPath}`);
-    if (!stat.isFile()) throw new Error(`pi-sync settings are not a regular file: ${configPath}`);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-  }
-  const temporaryPath = path.join(
-    path.dirname(configPath),
-    `.${path.basename(configPath)}.${process.pid}.${randomUUID()}.tmp`,
-  );
-  let handle: fs.FileHandle | undefined;
-  try {
-    handle = await fs.open(temporaryPath, "wx", 0o600);
-    await handle.writeFile(`${JSON.stringify(value, null, "\t")}\n`, "utf8");
-    if (process.platform !== "win32") await handle.chmod(0o600);
-    await handle.sync();
-    await handle.close();
-    handle = undefined;
-    await fs.rename(temporaryPath, configPath);
-  } catch (error) {
-    await handle?.close().catch(() => undefined);
-    await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
-    throw error;
-  }
-}

package/src/settings/settings-types.ts

@@ -81,6 +81,10 @@ export interface SyncPolicySettings {
   automatic: boolean;
   /** Explicit opt-in, separate from the legacy observe/shutdown policy. */
   automaticTransfer?: boolean;
+  /** Experimental autonomous merged-sync authorization. */
+  agentMode?: boolean;
+  /** Separate explicit authorization for recurring background work. */
+  continuous?: boolean;
   /** Version 4: settings.json root fields never uploaded. */
   localFields?: string[];
   mergeSettings?: boolean;
@@ -116,6 +120,8 @@ export interface SyncConfig<Backend extends ResolvedSyncBackend = ResolvedS3Back
   include: string[];
   automatic: boolean;
   automaticTransfer?: boolean;
+  agentMode?: boolean;
+  continuous?: boolean;
   localFields?: string[];
   mergeSettings?: boolean;
   mergeContent?: boolean;
@@ -139,6 +145,8 @@ export interface PartialConfig {
   include: string[];
   automatic: boolean;
   automaticTransfer?: boolean;
+  agentMode?: boolean;
+  continuous?: boolean;
   onSwitch: OnSwitchAction;
   showStatus: boolean;
   bucket?: string;

package/src/settings/settings-validation.ts

@@ -219,7 +219,7 @@ function validateSyncSetup(name: string, value: Record<string, unknown>, connect
   const localFields = normalizeLocalFields(sync.localFields);
   if (localFields.length > 0 && !include.includes("settings.json"))
     throw new Error("Nonempty localFields requires settings.json in sync.include.");
-  for (const key of ["mergeContent", "partialSync"])
+  for (const key of ["mergeContent", "partialSync", "agentMode", "continuous"])
     if (sync[key] !== undefined && typeof sync[key] !== "boolean") throw new Error(`${key} must be boolean.`);
   if (sync.mergeSettings !== undefined && typeof sync.mergeSettings !== "boolean")
     throw new Error("mergeSettings must be boolean.");

package/src/snapshot/snapshot-codec.ts

@@ -2,6 +2,7 @@ import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { promisify } from "node:util";
 import { createGunzip, gzip } from "node:zlib";
+import { throwIfAborted } from "../sync/signals.js";
 import { snapshotSelectionInclude } from "../sync/sync-policy.js";
 import type { Snapshot } from "./snapshot-types.js";
 
@@ -47,8 +48,3 @@ export async function decodeSnapshot(
   snapshotSelectionInclude(parsed);
   return parsed;
 }
-
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}

package/src/state/lock.ts

@@ -3,6 +3,7 @@ import fs from "node:fs/promises";
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import lockfile from "proper-lockfile";
 import type { CommandOptions } from "../commands/command-types.js";
+import { throwIfAborted } from "../sync/signals.js";
 import { LOCK_GUARD_STALE_MS, LOCK_GUARD_UPDATE_MS } from "./lock-policy.js";
 import { LOCKFILE_FS_ADAPTER } from "./lockfile-fs.js";
 import type { LockFile } from "./state-types.js";
@@ -57,8 +58,11 @@ export async function withLock<T>(
       inspection = { status: "missing" };
     }
     if (inspection.status === "valid") {
-      throw new Error(
-        `pi-sync is already running (${inspection.lock.command}, pid ${inspection.lock.pid}, started ${inspection.lock.startedAt}).`,
+      throw Object.assign(
+        new Error(
+          `pi-sync is already running (${inspection.lock.command}, pid ${inspection.lock.pid}, started ${inspection.lock.startedAt}).`,
+        ),
+        { code: "ELOCKED" },
       );
     }
     if (inspection.status === "unreadable") {
@@ -220,11 +224,6 @@ async function unlockGuarded(ctx: ExtensionCommandContext, options: CommandOptio
   }
 }
 
-function throwIfAborted(signal?: AbortSignal) {
-  if (!signal?.aborted) return;
-  throw signal.reason instanceof Error ? signal.reason : new DOMException("The operation was aborted", "AbortError");
-}
-
 async function releaseGuard(guard: Guard) {
   try {
     await guard.release();
@@ -261,11 +260,15 @@ async function describeHeldLock() {
     return new Error("pi-sync lock owner exited; retry shortly while the lock guard expires.");
   }
   if (current) {
-    return new Error(
-      `Pi-sync is currently running (${current.command}, pid ${current.pid}, started ${current.startedAt}).`,
+    return Object.assign(
+      new Error(`Pi-sync is currently running (${current.command}, pid ${current.pid}, started ${current.startedAt}).`),
+      { code: "ELOCKED" },
     );
   }
-  return new Error("Pi-sync is currently running (lock metadata is unreadable or still being written).");
+  return Object.assign(
+    new Error("Pi-sync is currently running (lock metadata is unreadable or still being written)."),
+    { code: "ELOCKED" },
+  );
 }
 
 function isLockHeldError(error: unknown) {

package/src/state/merge-baseline-store.ts

@@ -66,7 +66,7 @@ export async function stageMergeBaseline(
     return (
       !collisions.has(file.path) &&
       accepted.lastFileHashes[file.path] === file.sha256 &&
-      (file.path === "settings.json" || config.mergeContent) &&
+      (file.path === "settings.json" || config.mergeContent || (config.agentMode && isMergeTextPath(file.path))) &&
       eligible(file)
     );
   });
@@ -153,7 +153,7 @@ export async function hasCurrentMergeBaseline(config: AnySyncConfig, snapshot: S
     const hashes = new Map(ancestors.map((file) => [file.path, file.sha256]));
     return snapshot.files.every(
       (file) =>
-        !(file.path === "settings.json" || config.mergeContent) ||
+        !(file.path === "settings.json" || config.mergeContent || (config.agentMode && isMergeTextPath(file.path))) ||
         !eligible(file) ||
         hashes.get(file.path) === file.sha256,
     );

package/src/state/state-directory.ts

@@ -79,7 +79,14 @@ export async function migrateLegacyStateDirectory(): Promise<StateDirectoryPrepa
       realpath: false,
       stale: LOCK_GUARD_STALE_MS,
     });
-    if (legacyGuardHeld || (await pathExists(legacyLock))) {
+    // Idle continuous owners do not retain the exclusive migration guard.
+    // A live renewable lease still prevents moving their private state root.
+    const schedulerHeld = await lockfile.check(path.join(legacyStateDir(), "continuous", "scheduler"), {
+      fs: LOCKFILE_FS_ADAPTER,
+      realpath: false,
+      stale: LOCK_GUARD_STALE_MS,
+    });
+    if (legacyGuardHeld || schedulerHeld || (await pathExists(legacyLock))) {
       return {
         status: "deferred",
         message: