@anvil-works/anvil-cli 0.5.13 → 0.5.14

package/dist/cli.js

@@ -50156,217 +50156,7 @@ var __webpack_exports__ = {};
             throw errors_createNetworkError.network(e.message);
         }
     }
-    const DEFAULT_ANVIL_URL = resolveAnvilUrl();
-    async function syncToLatest(repoPath, appId, anvilUrl, authToken, currentBranch, username) {
-        try {
-            const git = esm_default(repoPath);
-            const commitId = (await git.revparse([
-                "HEAD"
-            ])).trim();
-            const session = new WatchSession(repoPath, appId, {
-                anvilUrl,
-                authToken,
-                currentBranch,
-                commitId,
-                username
-            });
-            await session.initialize();
-            await session.syncRemoteChanges();
-            const newCommitId = (await git.revparse([
-                "HEAD"
-            ])).trim();
-            return newCommitId;
-        } catch (e) {
-            if (isAnvilError(e)) throw e;
-            throw errors_createGitError.commandFailed("sync", e instanceof Error ? e.message : String(e));
-        }
-    }
-    async function api_watch(repoPath, appId, anvilUrl = DEFAULT_ANVIL_URL, stagedOnly = false, username) {
-        repoPath = external_path_default().resolve(repoPath);
-        const authToken = await auth_getValidAuthToken(anvilUrl, username);
-        await verifyAuth(authToken, anvilUrl);
-        const git = esm_default(repoPath);
-        let currentBranch;
-        try {
-            const branchRef = await git.revparse([
-                "--abbrev-ref",
-                "HEAD"
-            ]);
-            if ("HEAD" === branchRef) throw errors_createGitError.commandFailed("revparse", "Cannot sync from detached HEAD state. Please checkout a branch first.");
-            currentBranch = branchRef;
-        } catch (e) {
-            if ("git_command_failed" === e.type) throw e;
-            throw errors_createGitError.commandFailed("revparse", e.message);
-        }
-        let commitId;
-        try {
-            commitId = (await git.revparse([
-                "HEAD"
-            ])).trim();
-        } catch (e) {
-            throw errors_createGitError.commandFailed("revparse", e.message);
-        }
-        logger_logger.verbose(chalk_source.cyan("Current branch: ") + chalk_source.bold(currentBranch));
-        logger_logger.verbose(chalk_source.cyan("Current commit ID: ") + chalk_source.gray(commitId));
-        const syncStatus = await validateBranchSyncStatus(git, currentBranch, appId, anvilUrl, username);
-        let hasUncommittedChanges = false;
-        try {
-            const status = await git.status();
-            hasUncommittedChanges = status.files.length > 0;
-        } catch (e) {
-            throw errors_createGitError.commandFailed("status", e.message);
-        }
-        logger_logger.verbose(chalk_source.blue("Has uncommitted changes: ") + chalk_source.bold(hasUncommittedChanges));
-        const session = new WatchSession(repoPath, appId, {
-            anvilUrl,
-            authToken,
-            currentBranch,
-            commitId,
-            stagedOnly,
-            username
-        });
-        session.on("branch-changed", (data)=>{
-            logger_logger.debug("Event: branch-changed", data);
-        });
-        session.on("sync-conflict", (data)=>{
-            logger_logger.debug("Event: sync-conflict", data);
-        });
-        session.on("remote-update", (data)=>{
-            logger_logger.debug("Event: remote-update", data);
-        });
-        session.on("validation-failed", (data)=>{
-            logger_logger.debug("Event: validation-failed", data);
-        });
-        session.on("save-complete", (data)=>{
-            logger_logger.debug("Event: save-complete", data);
-        });
-        session.on("save-started", (data)=>{
-            logger_logger.debug("Event: save-started", data);
-        });
-        try {
-            await session.initialize();
-        } catch (e) {
-            throw errors_createGitError.commandFailed("initialize", e.message);
-        }
-        if (null !== syncStatus) session.syncStatus = syncStatus;
-        session.hasUncommittedChanges = hasUncommittedChanges;
-        return session;
-    }
-    function getUrlConfigKey(appId) {
-        return `anvil.auth.${appId}.url`;
-    }
-    function getUsernameConfigKey(appId) {
-        return `anvil.auth.${appId}.username`;
-    }
-    async function getLocalConfigValue(repoPath, key) {
-        try {
-            const value = (await esm_default(repoPath).raw([
-                "config",
-                "--local",
-                "--get",
-                key
-            ])).trim();
-            return value || void 0;
-        } catch  {
-            return;
-        }
-    }
-    async function getAppAuthBinding(repoPath, appId) {
-        const [url, username] = await Promise.all([
-            getLocalConfigValue(repoPath, getUrlConfigKey(appId)),
-            getLocalConfigValue(repoPath, getUsernameConfigKey(appId))
-        ]);
-        return {
-            url: url ? normalizeAnvilUrl(url) : void 0,
-            username: username || void 0
-        };
-    }
-    async function setAppAuthBinding(repoPath, appId, binding) {
-        const git = esm_default(repoPath);
-        if (binding.url) await git.raw([
-            "config",
-            "--local",
-            getUrlConfigKey(appId),
-            normalizeAnvilUrl(binding.url)
-        ]);
-        if (binding.username) await git.raw([
-            "config",
-            "--local",
-            getUsernameConfigKey(appId),
-            binding.username
-        ]);
-    }
-    function getCleanGitRemoteUrl(appId, anvilUrl) {
-        const normalized = normalizeAnvilUrl(anvilUrl);
-        const url = new URL(normalized);
-        return `${url.protocol}//${url.host}/git/${appId}.git`;
-    }
-    async function configureCredentialHelperForUrl(repoPath, anvilUrl) {
-        const normalized = normalizeAnvilUrl(anvilUrl);
-        const url = new URL(normalized);
-        const scope = `${url.protocol}//${url.host}`;
-        const git = esm_default(repoPath);
-        try {
-            await git.raw([
-                "config",
-                "--local",
-                "--unset-all",
-                `credential.${scope}.helper`
-            ]);
-        } catch  {}
-        await git.raw([
-            "config",
-            "--local",
-            "--add",
-            `credential.${scope}.helper`,
-            ""
-        ]);
-        await git.raw([
-            "config",
-            "--local",
-            "--add",
-            `credential.${scope}.helper`,
-            "!anvil git-credential"
-        ]);
-        await git.raw([
-            "config",
-            "--local",
-            `credential.${scope}.useHttpPath`,
-            "true"
-        ]);
-        await git.raw([
-            "config",
-            "--local",
-            `credential.${scope}.username`,
-            "git"
-        ]);
-    }
-    async function hardenCheckoutGitAuth(options) {
-        const { repoPath, appId, anvilUrl, username } = options;
-        const remoteName = options.remoteName || "origin";
-        const cleanRemoteUrl = getCleanGitRemoteUrl(appId, anvilUrl);
-        const git = esm_default(repoPath);
-        await git.raw([
-            "remote",
-            "set-url",
-            remoteName,
-            cleanRemoteUrl
-        ]);
-        await configureCredentialHelperForUrl(repoPath, anvilUrl);
-        await setAppAuthBinding(repoPath, appId, {
-            url: anvilUrl,
-            username
-        });
-        return {
-            cleanRemoteUrl
-        };
-    }
-    function parseAppIdFromGitPath(pathValue) {
-        if (!pathValue) return;
-        const normalizedPath = pathValue.startsWith("/") ? pathValue : `/${pathValue}`;
-        const match = normalizedPath.match(/\/git\/([A-Z0-9]+)\.git(?:$|\/)/);
-        return match ? match[1] : void 0;
-    }
+    var external_http_ = __webpack_require__("http");
     const external_node_url_namespaceObject = require("node:url");
     var external_node_child_process_ = __webpack_require__("node:child_process");
     let isDockerCached;
@@ -50829,2024 +50619,2234 @@ var __webpack_exports__ = {};
     defineLazyProperty(open_apps, 'browser', ()=>'browser');
     defineLazyProperty(open_apps, 'browserPrivate', ()=>'browserPrivate');
     const node_modules_open = open_open;
-    const defaultDeps = {
-        openSystem: async (pathToOpen)=>node_modules_open(pathToOpen),
-        isCommandAvailable: isCommandAvailable,
-        spawnShellCommand: async (commandLine)=>{
-            await new Promise((resolve, reject)=>{
-                const child = (0, external_child_process_.spawn)(commandLine, {
-                    shell: true,
-                    stdio: "inherit"
-                });
-                child.on("error", reject);
-                child.on("exit", (code)=>{
-                    if (0 === code || null === code) resolve();
-                    else reject(new Error(`Editor command exited with code ${code}`));
-                });
-            });
+    const successPage = `<!DOCTYPE html>
+  <html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>Anvil Sync • Login Complete</title>
+      <link rel="preconnect" href="https://fonts.googleapis.com">
+      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+      <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
+      <style>
+        * { box-sizing: border-box; }
+        html, body { height: 100%; margin: 0; }
+        body {
+          font-family: Poppins, -apple-system, system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+          color: #555555;
+          background: #f7fdff;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          padding: 20px;
         }
-    };
-    function parseCommandTokens(command) {
-        const input = command.trim();
-        if (!input) return [];
-        const tokens = [];
-        let current = "";
-        let quote = null;
-        let escaping = false;
-        for(let i = 0; i < input.length; i += 1){
-            const ch = input[i];
-            if (escaping) {
-                current += ch;
-                escaping = false;
-                continue;
-            }
-            if ("\\" === ch) {
-                escaping = true;
-                continue;
-            }
-            if (quote) {
-                if (ch === quote) quote = null;
-                else current += ch;
-                continue;
-            }
-            if ('"' === ch || "'" === ch) {
-                quote = ch;
-                continue;
-            }
-            if (/\s/.test(ch)) {
-                if (current) {
-                    tokens.push(current);
-                    current = "";
-                }
-                continue;
-            }
-            current += ch;
+        .card {
+          width: min(480px, 100%);
+          background: #ffffff;
+          border-radius: 12px;
+          padding: 48px 40px;
+          text-align: center;
+          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
         }
-        if (escaping) current += "\\";
-        if (quote) throw new Error(`Unterminated quote in command: ${command}`);
-        if (current) tokens.push(current);
-        return tokens;
-    }
-    function quoteForPosixShell(value) {
-        if ("" === value) return "''";
-        return `'${value.replace(/'/g, "'\"'\"'")}'`;
-    }
-    function quoteForCmdShell(value) {
-        const escaped = value.replace(/[%^&|<>()"!]/g, "^$&");
-        return `"${escaped}"`;
-    }
-    function buildShellCommandLine(tokens) {
-        if ("win32" === process.platform) return tokens.map(quoteForCmdShell).join(" ");
-        return tokens.map(quoteForPosixShell).join(" ");
+        .icon {
+          display: inline-flex;
+          align-items: center;
+          justify-content: center;
+          width: 56px;
+          height: 56px;
+          margin: 0 auto 24px;
+          border-radius: 50%;
+          background: #1bb0ee;
+          color: white;
+        }
+        .icon svg {
+          width: 28px;
+          height: 28px;
+        }
+        h1 {
+          font-size: 24px;
+          font-weight: 600;
+          line-height: 1.3;
+          margin: 0 0 12px;
+          color: #1a1a1a;
+        }
+        p {
+          color: #555555;
+          font-size: 15px;
+          line-height: 1.5;
+          margin: 0;
+        }
+      </style>
+    </head>
+    <body>
+      <main class="card" role="status" aria-live="polite">
+        <div class="icon" aria-hidden="true">
+          <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+            <path d="M20 7L9 18l-5-5" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </div>
+        <h1>Anvil login complete</h1>
+        <p>Close this window and return to your terminal to continue.</p>
+      </main>
+    </body>
+  </html>`;
+    function errorPage(errorMsg) {
+        return `<!DOCTYPE html>
+<html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <title>Anvil Sync • Login Error</title>
+      <link rel="preconnect" href="https://fonts.googleapis.com">
+      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+      <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
+      <style>
+        * { box-sizing: border-box; }
+        html, body { height: 100%; margin: 0; }
+        body {
+          font-family: Poppins, -apple-system, system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+          color: #555555;
+          background: #f7fdff;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          padding: 20px;
+        }
+        .card {
+          width: min(480px, 100%);
+          background: #ffffff;
+          border-radius: 12px;
+          padding: 48px 40px;
+          text-align: center;
+          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+        }
+        .icon {
+          display: inline-flex;
+          align-items: center;
+          justify-content: center;
+          width: 56px;
+          height: 56px;
+          margin: 0 auto 24px;
+          border-radius: 50%;
+          background: #ef4444;
+          color: white;
+        }
+        .icon svg {
+          width: 28px;
+          height: 28px;
+        }
+        h1 {
+          font-size: 24px;
+          font-weight: 600;
+          line-height: 1.3;
+          margin: 0 0 16px;
+          color: #1a1a1a;
+        }
+        p {
+          color: #555555;
+          font-size: 15px;
+          line-height: 1.5;
+          margin: 16px 0 0;
+        }
+        .details {
+          color: #666666;
+          font-size: 13px;
+          word-break: break-word;
+          font-weight: 500;
+          font-family: ui-monospace, "SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace;
+          margin: 16px 0 0;
+          padding: 12px;
+          background: #f8f9fa;
+          border-radius: 6px;
+          text-align: left;
+        }
+      </style>
+    </head>
+    <body>
+      <main class="card" role="status" aria-live="polite">
+        <div class="icon" aria-hidden="true">
+          <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+            <path d="M15 9l-6 6M9 9l6 6" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </div>
+        <h1>Anvil login failed</h1>
+        <div id="details" class="details">${errorMsg}</div>
+        <p>Close this window and return to your terminal to retry.</p>
+      </main>
+    </body>
+  </html>`;
     }
-    function formatFallbackEditorLabel(preferredEditorCommand) {
-        const trimmed = preferredEditorCommand.trim();
-        if (!trimmed) return "your editor";
-        return trimmed;
+    const CLIENT_ID = "anvil-sync";
+    const SCOPES = "apps:read apps:write user:read";
+    function oauth_login_base64url(buf) {
+        return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
     }
-    async function openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps = defaultDeps) {
-        if (preferredEditorCommand) if (deps.isCommandAvailable(preferredEditorCommand)) try {
-            const tokens = parseCommandTokens(preferredEditorCommand);
-            if (0 === tokens.length) throw new Error("empty command");
-            await deps.spawnShellCommand(buildShellCommandLine([
-                ...tokens,
-                targetPath
-            ]));
-            return;
-        } catch (error) {
-            logger_logger.warn(`Failed to open ${formatFallbackEditorLabel(preferredEditorCommand)} automatically: ${errors_getErrorMessage(error)}.`);
-        }
-        else logger_logger.info(`Open ${formatFallbackEditorLabel(preferredEditorCommand)} to edit your app.`);
-        await deps.openSystem(targetPath);
+    function sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
     }
-    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
-        if (explicitUrl) return {
-            source: "explicit",
-            url: normalizeAnvilUrl(explicitUrl)
-        };
-        if (availableUrls.length > 1) return {
-            source: "available-multiple",
-            urls: availableUrls
-        };
-        if (1 === availableUrls.length) return {
-            source: "available-single",
-            url: availableUrls[0]
+    function createBrowserLaunchPrompt(authUrl) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) return {
+            waitForOpen: Promise.resolve(false),
+            close: ()=>{}
         };
-        const fromConfig = getConfig("anvilUrl");
-        if ("string" == typeof fromConfig && fromConfig.trim()) return {
-            source: "config",
-            url: normalizeAnvilUrl(fromConfig.trim())
+        const rl = external_readline_namespaceObject.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        let closed = false;
+        let resolveWait = null;
+        const close = (opened = false)=>{
+            if (closed) return;
+            closed = true;
+            rl.close();
+            resolveWait?.(opened);
+            resolveWait = null;
         };
+        const waitForOpen = new Promise((resolve)=>{
+            resolveWait = resolve;
+            rl.on("SIGINT", ()=>{
+                close();
+                process.kill(process.pid, "SIGINT");
+            });
+            rl.question("", async ()=>{
+                try {
+                    await node_modules_open(authUrl);
+                    logger_logger.info(chalk_source.dim("Opened your browser to continue login."));
+                    close(true);
+                } catch  {
+                    logger_logger.warn("Could not open a browser automatically.");
+                    close(false);
+                }
+            });
+        });
         return {
-            source: "default",
-            url: isDevMode() ? "http://localhost:3000" : "https://anvil.works"
+            waitForOpen,
+            close
         };
     }
-    function decideUsernameForUrl(accounts) {
-        if (0 === accounts.length) return {
-            source: "none"
-        };
-        if (1 === accounts.length) return {
-            source: "single",
-            username: accounts[0]
-        };
-        return {
-            source: "multiple",
-            usernames: [
-                ...accounts
-            ]
-        };
-    }
-    async function resolveUsernameForUrl(anvilUrl, explicitUsername, promptMessage = "Multiple accounts found. Which account owns this app?") {
-        if (explicitUsername) return explicitUsername;
-        const decision = decideUsernameForUrl(auth_getAccountsForUrl(anvilUrl));
-        if ("none" === decision.source) return;
-        if ("single" === decision.source) {
-            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(decision.username));
-            return decision.username;
+    async function parseOAuthError(response) {
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+            const data = await response.json();
+            return data.error || `HTTP ${response.status}`;
+        }
+        const text = (await response.text()).trim();
+        if (!text) return `HTTP ${response.status}`;
+        try {
+            const parsed = JSON.parse(text);
+            return parsed.error || text;
+        } catch  {
+            return text;
         }
-        const choices = decision.usernames.map((acct)=>({
-                name: acct,
-                value: acct
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        return logger_logger.select(promptMessage, choices, decision.usernames[0]);
-    }
-    async function confirmReverseLookupWithResolvedUser(anvilUrl, username) {
-        const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username, `Multiple accounts found for ${anvilUrl}. Which account should be used for app lookup?`);
-        if (null === resolvedUsername) return null;
-        const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} ${resolvedUsername ? `for ${resolvedUsername}` : ""} for matching app IDs? This is slower than detecting the app ID from local git remotes.`, true);
-        return {
-            username: resolvedUsername,
-            shouldContinue
-        };
     }
-    async function resolveUrlForFallback(explicitUrl) {
-        const decision = decideFallbackUrl(explicitUrl);
-        if ("available-multiple" !== decision.source) return decision.url;
-        const choices = decision.urls.map((url)=>({
-                name: url,
-                value: url
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
+    async function exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier) {
+        const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+                grant_type: "authorization_code",
+                code,
+                redirect_uri: redirectUri,
+                client_id: CLIENT_ID,
+                code_verifier: codeVerifier
+            })
         });
-        const selectedUrl = await logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
-        return selectedUrl;
-    }
-    const defaultConfigureWatchGitAuthDeps = {
-        configureCredentialHelperForUrl: configureCredentialHelperForUrl,
-        setAppAuthBinding: setAppAuthBinding
-    };
-    const defaultSyncStartDeps = {
-        pushToAnvil,
-        recreateSessionAndValidate,
-        recheckSyncStatus,
-        startWatchingWithEventHandlers
-    };
-    function resolveWatchOpenPath(repoPath) {
-        return external_path_default().resolve(repoPath);
-    }
-    async function openWatchPath(targetPath, deps) {
-        const preferredEditor = String(getConfig("preferredEditor") || "").trim();
-        const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
-        await openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps);
-        logger_logger.info(chalk_source.gray(`Opened ${targetPath}`));
+        if (!tokenResponse.ok) throw new Error(`Failed to exchange authorization code for token. ${await parseOAuthError(tokenResponse)}`);
+        return await tokenResponse.json();
     }
-    async function configureWatchGitAuth(options, deps = defaultConfigureWatchGitAuthDeps) {
-        await deps.configureCredentialHelperForUrl(options.repoPath, options.anvilUrl);
-        await deps.setAppAuthBinding(options.repoPath, options.appId, {
-            url: options.anvilUrl,
-            username: options.username
+    async function requestDeviceAuthorization(anvilUrl) {
+        const response = await fetch(`${anvilUrl}/oauth/device_authorization`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+                client_id: CLIENT_ID,
+                scope: SCOPES
+            })
         });
+        if (!response.ok) throw new Error(`Failed to start device login. ${await parseOAuthError(response)}`);
+        return await response.json();
     }
