@superblocksteam/vite-plugin-file-sync 1.99.99-next.2 → 2.0.0-SNAPSHOT.2143e2e95d0107ab

package/dist/sync-service/index.js

@@ -1,18 +1,27 @@
-import EventEmitter from "node:events";
-import { SyncronizationStatus } from "@superblocksteam/library-shared/types";
-import { addTracingToMethods } from "@superblocksteam/shared";
+import { randomUUID } from "node:crypto";
+import { normalizePath } from "vite";
+import { SyncronizationStatus, } from "@superblocksteam/library-shared/types";
+import { addTracingToMethods, TracedEventEmitter, } from "@superblocksteam/shared";
+import { BadRequestError } from "@superblocksteam/shared";
+import { unwrapResponseDto } from "@superblocksteam/shared";
 import { applyErrorHandling, } from "../errors/error-handler.js";
 import { makeServerError } from "../errors/make-server-error.js";
-import { getErrorMeta, getLogger } from "../util/logger.js";
+import { POLICY_GATE_RUN_SYNC_BLOCKED_ERROR, policyGateRunRegistry, } from "../policy-gate-run-registry.js";
+import { getErrorMeta } from "../util/logger.js";
 import { OperationQueue } from "../util/operation-queue.js";
 import { withResolvers } from "../util/with-resolvers.js";
+import { classifyCheckpointResult } from "./checkpoint-result.js";
 import { downloadApplicationDirectory } from "./download.js";
-import { hasSwapFiles, discardAllDrafts, commitAllDrafts, getDraftInfo, createDraft, generateDraftDiff, } from "./draft-helpers.js";
+import { hasSwapFiles, discardAllDrafts, commitAllDrafts, getDraftInfo, createDraft, generateDraftDiff, createDraftMarkerOnly, createDraftDelete, cleanUpDraftsDirectory, } from "./draft-helpers.js";
+import { recordDraftStateReport } from "./draft-state-report-metrics.js";
 import { HashCache } from "./hash-cache.js";
-import { connectToISocketRPCServer, unwrapResponseDto, } from "./server-rpc/client.js";
-import { snapshotLocalDirectoryWithDrafts } from "./snapshot/take-snapshot.js";
+import { snapshotLocalDirectory, snapshotLocalDirectoryWithDrafts, } from "./snapshot/take-snapshot.js";
 import { uploadDirectorySnapshot } from "./snapshot/upload-snapshot.js";
 const SYNC_INTERVAL_MS = 10_000;
+/** Cap how long a continuous editing burst can defer the first upload. */
+const SYNC_MAX_WAIT_MS = 30_000;
+const AI_ACCEPT_UPLOAD_MAX_ATTEMPTS = 3;
+const AI_ACCEPT_UPLOAD_RETRY_DELAY_MS = 500;
 export var SyncServiceStatus;
 (function (SyncServiceStatus) {
     /** The sync service is not currently syncing or scheduled to sync */
@@ -23,48 +32,129 @@ export var SyncServiceStatus;
     SyncServiceStatus["DOWNLOADING"] = "DOWNLOADING";
     /** The sync service is currently syncing local -> server */
     SyncServiceStatus["UPLOADING"] = "UPLOADING";
+    /** The sync service is currently paused */
+    SyncServiceStatus["PAUSED"] = "PAUSED";
 })(SyncServiceStatus || (SyncServiceStatus = {}));
