@junctionpanel/server 0.1.28 → 0.1.31

package/dist/server/server/session.js

@@ -1,15 +1,16 @@
 import { v4 as uuidv4 } from 'uuid';
-import { watch } from 'node:fs';
+import { existsSync, watch } from 'node:fs';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { resolve, sep, basename, dirname } from 'path';
-import { homedir } from 'node:os';
+import { resolve, sep, basename, dirname, parse as parsePath } from 'path';
+import { homedir, hostname } from 'node:os';
 import { z } from 'zod';
 import { serializeAgentStreamEvent, } from './messages.js';
 import { BinaryMuxChannel, TerminalBinaryFlags, TerminalBinaryMessageType, } from '../shared/binary-mux.js';
 import { buildConfigOverrides, buildSessionConfig, extractTimestamps, extractTimelineSnapshot, } from './persistence-hooks.js';
 import { experimental_createMCPClient } from 'ai';
 import { buildProviderRegistry } from './agent/provider-registry.js';
+import { applyProviderEnv, } from './agent/provider-launch-config.js';
 import { scheduleAgentMetadataGeneration } from './agent/agent-metadata-generator.js';
 import { resolveEffectiveThinkingOptionId, toAgentPayload } from './agent/agent-projections.js';
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from './agent/timeline-append.js';
@@ -20,14 +21,18 @@ import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from
 import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, 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, mergePullRequest, resolveBaseRef, } from '../utils/checkout-git.js';
+import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestFailureLogs, getPullRequestStatus, listGitRemotes, mergePullRequest, resolveBaseRef, } from '../utils/checkout-git.js';
 import { getProjectIcon } from '../utils/project-icon.js';
 import { expandTilde } from '../utils/path.js';
-import { searchHomeDirectories, searchWorkspaceEntries, searchGitRepositories, checkIsGitRepo } from '../utils/directory-suggestions.js';
+import { searchHomeDirectories, searchWorkspaceEntries, searchWorkspaceEntriesAtGitRef, searchGitRepositories, checkIsGitRepo, } from '../utils/directory-suggestions.js';
 import { cloneRepository } from '../utils/git-clone.js';
 import { initRepository } from '../utils/git-init.js';
 import { resolveClientMessageId } from './client-message-id.js';
 import { deriveProjectGroupingKey, deriveProjectGroupingName } from '../shared/project-grouping.js';
+import { resolveDaemonVersion } from './daemon-version.js';
+import { runDaemonDoctor } from './daemon-doctor.js';
+import { MANAGED_DAEMON_PROVIDERS, autoRouteProviderExecutable, loadDaemonProviderSettings, saveDaemonProviderExecutablePath, } from './daemon-provider-settings.js';
+import { loadPersistedConfig } from './persisted-config.js';
 const execAsync = promisify(exec);
 const READ_ONLY_GIT_ENV = {
     ...process.env,
@@ -50,6 +55,7 @@ class SessionRequestError extends Error {
     }
 }
 const SAFE_GIT_REF_PATTERN = /^[A-Za-z0-9._\/-]+$/;
