@junctionpanel/server 0.1.52 → 0.1.54

package/dist/server/server/session.js

@@ -51,6 +51,10 @@ const pendingAgentMessageExecutions = new Map();
 const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_IDS[0];
 const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
 const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5000;
+const WORKSPACE_STATUS_WATCH_DEBOUNCE_MS = 250;
+const WORKSPACE_STATUS_GIT_REFRESH_MS = 3000;
+const WORKSPACE_STATUS_PR_ACTIVE_REFRESH_MS = 15000;
+const WORKSPACE_STATUS_PR_PASSIVE_REFRESH_MS = 60000;
 const TERMINAL_STREAM_WINDOW_BYTES = 256 * 1024;
 const TERMINAL_STREAM_MAX_PENDING_BYTES = 2 * 1024 * 1024;
 const TERMINAL_STREAM_MAX_PENDING_CHUNKS = 2048;
@@ -119,6 +123,8 @@ export class Session {
         this.clientActivity = null;
         this.MOBILE_BACKGROUND_STREAM_GRACE_MS = 60000;
         this.subscribedTerminalDirectories = new Set();
+        this.workspaceStatusSubscriptions = new Map();
+        this.workspaceStatusTargets = new Map();
         this.unsubscribeTerminalsChanged = null;
         this.terminalSubscriptions = new Map();
         this.terminalExitSubscriptions = new Map();
@@ -863,6 +869,12 @@ export class Session {
                 case 'checkout_status_request':
                     await this.handleCheckoutStatusRequest(msg);
                     break;
+                case 'subscribe_workspace_status_request':
+                    await this.handleSubscribeWorkspaceStatusRequest(msg);
+                    break;
+                case 'unsubscribe_workspace_status_request':
+                    this.handleUnsubscribeWorkspaceStatusRequest(msg);
+                    break;
                 case 'validate_branch_request':
                     await this.handleValidateBranchRequest(msg);
                     break;
@@ -2702,101 +2714,191 @@ export class Session {
             throw error;
         }
     }
+    buildCheckoutStatusPayload(cwd, status) {
+        if (!status.isGit) {
+            return {
+                cwd,
+                isGit: false,
+                repoRoot: null,
+                currentBranch: null,
+                isDirty: null,
+                baseRef: null,
+                aheadBehind: null,
+                aheadOfOrigin: null,
+                behindOfOrigin: null,
+                hasUpstream: false,
+                upstreamBranch: null,
+                hasRemote: false,
+                remoteUrl: null,
+                isJunctionOwnedWorktree: false,
+                error: null,
+            };
+        }
+        if (status.isJunctionOwnedWorktree) {
+            return {
+                cwd,
+                isGit: true,
+                repoRoot: status.repoRoot ?? null,
+                mainRepoRoot: status.mainRepoRoot,
+                currentBranch: status.currentBranch ?? null,
+                isDirty: status.isDirty ?? null,
+                baseRef: status.baseRef,
+                aheadBehind: status.aheadBehind ?? null,
+                aheadOfOrigin: status.aheadOfOrigin ?? null,
+                behindOfOrigin: status.behindOfOrigin ?? null,
+                hasUpstream: status.hasUpstream,
+                upstreamBranch: status.upstreamBranch ?? null,
+                hasRemote: status.hasRemote,
+                remoteUrl: status.remoteUrl,
+                isJunctionOwnedWorktree: true,
+                error: null,
+            };
+        }
+        return {
+            cwd,
+            isGit: true,
+            repoRoot: status.repoRoot ?? null,
+            currentBranch: status.currentBranch ?? null,
+            isDirty: status.isDirty ?? null,
+            baseRef: status.baseRef ?? null,
+            aheadBehind: status.aheadBehind ?? null,
+            aheadOfOrigin: status.aheadOfOrigin ?? null,
+            behindOfOrigin: status.behindOfOrigin ?? null,
+            hasUpstream: status.hasUpstream,
+            upstreamBranch: status.upstreamBranch ?? null,
+            hasRemote: status.hasRemote,
+            remoteUrl: status.remoteUrl,
+            isJunctionOwnedWorktree: false,
+            error: null,
+        };
+    }
+    buildCheckoutStatusErrorPayload(cwd, error) {
+        return {
+            cwd,
+            isGit: false,
+            repoRoot: null,
+            currentBranch: null,
+            isDirty: null,
+            baseRef: null,
+            aheadBehind: null,
+            aheadOfOrigin: null,
+            behindOfOrigin: null,
+            hasUpstream: false,
+            upstreamBranch: null,
+            hasRemote: false,
+            remoteUrl: null,
+            isJunctionOwnedWorktree: false,
+            error: this.toCheckoutError(error),
+            requestId: '',
+        };
+    }
+    buildCheckoutStatusLitePayload(cwd, repoRoot, status) {
+        if (!status.isGit) {
+            return {
+                cwd,
+                isGit: false,
+                repoRoot: null,
+                currentBranch: null,
+                isDirty: null,
+                baseRef: null,
+                aheadBehind: null,
+                aheadOfOrigin: null,
+                behindOfOrigin: null,
+                hasUpstream: false,
+                upstreamBranch: null,
+                hasRemote: Boolean(status.remoteUrl),
+                remoteUrl: status.remoteUrl,
+                isJunctionOwnedWorktree: false,
+                error: null,
+            };
+        }
+        return {
+            cwd,
+            isGit: true,
+            repoRoot,
+            currentBranch: status.currentBranch ?? null,
+            isDirty: false,
+            baseRef: null,
+            aheadBehind: null,
+            aheadOfOrigin: null,
+            behindOfOrigin: null,
+            hasUpstream: false,
+            upstreamBranch: null,
+            hasRemote: Boolean(status.remoteUrl),
+            remoteUrl: status.remoteUrl,
+            isJunctionOwnedWorktree: false,
+            error: null,
+        };
+    }
+    toWorkspaceGitStatus(payload) {
+        const normalizedPayload = payload;
+        const { cwd: _cwd, error: _error, requestId: _requestId, ...git } = normalizedPayload;
+        return git;
+    }
+    async resolveWorkspaceGitSnapshot(cwd, options) {
+        try {
+            const payload = await (async () => {
+                if (!options?.lite) {
+                    return this.buildCheckoutStatusPayload(cwd, await getCheckoutStatus(expandTilde(cwd), { junctionHome: this.junctionHome }));
+                }
+                const liteStatus = await getCheckoutStatusLite(expandTilde(cwd), {
+                    junctionHome: this.junctionHome,
+                });
+                if (liteStatus.isGit && liteStatus.isJunctionOwnedWorktree) {
+                    return this.buildCheckoutStatusPayload(cwd, await getCheckoutStatus(expandTilde(cwd), { junctionHome: this.junctionHome }));
+                }
+                return this.buildCheckoutStatusLitePayload(cwd, options.repoRoot ?? cwd, liteStatus);
+            })();
+            return {
+                git: this.toWorkspaceGitStatus(payload),
+                gitError: payload.error,
+            };
+        }
+        catch (error) {
+            const payload = this.buildCheckoutStatusErrorPayload(cwd, error);
+            return {
+                git: this.toWorkspaceGitStatus(payload),
+                gitError: payload.error,
+            };
+        }
+    }
+    async resolveWorkspacePullRequestSnapshot(cwd, remoteName) {
+        try {
+            const prStatus = await getPullRequestStatus(expandTilde(cwd), {
+                ...(remoteName ? { remoteName } : {}),
+            });
+            return {
+                pullRequest: prStatus.status,
+                pullRequestError: null,
+                githubFeaturesEnabled: prStatus.githubFeaturesEnabled,
+            };
+        }
+        catch (error) {
+            return {
+                pullRequest: null,
+                pullRequestError: this.toCheckoutError(error),
+                githubFeaturesEnabled: true,
+            };
+        }
+    }
     async handleCheckoutStatusRequest(msg) {
         const { cwd, requestId } = msg;
-        const resolvedCwd = expandTilde(cwd);
         try {
-            const status = await getCheckoutStatus(resolvedCwd, { junctionHome: this.junctionHome });
-            if (!status.isGit) {
-                this.emit({
-                    type: 'checkout_status_response',
-                    payload: {
-                        cwd,
-                        isGit: false,
-                        repoRoot: null,
-                        currentBranch: null,
-                        isDirty: null,
-                        baseRef: null,
-                        aheadBehind: null,
-                        aheadOfOrigin: null,
-                        behindOfOrigin: null,
-                        hasUpstream: false,
-                        upstreamBranch: null,
-                        hasRemote: false,
-                        remoteUrl: null,
-                        isJunctionOwnedWorktree: false,
-                        error: null,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            if (status.isJunctionOwnedWorktree) {
-                this.emit({
-                    type: 'checkout_status_response',
-                    payload: {
-                        cwd,
-                        isGit: true,
-                        repoRoot: status.repoRoot ?? null,
-                        mainRepoRoot: status.mainRepoRoot,
-                        currentBranch: status.currentBranch ?? null,
-                        isDirty: status.isDirty ?? null,
-                        baseRef: status.baseRef,
-                        aheadBehind: status.aheadBehind ?? null,
-                        aheadOfOrigin: status.aheadOfOrigin ?? null,
-                        behindOfOrigin: status.behindOfOrigin ?? null,
-                        hasUpstream: status.hasUpstream,
-                        upstreamBranch: status.upstreamBranch ?? null,
-                        hasRemote: status.hasRemote,
-                        remoteUrl: status.remoteUrl,
-                        isJunctionOwnedWorktree: true,
-                        error: null,
-                        requestId,
-                    },
-                });
-                return;
-            }
+            const status = await getCheckoutStatus(expandTilde(cwd), { junctionHome: this.junctionHome });
             this.emit({
                 type: 'checkout_status_response',
                 payload: {
-                    cwd,
-                    isGit: true,
-                    repoRoot: status.repoRoot ?? null,
-                    currentBranch: status.currentBranch ?? null,
-                    isDirty: status.isDirty ?? null,
-                    baseRef: status.baseRef ?? null,
-                    aheadBehind: status.aheadBehind ?? null,
-                    aheadOfOrigin: status.aheadOfOrigin ?? null,
-                    behindOfOrigin: status.behindOfOrigin ?? null,
-                    hasUpstream: status.hasUpstream,
-                    upstreamBranch: status.upstreamBranch ?? null,
-                    hasRemote: status.hasRemote,
-                    remoteUrl: status.remoteUrl,
-                    isJunctionOwnedWorktree: false,
-                    error: null,
+                    ...this.buildCheckoutStatusPayload(cwd, status),
                     requestId,
                 },
             });
         }
         catch (error) {
+            const payload = this.buildCheckoutStatusErrorPayload(cwd, error);
             this.emit({
                 type: 'checkout_status_response',
                 payload: {
-                    cwd,
-                    isGit: false,
-                    repoRoot: null,
-                    currentBranch: null,
-                    isDirty: null,
-                    baseRef: null,
-                    aheadBehind: null,
-                    aheadOfOrigin: null,
-                    behindOfOrigin: null,
-                    hasUpstream: false,
-                    upstreamBranch: null,
-                    hasRemote: false,
-                    remoteUrl: null,
-                    isJunctionOwnedWorktree: false,
-                    error: this.toCheckoutError(error),
+                    ...payload,
                     requestId,
                 },
             });
@@ -3114,6 +3216,384 @@ export class Session {
             });
         }
     }
+    buildWorkspaceStatusTargetKey(cwd, remoteName) {
+        return JSON.stringify([cwd, remoteName ?? '']);
+    }
+    closeWorkspaceStatusWatchTarget(target) {
+        if (target.debounceTimer) {
+            clearTimeout(target.debounceTimer);
+            target.debounceTimer = null;
+        }
+        if (target.gitRefreshInterval) {
+            clearInterval(target.gitRefreshInterval);
+            target.gitRefreshInterval = null;
+        }
+        if (target.prRefreshInterval) {
+            clearInterval(target.prRefreshInterval);
+            target.prRefreshInterval = null;
+        }
+        for (const watcher of target.watchers) {
+            watcher.close();
+        }
+        target.watchers = [];
+    }
+    workspaceStatusHasActiveSubscribers(target) {
+        for (const mode of target.subscriptions.values()) {
+            if (mode === 'active') {
+                return true;
+            }
+        }
+        return false;
+    }
+    hasWorkspaceStatusTarget(target) {
+        return this.workspaceStatusTargets.get(target.key) === target && target.subscriptions.size > 0;
+    }
+    workspaceStatusGitIdentityChanged(previousSnapshot, nextGit) {
+        if (!previousSnapshot) {
+            return false;
+        }
+        const previousGit = previousSnapshot.git;
+        if (previousGit.isGit !== nextGit.isGit) {
+            return true;
+        }
+        if (!previousGit.isGit || !nextGit.isGit) {
+            return false;
+        }
+        return (previousGit.currentBranch !== nextGit.currentBranch
+            || previousGit.repoRoot !== nextGit.repoRoot
+            || previousGit.isJunctionOwnedWorktree !== nextGit.isJunctionOwnedWorktree
+            || ((previousGit.isJunctionOwnedWorktree ? previousGit.mainRepoRoot : null)
+                !== (nextGit.isJunctionOwnedWorktree ? nextGit.mainRepoRoot : null)));
+    }
+    updateWorkspaceStatusPrPolling(target) {
+        if (target.prRefreshInterval) {
+            clearInterval(target.prRefreshInterval);
+            target.prRefreshInterval = null;
+        }
+        if (target.subscriptions.size === 0) {
+            return;
+        }
+        const intervalMs = this.workspaceStatusHasActiveSubscribers(target)
+            ? WORKSPACE_STATUS_PR_ACTIVE_REFRESH_MS
+            : WORKSPACE_STATUS_PR_PASSIVE_REFRESH_MS;
+        target.prRefreshInterval = setInterval(() => {
+            this.scheduleWorkspaceStatusTargetRefresh(target, {
+                includePr: true,
+                debounce: false,
+            });
+        }, intervalMs);
+    }
+    updateWorkspaceStatusGitPolling(target) {
+        if (target.gitRefreshInterval) {
+            clearInterval(target.gitRefreshInterval);
+            target.gitRefreshInterval = null;
+        }
+        if (!this.workspaceStatusHasActiveSubscribers(target)) {
+            return;
+        }
+        target.gitRefreshInterval = setInterval(() => {
+            this.scheduleWorkspaceStatusTargetRefresh(target, {
+                includePr: false,
+                debounce: false,
+            });
+        }, WORKSPACE_STATUS_GIT_REFRESH_MS);
+    }
+    removeWorkspaceStatusSubscription(subscriptionId) {
+        const subscription = this.workspaceStatusSubscriptions.get(subscriptionId);
+        if (!subscription) {
+            return;
+        }
+        this.workspaceStatusSubscriptions.delete(subscriptionId);
+        const target = this.workspaceStatusTargets.get(subscription.targetKey);
+        if (!target) {
+            return;
+        }
+        target.subscriptions.delete(subscriptionId);
+        if (target.subscriptions.size === 0) {
+            this.closeWorkspaceStatusWatchTarget(target);
+            this.workspaceStatusTargets.delete(subscription.targetKey);
+            return;
+        }
+        this.updateWorkspaceStatusGitPolling(target);
+        this.updateWorkspaceStatusPrPolling(target);
+    }
+    scheduleWorkspaceStatusTargetRefresh(target, options) {
+        const includePr = options?.includePr ?? false;
+        const shouldDebounce = options?.debounce ?? true;
+        if (!shouldDebounce) {
+            void this.refreshWorkspaceStatusTarget(target, { includePr });
+            return;
+        }
+        if (target.debounceTimer) {
+            clearTimeout(target.debounceTimer);
+        }
+        if (includePr) {
+            target.refreshIncludesPr = true;
+        }
+        target.debounceTimer = setTimeout(() => {
+            target.debounceTimer = null;
+            void this.refreshWorkspaceStatusTarget(target, {
+                includePr: includePr || target.refreshIncludesPr,
+            });
+        }, WORKSPACE_STATUS_WATCH_DEBOUNCE_MS);
+    }
+    workspaceStatusSnapshotFingerprint(snapshot) {
+        return JSON.stringify({
+            cwd: snapshot.cwd,
+            remoteName: snapshot.remoteName,
+            git: snapshot.git,
+            gitError: snapshot.gitError,
+            pullRequest: snapshot.pullRequest,
+            pullRequestError: snapshot.pullRequestError,
+            githubFeaturesEnabled: snapshot.githubFeaturesEnabled,
+        });
+    }
+    emitWorkspaceStatusChanged(_target, snapshot) {
+        this.emit({
+            type: 'workspace_status_changed',
+            payload: snapshot,
+        });
+    }
+    async computeWorkspaceStatusSnapshot(target, options) {
+        const hasExplicitIncludePr = options != null && 'includePr' in options;
+        const includePr = hasExplicitIncludePr ? Boolean(options?.includePr) : !target.latestPayload;
+        const fullGit = options?.fullGit ?? this.workspaceStatusHasActiveSubscribers(target);
+        const gitSnapshot = await this.resolveWorkspaceGitSnapshot(target.cwd, {
+            lite: !fullGit,
+            repoRoot: target.diffCwd || target.cwd,
+        });
+        const gitIdentityChanged = this.workspaceStatusGitIdentityChanged(target.latestPayload, gitSnapshot.git);
+        let pullRequest = target.latestPayload?.pullRequest ?? null;
+        let pullRequestError = target.latestPayload?.pullRequestError ?? null;
+        let githubFeaturesEnabled = target.latestPayload?.githubFeaturesEnabled ?? false;
+        if (!gitSnapshot.git.isGit) {
+            pullRequest = null;
+            pullRequestError = null;
+            githubFeaturesEnabled = false;
+        }
+        else if (includePr) {
+            const prSnapshot = await this.resolveWorkspacePullRequestSnapshot(target.cwd, target.remoteName);
+            pullRequest = prSnapshot.pullRequest;
+            pullRequestError = prSnapshot.pullRequestError;
+            githubFeaturesEnabled = prSnapshot.githubFeaturesEnabled;
+        }
+        else if (gitIdentityChanged) {
+            pullRequest = null;
+            pullRequestError = null;
+            githubFeaturesEnabled = false;
+        }
+        return {
+            cwd: target.cwd,
+            remoteName: target.remoteName,
+            git: gitSnapshot.git,
+            gitError: gitSnapshot.gitError,
+            pullRequest,
+            pullRequestError,
+            githubFeaturesEnabled,
+            refreshedAt: new Date().toISOString(),
+        };
+    }
+    async refreshWorkspaceStatusTarget(target, options) {
+        if (target.refreshPromise) {
+            target.refreshQueued = true;
+            target.refreshIncludesPr = target.refreshIncludesPr || Boolean(options?.includePr);
+            return;
+        }
+        target.refreshPromise = (async () => {
+            do {
+                const hasExplicitIncludePr = options != null && 'includePr' in options;
+                const fullGit = this.workspaceStatusHasActiveSubscribers(target);
+                const previousHasLoadedPullRequest = target.hasLoadedPullRequest;
+                const includePr = target.refreshIncludesPr
+                    || (hasExplicitIncludePr ? Boolean(options?.includePr) : !target.latestPayload);
+                target.refreshQueued = false;
+                target.refreshIncludesPr = false;
+                const snapshot = await this.computeWorkspaceStatusSnapshot(target, {
+                    includePr,
+                    fullGit,
+                });
+                if (!this.hasWorkspaceStatusTarget(target)) {
+                    return;
+                }
+                const activeSubscribersPresent = this.workspaceStatusHasActiveSubscribers(target);
+                const gitIdentityChanged = this.workspaceStatusGitIdentityChanged(target.latestPayload, snapshot.git);
+                const needsPrReplay = (!includePr && target.refreshIncludesPr)
+                    || (!includePr && fullGit && activeSubscribersPresent && gitIdentityChanged);
+                const needsFullGitReplay = !fullGit && activeSubscribersPresent;
+                if (needsPrReplay
+                    || needsFullGitReplay) {
+                    target.refreshQueued = true;
+                    target.refreshIncludesPr = target.refreshIncludesPr || needsPrReplay || needsFullGitReplay;
+                    continue;
+                }
+                target.latestPayload = snapshot;
+                target.hasLoadedPullRequest =
+                    !snapshot.git.isGit
+                        || includePr
+                        || (previousHasLoadedPullRequest && !gitIdentityChanged);
+                target.latestPayloadHasFullGitData = !snapshot.git.isGit || fullGit;
+                const fingerprint = this.workspaceStatusSnapshotFingerprint(snapshot);
+                if (fingerprint !== target.latestFingerprint) {
+                    target.latestFingerprint = fingerprint;
+                    this.emitWorkspaceStatusChanged(target, snapshot);
+                }
+            } while (target.refreshQueued);
+        })();
+        try {
+            await target.refreshPromise;
+        }
+        finally {
+            target.refreshPromise = null;
+        }
+    }
+    async ensureWorkspaceStatusWatchTarget(cwd, remoteName) {
+        const targetKey = this.buildWorkspaceStatusTargetKey(cwd, remoteName);
+        const existing = this.workspaceStatusTargets.get(targetKey);
+        if (existing) {
+            return existing;
+        }
+        const watchRoot = await this.resolveCheckoutWatchRoot(cwd);
+        const target = {
+            key: targetKey,
+            cwd,
+            diffCwd: watchRoot ?? cwd,
+            remoteName,
+            subscriptions: new Map(),
+            watchers: [],
+            gitRefreshInterval: null,
+            prRefreshInterval: null,
+            debounceTimer: null,
+            refreshPromise: null,
+            refreshQueued: false,
+            refreshIncludesPr: false,
+            latestPayload: null,
+            latestFingerprint: null,
+            hasLoadedPullRequest: false,
+            latestPayloadHasFullGitData: false,
+        };
+        const repoWatchPath = watchRoot ?? cwd;
+        const watchPaths = new Set([repoWatchPath]);
+        const gitDir = await this.resolveCheckoutGitDir(cwd);
+        if (gitDir) {
+            watchPaths.add(gitDir);
+        }
+        let hasRecursiveRepoCoverage = false;
+        const allowRecursiveRepoWatch = process.platform !== 'linux';
+        for (const watchPath of watchPaths) {
+            const shouldTryRecursive = watchPath === repoWatchPath && allowRecursiveRepoWatch;
+            const createWatcher = (recursive) => watch(watchPath, { recursive }, () => {
+                this.scheduleWorkspaceStatusTargetRefresh(target);
+            });
+            let watcher = null;
+            let watcherIsRecursive = false;
+            try {
+                if (shouldTryRecursive) {
+                    watcher = createWatcher(true);
+                    watcherIsRecursive = true;
+                }
+                else {
+                    watcher = createWatcher(false);
+                }
+            }
+            catch (error) {
+                if (shouldTryRecursive) {
+                    try {
+                        watcher = createWatcher(false);
+                        this.sessionLogger.warn({ err: error, watchPath, cwd, remoteName }, 'Workspace status recursive watch unavailable; using non-recursive fallback');
+                    }
+                    catch (fallbackError) {
+                        this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, remoteName }, 'Failed to start workspace status watcher');
+                    }
+                }
+                else {
+                    this.sessionLogger.warn({ err: error, watchPath, cwd, remoteName }, 'Failed to start workspace status watcher');
+                }
+            }
+            if (!watcher) {
+                continue;
+            }
+            watcher.on('error', (error) => {
+                this.sessionLogger.warn({ err: error, watchPath, cwd, remoteName }, 'Workspace status watcher error');
+            });
+            target.watchers.push(watcher);
+            if (watchPath === repoWatchPath && watcherIsRecursive) {
+                hasRecursiveRepoCoverage = true;
+            }
+        }
+        if (target.watchers.length === 0 || !hasRecursiveRepoCoverage) {
+            this.sessionLogger.warn({
+                cwd,
+                remoteName,
+                reason: target.watchers.length === 0 ? 'no_watchers' : 'missing_recursive_repo_root_coverage',
+            }, 'Workspace status watchers running with timed refresh support only');
+        }
+        this.workspaceStatusTargets.set(targetKey, target);
+        return target;
+    }
+    async handleSubscribeWorkspaceStatusRequest(msg) {
+        const cwd = expandTilde(msg.cwd);
+        const remoteName = msg.remoteName?.trim() ? msg.remoteName.trim() : null;
+        const mode = msg.mode ?? 'passive';
+        if (remoteName) {
+            this.assertSafeRemoteName(remoteName);
+        }
+        this.removeWorkspaceStatusSubscription(msg.subscriptionId);
+        const target = await this.ensureWorkspaceStatusWatchTarget(cwd, remoteName);
+        target.subscriptions.set(msg.subscriptionId, mode);
+        this.workspaceStatusSubscriptions.set(msg.subscriptionId, {
+            targetKey: target.key,
+        });
+        this.updateWorkspaceStatusGitPolling(target);
+        this.updateWorkspaceStatusPrPolling(target);
+        const fullGit = this.workspaceStatusHasActiveSubscribers(target);
+        const includePr = fullGit;
+        const previousFingerprint = target.latestFingerprint;
+        const hadExistingSubscribers = target.subscriptions.size > 1;
+        const snapshot = target.latestPayload
+            && (!includePr || target.hasLoadedPullRequest)
+            && (!fullGit || target.latestPayloadHasFullGitData)
+            && !(fullGit && target.latestPayload.gitError)
+            ? target.latestPayload
+            : await this.computeWorkspaceStatusSnapshot(target, { includePr, fullGit });
+        const hasLoadedPullRequest = target.hasLoadedPullRequest || includePr || !snapshot.git.isGit;
+        target.latestPayload = snapshot;
+        target.hasLoadedPullRequest = hasLoadedPullRequest;
+        target.latestPayloadHasFullGitData = !snapshot.git.isGit || fullGit;
+        const nextFingerprint = this.workspaceStatusSnapshotFingerprint(snapshot);
+        target.latestFingerprint = nextFingerprint;
+        this.emit({
+            type: 'subscribe_workspace_status_response',
+            payload: {
+                subscriptionId: msg.subscriptionId,
+                ...snapshot,
+                requestId: msg.requestId,
+            },
+        });
+        if (hadExistingSubscribers && nextFingerprint !== previousFingerprint) {
+            this.emitWorkspaceStatusChanged(target, snapshot);
+        }
+        if (!fullGit && snapshot.git.isGit && !hasLoadedPullRequest) {
+            this.scheduleWorkspaceStatusTargetRefresh(target, {
+                includePr: true,
+                debounce: false,
+            });
+        }
+    }
+    handleUnsubscribeWorkspaceStatusRequest(msg) {
+        this.removeWorkspaceStatusSubscription(msg.subscriptionId);
+    }
+    scheduleWorkspaceStatusRefreshForCwd(cwd, options) {
+        const resolvedCwd = expandTilde(cwd);
+        for (const target of this.workspaceStatusTargets.values()) {
+            if (target.cwd !== resolvedCwd && target.diffCwd !== resolvedCwd) {
+                continue;
+            }
+            this.scheduleWorkspaceStatusTargetRefresh(target, {
+                includePr: options?.includePr,
+                debounce: false,
+            });
+        }
+    }
     normalizeCheckoutDiffCompare(compare) {
         if (compare.mode === 'uncommitted' || compare.mode === 'staged' || compare.mode === 'unstaged') {
             return { mode: compare.mode };
@@ -3121,11 +3601,12 @@ export class Session {
         const trimmedBaseRef = compare.baseRef?.trim();
         return trimmedBaseRef ? { mode: 'base', baseRef: trimmedBaseRef } : { mode: 'base' };
     }
-    buildCheckoutDiffTargetKey(cwd, compare) {
+    buildCheckoutDiffTargetKey(cwd, compare, detail) {
         return JSON.stringify([
             cwd,
             compare.mode,
             compare.mode === 'base' ? (compare.baseRef ?? '') : '',
+            detail,
         ]);
     }
     closeCheckoutDiffWatchTarget(target) {
@@ -3212,13 +3693,19 @@ export class Session {
     }
     async computeCheckoutDiffSnapshot(cwd, compare, options) {
         const diffCwd = options?.diffCwd ?? cwd;
+        const detail = options?.detail ?? 'full';
         try {
             const diffResult = await getCheckoutDiff(diffCwd, {
                 mode: compare.mode,
                 baseRef: compare.baseRef,
                 includeStructured: true,
             }, { junctionHome: this.junctionHome });
-            const files = [...(diffResult.structured ?? [])];
+            const files = [...(diffResult.structured ?? [])].map((file) => detail === 'summary'
+                ? {
+                    ...file,
+                    hunks: [],
+                }
+                : file);
             files.sort((a, b) => {
                 if (a.path === b.path)
                     return 0;
@@ -3248,6 +3735,7 @@ export class Session {
                 target.refreshQueued = false;
                 const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
                     diffCwd: target.diffCwd,
+                    detail: target.detail,
                 });
                 target.latestPayload = snapshot;
                 const fingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
@@ -3264,8 +3752,8 @@ export class Session {
             target.refreshPromise = null;
         }
     }
-    async ensureCheckoutDiffWatchTarget(cwd, compare) {
-        const targetKey = this.buildCheckoutDiffTargetKey(cwd, compare);
+    async ensureCheckoutDiffWatchTarget(cwd, compare, detail) {
+        const targetKey = this.buildCheckoutDiffTargetKey(cwd, compare, detail);
         const existing = this.checkoutDiffTargets.get(targetKey);
         if (existing) {
             return existing;
@@ -3276,6 +3764,7 @@ export class Session {
             cwd,
             diffCwd: watchRoot ?? cwd,
             compare,
+            detail,
             subscriptions: new Set(),
             watchers: [],
             fallbackRefreshInterval: null,
@@ -3352,8 +3841,9 @@ export class Session {
     async handleSubscribeCheckoutDiffRequest(msg) {
         const cwd = expandTilde(msg.cwd);
         const compare = this.normalizeCheckoutDiffCompare(msg.compare);
+        const detail = msg.detail ?? 'full';
         this.removeCheckoutDiffSubscription(msg.subscriptionId);
-        const target = await this.ensureCheckoutDiffWatchTarget(cwd, compare);
+        const target = await this.ensureCheckoutDiffWatchTarget(cwd, compare, detail);
         target.subscriptions.add(msg.subscriptionId);
         this.checkoutDiffSubscriptions.set(msg.subscriptionId, {
             targetKey: target.key,
@@ -3361,6 +3851,7 @@ export class Session {
         const snapshot = target.latestPayload ??
             (await this.computeCheckoutDiffSnapshot(cwd, compare, {
                 diffCwd: target.diffCwd,
+                detail: target.detail,
             }));
         target.latestPayload = snapshot;
         target.latestFingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
@@ -3400,6 +3891,7 @@ export class Session {
                 addAll: msg.addAll ?? true,
             });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd);
             this.emit({
                 type: 'checkout_commit_response',
                 payload: {
@@ -3463,6 +3955,7 @@ export class Session {
                 mode: msg.strategy === 'squash' ? 'squash' : 'merge',
             }, { junctionHome: this.junctionHome });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_merge_response',
                 payload: {
@@ -3503,6 +3996,7 @@ export class Session {
                 requireCleanTarget: msg.requireCleanTarget ?? true,
             });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_merge_from_base_response',
                 payload: {
@@ -3529,6 +4023,7 @@ export class Session {
         const { cwd, requestId } = msg;
         try {
             await pushCurrentBranch(cwd, { remoteName: msg.remoteName });
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_push_response',
                 payload: {
@@ -3569,6 +4064,7 @@ export class Session {
                 base: msg.baseRef,
                 remoteName: msg.remoteName,
             });
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_pr_create_response',
                 payload: {
@@ -3689,6 +4185,7 @@ export class Session {
                 method: msg.method ?? 'squash',
                 remoteName: msg.remoteName,
             });
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_pr_merge_response',
                 payload: {
@@ -4049,6 +4546,7 @@ export class Session {
                     root,
                     relativePath: requestedPath,
                     ref,
+                    detail: request.detail ?? 'full',
                 });
                 this.emit({
                     type: 'workspace_file_explorer_response',
@@ -4978,6 +5476,11 @@ export class Session {
         }
         this.checkoutDiffTargets.clear();
         this.checkoutDiffSubscriptions.clear();
+        for (const target of this.workspaceStatusTargets.values()) {
+            this.closeWorkspaceStatusWatchTarget(target);
+        }
+        this.workspaceStatusTargets.clear();
+        this.workspaceStatusSubscriptions.clear();
     }
     // ============================================================================
     // Terminal Handlers