@getpaseo/server 0.1.99 → 0.1.101

package/dist/server/server/session.js

@@ -3,7 +3,6 @@ import { v4 as uuidv4 } from "uuid";
 import { stat } from "node:fs/promises";
 import { basename, normalize, resolve, sep } from "path";
 import { homedir } from "node:os";
-import { z } from "zod";
 import { CLIENT_CAPS } from "@getpaseo/protocol/client-capabilities";
 import { serializeAgentStreamEvent, } from "./messages.js";
 import { TerminalSessionController } from "../terminal/terminal-session-controller.js";
@@ -14,55 +13,52 @@ import { ensureAgentLoaded } from "./agent/agent-loading.js";
 import { formatSystemNotificationPrompt, sendPromptToAgent, waitForAgentRunStartWithTimeout, unarchiveAgentState, } from "./agent/agent-prompt.js";
 import { resolveCreateAgentTitles, resolveFirstAgentPromptTitle, } from "./agent/create-agent-title.js";
 import { respondToAgentPermission } from "./agent/permission-response.js";
-import { experimental_createMCPClient } from "ai";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { buildWorkspaceScriptPayloads, readPaseoConfigForProjection, } from "./script-status-projection.js";
-import { deriveProjectSlug } from "./workspace-git-metadata.js";
 import { spawnWorkspaceScript } from "./worktree-bootstrap.js";
+import { createWorkspaceScriptsService, } from "./session/workspace-scripts/workspace-scripts-service.js";
 import { getErrorMessage, getErrorMessageOr } from "@getpaseo/protocol/error-utils";
 import { getAgentStatusPriority } from "@getpaseo/protocol/agent-state-bucket";
 import { getParentAgentIdFromLabels } from "@getpaseo/protocol/agent-labels";
 import { createAgentCommand } from "./agent/create-agent/create.js";
 import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, detachAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./agent/lifecycle-command.js";
