@junctionpanel/server 0.1.54 → 0.1.56

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,6 +48,7 @@ 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;
@@ -133,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;
@@ -309,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);
         }
@@ -2351,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()
@@ -2383,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,
@@ -2390,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,
@@ -2406,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),
@@ -2439,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,
@@ -2446,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,
@@ -2884,7 +2941,8 @@ export class Session {
     async handleCheckoutStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const status = await getCheckoutStatus(expandTilde(cwd), { junctionHome: this.junctionHome });
+            const resolvedCwd = expandTilde(cwd);
+            const status = await this.runWorkspaceGitRead(resolvedCwd, () => getCheckoutStatus(resolvedCwd, { junctionHome: this.junctionHome }));
             this.emit({
                 type: 'checkout_status_response',
                 payload: {
@@ -3273,9 +3331,7 @@ export class Session {
         if (target.subscriptions.size === 0) {
             return;
         }
-        const intervalMs = this.workspaceStatusHasActiveSubscribers(target)
-            ? WORKSPACE_STATUS_PR_ACTIVE_REFRESH_MS
-            : WORKSPACE_STATUS_PR_PASSIVE_REFRESH_MS;
+        const intervalMs = this.resolveWorkspaceStatusPrRefreshIntervalMs(target);
         target.prRefreshInterval = setInterval(() => {
             this.scheduleWorkspaceStatusTargetRefresh(target, {
                 includePr: true,
@@ -3298,6 +3354,11 @@ export class Session {
             });
         }, WORKSPACE_STATUS_GIT_REFRESH_MS);
     }
+    resolveWorkspaceStatusPrRefreshIntervalMs(target) {
+        return this.workspaceStatusHasActiveSubscribers(target)
+            ? WORKSPACE_STATUS_PR_ACTIVE_REFRESH_MS
+            : WORKSPACE_STATUS_PR_PASSIVE_REFRESH_MS;
+    }
     removeWorkspaceStatusSubscription(subscriptionId) {
         const subscription = this.workspaceStatusSubscriptions.get(subscriptionId);
         if (!subscription) {
@@ -3432,6 +3493,7 @@ export class Session {
                         || includePr
                         || (previousHasLoadedPullRequest && !gitIdentityChanged);
                 target.latestPayloadHasFullGitData = !snapshot.git.isGit || fullGit;
+                this.updateWorkspaceStatusPrPolling(target);
                 const fingerprint = this.workspaceStatusSnapshotFingerprint(snapshot);
                 if (fingerprint !== target.latestFingerprint) {
                     target.latestFingerprint = fingerprint;
@@ -3477,51 +3539,23 @@ 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.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({
+            },
+            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',
@@ -3665,7 +3699,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);
         }
@@ -3695,11 +3829,11 @@ export class Session {
         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 });
+            }, { junctionHome: this.junctionHome }));
             const files = [...(diffResult.structured ?? [])].map((file) => detail === 'summary'
                 ? {
                     ...file,
@@ -3759,10 +3893,12 @@ export class Session {
             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(),
@@ -3771,6 +3907,7 @@ export class Session {
             debounceTimer: null,
             refreshPromise: null,
             refreshQueued: false,
+            refreshQueuedAfterWrite: false,
             latestPayload: null,
             latestFingerprint: null,
         };
@@ -3780,55 +3917,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,
@@ -3848,13 +3957,26 @@ export class Session {
         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: {
@@ -3876,21 +3998,105 @@ 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',
@@ -3917,45 +4123,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);
                 }
-            }
-            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);
+                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 });
+            }
             this.emit({
                 type: 'checkout_merge_response',
                 payload: {
@@ -3981,21 +4196,23 @@ 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',
@@ -4022,7 +4239,7 @@ 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',
@@ -4052,18 +4269,23 @@ 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',
@@ -4121,11 +4343,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: {
@@ -4153,7 +4375,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: {
@@ -4536,8 +4758,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');
             }
@@ -4584,6 +4806,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);