@getpaseo/server 0.1.59 → 0.1.60

package/dist/server/server/workspace-git-service.js

@@ -1,14 +1,22 @@
 import { watch } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, hasOriginRemote, resolveGhPath, resolveAbsoluteGitDir, } from "../utils/checkout-git.js";
+import { getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, getPullRequestStatus, hasOriginRemote, listBranchSuggestions, resolveRepositoryDefaultBranch, resolveBranchCheckout, resolveAbsoluteGitDir, } from "../utils/checkout-git.js";
+import { createGitHubService } from "../services/github-service.js";
 import { parseGitRevParsePath } from "../utils/git-rev-parse-path.js";
 import { runGitCommand } from "../utils/run-git-command.js";
+import { listPaseoWorktrees } from "../utils/worktree.js";
 import { READ_ONLY_GIT_ENV } from "./checkout-git-utils.js";
+import { buildWorkspaceGitMetadataFromSnapshot, } from "./workspace-git-metadata.js";
 import { normalizeWorkspaceId } from "./workspace-registry-model.js";
 const WORKSPACE_GIT_WATCH_DEBOUNCE_MS = 500;
 const BACKGROUND_GIT_FETCH_INTERVAL_MS = 180000;
+export const WORKSPACE_GIT_SELF_HEAL_INTERVAL_MS = 60000;
 const WORKING_TREE_WATCH_FALLBACK_REFRESH_MS = 5000;