-import { buildStoredAgentPayload, resolveEffectiveThinkingOptionId, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
+import { buildStoredAgentPayload, resolveStoredAgentPayloadUpdatedAt, toAgentPayload, } from "./agent/agent-projections.js";
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./agent/timeline-append.js";
 import { projectTimelineRows, selectProjectedTimelinePage, } from "./agent/timeline-projection.js";
-import { StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from "./agent/agent-response-loop.js";
-import { resolveStructuredGenerationProviders, } from "./agent/structured-generation-providers.js";
 import { getAgentStreamEventTurnId, } from "./agent/agent-sdk-types.js";
 import { ImportSessionsRequestError, importProviderSession, listImportableProviderSessions, normalizeImportAgentRequest, } from "./agent/import-sessions.js";
-import { checkoutLiteFromGitSnapshot, classifyDirectoryForProjectMembership, deriveWorkspaceDisplayName, generateWorkspaceId, } from "./workspace-registry-model.js";
+import { checkoutLiteFromGitSnapshot, deriveWorkspaceDisplayName, } from "./workspace-registry-model.js";
 import { resolveWorkspaceIdForPath } from "./resolve-workspace-id-for-path.js";
-import { createPersistedProjectRecord, createPersistedWorkspaceRecord, resolveProjectDisplayName, resolveWorkspaceDisplayName, resolveWorkspaceName, } from "./workspace-registry.js";
+import { resolveProjectDisplayName, resolveWorkspaceDisplayName, resolveWorkspaceName, } from "./workspace-registry.js";
 import { wrapSpokenInput } from "./voice-config.js";
 import { isVoicePermissionAllowed } from "./voice-permission-policy.js";
 import { VoiceSession } from "./session/voice/voice-session.js";
 import { CheckoutSession } from "./session/checkout/checkout-session.js";
+import { createWorkspaceGitObserverService, } from "./session/workspace-git-observer/workspace-git-observer-service.js";
+import { createAgentStructuredTextGeneration, createGitMetadataGenerator, } from "./session/checkout/git-metadata-generator.js";
 import { ChatScheduleLoopSession } from "./session/chat/chat-schedule-loop-session.js";
 import { ProviderCatalogSession } from "./session/provider/provider-catalog-session.js";
 import { WorkspaceFilesSession } from "./session/files/workspace-files-session.js";
 import { AgentConfigSession } from "./session/agent-config/agent-config-session.js";
 import { ProjectConfigSession } from "./session/project-config/project-config-session.js";
 import { DaemonSession } from "./session/daemon/daemon-session.js";
-import { buildMetadataPrompt } from "../utils/build-metadata-prompt.js";
 import { archivePersistedWorkspaceRecord, archiveWorkspaceContents, } from "./workspace-archive-service.js";
 import { WorkspaceReconciliationService } from "./workspace-reconciliation-service.js";
-import { checkoutResolvedBranch, renameCurrentBranch as renameCurrentBranchDefault, } from "../utils/checkout-git.js";
+import { renameCurrentBranch as renameCurrentBranchDefault } from "../utils/checkout-git.js";
+import { createGitMutationService, } from "./session/git-mutation/git-mutation-service.js";
+import { createWorkspaceProvisioningService, } from "./session/workspace-provisioning/workspace-provisioning-service.js";
+import { createAgentUpdatesService, matchesAgentUpdatesFilter, } from "./session/agent-updates/agent-updates-service.js";
 import { expandTilde } from "../utils/path.js";
 import { searchHomeDirectories, searchWorkspaceEntries } from "../utils/directory-suggestions.js";
-import { execCommand } from "../utils/spawn.js";
 import { createGitHubService } from "../services/github-service.js";
 import { summarizeFetchWorkspacesEntries, workspaceIdsOnCheckout, WorkspaceDirectory, } from "./workspace-directory.js";
 import { shouldEmitPendingBootstrapUpdate } from "./workspace-bootstrap-dedupe.js";
 import { attemptFirstAgentBranchAutoName, createLocalCheckoutWorkspace, createPaseoWorktree, } from "./paseo-worktree-service.js";
 import { generateBranchNameFromFirstAgentContext, } from "./worktree-branch-name-generator.js";
-import { assertSafeGitRef as assertWorktreeSafeGitRef, buildAgentSessionConfig as buildWorktreeAgentSessionConfig, createPaseoWorktreeWorkflow as createWorktreeWorkflow, handleCreatePaseoWorktreeRequest as handleCreateWorktreeRequest, handlePaseoWorktreeArchiveRequest as handleWorktreeArchiveRequest, handlePaseoWorktreeListRequest as handleWorktreeListRequest, handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage, } from "./worktree-session.js";
+import { buildAgentSessionConfig as buildWorktreeAgentSessionConfig, createPaseoWorktreeWorkflow as createWorktreeWorkflow, handleCreatePaseoWorktreeRequest as handleCreateWorktreeRequest, handlePaseoWorktreeArchiveRequest as handleWorktreeArchiveRequest, handlePaseoWorktreeListRequest as handleWorktreeListRequest, handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage, } from "./worktree-session.js";
 import { archiveByScope } from "./workspace-archive-service.js";
 import { WorktreeRequestError, toWorktreeRequestError, toWorktreeWireError, } from "./worktree-errors.js";
 import { createWorktree } from "../utils/worktree.js";
 import { runGitCommand } from "../utils/run-git-command.js";
 import { CreateAgentLifecycleDispatch } from "./agent/create-agent-lifecycle-dispatch.js";
-const WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY = "__removed__";
 // TODO: Remove once all app store clients are on >=0.1.45 and understand arbitrary provider strings.
 // Clients before 0.1.45 validate providers with z.enum(["claude", "codex", "opencode"]) and reject
 // the entire session message if they encounter an unknown provider.
@@ -83,13 +79,6 @@ function resolveSubscriptionId(subscribe, requestedSubscriptionId) {
     }
     return uuidv4();
 }
-function diffChangeTypeFor(file) {
-    if (file.isNew)
-        return "A";
-    if (file.isDeleted)
-        return "D";
-    return "M";
-}
 function buildWorkspaceCheckout(workspace, project, 
 // The persisted `branch` field is the source of truth, but it is null for
 // records created before branch was lifted to its own field (no migrations,
@@ -201,19 +190,12 @@ function describeRegistryTransition(record) {
  */
 export class Session {
     constructor(options) {
-        // Per-session MCP client and tools
-        this.agentMcpClient = null;
-        this.agentTools = null;
         this.unsubscribeAgentEvents = null;
         this.unsubscribeTerminalWorkspaceContributionEvents = null;
-        this.agentUpdatesSubscription = null;
         this.workspaceUpdatesSubscription = null;
         this.clientActivity = null;
         this.inflightRequests = 0;
         this.peakInflightRequests = 0;
-        this.workspaceGitWatchTargets = new Map();
-        this.workspaceGitFetchSubscriptions = new Map();
-        this.workspaceGitSubscriptions = new Map();
         this.agentsPager = new SortablePager({
             validKeys: FETCH_AGENTS_SORT_KEYS,
             defaultSort: [{ key: "updated_at", direction: "desc" }],
@@ -237,7 +219,7 @@ export class Session {
                 }
             },
         });
-        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, getTransportBufferedAmount, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, worktreesRoot, agentManager, agentStorage, projectRegistry, workspaceRegistry, filesystem, chatService, scheduleService, loopService, checkoutDiffManager, github, renameCurrentBranch, generateWorkspaceName, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, providerUsageService, serviceProxy, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, voice, voiceBridge, dictation, serverId, daemonVersion, daemonRuntimeConfig, } = options;
+        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, getTransportBufferedAmount, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, worktreesRoot, agentManager, agentStorage, projectRegistry, workspaceRegistry, filesystem, chatService, scheduleService, loopService, checkoutDiffManager, github, renameCurrentBranch, generateWorkspaceName, workspaceGitService, daemonConfigStore, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, providerUsageService, serviceProxy, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, voice, voiceBridge, dictation, serverId, daemonVersion, daemonRuntimeConfig, getWebSocketRuntimeMetrics, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion ?? null;
         this.clientCapabilities = parseClientCapabilities(clientCapabilities);
@@ -273,24 +255,49 @@ export class Session {
         this.renameCurrentBranch = renameCurrentBranch ?? renameCurrentBranchDefault;
         this.generateWorkspaceName = generateWorkspaceName ?? generateBranchNameFromFirstAgentContext;
         this.workspaceGitService = workspaceGitService;
+        this.gitMutation = createGitMutationService({
+            workspaceGitService: this.workspaceGitService,
+            github: this.github,
+            logger: this.sessionLogger,
+        });
+        this.workspaceProvisioning = createWorkspaceProvisioningService({
+            workspaceRegistry: this.workspaceRegistry,
+            projectRegistry: this.projectRegistry,
+            workspaceGitService: this.workspaceGitService,
+        });
         this.checkoutSession = new CheckoutSession({
             host: {
                 emit: (msg) => this.emit(msg),
-                notifyGitMutation: (cwd, reason, mutationOptions) => this.notifyGitMutation(cwd, reason, mutationOptions),
                 emitWorkspaceUpdateForCwd: (cwd) => this.emitWorkspaceUpdateForCwd(cwd),
-                handleWorkspaceGitBranchSnapshot: (cwd, branchName) => this.handleWorkspaceGitBranchSnapshot(cwd, branchName),
+                handleWorkspaceGitBranchSnapshot: (cwd, branchName) => this.workspaceGitObserver.handleBranchSnapshot(cwd, branchName),
                 renameCurrentBranch: (cwd, branch) => this.renameCurrentBranch(cwd, branch),
-                checkoutExistingBranch: (cwd, branch) => this.checkoutExistingBranch(cwd, branch),
-                generateCommitMessage: (cwd) => this.generateCommitMessage(cwd),
-                generatePullRequestText: (cwd, baseRef) => this.generatePullRequestText(cwd, baseRef),
             },
+            gitMutation: this.gitMutation,
             workspaceGitService: this.workspaceGitService,
             github: this.github,
             checkoutDiffManager,
+            gitMetadataGenerator: createGitMetadataGenerator({
+                workspaceGitService: this.workspaceGitService,
+                generation: createAgentStructuredTextGeneration({
+                    agentManager: this.agentManager,
+                    providerSnapshotManager,
+                    readDaemonConfig: () => this.readStructuredGenerationDaemonConfig(),
+                    getFocusedSelection: (cwd) => this.getFocusedAgentSelectionForCwd(cwd),
+                }),
+            }),
             paseoHome: this.paseoHome,
             worktreesRoot: this.worktreesRoot,
             logger: this.sessionLogger,
         });
+        this.workspaceGitObserver = createWorkspaceGitObserverService({
+            workspaceGitService: this.workspaceGitService,
+            describeWorkspaceRecordWithGitData: (workspace) => this.describeWorkspaceRecordWithGitData(workspace),
+            emitWorkspaceUpdateForCwd: (cwd) => this.emitWorkspaceUpdateForCwd(cwd),
+            emitWorkspaceUpdateForWorkspaceId: (workspaceId) => this.emitWorkspaceUpdateForWorkspaceId(workspaceId),
+            emitStatusUpdate: (cwd, snapshot) => this.checkoutSession.emitStatusUpdate(cwd, snapshot),
+            onBranchChanged,
+            logger: this.sessionLogger,
+        });
         this.chatScheduleLoopSession = new ChatScheduleLoopSession({
             host: {
                 emit: (msg) => this.emit(msg),
@@ -353,11 +360,14 @@ export class Session {
             serverId,
             daemonVersion,
             daemonRuntimeConfig,
+            getWebSocketRuntimeMetrics,
             listProviderAvailability: () => this.agentManager.listProviderAvailability(),
+            listAgents: () => this.agentManager.listAgents(),
+            listProjects: () => this.projectRegistry.list(),
+            listWorkspaces: () => this.workspaceRegistry.list(),
             logger: this.sessionLogger,
         });
         this.daemonConfigStore = daemonConfigStore;
-        this.mcpBaseUrl = mcpBaseUrl ?? null;
         this.terminalManager = terminalManager;
         this.terminalController = new TerminalSessionController({
             terminalManager,
@@ -370,6 +380,15 @@ export class Session {
             clientSupportsWrapReflow: () => this.clientCapabilities.has(CLIENT_CAPS.terminalReflowableSnapshot),
             getClientBufferedAmount: () => this.getTransportBufferedAmount(),
         });
+        this.agentUpdates = createAgentUpdatesService({
+            emit: (message) => this.emit(message),
+            buildAgentPayload: (agent) => this.buildAgentPayload(agent),
+            buildStoredAgentPayload: (record) => this.buildStoredAgentPayload(record),
+            isProviderVisibleToClient: (provider) => this.isProviderVisibleToClient(provider),
+            buildProjectPlacementForWorkspaceId: (workspaceId) => this.buildProjectPlacementForWorkspaceId(workspaceId),
+            emitWorkspaceUpdateForWorkspaceId: (workspaceId) => this.emitWorkspaceUpdateForWorkspaceId(workspaceId),
+            logger: this.sessionLogger,
+        });
         this.createAgentLifecycleDispatch = new CreateAgentLifecycleDispatch({
             paseoHome: this.paseoHome,
             worktreesRoot: this.worktreesRoot,
@@ -383,14 +402,7 @@ export class Session {
             listActiveWorkspaces: () => this.listActiveWorkspaceRefs(),
             archiveWorkspaceRecord: (workspaceId) => this.archiveWorkspaceRecord(workspaceId),
             emit: (message) => this.emit(message),
-            emitAgentRemove: (agentId) => {
-                if (this.agentUpdatesSubscription) {
-                    this.bufferOrEmitAgentUpdate(this.agentUpdatesSubscription, {
-                        kind: "remove",
-                        agentId,
-                    });
-                }
-            },
+            emitAgentRemove: (agentId) => this.agentUpdates.removeAgent(agentId),
             emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds) => this.emitWorkspaceUpdatesForWorkspaceIds(workspaceIds),
             markWorkspaceArchiving: (workspaceIds, archivingAt) => this.markWorkspaceArchiving(workspaceIds, archivingAt),
             clearWorkspaceArchiving: (workspaceIds) => this.clearWorkspaceArchiving(workspaceIds),
@@ -401,11 +413,24 @@ export class Session {
         this.serviceProxy = serviceProxy ?? null;
         this.scriptRuntimeStore = scriptRuntimeStore ?? null;
         this.workspaceSetupSnapshots = workspaceSetupSnapshots ?? new Map();
-        this.onBranchChanged = onBranchChanged;
         this.getDaemonTcpPort = getDaemonTcpPort ?? null;
         this.getDaemonTcpHost = getDaemonTcpHost ?? null;
         this.serviceProxyPublicBaseUrl = serviceProxyPublicBaseUrl ?? null;
         this.resolveScriptHealth = resolveScriptHealth ?? null;
+        this.workspaceScripts = createWorkspaceScriptsService({
+            serviceProxy: this.serviceProxy,
+            scriptRuntimeStore: this.scriptRuntimeStore,
+            terminalManager: this.terminalManager,
+            workspaceRegistry: this.workspaceRegistry,
+            workspaceGitService: this.workspaceGitService,
+            getDaemonTcpPort: this.getDaemonTcpPort,
+            getDaemonTcpHost: this.getDaemonTcpHost,
+            serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
+            resolveScriptHealth: this.resolveScriptHealth,
+            logger: this.sessionLogger,
+            emit: (message) => this.emit(message),
+            spawnWorkspaceScript,
+        });
         this.subscribeToOptionalManagers();
         this.workspaceDirectory = new WorkspaceDirectory({
             logger: this.sessionLogger,
@@ -440,8 +465,6 @@ export class Session {
             voiceBridge,
             dictation,
         });
-        // Initialize agent MCP client asynchronously
-        void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
         this.sessionLogger.trace({}, "agent.session.lifecycle.created");
     }
@@ -457,8 +480,7 @@ export class Session {
         return this.clientCapabilities.has(capability);
     }
     async syncWorkspaceGitObserverForWorkspace(workspace) {
-        const descriptor = await this.describeWorkspaceRecordWithGitData(workspace);
-        this.syncWorkspaceGitObservers([descriptor]);
+        await this.workspaceGitObserver.syncObserverForWorkspace(workspace);
     }
     async emitWorkspaceUpdateForWorkspaceId(workspaceId) {
         await this.emitWorkspaceUpdatesForWorkspaceIds([workspaceId], { skipReconcile: true });
@@ -476,8 +498,7 @@ export class Session {
         await this.emitWorkspaceUpdatesForWorkspaceIds(workspaceIds);
     }
     async warmWorkspaceGitDataForWorkspace(workspace) {
-        await this.syncWorkspaceGitObserverForWorkspace(workspace);
-        await this.emitWorkspaceUpdateForWorkspaceId(workspace.workspaceId);
+        await this.workspaceGitObserver.warmGitData(workspace);
     }
     /**
      * Get the client's current activity state
@@ -592,30 +613,6 @@ export class Session {
             },
         });
     }
-    /**
-     * Initialize Agent MCP client for this session using the daemon's HTTP MCP endpoint.
-     */
-    async initializeAgentMcp() {
-        try {
-            if (!this.mcpBaseUrl) {
-                this.sessionLogger.info("Skipping Agent MCP initialization because no MCP base URL is configured");
-                return;
-            }
-            const authToken = this.agentManager.getMcpAuthToken();
-            const transport = new StreamableHTTPClientTransport(new URL(this.mcpBaseUrl), authToken
-                ? { requestInit: { headers: { Authorization: `Bearer ${authToken}` } } }
-                : undefined);
-            this.agentMcpClient = await experimental_createMCPClient({
-                transport,
-            });
-            this.agentTools = (await this.agentMcpClient.tools());
-            const agentToolCount = Object.keys(this.agentTools ?? {}).length;
-            this.sessionLogger.trace({ agentToolCount }, "agent.session.mcp_init");
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to initialize Agent MCP");
-        }
-    }
     /**
      * Subscribe to AgentManager events and forward them to the client
      */
@@ -644,7 +641,7 @@ export class Session {
                     turnId: event.agent.activeForegroundTurnId ?? undefined,
                     lifecycle: event.agent.lifecycle,
                 }, "agent.session.forward_update");
-                void this.forwardAgentUpdate(event.agent);
+                void this.agentUpdates.forwardLiveAgent(event.agent);
                 return;
             }
             if (this.voiceSession.isActiveForAgent(event.agentId) &&
@@ -734,148 +731,6 @@ export class Session {
         }
         return LEGACY_PROVIDER_IDS.has(provider);
     }
-    agentThinkingOptionMatchesFilter(agent, filter) {
-        if (filter.thinkingOptionId === undefined) {
-            return true;
-        }
-        const expectedThinkingOptionId = resolveEffectiveThinkingOptionId({
-            configuredThinkingOptionId: filter.thinkingOptionId ?? null,
-        });
-        const resolvedThinkingOptionId = agent.effectiveThinkingOptionId ??
-            resolveEffectiveThinkingOptionId({
-                runtimeInfo: agent.runtimeInfo,
-                configuredThinkingOptionId: agent.thinkingOptionId ?? null,
-            });
-        return resolvedThinkingOptionId === expectedThinkingOptionId;
-    }
-    matchesAgentStructuralFilter(agent, project, filter) {
-        if (filter.statuses && filter.statuses.length > 0) {
-            const statuses = new Set(filter.statuses);
-            if (!statuses.has(agent.status)) {
-                return false;
-            }
-        }
-        if (typeof filter.requiresAttention === "boolean") {
-            const requiresAttention = agent.requiresAttention ?? false;
-            if (requiresAttention !== filter.requiresAttention) {
-                return false;
-            }
-        }
-        if (filter.projectKeys && filter.projectKeys.length > 0) {
-            const projectKeys = new Set(filter.projectKeys.filter((item) => item.trim().length > 0));
-            if (projectKeys.size > 0 && !projectKeys.has(project.projectKey)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    matchesAgentFilter(options) {
-        const { agent, project, filter } = options;
-        if (filter?.labels) {
-            const matchesLabels = Object.entries(filter.labels).every(([key, value]) => agent.labels[key] === value);
-            if (!matchesLabels) {
-                return false;
-            }
-        }
-        const includeArchived = filter?.includeArchived ?? false;
-        if (!includeArchived && agent.archivedAt) {
-            return false;
-        }
-        if (filter && !this.agentThinkingOptionMatchesFilter(agent, filter)) {
-            return false;
-        }
-        if (filter && !this.matchesAgentStructuralFilter(agent, project, filter)) {
-            return false;
-        }
-        return true;
-    }
-    getAgentUpdateTargetId(update) {
-        return update.kind === "remove" ? update.agentId : update.agent.id;
-    }
-    bufferOrEmitAgentUpdate(subscription, payload) {
-        if (payload.kind === "upsert" && !this.isProviderVisibleToClient(payload.agent.provider)) {
-            return;
-        }
-        if (subscription.isBootstrapping) {
-            subscription.pendingUpdatesByAgentId.set(this.getAgentUpdateTargetId(payload), payload);
-            return;
-        }
-        this.emit({
-            type: "agent_update",
-            payload,
-        });
-    }
-    async emitStoredAgentUpdate(record) {
-        const payload = this.buildStoredAgentPayload(record);
-        const subscription = this.agentUpdatesSubscription;
-        if (!subscription) {
-            return payload;
-        }
-        const project = payload.workspaceId
-            ? await this.buildProjectPlacementForWorkspaceId(payload.workspaceId)
-            : null;
-        if (!project) {
-            this.bufferOrEmitAgentUpdate(subscription, {
-                kind: "remove",
-                agentId: payload.id,
-            });
-            return payload;
-        }
-        const matches = this.matchesAgentFilter({
-            agent: payload,
-            project,
-            filter: subscription.filter,
-        });
-        this.bufferOrEmitAgentUpdate(subscription, matches
-            ? {
-                kind: "upsert",
-                agent: payload,
-                project,
-            }
-            : {
-                kind: "remove",
-                agentId: payload.id,
-            });
-        return payload;
-    }
-    flushBootstrappedAgentUpdates(options) {
-        const subscription = this.agentUpdatesSubscription;
-        if (!subscription || !subscription.isBootstrapping) {
-            return;
-        }
-        subscription.isBootstrapping = false;
-        const pending = Array.from(subscription.pendingUpdatesByAgentId.values());
-        subscription.pendingUpdatesByAgentId.clear();
-        for (const payload of pending) {
-            if (payload.kind === "upsert") {
-                const snapshotUpdatedAt = options?.snapshotUpdatedAtByAgentId?.get(payload.agent.id);
-                if (typeof snapshotUpdatedAt === "number") {
-                    const updateUpdatedAt = Date.parse(payload.agent.updatedAt);
-                    if (!Number.isNaN(updateUpdatedAt) && updateUpdatedAt <= snapshotUpdatedAt) {
-                        continue;
-                    }
-                }
-            }
-            this.emit({
-                type: "agent_update",
-                payload,
-            });
-        }
-    }
-    async findExactWorkspaceByDirectory(cwd, options) {
-        const normalizedCwd = await this.resolveWorkspaceDirectory(cwd, options);
-        const workspaces = await this.workspaceRegistry.list();
-        return workspaces.find((workspace) => workspace.cwd === normalizedCwd) ?? null;
-    }
-    async resolveWorkspaceDirectory(cwd, options) {
-        const normalizedCwd = resolve(cwd);
-        if (options?.refreshGit === false) {
-            const snapshot = this.workspaceGitService.peekSnapshot(normalizedCwd);
-            return resolve(snapshot?.git.repoRoot ?? normalizedCwd);
-        }
-        const checkout = await this.workspaceGitService.getCheckout(normalizedCwd);
-        return resolve(checkout.worktreeRoot ?? normalizedCwd);
-    }
     async buildProjectPlacementForWorkspace(workspace, projectRecord) {
         const project = projectRecord ?? (await this.projectRegistry.get(workspace.projectId));
         if (!project) {
@@ -905,51 +760,6 @@ export class Session {
             return null;
         return this.buildProjectPlacementForWorkspace(workspace, project);
     }
-    async forwardAgentUpdate(agent) {
-        try {
-            const subscription = this.agentUpdatesSubscription;
-            const payload = await this.buildAgentPayload(agent);
-            if (subscription) {
-                const project = payload.workspaceId
-                    ? await this.buildProjectPlacementForWorkspaceId(payload.workspaceId)
-                    : null;
-                if (!project) {
-                    this.bufferOrEmitAgentUpdate(subscription, {
-                        kind: "remove",
-                        agentId: payload.id,
-                    });
-                }
-                else {
-                    const matches = this.matchesAgentFilter({
-                        agent: payload,
-                        project,
-                        filter: subscription.filter,
-                    });
-                    if (matches) {
-                        this.bufferOrEmitAgentUpdate(subscription, {
-                            kind: "upsert",
-                            agent: payload,
-                            project,
-                        });
-                    }
-                    else {
-                        this.bufferOrEmitAgentUpdate(subscription, {
-                            kind: "remove",
-                            agentId: payload.id,
-                        });
-                    }
-                }
-            }
-            // A lifecycle change updates exactly the agent's owning workspace, never
-            // every workspace sharing its cwd. Ownership is the agent's workspaceId.
-            if (payload.workspaceId) {
-                await this.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
-            }
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error }, "Failed to emit agent update");
-        }
-    }
     /**
      * Main entry point for processing session messages
      */
@@ -1145,6 +955,8 @@ export class Session {
                 return this.daemonSession.handleGetStatusRequest(msg);
             case "daemon.get_pairing_offer.request":
                 return this.daemonSession.handleGetPairingOfferRequest(msg);
+            case "diagnostics.request":
+                return this.daemonSession.handleDiagnosticsRequest(msg);
             case "set_daemon_config_request":
                 this.emit({
                     type: "set_daemon_config_response",
@@ -1437,12 +1249,7 @@ export class Session {
                 requestId,
             },
         });
-        if (this.agentUpdatesSubscription) {
-            this.bufferOrEmitAgentUpdate(this.agentUpdatesSubscription, {
-                kind: "remove",
-                agentId,
-            });
-        }
+        this.agentUpdates.removeAgent(agentId);
         if (knownWorkspaceId) {
             await this.emitWorkspaceUpdateForWorkspaceId(knownWorkspaceId);
         }
@@ -1465,8 +1272,8 @@ export class Session {
             agentStorage: this.agentStorage,
             logger: this.sessionLogger,
         }, agentId);
-        if (this.agentUpdatesSubscription) {
-            const payload = await this.emitStoredAgentUpdate(archivedRecord);
+        if (this.agentUpdates.hasSubscription()) {
+            const payload = await this.agentUpdates.emitStoredRecord(archivedRecord);
             if (payload.workspaceId) {
                 await this.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
             }
@@ -1479,7 +1286,7 @@ export class Session {
             const result = await detachAgentCommand({ agentManager: this.agentManager }, agentId);
             const affectedWorkspaceIds = new Set();
             if (!result.live) {
-                const payload = await this.emitStoredAgentUpdate(result.record);
+                const payload = await this.agentUpdates.emitStoredRecord(result.record);
                 if (payload.workspaceId) {
                     affectedWorkspaceIds.add(payload.workspaceId);
                 }
@@ -1878,7 +1685,7 @@ export class Session {
             const createAgentConfig = createdWorktree
                 ? { ...config, cwd: createdWorktree.worktree.worktreePath }
                 : config;
-            const workspaceId = await this.resolveOrCreateWorkspaceIdForCreateAgent({
+            const workspaceId = await this.workspaceProvisioning.resolveOrCreateWorkspaceIdForCreateAgent({
                 createdWorktree,
                 requestedWorkspaceId: msg.workspaceId,
                 cwd: createAgentConfig.cwd,
@@ -1912,7 +1719,7 @@ export class Session {
             if (!createdWorktree && msg.workspaceId) {
                 await this.writeInitialWorkspaceTitleIfUntitled(workspaceId, workspacePromptTitle);
             }
-            await this.forwardAgentUpdate(snapshot);
+            await this.agentUpdates.forwardLiveAgent(snapshot);
             if (!createdWorktree && trimmedPrompt) {
                 await this.scheduleAutoNameLocalWorkspaceTitleForFirstAgent({
                     workspaceId,
@@ -2000,7 +1807,7 @@ export class Session {
             const snapshot = await this.agentManager.resumeAgentFromPersistence(handle, overrides);
             await unarchiveAgentState(this.agentStorage, this.agentManager, snapshot.id);
             await this.agentManager.hydrateTimelineFromProvider(snapshot.id);
-            await this.forwardAgentUpdate(snapshot);
+            await this.agentUpdates.forwardLiveAgent(snapshot);
             const timelineSize = this.agentManager.getTimeline(snapshot.id).length;
             if (requestId) {
                 const agentPayload = await this.buildAgentPayload(snapshot);
@@ -2062,7 +1869,7 @@ export class Session {
             }
             // An imported agent mints its own workspace; ownership is its workspaceId,
             // never an existing same-cwd workspace resolved by path.
-            const workspace = await this.createWorkspaceForDirectory(normalized.cwd);
+            const workspace = await this.workspaceProvisioning.createWorkspaceForDirectory(normalized.cwd);
             const { snapshot, timelineSize } = await importProviderSession({
                 request: normalized,
                 workspaceId: workspace.workspaceId,
@@ -2135,7 +1942,7 @@ export class Session {
                 snapshot = await this.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
-            await this.forwardAgentUpdate(snapshot);
+            await this.agentUpdates.forwardLiveAgent(snapshot);
             const timelineSize = this.agentManager.getTimeline(agentId).length;
             if (requestId) {
                 this.emit({
@@ -2244,8 +2051,8 @@ export class Session {
                     logger: this.sessionLogger,
                 },
             }),
-            checkoutExistingBranch: (cwd, branch) => this.checkoutExistingBranch(cwd, branch),
-            createBranchFromBase: (params) => this.createBranchFromBase(params),
+            checkoutExistingBranch: (cwd, branch) => this.gitMutation.checkoutExistingBranch(cwd, branch),
+            createBranchFromBase: (params) => this.gitMutation.createBranchFromBase(params),
             github: this.github,
         }, config, gitOptions, legacyWorktreeName, firstAgentContext);
     }
@@ -2290,7 +2097,7 @@ export class Session {
             branch: result.branchName,
             promptTitle: resolveFirstAgentPromptTitle(input.firstAgentContext),
         });
-        await this.notifyGitMutation(input.workspace.cwd, "rename-branch");
+        await this.gitMutation.notifyGitMutation(input.workspace.cwd, "rename-branch");
         await this.emitWorkspaceUpdateForCwd(input.workspace.cwd);
     }
     // Generated names may replace the prompt title set at creation, but not a user
@@ -2366,12 +2173,6 @@ export class Session {
             firstAgentContext: input.firstAgentContext,
         }), { cwd: input.cwd, message: "Failed to auto-name local workspace title" });
     }
-    assertSafeGitRef(ref, label) {
-        if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
-            throw new Error(`Invalid ${label}: ${ref}`);
-        }
-        assertWorktreeSafeGitRef(ref, label);
-    }
     isPathWithinRoot(rootPath, candidatePath) {
         const resolvedRoot = resolve(rootPath);
         const resolvedCandidate = resolve(candidatePath);
@@ -2380,220 +2181,6 @@ export class Session {
         }
         return resolvedCandidate.startsWith(resolvedRoot + sep);
     }
-    async generateCommitMessage(cwd) {
-        const diff = await this.workspaceGitService.getCheckoutDiff(cwd, {
-            mode: "uncommitted",
-            includeStructured: true,
-        });
-        const schema = z.object({
-            message: z
-                .string()
-                .min(1)
-                .max(72)
-                .describe("Concise git commit message, imperative mood, no trailing period."),
-        });
-        const fileList = diff.structured && diff.structured.length > 0
-            ? [
-                "Files changed:",
-                ...diff.structured.map((file) => {
-                    const changeType = diffChangeTypeFor(file);
-                    const status = file.status && file.status !== "ok" ? ` [${file.status}]` : "";
-                    return `${changeType}\t${file.path}\t(+${file.additions} -${file.deletions})${status}`;
-                }),
-            ].join("\n")
-            : "Files changed: (unknown)";
-        const maxPatchChars = 120000;
-        const patch = diff.diff.length > maxPatchChars
-            ? `${diff.diff.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`
-            : diff.diff;
-        const prompt = await buildMetadataPrompt({
-            cwd,
-            workspaceGitService: this.workspaceGitService,
-            contract: "Write a concise git commit message for the changes below.",
-            styles: [
-                {
-                    configKey: "commitMessage",
-                    default: "Concise, imperative mood, no trailing period.",
-                },
-            ],
-            after: [
-                "Return JSON only with a single field 'message'.",
-                "",
-                fileList,
-                "",
-                patch.length > 0 ? patch : "(No diff available)",
-            ].join("\n"),
-        });
-        const providers = await resolveStructuredGenerationProviders({
-            cwd,
-            providerSnapshotManager: this.providerSnapshotManager,
-            daemonConfig: this.readStructuredGenerationDaemonConfig(),
-            currentSelection: this.getFocusedAgentSelectionForCwd(cwd),
-        });
-        try {
-            const result = await generateStructuredAgentResponseWithFallback({
-                manager: this.agentManager,
-                cwd,
-                prompt,
-                schema,
-                schemaName: "CommitMessage",
-                maxRetries: 2,
-                providers,
-                persistSession: false,
-                agentConfigOverrides: {
-                    title: "Commit generator",
-                    internal: true,
-                },
-            });
-            return result.message;
-        }
-        catch (error) {
-            if (error instanceof StructuredAgentResponseError ||
-                error instanceof StructuredAgentFallbackError) {
-                return "Update files";
-            }
-            throw error;
-        }
-    }
-    async generatePullRequestText(cwd, baseRef) {
-        const diff = await this.workspaceGitService.getCheckoutDiff(cwd, {
-            mode: "base",
-            baseRef,
-            includeStructured: true,
-        });
-        const schema = z.object({
-            title: z.string().min(1).max(72),
-            body: z.string().min(1),
-        });
-        const fileList = diff.structured && diff.structured.length > 0
-            ? [
-                "Files changed:",
-                ...diff.structured.map((file) => {
-                    const changeType = diffChangeTypeFor(file);
-                    const status = file.status && file.status !== "ok" ? ` [${file.status}]` : "";
-                    return `${changeType}\t${file.path}\t(+${file.additions} -${file.deletions})${status}`;
-                }),
-            ].join("\n")
-            : "Files changed: (unknown)";
-        const maxPatchChars = 200000;
-        const patch = diff.diff.length > maxPatchChars
-            ? `${diff.diff.slice(0, maxPatchChars)}\n\n... (diff truncated to ${maxPatchChars} chars)\n`
-            : diff.diff;
-        const prompt = await buildMetadataPrompt({
-            cwd,
-            workspaceGitService: this.workspaceGitService,
-            contract: "Write a pull request title and body for the changes below.",
-            styles: [
-                {
-                    configKey: "pullRequest",
-                    default: "Clear, descriptive title; body explaining what changed and why.",
-                },
-            ],
-            after: [
-                "Return JSON only with fields 'title' and 'body'.",
-                "",
-                fileList,
-                "",
-                patch.length > 0 ? patch : "(No diff available)",
-            ].join("\n"),
-        });
-        const providers = await resolveStructuredGenerationProviders({
-            cwd,
-            providerSnapshotManager: this.providerSnapshotManager,
-            daemonConfig: this.readStructuredGenerationDaemonConfig(),
-            currentSelection: this.getFocusedAgentSelectionForCwd(cwd),
-        });
-        try {
-            return await generateStructuredAgentResponseWithFallback({
-                manager: this.agentManager,
-                cwd,
-                prompt,
-                schema,
-                schemaName: "PullRequest",
-                maxRetries: 2,
-                providers,
-                persistSession: false,
-                agentConfigOverrides: {
-                    title: "PR generator",
-                    internal: true,
-                },
-            });
-        }
-        catch (error) {
-            if (error instanceof StructuredAgentResponseError ||
-                error instanceof StructuredAgentFallbackError) {
-                return {
-                    title: "Update changes",
-                    body: "Automated PR generated by Paseo.",
-                };
-            }
-            throw error;
-        }
-    }
-    async ensureCleanWorkingTree(cwd) {
-        const dirty = await this.isWorkingTreeDirty(cwd);
-        if (dirty) {
-            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
-        }
-    }
-    async isWorkingTreeDirty(cwd) {
-        try {
-            const snapshot = await this.workspaceGitService.getSnapshot(cwd);
-            return snapshot.git.isDirty === true;
-        }
-        catch (error) {
-            throw new Error(`Unable to inspect git status for ${cwd}: ${getErrorMessage(error)}`, {
-                cause: error,
-            });
-        }
-    }
-    async checkoutExistingBranch(cwd, branch) {
-        this.assertSafeGitRef(branch, "branch");
-        const resolution = await this.workspaceGitService.validateBranchRef(cwd, branch);
-        if (resolution.kind === "not-found") {
-            throw new Error(`Branch not found: ${branch}`);
-        }
-        await this.ensureCleanWorkingTree(cwd);
-        const result = await checkoutResolvedBranch({
-            cwd,
-            resolution,
-        });
-        await this.notifyGitMutation(cwd, "switch-branch", { invalidateGithub: true });
-        return result;
-    }
-    async createBranchFromBase(params) {
-        const { cwd, baseBranch, newBranchName } = params;
-        this.assertSafeGitRef(baseBranch, "base branch");
-        this.assertSafeGitRef(newBranchName, "new branch");
-        const baseResolution = await this.workspaceGitService.validateBranchRef(cwd, baseBranch);
-        if (baseResolution.kind === "not-found") {
-            throw new Error(`Base branch not found: ${baseBranch}`);
-        }
-        const exists = await this.doesLocalBranchExist(cwd, newBranchName);
-        if (exists) {
-            throw new Error(`Branch already exists: ${newBranchName}`);
-        }
-        await this.ensureCleanWorkingTree(cwd);
-        await execCommand("git", ["checkout", "-b", newBranchName, baseBranch], {
-            cwd,
-        });
-        await this.notifyGitMutation(cwd, "create-branch");
-    }
-    async doesLocalBranchExist(cwd, branch) {
-        this.assertSafeGitRef(branch, "branch");
-        return this.workspaceGitService.hasLocalBranch(cwd, branch);
-    }
-    async notifyGitMutation(cwd, reason, options) {
-        if (options?.invalidateGithub) {
-            this.github.invalidate({ cwd });
-        }
-        try {
-            await this.workspaceGitService.getSnapshot(cwd, { force: true, reason });
-        }
-        catch (error) {
-            this.sessionLogger.warn({ err: error, cwd, reason }, "Failed to force-refresh workspace git snapshot after mutation");
-        }
-    }
     /**
      * Handle clearing agent attention flag
      */
@@ -2797,129 +2384,6 @@ export class Session {
             });
         }
     }
-    closeWorkspaceGitWatchTarget(target) {
-        if (target.debounceTimer) {
-            clearTimeout(target.debounceTimer);
-            target.debounceTimer = null;
-        }
-        for (const watcher of target.watchers) {
-            try {
-                watcher.close();
-            }
-            catch {
-                // Ignore watcher close errors
-            }
-        }
-        target.watchers.length = 0;
-    }
-    async removeWorkspaceGitWatchTarget(cwd) {
-        const normalizedCwd = resolve(cwd);
-        const target = this.workspaceGitWatchTargets.get(normalizedCwd);
-        if (target) {
-            this.closeWorkspaceGitWatchTarget(target);
-            this.workspaceGitWatchTargets.delete(normalizedCwd);
-        }
-    }
-    removeWorkspaceGitSubscription(cwd) {
-        const normalizedCwd = resolve(cwd);
-        const target = this.workspaceGitWatchTargets.get(normalizedCwd);
-        if (target) {
-            const unsubscribeFetch = this.workspaceGitFetchSubscriptions.get(normalizedCwd);
-            unsubscribeFetch?.();
-            this.workspaceGitFetchSubscriptions.delete(normalizedCwd);
-            this.closeWorkspaceGitWatchTarget(target);
-            this.workspaceGitWatchTargets.delete(normalizedCwd);
-        }
-        this.workspaceGitSubscriptions.get(normalizedCwd)?.();
-        this.workspaceGitSubscriptions.delete(normalizedCwd);
-    }
-    workspaceGitDescriptorStateKey(workspace) {
-        if (!workspace) {
-            return WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY;
-        }
-        return JSON.stringify([
-            workspace.name,
-            workspace.diffStat ? [workspace.diffStat.additions, workspace.diffStat.deletions] : null,
-        ]);
-    }
-    resolveWorkspaceGitWatchTarget(workspaceId) {
-        for (const target of this.workspaceGitWatchTargets.values()) {
-            if (target.workspaceId === workspaceId) {
-                return target;
-            }
-        }
-        return null;
-    }
-    shouldSkipWorkspaceGitWatchUpdate(workspaceId, workspace) {
-        const target = this.resolveWorkspaceGitWatchTarget(workspaceId);
-        if (!target) {
-            return false;
-        }
-        const nextStateKey = this.workspaceGitDescriptorStateKey(workspace);
-        if (target.latestDescriptorStateKey === nextStateKey) {
-            return true;
-        }
-        target.latestDescriptorStateKey = nextStateKey;
-        return false;
-    }
-    rememberWorkspaceGitDescriptorState(workspaceId, workspace) {
-        const target = this.resolveWorkspaceGitWatchTarget(workspaceId);
-        if (!target) {
-            return;
-        }
-        target.latestDescriptorStateKey = this.workspaceGitDescriptorStateKey(workspace);
-        target.lastBranchName = workspace?.name ?? null;
-    }
-    handleWorkspaceGitBranchSnapshot(cwd, branchName) {
-        const target = this.workspaceGitWatchTargets.get(resolve(cwd));
-        if (!target) {
-            return;
-        }
-        const previousBranchName = target.lastBranchName;
-        if (branchName === previousBranchName) {
-            return;
-        }
-        target.lastBranchName = branchName;
-        this.onBranchChanged?.(target.workspaceId, previousBranchName, branchName);
-    }
-    syncWorkspaceGitObservers(workspaces) {
-        for (const workspace of workspaces) {
-            this.syncWorkspaceGitObserver(workspace.workspaceDirectory, {
-                isGit: workspace.projectKind === "git",
-                workspaceId: workspace.id,
-            });
-            this.rememberWorkspaceGitDescriptorState(workspace.workspaceDirectory, workspace);
-        }
-    }
-    syncWorkspaceGitObserver(cwd, options) {
-        const normalizedCwd = resolve(cwd);
-        if (!options.isGit) {
-            this.removeWorkspaceGitSubscription(normalizedCwd);
-            return;
-        }
-        if (this.workspaceGitSubscriptions.has(normalizedCwd)) {
-            return;
-        }
-        const target = {
-            cwd: normalizedCwd,
-            workspaceId: options.workspaceId,
-            watchers: [],
-            debounceTimer: null,
-            refreshPromise: null,
-            refreshQueued: false,
-            latestDescriptorStateKey: null,
-            lastBranchName: null,
-        };
-        this.workspaceGitWatchTargets.set(normalizedCwd, target);
-        const subscription = this.workspaceGitService.registerWorkspace({ cwd: normalizedCwd }, (snapshot) => {
-            this.handleWorkspaceGitBranchSnapshot(normalizedCwd, snapshot.git.currentBranch ?? null);
-            void this.emitWorkspaceUpdateForCwd(normalizedCwd).catch((error) => {
-                this.sessionLogger.warn({ err: error, cwd: normalizedCwd }, "Failed to emit workspace update after git branch snapshot");
-            });
-            this.checkoutSession.emitStatusUpdate(normalizedCwd, snapshot);
-        });
-        this.workspaceGitSubscriptions.set(normalizedCwd, subscription.unsubscribe);
-    }
     async handlePaseoWorktreeListRequest(msg) {
         return handleWorktreeListRequest({
             emit: (message) => this.emit(message),
@@ -3115,7 +2579,7 @@ export class Session {
                 if (!entry) {
                     continue;
                 }
-                if (!this.matchesAgentFilter({
+                if (!matchesAgentUpdatesFilter({
                     agent: entry.agent,
                     project: entry.project,
                     filter,
@@ -3230,19 +2694,7 @@ export class Session {
             statusEnteredAt: null,
             activityAt: null,
             diffStat,
-            scripts: this.serviceProxy && this.scriptRuntimeStore
-                ? buildWorkspaceScriptPayloads({
-                    workspaceId: workspace.workspaceId,
-                    workspaceDirectory: workspace.cwd,
-                    paseoConfig: readPaseoConfigForProjection(workspace.cwd, this.sessionLogger),
-                    serviceProxy: this.serviceProxy,
-                    runtimeStore: this.scriptRuntimeStore,
-                    daemonPort: this.getDaemonTcpPort?.() ?? null,
-                    serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
-                    gitMetadata: this.resolveWorkspaceScriptGitMetadata(workspace.cwd),
-                    resolveHealth: this.resolveScriptHealth ?? undefined,
-                })
-                : [],
+            scripts: this.buildWorkspaceScriptPayloadSnapshot(workspace.workspaceId, workspace.cwd),
             ...(resolvedProjectRecord
                 ? {
                     project: await this.buildProjectPlacementForWorkspace(workspace, resolvedProjectRecord),
@@ -3411,91 +2863,6 @@ export class Session {
             });
         }
     }
-    async findOrCreateWorkspaceForDirectory(cwd) {
-        const inputCwd = resolve(cwd);
-        const normalizedCwd = await this.resolveWorkspaceDirectory(cwd);
-        const existingWorkspace = await this.findExactWorkspaceByDirectory(normalizedCwd, {
-            refreshGit: false,
-        });
-        if (existingWorkspace) {
-            if (existingWorkspace.archivedAt && inputCwd !== normalizedCwd) {
-                const timestamp = new Date().toISOString();
-                const checkout = checkoutLiteFromGitSnapshot(inputCwd, {
-                    isGit: false,
-                    currentBranch: null,
-                    remoteUrl: null,
-                    repoRoot: null,
-                    isPaseoOwnedWorktree: false,
-                    mainRepoRoot: null,
-                });
-                const membership = classifyDirectoryForProjectMembership({ cwd: inputCwd, checkout });
-                const projectRecord = await this.resolveProjectRecordForPlacement({
-                    membership,
-                    timestamp,
-                });
-                await this.projectRegistry.upsert(projectRecord);
-                const workspaceRecord = createPersistedWorkspaceRecord({
-                    workspaceId: generateWorkspaceId(),
-                    projectId: projectRecord.projectId,
-                    cwd: inputCwd,
-                    kind: membership.workspaceKind,
-                    displayName: membership.workspaceDisplayName,
-                    createdAt: timestamp,
-                    updatedAt: timestamp,
-                });
-                await this.workspaceRegistry.upsert(workspaceRecord);
-                return workspaceRecord;
-            }
-            return this.reclassifyOrUnarchiveWorkspaceForDirectory({
-                workspace: existingWorkspace,
-                project: await this.projectRegistry.get(existingWorkspace.projectId),
-                cwd: normalizedCwd,
-            });
-        }
-        return this.createWorkspaceForDirectory(normalizedCwd);
-    }
-    async resolveOrCreateWorkspaceIdForCreateAgent(input) {
-        if (input.createdWorktree) {
-            return input.createdWorktree.workspace.workspaceId;
-        }
-        if (input.requestedWorkspaceId) {
-            return input.requestedWorkspaceId;
-        }
-        return (await this.createWorkspaceForDirectory(input.cwd, input.initialTitle)).workspaceId;
-    }
-    async createWorkspaceForDirectory(cwd, title) {
-        const checkout = await this.workspaceGitService.getCheckout(cwd);
-        const membership = classifyDirectoryForProjectMembership({ cwd, checkout });
-        const timestamp = new Date().toISOString();
-        const projectRecord = await this.resolveProjectRecordForPlacement({
-            membership,
-            timestamp,
-        });
-        await this.projectRegistry.upsert(projectRecord);
-        const workspaceRecord = createPersistedWorkspaceRecord({
-            workspaceId: generateWorkspaceId(),
-            projectId: projectRecord.projectId,
-            cwd,
-            kind: membership.workspaceKind,
-            displayName: membership.workspaceDisplayName,
-            title: title ?? null,
-            createdAt: timestamp,
-            updatedAt: timestamp,
-        });
-        await this.workspaceRegistry.upsert(workspaceRecord);
-        return workspaceRecord;
-    }
-    async findOrCreateProjectForDirectory(cwd) {
-        const normalizedCwd = resolve(cwd);
-        const checkout = await this.workspaceGitService.getCheckout(normalizedCwd);
-        const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
-        const projectRecord = await this.resolveProjectRecordForPlacement({
-            membership,
-            timestamp: new Date().toISOString(),
-        });
-        await this.projectRegistry.upsert(projectRecord);
-        return projectRecord;
-    }
     buildProjectDescriptor(project) {
         return {
             projectId: project.projectId,
@@ -3505,64 +2872,6 @@ export class Session {
             projectKind: project.kind,
         };
     }
-    async reclassifyOrUnarchiveWorkspaceForDirectory(input) {
-        const checkout = await this.workspaceGitService.getCheckout(input.cwd);
-        const membership = classifyDirectoryForProjectMembership({ cwd: input.cwd, checkout });
-        const timestamp = new Date().toISOString();
-        const projectRecord = await this.resolveProjectRecordForPlacement({
-            membership,
-            timestamp,
-        });
-        const projectId = projectRecord.projectId;
-        const kind = membership.workspaceKind;
-        const displayName = membership.workspaceDisplayName;
-        if (input.workspace.projectId === projectId &&
-            input.workspace.kind === kind &&
-            input.workspace.displayName === displayName) {
-            if (!input.project) {
-                await this.projectRegistry.upsert(projectRecord);
-            }
-            return this.ensureWorkspaceRecordUnarchived(input.workspace);
-        }
-        await this.projectRegistry.upsert(projectRecord);
-        const nextWorkspace = {
-            ...input.workspace,
-            workspaceId: input.workspace.workspaceId,
-            projectId,
-            cwd: input.cwd,
-            kind,
-            displayName,
-            archivedAt: null,
-            updatedAt: timestamp,
-        };
-        await this.workspaceRegistry.upsert(nextWorkspace);
-        return nextWorkspace;
-    }
-    async resolveProjectRecordForPlacement(input) {
-        const rootPath = input.membership.projectRootPath;
-        const kind = input.membership.projectKind;
-        const projects = await this.projectRegistry.list();
-        const existingProject = projects.find((project) => !project.archivedAt && project.rootPath === rootPath) ??
-            projects.find((project) => project.rootPath === rootPath) ??
-            null;
-        if (!existingProject) {
-            return createPersistedProjectRecord({
-                projectId: input.membership.projectKey,
-                rootPath,
-                kind,
-                displayName: input.membership.projectName,
-                createdAt: input.timestamp,
-                updatedAt: input.timestamp,
-            });
-        }
-        return {
-            ...existingProject,
-            rootPath,
-            kind,
-            archivedAt: null,
-            updatedAt: input.timestamp,
-        };
-    }
     async unarchiveOwningWorkspaceForAgent(agentId) {
         const record = await this.agentStorage.get(agentId);
         if (!record?.workspaceId) {
@@ -3582,7 +2891,7 @@ export class Session {
             // missing, so the record must point at a real directory first.
             await this.recreateOwningWorktreeForRestore(workspace, workspace.branch);
         }
-        await this.ensureWorkspaceRecordUnarchived(workspace);
+        await this.workspaceProvisioning.ensureWorkspaceRecordUnarchived(workspace);
         await this.emitWorkspaceUpdatesForWorkspaceIds([workspace.workspaceId]);
     }
     async recreateOwningWorktreeForRestore(workspace, branch) {
@@ -3635,26 +2944,6 @@ export class Session {
             });
         }
     }
-    async ensureWorkspaceRecordUnarchived(workspace) {
-        const project = await this.projectRegistry.get(workspace.projectId);
-        if (!workspace.archivedAt && (!project || !project.archivedAt)) {
-            return workspace;
-        }
-        const timestamp = new Date().toISOString();
-        let unarchivedWorkspace = workspace;
-        if (workspace.archivedAt) {
-            unarchivedWorkspace = { ...workspace, archivedAt: null, updatedAt: timestamp };
-            await this.workspaceRegistry.upsert(unarchivedWorkspace);
-        }
-        if (project?.archivedAt) {
-            await this.projectRegistry.upsert({
-                ...project,
-                archivedAt: null,
-                updatedAt: timestamp,
-            });
-        }
-        return unarchivedWorkspace;
-    }
     async createPaseoWorktree(input, options) {
         const result = await createPaseoWorktree(input, {
             github: this.github,
@@ -3666,8 +2955,8 @@ export class Session {
             workspaceGitService: this.workspaceGitService,
         });
         void Promise.all([
-            this.notifyGitMutation(input.cwd, "create-worktree"),
-            this.notifyGitMutation(result.worktree.worktreePath, "create-worktree"),
+            this.gitMutation.notifyGitMutation(input.cwd, "create-worktree"),
+            this.gitMutation.notifyGitMutation(result.worktree.worktreePath, "create-worktree"),
         ]).catch((error) => {
             this.sessionLogger.warn({ err: error, cwd: input.cwd, worktreePath: result.worktree.worktreePath }, "Failed to warm git snapshots after creating worktree");
         });
@@ -3691,10 +2980,7 @@ export class Session {
             workspaceRegistry: this.workspaceRegistry,
         });
         if (!existingWorkspace) {
-            const watchTarget = this.resolveWorkspaceGitWatchTarget(workspaceId);
-            if (watchTarget) {
-                this.removeWorkspaceGitSubscription(watchTarget.cwd);
-            }
+            this.workspaceGitObserver.removeForWorkspaceId(workspaceId);
             return;
         }
         if (!existingWorkspace.archivedAt) {
@@ -3716,9 +3002,8 @@ export class Session {
     // store is keyed by the opaque workspace id. Each cleanup uses its own key so an
     // opaque id is never resolved as a filesystem path.
     async teardownArchivedWorkspace(input) {
-        await this.removeWorkspaceGitWatchTarget(input.cwd);
+        this.workspaceGitObserver.removeForCwd(input.cwd);
         this.scriptRuntimeStore?.removeForWorkspace(input.workspaceId);
-        this.removeWorkspaceGitSubscription(input.cwd);
     }
     async reconcileAndEmitWorkspaceUpdates() {
         if (!this.workspaceUpdatesSubscription) {
@@ -3793,10 +3078,10 @@ export class Session {
                 ? workspace
                 : null;
             if (options?.dedupeGitState &&
-                this.shouldSkipWorkspaceGitWatchUpdate(workspaceId, nextWorkspace)) {
+                this.workspaceGitObserver.shouldSkipUpdate(workspaceId, nextWorkspace)) {
                 continue;
             }
-            this.recordWorkspaceGitDescriptorState(workspaceId, nextWorkspace);
+            this.workspaceGitObserver.recordDescriptorState(workspaceId, nextWorkspace);
             if (!nextWorkspace) {
                 subscription.lastEmittedByWorkspaceId.delete(workspaceId);
                 this.bufferOrEmitWorkspaceUpdate(subscription, await this.buildWorkspaceRemoveUpdatePayload(workspaceId, options?.removedProjectId));
@@ -3818,16 +3103,6 @@ export class Session {
             void this.reconcileAndEmitWorkspaceUpdates();
         }
     }
-    recordWorkspaceGitDescriptorState(workspaceId, nextWorkspace) {
-        const watchTarget = this.resolveWorkspaceGitWatchTarget(workspaceId);
-        if (watchTarget && this.onBranchChanged) {
-            const newBranchName = nextWorkspace?.name ?? null;
-            if (newBranchName !== watchTarget.lastBranchName) {
-                this.onBranchChanged(workspaceId, watchTarget.lastBranchName, newBranchName);
-            }
-        }
-        this.rememberWorkspaceGitDescriptorState(workspaceId, nextWorkspace);
-    }
     async buildWorkspaceRemoveUpdatePayload(workspaceId, removedProjectId) {
         if (removedProjectId) {
             return { kind: "remove", id: workspaceId, removedProjectId };
@@ -3876,12 +3151,10 @@ export class Session {
         const subscriptionId = resolveSubscriptionId(request.subscribe, requestedSubscriptionId);
         try {
             if (subscriptionId) {
-                this.agentUpdatesSubscription = {
+                this.agentUpdates.beginSubscription({
                     subscriptionId,
                     filter: request.filter,
-                    isBootstrapping: true,
-                    pendingUpdatesByAgentId: new Map(),
-                };
+                });
             }
             const payload = await this.listFetchAgentsEntries(request);
             const snapshotUpdatedAtByAgentId = new Map();
@@ -3899,13 +3172,13 @@ export class Session {
                     ...payload,
                 },
             });
-            if (subscriptionId && this.agentUpdatesSubscription?.subscriptionId === subscriptionId) {
-                this.flushBootstrappedAgentUpdates({ snapshotUpdatedAtByAgentId });
+            if (subscriptionId) {
+                this.agentUpdates.flushBootstrapped(subscriptionId, { snapshotUpdatedAtByAgentId });
             }
         }
         catch (error) {
-            if (subscriptionId && this.agentUpdatesSubscription?.subscriptionId === subscriptionId) {
-                this.agentUpdatesSubscription = null;
+            if (subscriptionId) {
+                this.agentUpdates.clearSubscription(subscriptionId);
             }
             const code = error instanceof SessionRequestError ? error.code : "fetch_agents_failed";
             const message = error instanceof Error ? error.message : "Failed to fetch agents";
@@ -4004,7 +3277,7 @@ export class Session {
                 };
             }
             const payload = await this.listFetchWorkspacesEntries(request);
-            this.syncWorkspaceGitObservers(payload.entries);
+            this.workspaceGitObserver.syncObservers(payload.entries);
             this.sessionLogger.debug({
                 requestId: request.requestId,
                 subscriptionId,
@@ -4246,7 +3519,7 @@ export class Session {
             for (const workspaceRecord of await this.workspaceRegistry.list()) {
                 workspacesBefore.set(workspaceRecord.workspaceId, workspaceRecord);
             }
-            const workspace = await this.findOrCreateWorkspaceForDirectory(cwd);
+            const workspace = await this.workspaceProvisioning.findOrCreateWorkspaceForDirectory(cwd);
             const project = await this.projectRegistry.get(workspace.projectId);
             await this.syncWorkspaceGitObserverForWorkspace(workspace);
             const descriptor = await this.describeWorkspaceRecord(workspace);
@@ -4315,7 +3588,7 @@ export class Session {
             for (const project of await this.projectRegistry.list()) {
                 projectsBefore.set(project.projectId, project);
             }
-            const project = await this.findOrCreateProjectForDirectory(cwd);
+            const project = await this.workspaceProvisioning.findOrCreateProjectForDirectory(cwd);
             this.sessionLogger.info({
                 requestedCwd,
                 resolvedCwd: cwd,
@@ -4345,98 +3618,13 @@ export class Session {
             });
         }
     }
+    // Named accessor: the workspace descriptor builder and the git-watch test both read a workspace's
+    // scripts snapshot through here; the workspace-scripts module owns the payload assembly.
     buildWorkspaceScriptPayloadSnapshot(workspaceId, workspaceDirectory) {
-        if (!this.serviceProxy || !this.scriptRuntimeStore) {
-            return [];
-        }
-        return buildWorkspaceScriptPayloads({
-            workspaceId,
-            workspaceDirectory,
-            paseoConfig: readPaseoConfigForProjection(workspaceDirectory, this.sessionLogger),
-            serviceProxy: this.serviceProxy,
-            runtimeStore: this.scriptRuntimeStore,
-            daemonPort: this.getDaemonTcpPort?.() ?? null,
-            serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
-            gitMetadata: this.resolveWorkspaceScriptGitMetadata(workspaceDirectory),
-            resolveHealth: this.resolveScriptHealth ?? undefined,
-        });
+        return this.workspaceScripts.buildSnapshot(workspaceId, workspaceDirectory);
     }
-    resolveWorkspaceScriptGitMetadata(workspaceDirectory) {
-        const snapshot = this.workspaceGitService.peekSnapshot(workspaceDirectory);
-        if (!snapshot) {
-            return undefined;
-        }
-        return {
-            projectSlug: deriveProjectSlug(workspaceDirectory, snapshot.git.isGit ? snapshot.git.remoteUrl : null),
-            currentBranch: snapshot.git.currentBranch,
-        };
-    }
-    emitWorkspaceScriptStatusUpdate(workspaceId, workspaceDirectory) {
-        this.emit({
-            type: "script_status_update",
-            payload: {
-                workspaceId,
-                scripts: this.buildWorkspaceScriptPayloadSnapshot(workspaceId, workspaceDirectory),
-            },
-        });
-    }
-    async handleStartWorkspaceScriptRequest(request) {
-        try {
-            if (!this.terminalManager || !this.serviceProxy || !this.scriptRuntimeStore) {
-                throw new Error("Workspace scripts are not available on this daemon");
-            }
-            const workspace = await this.workspaceRegistry.get(request.workspaceId);
-            if (!workspace) {
-                throw new Error(`Workspace not found: ${request.workspaceId}`);
-            }
-            const gitMetadata = await this.workspaceGitService.getWorkspaceGitMetadata(workspace.cwd);
-            const serviceResult = await spawnWorkspaceScript({
-                repoRoot: workspace.cwd,
-                workspaceId: workspace.workspaceId,
-                projectSlug: gitMetadata.projectSlug,
-                branchName: gitMetadata.currentBranch,
-                scriptName: request.scriptName,
-                daemonPort: this.getDaemonTcpPort?.() ?? null,
-                daemonListenHost: this.getDaemonTcpHost?.() ?? null,
-                serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
-                serviceProxy: this.serviceProxy,
-                runtimeStore: this.scriptRuntimeStore,
-                terminalManager: this.terminalManager,
-                logger: this.sessionLogger,
-                onLifecycleChanged: () => {
-                    this.emitWorkspaceScriptStatusUpdate(workspace.workspaceId, workspace.cwd);
-                },
-            });
-            this.emitWorkspaceScriptStatusUpdate(workspace.workspaceId, workspace.cwd);
-            this.emit({
-                type: "start_workspace_script_response",
-                payload: {
-                    requestId: request.requestId,
-                    workspaceId: request.workspaceId,
-                    scriptName: request.scriptName,
-                    terminalId: serviceResult.terminalId,
-                    error: null,
-                },
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to start workspace script";
-            this.sessionLogger.error({
-                err: error,
-                workspaceId: request.workspaceId,
-                scriptName: request.scriptName,
-            }, "Failed to start workspace script");
-            this.emit({
-                type: "start_workspace_script_response",
-                payload: {
-                    requestId: request.requestId,
-                    workspaceId: request.workspaceId,
-                    scriptName: request.scriptName,
-                    terminalId: null,
-                    error: message,
-                },
-            });
-        }
+    handleStartWorkspaceScriptRequest(request) {
+        return this.workspaceScripts.start(request);
     }
     // COMPAT(desktopEditorBridge): added in v0.1.88, remove after 2026-12-03 once old clients no longer call daemon editor RPCs.
     async handleLegacyListAvailableEditorsRequest(request) {
@@ -4489,7 +3677,7 @@ export class Session {
             getDaemonTcpHost: this.getDaemonTcpHost,
             serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
             onScriptsChanged: (workspaceId, workspaceDirectory) => {
-                this.emitWorkspaceScriptStatusUpdate(workspaceId, workspaceDirectory);
+                this.workspaceScripts.emitStatusUpdate(workspaceId, workspaceDirectory);
             },
         }, input, options);
     }
@@ -5097,29 +4285,16 @@ export class Session {
             this.unsubscribeAgentEvents();
             this.unsubscribeAgentEvents = null;
         }
+        this.agentUpdates.dispose();
         if (this.unsubscribeTerminalWorkspaceContributionEvents) {
             this.unsubscribeTerminalWorkspaceContributionEvents();
             this.unsubscribeTerminalWorkspaceContributionEvents = null;
         }
         this.providerCatalogSession.dispose();
         await this.voiceSession.cleanup();
-        // Close MCP clients
-        if (this.agentMcpClient) {
-            try {
-                await this.agentMcpClient.close();
-            }
-            catch (error) {
-                this.sessionLogger.error({ err: error }, "Failed to close Agent MCP client");
-            }
-            this.agentMcpClient = null;
-            this.agentTools = null;
-        }
         this.terminalController.dispose();
         this.checkoutSession.cleanup();
-        for (const unsubscribe of this.workspaceGitSubscriptions.values()) {
-            unsubscribe();
-        }
-        this.workspaceGitSubscriptions.clear();
+        this.workspaceGitObserver.dispose();
     }
 }
 //# sourceMappingURL=session.js.map