@junctionpanel/server 0.1.53 → 0.1.55

package/dist/server/server/session.js

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
-import { existsSync, watch } from 'node:fs';
+import { existsSync, statSync, watch } from 'node:fs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { resolve, sep, basename, dirname, parse as parsePath } from 'path';
@@ -17,13 +17,13 @@ import { sanitizeTimelineItemForTransport, } from './tool-call-preview.js';
 import { toAgentPayload, resolveEffectiveThinkingOptionId, toStoredAgentPayload, } from './agent/agent-projections.js';
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from './agent/timeline-append.js';
 import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from './agent/timeline-projection.js';
-import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from './agent/agent-response-loop.js';
+import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, resolveStructuredGenerationPreferredProviderForCwd, resolveStructuredGenerationProviders, } from './agent/agent-response-loop.js';
 import { isValidAgentProvider, AGENT_PROVIDER_IDS } from './agent/provider-manifest.js';
 import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, isWorkspaceExplorerMissingPathError, } from './file-explorer/service.js';
 import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, attachInRepoWorktree, restoreInRepoWorktree, } from '../utils/worktree.js';
 import { readJunctionWorktreeMetadata } from '../utils/worktree-metadata.js';
 import { runAsyncWorktreeBootstrap } from './worktree-bootstrap.js';
-import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestFailureLogs, getPullRequestStatus, searchPullRequests, listGitRemotes, mergePullRequest, resolveBaseRefWithSource, } from '../utils/checkout-git.js';
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestFailureLogs, getPullRequestStatus, searchPullRequests, listGitRemotes, mergePullRequest, resolveMergeToBaseOperationCwd, resolveBaseRefWithSource, } from '../utils/checkout-git.js';
 import { getProjectIcon } from '../utils/project-icon.js';
 import { expandTilde } from '../utils/path.js';
 import { searchHomeDirectories, searchWorkspaceEntries, searchWorkspaceEntriesAtGitRef, searchGitRepositories, checkIsGitRepo, } from '../utils/directory-suggestions.js';