+const SAFE_GIT_REMOTE_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
 function coerceAgentProvider(logger, value, agentId) {
     if (isValidAgentProvider(value)) {
         return value;
@@ -77,6 +83,19 @@ function toAgentPersistenceHandle(logger, handle) {
         metadata: handle.metadata,
     };
 }
+function normalizeAgentRunOptions(runOptions) {
+    if (!runOptions) {
+        return undefined;
+    }
+    return {
+        ...(runOptions.outputSchema !== undefined ? { outputSchema: runOptions.outputSchema } : {}),
+        ...(runOptions.resumeFrom ? { resumeFrom: runOptions.resumeFrom } : {}),
+        ...(runOptions.maxThinkingTokens !== undefined
+            ? { maxThinkingTokens: runOptions.maxThinkingTokens }
+            : {}),
+        ...(runOptions.extra ? { extra: runOptions.extra } : {}),
+    };
+}
 /**
  * Session represents a single connected client session.
  * It owns all state management, orchestration logic, and message processing.
@@ -800,9 +819,15 @@ export class Session {
                 case 'branch_suggestions_request':
                     await this.handleBranchSuggestionsRequest(msg);
                     break;
+                case 'git_remotes_request':
+                    await this.handleGitRemotesRequest(msg);
+                    break;
                 case 'directory_suggestions_request':
                     await this.handleDirectorySuggestionsRequest(msg);
                     break;
+                case 'workspace_file_suggestions_request':
+                    await this.handleWorkspaceFileSuggestionsRequest(msg);
+                    break;
                 case 'git_clone_request':
                     await this.handleGitCloneRequest(msg);
                     break;
@@ -863,6 +888,18 @@ export class Session {
                 case 'list_available_providers_request':
                     await this.handleListAvailableProvidersRequest(msg);
                     break;
+                case 'run_daemon_doctor_request':
+                    await this.handleRunDaemonDoctorRequest(msg);
+                    break;
+                case 'get_daemon_provider_settings_request':
+                    await this.handleGetDaemonProviderSettingsRequest(msg);
+                    break;
+                case 'update_daemon_provider_settings_request':
+                    await this.handleUpdateDaemonProviderSettingsRequest(msg);
+                    break;
+                case 'auto_route_provider_request':
+                    await this.handleAutoRouteProviderRequest(msg);
+                    break;
                 case 'clear_agent_attention':
                     await this.handleClearAgentAttention(msg.agentId);
                     break;
@@ -1150,19 +1187,43 @@ export class Session {
         if (!record) {
             throw new Error(`Agent not found: ${agentId}`);
         }
+        const allRecords = await this.agentStorage.list();
+        const siblingRecords = record.archivedWorktree?.cleanupState === 'deleted' && record.archivedWorktree
+            ? allRecords.filter((candidate) => {
+                if (candidate.id === record.id || !candidate.archivedAt) {
+                    return false;
+                }
+                return candidate.cwd === record.cwd;
+            })
+            : [];
         let nextRecord = {
             ...record,
             archivedAt: null,
         };
         let restoredWorktree = null;
         if (record.archivedWorktree?.cleanupState === 'deleted') {
-            restoredWorktree = await restoreInRepoWorktree({
-                repoRoot: record.archivedWorktree.repoRoot,
-                baseBranch: record.archivedWorktree.baseBranch,
-                branchName: record.archivedWorktree.branchName,
-                worktreeSlug: record.archivedWorktree.worktreeSlug,
-                runSetup: false,
-            });
+            try {
+                restoredWorktree = await restoreInRepoWorktree({
+                    repoRoot: record.archivedWorktree.repoRoot,
+                    baseBranch: record.archivedWorktree.baseBranch,
+                    branchName: record.archivedWorktree.branchName,
+                    worktreeSlug: record.archivedWorktree.worktreeSlug,
+                    runSetup: false,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const restoredPath = record.archivedWorktree.originalCwd;
+                if (!message.includes('Worktree path already exists') || !existsSync(restoredPath)) {
+                    throw error;
+                }
+                restoredWorktree = {
+                    branchName: record.archivedWorktree.branchName,
+                    worktreePath: restoredPath,
+                    baseBranch: record.archivedWorktree.baseBranch,
+                    workspaceName: basename(restoredPath),
+                };
+            }
             nextRecord = {
                 ...nextRecord,
                 cwd: restoredWorktree.worktreePath,
@@ -1174,13 +1235,34 @@ export class Session {
                 },
             };
         }
-        await this.agentStorage.upsert(nextRecord);
-        const liveAgent = this.agentManager.getAgent(agentId);
-        if (liveAgent) {
-            this.agentManager.notifyAgentState(agentId);
-        }
-        else {
-            await this.forwardStoredAgentRecordUpdate(nextRecord);
+        const recordsToRestore = [record, ...siblingRecords].map((candidate) => {
+            const nextArchivedWorktree = restoredWorktree && candidate.archivedWorktree
+                ? {
+                    ...candidate.archivedWorktree,
+                    originalCwd: restoredWorktree.worktreePath,
+                    cleanupState: 'active',
+                    cleanedUpAt: null,
+                }
+                : candidate.archivedWorktree;
+            return {
+                ...candidate,
+                archivedAt: null,
+                cwd: restoredWorktree ? restoredWorktree.worktreePath : candidate.cwd,
+                archivedWorktree: nextArchivedWorktree,
+            };
+        });
+        for (const restoredRecord of recordsToRestore) {
+            await this.agentStorage.upsert(restoredRecord);
+            const liveAgent = this.agentManager.getAgent(restoredRecord.id);
+            if (liveAgent) {
+                this.agentManager.notifyAgentState(restoredRecord.id);
+            }
+            else {
+                await this.forwardStoredAgentRecordUpdate(restoredRecord);
+            }
+            if (restoredRecord.id === agentId) {
+                nextRecord = restoredRecord;
+            }
         }
         this.emit({
             type: 'agent_unarchived',
@@ -1363,7 +1445,7 @@ export class Session {
      * Handle create agent request
      */
     async handleCreateAgentRequest(msg) {
-        const { config, worktreeName, requestId, initialPrompt, clientMessageId, outputSchema, git, bootstrapSetupOverride, images, labels, } = msg;
+        const { config, worktreeName, requestId, initialPrompt, clientMessageId, outputSchema, initialRunOptions, git, bootstrapSetupOverride, generalPreferencesApplied, images, labels, } = msg;
         this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ''}`);
         try {
             const { sessionConfig, worktreeConfig, autoWorkspaceName } = await this.buildAgentSessionConfig(config, git, worktreeName, labels);
@@ -1387,21 +1469,27 @@ export class Session {
                     },
                 });
             }
-            const trimmedPrompt = initialPrompt?.trim();
+            const trimmedPrompt = initialPrompt?.trim() ?? '';
+            const hasInitialMessage = trimmedPrompt.length > 0 || Boolean(images?.length);
             const runInitialPrompt = async () => {
-                if (!trimmedPrompt) {
+                if (!hasInitialMessage) {
                     return;
                 }
-                scheduleAgentMetadataGeneration({
-                    agentManager: this.agentManager,
-                    agentId: snapshot.id,
-                    cwd: snapshot.cwd,
-                    initialPrompt: trimmedPrompt,
-                    explicitTitle: snapshot.config.title,
-                    junctionHome: this.junctionHome,
-                    logger: this.sessionLogger,
-                });
-                await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, resolveClientMessageId(clientMessageId), images, outputSchema ? { outputSchema } : undefined);
+                if (trimmedPrompt.length > 0) {
+                    scheduleAgentMetadataGeneration({
+                        agentManager: this.agentManager,
+                        agentId: snapshot.id,
+                        cwd: snapshot.cwd,
+                        initialPrompt: trimmedPrompt,
+                        explicitTitle: snapshot.config.title,
+                        junctionHome: this.junctionHome,
+                        logger: this.sessionLogger,
+                    });
+                }
+                await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, resolveClientMessageId(clientMessageId), images, normalizeAgentRunOptions({
+                    ...(outputSchema ? { outputSchema } : {}),
+                    ...(initialRunOptions ?? {}),
+                }));
             };
             const handleInitialPromptError = (promptError) => {
                 this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
@@ -1415,7 +1503,7 @@ export class Session {
                     },
                 });
             };
-            if (trimmedPrompt && !worktreeConfig) {
+            if (hasInitialMessage && !worktreeConfig) {
                 void runInitialPrompt().catch(handleInitialPromptError);
             }
             if (worktreeConfig) {
@@ -1423,6 +1511,7 @@ export class Session {
                     agentId: snapshot.id,
                     worktree: worktreeConfig,
                     setupOverride: bootstrapSetupOverride,
+                    generalPreferencesApplied,
                     terminalManager: this.terminalManager,
                     appendTimelineItem: (item) => appendTimelineItemIfAgentKnown({
                         agentManager: this.agentManager,
@@ -1435,7 +1524,7 @@ export class Session {
                         item,
                     }),
                     onSetupSettled: async (result) => {
-                        if (!trimmedPrompt || result.setupStatus === 'failed') {
+                        if (!hasInitialMessage || result.setupStatus === 'failed') {
                             return;
                         }
                         await runInitialPrompt().catch(handleInitialPromptError);
@@ -1587,7 +1676,7 @@ export class Session {
             this.handleAgentRunError(agentId, error, 'Failed to cancel running agent on request');
         }
     }
-    async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, _labels) {
+    async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, labels) {
         const cwd = expandTilde(config.cwd);
         const normalized = this.normalizeGitOptions(gitOptions, legacyWorktreeName);
         let repoRoot;
@@ -1608,7 +1697,26 @@ export class Session {
         catch {
             throw new Error('Selected project must be a git repository. Junction always creates a new worktree in .junction/.');
         }
-        const baseBranch = normalized?.baseBranch ?? (await resolveBaseRef(repoRoot));
+        if (!normalized) {
+            const ownership = await isJunctionOwnedWorktreeCwd(cwd, {
+                junctionHome: this.junctionHome,
+            });
+            if (ownership.allowed) {
+                const resolvedWorktree = await resolveJunctionWorktreeRootForCwd(cwd, {
+                    junctionHome: this.junctionHome,
+                });
+                const workspaceName = labels?.['junction:workspace']
+                    ?? (resolvedWorktree ? basename(resolvedWorktree.worktreePath) : basename(cwd));
+                return {
+                    sessionConfig: {
+                        ...config,
+                        cwd,
+                    },
+                    autoWorkspaceName: workspaceName,
+                };
+            }
+        }
+        const baseBranch = normalized?.baseBranch ?? (await resolveBaseRef(repoRoot, { remoteName: normalized?.remoteName }));
         if (!baseBranch) {
             throw new Error('Unable to determine a base branch for worktree creation');
         }
@@ -1616,6 +1724,7 @@ export class Session {
         const createdWorktree = await createInRepoWorktree({
             repoRoot,
             baseBranch,
+            remoteName: normalized?.remoteName,
             runSetup: false,
         });
         return {
@@ -1684,6 +1793,153 @@ export class Session {
             });
         }
     }
+    resolveDaemonVersionSafe() {
+        try {
+            return resolveDaemonVersion(import.meta.url);
+        }
+        catch {
+            return null;
+        }
+    }
+    toDaemonMetadata(input) {
+        const homeDir = input?.homeDir ?? homedir();
+        const rootDir = input?.rootDir ?? parsePath(homeDir).root;
+        return {
+            hostname: hostname(),
+            version: this.resolveDaemonVersionSafe(),
+            platform: process.platform,
+            homeDir,
+            rootDir,
+        };
+    }
+    async handleRunDaemonDoctorRequest(msg) {
+        try {
+            const result = await runDaemonDoctor(this.junctionHome, this.sessionLogger);
+            this.emit({
+                type: 'run_daemon_doctor_response',
+                payload: {
+                    daemon: result.daemon,
+                    summary: result.summary,
+                    checks: result.checks,
+                    ranAt: result.ranAt,
+                    error: null,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, 'Failed to run daemon doctor');
+            const snapshot = loadDaemonProviderSettings(this.junctionHome);
+            this.emit({
+                type: 'run_daemon_doctor_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(snapshot),
+                    summary: 'fail',
+                    checks: [],
+                    ranAt: new Date().toISOString(),
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleGetDaemonProviderSettingsRequest(msg) {
+        try {
+            const snapshot = loadDaemonProviderSettings(this.junctionHome);
+            this.emit({
+                type: 'get_daemon_provider_settings_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(snapshot),
+                    providers: MANAGED_DAEMON_PROVIDERS.map((provider) => snapshot.providers[provider]),
+                    error: null,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, 'Failed to load daemon provider settings');
+            this.emit({
+                type: 'get_daemon_provider_settings_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(),
+                    providers: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleUpdateDaemonProviderSettingsRequest(msg) {
+        try {
+            const snapshot = saveDaemonProviderExecutablePath({
+                junctionHome: this.junctionHome,
+                provider: msg.provider,
+                executablePath: msg.executablePath,
+            });
+            this.emit({
+                type: 'update_daemon_provider_settings_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(snapshot),
+                    provider: snapshot.providers[msg.provider],
+                    error: null,
+                    requestId: msg.requestId,
+                },
+            });
+            await this.handleRestartServerRequest(msg.requestId, 'settings_update');
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, provider: msg.provider }, 'Failed to update daemon provider settings');
+            this.emit({
+                type: 'update_daemon_provider_settings_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(),
+                    provider: null,
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleAutoRouteProviderRequest(msg) {
+        try {
+            const config = loadPersistedConfig(this.junctionHome);
+            const env = applyProviderEnv(process.env, config.agents?.providers?.[msg.provider]);
+            const executablePath = autoRouteProviderExecutable(msg.provider, {
+                env,
+                platform: process.platform,
+            });
+            if (!executablePath) {
+                throw new SessionRequestError('provider_not_found', `Could not automatically locate ${msg.provider} on this daemon.`);
+            }
+            const snapshot = saveDaemonProviderExecutablePath({
+                junctionHome: this.junctionHome,
+                provider: msg.provider,
+                executablePath,
+            });
+            this.emit({
+                type: 'auto_route_provider_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(snapshot),
+                    provider: snapshot.providers[msg.provider],
+                    error: null,
+                    requestId: msg.requestId,
+                },
+            });
+            await this.handleRestartServerRequest(msg.requestId, 'settings_update');
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, provider: msg.provider }, 'Failed to auto-route provider executable');
+            this.emit({
+                type: 'auto_route_provider_response',
+                payload: {
+                    daemon: this.toDaemonMetadata(),
+                    provider: null,
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
     normalizeGitOptions(gitOptions, legacyWorktreeName) {
         const fallbackOptions = legacyWorktreeName
             ? {
@@ -1698,6 +1954,7 @@ export class Session {
             return null;
         }
         const baseBranch = merged.baseBranch?.trim() || undefined;
+        const remoteName = merged.remoteName?.trim() || undefined;
         const createWorktree = Boolean(merged.createWorktree);
         const createNewBranch = Boolean(merged.createNewBranch);
         const normalizedBranchName = merged.newBranchName ? slugify(merged.newBranchName) : undefined;
@@ -1710,6 +1967,9 @@ export class Session {
         if (baseBranch) {
             this.assertSafeGitRef(baseBranch, 'base branch');
         }
+        if (remoteName) {
+            this.assertSafeRemoteName(remoteName);
+        }
         if (createWorktree && !baseBranch) {
             throw new Error('Base branch is required when creating a worktree');
         }
@@ -1733,6 +1993,7 @@ export class Session {
         }
         return {
             baseBranch,
+            remoteName,
             createNewBranch,
             newBranchName: normalizedBranchName,
             createWorktree,
@@ -1744,6 +2005,11 @@ export class Session {
             throw new Error(`Invalid ${label}: ${ref}`);
         }
     }
+    assertSafeRemoteName(remoteName) {
+        if (!SAFE_GIT_REMOTE_NAME_PATTERN.test(remoteName)) {
+            throw new Error(`Invalid remote name: ${remoteName}`);
+        }
+    }
     toCheckoutError(error) {
         if (error instanceof NotGitRepoError) {
             return { code: 'NOT_GIT_REPO', message: error.message };
@@ -2201,6 +2467,10 @@ export class Session {
         const { cwd, branchName, requestId } = msg;
         try {
             const resolvedCwd = expandTilde(cwd);
+            const remoteName = msg.remoteName?.trim() || undefined;
+            if (remoteName) {
+                this.assertSafeRemoteName(remoteName);
+            }
             // Try local branch first
             try {
                 await execAsync(`git rev-parse --verify ${branchName}`, {
@@ -2222,26 +2492,45 @@ export class Session {
             catch {
                 // Local branch doesn't exist, try remote
             }
-            // Try remote branch (origin/{branchName})
-            try {
-                await execAsync(`git rev-parse --verify origin/${branchName}`, {
-                    cwd: resolvedCwd,
-                    env: READ_ONLY_GIT_ENV,
-                });
-                this.emit({
-                    type: 'validate_branch_response',
-                    payload: {
-                        exists: true,
-                        resolvedRef: `origin/${branchName}`,
-                        isRemote: true,
-                        error: null,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            catch {
-                // Remote branch doesn't exist either
+            const { stdout: remoteStdout } = await execAsync('git remote', {
+                cwd: resolvedCwd,
+                env: READ_ONLY_GIT_ENV,
+            });
+            const configuredRemotes = remoteStdout
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0)
+                .sort((left, right) => left.localeCompare(right));
+            const remoteCandidates = remoteName
+                ? [remoteName, 'origin', ...configuredRemotes]
+                : ['origin', ...configuredRemotes];
+            const seen = new Set();
+            for (const candidateRemote of remoteCandidates) {
+                const trimmedRemote = candidateRemote.trim();
+                if (!trimmedRemote || seen.has(trimmedRemote)) {
+                    continue;
+                }
+                seen.add(trimmedRemote);
+                try {
+                    await execAsync(`git rev-parse --verify ${trimmedRemote}/${branchName}`, {
+                        cwd: resolvedCwd,
+                        env: READ_ONLY_GIT_ENV,
+                    });
+                    this.emit({
+                        type: 'validate_branch_response',
+                        payload: {
+                            exists: true,
+                            resolvedRef: `${trimmedRemote}/${branchName}`,
+                            isRemote: true,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                    return;
+                }
+                catch {
+                    // try next remote
+                }
             }
             // Branch not found anywhere
             this.emit({
@@ -2272,7 +2561,11 @@ export class Session {
         const { cwd, query, limit, requestId } = msg;
         try {
             const resolvedCwd = expandTilde(cwd);
-            const branches = await listBranchSuggestions(resolvedCwd, { query, limit });
+            const branches = await listBranchSuggestions(resolvedCwd, {
+                query,
+                limit,
+                remoteName: msg.remoteName,
+            });
             this.emit({
                 type: 'branch_suggestions_response',
                 payload: {
@@ -2293,6 +2586,30 @@ export class Session {
             });
         }
     }
+    async handleGitRemotesRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const remotes = await listGitRemotes(expandTilde(cwd));
+            this.emit({
+                type: 'git_remotes_response',
+                payload: {
+                    remotes,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: 'git_remotes_response',
+                payload: {
+                    remotes: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
     async handleDirectorySuggestionsRequest(msg) {
         const { query, limit, requestId, cwd, includeFiles, includeDirectories, onlyGitRepos } = msg;
         try {
@@ -2351,6 +2668,55 @@ export class Session {
             });
         }
     }
+    async handleWorkspaceFileSuggestionsRequest(msg) {
+        const { cwd, query, limit, requestId, includeDirectories, includeFiles, ref } = msg;
+        try {
+            const workspaceCwd = expandTilde(cwd);
+            if (ref) {
+                this.assertSafeGitRef(ref, 'workspace file ref');
+            }
+            const entries = ref
+                ? await searchWorkspaceEntriesAtGitRef({
+                    cwd: workspaceCwd,
+                    ref,
+                    query,
+                    limit,
+                    includeDirectories,
+                    includeFiles,
+                })
+                : await searchWorkspaceEntries({
+                    cwd: workspaceCwd,
+                    query,
+                    limit,
+                    includeDirectories,
+                    includeFiles,
+                });
+            this.emit({
+                type: 'workspace_file_suggestions_response',
+                payload: {
+                    cwd,
+                    query,
+                    ref: ref ?? null,
+                    entries,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.emit({
+                type: 'workspace_file_suggestions_response',
+                payload: {
+                    cwd,
+                    query,
+                    ref: ref ?? null,
+                    entries: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
     async handleGitCloneRequest(msg) {
         const { url, targetDirectory, requestId } = msg;
         try {
@@ -2792,6 +3158,7 @@ export class Session {
             }
             await mergeFromBase(cwd, {
                 baseRef: msg.baseRef,
+                remoteName: msg.remoteName,
                 requireCleanTarget: msg.requireCleanTarget ?? true,
             });
             this.scheduleCheckoutDiffRefreshForCwd(cwd);
@@ -2820,7 +3187,7 @@ export class Session {
     async handleCheckoutPushRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            await pushCurrentBranch(cwd);
+            await pushCurrentBranch(cwd, { remoteName: msg.remoteName });
             this.emit({
                 type: 'checkout_push_response',
                 payload: {
@@ -2859,6 +3226,7 @@ export class Session {
                 title,
                 body,
                 base: msg.baseRef,
+                remoteName: msg.remoteName,
             });
             this.emit({
                 type: 'checkout_pr_create_response',
@@ -2887,7 +3255,7 @@ export class Session {
     async handleCheckoutPrStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const prStatus = await getPullRequestStatus(cwd);
+            const prStatus = await getPullRequestStatus(cwd, { remoteName: msg.remoteName });
             this.emit({
                 type: 'checkout_pr_status_response',
                 payload: {
@@ -2915,7 +3283,7 @@ export class Session {
     async handleCheckoutPrFailureLogsRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const result = await getPullRequestFailureLogs(cwd);
+            const result = await getPullRequestFailureLogs(cwd, { remoteName: msg.remoteName });
             this.emit({
                 type: 'checkout_pr_failure_logs_response',
                 payload: {
@@ -2945,6 +3313,7 @@ export class Session {
         try {
             await mergePullRequest(cwd, {
                 method: msg.method ?? 'squash',
+                remoteName: msg.remoteName,
             });
             this.emit({
                 type: 'checkout_pr_merge_response',
@@ -3295,19 +3664,24 @@ export class Session {
      * Handle read-only file explorer requests scoped to a workspace cwd
      */
     async handleWorkspaceFileExplorerRequest(request) {
-        const { cwd, path: requestedPath = '.', mode, requestId } = request;
+        const { cwd, path: requestedPath = '.', mode, requestId, ref } = request;
         try {
             const root = expandTilde(cwd);
+            if (ref) {
+                this.assertSafeGitRef(ref, 'workspace file ref');
+            }
             if (mode === 'list') {
                 const directory = await listDirectoryEntries({
                     root,
                     relativePath: requestedPath,
+                    ref,
                 });
                 this.emit({
                     type: 'workspace_file_explorer_response',
                     payload: {
                         cwd,
                         path: directory.path,
+                        ref: ref ?? null,
                         mode,
                         directory,
                         file: null,
@@ -3320,12 +3694,14 @@ export class Session {
                 const file = await readExplorerFile({
                     root,
                     relativePath: requestedPath,
+                    ref,
                 });
                 this.emit({
                     type: 'workspace_file_explorer_response',
                     payload: {
                         cwd,
                         path: file.path,
+                        ref: ref ?? null,
                         mode,
                         directory: null,
                         file,
@@ -3342,6 +3718,7 @@ export class Session {
                 payload: {
                     cwd,
                     path: requestedPath,
+                    ref: ref ?? null,
                     mode,
                     directory: null,
                     file: null,
@@ -4028,7 +4405,7 @@ export class Session {
                 this.sessionLogger.error({ err: error, agentId }, 'Failed to record user message for send_agent_message_request');
             }
             const prompt = this.buildAgentPrompt(msg.text, msg.images);
-            const started = this.startAgentStream(agentId, prompt);
+            const started = this.startAgentStream(agentId, prompt, normalizeAgentRunOptions(msg.runOptions));
             if (!started.ok) {
                 this.emit({
                     type: 'send_agent_message_response',