@getpaseo/server 0.1.100 → 0.1.102-beta.2

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,54 @@ 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 { CLIENT_SHUTDOWN_RPC_REASON, normalizeClientRestartRpcReason, } from "./lifecycle-reasons.js";
 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 { buildAgentForkContextAttachment } from "./agent/activity-curator.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 +81,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 +192,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 +221,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 +257,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),
@@ -348,16 +357,21 @@ export class Session {
         this.daemonSession = new DaemonSession({
             host: {
                 emit: (msg) => this.emit(msg),
+                emitLifecycleIntent: (intent) => this.emitLifecycleIntent(intent),
             },
+            clientId: this.clientId,
             paseoHome: this.paseoHome,
             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 +384,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 +406,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 +417,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 +469,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 +484,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 +502,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 +617,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 +645,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 +735,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) {
@@ -891,12 +750,6 @@ export class Session {
         };
     }
     async buildProjectPlacementForWorkspaceId(workspaceId) {
-        const workspace = await this.workspaceRegistry.get(workspaceId);
-        if (!workspace)
-            return null;
-        return this.buildProjectPlacementForWorkspace(workspace);
-    }
-    async buildProjectPlacementForExistingWorkspaceProject(workspaceId) {
         const workspace = await this.workspaceRegistry.get(workspaceId);
         if (!workspace)
             return null;
@@ -905,51 +758,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
      */
@@ -1005,6 +813,7 @@ export class Session {
         const promise = this.dispatchVoiceAndControlMessage(msg) ??
             this.dispatchAgentRewindMessage(msg) ??
             this.dispatchAgentRelationshipMessage(msg) ??
+            this.dispatchAgentTimelineMessage(msg) ??
             this.dispatchAgentLifecycleMessage(msg) ??
             this.dispatchAgentConfigMessage(msg) ??
             this.dispatchCheckoutMessage(msg) ??
@@ -1081,6 +890,16 @@ export class Session {
                 return undefined;
         }
     }
+    dispatchAgentTimelineMessage(msg) {
+        switch (msg.type) {
+            case "fetch_agent_timeline_request":
+                return this.handleFetchAgentTimelineRequest(msg);
+            case "agent.fork_context.request":
+                return this.handleAgentForkContextRequest(msg);
+            default:
+                return undefined;
+        }
+    }
     dispatchAgentLifecycleMessage(msg) {
         switch (msg.type) {
             case "fetch_agents_request":
@@ -1115,8 +934,6 @@ export class Session {
                 return this.handleRefreshAgentRequest(msg);
             case "cancel_agent_request":
                 return this.handleCancelAgentRequest(msg.agentId, msg.requestId);
-            case "fetch_agent_timeline_request":
-                return this.handleFetchAgentTimelineRequest(msg);
             case "agent_permission_response":
                 return this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
             case "clear_agent_attention":
@@ -1145,6 +962,10 @@ 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 "daemon.update.request":
+                return this.daemonSession.handleUpdateRequest(msg);
             case "set_daemon_config_request":
                 this.emit({
                     type: "set_daemon_config_response",
@@ -1352,6 +1173,9 @@ export class Session {
     resetPeakInflight() {
         this.peakInflightRequests = this.inflightRequests;
     }
+    getSessionId() {
+        return this.sessionId;
+    }
     async handleBinaryFrame(binaryFrame) {
         if (binaryFrame.kind === "file_transfer") {
             await this.workspaceFilesSession.handleFileTransferFrame(binaryFrame.frame);
@@ -1360,6 +1184,7 @@ export class Session {
         this.terminalController.handleBinaryFrame(binaryFrame.frame);
     }
     async handleRestartServerRequest(requestId, reason) {
+        const lifecycleReason = normalizeClientRestartRpcReason(reason);
         const payload = {
             status: "restart_requested",
             clientId: this.clientId,
@@ -1368,7 +1193,7 @@ export class Session {
             payload.reason = reason;
         }
         payload.requestId = requestId;
-        this.sessionLogger.warn({ reason }, "Restart requested via websocket");
+        this.sessionLogger.warn({ reason: lifecycleReason }, "Restart requested via websocket");
         this.emit({
             type: "status",
             payload,
@@ -1377,11 +1202,12 @@ export class Session {
             type: "restart",
             clientId: this.clientId,
             requestId,
-            ...(reason ? { reason } : {}),
+            reason: lifecycleReason,
         });
     }
     async handleShutdownServerRequest(requestId) {
-        this.sessionLogger.warn("Shutdown requested via websocket");
+        const reason = CLIENT_SHUTDOWN_RPC_REASON;
+        this.sessionLogger.warn({ reason }, "Shutdown requested via websocket");
         this.emit({
             type: "status",
             payload: {
@@ -1394,6 +1220,7 @@ export class Session {
             type: "shutdown",
             clientId: this.clientId,
             requestId,
+            reason,
         });
     }
     emitLifecycleIntent(intent) {
@@ -1437,12 +1264,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 +1287,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 +1301,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,12 +1700,13 @@ 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,
                 initialTitle: workspacePromptTitle,
             });
+            const createdDirectoryWorkspaceForAgent = !createdWorktree && !msg.workspaceId;
             const { snapshot, liveSnapshot } = await createAgentCommand({
                 agentManager: this.agentManager,
                 agentStorage: this.agentStorage,
@@ -1909,11 +1732,8 @@ export class Session {
                 buildSessionConfig: (sessionConfig, gitOptions, legacyWorktreeName, ctx) => this.buildAgentSessionConfig(sessionConfig, gitOptions, legacyWorktreeName, ctx),
             });
             createdAgentId = snapshot.id;
-            if (!createdWorktree && msg.workspaceId) {
-                await this.writeInitialWorkspaceTitleIfUntitled(workspaceId, workspacePromptTitle);
-            }
-            await this.forwardAgentUpdate(snapshot);
-            if (!createdWorktree && trimmedPrompt) {
+            await this.agentUpdates.forwardLiveAgent(snapshot);
+            if (createdDirectoryWorkspaceForAgent && trimmedPrompt) {
                 await this.scheduleAutoNameLocalWorkspaceTitleForFirstAgent({
                     workspaceId,
                     cwd: createAgentConfig.cwd,
@@ -2000,7 +1820,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 +1882,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 +1955,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 +2064,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 +2110,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
@@ -2311,20 +2131,6 @@ export class Session {
             updatedAt: new Date().toISOString(),
         });
     }
-    async writeInitialWorkspaceTitleIfUntitled(workspaceId, title) {
-        if (!title) {
-            return;
-        }
-        const current = await this.workspaceRegistry.get(workspaceId);
-        if (!current || current.title) {
-            return;
-        }
-        await this.workspaceRegistry.upsert({
-            ...current,
-            title,
-            updatedAt: new Date().toISOString(),
-        });
-    }
     // Wraps the injected workspace-name generator for a directory workspace.
     async generateWorkspaceTitleFromContext(input) {
         return this.generateWorkspaceName({
@@ -2366,12 +2172,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 +2180,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 +2383,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 +2578,7 @@ export class Session {
                 if (!entry) {
                     continue;
                 }
-                if (!this.matchesAgentFilter({
+                if (!matchesAgentUpdatesFilter({
                     agent: entry.agent,
                     project: entry.project,
                     filter,
@@ -3160,9 +2623,7 @@ export class Session {
             if (existing) {
                 return existing;
             }
-            const placementPromise = request.type === "fetch_agent_history_request"
-                ? this.buildProjectPlacementForExistingWorkspaceProject(workspaceId)
-                : this.buildProjectPlacementForWorkspaceId(workspaceId);
+            const placementPromise = this.buildProjectPlacementForWorkspaceId(workspaceId);
             placementByWorkspaceId.set(workspaceId, placementPromise);
             return placementPromise;
         };
@@ -3230,19 +2691,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 +2860,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 +2869,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 +2888,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 +2941,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 +2952,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 +2977,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 +2999,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 +3075,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 +3100,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 +3148,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 +3169,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 +3274,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 +3516,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 +3585,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 +3615,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,
-        });
-    }
-    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,
-        };
+        return this.workspaceScripts.buildSnapshot(workspaceId, workspaceDirectory);
     }
-    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 +3674,7 @@ export class Session {
             getDaemonTcpHost: this.getDaemonTcpHost,
             serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
             onScriptsChanged: (workspaceId, workspaceDirectory) => {
-                this.emitWorkspaceScriptStatusUpdate(workspaceId, workspaceDirectory);
+                this.workspaceScripts.emitStatusUpdate(workspaceId, workspaceDirectory);
             },
         }, input, options);
     }
@@ -4850,6 +4035,51 @@ export class Session {
             });
         }
     }
+    async handleAgentForkContextRequest(msg) {
+        try {
+            const snapshot = await ensureAgentLoaded(msg.agentId, {
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                logger: this.sessionLogger,
+            });
+            const agentPayload = await this.buildAgentPayload(snapshot);
+            const rows = this.agentManager.fetchTimeline(msg.agentId, {
+                direction: "tail",
+                limit: 0,
+            }).rows;
+            const forkContext = buildAgentForkContextAttachment({
+                rows,
+                boundaryMessageId: msg.boundaryMessageId,
+                agentTitle: agentPayload.title,
+                cwd: snapshot.cwd,
+            });
+            this.emit({
+                type: "agent.fork_context.response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    attachment: forkContext.attachment,
+                    itemCount: forkContext.itemCount,
+                    boundaryMessageId: forkContext.boundaryMessageId,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: msg.agentId }, "Failed to handle agent.fork_context.request");
+            this.emit({
+                type: "agent.fork_context.response",
+                payload: {
+                    requestId: msg.requestId,
+                    agentId: msg.agentId,
+                    attachment: null,
+                    itemCount: 0,
+                    boundaryMessageId: msg.boundaryMessageId ?? null,
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
     async handleSendAgentMessageRequest(msg) {
         const resolved = await this.resolveAgentIdentifier(msg.agentId);
         if (!resolved.ok) {
@@ -5097,29 +4327,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