@@ -48,9 +48,14 @@ const READ_ONLY_GIT_ENV = {
 const DEFAULT_STORED_TIMELINE_FETCH_LIMIT = 200;
 const pendingAgentInitializations = new Map();
 const pendingAgentMessageExecutions = new Map();
+const sharedWorkspaceGitOperationStates = 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 +124,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();
@@ -127,6 +134,7 @@ export class Session {
         this.nextTerminalStreamId = 1;
         this.checkoutDiffSubscriptions = new Map();
         this.checkoutDiffTargets = new Map();
+        this.workspaceGitOperationStates = sharedWorkspaceGitOperationStates;
         const { clientId, userId, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, junctionHome, agentManager, agentStorage, createAgentMcpTransport, terminalManager, agentProviderRuntimeSettings, } = options;
         this.clientId = clientId;
         this.userId = userId;
@@ -303,7 +311,10 @@ export class Session {
             this.sessionLogger.error({ err: error, agentId: input.agentId }, `Failed to record user message for agent ${input.agentId}`);
         }
         const prompt = this.buildAgentPrompt(input.text, input.images);
-        const started = this.startAgentStream(input.agentId, prompt, input.runOptions);
+        const started = this.startAgentStream(input.agentId, prompt, {
+            ...input.runOptions,
+            ...(input.messageId ? { messageId: input.messageId } : {}),
+        });
         if (!started.ok) {
             throw new Error(started.error);
         }
@@ -863,6 +874,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;
@@ -2339,8 +2356,53 @@ export class Session {
         }
         return resolvedCandidate.startsWith(resolvedRoot + sep);
     }
-    async generateCommitMessage(cwd) {
-        const diff = await getCheckoutDiff(cwd, { mode: 'uncommitted', includeStructured: true }, { junctionHome: this.junctionHome });
+    async resolvePreferredStructuredProviderForCwd(cwd) {
+        const resolvedCwd = expandTilde(cwd);
+        const storedRecords = new Map((await this.agentStorage.list()).map((record) => [record.id, record]));
+        const liveCandidates = this.agentManager.listAgents().map((agent) => {
+            const storedRecord = storedRecords.get(agent.id);
+            return {
+                provider: agent.provider,
+                cwd: agent.cwd,
+                lastActivityAt: agent.lastUserMessageAt ?? agent.updatedAt,
+                updatedAt: agent.updatedAt,
+                archivedAt: storedRecord?.archivedAt ?? null,
+                internal: agent.internal ?? storedRecord?.internal ?? false,
+            };
+        });
+        const storedCandidates = Array.from(storedRecords.values()).map((record) => ({
+            provider: record.provider,
+            cwd: record.cwd,
+            lastActivityAt: record.lastActivityAt ?? record.lastUserMessageAt ?? record.updatedAt,
+            updatedAt: record.updatedAt,
+            archivedAt: record.archivedAt ?? null,
+            internal: record.internal ?? false,
+        }));
+        return resolveStructuredGenerationPreferredProviderForCwd({
+            cwd: resolvedCwd,
+            candidates: [...liveCandidates, ...storedCandidates],
+        });
+    }
+    async resolveStructuredHelperProviders(cwd, reason) {
+        let preferredProvider = null;
+        try {
+            preferredProvider = await this.resolvePreferredStructuredProviderForCwd(cwd);
+        }
+        catch (error) {
+            this.sessionLogger.warn({ err: error, cwd, reason }, 'Failed to resolve preferred provider for structured helper generation');
+        }
+        return {
+            preferredProvider,
+            providers: resolveStructuredGenerationProviders({
+                preferredProvider,
+                reason,
+                providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
+            }),
+        };
+    }
+    async generateCommitMessage(cwd, diffOverride) {
+        const diff = diffOverride ??
+            (await getCheckoutDiff(cwd, { mode: 'uncommitted', includeStructured: true }, { junctionHome: this.junctionHome }));
         const schema = z.object({
             message: z
                 .string()
@@ -2371,6 +2433,7 @@ export class Session {
             patch.length > 0 ? patch : '(No diff available)',
         ].join('\n');
         try {
+            const { preferredProvider, providers } = await this.resolveStructuredHelperProviders(cwd, 'commit');
             const result = await generateStructuredAgentResponseWithFallback({
                 manager: this.agentManager,
                 cwd,
@@ -2378,7 +2441,9 @@ export class Session {
                 schema,
                 schemaName: 'CommitMessage',
                 maxRetries: 2,
-                providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
+                providers,
+                preferredProvider,
+                reason: 'commit',
                 agentConfigOverrides: {
                     title: 'Commit generator',
                     internal: true,
@@ -2394,12 +2459,13 @@ export class Session {
             throw error;
         }
     }
-    async generatePullRequestText(cwd, baseRef) {
-        const diff = await getCheckoutDiff(cwd, {
-            mode: 'base',
-            baseRef,
-            includeStructured: true,
-        }, { junctionHome: this.junctionHome });
+    async generatePullRequestText(cwd, baseRef, diffOverride) {
+        const diff = diffOverride ??
+            (await getCheckoutDiff(cwd, {
+                mode: 'base',
+                baseRef,
+                includeStructured: true,
+            }, { junctionHome: this.junctionHome }));
         const schema = z.object({
             title: z.string().min(1).max(72),
             body: z.string().min(1),
@@ -2427,6 +2493,7 @@ export class Session {
             patch.length > 0 ? patch : '(No diff available)',
         ].join('\n');
         try {
+            const { preferredProvider, providers } = await this.resolveStructuredHelperProviders(cwd, 'pr');
             return await generateStructuredAgentResponseWithFallback({
                 manager: this.agentManager,
                 cwd,
@@ -2434,7 +2501,9 @@ export class Session {
                 schema,
                 schemaName: 'PullRequest',
                 maxRetries: 2,
-                providers: DEFAULT_STRUCTURED_GENERATION_PROVIDERS,
+                providers,
+                preferredProvider,
+                reason: 'pr',
                 agentConfigOverrides: {
                     title: 'PR generator',
                     internal: true,
@@ -2702,101 +2771,192 @@ 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 resolvedCwd = expandTilde(cwd);
+            const status = await this.runWorkspaceGitRead(resolvedCwd, () => getCheckoutStatus(resolvedCwd, { 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 +3274,365 @@ 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.resolveWorkspaceStatusPrRefreshIntervalMs(target);
+        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);
+    }
+    resolveWorkspaceStatusPrRefreshIntervalMs(target) {
+        if (this.workspaceStatusHasActiveSubscribers(target)) {
+            return WORKSPACE_STATUS_PR_ACTIVE_REFRESH_MS;
+        }
+        const pullRequest = target.latestPayload?.pullRequest;
+        const hasOpenPullRequest = pullRequest != null && !pullRequest.isMerged && pullRequest.state.toLowerCase() === 'open';
+        return hasOpenPullRequest
+            ? WORKSPACE_STATUS_PR_ACTIVE_REFRESH_MS
+            : WORKSPACE_STATUS_PR_PASSIVE_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;
+                this.updateWorkspaceStatusPrPolling(target);
+                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);
+        }
+        const watchSetup = this.startCheckoutWatchers({
+            repoWatchPath,
+            watchPaths,
+            onChange: () => {
+                this.scheduleWorkspaceStatusTargetRefresh(target);
+            },
+            recursiveUnavailableMessage: 'Workspace status recursive watch unavailable; using non-recursive fallback',
+            startFailedMessage: 'Failed to start workspace status watcher',
+            watcherErrorMessage: 'Workspace status watcher error',
+            context: { cwd, remoteName },
+        });
+        target.watchers = watchSetup.watchers;
+        if (target.watchers.length === 0 || !watchSetup.hasRecursiveRepoCoverage) {
+            const log = watchSetup.repoWatchPathMissing && watchSetup.failedWatcherCount === 0
+                ? this.sessionLogger.debug.bind(this.sessionLogger)
+                : this.sessionLogger.warn.bind(this.sessionLogger);
+            log({
+                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 +3640,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) {
@@ -3184,7 +3704,107 @@ export class Session {
             return null;
         }
     }
+    isExpectedMissingWatchPathError(error) {
+        if (!error || typeof error !== 'object') {
+            return false;
+        }
+        const code = 'code' in error && typeof error.code === 'string'
+            ? error.code
+            : null;
+        return code === 'ENOENT' || code === 'ENOTDIR' || code === 'EPERM';
+    }
+    isWatchPathMissing(watchPath) {
+        try {
+            statSync(watchPath);
+            return false;
+        }
+        catch (error) {
+            return this.isExpectedMissingWatchPathError(error);
+        }
+    }
+    startCheckoutWatchers(options) {
+        const watchers = [];
+        let hasRecursiveRepoCoverage = false;
+        let repoWatchPathMissing = false;
+        let failedWatcherCount = 0;
+        const allowRecursiveRepoWatch = process.platform !== 'linux';
+        for (const watchPath of options.watchPaths) {
+            const shouldTryRecursive = watchPath === options.repoWatchPath && allowRecursiveRepoWatch;
+            if (this.isWatchPathMissing(watchPath)) {
+                if (watchPath === options.repoWatchPath) {
+                    repoWatchPathMissing = true;
+                }
+                continue;
+            }
+            const createWatcher = (recursive) => watch(watchPath, { recursive }, () => {
+                options.onChange();
+            });
+            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, ...options.context }, options.recursiveUnavailableMessage);
+                    }
+                    catch (fallbackError) {
+                        if (this.isExpectedMissingWatchPathError(fallbackError)
+                            && this.isWatchPathMissing(watchPath)) {
+                            if (watchPath === options.repoWatchPath) {
+                                repoWatchPathMissing = true;
+                            }
+                            continue;
+                        }
+                        failedWatcherCount += 1;
+                        this.sessionLogger.warn({ err: fallbackError, watchPath, ...options.context }, options.startFailedMessage);
+                    }
+                }
+                else {
+                    if (this.isExpectedMissingWatchPathError(error) && this.isWatchPathMissing(watchPath)) {
+                        if (watchPath === options.repoWatchPath) {
+                            repoWatchPathMissing = true;
+                        }
+                        continue;
+                    }
+                    failedWatcherCount += 1;
+                    this.sessionLogger.warn({ err: error, watchPath, ...options.context }, options.startFailedMessage);
+                }
+            }
+            if (!watcher) {
+                continue;
+            }
+            watcher.on('error', (error) => {
+                if (this.isExpectedMissingWatchPathError(error) && this.isWatchPathMissing(watchPath)) {
+                    return;
+                }
+                this.sessionLogger.warn({ err: error, watchPath, ...options.context }, options.watcherErrorMessage);
+            });
+            watchers.push(watcher);
+            if (watchPath === options.repoWatchPath && watcherIsRecursive) {
+                hasRecursiveRepoCoverage = true;
+            }
+        }
+        return {
+            watchers,
+            hasRecursiveRepoCoverage,
+            repoWatchPathMissing,
+            failedWatcherCount,
+        };
+    }
     scheduleCheckoutDiffTargetRefresh(target) {
+        if (this.isWorkspaceGitWritePending(target.workspaceGitKey)) {
+            target.refreshQueuedAfterWrite = true;
+            return;
+        }
         if (target.debounceTimer) {
             clearTimeout(target.debounceTimer);
         }
@@ -3212,13 +3832,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, {
+            const diffResult = await this.runWorkspaceGitRead(diffCwd, () => getCheckoutDiff(diffCwd, {
                 mode: compare.mode,
                 baseRef: compare.baseRef,
                 includeStructured: true,
-            }, { junctionHome: this.junctionHome });
-            const files = [...(diffResult.structured ?? [])];
+            }, { junctionHome: this.junctionHome }));
+            const files = [...(diffResult.structured ?? [])].map((file) => detail === 'summary'
+                ? {
+                    ...file,
+                    hunks: [],
+                }
+                : file);
             files.sort((a, b) => {
                 if (a.path === b.path)
                     return 0;
@@ -3248,6 +3874,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,24 +3891,28 @@ 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;
         }
         const watchRoot = await this.resolveCheckoutWatchRoot(cwd);
+        const workspaceGitKey = watchRoot ?? cwd;
         const target = {
             key: targetKey,
             cwd,
             diffCwd: watchRoot ?? cwd,
+            workspaceGitKey,
             compare,
+            detail,
             subscriptions: new Set(),
             watchers: [],
             fallbackRefreshInterval: null,
             debounceTimer: null,
             refreshPromise: null,
             refreshQueued: false,
+            refreshQueuedAfterWrite: false,
             latestPayload: null,
             latestFingerprint: null,
         };
@@ -3291,55 +3922,27 @@ export class Session {
         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 }, () => {
+        const watchSetup = this.startCheckoutWatchers({
+            repoWatchPath,
+            watchPaths,
+            onChange: () => {
                 this.scheduleCheckoutDiffTargetRefresh(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, compare }, 'Checkout diff recursive watch unavailable; using non-recursive fallback');
-                    }
-                    catch (fallbackError) {
-                        this.sessionLogger.warn({ err: fallbackError, watchPath, cwd, compare }, 'Failed to start checkout diff watcher');
-                    }
-                }
-                else {
-                    this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, 'Failed to start checkout diff watcher');
-                }
-            }
-            if (!watcher) {
-                continue;
-            }
-            watcher.on('error', (error) => {
-                this.sessionLogger.warn({ err: error, watchPath, cwd, compare }, 'Checkout diff watcher error');
-            });
-            target.watchers.push(watcher);
-            if (watchPath === repoWatchPath && watcherIsRecursive) {
-                hasRecursiveRepoCoverage = true;
-            }
-        }
-        const missingRepoCoverage = !hasRecursiveRepoCoverage;
+            },
+            recursiveUnavailableMessage: 'Checkout diff recursive watch unavailable; using non-recursive fallback',
+            startFailedMessage: 'Failed to start checkout diff watcher',
+            watcherErrorMessage: 'Checkout diff watcher error',
+            context: { cwd, compare },
+        });
+        target.watchers = watchSetup.watchers;
+        const missingRepoCoverage = !watchSetup.hasRecursiveRepoCoverage;
         if (target.watchers.length === 0 || missingRepoCoverage) {
             target.fallbackRefreshInterval = setInterval(() => {
                 this.scheduleCheckoutDiffTargetRefresh(target);
             }, CHECKOUT_DIFF_FALLBACK_REFRESH_MS);
-            this.sessionLogger.warn({
+            const log = watchSetup.repoWatchPathMissing && watchSetup.failedWatcherCount === 0
+                ? this.sessionLogger.debug.bind(this.sessionLogger)
+                : this.sessionLogger.warn.bind(this.sessionLogger);
+            log({
                 cwd,
                 compare,
                 intervalMs: CHECKOUT_DIFF_FALLBACK_REFRESH_MS,
@@ -3352,18 +3955,33 @@ 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,
         });
-        const snapshot = target.latestPayload ??
-            (await this.computeCheckoutDiffSnapshot(cwd, compare, {
+        if (target.refreshPromise) {
+            await target.refreshPromise;
+        }
+        const canReuseLatestPayload = target.latestPayload !== null &&
+            !target.refreshQueuedAfterWrite &&
+            !this.isWorkspaceGitWritePending(target.workspaceGitKey);
+        const shouldPreserveQueuedFingerprint = !canReuseLatestPayload && target.refreshQueuedAfterWrite;
+        const snapshot = canReuseLatestPayload
+            ? target.latestPayload
+            : await this.computeCheckoutDiffSnapshot(cwd, compare, {
                 diffCwd: target.diffCwd,
-            }));
+                detail: target.detail,
+            });
+        if (!snapshot) {
+            throw new Error('Checkout diff snapshot was unavailable');
+        }
         target.latestPayload = snapshot;
-        target.latestFingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
+        if (!shouldPreserveQueuedFingerprint) {
+            target.latestFingerprint = this.checkoutDiffSnapshotFingerprint(snapshot);
+        }
         this.emit({
             type: 'subscribe_checkout_diff_response',
             payload: {
@@ -3385,21 +4003,106 @@ export class Session {
             this.scheduleCheckoutDiffTargetRefresh(target);
         }
     }
+    getWorkspaceGitOperationState(workspaceGitKey) {
+        const existing = this.workspaceGitOperationStates.get(workspaceGitKey);
+        if (existing) {
+            return existing;
+        }
+        const created = {
+            writeBarrier: Promise.resolve(),
+            pendingWrites: 0,
+            activeReaders: 0,
+            readerDrain: Promise.resolve(),
+            resolveReaderDrain: null,
+        };
+        this.workspaceGitOperationStates.set(workspaceGitKey, created);
+        return created;
+    }
+    isWorkspaceGitWritePending(workspaceGitKey) {
+        return (this.workspaceGitOperationStates.get(workspaceGitKey)?.pendingWrites ?? 0) > 0;
+    }
+    async resolveWorkspaceGitOperationKey(cwd) {
+        const resolvedCwd = expandTilde(cwd);
+        return (await this.resolveCheckoutWatchRoot(resolvedCwd)) ?? resolvedCwd;
+    }
+    flushQueuedCheckoutDiffRefreshesForWorkspace(workspaceGitKey) {
+        for (const target of this.checkoutDiffTargets.values()) {
+            if (target.workspaceGitKey !== workspaceGitKey || !target.refreshQueuedAfterWrite) {
+                continue;
+            }
+            target.refreshQueuedAfterWrite = false;
+            this.scheduleCheckoutDiffTargetRefresh(target);
+        }
+    }
+    async runWorkspaceGitRead(cwd, operation) {
+        const workspaceGitKey = await this.resolveWorkspaceGitOperationKey(cwd);
+        const state = this.getWorkspaceGitOperationState(workspaceGitKey);
+        while (state.pendingWrites > 0) {
+            await state.writeBarrier;
+        }
+        state.activeReaders += 1;
+        if (state.activeReaders === 1) {
+            state.readerDrain = new Promise((resolve) => {
+                state.resolveReaderDrain = resolve;
+            });
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            state.activeReaders = Math.max(0, state.activeReaders - 1);
+            if (state.activeReaders === 0) {
+                state.resolveReaderDrain?.();
+                state.resolveReaderDrain = null;
+                state.readerDrain = Promise.resolve();
+            }
+        }
+    }
+    async runWorkspaceGitWrite(cwd, operation) {
+        const workspaceGitKey = await this.resolveWorkspaceGitOperationKey(cwd);
+        const state = this.getWorkspaceGitOperationState(workspaceGitKey);
+        const previousBarrier = state.writeBarrier;
+        let releaseCurrentBarrier = () => { };
+        const currentBarrier = new Promise((resolve) => {
+            releaseCurrentBarrier = resolve;
+        });
+        state.pendingWrites += 1;
+        state.writeBarrier = previousBarrier.then(() => currentBarrier);
+        try {
+            await previousBarrier;
+            while (state.activeReaders > 0) {
+                await state.readerDrain;
+            }
+            return await operation();
+        }
+        finally {
+            state.pendingWrites = Math.max(0, state.pendingWrites - 1);
+            releaseCurrentBarrier();
+            if (state.pendingWrites === 0) {
+                state.writeBarrier = Promise.resolve();
+                this.flushQueuedCheckoutDiffRefreshesForWorkspace(workspaceGitKey);
+            }
+        }
+    }
     async handleCheckoutCommitRequest(msg) {
         const { cwd, requestId } = msg;
         try {
             let message = msg.message?.trim() ?? '';
             if (!message) {
-                message = await this.generateCommitMessage(cwd);
+                const diff = await this.runWorkspaceGitRead(cwd, () => getCheckoutDiff(cwd, { mode: 'uncommitted', includeStructured: true }, { junctionHome: this.junctionHome }));
+                message = await this.generateCommitMessage(cwd, diff);
             }
             if (!message) {
                 throw new Error('Commit message is required');
             }
-            await commitChanges(cwd, {
-                message,
-                addAll: msg.addAll ?? true,
+            await this.runWorkspaceGitWrite(cwd, async () => {
+                await commitChanges(cwd, {
+                    message,
+                    addAll: msg.addAll ?? true,
+                });
+                this.scheduleCheckoutDiffRefreshForCwd(cwd);
             });
-            this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd);
             this.emit({
                 type: 'checkout_commit_response',
                 payload: {
@@ -3425,44 +4128,54 @@ export class Session {
     async handleCheckoutMergeRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const status = await getCheckoutStatus(cwd, { junctionHome: this.junctionHome });
-            if (!status.isGit) {
-                try {
-                    await execAsync('git rev-parse --is-inside-work-tree', {
+            const mergeOperationCwd = await resolveMergeToBaseOperationCwd(cwd, { baseRef: msg.baseRef }, { junctionHome: this.junctionHome });
+            await this.runWorkspaceGitWrite(mergeOperationCwd, async () => {
+                const status = await getCheckoutStatus(cwd, { junctionHome: this.junctionHome });
+                if (!status.isGit) {
+                    try {
+                        await execAsync('git rev-parse --is-inside-work-tree', {
+                            cwd,
+                            env: READ_ONLY_GIT_ENV,
+                        });
+                    }
+                    catch (error) {
+                        const details = typeof error?.stderr === 'string'
+                            ? String(error.stderr).trim()
+                            : error instanceof Error
+                                ? error.message
+                                : String(error);
+                        throw new Error(`Not a git repository: ${cwd}\n${details}`.trim());
+                    }
+                }
+                if (msg.requireCleanTarget) {
+                    const { stdout } = await execAsync('git status --porcelain', {
                         cwd,
                         env: READ_ONLY_GIT_ENV,
                     });
+                    if (stdout.trim().length > 0) {
+                        throw new Error('Working directory has uncommitted changes.');
+                    }
                 }
-                catch (error) {
-                    const details = typeof error?.stderr === 'string'
-                        ? String(error.stderr).trim()
-                        : error instanceof Error
-                            ? error.message
-                            : String(error);
-                    throw new Error(`Not a git repository: ${cwd}\n${details}`.trim());
+                let baseRef = msg.baseRef ?? (status.isGit ? status.baseRef : null);
+                if (!baseRef) {
+                    throw new Error('Base branch is required for merge');
                 }
-            }
-            if (msg.requireCleanTarget) {
-                const { stdout } = await execAsync('git status --porcelain', {
-                    cwd,
-                    env: READ_ONLY_GIT_ENV,
-                });
-                if (stdout.trim().length > 0) {
-                    throw new Error('Working directory has uncommitted changes.');
+                if (baseRef.startsWith('origin/')) {
+                    baseRef = baseRef.slice('origin/'.length);
                 }
+                await mergeToBase(cwd, {
+                    baseRef,
+                    mode: msg.strategy === 'squash' ? 'squash' : 'merge',
+                }, { junctionHome: this.junctionHome });
+                this.scheduleCheckoutDiffRefreshForCwd(cwd);
+                if (resolve(mergeOperationCwd) !== resolve(cwd)) {
+                    this.scheduleCheckoutDiffRefreshForCwd(mergeOperationCwd);
+                }
+            });
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
+            if (resolve(mergeOperationCwd) !== resolve(cwd)) {
+                this.scheduleWorkspaceStatusRefreshForCwd(mergeOperationCwd, { includePr: true });
             }
-            let baseRef = msg.baseRef ?? (status.isGit ? status.baseRef : null);
-            if (!baseRef) {
-                throw new Error('Base branch is required for merge');
-            }
-            if (baseRef.startsWith('origin/')) {
-                baseRef = baseRef.slice('origin/'.length);
-            }
-            await mergeToBase(cwd, {
-                baseRef,
-                mode: msg.strategy === 'squash' ? 'squash' : 'merge',
-            }, { junctionHome: this.junctionHome });
-            this.scheduleCheckoutDiffRefreshForCwd(cwd);
             this.emit({
                 type: 'checkout_merge_response',
                 payload: {
@@ -3488,21 +4201,24 @@ export class Session {
     async handleCheckoutMergeFromBaseRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            if (msg.requireCleanTarget ?? true) {
-                const { stdout } = await execAsync('git status --porcelain', {
-                    cwd,
-                    env: READ_ONLY_GIT_ENV,
-                });
-                if (stdout.trim().length > 0) {
-                    throw new Error('Working directory has uncommitted changes.');
+            await this.runWorkspaceGitWrite(cwd, async () => {
+                if (msg.requireCleanTarget ?? true) {
+                    const { stdout } = await execAsync('git status --porcelain', {
+                        cwd,
+                        env: READ_ONLY_GIT_ENV,
+                    });
+                    if (stdout.trim().length > 0) {
+                        throw new Error('Working directory has uncommitted changes.');
+                    }
                 }
-            }
-            await mergeFromBase(cwd, {
-                baseRef: msg.baseRef,
-                remoteName: msg.remoteName,
-                requireCleanTarget: msg.requireCleanTarget ?? true,
+                await mergeFromBase(cwd, {
+                    baseRef: msg.baseRef,
+                    remoteName: msg.remoteName,
+                    requireCleanTarget: msg.requireCleanTarget ?? true,
+                });
+                this.scheduleCheckoutDiffRefreshForCwd(cwd);
             });
-            this.scheduleCheckoutDiffRefreshForCwd(cwd);
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_merge_from_base_response',
                 payload: {
@@ -3528,7 +4244,8 @@ export class Session {
     async handleCheckoutPushRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            await pushCurrentBranch(cwd, { remoteName: msg.remoteName });
+            await this.runWorkspaceGitWrite(cwd, () => pushCurrentBranch(cwd, { remoteName: msg.remoteName }));
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_push_response',
                 payload: {
@@ -3557,18 +4274,24 @@ export class Session {
             let title = msg.title?.trim() ?? '';
             let body = msg.body?.trim() ?? '';
             if (!title || !body) {
-                const generated = await this.generatePullRequestText(cwd, msg.baseRef);
+                const diff = await this.runWorkspaceGitRead(cwd, () => getCheckoutDiff(cwd, {
+                    mode: 'base',
+                    baseRef: msg.baseRef,
+                    includeStructured: true,
+                }, { junctionHome: this.junctionHome }));
+                const generated = await this.generatePullRequestText(cwd, msg.baseRef, diff);
                 if (!title)
                     title = generated.title;
                 if (!body)
                     body = generated.body;
             }
-            const result = await createPullRequest(cwd, {
+            const result = await this.runWorkspaceGitWrite(cwd, () => createPullRequest(cwd, {
                 title,
                 body,
                 base: msg.baseRef,
                 remoteName: msg.remoteName,
-            });
+            }));
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_pr_create_response',
                 payload: {
@@ -3625,11 +4348,11 @@ export class Session {
         const cwd = expandTilde(msg.cwd);
         const { requestId } = msg;
         try {
-            const result = await searchPullRequests(cwd, {
+            const result = await this.runWorkspaceGitRead(cwd, () => searchPullRequests(cwd, {
                 query: msg.query,
                 limit: msg.limit,
                 remoteName: msg.remoteName,
-            });
+            }));
             this.emit({
                 type: 'checkout_pr_search_response',
                 payload: {
@@ -3657,7 +4380,7 @@ export class Session {
     async handleCheckoutPrFailureLogsRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const result = await getPullRequestFailureLogs(cwd, { remoteName: msg.remoteName });
+            const result = await this.runWorkspaceGitRead(cwd, () => getPullRequestFailureLogs(cwd, { remoteName: msg.remoteName }));
             this.emit({
                 type: 'checkout_pr_failure_logs_response',
                 payload: {
@@ -3689,6 +4412,7 @@ export class Session {
                 method: msg.method ?? 'squash',
                 remoteName: msg.remoteName,
             });
+            this.scheduleWorkspaceStatusRefreshForCwd(cwd, { includePr: true });
             this.emit({
                 type: 'checkout_pr_merge_response',
                 payload: {
@@ -4039,8 +4763,8 @@ export class Session {
      */
     async handleWorkspaceFileExplorerRequest(request) {
         const { cwd, path: requestedPath = '.', mode, requestId, ref } = request;
+        const root = expandTilde(cwd);
         try {
-            const root = expandTilde(cwd);
             if (ref) {
                 this.assertSafeGitRef(ref, 'workspace file ref');
             }
@@ -4049,6 +4773,7 @@ export class Session {
                     root,
                     relativePath: requestedPath,
                     ref,
+                    detail: request.detail ?? 'full',
                 });
                 this.emit({
                     type: 'workspace_file_explorer_response',
@@ -4086,6 +4811,25 @@ export class Session {
             }
         }
         catch (error) {
+            if (mode === 'file'
+                && request.allowMissing
+                && isWorkspaceExplorerMissingPathError(error)
+                && (ref != null || existsSync(root))) {
+                this.emit({
+                    type: 'workspace_file_explorer_response',
+                    payload: {
+                        cwd,
+                        path: requestedPath,
+                        ref: ref ?? null,
+                        mode,
+                        directory: null,
+                        file: null,
+                        error: null,
+                        requestId,
+                    },
+                });
+                return;
+            }
             const log = isWorkspaceExplorerMissingPathError(error)
                 ? this.sessionLogger.debug.bind(this.sessionLogger)
                 : this.sessionLogger.error.bind(this.sessionLogger);
@@ -4978,6 +5722,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