-export class SyncService extends EventEmitter {
-    // TODO: this is temporary, we will not use a fixed token for the lifetime of the sync service
-    authToken;
-    superblocksBaseUrl;
+function isDevOrLocal() {
+    const env = process.env.SUPERBLOCKS_SERVER_ENV ?? process.env.SUPERBLOCKS_ENVIRONMENT;
+    return env === "dev" || env === "local";
+}
+/**
+ * Whether `downloadDirectory()` should seed `lastCommitId` from the server's
+ * latest non-draft commit. We seed only when the field is unset:
+ *
+ * - Cold/recycled pod: `lastCommitId` is undefined (it is otherwise only
+ *   advanced by uploads), so seeding gives the restore path the correct
+ *   Bucketeer archive key instead of a stale chat-history commitId.
+ * - Warm reconnect: `lastCommitId` already holds the upload-advanced value,
+ *   which is the freshest key. We never overwrite it — the server's
+ *   `getLatestNonDraftCommitForBranch` can lag under read-replica delay and
+ *   would reintroduce the same mismatch.
+ *
+ * A branch switch clears `lastCommitId` (see `setBranchName`), so the cold-pod
+ * seed re-fires for the new branch.
+ */
+export function shouldSeedLastCommitId(currentLastCommitId, incomingCommitId) {
+    return Boolean(incomingCommitId) && !currentLastCommitId;
+}
+/**
+ * Returns log level for sync errors.
+ * Shutdown/connection closed = warn (expected during teardown or transient).
+ * Page not found = warn in dev/local (expected in ephemeral), error elsewhere.
+ */
+function getSyncErrorLogLevel(error) {
+    const msg = error?.message ?? "";
+    if (msg.includes("RPC client is shutting down") ||
+        msg.includes("Connection closed")) {
+        return "warn";
+    }
+    if (msg.includes("Page not found")) {
+        return isDevOrLocal() ? "warn" : "error";
+    }
+    return "error";
+}
+function logSyncError(logger, error, message, attributes = {}) {
+    const errorMeta = { ...attributes, ...getErrorMeta(error) };
+    const level = getSyncErrorLogLevel(error);
+    if (level === "warn") {
+        // Logger.warn() has a variadic (...messages) signature and does not
+        // forward the second argument as structured ErrorMeta to log listeners.
+        // Use logger.error() so that meta is preserved, but include
+        // "[expected]" so it's clear this is a downgraded/expected error.
+        logger.error(`${message} [expected]`, errorMeta);
+    }
+    else {
+        logger.error(message, errorMeta);
+    }
+}
+export function isTransientAiAcceptUploadError(error) {
+    const msg = error?.message ?? "";
+    return (msg.includes("Connection closed") ||
+        msg.includes("Failed to connect to socket") ||
+        msg.includes("RPC client is shutting down") ||
+        msg.includes("RPC timeout") ||
+        msg.toLowerCase().includes("deadline exceeded"));
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export class SyncService extends TracedEventEmitter {
     appRootDirPath;
     applicationId;
-    branchName;
+    _branchName;
     generationNumberSequence;
     lastSyncedGenerationNumber;
     hashCache = new HashCache();
     // TODO: this can be private, we leave it public for now because tsc complains that its value is never read
     lastSyncedDirectoryHash;
+    /** The most recent commit ID returned by the server after a successful commit */
+    lastCommitId;
     // A queue to ensure that all filesystem operations are executed one at a time
     fsOperationQueue;
     // A queue to ensure that the actual sync operations are executed one at a time
     syncOperationQueue = new OperationQueue();
+    draftStateReportQueue = new OperationQueue();
+    draftStateReports = new Map();
     /** This will be defined if (and only if) a sync is currently pending */
     pendingSyncUp;
+    handledAutosyncUploads = new WeakSet();
+    latestAutosyncPreparation;
+    latestAutosyncUpload;
+    /** When true, `uploadDirectory()` short-circuits so the migration can
+     *  run `flipTemplate()` without waiting behind autosave queue entries. */
+    _autoSyncPaused = false;
     lockService;
     _status = SyncServiceStatus.IDLE;
     _synchronizationStatus = SyncronizationStatus.SERVER_AHEAD;
     _tracer;
+    _rpcClient;
+    _logger;
+    _moduleInvalidationCallback;
+    removeManualCommitsEnabled;
     constructor(config) {
-        super();
+        super(config.tracer);
         this.fsOperationQueue = config.fsOperationQueue;
-        this.authToken = config.authToken;
-        this.superblocksBaseUrl = config.superblocksBaseUrl;
-        this.appRootDirPath = config.appRootDirPath;
+        // Normalize path to handle Windows drive letter case
+        this.appRootDirPath = normalizePath(config.appRootDirPath);
         this.applicationId = config.applicationId;
-        this.branchName = config.branchName;
+        this._branchName = config.branchName;
         this.lockService = config.lockService;
         this._tracer = config.tracer;
+        this._rpcClient = config.rpcClient;
+        this._logger = config.logger;
+        this.removeManualCommitsEnabled =
+            config.removeManualCommitsEnabled ?? false;
         applyErrorHandling(this, {
             downloadDirectory: { operation: "syncing directory from server" },
             uploadDirectory: { operation: "syncing directory to server" },
+            syncCurrentDirectoryWithDraftsNow: {
+                operation: "syncing current directory to server",
+            },
             hasLocalDraftChanges: { operation: "checking for local draft changes" },
             commitLocalDraftChanges: { operation: "committing local draft changes" },
         });
         const methods = [
             "downloadDirectory",
             "uploadDirectory",
+            "syncCurrentDirectoryWithDraftsNow",
             "uploadDirectoryNowIfNeeded",
             "scheduleUploadDirectory",
             "performUploadDirectory",
@@ -76,29 +166,62 @@ export class SyncService extends EventEmitter {
         ];
         addTracingToMethods(this, methods, this._tracer);
     }
+    getLogger() {
+        return this._logger;
+    }
+    get branchName() {
+        return this._branchName;
+    }
+    get serverBaseUrl() {
+        return this._rpcClient.baseUrl;
+    }
+    get serverAuthToken() {
+        return this._rpcClient.authTokenValue;
+    }
+    get currentBranchName() {
+        return this._branchName;
+    }
+    setBranchName(nextBranchName) {
+        if (this._branchName === nextBranchName) {
+            return;
+        }
+        const previousBranchName = this._branchName;
+        this._branchName = nextBranchName;
+        this.pendingSyncUp = undefined;
+        this.lastSyncedDirectoryHash = undefined;
+        this.lastSyncedGenerationNumber = undefined;
+        this.draftStateReports.clear();
+        // lastCommitId is per-branch: the old branch's commit is meaningless on the
+        // new one. Clearing it keeps the invariant clean and lets the cold-pod seed
+        // in downloadDirectory() re-fire for the new branch (its guard is
+        // `!this.lastCommitId`); otherwise context restore would resolve the old
+        // branch's commitId on the new branch.
+        this.lastCommitId = undefined;
+        this.setSynchronizationStatus(SyncronizationStatus.SERVER_AHEAD);
+        this.getLogger().info(`[sync-service] switched branch context from '${previousBranchName}' to '${nextBranchName}'`);
+    }
     /** The current status of the sync service, which indicates what the service is currently doing */
     get status() {
         return this._status;
     }
     set status(status) {
-        const logger = getLogger();
         this._status = status;
         const scheduledSyncTime = status === SyncServiceStatus.SCHEDULED
             ? this.pendingSyncUp?.syncTime
             : undefined;
-        logger.info(`[sync-service] statusChange: ${status}, ${scheduledSyncTime}`);
+        this.getLogger().info(`[sync-service] statusChange: ${status}, ${scheduledSyncTime}`);
         this.emit("statusChange", status, scheduledSyncTime);
     }
     /** The current synchronization status, which indicates whether the server and local directories are in sync */
     get synchronizationStatus() {
         return this._synchronizationStatus;
     }
-    set synchronizationStatus(status) {
+    setSynchronizationStatus(status, source) {
         this._synchronizationStatus = status;
         const generationNumber = status === SyncronizationStatus.IN_SYNC
             ? this.lastSyncedGenerationNumber
             : undefined;
-        this.emit("synchronizationStatusChange", status, generationNumber);
+        this.emit("synchronizationStatusChange", status, generationNumber, source);
     }
     /**
      * Enqueues a filesystem operation to be executed one at a time and avoiding conflicts with sync operations.
@@ -106,34 +229,71 @@ export class SyncService extends EventEmitter {
     fsOperation(operation) {
         return this.fsOperationQueue.enqueue(operation);
     }
+    /**
+     * Sets a callback to invalidate Vite's module graph when files are created/modified.
+     * This ensures that TypeScript checks and builds get fresh data after file writes.
+     *
+     * @param callback - Function that takes a file path (relative to app root) and invalidates the module
+     */
+    setModuleInvalidationCallback(callback) {
+        this._moduleInvalidationCallback = callback;
+    }
     /**
      * Pulls the application down from the server.
      */
     downloadDirectory() {
-        const logger = getLogger();
-        logger.info("[sync-service] Synchronizating application from the server");
+        this.getLogger().info("[sync-service] Synchronizating application from the server");
         return this.fsOperation(async () => {
             this.status = SyncServiceStatus.DOWNLOADING;
-            const rpcClient = await this.getRpcClient();
             try {
-                const directoryHash = await downloadApplicationDirectory({
-                    rpcClient,
-                    applicationId: this.applicationId,
-                    branch: this.branchName,
-                    localDirectoryPath: this.appRootDirPath,
-                    hashCache: this.hashCache,
+                const { directoryHash, latestNonDraftCommitId } = await this._rpcClient.call(async (rpcClient) => {
+                    return await downloadApplicationDirectory({
+                        rpcClient,
+                        applicationId: this.applicationId,
+                        branch: this._branchName,
+                        localDirectoryPath: this.appRootDirPath,
+                        hashCache: this.hashCache,
+                    });
                 });
                 this.lastSyncedDirectoryHash = directoryHash;
-                this.synchronizationStatus = SyncronizationStatus.IN_SYNC;
-                logger.info("[sync-service] Synchronization finished");
+                // Seed lastCommitId from the server's latest non-draft commit so
+                // context restore resolves the correct Bucketeer archive on a
+                // cold/recycled pod. See shouldSeedLastCommitId for why we only seed
+                // when the field is unset and never overwrite a warm pod's
+                // upload-advanced value.
+                if (shouldSeedLastCommitId(this.lastCommitId, latestNonDraftCommitId)) {
+                    this.lastCommitId = latestNonDraftCommitId;
+                    this.emit("commitIdChanged", latestNonDraftCommitId);
+                    this.getLogger().info(`[sync-service] seeded lastCommitId=${latestNonDraftCommitId} appId=${this.applicationId} branch=${this._branchName ?? "<none>"} from server on cold-pod download`);
+                }
+                else if (latestNonDraftCommitId && this.lastCommitId) {
+                    // Warm reconnect: the server returned a commit but we keep the
+                    // upload-advanced value. A divergence here is the exact precursor to
+                    // the context-loss this fix addresses (e.g. server behind read-replica
+                    // lag), so surface it at info; log the matching case at debug to keep
+                    // prod dashboards quiet.
+                    if (this.lastCommitId !== latestNonDraftCommitId) {
+                        this.getLogger().info(`[sync-service] warm reconnect: kept lastCommitId=${this.lastCommitId}, server returned ${latestNonDraftCommitId} (values differ, not overwriting) appId=${this.applicationId}`);
+                    }
+                    else {
+                        this.getLogger().debug(`[sync-service] warm reconnect: kept lastCommitId=${this.lastCommitId}, server returned matching value appId=${this.applicationId}`);
+                    }
+                }
+                else if (!latestNonDraftCommitId && !this.lastCommitId) {
+                    // Cold pod with no server-side non-draft commit (new app or
+                    // draft-only branch): nothing to seed, context restore will fall back
+                    // to chat history. Log at debug to distinguish this from a warm skip.
+                    this.getLogger().debug(`[sync-service] cold-pod download: server returned no non-draft commitId (new app or draft-only branch), context restore will fall back to chat history appId=${this.applicationId} branch=${this._branchName ?? "<none>"}`);
+                }
+                this.setSynchronizationStatus(SyncronizationStatus.IN_SYNC);
+                this.getLogger().info("[sync-service] Synchronization finished");
             }
             catch (err) {
-                logger.error("[sync-service] Error synchronizing application from the server", getErrorMeta(err));
+                logSyncError(this.getLogger(), err, "[sync-service] Error synchronizing application from the server");
                 throw err;
             }
             finally {
                 this.status = SyncServiceStatus.IDLE;
-                rpcClient.close();
             }
         });
     }
@@ -146,20 +306,61 @@ export class SyncService extends EventEmitter {
      * operations.
      * This method is also idempotent.
      */
-    uploadDirectory() {
-        const logger = getLogger();
-        logger.info("[sync-service] Application updated, scheduling synchronization");
-        this.synchronizationStatus = SyncronizationStatus.LOCAL_AHEAD;
+    uploadDirectory(source) {
+        if (this._autoSyncPaused) {
+            this.getLogger().info("[sync-service] Auto-sync paused (migration in progress), skipping upload");
+            return Promise.resolve();
+        }
+        this.getLogger().info(`[sync-service] Application updated, scheduling synchronization (source=${source})`);
+        this.setSynchronizationStatus(SyncronizationStatus.LOCAL_AHEAD, source);
+        const preparation = Symbol();
+        this.latestAutosyncPreparation = preparation;
+        this.latestAutosyncUpload = undefined;
         return this.fsOperation(async () => {
-            // Snapshot with uncommitted state (including drafts)
-            const directorySnapshot = await snapshotLocalDirectoryWithDrafts(this.appRootDirPath);
-            const completedPromise = this.scheduleUploadDirectory(directorySnapshot, false, this.generationNumberSequence?.currentValue);
-            completedPromise.then(() => {
-                logger.info("[sync-service] Synchronization completed");
-            }, (err) => {
-                logger.error("[sync-service] error syncing directory to server", getErrorMeta(err));
-                this.emit("error", makeServerError(err));
-            });
+            try {
+                // Snapshot with uncommitted state (including drafts)
+                const directorySnapshot = await snapshotLocalDirectoryWithDrafts(this.appRootDirPath);
+                this.getLogger().info(`[sync-service] Snapshot captured for upload (source=${source})`);
+                const completedPromise = this.scheduleUploadDirectory(directorySnapshot, false, this.generationNumberSequence?.currentValue, source);
+                void this.trackAutosyncUpload(completedPromise, source, preparation);
+            }
+            catch (err) {
+                if (this.latestAutosyncPreparation === preparation) {
+                    this.latestAutosyncPreparation = undefined;
+                    logSyncError(this.getLogger(), err, "[sync-service] error preparing directory sync");
+                    this.reportAutosyncError(err, source);
+                }
+                throw err;
+            }
+        });
+    }
+    trackAutosyncUpload(completedPromise, source, preparation) {
+        if (!preparation || this.latestAutosyncPreparation === preparation) {
+            this.latestAutosyncPreparation = undefined;
+            this.latestAutosyncUpload = completedPromise;
+        }
+        if (this.handledAutosyncUploads.has(completedPromise)) {
+            return completedPromise;
+        }
+        this.handledAutosyncUploads.add(completedPromise);
+        completedPromise.then(() => {
+            this.getLogger().info("[sync-service] Synchronization completed");
+        }, (err) => {
+            logSyncError(this.getLogger(), err, "[sync-service] error syncing directory to server");
+            if (this.latestAutosyncUpload !== completedPromise) {
+                return;
+            }
+            this.reportAutosyncError(err, source);
+        });
+        return completedPromise;
+    }
+    reportAutosyncError(error, source) {
+        this.setSynchronizationStatus(SyncronizationStatus.ERROR, source);
+        this.emit("error", {
+            ...makeServerError(error instanceof Error || (typeof error === "object" && error !== null)
+                ? error
+                : new Error(String(error))),
+            type: "dev-server/sync",
         });
     }
     /**
@@ -168,96 +369,399 @@ export class SyncService extends EventEmitter {
      *
      * @returns the dbfs hash of the most recent sync
      */
-    uploadDirectoryNowIfNeeded() {
+    uploadDirectoryNowIfNeeded(source) {
         if (!this.pendingSyncUp) {
-            const logger = getLogger();
-            logger.info("[sync-service] No pending sync, skipping");
-            return Promise.resolve(this.lastSyncedDirectoryHash || "");
+            this.getLogger().info("[sync-service] No pending sync, skipping");
+            return Promise.resolve({
+                directoryHash: this.lastSyncedDirectoryHash || "",
+                commitId: undefined,
+            });
         }
         const directorySnapshot = this.pendingSyncUp.directorySnapshot;
-        const logger = getLogger();
-        logger.info("[sync-service] Performing immediate sync");
+        this.getLogger().info(`[sync-service] Performing immediate sync (source=${source})`);
+        const preparation = Symbol();
+        this.latestAutosyncPreparation = preparation;
+        this.latestAutosyncUpload = undefined;
         return this.fsOperation(async () => {
-            const completedPromise = this.scheduleUploadDirectory(directorySnapshot, true, this.generationNumberSequence?.currentValue);
-            const directoryHash = await completedPromise;
-            logger.info("[sync-service] Synchronization completed");
-            return directoryHash;
+            const completedPromise = this.scheduleUploadDirectory(directorySnapshot, true, this.generationNumberSequence?.currentValue, source);
+            return await this.trackAutosyncUpload(completedPromise, source, preparation);
         });
     }
-    scheduleUploadDirectory(directorySnapshot, performNow, generationNumber) {
+    /**
+     * Immediately sync the current local application directory to the server,
+     * including local draft files, even when autosync has no pending snapshot.
+     *
+     * Use this for operations that need read-your-writes semantics against DBFS.
+     * `uploadDirectoryNowIfNeeded` is only an autosync drain; it can legally
+     * return the last synced hash when no autosync is pending.
+     */
+    syncCurrentDirectoryWithDraftsNow(source) {
+        this.getLogger().info(`[sync-service] Syncing current directory with drafts (source=${source})`);
+        return this.fsOperation(async () => {
+            const directorySnapshot = await snapshotLocalDirectoryWithDrafts(this.appRootDirPath);
+            const completedPromise = this.scheduleUploadDirectory(directorySnapshot, true, this.generationNumberSequence?.currentValue, source);
+            const result = await completedPromise;
+            this.getLogger().info("[sync-service] Current directory synchronization completed");
+            return result;
+        });
+    }
+    scheduleUploadDirectory(directorySnapshot, performNow, generationNumber, source) {
         if (performNow && this.pendingSyncUp) {
             // There is already a sync pending, cancel it so that we can schedule a new one, to be performed immediately
             clearTimeout(this.pendingSyncUp.timeoutId);
             this.pendingSyncUp = undefined;
         }
         if (this.pendingSyncUp) {
-            // There is already a sync pending, we don't need to schedule a new one, we will use the existing one but
-            // we will update the directory snapshot
+            // Coalesce into the pending sync: refresh the snapshot, and for autosave
+            // reset the idle timer (trailing debounce) up to the burst max wait.
+            // `source` deliberately keeps the value that opened the burst — the
+            // server classifies the commit by it.
             this.pendingSyncUp.directorySnapshot = directorySnapshot;
             this.pendingSyncUp.generationNumber = generationNumber;
+            if (!performNow && this.removeManualCommitsEnabled) {
+                this.armPendingSyncTimeout(this.nextAutosyncDelayMs(this.pendingSyncUp.burstStartedAt));
+            }
         }
         else {
             const { promise: completedPromise, resolve, reject, } = withResolvers();
-            const logger = getLogger();
-            const timeoutDelayMs = performNow ? 0 : SYNC_INTERVAL_MS;
-            const pendingSyncUp = {
+            const burstStartedAt = performance.now();
+            const timeoutDelayMs = performNow
+                ? 0
+                : this.nextAutosyncDelayMs(burstStartedAt);
+            this.pendingSyncUp = {
+                burstStartedAt,
+                completed: completedPromise,
                 directorySnapshot,
                 generationNumber,
+                reject,
+                resolve,
+                source,
                 syncTime: performance.now() + timeoutDelayMs,
-                timeoutId: setTimeout(async () => {
-                    this.pendingSyncUp = undefined;
-                    await this.syncOperationQueue.enqueue(async () => {
-                        try {
-                            const isLockValid = await this.lockService.checkAndUpdateLockIfPossible();
-                            if (!isLockValid) {
-                                throw new Error("Lock is not valid");
-                            }
-                            const directoryHash = await this.performUploadDirectory(
-                            // Note: we should not use `directorySnapshot` here, because it might have changed since when the sync was
-                            // originally scheduled which is when we captured the value of this lexical variable
-                            pendingSyncUp.directorySnapshot, pendingSyncUp.generationNumber);
-                            this.lastSyncedDirectoryHash = directoryHash;
-                            resolve(directoryHash);
-                        }
-                        catch (error) {
-                            logger.error("[sync-service] Error synchronizing directory to server: " +
-                                error, getErrorMeta(error));
-                            reject(error);
-                        }
-                    });
-                }, timeoutDelayMs),
-                completed: completedPromise,
             };
-            this.pendingSyncUp = pendingSyncUp;
+            this.armPendingSyncTimeout(timeoutDelayMs);
         }
         this.status = SyncServiceStatus.SCHEDULED;
         return this.pendingSyncUp.completed;
     }
+    /**
+     * Idle interval, capped so a continuous editing burst still uploads by
+     * SYNC_MAX_WAIT_MS after the first change.
+     */
+    nextAutosyncDelayMs(burstStartedAt) {
+        const remainingMaxMs = SYNC_MAX_WAIT_MS - (performance.now() - burstStartedAt);
+        if (remainingMaxMs <= 0) {
+            return 0;
+        }
+        return Math.min(SYNC_INTERVAL_MS, remainingMaxMs);
+    }
+    armPendingSyncTimeout(timeoutDelayMs) {
+        const pendingSyncUp = this.pendingSyncUp;
+        if (!pendingSyncUp) {
+            return;
+        }
+        clearTimeout(pendingSyncUp.timeoutId);
+        pendingSyncUp.syncTime = performance.now() + timeoutDelayMs;
+        pendingSyncUp.timeoutId = setTimeout(() => {
+            void (async () => {
+                this.pendingSyncUp = undefined;
+                await this.syncOperationQueue.enqueue(async () => {
+                    try {
+                        const isLockValid = await this.lockService.ensureLockForWrite();
+                        if (!isLockValid) {
+                            throw new Error("Lock is not valid");
+                        }
+                        const result = await this.performUploadDirectory(
+                        // Note: we should not use a lexical snapshot — it may have changed
+                        // since the sync was originally scheduled.
+                        pendingSyncUp.directorySnapshot, pendingSyncUp.generationNumber, pendingSyncUp.source);
+                        this.lastSyncedDirectoryHash = result.directoryHash;
+                        pendingSyncUp.resolve(result);
+                    }
+                    catch (error) {
+                        logSyncError(this.getLogger(), error, "[sync-service] Error synchronizing directory to server: " +
+                            error?.message);
+                        pendingSyncUp.reject(error);
+                    }
+                });
+            })();
+        }, timeoutDelayMs);
+    }
+    cancelPendingSync() {
+        if (this.pendingSyncUp) {
+            clearTimeout(this.pendingSyncUp.timeoutId);
+            this.pendingSyncUp = undefined;
+        }
+        this.status = SyncServiceStatus.PAUSED;
+    }
+    /**
+     * Prevents future `uploadDirectory()` calls from enqueuing work into
+     * `fsOperationQueue` / `syncOperationQueue`.  Also cancels any pending
+     * timeout-based sync that hasn't fired yet.
+     *
+     * This is used by the v2→v3 migration: the restructure step writes many
+     * files, and the Vite file-watcher would normally funnel each change into
+     * `uploadDirectory()`.  By pausing first we keep the queues empty so that
+     * `flipTemplate()` can enqueue immediately.
+     *
+     * Call `resumeAutoSync()` in failure paths so the user can continue
+     * editing normally.  On success the SABS pod restarts with a fresh
+     * SyncService instance, so resume is unnecessary.
+     */
+    pauseAutoSync() {
+        this._autoSyncPaused = true;
+        this.cancelPendingSync();
+    }
+    /**
+     * Re-enables the normal `uploadDirectory()` auto-sync path after a
+     * failed migration so edits are no longer silently dropped.
+     */
+    resumeAutoSync() {
+        this._autoSyncPaused = false;
+        this.status = SyncServiceStatus.IDLE;
+    }
+    /**
+     * Takes a snapshot of an arbitrary local directory and uploads it to DBFS.
+     * Used by the git deploy flow to upload a worktree snapshot for a main branch commit.
+     * Does NOT create any internal commits — the caller is responsible for that.
+     */
+    async uploadSnapshotToDbfs(localDirectoryPath) {
+        const snapshot = await snapshotLocalDirectory(localDirectoryPath);
+        await this._rpcClient.call(async (rpcClient) => {
+            await this.uploadDirectoryWithRetry(rpcClient, snapshot);
+        });
+        this.hashCache.add_directory_recursive(snapshot);
+        return { directoryHash: snapshot.hash };
+    }
+    /**
+     * Uploads the local application directory to the server, retrying if the server returns a BadRequestError.
+     */
+    async uploadDirectoryWithRetry(rpcClient, directorySnapshot) {
+        let retryCount = 0;
+        while (retryCount < 3) {
+            try {
+                await uploadDirectorySnapshot(rpcClient, directorySnapshot, this.hashCache);
+                return;
+            }
+            catch (error) {
+                if (error instanceof BadRequestError) {
+                    retryCount++;
+                    logSyncError(this.getLogger(), error, "[sync-service] Error synchronizing directory and server with error: " +
+                        error.message);
+                    if (retryCount === 3) {
+                        this.getLogger().error("[sync-service] Directory upload failed after max retry attempts", getErrorMeta(error));
+                        this.logWarnStructured("[sync-service] Directory upload failed", {
+                            "application.id": this.applicationId,
+                            attempts: retryCount,
+                            "branch.name": this._branchName,
+                            outcome: "upload_failed",
+                            status: error.status,
+                        });
+                        throw error;
+                    }
+                    this.getLogger().warn("[sync-service] Retrying upload due to BadRequestError and clearing hash cache");
+                    this.hashCache.empty();
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
     /**
      * Performs the actual upload of the local application directory to the server.
+     *
+     * `targetTemplateName` is only meaningful when `source === 'migrate:templateFlip'`.
+     * It is threaded into the RPC payload so the server can atomically update
+     * `application_v2.template_name` in the same transaction that creates the
+     * first post-migration commit.
      */
-    async performUploadDirectory(directorySnapshot, generationNumber) {
+    async performUploadDirectory(directorySnapshot, generationNumber, source, targetTemplateName, migrationGeneration, selfRestart) {
+        // Block syncing local edits while a policy gate run is executing so the
+        // application cannot change out from under the run's target (APPS-4466).
+        // This is the single funnel for every upload path (autosave + explicit).
+        if (policyGateRunRegistry.isRunning(this.applicationId)) {
+            this.getLogger().info("[sync-service] Skipping directory upload while a policy gate run is in progress");
+            throw new Error(POLICY_GATE_RUN_SYNC_BLOCKED_ERROR);
+        }
+        this.getLogger().info(`[sync-service] performUploadDirectory starting (source=${source})`);
         this.status = SyncServiceStatus.UPLOADING;
-        const rpcClient = await this.getRpcClient();
         try {
-            await uploadDirectorySnapshot(rpcClient, directorySnapshot, this.hashCache);
+            await this._rpcClient.call(async (rpcClient) => {
+                await this.uploadDirectoryWithRetry(rpcClient, directorySnapshot);
+            });
             // Now that the directory has been uploaded, we know that all of its hashes are in the server,
             // so we can add them to the hash cache
             this.hashCache.add_directory_recursive(directorySnapshot);
-            await unwrapResponseDto(rpcClient.call.v3.application.liveEditDirectoryContents.set({
-                applicationId: this.applicationId,
-                branchName: this.branchName,
-                hash: directorySnapshot.hash,
-            }));
+            const { degradedMode, commitId, commitMessage, checkpointSkipped } = await this._rpcClient.call(async (rpcClient) => {
+                const payload = {
+                    applicationId: this.applicationId,
+                    branchName: this._branchName,
+                    hash: directorySnapshot.hash,
+                    source: source,
+                };
+                if (source === "migrate:templateFlip" && targetTemplateName) {
+                    payload.targetTemplateName = targetTemplateName;
+                }
+                if ((source === "migrate:backup" ||
+                    source === "migrate:templateFlip") &&
+                    migrationGeneration !== undefined) {
+                    payload.migrationGeneration = migrationGeneration;
+                }
+                // The "will self-restart in place" handshake: tell the server it can
+                // skip terminating the live-edit pod after the flip because the dev
+                // server will respawn itself in place (same pod/pitcherURL). Sent
+                // only on the flip RPC and only when true, so the fallback
+                // (flag off / unsupervised) is byte-identical to today's behavior.
+                if (source === "migrate:templateFlip" && selfRestart) {
+                    payload.selfRestart = true;
+                }
+                this.getLogger().info(`[sync-service] setApplicationHash RPC start (source=${source})`);
+                return unwrapResponseDto(rpcClient.call.v3.application.liveEditDirectoryContents.set(payload));
+            });
+            if (degradedMode) {
+                const errMsg = "There is an issue with the application and it was put in degraded mode: " +
+                    degradedMode.errors.map((e) => e.message).join("\n");
+                this.getLogger().error("[sync-service] " + errMsg);
+            }
+            this.getLogger().info(`[sync-service] performUploadDirectory completed (source=${source} degraded=${!!degradedMode})`);
+            const checkpointLog = classifyCheckpointResult(commitId, checkpointSkipped);
+            if (checkpointLog.level === "info") {
+                this.getLogger().info(`[sync-service] No checkpoint created by design (reason=${checkpointLog.reason} source=${source})`);
+            }
+            else if (checkpointLog.level === "warn") {
+                // The only genuine failure signal: the server expected to checkpoint
+                // but returned neither a commitId nor a by-design skip reason.
+                this.getLogger().warn(`[sync-service] No commitId and no skip reason returned from server - checkpoint creation may have failed (source=${source})`);
+            }
+            this.emit("degradedModeChange", degradedMode);
             this.lastSyncedGenerationNumber = generationNumber;
-            this.synchronizationStatus = SyncronizationStatus.IN_SYNC;
-            return directorySnapshot.hash;
+            this.setSynchronizationStatus(SyncronizationStatus.IN_SYNC, source);
+            if (commitId) {
+                this.lastCommitId = commitId;
+                this.emit("commitIdChanged", commitId);
+                this.emit("checkpointCreated", { commitId, commitMessage });
+            }
+            return {
+                checkpointSkipped,
+                commitId,
+                directoryHash: directorySnapshot.hash,
+            };
         }
         finally {
             this.status = SyncServiceStatus.IDLE;
-            rpcClient.close();
         }
     }
+    /**
+     * Atomically flip the application's template to `targetTemplateName` and
+     * upload the current local directory (which the caller must have already
+     * restructured to match the new template) as the first commit on that
+     * template. This is the V2 -> V3 migration entry point invoked by the
+     * dev server after it finishes the deterministic folder restructure.
+     *
+     * The server performs three things in a single database transaction:
+     *   1. update application_v2.template_name = targetTemplateName
+     *   2. advance the live-edit directory hash to the uploaded snapshot
+     *   3. create a new application_commit that inherits the new template_name
+     * After the transaction commits, the server terminates the SABS live-edit
+     * pod so the next pod starts with the new TEMPLATE_NAME env var -- unless
+     * `selfRestart` is set, in which case the dev server has signaled it will
+     * respawn itself in place (keeping the same pod) and the server skips
+     * termination. Older deployed/preview commits retain their original
+     * template_name and keep rendering on the legacy runtime.
+     */
+    async flipTemplate({ targetTemplateName, migrationGeneration, selfRestart, }) {
+        if (!targetTemplateName) {
+            throw new BadRequestError("flipTemplate requires a non-empty targetTemplateName");
+        }
+        this.getLogger().info(`[sync-service] Flipping template to ${targetTemplateName}`);
+        return this.fsOperation(async () => {
+            const directorySnapshot = await snapshotLocalDirectoryWithDrafts(this.appRootDirPath);
+            return this.syncOperationQueue.enqueue(async () => {
+                const isLockValid = await this.lockService.ensureLockForWrite();
+                if (!isLockValid) {
+                    throw new Error("Lock is not valid");
+                }
+                const result = await this.performUploadDirectory(directorySnapshot, this.generationNumberSequence?.currentValue, "migrate:templateFlip", targetTemplateName, migrationGeneration, selfRestart);
+                this.lastSyncedDirectoryHash = result.directoryHash;
+                if (result.commitId) {
+                    this.lastCommitId = result.commitId;
+                    this.emit("commitIdChanged", result.commitId);
+                }
+                return result;
+            });
+        });
+    }
+    /**
+     * Snapshot the current local directory and push it to the server as a
+     * named pre-migration checkpoint, regardless of whether anything changed
+     * vs the last sync.
+     *
+     * `uploadDirectoryNowIfNeeded` is not a fit here: it short-circuits when
+     * there is no pending snapshot, and on the server side a plain `edit`
+     * source also short-circuits when the hash matches the last checkpoint.
+     * Both are correct for normal autosave behavior -- but the whole point of
+     * the pre-migration backup is to produce a restore target precisely when
+     * nothing has changed (i.e. "checkpoint what is on disk right now, before
+     * I move it to scratch/v2-backup").
+     *
+     * The server recognizes `source: 'migrate:backup'` and unconditionally
+     * writes a SAVEPOINT_MANUAL commit whose `template_name` is inherited
+     * from the still-unflipped `application_v2.template_name`, i.e. the
+     * legacy template. That makes the backup commit a valid rollback target
+     * for the v2 runtime.
+     */
+    async backupCurrentDirectory({ migrationGeneration, } = {}) {
+        this.getLogger().info("[sync-service] Taking pre-migration backup snapshot");
+        return this.fsOperation(async () => {
+            const directorySnapshot = await snapshotLocalDirectoryWithDrafts(this.appRootDirPath);
+            return this.syncOperationQueue.enqueue(async () => {
+                const isLockValid = await this.lockService.ensureLockForWrite();
+                if (!isLockValid) {
+                    throw new Error("Lock is not valid");
+                }
+                const result = await this.performUploadDirectory(directorySnapshot, this.generationNumberSequence?.currentValue, "migrate:backup", undefined, migrationGeneration);
+                this.lastSyncedDirectoryHash = result.directoryHash;
+                if (result.commitId) {
+                    this.lastCommitId = result.commitId;
+                    this.emit("commitIdChanged", result.commitId);
+                }
+                return result;
+            });
+        });
+    }
+    /**
+     * Resolve datasource integration IDs (UUIDs) to plugin IDs.
+     * Used by migration preflight to classify whether UUID-backed steps map to
+     * supported SDK integration types.
+     */
+    async getIntegrationPluginIds(integrationIds) {
+        const uniqueIntegrationIds = [...new Set(integrationIds)];
+        if (uniqueIntegrationIds.length === 0) {
+            return new Map();
+        }
+        const endpoint = new URL("api/v1/integrations", this._rpcClient.baseUrl);
+        for (const integrationId of uniqueIntegrationIds) {
+            endpoint.searchParams.append("id", integrationId);
+        }
+        const response = await fetch(endpoint.toString(), {
+            headers: {
+                Authorization: `Bearer ${this._rpcClient.authTokenValue}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to resolve integration plugin IDs: ${response.status} ${response.statusText}`);
+        }
+        const body = (await response.json());
+        const result = new Map();
+        for (const integration of body.data ?? []) {
+            if (typeof integration.id === "string" &&
+                typeof integration.pluginId === "string") {
+                result.set(integration.id, integration.pluginId);
+            }
+        }
+        return result;
+    }
     /**
      * Checks if there are any local draft changes (.sbswap.edit and .sbswap.add files).
      *
@@ -265,13 +769,15 @@ export class SyncService extends EventEmitter {
      */
     async hasLocalDraftChanges() {
         return this.fsOperation(async () => {
-            return await hasSwapFiles(this.appRootDirPath);
+            const result = await hasSwapFiles(this.appRootDirPath);
+            this.getLogger().info(`[sync-service] hasLocalDraftChanges=${result}`);
+            return result;
         });
     }
     /**
      * Gets information about current draft changes.
      *
-     * @returns A promise that resolves to information about draft edits and additions.
+     * @returns A promise that resolves to information about draft edits, additions, and deletions.
      */
     async getDraftChanges() {
         return this.fsOperation(async () => {
@@ -296,34 +802,72 @@ export class SyncService extends EventEmitter {
      * @returns A promise that resolves when the draft edit or addition is created.
      */
     async createDraftFile(filePath, draftContent) {
-        const logger = getLogger();
+        // Normalize path for cross-platform compatibility (Windows)
+        const normalizedFilePath = normalizePath(filePath);
+        this.getLogger().info(`[sync-service] Creating draft file: ${normalizedFilePath}`);
         await this.fsOperation(async () => {
-            const fullPath = `${this.appRootDirPath}/${filePath}`;
+            const path = await import("node:path");
+            const fullPath = path.join(this.appRootDirPath, normalizedFilePath);
             const type = await createDraft(fullPath, draftContent, this.appRootDirPath);
             if (type === "edit") {
-                logger.info(`[sync-service] Draft edit created for: ${filePath}`);
+                this.getLogger().info(`[sync-service] Draft edit created for: ${normalizedFilePath}`);
             }
             else {
-                logger.info(`[sync-service] Draft addition created for: ${filePath}`);
+                this.getLogger().info(`[sync-service] Draft addition created for: ${normalizedFilePath}`);
+            }
+            // Invalidate Vite's module graph for this file
+            if (this._moduleInvalidationCallback) {
+                this._moduleInvalidationCallback(normalizedFilePath);
+                this.getLogger().info(`[sync-service] Triggered Vite module invalidation for: ${normalizedFilePath}`);
             }
         });
-        this.emit("draftStateChanged", true);
+        this.getLogger().info("[sync-service] Draft file created", {
+            filePath: normalizedFilePath,
+        });
+        this.notifyDraftStateChanged(true);
+    }
+    /**
+     * Creates the marker file only for a draft edit or addition.
+     * Compare to `createDraftFile`. This method does not actually write content to target file.
+     *
+     * @param filePath - The path to the file for which to create the respective marker (relative to app root).
+     * @returns A promise that resolves when the draft edit or addition marker is created.
+     */
+    async createDraftMarkerOnly(filePath) {
+        await this.fsOperation(async () => {
+            const fullPath = `${this.appRootDirPath}/${filePath}`;
+            await createDraftMarkerOnly(fullPath, this.appRootDirPath);
+        });
+        this.notifyDraftStateChanged(true);
+    }
+    /**
+     * Creates a draft deletion by backing up the file and removing it from the workspace.
+     *
+     * @param filePath - The path to the file to delete (relative to app root).
+     * @returns A promise that resolves when the draft deletion is created.
+     */
+    async createDraftDelete(filePath) {
+        await this.fsOperation(async () => {
+            const fullPath = `${this.appRootDirPath}/${filePath}`;
+            await createDraftDelete(fullPath, this.appRootDirPath);
+        });
+        this.notifyDraftStateChanged(true);
     }
     /**
      * Discards all local draft changes by restoring original files and removing draft additions.
      *
      * @returns A promise that resolves when all draft changes have been discarded.
      */
-    async discardLocalDraftChanges() {
-        const logger = getLogger();
-        logger.info("[sync-service] Discarding local draft changes");
-        this.fsOperation(async () => {
+    async discardLocalDraftChanges(source) {
+        this.getLogger().info("[sync-service] Discarding local draft changes");
+        await this.fsOperation(async () => {
             await discardAllDrafts(this.appRootDirPath);
             // Emit event so UI can refresh
-            logger.info("[sync-service] Local draft changes discarded");
+            this.getLogger().info("[sync-service] Local draft changes discarded");
         });
-        this.uploadDirectory();
-        this.emit("draftStateChanged", false);
+        await this.uploadDirectory(source);
+        await this.uploadDirectoryNowIfNeeded(source);
+        this.notifyDraftStateChanged(false);
     }
     /**
      * Commits all draft changes by removing .sbswap.edit and .sbswap.add markers.
@@ -331,21 +875,222 @@ export class SyncService extends EventEmitter {
      *
      * @returns A promise that resolves when all drafts have been committed.
      */
-    async commitLocalDraftChanges() {
-        const logger = getLogger();
-        logger.info("[sync-service] Committing local draft changes");
-        this.fsOperation(async () => {
+    async commitLocalDraftChanges(source) {
+        const checkpointAttemptId = source === "ai:accept" ? randomUUID() : undefined;
+        if (checkpointAttemptId) {
+            this.getLogger().info(`[sync-service] Committing local draft changes (source=${source})`, { checkpointAttemptId });
+        }
+        else {
+            this.getLogger().info(`[sync-service] Committing local draft changes (source=${source})`);
+        }
+        await this.fsOperation(async () => {
             await commitAllDrafts(this.appRootDirPath);
-            logger.info("[sync-service] Local draft changes committed");
+            this.getLogger().info("[sync-service] Local draft changes committed");
+        });
+        const uploadResult = await this.uploadCommittedDraftForSource(source, checkpointAttemptId);
+        const result = uploadResult.result;
+        this.notifyDraftStateChanged(false);
+        this.getLogger().info(`[sync-service] commitLocalDraftChanges upload result commitId=${result.commitId ?? "none"}`);
+        if (source === "ai:accept") {
+            const checkpointLog = classifyCheckpointResult(result.commitId, result.checkpointSkipped);
+            this.logAiAcceptCheckpointOutcome({
+                attempts: uploadResult.attempts,
+                checkpointAttemptId,
+                checkpointSkipReason: checkpointLog.level === "info" ? checkpointLog.reason : undefined,
+                commitId: result.commitId,
+                outcome: this.aiAcceptCheckpointOutcomeFromLog(checkpointLog),
+            });
+        }
+        if (result.commitId) {
+            return { commitId: result.commitId };
+        }
+        return undefined;
+    }
+    async uploadCommittedDraftForSource(source, checkpointAttemptId) {
+        return source === "ai:accept"
+            ? await this.uploadCommittedDraftWithRetry(source, checkpointAttemptId)
+            : { result: await this.uploadCommittedDraft(source), attempts: 1 };
+    }
+    async uploadCommittedDraft(source) {
+        await this.uploadDirectory(source);
+        return await this.uploadDirectoryNowIfNeeded(source);
+    }
+    async uploadCommittedDraftWithRetry(source, checkpointAttemptId) {
+        for (let attempt = 1;; attempt++) {
+            try {
+                return {
+                    result: await this.uploadCommittedDraft(source),
+                    attempts: attempt,
+                };
+            }
+            catch (error) {
+                if (!isTransientAiAcceptUploadError(error)) {
+                    this.logAiAcceptCheckpointOutcome({
+                        attempts: attempt,
+                        checkpointAttemptId,
+                        error,
+                        outcome: "upload_failed",
+                    });
+                    throw error;
+                }
+                if (attempt >= AI_ACCEPT_UPLOAD_MAX_ATTEMPTS) {
+                    this.getLogger().error(`[sync-service] Committed draft upload failed after max retry attempts (source=${source} maxAttempts=${AI_ACCEPT_UPLOAD_MAX_ATTEMPTS}) [expected]`, getErrorMeta(error));
+                    this.logAiAcceptCheckpointOutcome({
+                        attempts: attempt,
+                        checkpointAttemptId,
+                        error,
+                        logError: false,
+                        outcome: "upload_failed",
+                    });
+                    throw error;
+                }
+                // Intermediate retries are expected transient transport noise; final
+                // exhaustion is logged above as an error-level signal.
+                const errorMeta = getErrorMeta(error);
+                this.getLogger().info("[sync-service] Retrying committed draft upload after transient error [expected]", {
+                    applicationId: this.applicationId,
+                    branchName: this._branchName,
+                    checkpointAttemptId,
+                    errorKind: errorMeta.error.kind,
+                    errorMessage: errorMeta.error.message,
+                    nextAttempt: attempt + 1,
+                    source,
+                });
+                await sleep(AI_ACCEPT_UPLOAD_RETRY_DELAY_MS);
+            }
+        }
+    }
+    logAiAcceptCheckpointOutcome({ attempts, checkpointAttemptId, checkpointSkipReason, commitId, error, logError = true, outcome, }) {
+        const logFields = {
+            applicationId: this.applicationId,
+            attempts,
+            branchName: this._branchName,
+            outcome,
+            source: "ai:accept",
+        };
+        if (checkpointAttemptId) {
+            logFields.checkpointAttemptId = checkpointAttemptId;
+        }
+        if (commitId) {
+            logFields.commitId = commitId;
+        }
+        if (checkpointSkipReason) {
+            logFields.checkpointSkipReason = checkpointSkipReason;
+        }
+        if (outcome === "upload_failed") {
+            this.logWarnStructured("[sync-service] ai:accept checkpoint upload failed", logFields);
+            if (logError && error) {
+                this.getLogger().error("[sync-service] ai:accept checkpoint upload failed", getErrorMeta(error));
+            }
+        }
+        else if (outcome === "no_commit_id") {
+            this.logWarnStructured("[sync-service] ai:accept checkpoint upload completed without commit", logFields);
+        }
+        else if (outcome.startsWith("skipped_")) {
+            this.logInfoStructured("[sync-service] ai:accept checkpoint skipped by design", logFields);
+        }
+        else {
+            this.logInfoStructured("[sync-service] ai:accept checkpoint upload completed", logFields);
+        }
+    }
+    aiAcceptCheckpointOutcomeFromLog(checkpointLog) {
+        if (checkpointLog.level === "none") {
+            return "commit_created";
+        }
+        if (checkpointLog.level === "warn") {
+            return "no_commit_id";
+        }
+        switch (checkpointLog.reason) {
+            case "draft-autosave":
+                return "skipped_draft_state";
+            case "no-changes":
+                return "skipped_no_changes";
+            case "no-op-source":
+                return "skipped_no_op_source";
+        }
+    }
+    logWarnStructured(message, attributes) {
+        const logger = this.getLogger();
+        if (logger.warnStructured) {
+            logger.warnStructured(message, attributes);
+            return;
+        }
+        logger.warn(message, attributes);
+    }
+    logInfoStructured(message, attributes) {
+        const logger = this.getLogger();
+        if (logger.infoStructured) {
+            logger.infoStructured(message, attributes);
+            return;
+        }
+        logger.info(message, attributes);
+    }
+    /**
+     * Reports draft state to the server
+     */
+    async reportDraftStateToServer(hasDraft) {
+        const branchName = this._branchName;
+        const startedAt = performance.now();
+        const attributes = {
+            "application.id": this.applicationId,
+            "branch.name": branchName,
+            "draft.has_draft": hasDraft,
+        };
+        const report = this.draftStateReportQueue.enqueue(async () => {
+            for (let attempt = 1;; attempt++) {
+                try {
+                    await this._rpcClient.call(async (rpcClient) => {
+                        await rpcClient.call.v3.application.draftState.set({
+                            applicationId: this.applicationId,
+                            branchName,
+                            hasDraft,
+                        });
+                    });
+                    this.logInfoStructured("[sync-service] Reported draft state to server", attributes);
+                    recordDraftStateReport("success", performance.now() - startedAt);
+                    return true;
+                }
+                catch (error) {
+                    if (isTransientAiAcceptUploadError(error) &&
+                        attempt < AI_ACCEPT_UPLOAD_MAX_ATTEMPTS) {
+                        const errorMeta = getErrorMeta(error);
+                        this.logInfoStructured("[sync-service] Retrying draft state report after transient error [expected]", {
+                            ...attributes,
+                            attempt,
+                            errorKind: errorMeta.error.kind,
+                            errorMessage: errorMeta.error.message,
+                            nextAttempt: attempt + 1,
+                        });
+                        await sleep(AI_ACCEPT_UPLOAD_RETRY_DELAY_MS);
+                        continue;
+                    }
+                    logSyncError(this.getLogger(), error, "[sync-service] Failed to report draft state to server", attributes);
+                    recordDraftStateReport("error", performance.now() - startedAt);
+                    return false;
+                }
+            }
         });
-        this.uploadDirectory();
-        this.emit("draftStateChanged", false);
+        this.draftStateReports.set(hasDraft, report);
+        return report;
     }
-    async getRpcClient() {
-        return await connectToISocketRPCServer({
-            superblocksBaseUrl: this.superblocksBaseUrl,
-            token: this.authToken,
+    async waitForDraftStateReport(hasDraft) {
+        return (await this.draftStateReports.get(hasDraft)) ?? false;
+    }
+    notifyDraftStateChanged(hasDraft) {
+        this.emit("draftStateChanged", hasDraft);
+        void this.reportDraftStateToServer(hasDraft);
+    }
+    /**
+     * Clears the drafts directory without restoring or uploading.
+     * Used when restoring from a checkpoint where the database provides the correct state.
+     */
+    async clearDraftsDirectory() {
+        this.getLogger().info("[sync-service] Clearing drafts directory");
+        await this.fsOperation(async () => {
+            await cleanUpDraftsDirectory(this.appRootDirPath);
+            this.getLogger().info("[sync-service] Drafts directory cleared");
         });
+        this.notifyDraftStateChanged(false);
     }
 }
 //# sourceMappingURL=index.js.map