+// Consumer reads may reuse cached values within this window; older peeks cold-load through the service.
+const WORKSPACE_GIT_CONSUMER_TTL_MS = 15000;
+// Non-forced refresh triggers share this minimum gap to absorb watcher/self-heal bursts; force bypasses it.
+const WORKSPACE_GIT_INTERNAL_MIN_GAP_MS = 2000;
 export class WorkspaceGitServiceImpl {
     constructor(options) {
         this.workspaceTargets = new Map();
@@ -16,6 +24,13 @@ export class WorkspaceGitServiceImpl {
         this.workspaceTargetSetups = new Map();
         this.workingTreeWatchTargets = new Map();
         this.workingTreeWatchSetups = new Map();
+        this.branchValidationCache = new Map();
+        this.localBranchCache = new Map();
+        this.branchSuggestionsCache = new Map();
+        this.stashListCache = new Map();
+        this.worktreeListCache = new Map();
+        this.defaultBranchCache = new Map();
+        this.checkoutDiffCache = new Map();
         this.logger = options.logger.child({ module: "workspace-git-service" });
         this.paseoHome = options.paseoHome;
         this.deps = {
@@ -23,8 +38,13 @@ export class WorkspaceGitServiceImpl {
             readdir: options.deps?.readdir ?? readdir,
             getCheckoutStatus: options.deps?.getCheckoutStatus ?? getCheckoutStatus,
             getCheckoutShortstat: options.deps?.getCheckoutShortstat ?? getCheckoutShortstat,
+            getCheckoutDiff: options.deps?.getCheckoutDiff ?? getCheckoutDiff,
             getPullRequestStatus: options.deps?.getPullRequestStatus ?? getPullRequestStatus,
-            resolveGhPath: options.deps?.resolveGhPath ?? resolveGhPath,
+            resolveBranchCheckout: options.deps?.resolveBranchCheckout ?? resolveBranchCheckout,
+            resolveRepositoryDefaultBranch: options.deps?.resolveRepositoryDefaultBranch ?? resolveRepositoryDefaultBranch,
+            listBranchSuggestions: options.deps?.listBranchSuggestions ?? listBranchSuggestions,
+            listPaseoWorktrees: options.deps?.listPaseoWorktrees ?? listPaseoWorktrees,
+            github: options.deps?.github ?? createGitHubService(),
             resolveAbsoluteGitDir: options.deps?.resolveAbsoluteGitDir ?? resolveAbsoluteGitDir,
             hasOriginRemote: options.deps?.hasOriginRemote ?? hasOriginRemote,
             runGitFetch: options.deps?.runGitFetch ?? runGitFetch,
@@ -36,6 +56,9 @@ export class WorkspaceGitServiceImpl {
         const cwd = normalizeWorkspaceId(params.cwd);
         const target = await this.ensureWorkspaceTarget(cwd);
         target.listeners.add(listener);
+        if (target.listeners.size === 1) {
+            this.startWorkspaceSubscriptionTimers(target);
+        }
         return {
             initial: target.latestSnapshot ?? (await this.getSnapshot(cwd)),
             unsubscribe: () => {
@@ -43,24 +66,143 @@ export class WorkspaceGitServiceImpl {
             },
         };
     }
-    async getSnapshot(cwd) {
+    async getSnapshot(cwd, options) {
         cwd = normalizeWorkspaceId(cwd);
-        const target = this.workspaceTargets.get(cwd);
-        if (target?.latestSnapshot) {
+        const request = this.normalizeRefreshRequest(options, "getSnapshot", true);
+        const target = await this.ensureWorkspaceTarget(cwd);
+        if (!request.force && this.isSnapshotWarm(target)) {
             return target.latestSnapshot;
         }
-        const ensuredTarget = await this.ensureWorkspaceTarget(cwd);
-        return ensuredTarget.latestSnapshot ?? (await this.refreshSnapshot(cwd));
+        return this.requestWorkspaceSnapshot(target, request);
     }
     peekSnapshot(cwd) {
         cwd = normalizeWorkspaceId(cwd);
         return this.workspaceTargets.get(cwd)?.latestSnapshot ?? null;
     }
+    getCheckoutDiff(cwd, options, readOptions) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedOptions = this.normalizeCheckoutDiffOptions(options);
+        const key = this.buildCheckoutDiffCacheKey(normalizedCwd, normalizedOptions);
+        return this.readAuxiliaryCache(this.checkoutDiffCache, key, readOptions, () => this.deps.getCheckoutDiff(normalizedCwd, normalizedOptions, { paseoHome: this.paseoHome }));
+    }
+    normalizeCheckoutDiffOptions(options) {
+        return {
+            mode: options.mode,
+            ...(options.mode === "base" && options.baseRef !== undefined
+                ? { baseRef: options.baseRef }
+                : {}),
+            ...(options.ignoreWhitespace === true ? { ignoreWhitespace: true } : {}),
+            ...(options.includeStructured === true ? { includeStructured: true } : {}),
+        };
+    }
+    buildCheckoutDiffCacheKey(cwd, options) {
+        // Diff content varies by compare signature. Keep the cache per exact diff read shape so
+        // hot diff panes coalesce while base refs and rendering options never share stale patches.
+        return JSON.stringify([
+            "checkout-diff",
+            cwd,
+            options.mode,
+            options.mode === "base" ? (options.baseRef ?? null) : null,
+            options.ignoreWhitespace === true,
+            options.includeStructured === true,
+        ]);
+    }
+    validateBranchRef(cwd, ref, options) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedRef = ref.trim();
+        const key = JSON.stringify(["branch-validation", normalizedCwd, normalizedRef]);
+        return this.readAuxiliaryCache(this.branchValidationCache, key, options, () => this.deps.resolveBranchCheckout(normalizedCwd, normalizedRef));
+    }
+    hasLocalBranch(cwd, branch, options) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const normalizedBranch = branch.trim();
+        const ref = `refs/heads/${normalizedBranch}`;
+        const key = JSON.stringify(["local-branch", normalizedCwd, ref]);
+        return this.readAuxiliaryCache(this.localBranchCache, key, options, async () => {
+            const result = await this.deps.runGitCommand(["rev-parse", "--verify", "--quiet", ref], {
+                cwd: normalizedCwd,
+                env: READ_ONLY_GIT_ENV,
+                acceptExitCodes: [0, 1],
+            });
+            return result.exitCode === 0;
+        });
+    }
+    suggestBranchesForCwd(cwd, options, readOptions) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const query = options?.query ?? "";
+        const limit = options?.limit;
+        const key = JSON.stringify(["branch-suggestions", normalizedCwd, query, limit ?? null]);
+        return this.readAuxiliaryCache(this.branchSuggestionsCache, key, readOptions, () => this.deps.listBranchSuggestions(normalizedCwd, options));
+    }
+    listStashes(cwd, options, readOptions) {
+        const normalizedCwd = normalizeWorkspaceId(cwd);
+        const paseoOnly = options?.paseoOnly !== false;
+        const key = JSON.stringify(["stashes", normalizedCwd, paseoOnly]);
+        return this.readAuxiliaryCache(this.stashListCache, key, readOptions, async () => {
+            const { stdout } = await this.deps.runGitCommand(["stash", "list", "--format=%gd%x00%s"], {
+                cwd: normalizedCwd,
+                env: READ_ONLY_GIT_ENV,
+            });
+            return parseWorkspaceGitStashList(stdout, { paseoOnly });
+        });
+    }
+    async listWorktrees(cwdOrRepoRoot, options) {
+        const repoRoot = await this.resolveRepoRoot(cwdOrRepoRoot, options);
+        const key = JSON.stringify(["worktrees", repoRoot]);
+        return this.readAuxiliaryCache(this.worktreeListCache, key, options, () => this.deps.listPaseoWorktrees({
+            cwd: repoRoot,
+            paseoHome: this.paseoHome,
+        }));
+    }
+    async resolveRepoRoot(cwd, options) {
+        const snapshot = await this.getSnapshot(cwd, options);
+        if (!snapshot.git.isGit) {
+            throw new Error("Create worktree requires a git repository");
+        }
+        return snapshot.git.isPaseoOwnedWorktree
+            ? (snapshot.git.mainRepoRoot ?? snapshot.git.repoRoot ?? normalizeWorkspaceId(cwd))
+            : (snapshot.git.repoRoot ?? normalizeWorkspaceId(cwd));
+    }
+    async resolveDefaultBranch(cwdOrRepoRoot, options) {
+        const cwd = normalizeWorkspaceId(cwdOrRepoRoot);
+        const key = JSON.stringify(["default-branch", cwd]);
+        return this.readAuxiliaryCache(this.defaultBranchCache, key, options, async () => {
+            const defaultBranch = await this.deps.resolveRepositoryDefaultBranch(cwd);
+            if (!defaultBranch) {
+                throw new Error("Unable to resolve repository default branch");
+            }
+            return defaultBranch;
+        });
+    }
+    async getWorkspaceGitMetadata(cwd, options) {
+        const snapshot = await this.getSnapshot(cwd, options);
+        const directoryName = options?.directoryName ??
+            normalizeWorkspaceId(cwd).split(/[\\/]/).filter(Boolean).at(-1) ??
+            cwd;
+        return buildWorkspaceGitMetadataFromSnapshot({
+            cwd: normalizeWorkspaceId(cwd),
+            directoryName,
+            isGit: snapshot.git.isGit,
+            repoRoot: snapshot.git.repoRoot,
+            mainRepoRoot: snapshot.git.mainRepoRoot,
+            currentBranch: snapshot.git.currentBranch,
+            remoteUrl: snapshot.git.remoteUrl,
+        });
+    }
+    async resolveRepoRemoteUrl(cwd, options) {
+        const snapshot = await this.getSnapshot(cwd, options);
+        return snapshot.git.remoteUrl;
+    }
     async refresh(cwd, _options) {
         cwd = normalizeWorkspaceId(cwd);
         const target = this.workspaceTargets.get(cwd);
         if (target) {
-            await this.refreshWorkspaceTarget(target);
+            await this.refreshWorkspaceTarget(target, {
+                force: false,
+                includeGitHub: false,
+                reason: "refresh",
+                notify: true,
+            });
             return;
         }
         await this.ensureWorkspaceTarget(cwd);
@@ -114,6 +256,51 @@ export class WorkspaceGitServiceImpl {
         this.workspaceTargetSetups.set(cwd, setup);
         return setup;
     }
+    readAuxiliaryCache(cache, key, options, load) {
+        if (options?.force && !options.reason) {
+            throw new Error("WorkspaceGitService forced read requires a reason");
+        }
+        const entry = this.ensureAuxiliaryCacheEntry(cache, key);
+        const nowMs = this.deps.now().getTime();
+        if (!options?.force && entry.value !== null && entry.loadedAtMs !== null) {
+            const ageMs = nowMs - entry.loadedAtMs;
+            if (ageMs <= WORKSPACE_GIT_CONSUMER_TTL_MS) {
+                return Promise.resolve(entry.value);
+            }
+            if (entry.lastShellOutAtMs !== null &&
+                nowMs - entry.lastShellOutAtMs < WORKSPACE_GIT_INTERNAL_MIN_GAP_MS) {
+                return Promise.resolve(entry.value);
+            }
+        }
+        if (entry.inFlight) {
+            return entry.inFlight;
+        }
+        entry.lastShellOutAtMs = nowMs;
+        entry.inFlight = load()
+            .then((value) => {
+            entry.value = value;
+            entry.loadedAtMs = this.deps.now().getTime();
+            return value;
+        })
+            .finally(() => {
+            entry.inFlight = null;
+        });
+        return entry.inFlight;
+    }
+    ensureAuxiliaryCacheEntry(cache, key) {
+        const existing = cache.get(key);
+        if (existing) {
+            return existing;
+        }
+        const entry = {
+            value: null,
+            loadedAtMs: null,
+            lastShellOutAtMs: null,
+            inFlight: null,
+        };
+        cache.set(key, entry);
+        return entry;
+    }
     async ensureWorkingTreeWatchTarget(cwd) {
         const existingTarget = this.workingTreeWatchTargets.get(cwd);
         if (existingTarget) {
@@ -135,24 +322,39 @@ export class WorkspaceGitServiceImpl {
             listeners: new Set(),
             watchers: [],
             debounceTimer: null,
-            refreshPromise: null,
-            refreshQueued: false,
+            selfHealTimer: null,
+            githubPollSubscription: null,
+            githubPollHeadRef: null,
+            refreshState: { status: "idle" },
             latestSnapshot: null,
+            latestSnapshotLoadedAtMs: null,
             latestFingerprint: null,
+            lastShellOutAtMs: null,
             repoGitRoot: null,
         };
-        const initial = await this.refreshSnapshot(cwd);
-        this.rememberSnapshot(target, initial);
         this.workspaceTargets.set(cwd, target);
-        const gitDir = await this.deps.resolveAbsoluteGitDir(cwd);
-        if (!gitDir) {
+        try {
+            await this.requestWorkspaceSnapshot(target, {
+                force: false,
+                includeGitHub: true,
+                reason: "initial",
+                notify: false,
+            });
+            const gitDir = await this.deps.resolveAbsoluteGitDir(cwd);
+            if (!gitDir) {
+                return target;
+            }
+            const repoGitRoot = await this.resolveWorkspaceGitRefsRoot(gitDir);
+            target.repoGitRoot = repoGitRoot;
+            this.startWorkspaceWatchers(target, gitDir, repoGitRoot);
+            await this.ensureRepoTarget(target);
             return target;
         }
-        const repoGitRoot = await this.resolveWorkspaceGitRefsRoot(gitDir);
-        target.repoGitRoot = repoGitRoot;
-        this.startWorkspaceWatchers(target, gitDir, repoGitRoot);
-        await this.ensureRepoTarget(target);
-        return target;
+        catch (error) {
+            this.closeWorkspaceTarget(target);
+            this.workspaceTargets.delete(cwd);
+            throw error;
+        }
     }
     async createWorkingTreeWatchTarget(cwd) {
         const repoRoot = await this.resolveCheckoutWatchRoot(cwd);
@@ -192,7 +394,10 @@ export class WorkspaceGitServiceImpl {
         const missingRepoCoverage = repoRoot === null || !hasRecursiveRepoCoverage;
         if (target.watchers.length === 0 || missingRepoCoverage) {
             target.fallbackRefreshInterval = setInterval(() => {
-                this.scheduleWorkspaceRefresh(cwd);
+                this.scheduleWorkspaceRefresh(cwd, {
+                    force: true,
+                    reason: "working-tree-watch-fallback",
+                });
                 for (const listener of target.listeners) {
                     listener();
                 }
@@ -281,7 +486,7 @@ export class WorkspaceGitServiceImpl {
         this.repoTargets.set(repoGitRoot, repoTarget);
         void this.runRepoFetch(repoTarget);
     }
-    scheduleWorkspaceRefresh(targetOrCwd) {
+    scheduleWorkspaceRefresh(targetOrCwd, options) {
         const target = typeof targetOrCwd === "string"
             ? this.workspaceTargets.get(normalizeWorkspaceId(targetOrCwd))
             : targetOrCwd;
@@ -293,9 +498,65 @@ export class WorkspaceGitServiceImpl {
         }
         target.debounceTimer = setTimeout(() => {
             target.debounceTimer = null;
-            void this.refreshWorkspaceTarget(target);
+            void this.refreshWorkspaceTarget(target, {
+                force: options?.force === true,
+                includeGitHub: false,
+                reason: options?.reason ?? "watch",
+                notify: true,
+            });
         }, WORKSPACE_GIT_WATCH_DEBOUNCE_MS);
     }
+    startWorkspaceSubscriptionTimers(target) {
+        if (!target.selfHealTimer) {
+            target.selfHealTimer = setInterval(() => {
+                this.getSnapshot(target.cwd, { reason: "self-heal-git" }).catch((error) => {
+                    this.logger.warn({ err: error, cwd: target.cwd, reason: "self-heal-git" }, "Failed to run workspace git self-heal refresh");
+                });
+            }, WORKSPACE_GIT_SELF_HEAL_INTERVAL_MS);
+        }
+        this.updateGitHubPollForTarget(target);
+    }
+    updateGitHubPollForTarget(target) {
+        if (target.listeners.size === 0) {
+            this.stopGitHubPollForTarget(target);
+            return;
+        }
+        const snapshot = target.latestSnapshot;
+        if (!snapshot || !this.deps.github.retainCurrentPullRequestStatusPoll) {
+            this.stopGitHubPollForTarget(target);
+            return;
+        }
+        const headRef = snapshot.git.currentBranch;
+        if (!headRef || !hasGitHubRemoteUrl(snapshot.git.remoteUrl)) {
+            this.stopGitHubPollForTarget(target);
+            return;
+        }
+        if (target.githubPollHeadRef === headRef && target.githubPollSubscription) {
+            return;
+        }
+        this.stopGitHubPollForTarget(target);
+        target.githubPollHeadRef = headRef;
+        target.githubPollSubscription = this.deps.github.retainCurrentPullRequestStatusPoll({
+            cwd: target.cwd,
+            headRef,
+            onStatus: () => {
+                void this.refreshWorkspaceTarget(target, {
+                    force: false,
+                    includeGitHub: true,
+                    reason: "self-heal-github",
+                    notify: true,
+                });
+            },
+            onError: (error) => {
+                this.logger.warn({ err: error, cwd: target.cwd, headRef, reason: "self-heal-github" }, "Failed to run GitHub self-heal refresh");
+            },
+        });
+    }
+    stopGitHubPollForTarget(target) {
+        target.githubPollSubscription?.unsubscribe();
+        target.githubPollSubscription = null;
+        target.githubPollHeadRef = null;
+    }
     addWorkingTreeWatcher(target, watchPath, shouldTryRecursive) {
         if (target.watchedPaths.has(watchPath)) {
             return false;
@@ -305,7 +566,10 @@ export class WorkspaceGitServiceImpl {
             if (process.platform === "linux" && target.repoWatchPath) {
                 void this.refreshLinuxRepoTreeWatchers(target);
             }
-            this.scheduleWorkspaceRefresh(cwd);
+            this.scheduleWorkspaceRefresh(cwd, {
+                force: true,
+                reason: "working-tree-watch",
+            });
             for (const listener of target.listeners) {
                 listener();
             }
@@ -415,37 +679,119 @@ export class WorkspaceGitServiceImpl {
         }
         return directories;
     }
-    async refreshWorkspaceTarget(target) {
-        if (target.refreshPromise) {
-            target.refreshQueued = true;
-            return;
-        }
-        target.refreshPromise = (async () => {
-            do {
-                target.refreshQueued = false;
-                try {
-                    const snapshot = await this.refreshSnapshot(target.cwd);
-                    this.rememberSnapshot(target, snapshot, { notify: true });
-                }
-                catch (error) {
-                    this.logger.warn({ err: error, cwd: target.cwd }, "Failed to refresh workspace git snapshot");
-                }
-            } while (target.refreshQueued);
-        })();
+    async refreshWorkspaceTarget(target, request) {
         try {
-            await target.refreshPromise;
+            await this.requestWorkspaceSnapshot(target, request);
         }
-        finally {
-            target.refreshPromise = null;
+        catch (error) {
+            this.logger.warn({ err: error, cwd: target.cwd, reason: request.reason }, "Failed to refresh workspace git snapshot");
+        }
+    }
+    requestWorkspaceSnapshot(target, request) {
+        if (target.refreshState.status === "in-flight") {
+            if (request.force && !target.refreshState.force) {
+                target.refreshState.queued = this.mergeQueuedRefresh(target.refreshState.queued, request);
+            }
+            return target.refreshState.promise;
+        }
+        if (!request.force && this.shouldThrottleNonForcedRefresh(target)) {
+            return Promise.resolve(target.latestSnapshot);
+        }
+        const promise = this.runWorkspaceRefreshLoop(target, request).finally(() => {
+            const state = target.refreshState;
+            if (state.status === "in-flight" && state.promise === promise) {
+                target.refreshState = { status: "idle" };
+            }
+        });
+        target.refreshState = {
+            status: "in-flight",
+            promise,
+            force: request.force,
+            includeGitHub: request.includeGitHub,
+            queued: null,
+        };
+        return promise;
+    }
+    normalizeRefreshRequest(options, defaultReason, notify) {
+        if (options?.force && !options.reason) {
+            throw new Error("WorkspaceGitService.getSnapshot force refresh requires a reason");
+        }
+        const force = options?.force === true;
+        return {
+            force,
+            includeGitHub: options?.includeGitHub ?? force,
+            reason: options?.reason ?? defaultReason,
+            notify,
+        };
+    }
+    isSnapshotWarm(target) {
+        if (!target.latestSnapshot || target.latestSnapshotLoadedAtMs === null) {
+            return false;
+        }
+        return (this.deps.now().getTime() - target.latestSnapshotLoadedAtMs <= WORKSPACE_GIT_CONSUMER_TTL_MS);
+    }
+    shouldThrottleNonForcedRefresh(target) {
+        if (!target.latestSnapshot || target.lastShellOutAtMs === null) {
+            return false;
+        }
+        return this.deps.now().getTime() - target.lastShellOutAtMs < WORKSPACE_GIT_INTERNAL_MIN_GAP_MS;
+    }
+    mergeQueuedRefresh(queued, request) {
+        if (!queued) {
+            return {
+                force: request.force,
+                includeGitHub: request.includeGitHub,
+                reason: request.reason,
+                notify: request.notify,
+            };
+        }
+        const force = queued.force || request.force;
+        return {
+            force,
+            includeGitHub: queued.includeGitHub || request.includeGitHub,
+            reason: request.force && !queued.force ? request.reason : queued.reason,
+            notify: queued.notify || request.notify,
+        };
+    }
+    async runWorkspaceRefreshLoop(target, initialRequest) {
+        let request = initialRequest;
+        let snapshot;
+        while (true) {
+            snapshot = await this.refreshSnapshot(target, request);
+            this.rememberSnapshot(target, snapshot, {
+                notify: request.notify,
+                forceEmit: request.force,
+            });
+            const state = target.refreshState;
+            if (state.status !== "in-flight" || !state.queued) {
+                break;
+            }
+            request = state.queued;
+            state.queued = null;
+            state.force = request.force;
+            state.includeGitHub = request.includeGitHub;
         }
+        return snapshot;
     }
-    async refreshSnapshot(cwd) {
-        return loadWorkspaceGitRuntimeSnapshot(cwd, { paseoHome: this.paseoHome }, this.deps.now(), this.deps);
+    async refreshSnapshot(target, request) {
+        const now = this.deps.now();
+        target.lastShellOutAtMs = now.getTime();
+        const forceGitHub = request.force && request.includeGitHub;
+        if (forceGitHub) {
+            this.deps.github.invalidate({ cwd: target.cwd });
+        }
+        const snapshot = await loadWorkspaceGitRuntimeSnapshot(target.cwd, { paseoHome: this.paseoHome }, now, this.deps, { force: request.force, forceGitHub, reason: request.reason });
+        target.latestSnapshotLoadedAtMs = now.getTime();
+        return snapshot;
     }
     rememberSnapshot(target, snapshot, options) {
         target.latestSnapshot = snapshot;
+        if (target.listeners.size > 0) {
+            this.updateGitHubPollForTarget(target);
+        }
         const fingerprint = JSON.stringify(snapshot);
-        if (target.latestFingerprint === fingerprint) {
+        const fingerprintMatches = target.latestFingerprint === fingerprint;
+        if (fingerprintMatches && !options?.forceEmit) {
             return;
         }
         target.latestFingerprint = fingerprint;
@@ -475,7 +821,12 @@ export class WorkspaceGitServiceImpl {
                 if (!workspaceTarget) {
                     return;
                 }
-                await this.refreshWorkspaceTarget(workspaceTarget);
+                await this.refreshWorkspaceTarget(workspaceTarget, {
+                    force: false,
+                    includeGitHub: false,
+                    reason: "repo-fetch",
+                    notify: true,
+                });
             }));
         }
     }
@@ -519,6 +870,11 @@ export class WorkspaceGitServiceImpl {
             clearTimeout(target.debounceTimer);
             target.debounceTimer = null;
         }
+        if (target.selfHealTimer) {
+            clearInterval(target.selfHealTimer);
+            target.selfHealTimer = null;
+        }
+        this.stopGitHubPollForTarget(target);
         for (const watcher of target.watchers) {
             watcher.close();
         }
@@ -545,18 +901,20 @@ export class WorkspaceGitServiceImpl {
         target.workspaceKeys.clear();
     }
 }
-async function loadWorkspaceGitRuntimeSnapshot(cwd, context, now, deps) {
+async function loadWorkspaceGitRuntimeSnapshot(cwd, context, now, deps, options) {
     const checkoutStatus = await deps.getCheckoutStatus(cwd, context);
     if (!checkoutStatus.isGit) {
         return buildNotGitSnapshot(cwd);
     }
     const [diffStat, github] = await Promise.all([
-        deps.getCheckoutShortstat(cwd, context),
+        deps.getCheckoutShortstat(cwd, context, { force: options?.force }),
         loadGitHubSnapshot({
             cwd,
             remoteUrl: checkoutStatus.remoteUrl,
             now,
             deps,
+            force: options?.forceGitHub,
+            reason: options?.reason,
         }),
     ]);
     return {
@@ -569,9 +927,11 @@ async function loadWorkspaceGitRuntimeSnapshot(cwd, context, now, deps) {
             remoteUrl: checkoutStatus.remoteUrl,
             isPaseoOwnedWorktree: checkoutStatus.isPaseoOwnedWorktree,
             isDirty: checkoutStatus.isDirty,
+            baseRef: checkoutStatus.baseRef,
             aheadBehind: checkoutStatus.aheadBehind,
             aheadOfOrigin: checkoutStatus.aheadOfOrigin,
             behindOfOrigin: checkoutStatus.behindOfOrigin,
+            hasRemote: checkoutStatus.hasRemote,
             diffStat,
         },
         github,
@@ -583,27 +943,27 @@ async function loadGitHubSnapshot(options) {
             featuresEnabled: false,
             pullRequest: null,
             error: null,
-            refreshedAt: null,
         };
     }
     try {
-        await options.deps.resolveGhPath();
+        await options.deps.github.isAuthenticated({ cwd: options.cwd });
     }
     catch {
         return {
             featuresEnabled: false,
             pullRequest: null,
             error: null,
-            refreshedAt: null,
         };
     }
     try {
-        const result = await options.deps.getPullRequestStatus(options.cwd);
+        const result = await options.deps.getPullRequestStatus(options.cwd, options.deps.github, {
+            force: options.force,
+            reason: options.reason,
+        });
         return {
             featuresEnabled: true,
             pullRequest: result.status,
             error: null,
-            refreshedAt: options.now.toISOString(),
         };
     }
     catch (error) {
@@ -613,7 +973,6 @@ async function loadGitHubSnapshot(options) {
             error: {
                 message: error instanceof Error ? error.message : String(error),
             },
-            refreshedAt: options.now.toISOString(),
         };
     }
 }
@@ -625,6 +984,32 @@ function hasGitHubRemoteUrl(remoteUrl) {
         remoteUrl.startsWith("git@github.com:") ||
         remoteUrl.startsWith("ssh://git@github.com/"));
 }
+function parseWorkspaceGitStashList(stdout, options) {
+    const entries = [];
+    const lines = stdout.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+        const sepIdx = line.indexOf("\0");
+        if (sepIdx < 0) {
+            continue;
+        }
+        const refPart = line.slice(0, sepIdx);
+        const subject = line.slice(sepIdx + 1);
+        const indexMatch = refPart.match(/\{(\d+)\}/);
+        if (!indexMatch) {
+            continue;
+        }
+        const index = Number(indexMatch[1]);
+        const prefix = "paseo-auto-stash:";
+        const prefixIdx = subject.indexOf(prefix);
+        const isPaseo = prefixIdx >= 0;
+        const branch = isPaseo ? subject.slice(prefixIdx + prefix.length).trim() || null : null;
+        if (options.paseoOnly && !isPaseo) {
+            continue;
+        }
+        entries.push({ index, message: subject, branch, isPaseo });
+    }
+    return entries;
+}
 function buildNotGitSnapshot(cwd) {
     return {
         cwd,
@@ -636,16 +1021,17 @@ function buildNotGitSnapshot(cwd) {
             remoteUrl: null,
             isPaseoOwnedWorktree: false,
             isDirty: null,
+            baseRef: null,
             aheadBehind: null,
             aheadOfOrigin: null,
             behindOfOrigin: null,
+            hasRemote: false,
             diffStat: null,
         },
         github: {
             featuresEnabled: false,
             pullRequest: null,
             error: null,
-            refreshedAt: null,
         },
     };
 }