-    function isStaleRemotePushError(message) {
-        const normalized = message.toLowerCase();
-        return normalized.includes("fetch first") || normalized.includes("non-fast-forward") || normalized.includes("failed to push some refs") || normalized.includes("remote contains work that you do") || normalized.includes("[rejected]");
-    }
-    async function selectAppId(candidates) {
-        if (0 === candidates.length) {
-            logger_logger.warn("Could not auto-detect app ID from repository.");
-            const rl = external_readline_namespaceObject.createInterface({
-                input: process.stdin,
-                output: process.stdout
-            });
-            const manualAppId = await new Promise((resolve)=>{
-                const handleInterrupt = ()=>{
-                    rl.close();
-                    logger_logger.warn("Operation cancelled by user.");
-                    resolve(null);
-                };
-                rl.on("SIGINT", handleInterrupt);
-                rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
-                    rl.removeListener("SIGINT", handleInterrupt);
-                    rl.close();
-                    const trimmed = answer.trim();
-                    trimmed ? resolve(trimmed) : resolve(null);
-                });
+    async function pollDeviceAuthorization(anvilUrl, deviceAuth, options) {
+        const expiresAt = Date.now() + 1000 * deviceAuth.expires_in;
+        let intervalMs = 1000 * Math.max(deviceAuth.interval ?? 5, 1);
+        while(Date.now() < expiresAt){
+            if (options?.isCancelled?.()) throw new Error("cancelled");
+            const response = await fetch(`${anvilUrl}/oauth/token`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                },
+                body: new URLSearchParams({
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                    device_code: deviceAuth.device_code,
+                    client_id: CLIENT_ID
+                })
             });
-            if (manualAppId) return {
-                appId: manualAppId,
-                source: "config",
-                description: "Manual entry"
-            };
-            return null;
-        }
-        if (1 === candidates.length) {
-            const [candidate] = candidates;
-            logger_logger.success("Auto-selected detected app ID: " + chalk_source.bold(candidate.appId));
-            return candidate;
-        }
-        const choices = candidates.map((candidate, index)=>({
-                name: formatCandidateLabel(candidate),
-                value: index
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        try {
-            const answer = await logger_logger.prompt([
-                {
-                    type: "list",
-                    name: "appId",
-                    message: "Select an app ID:",
-                    choices: choices,
-                    pageSize: 10
-                }
-            ]);
-            if (null === answer.appId) {
-                const rl = external_readline_namespaceObject.createInterface({
-                    input: process.stdin,
-                    output: process.stdout
-                });
-                const manualAppId = await new Promise((resolve)=>{
-                    rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
-                        rl.close();
-                        const trimmed = answer.trim();
-                        trimmed ? resolve(trimmed) : resolve(null);
-                    });
-                });
-                if (manualAppId) return {
-                    appId: manualAppId,
-                    source: "config",
-                    description: "Manual entry"
-                };
-                return null;
+            if (response.ok) return await response.json();
+            const error = await parseOAuthError(response);
+            if ("authorization_pending" === error) {
+                await sleep(intervalMs);
+                continue;
             }
-            return candidates[answer.appId];
-        } catch (error) {
-            const errorObj = error;
-            if ("ExitPromptError" === errorObj.name || errorObj.message.includes("User force closed")) logger_logger.warn("Operation cancelled by user.");
-            return null;
-        }
-    }
-    async function pushToAnvil(options) {
-        try {
-            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
-            const git = new GitService(options.repoPath);
-            const refSpec = `${options.branchName}:${options.branchName}`;
-            logger_logger.progress("push", "Pushing to Anvil...");
-            await git.push(pushUrl, refSpec, options.force ?? false);
-            logger_logger.progressEnd("push", "Pushed to Anvil");
-            return {
-                success: true,
-                staleRemote: false
-            };
-        } catch (e) {
-            const errorMessage = errors_getErrorMessage(e);
-            logger_logger.progressEnd("push", "Push failed");
-            logger_logger.error(`Failed to push: ${errorMessage}`);
-            return {
-                success: false,
-                staleRemote: isStaleRemotePushError(errorMessage),
-                errorMessage
-            };
+            if ("slow_down" === error) {
+                intervalMs += 1000;
+                await sleep(intervalMs);
+                continue;
+            }
+            if ("access_denied" === error) throw new Error("Device login was denied.");
+            if ("expired_token" === error || "invalid_grant" === error) break;
+            throw new Error(`Device login failed. ${error}`);
         }
+        throw new Error("Device login expired before it was approved.");
     }
-    async function fetchAndRebaseFromAnvil(options) {
-        const git = new GitService(options.repoPath);
-        const tempRef = `anvil-rebase-temp-${Date.now()}`;
-        let didStash = false;
-        try {
-            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
-            const hasChanges = await git.hasUncommittedChanges();
-            if (hasChanges) {
-                logger_logger.progress("rebase", "Stashing uncommitted changes...");
-                didStash = await git.stash("anvil-sync: stash before rebase");
-            }
-            logger_logger.progressUpdate("rebase", "Fetching from Anvil...");
-            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
-            logger_logger.progressUpdate("rebase", "Rebasing...");
-            await git.rebase(tempRef);
-            logger_logger.progressUpdate("rebase", "Pushing rebased changes...");
-            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
-            await git.push(pushUrl, `${options.branchName}:${options.branchName}`, true);
-            logger_logger.progressEnd("rebase", "Rebased and pushed to Anvil");
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            if (didStash) try {
-                await git.stashPop();
-                logger_logger.verbose(chalk_source.green("Restored uncommitted changes"));
-            } catch (e) {
-                logger_logger.warn("Uncommitted changes were stashed but could not be restored automatically.");
-                logger_logger.info(chalk_source.gray("   Run: git stash pop"));
-            }
-            return {
-                success: true,
-                conflicted: false
-            };
-        } catch (e) {
-            const msg = errors_getErrorMessage(e);
-            if (msg.includes("rebase") && (msg.includes("conflict") || msg.includes("CONFLICT") || msg.includes("could not apply"))) {
-                try {
-                    await git.rebaseAbort();
-                } catch  {}
-                await git.deleteRef(`refs/heads/${tempRef}`);
-                if (didStash) try {
-                    await git.stashPop();
-                } catch  {
-                    logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
+    async function createPkceLoginFlow(anvilUrl) {
+        const codeVerifier = external_crypto_.randomBytes(48).toString("hex");
+        const codeChallenge = oauth_login_base64url(external_crypto_.createHash("sha256").update(codeVerifier, "ascii").digest());
+        const state = external_crypto_.randomBytes(16).toString("hex");
+        const server = external_http_.createServer();
+        await new Promise((resolve)=>server.listen(0, "127.0.0.1", resolve));
+        const address = server.address();
+        if (!address || "string" == typeof address) throw new Error("No address");
+        const port = address.port;
+        const redirectUri = `http://127.0.0.1:${port}/oauth-callback`;
+        const authUrl = new URL(`${anvilUrl}/oauth/authorize`);
+        authUrl.searchParams.set("response_type", "code");
+        authUrl.searchParams.set("client_id", CLIENT_ID);
+        authUrl.searchParams.set("redirect_uri", redirectUri);
+        authUrl.searchParams.set("scope", SCOPES);
+        authUrl.searchParams.set("state", state);
+        authUrl.searchParams.set("code_challenge", codeChallenge);
+        authUrl.searchParams.set("code_challenge_method", "S256");
+        const codePromise = new Promise((resolve, reject)=>{
+            server.on("request", (req, res)=>{
+                if (!req.url) return;
+                const url = new URL(req.url, `http://127.0.0.1:${port}`);
+                if ("/oauth-callback" !== url.pathname) return;
+                const code = url.searchParams.get("code") || void 0;
+                const error = url.searchParams.get("error") || void 0;
+                const recvState = url.searchParams.get("state");
+                if (!recvState || !code && !error) {
+                    res.statusCode = 400;
+                    res.end("Missing code, error or state");
+                    reject(new Error("Missing code/state/error"));
+                    server.close();
+                    return;
                 }
-                logger_logger.progressEnd("rebase", "Rebase failed - conflicts");
-                return {
-                    success: false,
-                    conflicted: true
-                };
-            }
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            if (didStash) try {
-                await git.stashPop();
-            } catch  {
-                logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
-            }
-            logger_logger.progressEnd("rebase", "Rebase failed");
-            logger_logger.error(`Failed to rebase: ${msg}`);
-            return {
-                success: false,
-                conflicted: false
-            };
-        }
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "text/html; charset=utf-8");
+                if (code) res.end(successPage);
+                else res.end(errorPage(error || "unknown"));
+                resolve({
+                    code,
+                    error,
+                    recvState
+                });
+                server.closeAllConnections();
+                server.close();
+            });
+        });
+        let closed = false;
+        server.on("close", ()=>{
+            closed = true;
+        });
+        const close = async ()=>{
+            if (closed) return;
+            closed = true;
+            server.closeAllConnections();
+            if (!server.listening) return;
+            await new Promise((resolve)=>server.close(()=>resolve()));
+        };
+        return {
+            authUrl,
+            close,
+            waitForLogin: (async ()=>{
+                const { code, error, recvState } = await codePromise;
+                if (recvState !== state) throw new Error("Invalid state received from OAuth callback");
+                if (error) throw new Error(`Error received from OAuth callback: ${error}`);
+                const tokenData = await exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier);
+                return login(anvilUrl, {
+                    access_token: tokenData.access_token,
+                    refresh_token: tokenData.refresh_token,
+                    expires_in: tokenData.expires_in,
+                    scope: tokenData.scope
+                });
+            })()
+        };
     }
-    async function fetchAndHardResetFromAnvil(options) {
-        const git = new GitService(options.repoPath);
-        const tempRef = `anvil-reset-temp-${Date.now()}`;
+    function raceLoginAttempts(attempts) {
+        return new Promise((resolve, reject)=>{
+            let remaining = attempts.length;
+            let lastError = null;
+            for (const attempt of attempts)attempt.then(resolve).catch((error)=>{
+                if ("cancelled" === error.message) return;
+                remaining -= 1;
+                lastError = error;
+                if (0 === remaining && lastError) reject(lastError);
+            });
+        });
+    }
+    async function runInteractiveLoginFlow(anvilUrl) {
+        const pkceFlow = await createPkceLoginFlow(anvilUrl);
+        const deviceAuth = await requestDeviceAuthorization(anvilUrl);
+        const browserPrompt = createBrowserLaunchPrompt(pkceFlow.authUrl.toString());
+        let settled = false;
+        let spinnerStarted = false;
+        logger_logger.info(chalk_source.dim(`Logging in to ${anvilUrl}`));
+        console.log();
+        logger_logger.info(chalk_source.dim("Visit:"), `${deviceAuth.verification_uri_complete || deviceAuth.verification_uri}`);
+        logger_logger.info(chalk_source.dim("Device code:"), `${deviceAuth.user_code}`);
+        console.log();
+        logger_logger.info("OR Press ENTER to open a browser...");
+        browserPrompt.waitForOpen.then((opened)=>{
+            if (opened && !settled) {
+                spinnerStarted = true;
+                logger_logger.progress("login", "Waiting for login to complete...");
+            }
+        });
         try {
-            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
-            logger_logger.progress("reset", "Fetching from Anvil...");
-            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
-            logger_logger.progressUpdate("reset", "Resetting to Anvil's version...");
-            await git.reset(tempRef, "hard");
-            logger_logger.progressEnd("reset", "Reset to Anvil's version");
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            return true;
-        } catch (e) {
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            logger_logger.progressEnd("reset", "Reset failed");
-            logger_logger.error(`Failed to reset: ${errors_getErrorMessage(e)}`);
-            return false;
+            const result = await raceLoginAttempts([
+                pkceFlow.waitForLogin,
+                pollDeviceAuthorization(anvilUrl, deviceAuth, {
+                    isCancelled: ()=>settled
+                }).then(async (tokenData)=>login(anvilUrl, {
+                        access_token: tokenData.access_token,
+                        refresh_token: tokenData.refresh_token,
+                        expires_in: tokenData.expires_in,
+                        scope: tokenData.scope
+                    }))
+            ]);
+            settled = true;
+            return result;
+        } finally{
+            settled = true;
+            browserPrompt.close();
+            if (spinnerStarted) logger_logger.progressEnd("login");
+            await pkceFlow.close();
         }
     }
-    function getSyncStateCategory(syncStatus) {
-        if (syncStatus?.branchMissing) return "branch-missing";
-        if (syncStatus?.diverged) return "diverged";
-        if (syncStatus?.ahead && !syncStatus?.behind) return "ahead";
-        if (syncStatus?.behind && !syncStatus?.ahead) return "behind";
-        if (syncStatus?.ahead && syncStatus?.behind) return "diverged";
-        return "in-sync";
+    function getUrlConfigKey(appId) {
+        return `anvil.auth.${appId}.url`;
     }
-    async function recheckSyncStatus(previousCategory, previousBranch, options) {
-        try {
-            logger_logger.progress("verify", "Verifying repository status...");
-            const freshSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
-            logger_logger.progressEnd("verify");
-            const currentCategory = getSyncStateCategory(freshSession.syncStatus);
-            const currentBranch = freshSession.getBranchName() || "master";
-            if (currentCategory !== previousCategory || currentBranch !== previousBranch) {
-                logger_logger.warn("Repository status has changed. Re-evaluating...");
-                return freshSession;
-            }
-            freshSession.cleanup();
-            return null;
-        } catch (e) {
-            logger_logger.progressEnd("verify");
-            logger_logger.verbose(chalk_source.gray(`Could not re-verify status: ${errors_getErrorMessage(e)}`));
-            return null;
-        }
+    function getUsernameConfigKey(appId) {
+        return `anvil.auth.${appId}.username`;
     }
-    async function recreateSessionAndValidate(options) {
-        logger_logger.progress("init", "Restarting watch session...");
+    async function getLocalConfigValue(repoPath, key) {
         try {
-            const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
-            logger_logger.progressEnd("init");
-            return await checkSyncStatusAndStart(newSession, options);
-        } catch (e) {
-            logger_logger.progressEnd("init", "Failed");
-            logger_logger.error(`Failed to restart: ${errors_getErrorMessage(e)}`);
-            return false;
+            const value = (await esm_default(repoPath).raw([
+                "config",
+                "--local",
+                "--get",
+                key
+            ])).trim();
+            return value || void 0;
+        } catch  {
+            return;
         }
     }
-    async function checkSyncStatusAndStart(session, options, deps = defaultSyncStartDeps) {
-        const syncStatus = session.syncStatus;
-        const branchName = session.getBranchName() || "master";
-        const hasUncommitted = session.hasUncommittedChanges;
-        const stateCategory = getSyncStateCategory(syncStatus);
-        if (syncStatus?.branchMissing) {
-            logger_logger.warn(`Branch '${branchName}' doesn't exist on Anvil yet.`);
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            let shouldPush = options.autoMode;
-            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing new branch to Anvil..."));
-            else {
-                shouldPush = await logger_logger.confirm("Would you like to push this branch to Anvil?", true);
-                if (shouldPush) {
-                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
-                }
-            }
-            if (!shouldPush) {
-                logger_logger.warn("Watch cancelled. Push your branch to Anvil, then try again.");
-                session.cleanup();
-                return false;
-            }
-            session.cleanup();
-            const pushed = await deps.pushToAnvil({
-                repoPath: options.repoPath,
-                appId: options.appId,
-                anvilUrl: options.anvilUrl,
-                branchName,
-                username: options.username
+    async function getAppAuthBinding(repoPath, appId) {
+        const [url, username] = await Promise.all([
+            getLocalConfigValue(repoPath, getUrlConfigKey(appId)),
+            getLocalConfigValue(repoPath, getUsernameConfigKey(appId))
+        ]);
+        return {
+            url: url ? normalizeAnvilUrl(url) : void 0,
+            username: username || void 0
+        };
+    }
+    async function setAppAuthBinding(repoPath, appId, binding) {
+        const git = esm_default(repoPath);
+        if (binding.url) await git.raw([
+            "config",
+            "--local",
+            getUrlConfigKey(appId),
+            normalizeAnvilUrl(binding.url)
+        ]);
+        if (binding.username) await git.raw([
+            "config",
+            "--local",
+            getUsernameConfigKey(appId),
+            binding.username
+        ]);
+    }
+    function getCleanGitRemoteUrl(appId, anvilUrl) {
+        const normalized = normalizeAnvilUrl(anvilUrl);
+        const url = new URL(normalized);
+        return `${url.protocol}//${url.host}/git/${appId}.git`;
+    }
+    async function configureCredentialHelperForUrl(repoPath, anvilUrl) {
+        const normalized = normalizeAnvilUrl(anvilUrl);
+        const url = new URL(normalized);
+        const scope = `${url.protocol}//${url.host}`;
+        const git = esm_default(repoPath);
+        try {
+            await git.raw([
+                "config",
+                "--local",
+                "--unset-all",
+                `credential.${scope}.helper`
+            ]);
+        } catch  {}
+        await git.raw([
+            "config",
+            "--local",
+            "--add",
+            `credential.${scope}.helper`,
+            ""
+        ]);
+        await git.raw([
+            "config",
+            "--local",
+            "--add",
+            `credential.${scope}.helper`,
+            "!anvil git-credential"
+        ]);
+        await git.raw([
+            "config",
+            "--local",
+            `credential.${scope}.useHttpPath`,
+            "true"
+        ]);
+        await git.raw([
+            "config",
+            "--local",
+            `credential.${scope}.username`,
+            "git"
+        ]);
+    }
+    async function hardenCheckoutGitAuth(options) {
+        const { repoPath, appId, anvilUrl, username } = options;
+        const remoteName = options.remoteName || "origin";
+        const cleanRemoteUrl = getCleanGitRemoteUrl(appId, anvilUrl);
+        const git = esm_default(repoPath);
+        await git.raw([
+            "remote",
+            "set-url",
+            remoteName,
+            cleanRemoteUrl
+        ]);
+        await configureCredentialHelperForUrl(repoPath, anvilUrl);
+        await setAppAuthBinding(repoPath, appId, {
+            url: anvilUrl,
+            username
+        });
+        return {
+            cleanRemoteUrl
+        };
+    }
+    function parseAppIdFromGitPath(pathValue) {
+        if (!pathValue) return;
+        const normalizedPath = pathValue.startsWith("/") ? pathValue : `/${pathValue}`;
+        const match = normalizedPath.match(/\/git\/([A-Z0-9]+)\.git(?:$|\/)/);
+        return match ? match[1] : void 0;
+    }
+    const defaultDeps = {
+        openSystem: async (pathToOpen)=>node_modules_open(pathToOpen),
+        isCommandAvailable: isCommandAvailable,
+        spawnShellCommand: async (commandLine)=>{
+            await new Promise((resolve, reject)=>{
+                const child = (0, external_child_process_.spawn)(commandLine, {
+                    shell: true,
+                    stdio: "inherit"
+                });
+                child.on("error", reject);
+                child.on("exit", (code)=>{
+                    if (0 === code || null === code) resolve();
+                    else reject(new Error(`Editor command exited with code ${code}`));
+                });
             });
-            if (!pushed.success) {
-                if (pushed.staleRemote) {
-                    logger_logger.warn("Branch appeared on Anvil while pushing. Re-checking sync status...");
-                    return await deps.recreateSessionAndValidate(options);
-                }
-                return false;
-            }
-            return await deps.recreateSessionAndValidate(options);
         }
-        if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
-            logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            let shouldPush = options.autoMode;
-            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing to Anvil..."));
-            else {
-                const action = await logger_logger.select("What would you like to do?", [
-                    {
-                        name: "Push your changes to Anvil (recommended)",
-                        value: "push"
-                    },
-                    {
-                        name: "Exit and handle manually",
-                        value: "exit"
-                    }
-                ], "push");
-                shouldPush = "push" === action;
-                if (shouldPush) {
-                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
-                }
+    };
+    function parseCommandTokens(command) {
+        const input = command.trim();
+        if (!input) return [];
+        const tokens = [];
+        let current = "";
+        let quote = null;
+        let escaping = false;
+        for(let i = 0; i < input.length; i += 1){
+            const ch = input[i];
+            if (escaping) {
+                current += ch;
+                escaping = false;
+                continue;
             }
-            if (!shouldPush) {
-                logger_logger.warn("Watch cancelled.");
-                session.cleanup();
-                return false;
+            if ("\\" === ch) {
+                escaping = true;
+                continue;
             }
-            session.cleanup();
-            const pushed = await deps.pushToAnvil({
-                repoPath: options.repoPath,
-                appId: options.appId,
-                anvilUrl: options.anvilUrl,
-                branchName,
-                username: options.username
-            });
-            if (!pushed.success) return false;
-            return await deps.recreateSessionAndValidate(options);
-        } else if (syncStatus.diverged) {
-            logger_logger.warn("Your local repository has diverged from Anvil.");
-            logger_logger.info(chalk_source.gray(`   You are ${syncStatus.ahead} commit(s) ahead and ${syncStatus.behind} commit(s) behind.`));
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            session.cleanup();
-            if (options.autoMode) {
-                logger_logger.info(chalk_source.cyan("→ Auto-rebasing onto Anvil's version..."));
-                const result = await fetchAndRebaseFromAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username
-                });
-                if (result.conflicted) {
-                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
-                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
-                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
-                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
-                    return false;
-                }
-                if (!result.success) return false;
-                return await deps.recreateSessionAndValidate(options);
+            if (quote) {
+                if (ch === quote) quote = null;
+                else current += ch;
+                continue;
             }
-            const action = await logger_logger.select("How would you like to resolve this?", [
-                {
-                    name: "Pull from Anvil and rebase your changes on top (recommended)",
-                    value: "rebase"
-                },
-                {
-                    name: "Discard your local commits and use Anvil's version",
-                    value: "reset"
-                },
-                {
-                    name: "Push your version to Anvil (overwrites remote)",
-                    value: "push"
-                },
-                {
-                    name: "Exit and handle manually",
-                    value: "exit"
-                }
-            ], "rebase");
-            if ("exit" === action) {
-                logger_logger.warn("Watch cancelled.");
-                return false;
+            if ('"' === ch || "'" === ch) {
+                quote = ch;
+                continue;
             }
-            const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
-            if (changed) return await checkSyncStatusAndStart(changed, options, deps);
-            if ("rebase" === action) {
-                const result = await fetchAndRebaseFromAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username
-                });
-                if (result.conflicted) {
-                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
-                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
-                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
-                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
-                    return false;
+            if (/\s/.test(ch)) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
                 }
-                if (!result.success) return false;
-                return await deps.recreateSessionAndValidate(options);
+                continue;
             }
-            if ("reset" === action) {
-                const resetWarning = hasUncommitted ? `This will discard ${syncStatus.ahead} local commit(s) and your uncommitted changes. Are you sure?` : `This will discard ${syncStatus.ahead} local commit(s). Are you sure?`;
-                const confirmed = await logger_logger.confirm(resetWarning, false);
-                if (!confirmed) {
-                    logger_logger.warn("Watch cancelled.");
-                    return false;
+            current += ch;
+        }
+        if (escaping) current += "\\";
+        if (quote) throw new Error(`Unterminated quote in command: ${command}`);
+        if (current) tokens.push(current);
+        return tokens;
+    }
+    function quoteForPosixShell(value) {
+        if ("" === value) return "''";
+        return `'${value.replace(/'/g, "'\"'\"'")}'`;
+    }
+    function quoteForCmdShell(value) {
+        const escaped = value.replace(/[%^&|<>()"!]/g, "^$&");
+        return `"${escaped}"`;
+    }
+    function buildShellCommandLine(tokens) {
+        if ("win32" === process.platform) return tokens.map(quoteForCmdShell).join(" ");
+        return tokens.map(quoteForPosixShell).join(" ");
+    }
+    function formatFallbackEditorLabel(preferredEditorCommand) {
+        const trimmed = preferredEditorCommand.trim();
+        if (!trimmed) return "your editor";
+        return trimmed;
+    }
+    async function openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps = defaultDeps) {
+        if (preferredEditorCommand) if (deps.isCommandAvailable(preferredEditorCommand)) try {
+            const tokens = parseCommandTokens(preferredEditorCommand);
+            if (0 === tokens.length) throw new Error("empty command");
+            await deps.spawnShellCommand(buildShellCommandLine([
+                ...tokens,
+                targetPath
+            ]));
+            return;
+        } catch (error) {
+            logger_logger.warn(`Failed to open ${formatFallbackEditorLabel(preferredEditorCommand)} automatically: ${errors_getErrorMessage(error)}.`);
+        }
+        else logger_logger.info(`Open ${formatFallbackEditorLabel(preferredEditorCommand)} to edit your app.`);
+        await deps.openSystem(targetPath);
+    }
+    const CHECKOUT_ERROR_VALUE = "__ERROR__";
+    function isAbortLikeError(error) {
+        if (error instanceof Error && "AbortError" === error.name) return true;
+        if ("object" == typeof error && null !== error) {
+            const maybeType = error.type;
+            const maybeMessage = error.message;
+            if ("network_error" === maybeType && "string" == typeof maybeMessage && maybeMessage.toLowerCase().includes("abort")) return true;
+        }
+        const message = errors_getErrorMessage(error).toLowerCase();
+        return "aborted" === message || message.includes("aborted");
+    }
+    function normalizePickerQuery(term) {
+        return (term || "").trim();
+    }
+    function parseNonNegativeMs(raw) {
+        if (null == raw) return null;
+        const parsed = Number(raw);
+        if (!Number.isFinite(parsed) || parsed < 0) return null;
+        return parsed;
+    }
+    function getCheckoutPickerDelayMs() {
+        const fromEnv = parseNonNegativeMs(process.env.ANVIL_CHECKOUT_PICKER_DELAY_MS);
+        if (null != fromEnv) return fromEnv;
+        return 0;
+    }
+    function getCheckoutPickerPaginationDelayMs() {
+        return getCheckoutPickerDelayMs();
+    }
+    function getCheckoutPickerMaxRows() {
+        const raw = process.env.ANVIL_CHECKOUT_PICKER_MAX_ROWS;
+        const fromEnv = null == raw ? NaN : Number(raw);
+        if (null != raw && Number.isFinite(fromEnv) && fromEnv >= 4) return Math.floor(fromEnv);
+        return 12;
+    }
+    function formatLastEdited(lastEdited) {
+        if (!lastEdited) return;
+        return chalk_source.gray(`Last edited: ${lastEdited}`);
+    }
+    function formatAppPickerLabel(app) {
+        const appName = app.app_name || "Unnamed App";
+        return `${chalk_source.cyan(appName)} ${chalk_source.gray(`(${app.app_id})`)}`;
+    }
+    async function waitForDebounce(ms, signal) {
+        if (ms <= 0) return;
+        if (signal.aborted) throw new Error("aborted");
+        await new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                cleanup();
+                resolve();
+            }, ms);
+            const onAbort = ()=>{
+                cleanup();
+                reject(new Error("aborted"));
+            };
+            const cleanup = ()=>{
+                clearTimeout(timer);
+                signal.removeEventListener("abort", onAbort);
+            };
+            signal.addEventListener("abort", onAbort, {
+                once: true
+            });
+        });
+    }
+    function createCheckoutPickerSource(anvilUrl, username, deps, options = {}) {
+        const pageSize = options.pageSize ?? 20;
+        const debounceMs = options.debounceMs ?? 200;
+        const staleTimeMs = options.staleTimeMs ?? 30000;
+        const maxAutoPagesPerCall = options.maxAutoPagesPerCall ?? 8;
+        const initialQuery = normalizePickerQuery(options.initialQuery);
+        const simulatedDelayMs = getCheckoutPickerDelayMs();
+        const paginationDelayMs = getCheckoutPickerPaginationDelayMs();
+        const cache = new Map();
+        const getState = (query)=>{
+            const existing = cache.get(query);
+            if (existing) return existing;
+            const created = {
+                items: [],
+                nextCursor: null,
+                exhausted: false,
+                lastError: null,
+                updatedAt: 0,
+                inFlight: null
+            };
+            cache.set(query, created);
+            return created;
+        };
+        const fetchPage = async (query, signal, options = {})=>{
+            const state = getState(query);
+            if (state.inFlight) return void await state.inFlight;
+            state.inFlight = (async ()=>{
+                try {
+                    if (simulatedDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, simulatedDelayMs));
+                    if (options.cursor && paginationDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, paginationDelayMs));
+                    const response = await deps.listAppsForCheckout({
+                        anvilUrl,
+                        username,
+                        limit: pageSize,
+                        cursor: options.cursor,
+                        q: query || void 0,
+                        signal
+                    });
+                    if (options.reset) state.items = [
+                        ...response.apps
+                    ];
+                    else state.items.push(...response.apps);
+                    state.nextCursor = response.next_cursor;
+                    state.exhausted = !response.next_cursor;
+                    state.lastError = null;
+                    state.updatedAt = Date.now();
+                } catch (e) {
+                    if (!signal.aborted && !isAbortLikeError(e)) {
+                        const message = errors_getErrorMessage(e);
+                        state.lastError = message;
+                        state.updatedAt = Date.now();
+                    }
+                } finally{
+                    state.inFlight = null;
                 }
-                const reset = await fetchAndHardResetFromAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username
+            })();
+            await state.inFlight;
+        };
+        const ensureLoaded = async (query, signal)=>{
+            const state = getState(query);
+            const isStale = Date.now() - state.updatedAt > staleTimeMs;
+            if (0 === state.items.length) {
+                await waitForDebounce(debounceMs, signal);
+                await fetchPage(query, signal, {
+                    cursor: void 0,
+                    reset: false
                 });
-                if (!reset) return false;
-                return await deps.recreateSessionAndValidate(options);
-            }
-            if ("push" === action) {
-                const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
-                if (!confirmed) {
-                    logger_logger.warn("Watch cancelled.");
-                    return false;
-                }
-                const pushed = await deps.pushToAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username,
-                    force: true
+            } else if (state.lastError) {
+                await waitForDebounce(debounceMs, signal);
+                await fetchPage(query, signal, {
+                    cursor: void 0,
+                    reset: true
+                });
+            } else if (isStale) {
+                await waitForDebounce(debounceMs, signal);
+                await fetchPage(query, signal, {
+                    cursor: void 0,
+                    reset: true
                 });
-                if (!pushed.success) return false;
-                return await deps.recreateSessionAndValidate(options);
             }
-        } else {
-            logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
-            logger_logger.verbose(chalk_source.gray("   You need to sync to the latest version before watching."));
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            let shouldSync = options.autoMode;
-            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-syncing to latest version..."));
-            else {
-                shouldSync = await logger_logger.confirm("Would you like to sync to the latest version from Anvil now?", true);
-                if (shouldSync) {
-                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
-                }
+            let pagesLoaded = 0;
+            while(state.nextCursor && pagesLoaded < maxAutoPagesPerCall){
+                if (signal.aborted) throw new Error("aborted");
+                const cursor = state.nextCursor;
+                await fetchPage(query, signal, {
+                    cursor,
+                    reset: false
+                });
+                pagesLoaded += 1;
             }
-            if (!shouldSync) {
-                logger_logger.warn("Watch cancelled. Please sync manually before watching.");
-                session.cleanup();
-                return false;
+        };
+        return {
+            source: async (term, { signal })=>{
+                const query = normalizePickerQuery(term) || initialQuery;
+                if (signal.aborted) return [];
+                await ensureLoaded(query, signal);
+                const state = getState(query);
+                if (state.lastError) return [
+                    {
+                        name: `${chalk_source.yellow("Fetch failed")} ${chalk_source.gray(`(${state.lastError})`)}`,
+                        value: CHECKOUT_ERROR_VALUE,
+                        disabled: true
+                    }
+                ];
+                const summary = state.nextCursor ? chalk_source.gray(`Loaded ${state.items.length} apps • more available`) : chalk_source.gray(`Loaded ${state.items.length} apps`);
+                const choices = state.items.map((app)=>({
+                        name: formatAppPickerLabel(app),
+                        value: app.app_id,
+                        description: formatLastEdited(app.last_edited)
+                    }));
+                choices.unshift({
+                    name: summary,
+                    value: CHECKOUT_ERROR_VALUE,
+                    disabled: true
+                });
+                return choices;
             }
-            session.cleanup();
-            let authToken;
-            try {
-                authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            } catch (e) {
-                logger_logger.error("Not logged in. Please log in first.");
-                process.exit(1);
+        };
+    }
+    const INLINE_SPINNER_FRAMES = [
+        "⠋",
+        "⠙",
+        "⠹",
+        "⠸",
+        "⠼",
+        "⠴",
+        "⠦",
+        "⠧",
+        "⠇",
+        "⠏"
+    ];
+    async function runCustomCheckoutPicker(anvilUrl, username, deps, initialQuery) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
+        const pageSize = 20;
+        const staleTimeMs = 30000;
+        const debounceMs = 180;
+        const simulatedDelayMs = getCheckoutPickerDelayMs();
+        const paginationDelayMs = getCheckoutPickerPaginationDelayMs();
+        const maxVisibleRows = getCheckoutPickerMaxRows();
+        const cache = new Map();
+        let query = normalizePickerQuery(initialQuery);
+        let selectedIndex = 0;
+        let scrollOffset = 0;
+        let loading = false;
+        let loadingMore = false;
+        let done = false;
+        let pendingTimer = null;
+        let loadingRenderTimer = null;
+        let activeController = null;
+        let resolveResult = null;
+        const ensureState = (key)=>{
+            const existing = cache.get(key);
+            if (existing) return existing;
+            const created = {
+                items: [],
+                nextCursor: null,
+                lastError: null,
+                updatedAt: 0
+            };
+            cache.set(key, created);
+            return created;
+        };
+        const currentState = ()=>ensureState(query);
+        const clearScreen = ()=>{
+            process.stdout.write("\x1b[2J\x1b[H");
+        };
+        const visibleRows = ()=>{
+            const rows = process.stdout.rows || 24;
+            return Math.min(maxVisibleRows, Math.max(6, rows - 9));
+        };
+        const syncViewport = ()=>{
+            const items = currentState().items;
+            if (selectedIndex >= items.length) selectedIndex = Math.max(0, items.length - 1);
+            const height = visibleRows();
+            if (selectedIndex < scrollOffset) scrollOffset = selectedIndex;
+            else if (selectedIndex >= scrollOffset + height) scrollOffset = Math.max(0, selectedIndex - height + 1);
+        };
+        const render = ()=>{
+            clearScreen();
+            const state = currentState();
+            const items = state.items;
+            const activeQuery = query || chalk_source.gray("(all apps)");
+            const spinnerFrame = INLINE_SPINNER_FRAMES[Math.floor(Date.now() / 120) % INLINE_SPINNER_FRAMES.length];
+            const status = loading ? loadingMore ? chalk_source.yellow(`${spinnerFrame} Loading more apps... (${items.length} loaded)`) : chalk_source.yellow(`${spinnerFrame} Loading apps...`) : state.nextCursor ? chalk_source.gray(`Loaded ${items.length} apps • more available`) : chalk_source.gray(`Loaded ${items.length} apps`);
+            process.stdout.write(`${chalk_source.bold("Search apps by name or app ID")}\n`);
+            process.stdout.write(`${chalk_source.cyan("Query:")} ${activeQuery}\n`);
+            process.stdout.write(`${status}\n`);
+            if (state.lastError) process.stdout.write(`${chalk_source.red(`Fetch failed: ${state.lastError}`)}\n`);
+            const height = visibleRows();
+            const start = scrollOffset;
+            const end = Math.min(items.length, start + height);
+            if (0 !== items.length || loading || state.lastError) for(let i = start; i < end; i += 1){
+                const item = items[i];
+                const label = formatAppPickerLabel(item);
+                const line = i === selectedIndex ? `${chalk_source.green("❯")} ${label}` : `  ${label}`;
+                process.stdout.write(`${line}\n`);
             }
-            logger_logger.progress("sync-latest", "Syncing to latest version from Anvil...");
+            else process.stdout.write(`${chalk_source.gray("No matches. Keep typing.")}\n`);
+            process.stdout.write(`\n${chalk_source.gray("↑/↓ navigate • type to search • enter select • esc/ctrl+c cancel")}\n`);
+        };
+        const fetchPage = async (key, cursor)=>{
+            const state = ensureState(key);
+            const controller = new AbortController();
+            if (!cursor && activeController) activeController.abort();
+            activeController = controller;
+            loading = true;
+            loadingMore = !!cursor;
+            startLoadingAnimation();
+            render();
             try {
-                const newCommitId = await syncToLatest(options.repoPath, options.appId, options.anvilUrl, authToken, branchName, options.username);
-                logger_logger.progressEnd("sync-latest", `Synced to latest version: ${newCommitId.substring(0, 8)}`);
+                if (simulatedDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, simulatedDelayMs));
+                if (cursor && paginationDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, paginationDelayMs));
+                const response = await deps.listAppsForCheckout({
+                    anvilUrl,
+                    username,
+                    limit: pageSize,
+                    cursor,
+                    q: key || void 0,
+                    signal: controller.signal
+                });
+                const merged = cursor ? state.items.concat(response.apps) : response.apps;
+                cache.set(key, {
+                    items: merged,
+                    nextCursor: response.next_cursor,
+                    lastError: null,
+                    updatedAt: Date.now()
+                });
+                if (key === query) syncViewport();
             } catch (e) {
-                logger_logger.progressEnd("sync-latest", "Failed");
-                logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
-                process.exit(1);
-            }
-            return await deps.recreateSessionAndValidate(options);
-        }
-        await deps.startWatchingWithEventHandlers(session, options);
-        return true;
-    }
-    async function startWatchingWithEventHandlers(session, options) {
-        const { autoMode, repoPath, appId, anvilUrl, stagedOnly } = options;
-        session.on("branch-changed", async ({ oldBranch, newBranch })=>{
-            try {
-                session.cleanup();
-                logger_logger.warn(`Branch changed: ${chalk_source.bold(oldBranch)} → ${chalk_source.bold(newBranch)}`);
-                logger_logger.info(chalk_source.cyan("→ Restarting watch on new branch..."));
-                const git = esm_default(repoPath);
-                const actualBranch = (await git.revparse([
-                    "--abbrev-ref",
-                    "HEAD"
-                ])).trim();
-                if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed again to ${chalk_source.bold(actualBranch)}, using that instead`));
-                logger_logger.progress("init", "Initializing watch session...");
-                try {
-                    const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
-                    logger_logger.progressEnd("init");
-                    const started = await checkSyncStatusAndStart(newSession, options);
-                    if (!started) process.exit(0);
-                } catch (e) {
-                    logger_logger.progressEnd("init", "Failed");
-                    logger_logger.error("Failed to restart watch: " + errors_getErrorMessage(e));
-                    process.exit(1);
-                }
-            } catch (error) {
-                logger_logger.error(`Error handling branch change: ${error.message}`);
-                process.exit(1);
-            }
-        });
-        session.on("validation-failed", ({ reason, currentBranch })=>{
-            logger_logger.error(chalk_source.red(`Validation failed: ${reason}`));
-            logger_logger.verbose(chalk_source.yellow(`   Current branch: ${currentBranch}`));
-            logger_logger.verbose(chalk_source.yellow("   Please restart anvil to re-validate the branch."));
-            session.cleanup();
-            process.exit(1);
-        });
-        session.on("max-retries-exceeded", async ()=>{
-            if (autoMode) {
-                logger_logger.info(chalk_source.cyan("→ Auto-restarting watch session..."));
-                session.cleanup();
-                const restarted = await recreateSessionAndValidate(options);
-                if (!restarted) process.exit(1);
-            } else {
-                const shouldRestart = await logger_logger.confirm("Would you like to restart the watch session?", true);
-                if (shouldRestart) {
-                    session.cleanup();
-                    const restarted = await recreateSessionAndValidate(options);
-                    if (!restarted) process.exit(1);
+                if (!controller.signal.aborted && !isAbortLikeError(e)) {
+                    const message = errors_getErrorMessage(e);
+                    cache.set(key, {
+                        ...state,
+                        lastError: message,
+                        updatedAt: Date.now()
+                    });
                 }
+            } finally{
+                if (activeController === controller) activeController = null;
+                loading = false;
+                loadingMore = false;
+                stopLoadingAnimation();
+                render();
             }
-        });
-        if (session.hasUncommittedChanges) {
-            if (!autoMode) {
-                const shouldContinue = await logger_logger.confirm("Continue? Your uncommitted changes will be synced to Anvil.", true);
-                if (!shouldContinue) {
-                    logger_logger.warn("Watch cancelled. Commit, stash, or discard your changes, then try again.");
-                    session.cleanup();
-                    process.exit(0);
-                }
+        };
+        const ensureFresh = async (key)=>{
+            const state = ensureState(key);
+            const stale = Date.now() - state.updatedAt > staleTimeMs;
+            if (0 === state.items.length || stale || state.lastError) await fetchPage(key);
+            else render();
+        };
+        const maybeLoadMore = async ()=>{
+            const state = currentState();
+            if (!state.nextCursor || loading) return;
+            if (selectedIndex >= Math.max(0, state.items.length - 2)) await fetchPage(query, state.nextCursor || void 0);
+        };
+        const scheduleQueryFetch = ()=>{
+            if (pendingTimer) clearTimeout(pendingTimer);
+            pendingTimer = setTimeout(()=>{
+                pendingTimer = null;
+                ensureFresh(query);
+            }, debounceMs);
+        };
+        const startLoadingAnimation = ()=>{
+            if (loadingRenderTimer) return;
+            loadingRenderTimer = setInterval(()=>{
+                if (!done && loading) render();
+            }, 120);
+        };
+        const stopLoadingAnimation = ()=>{
+            if (!loadingRenderTimer) return;
+            clearInterval(loadingRenderTimer);
+            loadingRenderTimer = null;
+        };
+        const finish = (value)=>{
+            done = true;
+            if (pendingTimer) {
+                clearTimeout(pendingTimer);
+                pendingTimer = null;
             }
-            logger_logger.progress("save", "Saving uncommitted changes to Anvil...");
-            try {
-                await session.forceSave();
-                logger_logger.progressEnd("save");
-            } catch (e) {
-                logger_logger.progressEnd("save", "Failed");
-                logger_logger.error(`Failed to save: ${errors_getErrorMessage(e)}`);
+            if (activeController) {
+                activeController.abort();
+                activeController = null;
             }
-        }
-        await session.startWatching();
-    }
-    async function handleWatchCommand(options) {
-        const invoked = process.argv[2];
-        if ("sync" === invoked) {
-            logger_logger.error("'sync' has been renamed to 'watch'. Please use 'anvil watch' instead.");
-            process.exit(1);
-        }
-        const { path: repoPath = process.cwd(), appid: explicitAppId, useFirst = false, stagedOnly = false, autoMode = false, url: explicitUrl, user: explicitUsername, open: openAfterValidation = false } = options;
-        try {
-            const validationResult = await validateAnvilApp(repoPath);
-            if (validationResult.appName) logger_logger.info(chalk_source.green("Anvil app: ") + chalk_source.bold(validationResult.appName));
-            const detectedFromAllRemotes = await detectAppIdsFromAllRemotes(repoPath);
-            let filteredCandidates = filterCandidates(detectedFromAllRemotes, explicitUrl, explicitUsername);
-            logger_logger.verbose(chalk_source.cyan(`Detected ${detectedFromAllRemotes.length} app ID(s) from git remotes`));
-            if (filteredCandidates.length !== detectedFromAllRemotes.length) logger_logger.verbose(chalk_source.cyan(`After filtering: ${filteredCandidates.length} candidate(s)`));
-            let finalAppId;
-            let anvilUrl;
-            let username = explicitUsername;
-            let fallbackUrl;
-            let shouldPersistUsernameBinding = false;
-            if (explicitAppId) {
-                finalAppId = explicitAppId;
-                const binding = await getAppAuthBinding(repoPath, explicitAppId);
-                if (binding.url && !explicitUrl) {
-                    anvilUrl = normalizeAnvilUrl(binding.url);
-                    logger_logger.verbose(chalk_source.cyan("Resolved URL from binding for app ID: ") + chalk_source.bold(anvilUrl));
-                }
-                if (binding.username && !explicitUsername) {
-                    username = binding.username;
-                    logger_logger.verbose(chalk_source.cyan("Resolved username from binding for app ID: ") + chalk_source.bold(username));
-                }
-                const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
-                if (remoteInfo.detectedUrl && !explicitUrl && !anvilUrl) {
-                    anvilUrl = normalizeAnvilUrl(remoteInfo.detectedUrl);
-                    logger_logger.verbose(chalk_source.cyan("Resolved URL from remote for app ID: ") + chalk_source.bold(anvilUrl));
-                }
-                if (remoteInfo.detectedUsername && !explicitUsername && !username) {
-                    username = remoteInfo.detectedUsername;
-                    logger_logger.verbose(chalk_source.cyan("Resolved username from remote for app ID: ") + chalk_source.bold(username));
-                }
-            } else {
-                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
-                if (0 === filteredCandidates.length) {
-                    logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
-                    const resolvedFallbackUrl = await resolveUrlForFallback(explicitUrl);
-                    if (null === resolvedFallbackUrl) {
-                        logger_logger.warn("Operation cancelled.");
-                        process.exit(0);
-                    }
-                    fallbackUrl = normalizeAnvilUrl(resolvedFallbackUrl);
-                    const lookupDecision = await confirmReverseLookupWithResolvedUser(fallbackUrl, username);
-                    if (null === lookupDecision) {
-                        logger_logger.warn("Operation cancelled.");
-                        process.exit(0);
-                    }
-                    username = lookupDecision.username;
-                    if (lookupDecision.shouldContinue) {
-                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${username ? `for ${username}` : ""} for matching app IDs...`);
-                        const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
-                            anvilUrl: fallbackUrl,
-                            username,
-                            includeRemotes: false
-                        });
-                        logger_logger.progressEnd("detect");
-                        for (const c of reverseLookupCandidates)filteredCandidates.push({
-                            ...c,
-                            detectedUrl: fallbackUrl
-                        });
-                    }
-                }
-                if (filteredCandidates.length > 0) {
-                    for (const c of filteredCandidates)logger_logger.verbose(chalk_source.gray(`   Found: ${formatCandidateLabel(c)}`));
-                    if (filteredCandidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${filteredCandidates.length} potential app IDs`));
-                }
-                if (useFirst && filteredCandidates.length > 0) {
-                    const selected = filteredCandidates[0];
-                    finalAppId = selected.appId;
-                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
-                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
-                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
-                } else {
-                    const selected = await selectAppId(filteredCandidates);
-                    if (!selected) {
-                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
-                        process.exit(1);
-                    }
-                    finalAppId = selected.appId;
-                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
-                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
-                }
-            }
-            const binding = await getAppAuthBinding(repoPath, finalAppId);
-            if (binding.url && !explicitUrl) {
-                anvilUrl = normalizeAnvilUrl(binding.url);
-                logger_logger.verbose(chalk_source.cyan("Using app binding URL: ") + chalk_source.bold(anvilUrl));
-            }
-            if (binding.username && !explicitUsername) {
-                username = binding.username;
-                logger_logger.verbose(chalk_source.cyan("Using app binding username: ") + chalk_source.bold(username));
+            stopLoadingAnimation();
+            process.stdin.removeListener("keypress", onKeypress);
+            if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(false);
+            process.stdin.pause();
+            clearScreen();
+            if (resolveResult) resolveResult(value);
+        };
+        const onKeypress = (_str, key)=>{
+            if (done) return;
+            if (key.ctrl && "c" === key.name) return void finish(null);
+            if ("escape" === key.name) return void finish(null);
+            if ("return" === key.name) {
+                const state = currentState();
+                const selected = state.items[selectedIndex];
+                finish(selected ? selected.app_id : null);
+                return;
             }
-            shouldPersistUsernameBinding = !binding.username && !explicitUsername;
-            if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
-            else if (!anvilUrl) if (fallbackUrl) anvilUrl = fallbackUrl;
-            else {
-                const resolvedFallbackUrl = await resolveUrlForFallback();
-                if (null === resolvedFallbackUrl) {
-                    logger_logger.warn("Operation cancelled.");
-                    process.exit(0);
+            if ("up" === key.name) {
+                if (selectedIndex > 0) {
+                    selectedIndex -= 1;
+                    syncViewport();
+                    render();
                 }
-                anvilUrl = normalizeAnvilUrl(resolvedFallbackUrl);
-            }
-            anvilUrl = normalizeAnvilUrl(anvilUrl);
-            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
-            const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username);
-            if (null === resolvedUsername) {
-                logger_logger.warn("Operation cancelled.");
-                process.exit(0);
+                return;
             }
-            username = resolvedUsername;
-            if (shouldPersistUsernameBinding && username && auth_getAccountsForUrl(anvilUrl).length > 1) {
-                await setAppAuthBinding(repoPath, finalAppId, {
-                    url: anvilUrl,
-                    username
-                });
-                logger_logger.verbose(chalk_source.cyan("Saved app account binding for future non-interactive use."));
+            if ("down" === key.name) {
+                const maxIndex = Math.max(0, currentState().items.length - 1);
+                if (selectedIndex < maxIndex) {
+                    selectedIndex += 1;
+                    syncViewport();
+                    render();
+                    maybeLoadMore();
+                }
+                return;
             }
-            if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
-            if (!hasTokensForUrl(anvilUrl, username)) {
-                if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
-                else logger_logger.error(`Not logged in to ${anvilUrl}`);
-                logger_logger.verbose(chalk_source.yellow("Please log in first:"));
-                logger_logger.info(chalk_source.cyan(`   anvil login ${anvilUrl.replace(/^https?:\/\//, "")}`));
-                process.exit(1);
+            if ("backspace" === key.name || "delete" === key.name) {
+                if (query.length > 0) {
+                    query = query.slice(0, -1);
+                    selectedIndex = 0;
+                    scrollOffset = 0;
+                    render();
+                    scheduleQueryFetch();
+                }
+                return;
             }
-            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
-            await configureWatchGitAuth({
-                repoPath,
-                appId: finalAppId,
-                anvilUrl,
-                username
-            });
-            logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
-            const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
-            logger_logger.progressEnd("validate");
-            if (!appIdValidation.valid) {
-                logger_logger.error(`App ID validation failed: ${appIdValidation.error}`);
-                logger_logger.verbose(chalk_source.yellow("This could mean:"));
-                logger_logger.verbose(chalk_source.yellow("  • The app ID doesn't exist on the server"));
-                logger_logger.verbose(chalk_source.yellow("  • You don't have access to this app"));
-                logger_logger.verbose(chalk_source.yellow("  • There's a network or authentication issue"));
-                process.exit(1);
+            if (!key.ctrl && !key.meta && key.sequence && 1 === key.sequence.length && key.sequence >= " ") {
+                query += key.sequence;
+                selectedIndex = 0;
+                scrollOffset = 0;
+                render();
+                scheduleQueryFetch();
             }
-            logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
-            if (appIdValidation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${appIdValidation.app_name}`));
-            if (stagedOnly) logger_logger.info(chalk_source.yellow("▸ Staged-only mode: Only staged changes will be synced"));
-            if (autoMode) logger_logger.info(chalk_source.cyan("▸ Auto mode: Will automatically restart on branch changes and sync when behind"));
-            logger_logger.progress("init", "Initializing watch session...");
-            const session = await api_watch(repoPath, finalAppId, anvilUrl, stagedOnly, username);
-            logger_logger.progressEnd("init");
-            if (openAfterValidation) await openWatchPath(resolveWatchOpenPath(repoPath));
-            logger_logger.verbose(chalk_source.blue("Watching for file changes..."));
-            const started = await checkSyncStatusAndStart(session, {
-                autoMode,
-                repoPath,
-                appId: finalAppId,
-                anvilUrl,
-                stagedOnly,
-                username
+        };
+        logger_logger.pause();
+        try {
+            external_readline_default().emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on("keypress", onKeypress);
+            await ensureFresh(query);
+            return await new Promise((resolve)=>{
+                resolveResult = resolve;
             });
-            if (!started) process.exit(1);
-        } catch (e) {
-            logger_logger.error("Error: " + errors_getErrorMessage(e));
-            process.exit(1);
+        } finally{
+            logger_logger.resume();
         }
     }
-    function registerWatchCommand(program) {
-        const watchCommand = program.command("watch [path]").description("Watch for file changes and sync to Anvil").alias("sync").alias("w").option("-A, --appid <APP_ID>", "Specify app ID directly").option("-f, --first", "Auto-select first detected app ID without confirmation").option("-s, --staged-only", "Only sync staged changes (use git add to stage files)").option("-a, --auto", "Auto mode: restart on branch changes and sync when behind").option("-O, --open", "Open watched path in preferred editor (or default app)").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL (e.g., anvil.works, localhost)").option("-U, --user <USERNAME>", "Specify which user account to use").action(async (path, options, command)=>{
-            const globalOptions = command.optsWithGlobals();
-            if (void 0 !== globalOptions.verbose && logger_logger instanceof CLILogger) logger_logger.setVerbose(globalOptions.verbose);
-            await handleWatchCommand({
-                path,
-                appid: options.appid,
-                useFirst: options.first,
-                stagedOnly: options.stagedOnly,
-                autoMode: options.auto,
-                verbose: globalOptions.verbose,
-                open: options.open,
-                url: options.url,
-                user: options.user
-            });
+    async function selectAppForCheckout(anvilUrl, username, deps, initialQuery) {
+        if (!isTestMode() && "1" !== process.env.ANVIL_CHECKOUT_LEGACY_PICKER) return runCustomCheckoutPicker(anvilUrl, username, deps, initialQuery);
+        const picker = createCheckoutPickerSource(anvilUrl, username, deps, {
+            initialQuery
         });
-        return watchCommand;
+        try {
+            const answer = await logger_logger.prompt([
+                {
+                    type: "search",
+                    name: "value",
+                    message: "Search apps by name or app ID",
+                    source: picker.source,
+                    pageSize: 12,
+                    loop: false,
+                    instructions: {
+                        navigation: "↑↓ navigate • type to filter",
+                        pager: "enter select • ctrl+c cancel"
+                    }
+                }
+            ]);
+            const selected = String(answer.value || "");
+            if (!selected || selected === CHECKOUT_ERROR_VALUE) return null;
+            return selected;
+        } catch (e) {
+            const err = e;
+            if ("ExitPromptError" === err.name || String(err.message || "").includes("User force closed")) return null;
+            throw e;
+        }
     }
-    var external_http_ = __webpack_require__("http");
-    const successPage = `<!DOCTYPE html>
-  <html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>Anvil Sync • Login Complete</title>
-      <link rel="preconnect" href="https://fonts.googleapis.com">
-      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-      <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
-      <style>
-        * { box-sizing: border-box; }
-        html, body { height: 100%; margin: 0; }
-        body {
-          font-family: Poppins, -apple-system, system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-          color: #555555;
-          background: #f7fdff;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          padding: 20px;
-        }
-        .card {
-          width: min(480px, 100%);
-          background: #ffffff;
-          border-radius: 12px;
-          padding: 48px 40px;
-          text-align: center;
-          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
-        }
-        .icon {
-          display: inline-flex;
-          align-items: center;
-          justify-content: center;
-          width: 56px;
-          height: 56px;
-          margin: 0 auto 24px;
-          border-radius: 50%;
-          background: #1bb0ee;
-          color: white;
-        }
-        .icon svg {
-          width: 28px;
-          height: 28px;
-        }
-        h1 {
-          font-size: 24px;
-          font-weight: 600;
-          line-height: 1.3;
-          margin: 0 0 12px;
-          color: #1a1a1a;
-        }
-        p {
-          color: #555555;
-          font-size: 15px;
-          line-height: 1.5;
-          margin: 0;
-        }
-      </style>
-    </head>
-    <body>
-      <main class="card" role="status" aria-live="polite">
-        <div class="icon" aria-hidden="true">
-          <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-            <path d="M20 7L9 18l-5-5" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
-          </svg>
-        </div>
-        <h1>Anvil login complete</h1>
-        <p>Close this window and return to your terminal to continue.</p>
-      </main>
-    </body>
-  </html>`;
-    function errorPage(errorMsg) {
-        return `<!DOCTYPE html>
-<html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>Anvil Sync • Login Error</title>
-      <link rel="preconnect" href="https://fonts.googleapis.com">
-      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-      <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
-      <style>
-        * { box-sizing: border-box; }
-        html, body { height: 100%; margin: 0; }
-        body {
-          font-family: Poppins, -apple-system, system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-          color: #555555;
-          background: #f7fdff;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          padding: 20px;
+    const defaultCheckoutDeps = {
+        getValidAuthToken: auth_getValidAuthToken,
+        validateAppId: validateAppId,
+        listAppsForCheckout: listAppsForCheckout,
+        runInteractiveLoginFlow: runInteractiveLoginFlow,
+        clone: async (repoUrl, destinationPath, options)=>{
+            const cloneArgs = [];
+            if (options?.branch) cloneArgs.push("--branch", options.branch);
+            if ("number" == typeof options?.depth) cloneArgs.push("--depth", String(options.depth));
+            if (options?.singleBranch) cloneArgs.push("--single-branch");
+            if (options?.origin) cloneArgs.push("--origin", options.origin);
+            if (options?.quiet) cloneArgs.push("--quiet");
+            if (options?.verbose) cloneArgs.push("--verbose");
+            await esm_default().clone(repoUrl, destinationPath, cloneArgs);
+        },
+        hardenCheckoutGitAuth: hardenCheckoutGitAuth
+    };
+    function isInteractiveSession() {
+        return !!(process.stdin.isTTY && process.stdout.isTTY);
+    }
+    function parseCheckoutInput(input) {
+        const trimmed = input.trim();
+        if (!trimmed) throw new Error("Input is required.");
+        if (/^[A-Z0-9]+$/.test(trimmed)) return {
+            appId: trimmed
+        };
+        const asUrl = /^https?:\/\//.test(trimmed) ? trimmed : normalizeAnvilUrl(trimmed);
+        let parsed;
+        try {
+            parsed = new URL(asUrl);
+        } catch  {
+            throw new Error("Input must be an editor URL, /git URL, or bare app ID.");
         }
-        .card {
-          width: min(480px, 100%);
-          background: #ffffff;
-          border-radius: 12px;
-          padding: 48px 40px;
-          text-align: center;
-          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+        const gitMatch = parsed.pathname.match(/\/git\/([A-Z0-9]+)\.git(?:$|\/)/);
+        if (gitMatch) return {
+            appId: gitMatch[1],
+            detectedUrl: `${parsed.protocol}//${parsed.host}`
+        };
+        const appsMatch = parsed.pathname.match(/\/apps\/([A-Z0-9]+)(?:\/|$)/);
+        if (appsMatch) return {
+            appId: appsMatch[1],
+            detectedUrl: `${parsed.protocol}//${parsed.host}`
+        };
+        throw new Error("Could not extract app ID. Expected URL path containing /apps/<APPID> or /git/<APPID>.git.");
+    }
+    function sanitizeDirectoryName(name) {
+        return name.trim().replace(/\s+/g, "_").replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+    }
+    function formatPathForDisplay(destinationPath) {
+        const relative = external_path_default().relative(process.cwd(), destinationPath);
+        if ("" === relative) return ".";
+        if (relative.startsWith("..")) return destinationPath;
+        return relative.startsWith(".") ? relative : `./${relative}`;
+    }
+    function getDefaultDestinationDirectory(appId, appName) {
+        if (appName) {
+            const sanitized = sanitizeDirectoryName(appName);
+            if (sanitized) return sanitized;
         }
-        .icon {
-          display: inline-flex;
-          align-items: center;
-          justify-content: center;
-          width: 56px;
-          height: 56px;
-          margin: 0 auto 24px;
-          border-radius: 50%;
-          background: #ef4444;
-          color: white;
+        return appId;
+    }
+    async function resolveCheckoutUrl(explicitUrl, parsedUrl) {
+        if (explicitUrl) {
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from --url: ") + chalk_source.bold(normalizeAnvilUrl(explicitUrl)));
+            return normalizeAnvilUrl(explicitUrl);
         }
-        .icon svg {
-          width: 28px;
-          height: 28px;
+        if (parsedUrl) {
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from checkout input: ") + chalk_source.bold(normalizeAnvilUrl(parsedUrl)));
+            return normalizeAnvilUrl(parsedUrl);
         }
-        h1 {
-          font-size: 24px;
-          font-weight: 600;
-          line-height: 1.3;
-          margin: 0 0 16px;
-          color: #1a1a1a;
+        const decision = decideFallbackUrl(void 0);
+        if ("available-multiple" !== decision.source) {
+            if (decision.url) logger_logger.verbose(chalk_source.cyan("Using configured Anvil URL: ") + chalk_source.bold(decision.url));
+            return decision.url;
         }
-        p {
-          color: #555555;
-          font-size: 15px;
-          line-height: 1.5;
-          margin: 16px 0 0;
+        const choices = decision.urls.map((url)=>({
+                name: url,
+                value: url
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        return logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
+    }
+    async function isPathInsideGitRepo(targetPath) {
+        const resolved = external_path_default().resolve(targetPath);
+        let current = resolved;
+        while(!external_fs_.existsSync(current)){
+            const parent = external_path_default().dirname(current);
+            if (parent === current) return false;
+            current = parent;
         }
-        .details {
-          color: #666666;
-          font-size: 13px;
-          word-break: break-word;
-          font-weight: 500;
-          font-family: ui-monospace, "SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace;
-          margin: 16px 0 0;
-          padding: 12px;
-          background: #f8f9fa;
-          border-radius: 6px;
-          text-align: left;
+        try {
+            const output = (await esm_default(current).raw([
+                "rev-parse",
+                "--is-inside-work-tree"
+            ])).trim();
+            return "true" === output;
+        } catch  {
+            return false;
         }
-      </style>
-    </head>
-    <body>
-      <main class="card" role="status" aria-live="polite">
-        <div class="icon" aria-hidden="true">
-          <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-            <path d="M15 9l-6 6M9 9l6 6" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-          </svg>
-        </div>
-        <h1>Anvil login failed</h1>
-        <div id="details" class="details">${errorMsg}</div>
-        <p>Close this window and return to your terminal to retry.</p>
-      </main>
-    </body>
-  </html>`;
     }
-    const CLIENT_ID = "anvil-sync";
-    const SCOPES = "apps:read apps:write user:read";
-    function oauth_login_base64url(buf) {
-        return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    async function isDirectoryNonEmpty(destinationPath) {
+        if (!external_fs_.existsSync(destinationPath)) return false;
+        const stats = await external_fs_.promises.stat(destinationPath);
+        if (!stats.isDirectory()) return true;
+        const entries = await external_fs_.promises.readdir(destinationPath);
+        return entries.length > 0;
     }
-    function sleep(ms) {
-        return new Promise((resolve)=>setTimeout(resolve, ms));
+    async function validateCheckoutDestination(destinationPath, force = false) {
+        const nonEmpty = await isDirectoryNonEmpty(destinationPath);
+        if (nonEmpty && !force) throw new Error(`Destination '${destinationPath}' already exists and is not empty.`);
+        const insideGit = await isPathInsideGitRepo(destinationPath);
+        if (insideGit && !force) throw new Error(`Destination '${destinationPath}' is inside an existing Git repository.`);
+        if (force && nonEmpty) logger_logger.warn(`--force set: destination '${destinationPath}' is non-empty and clone may still fail.`);
+        if (force && insideGit) logger_logger.warn("--force set: cloning inside an existing Git repository.");
     }
-    function createBrowserLaunchPrompt(authUrl) {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) return {
-            waitForOpen: Promise.resolve(false),
-            close: ()=>{}
-        };
-        const rl = external_readline_namespaceObject.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        let closed = false;
-        let resolveWait = null;
-        const close = (opened = false)=>{
-            if (closed) return;
-            closed = true;
-            rl.close();
-            resolveWait?.(opened);
-            resolveWait = null;
-        };
-        const waitForOpen = new Promise((resolve)=>{
-            resolveWait = resolve;
-            rl.on("SIGINT", ()=>{
-                close();
-                process.kill(process.pid, "SIGINT");
-            });
-            rl.question("", async ()=>{
-                try {
-                    await node_modules_open(authUrl);
-                    logger_logger.info(chalk_source.dim("Opened your browser to continue login."));
-                    close(true);
-                } catch  {
-                    logger_logger.warn("Could not open a browser automatically.");
-                    close(false);
-                }
-            });
+    async function ensureCheckoutAuthToken(anvilUrl, username, deps = defaultCheckoutDeps) {
+        try {
+            logger_logger.verbose(chalk_source.cyan("Checking auth token for: ") + chalk_source.bold(username ? `${username} @ ${anvilUrl}` : anvilUrl));
+            return await deps.getValidAuthToken(anvilUrl, username);
+        } catch (e) {
+            const interactive = process.stdin.isTTY && process.stdout.isTTY;
+            if (!interactive) throw errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
+            const shouldLogin = await logger_logger.confirm(`Not logged in to ${anvilUrl}. Log in now?`, true);
+            if (!shouldLogin) throw errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
+            await deps.runInteractiveLoginFlow(anvilUrl);
+            return deps.getValidAuthToken(anvilUrl, username);
+        }
+    }
+    async function resolveCheckoutUsername(anvilUrl, explicitUsername, getAccounts = auth_getAccountsForUrl) {
+        if (explicitUsername) return explicitUsername;
+        const accounts = getAccounts(anvilUrl);
+        if (0 === accounts.length) return;
+        if (1 === accounts.length) {
+            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(accounts[0]));
+            return accounts[0];
+        }
+        const interactive = process.stdin.isTTY && process.stdout.isTTY;
+        if (!interactive) throw new Error(`Multiple accounts found for ${anvilUrl}. Use --user <USERNAME> to choose one.`);
+        const choices = accounts.map((acct)=>({
+                name: acct,
+                value: acct
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
         });
-        return {
-            waitForOpen,
-            close
-        };
+        return logger_logger.select(`Multiple accounts found for ${anvilUrl}. Which account should be used for checkout?`, choices, accounts[0]);
     }
-    async function parseOAuthError(response) {
-        const contentType = response.headers.get("content-type") || "";
-        if (contentType.includes("application/json")) {
-            const data = await response.json();
-            return data.error || `HTTP ${response.status}`;
+    async function executeCheckout(options, deps = defaultCheckoutDeps) {
+        let checkoutInput = options.input?.trim();
+        let preselectedAnvilUrl;
+        let preselectedUsername;
+        if (!checkoutInput) {
+            if (!isInteractiveSession()) throw new Error("`anvil checkout` without arguments requires an interactive TTY. Pass APP_ID or URL explicitly in non-interactive mode.");
+            const selectedUrl = await resolveCheckoutUrl(options.url);
+            if (!selectedUrl) return void logger_logger.info("Checkout cancelled.");
+            preselectedAnvilUrl = selectedUrl;
+            const selectedUsername = await resolveCheckoutUsername(selectedUrl, options.user);
+            if (null === selectedUsername) return void logger_logger.info("Checkout cancelled.");
+            preselectedUsername = selectedUsername || void 0;
+            const selectedInput = await selectAppForCheckout(selectedUrl, preselectedUsername, deps, options.query);
+            if (!selectedInput) return void logger_logger.info("Checkout cancelled.");
+            checkoutInput = selectedInput;
         }
-        const text = (await response.text()).trim();
-        if (!text) return `HTTP ${response.status}`;
+        logger_logger.verbose(chalk_source.cyan("Checkout input: ") + chalk_source.bold(checkoutInput));
+        const parsed = parseCheckoutInput(checkoutInput);
+        logger_logger.verbose(chalk_source.cyan("Resolved app ID: ") + chalk_source.bold(parsed.appId));
+        const anvilUrl = preselectedAnvilUrl || await resolveCheckoutUrl(options.url, parsed.detectedUrl);
+        if (!anvilUrl) return void logger_logger.info("Checkout cancelled.");
+        const resolvedUsername = preselectedUsername || await resolveCheckoutUsername(anvilUrl, options.user);
+        if (null === resolvedUsername) return void logger_logger.info("Checkout cancelled.");
+        if (resolvedUsername) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(resolvedUsername));
+        else logger_logger.verbose(chalk_source.cyan("No account preselected; resolving after auth token lookup."));
+        const authToken = await ensureCheckoutAuthToken(anvilUrl, resolvedUsername, deps);
+        let checkoutUsername = resolvedUsername;
+        if (!checkoutUsername) {
+            const inferredUsername = await resolveCheckoutUsername(anvilUrl, void 0);
+            if (null === inferredUsername) return void logger_logger.info("Checkout cancelled.");
+            if (!inferredUsername) throw new Error(`Could not determine account for ${anvilUrl}. Use --user <USERNAME> so checkout can bind repository credentials.`);
+            checkoutUsername = inferredUsername;
+        }
+        logger_logger.verbose(chalk_source.cyan("Checkout account: ") + chalk_source.bold(checkoutUsername));
+        logger_logger.verbose(chalk_source.blue(`Validating app ID ${parsed.appId} with Anvil server...`));
+        const validation = await deps.validateAppId(parsed.appId, anvilUrl, checkoutUsername);
+        if (!validation.valid) throw new Error(validation.error || `App '${parsed.appId}' is not accessible on ${anvilUrl}.`);
+        logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
+        if (validation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${validation.app_name}`));
+        const destinationDir = options.directory || getDefaultDestinationDirectory(parsed.appId, validation.app_name);
+        const destinationPath = external_path_default().resolve(process.cwd(), destinationDir);
+        const destinationDisplay = formatPathForDisplay(destinationPath);
+        logger_logger.verbose(chalk_source.cyan("Resolved destination: ") + chalk_source.bold(destinationDisplay));
+        await validateCheckoutDestination(destinationPath, options.force);
+        const cloneUrl = getGitPushUrl(parsed.appId, authToken, anvilUrl);
+        logger_logger.verbose(chalk_source.cyan("Clone source: ") + chalk_source.bold(`${anvilUrl}/git/${parsed.appId}.git`));
+        if (options.branch) logger_logger.verbose(chalk_source.cyan("Requested branch: ") + chalk_source.bold(options.branch));
+        if ("number" == typeof options.depth) logger_logger.verbose(chalk_source.cyan("Clone depth: ") + chalk_source.bold(String(options.depth)));
+        if (options.singleBranch) logger_logger.verbose(chalk_source.cyan("Single-branch clone enabled"));
+        logger_logger.progress("checkout", `Checking out app ${parsed.appId} from ${anvilUrl}`);
+        logger_logger.info(chalk_source.gray(`   Destination directory: ${destinationDisplay}`));
+        await deps.clone(cloneUrl, destinationPath, {
+            branch: options.branch,
+            depth: options.depth,
+            singleBranch: options.singleBranch,
+            origin: options.origin,
+            quiet: options.quiet,
+            verbose: options.verbose
+        });
+        const remoteName = options.origin || "origin";
         try {
-            const parsed = JSON.parse(text);
-            return parsed.error || text;
-        } catch  {
-            return text;
+            await deps.hardenCheckoutGitAuth({
+                repoPath: destinationPath,
+                appId: parsed.appId,
+                anvilUrl,
+                username: checkoutUsername,
+                remoteName
+            });
+            logger_logger.verbose(chalk_source.cyan("Configured Git auth bridge for remote: ") + chalk_source.bold(remoteName));
+        } catch (e) {
+            throw new Error(`Checkout clone succeeded, but failed to configure repository credentials: ${errors_getErrorMessage(e)}. The repository exists at ${destinationDisplay}, but Git auth bridge setup is incomplete.`);
+        }
+        logger_logger.progressEnd("checkout", `Checked out ${parsed.appId} into ${destinationDisplay}`);
+        const preferredEditor = String(getConfig("preferredEditor") || "").trim();
+        const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
+        if (options.open) {
+            await checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand);
+            logger_logger.info(chalk_source.gray(`Opened ${destinationDisplay}`));
         }
+        if (preferredEditorCommand && !options.open) if (isCommandAvailable(preferredEditorCommand)) logger_logger.info(chalk_source.cyan(`Next: ${preferredEditorCommand} ${destinationDisplay}`));
+        else logger_logger.warn(`Preferred editor command '${preferredEditorCommand}' was not found in PATH. Run 'anvil configure' to choose an installed editor.`);
     }
-    async function exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier) {
-        const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded"
-            },
-            body: new URLSearchParams({
-                grant_type: "authorization_code",
-                code,
-                redirect_uri: redirectUri,
-                client_id: CLIENT_ID,
-                code_verifier: codeVerifier
-            })
-        });
-        if (!tokenResponse.ok) throw new Error(`Failed to exchange authorization code for token. ${await parseOAuthError(tokenResponse)}`);
-        return await tokenResponse.json();
+    async function checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps) {
+        await openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps);
     }
-    async function requestDeviceAuthorization(anvilUrl) {
-        const response = await fetch(`${anvilUrl}/oauth/device_authorization`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded"
-            },
-            body: new URLSearchParams({
-                client_id: CLIENT_ID,
-                scope: SCOPES
-            })
+    function registerCheckoutCommand(program) {
+        const checkoutCommand = program.command("checkout [input] [directory]").description("Check out an Anvil app locally from editor URL, git URL, app ID, or interactive selection").alias("co").option("-O, --open", "Open destination after checkout").option("-b, --branch <BRANCH>", "Checkout a specific branch").option("--depth <N>", "Create a shallow clone with history truncated to N commits", (value)=>parseInt(value, 10)).option("--single-branch", "Clone only one branch").option("--origin <NAME>", "Use a custom remote name instead of origin").option("--quiet", "Suppress git clone progress output").option("--verbose", "Enable verbose git clone output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL").option("-U, --user <USERNAME>", "Specify which user account to use").option("-f, --force", "Override safety checks for destination path").option("-Q, --query <QUERY>", "Initial search query for interactive checkout picker").action(async (input, directory, options, command)=>{
+            try {
+                const globalOptions = command?.optsWithGlobals() || options || {};
+                if ("number" == typeof options?.depth && (!Number.isFinite(options.depth) || options.depth <= 0)) throw new Error("--depth must be a positive integer");
+                await executeCheckout({
+                    input,
+                    directory,
+                    open: options?.open,
+                    branch: options?.branch,
+                    depth: options?.depth,
+                    singleBranch: options?.singleBranch,
+                    origin: options?.origin,
+                    quiet: options?.quiet,
+                    verbose: globalOptions.verbose,
+                    url: options?.url,
+                    user: options?.user,
+                    force: options?.force,
+                    query: options?.query
+                }, defaultCheckoutDeps);
+            } catch (e) {
+                logger_logger.error("Error: " + errors_getErrorMessage(e));
+                process.exit(1);
+            }
         });
-        if (!response.ok) throw new Error(`Failed to start device login. ${await parseOAuthError(response)}`);
-        return await response.json();
+        checkoutCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + '\n  anvil checkout http://localhost:3000/build/apps/APPID/code/assets/theme.css\n  anvil checkout https://anvil.works/git/APPID.git\n  anvil checkout APPID --url anvil.works\n  anvil checkout APPID --branch master --depth 1 --single-branch\n  anvil checkout APPID -O  # open editor/file browser after checkout\n  anvil checkout APPID my-local-folder --force\n  anvil checkout  # interactive search/select app list\n  anvil checkout -Q "dashboard"  # preseed picker search\n');
     }
-    async function pollDeviceAuthorization(anvilUrl, deviceAuth, options) {
-        const expiresAt = Date.now() + 1000 * deviceAuth.expires_in;
-        let intervalMs = 1000 * Math.max(deviceAuth.interval ?? 5, 1);
-        while(Date.now() < expiresAt){
-            if (options?.isCancelled?.()) throw new Error("cancelled");
-            const response = await fetch(`${anvilUrl}/oauth/token`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/x-www-form-urlencoded"
-                },
-                body: new URLSearchParams({
-                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-                    device_code: deviceAuth.device_code,
-                    client_id: CLIENT_ID
-                })
+    const DEFAULT_ANVIL_URL = resolveAnvilUrl();
+    async function syncToLatest(repoPath, appId, anvilUrl, authToken, currentBranch, username) {
+        try {
+            const git = esm_default(repoPath);
+            const commitId = (await git.revparse([
+                "HEAD"
+            ])).trim();
+            const session = new WatchSession(repoPath, appId, {
+                anvilUrl,
+                authToken,
+                currentBranch,
+                commitId,
+                username
             });
-            if (response.ok) return await response.json();
-            const error = await parseOAuthError(response);
-            if ("authorization_pending" === error) {
-                await sleep(intervalMs);
-                continue;
-            }
-            if ("slow_down" === error) {
-                intervalMs += 1000;
-                await sleep(intervalMs);
-                continue;
-            }
-            if ("access_denied" === error) throw new Error("Device login was denied.");
-            if ("expired_token" === error || "invalid_grant" === error) break;
-            throw new Error(`Device login failed. ${error}`);
+            await session.initialize();
+            await session.syncRemoteChanges();
+            const newCommitId = (await git.revparse([
+                "HEAD"
+            ])).trim();
+            return newCommitId;
+        } catch (e) {
+            if (isAnvilError(e)) throw e;
+            throw errors_createGitError.commandFailed("sync", e instanceof Error ? e.message : String(e));
         }
-        throw new Error("Device login expired before it was approved.");
     }
-    async function createPkceLoginFlow(anvilUrl) {
-        const codeVerifier = external_crypto_.randomBytes(48).toString("hex");
-        const codeChallenge = oauth_login_base64url(external_crypto_.createHash("sha256").update(codeVerifier, "ascii").digest());
-        const state = external_crypto_.randomBytes(16).toString("hex");
-        const server = external_http_.createServer();
-        await new Promise((resolve)=>server.listen(0, "127.0.0.1", resolve));
-        const address = server.address();
-        if (!address || "string" == typeof address) throw new Error("No address");
-        const port = address.port;
-        const redirectUri = `http://127.0.0.1:${port}/oauth-callback`;
-        const authUrl = new URL(`${anvilUrl}/oauth/authorize`);
-        authUrl.searchParams.set("response_type", "code");
-        authUrl.searchParams.set("client_id", CLIENT_ID);
-        authUrl.searchParams.set("redirect_uri", redirectUri);
-        authUrl.searchParams.set("scope", SCOPES);
-        authUrl.searchParams.set("state", state);
-        authUrl.searchParams.set("code_challenge", codeChallenge);
-        authUrl.searchParams.set("code_challenge_method", "S256");
-        const codePromise = new Promise((resolve, reject)=>{
-            server.on("request", (req, res)=>{
-                if (!req.url) return;
-                const url = new URL(req.url, `http://127.0.0.1:${port}`);
-                if ("/oauth-callback" !== url.pathname) return;
-                const code = url.searchParams.get("code") || void 0;
-                const error = url.searchParams.get("error") || void 0;
-                const recvState = url.searchParams.get("state");
-                if (!recvState || !code && !error) {
-                    res.statusCode = 400;
-                    res.end("Missing code, error or state");
-                    reject(new Error("Missing code/state/error"));
-                    server.close();
-                    return;
-                }
-                res.statusCode = 200;
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                if (code) res.end(successPage);
-                else res.end(errorPage(error || "unknown"));
-                resolve({
-                    code,
-                    error,
-                    recvState
-                });
-                server.closeAllConnections();
-                server.close();
-            });
+    async function api_watch(repoPath, appId, anvilUrl = DEFAULT_ANVIL_URL, stagedOnly = false, username) {
+        repoPath = external_path_default().resolve(repoPath);
+        const authToken = await auth_getValidAuthToken(anvilUrl, username);
+        await verifyAuth(authToken, anvilUrl);
+        const git = esm_default(repoPath);
+        let currentBranch;
+        try {
+            const branchRef = await git.revparse([
+                "--abbrev-ref",
+                "HEAD"
+            ]);
+            if ("HEAD" === branchRef) throw errors_createGitError.commandFailed("revparse", "Cannot sync from detached HEAD state. Please checkout a branch first.");
+            currentBranch = branchRef;
+        } catch (e) {
+            if ("git_command_failed" === e.type) throw e;
+            throw errors_createGitError.commandFailed("revparse", e.message);
+        }
+        let commitId;
+        try {
+            commitId = (await git.revparse([
+                "HEAD"
+            ])).trim();
+        } catch (e) {
+            throw errors_createGitError.commandFailed("revparse", e.message);
+        }
+        logger_logger.verbose(chalk_source.cyan("Current branch: ") + chalk_source.bold(currentBranch));
+        logger_logger.verbose(chalk_source.cyan("Current commit ID: ") + chalk_source.gray(commitId));
+        const syncStatus = await validateBranchSyncStatus(git, currentBranch, appId, anvilUrl, username);
+        let hasUncommittedChanges = false;
+        try {
+            const status = await git.status();
+            hasUncommittedChanges = status.files.length > 0;
+        } catch (e) {
+            throw errors_createGitError.commandFailed("status", e.message);
+        }
+        logger_logger.verbose(chalk_source.blue("Has uncommitted changes: ") + chalk_source.bold(hasUncommittedChanges));
+        const session = new WatchSession(repoPath, appId, {
+            anvilUrl,
+            authToken,
+            currentBranch,
+            commitId,
+            stagedOnly,
+            username
         });
-        let closed = false;
-        server.on("close", ()=>{
-            closed = true;
+        session.on("branch-changed", (data)=>{
+            logger_logger.debug("Event: branch-changed", data);
         });
-        const close = async ()=>{
-            if (closed) return;
-            closed = true;
-            server.closeAllConnections();
-            if (!server.listening) return;
-            await new Promise((resolve)=>server.close(()=>resolve()));
-        };
-        return {
-            authUrl,
-            close,
-            waitForLogin: (async ()=>{
-                const { code, error, recvState } = await codePromise;
-                if (recvState !== state) throw new Error("Invalid state received from OAuth callback");
-                if (error) throw new Error(`Error received from OAuth callback: ${error}`);
-                const tokenData = await exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier);
-                return login(anvilUrl, {
-                    access_token: tokenData.access_token,
-                    refresh_token: tokenData.refresh_token,
-                    expires_in: tokenData.expires_in,
-                    scope: tokenData.scope
-                });
-            })()
-        };
-    }
-    function raceLoginAttempts(attempts) {
-        return new Promise((resolve, reject)=>{
-            let remaining = attempts.length;
-            let lastError = null;
-            for (const attempt of attempts)attempt.then(resolve).catch((error)=>{
-                if ("cancelled" === error.message) return;
-                remaining -= 1;
-                lastError = error;
-                if (0 === remaining && lastError) reject(lastError);
-            });
+        session.on("sync-conflict", (data)=>{
+            logger_logger.debug("Event: sync-conflict", data);
         });
-    }
-    async function runInteractiveLoginFlow(anvilUrl) {
-        const pkceFlow = await createPkceLoginFlow(anvilUrl);
-        const deviceAuth = await requestDeviceAuthorization(anvilUrl);
-        const browserPrompt = createBrowserLaunchPrompt(pkceFlow.authUrl.toString());
-        let settled = false;
-        let spinnerStarted = false;
-        logger_logger.info(chalk_source.dim(`Logging in to ${anvilUrl}`));
-        console.log();
-        logger_logger.info(chalk_source.dim("Visit:"), `${deviceAuth.verification_uri_complete || deviceAuth.verification_uri}`);
-        logger_logger.info(chalk_source.dim("Device code:"), `${deviceAuth.user_code}`);
-        console.log();
-        logger_logger.info("OR Press ENTER to open a browser...");
-        browserPrompt.waitForOpen.then((opened)=>{
-            if (opened && !settled) {
-                spinnerStarted = true;
-                logger_logger.progress("login", "Waiting for login to complete...");
-            }
+        session.on("remote-update", (data)=>{
+            logger_logger.debug("Event: remote-update", data);
+        });
+        session.on("validation-failed", (data)=>{
+            logger_logger.debug("Event: validation-failed", data);
+        });
+        session.on("save-complete", (data)=>{
+            logger_logger.debug("Event: save-complete", data);
+        });
+        session.on("save-started", (data)=>{
+            logger_logger.debug("Event: save-started", data);
         });
         try {
-            const result = await raceLoginAttempts([
-                pkceFlow.waitForLogin,
-                pollDeviceAuthorization(anvilUrl, deviceAuth, {
-                    isCancelled: ()=>settled
-                }).then(async (tokenData)=>login(anvilUrl, {
-                        access_token: tokenData.access_token,
-                        refresh_token: tokenData.refresh_token,
-                        expires_in: tokenData.expires_in,
-                        scope: tokenData.scope
-                    }))
-            ]);
-            settled = true;
-            return result;
-        } finally{
-            settled = true;
-            browserPrompt.close();
-            if (spinnerStarted) logger_logger.progressEnd("login");
-            await pkceFlow.close();
-        }
-    }
-    const CHECKOUT_ERROR_VALUE = "__ERROR__";
-    function isAbortLikeError(error) {
-        if (error instanceof Error && "AbortError" === error.name) return true;
-        if ("object" == typeof error && null !== error) {
-            const maybeType = error.type;
-            const maybeMessage = error.message;
-            if ("network_error" === maybeType && "string" == typeof maybeMessage && maybeMessage.toLowerCase().includes("abort")) return true;
+            await session.initialize();
+        } catch (e) {
+            throw errors_createGitError.commandFailed("initialize", e.message);
         }
-        const message = errors_getErrorMessage(error).toLowerCase();
-        return "aborted" === message || message.includes("aborted");
+        if (null !== syncStatus) session.syncStatus = syncStatus;
+        session.hasUncommittedChanges = hasUncommittedChanges;
+        return session;
     }
-    function normalizePickerQuery(term) {
-        return (term || "").trim();
+    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
+        if (explicitUrl) return {
+            source: "explicit",
+            url: normalizeAnvilUrl(explicitUrl)
+        };
+        if (availableUrls.length > 1) return {
+            source: "available-multiple",
+            urls: availableUrls
+        };
+        if (1 === availableUrls.length) return {
+            source: "available-single",
+            url: availableUrls[0]
+        };
+        const fromConfig = getConfig("anvilUrl");
+        if ("string" == typeof fromConfig && fromConfig.trim()) return {
+            source: "config",
+            url: normalizeAnvilUrl(fromConfig.trim())
+        };
+        return {
+            source: "default",
+            url: isDevMode() ? "http://localhost:3000" : "https://anvil.works"
+        };
     }
-    function parseNonNegativeMs(raw) {
-        if (null == raw) return null;
-        const parsed = Number(raw);
-        if (!Number.isFinite(parsed) || parsed < 0) return null;
-        return parsed;
+    function decideUsernameForUrl(accounts) {
+        if (0 === accounts.length) return {
+            source: "none"
+        };
+        if (1 === accounts.length) return {
+            source: "single",
+            username: accounts[0]
+        };
+        return {
+            source: "multiple",
+            usernames: [
+                ...accounts
+            ]
+        };
     }
-    function getCheckoutPickerDelayMs() {
-        const fromEnv = parseNonNegativeMs(process.env.ANVIL_CHECKOUT_PICKER_DELAY_MS);
-        if (null != fromEnv) return fromEnv;
-        return 0;
+    async function resolveUsernameForUrl(anvilUrl, explicitUsername, promptMessage = "Multiple accounts found. Which account owns this app?") {
+        if (explicitUsername) return explicitUsername;
+        const decision = decideUsernameForUrl(auth_getAccountsForUrl(anvilUrl));
+        if ("none" === decision.source) return;
+        if ("single" === decision.source) {
+            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(decision.username));
+            return decision.username;
+        }
+        const choices = decision.usernames.map((acct)=>({
+                name: acct,
+                value: acct
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        return logger_logger.select(promptMessage, choices, decision.usernames[0]);
     }
-    function getCheckoutPickerPaginationDelayMs() {
-        return getCheckoutPickerDelayMs();
+    async function confirmReverseLookupWithResolvedUser(anvilUrl, username) {
+        const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username, `Multiple accounts found for ${anvilUrl}. Which account should be used for app lookup?`);
+        if (null === resolvedUsername) return null;
+        const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} ${resolvedUsername ? `for ${resolvedUsername}` : ""} for matching app IDs? This is slower than detecting the app ID from local git remotes.`, true);
+        return {
+            username: resolvedUsername,
+            shouldContinue
+        };
     }
-    function getCheckoutPickerMaxRows() {
-        const raw = process.env.ANVIL_CHECKOUT_PICKER_MAX_ROWS;
-        const fromEnv = null == raw ? NaN : Number(raw);
-        if (null != raw && Number.isFinite(fromEnv) && fromEnv >= 4) return Math.floor(fromEnv);
-        return 12;
+    async function resolveUrlForFallback(explicitUrl) {
+        const decision = decideFallbackUrl(explicitUrl);
+        if ("available-multiple" !== decision.source) return decision.url;
+        const choices = decision.urls.map((url)=>({
+                name: url,
+                value: url
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        const selectedUrl = await logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
+        return selectedUrl;
     }
-    function formatLastEdited(lastEdited) {
-        if (!lastEdited) return;
-        return chalk_source.gray(`Last edited: ${lastEdited}`);
+    const defaultConfigureWatchGitAuthDeps = {
+        configureCredentialHelperForUrl: configureCredentialHelperForUrl,
+        setAppAuthBinding: setAppAuthBinding
+    };
+    const defaultSyncStartDeps = {
+        pushToAnvil,
+        recreateSessionAndValidate,
+        recheckSyncStatus,
+        startWatchingWithEventHandlers
+    };
+    function resolveWatchOpenPath(repoPath) {
+        return external_path_default().resolve(repoPath);
     }
-    function formatAppPickerLabel(app) {
-        const appName = app.app_name || "Unnamed App";
-        return `${chalk_source.cyan(appName)} ${chalk_source.gray(`(${app.app_id})`)}`;
+    async function openWatchPath(targetPath, deps) {
+        const preferredEditor = String(getConfig("preferredEditor") || "").trim();
+        const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
+        await openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps);
+        logger_logger.info(chalk_source.gray(`Opened ${targetPath}`));
     }
-    async function waitForDebounce(ms, signal) {
-        if (ms <= 0) return;
-        if (signal.aborted) throw new Error("aborted");
-        await new Promise((resolve, reject)=>{
-            const timer = setTimeout(()=>{
-                cleanup();
-                resolve();
-            }, ms);
-            const onAbort = ()=>{
-                cleanup();
-                reject(new Error("aborted"));
-            };
-            const cleanup = ()=>{
-                clearTimeout(timer);
-                signal.removeEventListener("abort", onAbort);
-            };
-            signal.addEventListener("abort", onAbort, {
-                once: true
-            });
+    async function configureWatchGitAuth(options, deps = defaultConfigureWatchGitAuthDeps) {
+        await deps.configureCredentialHelperForUrl(options.repoPath, options.anvilUrl);
+        await deps.setAppAuthBinding(options.repoPath, options.appId, {
+            url: options.anvilUrl,
+            username: options.username
         });
     }
-    function createCheckoutPickerSource(anvilUrl, username, deps, options = {}) {
-        const pageSize = options.pageSize ?? 20;
-        const debounceMs = options.debounceMs ?? 200;
-        const staleTimeMs = options.staleTimeMs ?? 30000;
-        const maxAutoPagesPerCall = options.maxAutoPagesPerCall ?? 8;
-        const initialQuery = normalizePickerQuery(options.initialQuery);
-        const simulatedDelayMs = getCheckoutPickerDelayMs();
-        const paginationDelayMs = getCheckoutPickerPaginationDelayMs();
-        const cache = new Map();
-        const getState = (query)=>{
-            const existing = cache.get(query);
-            if (existing) return existing;
-            const created = {
-                items: [],
-                nextCursor: null,
-                exhausted: false,
-                lastError: null,
-                updatedAt: 0,
-                inFlight: null
+    function isStaleRemotePushError(message) {
+        const normalized = message.toLowerCase();
+        return normalized.includes("fetch first") || normalized.includes("non-fast-forward") || normalized.includes("failed to push some refs") || normalized.includes("remote contains work that you do") || normalized.includes("[rejected]");
+    }
+    async function selectAppId(candidates) {
+        if (0 === candidates.length) {
+            logger_logger.warn("Could not auto-detect app ID from repository.");
+            const rl = external_readline_namespaceObject.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const manualAppId = await new Promise((resolve)=>{
+                const handleInterrupt = ()=>{
+                    rl.close();
+                    logger_logger.warn("Operation cancelled by user.");
+                    resolve(null);
+                };
+                rl.on("SIGINT", handleInterrupt);
+                rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
+                    rl.removeListener("SIGINT", handleInterrupt);
+                    rl.close();
+                    const trimmed = answer.trim();
+                    trimmed ? resolve(trimmed) : resolve(null);
+                });
+            });
+            if (manualAppId) return {
+                appId: manualAppId,
+                source: "config",
+                description: "Manual entry"
             };
-            cache.set(query, created);
-            return created;
-        };
-        const fetchPage = async (query, signal, options = {})=>{
-            const state = getState(query);
-            if (state.inFlight) return void await state.inFlight;
-            state.inFlight = (async ()=>{
-                try {
-                    if (simulatedDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, simulatedDelayMs));
-                    if (options.cursor && paginationDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, paginationDelayMs));
-                    const response = await deps.listAppsForCheckout({
-                        anvilUrl,
-                        username,
-                        limit: pageSize,
-                        cursor: options.cursor,
-                        q: query || void 0,
-                        signal
-                    });
-                    if (options.reset) state.items = [
-                        ...response.apps
-                    ];
-                    else state.items.push(...response.apps);
-                    state.nextCursor = response.next_cursor;
-                    state.exhausted = !response.next_cursor;
-                    state.lastError = null;
-                    state.updatedAt = Date.now();
-                } catch (e) {
-                    if (!signal.aborted && !isAbortLikeError(e)) {
-                        const message = errors_getErrorMessage(e);
-                        state.lastError = message;
-                        state.updatedAt = Date.now();
-                    }
-                } finally{
-                    state.inFlight = null;
+            return null;
+        }
+        if (1 === candidates.length) {
+            const [candidate] = candidates;
+            logger_logger.success("Auto-selected detected app ID: " + chalk_source.bold(candidate.appId));
+            return candidate;
+        }
+        const choices = candidates.map((candidate, index)=>({
+                name: formatCandidateLabel(candidate),
+                value: index
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        try {
+            const answer = await logger_logger.prompt([
+                {
+                    type: "list",
+                    name: "appId",
+                    message: "Select an app ID:",
+                    choices: choices,
+                    pageSize: 10
                 }
-            })();
-            await state.inFlight;
-        };
-        const ensureLoaded = async (query, signal)=>{
-            const state = getState(query);
-            const isStale = Date.now() - state.updatedAt > staleTimeMs;
-            if (0 === state.items.length) {
-                await waitForDebounce(debounceMs, signal);
-                await fetchPage(query, signal, {
-                    cursor: void 0,
-                    reset: false
-                });
-            } else if (state.lastError) {
-                await waitForDebounce(debounceMs, signal);
-                await fetchPage(query, signal, {
-                    cursor: void 0,
-                    reset: true
-                });
-            } else if (isStale) {
-                await waitForDebounce(debounceMs, signal);
-                await fetchPage(query, signal, {
-                    cursor: void 0,
-                    reset: true
+            ]);
+            if (null === answer.appId) {
+                const rl = external_readline_namespaceObject.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
                 });
-            }
-            let pagesLoaded = 0;
-            while(state.nextCursor && pagesLoaded < maxAutoPagesPerCall){
-                if (signal.aborted) throw new Error("aborted");
-                const cursor = state.nextCursor;
-                await fetchPage(query, signal, {
-                    cursor,
-                    reset: false
+                const manualAppId = await new Promise((resolve)=>{
+                    rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
+                        rl.close();
+                        const trimmed = answer.trim();
+                        trimmed ? resolve(trimmed) : resolve(null);
+                    });
                 });
-                pagesLoaded += 1;
+                if (manualAppId) return {
+                    appId: manualAppId,
+                    source: "config",
+                    description: "Manual entry"
+                };
+                return null;
             }
-        };
-        return {
-            source: async (term, { signal })=>{
-                const query = normalizePickerQuery(term) || initialQuery;
-                if (signal.aborted) return [];
-                await ensureLoaded(query, signal);
-                const state = getState(query);
-                if (state.lastError) return [
-                    {
-                        name: `${chalk_source.yellow("Fetch failed")} ${chalk_source.gray(`(${state.lastError})`)}`,
-                        value: CHECKOUT_ERROR_VALUE,
-                        disabled: true
-                    }
-                ];
-                const summary = state.nextCursor ? chalk_source.gray(`Loaded ${state.items.length} apps • more available`) : chalk_source.gray(`Loaded ${state.items.length} apps`);
-                const choices = state.items.map((app)=>({
-                        name: formatAppPickerLabel(app),
-                        value: app.app_id,
-                        description: formatLastEdited(app.last_edited)
-                    }));
-                choices.unshift({
-                    name: summary,
-                    value: CHECKOUT_ERROR_VALUE,
-                    disabled: true
-                });
-                return choices;
-            }
-        };
+            return candidates[answer.appId];
+        } catch (error) {
+            const errorObj = error;
+            if ("ExitPromptError" === errorObj.name || errorObj.message.includes("User force closed")) logger_logger.warn("Operation cancelled by user.");
+            return null;
+        }
     }
-    const INLINE_SPINNER_FRAMES = [
-        "⠋",
-        "⠙",
-        "⠹",
-        "⠸",
-        "⠼",
-        "⠴",
-        "⠦",
-        "⠧",
-        "⠇",
-        "⠏"
-    ];
-    async function runCustomCheckoutPicker(anvilUrl, username, deps, initialQuery) {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
-        const pageSize = 20;
-        const staleTimeMs = 30000;
-        const debounceMs = 180;
-        const simulatedDelayMs = getCheckoutPickerDelayMs();
-        const paginationDelayMs = getCheckoutPickerPaginationDelayMs();
-        const maxVisibleRows = getCheckoutPickerMaxRows();
-        const cache = new Map();
-        let query = normalizePickerQuery(initialQuery);
-        let selectedIndex = 0;
-        let scrollOffset = 0;
-        let loading = false;
-        let loadingMore = false;
-        let done = false;
-        let pendingTimer = null;
-        let loadingRenderTimer = null;
-        let activeController = null;
-        let resolveResult = null;
-        const ensureState = (key)=>{
-            const existing = cache.get(key);
-            if (existing) return existing;
-            const created = {
-                items: [],
-                nextCursor: null,
-                lastError: null,
-                updatedAt: 0
+    async function pushToAnvil(options) {
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
+            const git = new GitService(options.repoPath);
+            const refSpec = `${options.branchName}:${options.branchName}`;
+            logger_logger.progress("push", "Pushing to Anvil...");
+            await git.push(pushUrl, refSpec, options.force ?? false);
+            logger_logger.progressEnd("push", "Pushed to Anvil");
+            return {
+                success: true,
+                staleRemote: false
             };
-            cache.set(key, created);
-            return created;
-        };
-        const currentState = ()=>ensureState(query);
-        const clearScreen = ()=>{
-            process.stdout.write("\x1b[2J\x1b[H");
-        };
-        const visibleRows = ()=>{
-            const rows = process.stdout.rows || 24;
-            return Math.min(maxVisibleRows, Math.max(6, rows - 9));
-        };
-        const syncViewport = ()=>{
-            const items = currentState().items;
-            if (selectedIndex >= items.length) selectedIndex = Math.max(0, items.length - 1);
-            const height = visibleRows();
-            if (selectedIndex < scrollOffset) scrollOffset = selectedIndex;
-            else if (selectedIndex >= scrollOffset + height) scrollOffset = Math.max(0, selectedIndex - height + 1);
-        };
-        const render = ()=>{
-            clearScreen();
-            const state = currentState();
-            const items = state.items;
-            const activeQuery = query || chalk_source.gray("(all apps)");
-            const spinnerFrame = INLINE_SPINNER_FRAMES[Math.floor(Date.now() / 120) % INLINE_SPINNER_FRAMES.length];
-            const status = loading ? loadingMore ? chalk_source.yellow(`${spinnerFrame} Loading more apps... (${items.length} loaded)`) : chalk_source.yellow(`${spinnerFrame} Loading apps...`) : state.nextCursor ? chalk_source.gray(`Loaded ${items.length} apps • more available`) : chalk_source.gray(`Loaded ${items.length} apps`);
-            process.stdout.write(`${chalk_source.bold("Search apps by name or app ID")}\n`);
-            process.stdout.write(`${chalk_source.cyan("Query:")} ${activeQuery}\n`);
-            process.stdout.write(`${status}\n`);
-            if (state.lastError) process.stdout.write(`${chalk_source.red(`Fetch failed: ${state.lastError}`)}\n`);
-            const height = visibleRows();
-            const start = scrollOffset;
-            const end = Math.min(items.length, start + height);
-            if (0 !== items.length || loading || state.lastError) for(let i = start; i < end; i += 1){
-                const item = items[i];
-                const label = formatAppPickerLabel(item);
-                const line = i === selectedIndex ? `${chalk_source.green("❯")} ${label}` : `  ${label}`;
-                process.stdout.write(`${line}\n`);
+        } catch (e) {
+            const errorMessage = errors_getErrorMessage(e);
+            logger_logger.progressEnd("push", "Push failed");
+            logger_logger.error(`Failed to push: ${errorMessage}`);
+            return {
+                success: false,
+                staleRemote: isStaleRemotePushError(errorMessage),
+                errorMessage
+            };
+        }
+    }
+    async function fetchAndRebaseFromAnvil(options) {
+        const git = new GitService(options.repoPath);
+        const tempRef = `anvil-rebase-temp-${Date.now()}`;
+        let didStash = false;
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
+            const hasChanges = await git.hasUncommittedChanges();
+            if (hasChanges) {
+                logger_logger.progress("rebase", "Stashing uncommitted changes...");
+                didStash = await git.stash("anvil-sync: stash before rebase");
             }
-            else process.stdout.write(`${chalk_source.gray("No matches. Keep typing.")}\n`);
-            process.stdout.write(`\n${chalk_source.gray("↑/↓ navigate • type to search • enter select • esc/ctrl+c cancel")}\n`);
-        };
-        const fetchPage = async (key, cursor)=>{
-            const state = ensureState(key);
-            const controller = new AbortController();
-            if (!cursor && activeController) activeController.abort();
-            activeController = controller;
-            loading = true;
-            loadingMore = !!cursor;
-            startLoadingAnimation();
-            render();
-            try {
-                if (simulatedDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, simulatedDelayMs));
-                if (cursor && paginationDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, paginationDelayMs));
-                const response = await deps.listAppsForCheckout({
-                    anvilUrl,
-                    username,
-                    limit: pageSize,
-                    cursor,
-                    q: key || void 0,
-                    signal: controller.signal
-                });
-                const merged = cursor ? state.items.concat(response.apps) : response.apps;
-                cache.set(key, {
-                    items: merged,
-                    nextCursor: response.next_cursor,
-                    lastError: null,
-                    updatedAt: Date.now()
-                });
-                if (key === query) syncViewport();
+            logger_logger.progressUpdate("rebase", "Fetching from Anvil...");
+            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
+            logger_logger.progressUpdate("rebase", "Rebasing...");
+            await git.rebase(tempRef);
+            logger_logger.progressUpdate("rebase", "Pushing rebased changes...");
+            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
+            await git.push(pushUrl, `${options.branchName}:${options.branchName}`, true);
+            logger_logger.progressEnd("rebase", "Rebased and pushed to Anvil");
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            if (didStash) try {
+                await git.stashPop();
+                logger_logger.verbose(chalk_source.green("Restored uncommitted changes"));
             } catch (e) {
-                if (!controller.signal.aborted && !isAbortLikeError(e)) {
-                    const message = errors_getErrorMessage(e);
-                    cache.set(key, {
-                        ...state,
-                        lastError: message,
-                        updatedAt: Date.now()
-                    });
+                logger_logger.warn("Uncommitted changes were stashed but could not be restored automatically.");
+                logger_logger.info(chalk_source.gray("   Run: git stash pop"));
+            }
+            return {
+                success: true,
+                conflicted: false
+            };
+        } catch (e) {
+            const msg = errors_getErrorMessage(e);
+            if (msg.includes("rebase") && (msg.includes("conflict") || msg.includes("CONFLICT") || msg.includes("could not apply"))) {
+                try {
+                    await git.rebaseAbort();
+                } catch  {}
+                await git.deleteRef(`refs/heads/${tempRef}`);
+                if (didStash) try {
+                    await git.stashPop();
+                } catch  {
+                    logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
                 }
-            } finally{
-                if (activeController === controller) activeController = null;
-                loading = false;
-                loadingMore = false;
-                stopLoadingAnimation();
-                render();
+                logger_logger.progressEnd("rebase", "Rebase failed - conflicts");
+                return {
+                    success: false,
+                    conflicted: true
+                };
             }
-        };
-        const ensureFresh = async (key)=>{
-            const state = ensureState(key);
-            const stale = Date.now() - state.updatedAt > staleTimeMs;
-            if (0 === state.items.length || stale || state.lastError) await fetchPage(key);
-            else render();
-        };
-        const maybeLoadMore = async ()=>{
-            const state = currentState();
-            if (!state.nextCursor || loading) return;
-            if (selectedIndex >= Math.max(0, state.items.length - 2)) await fetchPage(query, state.nextCursor || void 0);
-        };
-        const scheduleQueryFetch = ()=>{
-            if (pendingTimer) clearTimeout(pendingTimer);
-            pendingTimer = setTimeout(()=>{
-                pendingTimer = null;
-                ensureFresh(query);
-            }, debounceMs);
-        };
-        const startLoadingAnimation = ()=>{
-            if (loadingRenderTimer) return;
-            loadingRenderTimer = setInterval(()=>{
-                if (!done && loading) render();
-            }, 120);
-        };
-        const stopLoadingAnimation = ()=>{
-            if (!loadingRenderTimer) return;
-            clearInterval(loadingRenderTimer);
-            loadingRenderTimer = null;
-        };
-        const finish = (value)=>{
-            done = true;
-            if (pendingTimer) {
-                clearTimeout(pendingTimer);
-                pendingTimer = null;
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            if (didStash) try {
+                await git.stashPop();
+            } catch  {
+                logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
             }
-            if (activeController) {
-                activeController.abort();
-                activeController = null;
-            }
-            stopLoadingAnimation();
-            process.stdin.removeListener("keypress", onKeypress);
-            if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(false);
-            process.stdin.pause();
-            clearScreen();
-            if (resolveResult) resolveResult(value);
-        };
-        const onKeypress = (_str, key)=>{
-            if (done) return;
-            if (key.ctrl && "c" === key.name) return void finish(null);
-            if ("escape" === key.name) return void finish(null);
-            if ("return" === key.name) {
-                const state = currentState();
-                const selected = state.items[selectedIndex];
-                finish(selected ? selected.app_id : null);
-                return;
-            }
-            if ("up" === key.name) {
-                if (selectedIndex > 0) {
-                    selectedIndex -= 1;
-                    syncViewport();
-                    render();
-                }
-                return;
-            }
-            if ("down" === key.name) {
-                const maxIndex = Math.max(0, currentState().items.length - 1);
-                if (selectedIndex < maxIndex) {
-                    selectedIndex += 1;
-                    syncViewport();
-                    render();
-                    maybeLoadMore();
-                }
-                return;
-            }
-            if ("backspace" === key.name || "delete" === key.name) {
-                if (query.length > 0) {
-                    query = query.slice(0, -1);
-                    selectedIndex = 0;
-                    scrollOffset = 0;
-                    render();
-                    scheduleQueryFetch();
-                }
-                return;
-            }
-            if (!key.ctrl && !key.meta && key.sequence && 1 === key.sequence.length && key.sequence >= " ") {
-                query += key.sequence;
-                selectedIndex = 0;
-                scrollOffset = 0;
-                render();
-                scheduleQueryFetch();
-            }
-        };
-        logger_logger.pause();
-        try {
-            external_readline_default().emitKeypressEvents(process.stdin);
-            if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(true);
-            process.stdin.resume();
-            process.stdin.on("keypress", onKeypress);
-            await ensureFresh(query);
-            return await new Promise((resolve)=>{
-                resolveResult = resolve;
-            });
-        } finally{
-            logger_logger.resume();
+            logger_logger.progressEnd("rebase", "Rebase failed");
+            logger_logger.error(`Failed to rebase: ${msg}`);
+            return {
+                success: false,
+                conflicted: false
+            };
         }
     }
-    async function selectAppForCheckout(anvilUrl, username, deps, initialQuery) {
-        if (!isTestMode() && "1" !== process.env.ANVIL_CHECKOUT_LEGACY_PICKER) return runCustomCheckoutPicker(anvilUrl, username, deps, initialQuery);
-        const picker = createCheckoutPickerSource(anvilUrl, username, deps, {
-            initialQuery
-        });
+    async function fetchAndHardResetFromAnvil(options) {
+        const git = new GitService(options.repoPath);
+        const tempRef = `anvil-reset-temp-${Date.now()}`;
         try {
-            const answer = await logger_logger.prompt([
-                {
-                    type: "search",
-                    name: "value",
-                    message: "Search apps by name or app ID",
-                    source: picker.source,
-                    pageSize: 12,
-                    loop: false,
-                    instructions: {
-                        navigation: "↑↓ navigate • type to filter",
-                        pager: "enter select • ctrl+c cancel"
-                    }
-                }
-            ]);
-            const selected = String(answer.value || "");
-            if (!selected || selected === CHECKOUT_ERROR_VALUE) return null;
-            return selected;
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
+            logger_logger.progress("reset", "Fetching from Anvil...");
+            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
+            logger_logger.progressUpdate("reset", "Resetting to Anvil's version...");
+            await git.reset(tempRef, "hard");
+            logger_logger.progressEnd("reset", "Reset to Anvil's version");
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            return true;
         } catch (e) {
-            const err = e;
-            if ("ExitPromptError" === err.name || String(err.message || "").includes("User force closed")) return null;
-            throw e;
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            logger_logger.progressEnd("reset", "Reset failed");
+            logger_logger.error(`Failed to reset: ${errors_getErrorMessage(e)}`);
+            return false;
         }
     }
-    const defaultCheckoutDeps = {
-        getValidAuthToken: auth_getValidAuthToken,
-        validateAppId: validateAppId,
-        listAppsForCheckout: listAppsForCheckout,
-        runInteractiveLoginFlow: runInteractiveLoginFlow,
-        clone: async (repoUrl, destinationPath, options)=>{
-            const cloneArgs = [];
-            if (options?.branch) cloneArgs.push("--branch", options.branch);
-            if ("number" == typeof options?.depth) cloneArgs.push("--depth", String(options.depth));
-            if (options?.singleBranch) cloneArgs.push("--single-branch");
-            if (options?.origin) cloneArgs.push("--origin", options.origin);
-            if (options?.quiet) cloneArgs.push("--quiet");
-            if (options?.verbose) cloneArgs.push("--verbose");
-            await esm_default().clone(repoUrl, destinationPath, cloneArgs);
-        },
-        hardenCheckoutGitAuth: hardenCheckoutGitAuth
-    };
-    function isInteractiveSession() {
-        return !!(process.stdin.isTTY && process.stdout.isTTY);
+    function getSyncStateCategory(syncStatus) {
+        if (syncStatus?.branchMissing) return "branch-missing";
+        if (syncStatus?.diverged) return "diverged";
+        if (syncStatus?.ahead && !syncStatus?.behind) return "ahead";
+        if (syncStatus?.behind && !syncStatus?.ahead) return "behind";
+        if (syncStatus?.ahead && syncStatus?.behind) return "diverged";
+        return "in-sync";
     }
-    function parseCheckoutInput(input) {
-        const trimmed = input.trim();
-        if (!trimmed) throw new Error("Input is required.");
-        if (/^[A-Z0-9]+$/.test(trimmed)) return {
-            appId: trimmed
-        };
-        const asUrl = /^https?:\/\//.test(trimmed) ? trimmed : normalizeAnvilUrl(trimmed);
-        let parsed;
+    async function recheckSyncStatus(previousCategory, previousBranch, options) {
         try {
-            parsed = new URL(asUrl);
-        } catch  {
-            throw new Error("Input must be an editor URL, /git URL, or bare app ID.");
-        }
-        const gitMatch = parsed.pathname.match(/\/git\/([A-Z0-9]+)\.git(?:$|\/)/);
-        if (gitMatch) return {
-            appId: gitMatch[1],
-            detectedUrl: `${parsed.protocol}//${parsed.host}`
-        };
-        const appsMatch = parsed.pathname.match(/\/apps\/([A-Z0-9]+)(?:\/|$)/);
-        if (appsMatch) return {
-            appId: appsMatch[1],
-            detectedUrl: `${parsed.protocol}//${parsed.host}`
-        };
-        throw new Error("Could not extract app ID. Expected URL path containing /apps/<APPID> or /git/<APPID>.git.");
-    }
-    function sanitizeDirectoryName(name) {
-        return name.trim().replace(/\s+/g, "_").replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
-    }
-    function formatPathForDisplay(destinationPath) {
-        const relative = external_path_default().relative(process.cwd(), destinationPath);
-        if ("" === relative) return ".";
-        if (relative.startsWith("..")) return destinationPath;
-        return relative.startsWith(".") ? relative : `./${relative}`;
-    }
-    function getDefaultDestinationDirectory(appId, appName) {
-        if (appName) {
-            const sanitized = sanitizeDirectoryName(appName);
-            if (sanitized) return sanitized;
-        }
-        return appId;
-    }
-    async function resolveCheckoutUrl(explicitUrl, parsedUrl) {
-        if (explicitUrl) {
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from --url: ") + chalk_source.bold(normalizeAnvilUrl(explicitUrl)));
-            return normalizeAnvilUrl(explicitUrl);
-        }
-        if (parsedUrl) {
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from checkout input: ") + chalk_source.bold(normalizeAnvilUrl(parsedUrl)));
-            return normalizeAnvilUrl(parsedUrl);
-        }
-        const decision = decideFallbackUrl(void 0);
-        if ("available-multiple" !== decision.source) {
-            if (decision.url) logger_logger.verbose(chalk_source.cyan("Using configured Anvil URL: ") + chalk_source.bold(decision.url));
-            return decision.url;
+            logger_logger.progress("verify", "Verifying repository status...");
+            const freshSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            logger_logger.progressEnd("verify");
+            const currentCategory = getSyncStateCategory(freshSession.syncStatus);
+            const currentBranch = freshSession.getBranchName() || "master";
+            if (currentCategory !== previousCategory || currentBranch !== previousBranch) {
+                logger_logger.warn("Repository status has changed. Re-evaluating...");
+                return freshSession;
+            }
+            freshSession.cleanup();
+            return null;
+        } catch (e) {
+            logger_logger.progressEnd("verify");
+            logger_logger.verbose(chalk_source.gray(`Could not re-verify status: ${errors_getErrorMessage(e)}`));
+            return null;
         }
-        const choices = decision.urls.map((url)=>({
-                name: url,
-                value: url
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        return logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
     }
-    async function isPathInsideGitRepo(targetPath) {
-        const resolved = external_path_default().resolve(targetPath);
-        let current = resolved;
-        while(!external_fs_.existsSync(current)){
-            const parent = external_path_default().dirname(current);
-            if (parent === current) return false;
-            current = parent;
-        }
+    async function recreateSessionAndValidate(options) {
+        logger_logger.progress("init", "Restarting watch session...");
         try {
-            const output = (await esm_default(current).raw([
-                "rev-parse",
-                "--is-inside-work-tree"
-            ])).trim();
-            return "true" === output;
-        } catch  {
+            const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            logger_logger.progressEnd("init");
+            return await checkSyncStatusAndStart(newSession, options);
+        } catch (e) {
+            logger_logger.progressEnd("init", "Failed");
+            logger_logger.error(`Failed to restart: ${errors_getErrorMessage(e)}`);
             return false;
         }
     }
-    async function isDirectoryNonEmpty(destinationPath) {
-        if (!external_fs_.existsSync(destinationPath)) return false;
-        const stats = await external_fs_.promises.stat(destinationPath);
-        if (!stats.isDirectory()) return true;
-        const entries = await external_fs_.promises.readdir(destinationPath);
-        return entries.length > 0;
-    }
-    async function validateCheckoutDestination(destinationPath, force = false) {
-        const nonEmpty = await isDirectoryNonEmpty(destinationPath);
-        if (nonEmpty && !force) throw new Error(`Destination '${destinationPath}' already exists and is not empty.`);
-        const insideGit = await isPathInsideGitRepo(destinationPath);
-        if (insideGit && !force) throw new Error(`Destination '${destinationPath}' is inside an existing Git repository.`);
-        if (force && nonEmpty) logger_logger.warn(`--force set: destination '${destinationPath}' is non-empty and clone may still fail.`);
-        if (force && insideGit) logger_logger.warn("--force set: cloning inside an existing Git repository.");
-    }
-    async function ensureCheckoutAuthToken(anvilUrl, username, deps = defaultCheckoutDeps) {
-        try {
-            logger_logger.verbose(chalk_source.cyan("Checking auth token for: ") + chalk_source.bold(username ? `${username} @ ${anvilUrl}` : anvilUrl));
-            return await deps.getValidAuthToken(anvilUrl, username);
-        } catch (e) {
-            const interactive = process.stdin.isTTY && process.stdout.isTTY;
-            if (!interactive) throw errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
-            const shouldLogin = await logger_logger.confirm(`Not logged in to ${anvilUrl}. Log in now?`, true);
-            if (!shouldLogin) throw errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
-            await deps.runInteractiveLoginFlow(anvilUrl);
-            return deps.getValidAuthToken(anvilUrl, username);
+    async function checkSyncStatusAndStart(session, options, deps = defaultSyncStartDeps) {
+        const syncStatus = session.syncStatus;
+        const branchName = session.getBranchName() || "master";
+        const hasUncommitted = session.hasUncommittedChanges;
+        const stateCategory = getSyncStateCategory(syncStatus);
+        if (syncStatus?.branchMissing) {
+            logger_logger.warn(`Branch '${branchName}' doesn't exist on Anvil yet.`);
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldPush = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing new branch to Anvil..."));
+            else {
+                shouldPush = await logger_logger.confirm("Would you like to push this branch to Anvil?", true);
+                if (shouldPush) {
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
+                }
+            }
+            if (!shouldPush) {
+                logger_logger.warn("Watch cancelled. Push your branch to Anvil, then try again.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            const pushed = await deps.pushToAnvil({
+                repoPath: options.repoPath,
+                appId: options.appId,
+                anvilUrl: options.anvilUrl,
+                branchName,
+                username: options.username
+            });
+            if (!pushed.success) {
+                if (pushed.staleRemote) {
+                    logger_logger.warn("Branch appeared on Anvil while pushing. Re-checking sync status...");
+                    return await deps.recreateSessionAndValidate(options);
+                }
+                return false;
+            }
+            return await deps.recreateSessionAndValidate(options);
         }
-    }
-    async function resolveCheckoutUsername(anvilUrl, explicitUsername, getAccounts = auth_getAccountsForUrl) {
-        if (explicitUsername) return explicitUsername;
-        const accounts = getAccounts(anvilUrl);
-        if (0 === accounts.length) return;
-        if (1 === accounts.length) {
-            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(accounts[0]));
-            return accounts[0];
+        if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
+            logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldPush = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing to Anvil..."));
+            else {
+                const action = await logger_logger.select("What would you like to do?", [
+                    {
+                        name: "Push your changes to Anvil (recommended)",
+                        value: "push"
+                    },
+                    {
+                        name: "Exit and handle manually",
+                        value: "exit"
+                    }
+                ], "push");
+                shouldPush = "push" === action;
+                if (shouldPush) {
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
+                }
+            }
+            if (!shouldPush) {
+                logger_logger.warn("Watch cancelled.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            const pushed = await deps.pushToAnvil({
+                repoPath: options.repoPath,
+                appId: options.appId,
+                anvilUrl: options.anvilUrl,
+                branchName,
+                username: options.username
+            });
+            if (!pushed.success) return false;
+            return await deps.recreateSessionAndValidate(options);
+        } else if (syncStatus.diverged) {
+            logger_logger.warn("Your local repository has diverged from Anvil.");
+            logger_logger.info(chalk_source.gray(`   You are ${syncStatus.ahead} commit(s) ahead and ${syncStatus.behind} commit(s) behind.`));
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            session.cleanup();
+            if (options.autoMode) {
+                logger_logger.info(chalk_source.cyan("→ Auto-rebasing onto Anvil's version..."));
+                const result = await fetchAndRebaseFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (result.conflicted) {
+                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
+                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
+                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
+                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
+                    return false;
+                }
+                if (!result.success) return false;
+                return await deps.recreateSessionAndValidate(options);
+            }
+            const action = await logger_logger.select("How would you like to resolve this?", [
+                {
+                    name: "Pull from Anvil and rebase your changes on top (recommended)",
+                    value: "rebase"
+                },
+                {
+                    name: "Discard your local commits and use Anvil's version",
+                    value: "reset"
+                },
+                {
+                    name: "Push your version to Anvil (overwrites remote)",
+                    value: "push"
+                },
+                {
+                    name: "Exit and handle manually",
+                    value: "exit"
+                }
+            ], "rebase");
+            if ("exit" === action) {
+                logger_logger.warn("Watch cancelled.");
+                return false;
+            }
+            const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+            if (changed) return await checkSyncStatusAndStart(changed, options, deps);
+            if ("rebase" === action) {
+                const result = await fetchAndRebaseFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (result.conflicted) {
+                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
+                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
+                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
+                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
+                    return false;
+                }
+                if (!result.success) return false;
+                return await deps.recreateSessionAndValidate(options);
+            }
+            if ("reset" === action) {
+                const resetWarning = hasUncommitted ? `This will discard ${syncStatus.ahead} local commit(s) and your uncommitted changes. Are you sure?` : `This will discard ${syncStatus.ahead} local commit(s). Are you sure?`;
+                const confirmed = await logger_logger.confirm(resetWarning, false);
+                if (!confirmed) {
+                    logger_logger.warn("Watch cancelled.");
+                    return false;
+                }
+                const reset = await fetchAndHardResetFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (!reset) return false;
+                return await deps.recreateSessionAndValidate(options);
+            }
+            if ("push" === action) {
+                const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
+                if (!confirmed) {
+                    logger_logger.warn("Watch cancelled.");
+                    return false;
+                }
+                const pushed = await deps.pushToAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username,
+                    force: true
+                });
+                if (!pushed.success) return false;
+                return await deps.recreateSessionAndValidate(options);
+            }
+        } else {
+            logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
+            logger_logger.verbose(chalk_source.gray("   You need to sync to the latest version before watching."));
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldSync = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-syncing to latest version..."));
+            else {
+                shouldSync = await logger_logger.confirm("Would you like to sync to the latest version from Anvil now?", true);
+                if (shouldSync) {
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
+                }
+            }
+            if (!shouldSync) {
+                logger_logger.warn("Watch cancelled. Please sync manually before watching.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            let authToken;
+            try {
+                authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            } catch (e) {
+                logger_logger.error("Not logged in. Please log in first.");
+                process.exit(1);
+            }
+            logger_logger.progress("sync-latest", "Syncing to latest version from Anvil...");
+            try {
+                const newCommitId = await syncToLatest(options.repoPath, options.appId, options.anvilUrl, authToken, branchName, options.username);
+                logger_logger.progressEnd("sync-latest", `Synced to latest version: ${newCommitId.substring(0, 8)}`);
+            } catch (e) {
+                logger_logger.progressEnd("sync-latest", "Failed");
+                logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
+                process.exit(1);
+            }
+            return await deps.recreateSessionAndValidate(options);
         }
-        const interactive = process.stdin.isTTY && process.stdout.isTTY;
-        if (!interactive) throw new Error(`Multiple accounts found for ${anvilUrl}. Use --user <USERNAME> to choose one.`);
-        const choices = accounts.map((acct)=>({
-                name: acct,
-                value: acct
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        return logger_logger.select(`Multiple accounts found for ${anvilUrl}. Which account should be used for checkout?`, choices, accounts[0]);
+        await deps.startWatchingWithEventHandlers(session, options);
+        return true;
     }
-    async function executeCheckout(options, deps = defaultCheckoutDeps) {
-        let checkoutInput = options.input?.trim();
-        let preselectedAnvilUrl;
-        let preselectedUsername;
-        if (!checkoutInput) {
-            if (!isInteractiveSession()) throw new Error("`anvil checkout` without arguments requires an interactive TTY. Pass APP_ID or URL explicitly in non-interactive mode.");
-            const selectedUrl = await resolveCheckoutUrl(options.url);
-            if (!selectedUrl) return void logger_logger.info("Checkout cancelled.");
-            preselectedAnvilUrl = selectedUrl;
-            const selectedUsername = await resolveCheckoutUsername(selectedUrl, options.user);
-            if (null === selectedUsername) return void logger_logger.info("Checkout cancelled.");
-            preselectedUsername = selectedUsername || void 0;
-            const selectedInput = await selectAppForCheckout(selectedUrl, preselectedUsername, deps, options.query);
-            if (!selectedInput) return void logger_logger.info("Checkout cancelled.");
-            checkoutInput = selectedInput;
-        }
-        logger_logger.verbose(chalk_source.cyan("Checkout input: ") + chalk_source.bold(checkoutInput));
-        const parsed = parseCheckoutInput(checkoutInput);
-        logger_logger.verbose(chalk_source.cyan("Resolved app ID: ") + chalk_source.bold(parsed.appId));
-        const anvilUrl = preselectedAnvilUrl || await resolveCheckoutUrl(options.url, parsed.detectedUrl);
-        if (!anvilUrl) return void logger_logger.info("Checkout cancelled.");
-        const resolvedUsername = preselectedUsername || await resolveCheckoutUsername(anvilUrl, options.user);
-        if (null === resolvedUsername) return void logger_logger.info("Checkout cancelled.");
-        if (resolvedUsername) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(resolvedUsername));
-        else logger_logger.verbose(chalk_source.cyan("No account preselected; resolving after auth token lookup."));
-        const authToken = await ensureCheckoutAuthToken(anvilUrl, resolvedUsername, deps);
-        let checkoutUsername = resolvedUsername;
-        if (!checkoutUsername) {
-            const inferredUsername = await resolveCheckoutUsername(anvilUrl, void 0);
-            if (null === inferredUsername) return void logger_logger.info("Checkout cancelled.");
-            if (!inferredUsername) throw new Error(`Could not determine account for ${anvilUrl}. Use --user <USERNAME> so checkout can bind repository credentials.`);
-            checkoutUsername = inferredUsername;
-        }
-        logger_logger.verbose(chalk_source.cyan("Checkout account: ") + chalk_source.bold(checkoutUsername));
-        logger_logger.verbose(chalk_source.blue(`Validating app ID ${parsed.appId} with Anvil server...`));
-        const validation = await deps.validateAppId(parsed.appId, anvilUrl, checkoutUsername);
-        if (!validation.valid) throw new Error(validation.error || `App '${parsed.appId}' is not accessible on ${anvilUrl}.`);
-        logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
-        if (validation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${validation.app_name}`));
-        const destinationDir = options.directory || getDefaultDestinationDirectory(parsed.appId, validation.app_name);
-        const destinationPath = external_path_default().resolve(process.cwd(), destinationDir);
-        const destinationDisplay = formatPathForDisplay(destinationPath);
-        logger_logger.verbose(chalk_source.cyan("Resolved destination: ") + chalk_source.bold(destinationDisplay));
-        await validateCheckoutDestination(destinationPath, options.force);
-        const cloneUrl = getGitPushUrl(parsed.appId, authToken, anvilUrl);
-        logger_logger.verbose(chalk_source.cyan("Clone source: ") + chalk_source.bold(`${anvilUrl}/git/${parsed.appId}.git`));
-        if (options.branch) logger_logger.verbose(chalk_source.cyan("Requested branch: ") + chalk_source.bold(options.branch));
-        if ("number" == typeof options.depth) logger_logger.verbose(chalk_source.cyan("Clone depth: ") + chalk_source.bold(String(options.depth)));
-        if (options.singleBranch) logger_logger.verbose(chalk_source.cyan("Single-branch clone enabled"));
-        logger_logger.progress("checkout", `Checking out app ${parsed.appId} from ${anvilUrl}`);
-        logger_logger.info(chalk_source.gray(`   Destination directory: ${destinationDisplay}`));
-        await deps.clone(cloneUrl, destinationPath, {
-            branch: options.branch,
-            depth: options.depth,
-            singleBranch: options.singleBranch,
-            origin: options.origin,
-            quiet: options.quiet,
-            verbose: options.verbose
+    async function startWatchingWithEventHandlers(session, options) {
+        const { autoMode, repoPath, appId, anvilUrl, stagedOnly } = options;
+        session.on("branch-changed", async ({ oldBranch, newBranch })=>{
+            try {
+                session.cleanup();
+                logger_logger.warn(`Branch changed: ${chalk_source.bold(oldBranch)} → ${chalk_source.bold(newBranch)}`);
+                logger_logger.info(chalk_source.cyan("→ Restarting watch on new branch..."));
+                const git = esm_default(repoPath);
+                const actualBranch = (await git.revparse([
+                    "--abbrev-ref",
+                    "HEAD"
+                ])).trim();
+                if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed again to ${chalk_source.bold(actualBranch)}, using that instead`));
+                logger_logger.progress("init", "Initializing watch session...");
+                try {
+                    const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
+                    logger_logger.progressEnd("init");
+                    const started = await checkSyncStatusAndStart(newSession, options);
+                    if (!started) process.exit(0);
+                } catch (e) {
+                    logger_logger.progressEnd("init", "Failed");
+                    logger_logger.error("Failed to restart watch: " + errors_getErrorMessage(e));
+                    process.exit(1);
+                }
+            } catch (error) {
+                logger_logger.error(`Error handling branch change: ${error.message}`);
+                process.exit(1);
+            }
+        });
+        session.on("validation-failed", ({ reason, currentBranch })=>{
+            logger_logger.error(chalk_source.red(`Validation failed: ${reason}`));
+            logger_logger.verbose(chalk_source.yellow(`   Current branch: ${currentBranch}`));
+            logger_logger.verbose(chalk_source.yellow("   Please restart anvil to re-validate the branch."));
+            session.cleanup();
+            process.exit(1);
+        });
+        session.on("max-retries-exceeded", async ()=>{
+            if (autoMode) {
+                logger_logger.info(chalk_source.cyan("→ Auto-restarting watch session..."));
+                session.cleanup();
+                const restarted = await recreateSessionAndValidate(options);
+                if (!restarted) process.exit(1);
+            } else {
+                const shouldRestart = await logger_logger.confirm("Would you like to restart the watch session?", true);
+                if (shouldRestart) {
+                    session.cleanup();
+                    const restarted = await recreateSessionAndValidate(options);
+                    if (!restarted) process.exit(1);
+                }
+            }
         });
-        const remoteName = options.origin || "origin";
+        if (session.hasUncommittedChanges) {
+            if (!autoMode) {
+                const shouldContinue = await logger_logger.confirm("Continue? Your uncommitted changes will be synced to Anvil.", true);
+                if (!shouldContinue) {
+                    logger_logger.warn("Watch cancelled. Commit, stash, or discard your changes, then try again.");
+                    session.cleanup();
+                    process.exit(0);
+                }
+            }
+            logger_logger.progress("save", "Saving uncommitted changes to Anvil...");
+            try {
+                await session.forceSave();
+                logger_logger.progressEnd("save");
+            } catch (e) {
+                logger_logger.progressEnd("save", "Failed");
+                logger_logger.error(`Failed to save: ${errors_getErrorMessage(e)}`);
+            }
+        }
+        await session.startWatching();
+    }
+    async function handleWatchCommand(options) {
+        const invoked = process.argv[2];
+        if ("sync" === invoked) {
+            logger_logger.error("'sync' has been renamed to 'watch'. Please use 'anvil watch' instead.");
+            process.exit(1);
+        }
+        const { path: repoPath = process.cwd(), appid: explicitAppId, useFirst = false, stagedOnly = false, autoMode = false, url: explicitUrl, user: explicitUsername, open: openAfterValidation = false } = options;
         try {
-            await deps.hardenCheckoutGitAuth({
-                repoPath: destinationPath,
-                appId: parsed.appId,
+            const validationResult = await validateAnvilApp(repoPath);
+            if (validationResult.appName) logger_logger.info(chalk_source.green("Anvil app: ") + chalk_source.bold(validationResult.appName));
+            const detectedFromAllRemotes = await detectAppIdsFromAllRemotes(repoPath);
+            let filteredCandidates = filterCandidates(detectedFromAllRemotes, explicitUrl, explicitUsername);
+            logger_logger.verbose(chalk_source.cyan(`Detected ${detectedFromAllRemotes.length} app ID(s) from git remotes`));
+            if (filteredCandidates.length !== detectedFromAllRemotes.length) logger_logger.verbose(chalk_source.cyan(`After filtering: ${filteredCandidates.length} candidate(s)`));
+            let finalAppId;
+            let anvilUrl;
+            let username = explicitUsername;
+            let fallbackUrl;
+            let shouldPersistUsernameBinding = false;
+            if (explicitAppId) {
+                finalAppId = explicitAppId;
+                const binding = await getAppAuthBinding(repoPath, explicitAppId);
+                if (binding.url && !explicitUrl) {
+                    anvilUrl = normalizeAnvilUrl(binding.url);
+                    logger_logger.verbose(chalk_source.cyan("Resolved URL from binding for app ID: ") + chalk_source.bold(anvilUrl));
+                }
+                if (binding.username && !explicitUsername) {
+                    username = binding.username;
+                    logger_logger.verbose(chalk_source.cyan("Resolved username from binding for app ID: ") + chalk_source.bold(username));
+                }
+                const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
+                if (remoteInfo.detectedUrl && !explicitUrl && !anvilUrl) {
+                    anvilUrl = normalizeAnvilUrl(remoteInfo.detectedUrl);
+                    logger_logger.verbose(chalk_source.cyan("Resolved URL from remote for app ID: ") + chalk_source.bold(anvilUrl));
+                }
+                if (remoteInfo.detectedUsername && !explicitUsername && !username) {
+                    username = remoteInfo.detectedUsername;
+                    logger_logger.verbose(chalk_source.cyan("Resolved username from remote for app ID: ") + chalk_source.bold(username));
+                }
+            } else {
+                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
+                if (0 === filteredCandidates.length) {
+                    logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
+                    const resolvedFallbackUrl = await resolveUrlForFallback(explicitUrl);
+                    if (null === resolvedFallbackUrl) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    fallbackUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+                    const lookupDecision = await confirmReverseLookupWithResolvedUser(fallbackUrl, username);
+                    if (null === lookupDecision) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    username = lookupDecision.username;
+                    if (lookupDecision.shouldContinue) {
+                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${username ? `for ${username}` : ""} for matching app IDs...`);
+                        const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
+                            anvilUrl: fallbackUrl,
+                            username,
+                            includeRemotes: false
+                        });
+                        logger_logger.progressEnd("detect");
+                        for (const c of reverseLookupCandidates)filteredCandidates.push({
+                            ...c,
+                            detectedUrl: fallbackUrl
+                        });
+                    }
+                }
+                if (filteredCandidates.length > 0) {
+                    for (const c of filteredCandidates)logger_logger.verbose(chalk_source.gray(`   Found: ${formatCandidateLabel(c)}`));
+                    if (filteredCandidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${filteredCandidates.length} potential app IDs`));
+                }
+                if (useFirst && filteredCandidates.length > 0) {
+                    const selected = filteredCandidates[0];
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
+                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
+                } else {
+                    const selected = await selectAppId(filteredCandidates);
+                    if (!selected) {
+                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
+                        process.exit(1);
+                    }
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
+                }
+            }
+            const binding = await getAppAuthBinding(repoPath, finalAppId);
+            if (binding.url && !explicitUrl) {
+                anvilUrl = normalizeAnvilUrl(binding.url);
+                logger_logger.verbose(chalk_source.cyan("Using app binding URL: ") + chalk_source.bold(anvilUrl));
+            }
+            if (binding.username && !explicitUsername) {
+                username = binding.username;
+                logger_logger.verbose(chalk_source.cyan("Using app binding username: ") + chalk_source.bold(username));
+            }
+            shouldPersistUsernameBinding = !binding.username && !explicitUsername;
+            if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
+            else if (!anvilUrl) if (fallbackUrl) anvilUrl = fallbackUrl;
+            else {
+                const resolvedFallbackUrl = await resolveUrlForFallback();
+                if (null === resolvedFallbackUrl) {
+                    logger_logger.warn("Operation cancelled.");
+                    process.exit(0);
+                }
+                anvilUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+            }
+            anvilUrl = normalizeAnvilUrl(anvilUrl);
+            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
+            const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username);
+            if (null === resolvedUsername) {
+                logger_logger.warn("Operation cancelled.");
+                process.exit(0);
+            }
+            username = resolvedUsername;
+            if (shouldPersistUsernameBinding && username && auth_getAccountsForUrl(anvilUrl).length > 1) {
+                await setAppAuthBinding(repoPath, finalAppId, {
+                    url: anvilUrl,
+                    username
+                });
+                logger_logger.verbose(chalk_source.cyan("Saved app account binding for future non-interactive use."));
+            }
+            if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
+            if (!hasTokensForUrl(anvilUrl, username)) {
+                if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
+                else logger_logger.error(`Not logged in to ${anvilUrl}`);
+                logger_logger.verbose(chalk_source.yellow("Please log in first:"));
+                logger_logger.info(chalk_source.cyan(`   anvil login ${anvilUrl.replace(/^https?:\/\//, "")}`));
+                process.exit(1);
+            }
+            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
+            await configureWatchGitAuth({
+                repoPath,
+                appId: finalAppId,
                 anvilUrl,
-                username: checkoutUsername,
-                remoteName
+                username
             });
-            logger_logger.verbose(chalk_source.cyan("Configured Git auth bridge for remote: ") + chalk_source.bold(remoteName));
+            logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
+            const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
+            logger_logger.progressEnd("validate");
+            if (!appIdValidation.valid) {
+                logger_logger.error(`App ID validation failed: ${appIdValidation.error}`);
+                logger_logger.verbose(chalk_source.yellow("This could mean:"));
+                logger_logger.verbose(chalk_source.yellow("  • The app ID doesn't exist on the server"));
+                logger_logger.verbose(chalk_source.yellow("  • You don't have access to this app"));
+                logger_logger.verbose(chalk_source.yellow("  • There's a network or authentication issue"));
+                process.exit(1);
+            }
+            logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
+            if (appIdValidation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${appIdValidation.app_name}`));
+            if (stagedOnly) logger_logger.info(chalk_source.yellow("▸ Staged-only mode: Only staged changes will be synced"));
+            if (autoMode) logger_logger.info(chalk_source.cyan("▸ Auto mode: Will automatically restart on branch changes and sync when behind"));
+            logger_logger.progress("init", "Initializing watch session...");
+            const session = await api_watch(repoPath, finalAppId, anvilUrl, stagedOnly, username);
+            logger_logger.progressEnd("init");
+            if (openAfterValidation) await openWatchPath(resolveWatchOpenPath(repoPath));
+            logger_logger.verbose(chalk_source.blue("Watching for file changes..."));
+            const started = await checkSyncStatusAndStart(session, {
+                autoMode,
+                repoPath,
+                appId: finalAppId,
+                anvilUrl,
+                stagedOnly,
+                username
+            });
+            if (!started) process.exit(1);
         } catch (e) {
-            throw new Error(`Checkout clone succeeded, but failed to configure repository credentials: ${errors_getErrorMessage(e)}. The repository exists at ${destinationDisplay}, but Git auth bridge setup is incomplete.`);
-        }
-        logger_logger.progressEnd("checkout", `Checked out ${parsed.appId} into ${destinationDisplay}`);
-        const preferredEditor = String(getConfig("preferredEditor") || "").trim();
-        const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
-        if (options.open) {
-            await checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand);
-            logger_logger.info(chalk_source.gray(`Opened ${destinationDisplay}`));
+            logger_logger.error("Error: " + errors_getErrorMessage(e));
+            process.exit(1);
         }
-        if (preferredEditorCommand && !options.open) if (isCommandAvailable(preferredEditorCommand)) logger_logger.info(chalk_source.cyan(`Next: ${preferredEditorCommand} ${destinationDisplay}`));
-        else logger_logger.warn(`Preferred editor command '${preferredEditorCommand}' was not found in PATH. Run 'anvil configure' to choose an installed editor.`);
     }
-    async function checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps) {
-        await openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps);
-    }
-    function registerCheckoutCommand(program) {
-        const checkoutCommand = program.command("checkout [input] [directory]").description("Check out an Anvil app locally from editor URL, git URL, app ID, or interactive selection").alias("co").option("-O, --open", "Open destination after checkout").option("-b, --branch <BRANCH>", "Checkout a specific branch").option("--depth <N>", "Create a shallow clone with history truncated to N commits", (value)=>parseInt(value, 10)).option("--single-branch", "Clone only one branch").option("--origin <NAME>", "Use a custom remote name instead of origin").option("--quiet", "Suppress git clone progress output").option("--verbose", "Enable verbose git clone output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL").option("-U, --user <USERNAME>", "Specify which user account to use").option("-f, --force", "Override safety checks for destination path").option("-Q, --query <QUERY>", "Initial search query for interactive checkout picker").action(async (input, directory, options, command)=>{
-            try {
-                const globalOptions = command?.optsWithGlobals() || options || {};
-                if ("number" == typeof options?.depth && (!Number.isFinite(options.depth) || options.depth <= 0)) throw new Error("--depth must be a positive integer");
-                await executeCheckout({
-                    input,
-                    directory,
-                    open: options?.open,
-                    branch: options?.branch,
-                    depth: options?.depth,
-                    singleBranch: options?.singleBranch,
-                    origin: options?.origin,
-                    quiet: options?.quiet,
-                    verbose: globalOptions.verbose,
-                    url: options?.url,
-                    user: options?.user,
-                    force: options?.force,
-                    query: options?.query
-                }, defaultCheckoutDeps);
-            } catch (e) {
-                logger_logger.error("Error: " + errors_getErrorMessage(e));
-                process.exit(1);
-            }
+    function registerWatchCommand(program) {
+        const watchCommand = program.command("watch [path]").description("Watch for file changes and sync to Anvil").alias("sync").alias("w").option("-A, --appid <APP_ID>", "Specify app ID directly").option("-f, --first", "Auto-select first detected app ID without confirmation").option("-s, --staged-only", "Only sync staged changes (use git add to stage files)").option("-a, --auto", "Auto mode: restart on branch changes and sync when behind").option("-O, --open", "Open watched path in preferred editor (or default app)").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL (e.g., anvil.works, localhost)").option("-U, --user <USERNAME>", "Specify which user account to use").action(async (path, options, command)=>{
+            const globalOptions = command.optsWithGlobals();
+            if (void 0 !== globalOptions.verbose && logger_logger instanceof CLILogger) logger_logger.setVerbose(globalOptions.verbose);
+            await handleWatchCommand({
+                path,
+                appid: options.appid,
+                useFirst: options.first,
+                stagedOnly: options.stagedOnly,
+                autoMode: options.auto,
+                verbose: globalOptions.verbose,
+                open: options.open,
+                url: options.url,
+                user: options.user
+            });
         });
-        checkoutCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + '\n  anvil checkout http://localhost:3000/build/apps/APPID/code/assets/theme.css\n  anvil checkout https://anvil.works/git/APPID.git\n  anvil checkout APPID --url anvil.works\n  anvil checkout APPID --branch master --depth 1 --single-branch\n  anvil checkout APPID -O  # open editor/file browser after checkout\n  anvil checkout APPID my-local-folder --force\n  anvil checkout  # interactive search/select app list\n  anvil checkout -Q "dashboard"  # preseed picker search\n');
+        return watchCommand;
     }
     const gitCredential_defaultDeps = {
         getValidAuthToken: auth_getValidAuthToken,