@getpaseo/server 0.1.100 → 0.1.101

package/dist/server/server/session/workspace-git-observer/workspace-git-observer-service.js

@@ -0,0 +1,134 @@
+import { resolve } from "node:path";
+const WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY = "__removed__";
+export function createWorkspaceGitObserverService(deps) {
+    const { workspaceGitService, describeWorkspaceRecordWithGitData, emitWorkspaceUpdateForCwd, emitWorkspaceUpdateForWorkspaceId, emitStatusUpdate, onBranchChanged, logger, } = deps;
+    const watchTargets = new Map();
+    const subscriptions = new Map();
+    function descriptorStateKey(workspace) {
+        if (!workspace) {
+            return WORKSPACE_GIT_WATCH_REMOVED_STATE_KEY;
+        }
+        return JSON.stringify([
+            workspace.name,
+            workspace.diffStat ? [workspace.diffStat.additions, workspace.diffStat.deletions] : null,
+        ]);
+    }
+    function resolveTargetByWorkspaceId(workspaceId) {
+        for (const target of watchTargets.values()) {
+            if (target.workspaceId === workspaceId) {
+                return target;
+            }
+        }
+        return null;
+    }
+    function rememberDescriptorState(workspaceId, workspace) {
+        const target = resolveTargetByWorkspaceId(workspaceId);
+        if (!target) {
+            return;
+        }
+        target.latestDescriptorStateKey = descriptorStateKey(workspace);
+        target.lastBranchName = workspace?.name ?? null;
+    }
+    function removeForCwd(cwd) {
+        const normalizedCwd = resolve(cwd);
+        watchTargets.delete(normalizedCwd);
+        subscriptions.get(normalizedCwd)?.();
+        subscriptions.delete(normalizedCwd);
+    }
+    function handleBranchSnapshot(cwd, branchName) {
+        const target = watchTargets.get(resolve(cwd));
+        if (!target) {
+            return;
+        }
+        const previousBranchName = target.lastBranchName;
+        if (branchName === previousBranchName) {
+            return;
+        }
+        target.lastBranchName = branchName;
+        onBranchChanged?.(target.workspaceId, previousBranchName, branchName);
+    }
+    function syncObserver(cwd, options) {
+        const normalizedCwd = resolve(cwd);
+        if (!options.isGit) {
+            removeForCwd(normalizedCwd);
+            return;
+        }
+        if (subscriptions.has(normalizedCwd)) {
+            return;
+        }
+        const target = {
+            cwd: normalizedCwd,
+            workspaceId: options.workspaceId,
+            latestDescriptorStateKey: null,
+            lastBranchName: null,
+        };
+        watchTargets.set(normalizedCwd, target);
+        const subscription = workspaceGitService.registerWorkspace({ cwd: normalizedCwd }, (snapshot) => {
+            handleBranchSnapshot(normalizedCwd, snapshot.git.currentBranch ?? null);
+            void emitWorkspaceUpdateForCwd(normalizedCwd).catch((error) => {
+                logger.warn({ err: error, cwd: normalizedCwd }, "Failed to emit workspace update after git branch snapshot");
+            });
+            emitStatusUpdate(normalizedCwd, snapshot);
+        });
+        subscriptions.set(normalizedCwd, subscription.unsubscribe);
+    }
+    function syncObservers(workspaces) {
+        for (const workspace of workspaces) {
+            syncObserver(workspace.workspaceDirectory, {
+                isGit: workspace.projectKind === "git",
+                workspaceId: workspace.id,
+            });
+            rememberDescriptorState(workspace.workspaceDirectory, workspace);
+        }
+    }
+    async function syncObserverForWorkspace(workspace) {
+        const descriptor = await describeWorkspaceRecordWithGitData(workspace);
+        syncObservers([descriptor]);
+    }
+    return {
+        syncObservers,
+        syncObserverForWorkspace,
+        async warmGitData(workspace) {
+            await syncObserverForWorkspace(workspace);
+            await emitWorkspaceUpdateForWorkspaceId(workspace.workspaceId);
+        },
+        shouldSkipUpdate(workspaceId, workspace) {
+            const target = resolveTargetByWorkspaceId(workspaceId);
+            if (!target) {
+                return false;
+            }
+            const nextStateKey = descriptorStateKey(workspace);
+            if (target.latestDescriptorStateKey === nextStateKey) {
+                return true;
+            }
+            target.latestDescriptorStateKey = nextStateKey;
+            return false;
+        },
+        recordDescriptorState(workspaceId, nextWorkspace) {
+            const target = resolveTargetByWorkspaceId(workspaceId);
+            if (target && onBranchChanged) {
+                const newBranchName = nextWorkspace?.name ?? null;
+                if (newBranchName !== target.lastBranchName) {
+                    onBranchChanged(workspaceId, target.lastBranchName, newBranchName);
+                }
+            }
+            rememberDescriptorState(workspaceId, nextWorkspace);
+        },
+        handleBranchSnapshot,
+        removeForWorkspaceId(workspaceId) {
+            const target = resolveTargetByWorkspaceId(workspaceId);
+            if (target) {
+                removeForCwd(target.cwd);
+            }
+        },
+        removeForCwd,
+        dispose() {
+            for (const unsubscribe of subscriptions.values()) {
+                unsubscribe();
+            }
+            subscriptions.clear();
+            watchTargets.clear();
+        },
+    };
+}
+//# sourceMappingURL=workspace-git-observer-service.js.map

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.d.ts

@@ -0,0 +1,34 @@
+import { type PersistedProjectRecord, type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "../../workspace-registry.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+import type { CreatePaseoWorktreeWorkflowResult } from "../../worktree-session.js";
+/**
+ * Resolves which workspace and project records a directory belongs to, creating,
+ * reclassifying, or unarchiving them as needed. Every path that needs a workspace
+ * for a cwd — opening a project, importing an agent, creating an agent, restoring
+ * an archived worktree — funnels through this one module, so the
+ * classify → resolve-project → persist → unarchive sequence (and the
+ * archived-reopen-at-a-different-path and reclassify-vs-unarchive special cases)
+ * lives in a single place instead of being smeared across the session.
+ *
+ * Read-only path resolution (no create/persist) lives in resolve-workspace-id-for-path.ts;
+ * this module owns the create-and-persist side.
+ */
+export interface ResolveOrCreateWorkspaceIdInput {
+    createdWorktree: CreatePaseoWorktreeWorkflowResult | null;
+    requestedWorkspaceId?: string;
+    cwd: string;
+    initialTitle: string | null;
+}
+export interface WorkspaceProvisioningService {
+    findOrCreateWorkspaceForDirectory(cwd: string): Promise<PersistedWorkspaceRecord>;
+    resolveOrCreateWorkspaceIdForCreateAgent(input: ResolveOrCreateWorkspaceIdInput): Promise<string>;
+    createWorkspaceForDirectory(cwd: string, title?: string | null): Promise<PersistedWorkspaceRecord>;
+    findOrCreateProjectForDirectory(cwd: string): Promise<PersistedProjectRecord>;
+    ensureWorkspaceRecordUnarchived(workspace: PersistedWorkspaceRecord): Promise<PersistedWorkspaceRecord>;
+}
+export declare function createWorkspaceProvisioningService(deps: {
+    workspaceRegistry: WorkspaceRegistry;
+    projectRegistry: ProjectRegistry;
+    workspaceGitService: Pick<WorkspaceGitService, "getCheckout" | "peekSnapshot">;
+}): WorkspaceProvisioningService;
+//# sourceMappingURL=workspace-provisioning-service.d.ts.map

package/dist/server/server/session/workspace-provisioning/workspace-provisioning-service.js

@@ -0,0 +1,190 @@
+import { resolve } from "node:path";
+import { checkoutLiteFromGitSnapshot, classifyDirectoryForProjectMembership, generateWorkspaceId, } from "../../workspace-registry-model.js";
+import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from "../../workspace-registry.js";
+export function createWorkspaceProvisioningService(deps) {
+    const { workspaceRegistry, projectRegistry, workspaceGitService } = deps;
+    async function resolveWorkspaceDirectory(cwd, options) {
+        const normalizedCwd = resolve(cwd);
+        if (options?.refreshGit === false) {
+            const snapshot = workspaceGitService.peekSnapshot(normalizedCwd);
+            return resolve(snapshot?.git.repoRoot ?? normalizedCwd);
+        }
+        const checkout = await workspaceGitService.getCheckout(normalizedCwd);
+        return resolve(checkout.worktreeRoot ?? normalizedCwd);
+    }
+    async function findExactWorkspaceByDirectory(cwd, options) {
+        const normalizedCwd = await resolveWorkspaceDirectory(cwd, options);
+        const workspaces = await workspaceRegistry.list();
+        return workspaces.find((workspace) => workspace.cwd === normalizedCwd) ?? null;
+    }
+    async function resolveProjectRecordForPlacement(input) {
+        const rootPath = input.membership.projectRootPath;
+        const kind = input.membership.projectKind;
+        const projects = await 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 function reclassifyOrUnarchiveWorkspaceForDirectory(input) {
+        const checkout = await workspaceGitService.getCheckout(input.cwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd: input.cwd, checkout });
+        const timestamp = new Date().toISOString();
+        const projectRecord = await 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 projectRegistry.upsert(projectRecord);
+            }
+            return ensureWorkspaceRecordUnarchived(input.workspace);
+        }
+        await projectRegistry.upsert(projectRecord);
+        const nextWorkspace = {
+            ...input.workspace,
+            projectId,
+            cwd: input.cwd,
+            kind,
+            displayName,
+            archivedAt: null,
+            updatedAt: timestamp,
+        };
+        await workspaceRegistry.upsert(nextWorkspace);
+        return nextWorkspace;
+    }
+    async function findOrCreateWorkspaceForDirectory(cwd) {
+        const inputCwd = resolve(cwd);
+        const normalizedCwd = await resolveWorkspaceDirectory(cwd);
+        const existingWorkspace = await 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 resolveProjectRecordForPlacement({
+                    membership,
+                    timestamp,
+                });
+                await projectRegistry.upsert(projectRecord);
+                const workspaceRecord = createPersistedWorkspaceRecord({
+                    workspaceId: generateWorkspaceId(),
+                    projectId: projectRecord.projectId,
+                    cwd: inputCwd,
+                    kind: membership.workspaceKind,
+                    displayName: membership.workspaceDisplayName,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                });
+                await workspaceRegistry.upsert(workspaceRecord);
+                return workspaceRecord;
+            }
+            return reclassifyOrUnarchiveWorkspaceForDirectory({
+                workspace: existingWorkspace,
+                project: await projectRegistry.get(existingWorkspace.projectId),
+                cwd: normalizedCwd,
+            });
+        }
+        return createWorkspaceForDirectory(normalizedCwd);
+    }
+    async function resolveOrCreateWorkspaceIdForCreateAgent(input) {
+        if (input.createdWorktree) {
+            return input.createdWorktree.workspace.workspaceId;
+        }
+        if (input.requestedWorkspaceId) {
+            return input.requestedWorkspaceId;
+        }
+        return (await createWorkspaceForDirectory(input.cwd, input.initialTitle)).workspaceId;
+    }
+    async function createWorkspaceForDirectory(cwd, title) {
+        const checkout = await workspaceGitService.getCheckout(cwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd, checkout });
+        const timestamp = new Date().toISOString();
+        const projectRecord = await resolveProjectRecordForPlacement({
+            membership,
+            timestamp,
+        });
+        await 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 workspaceRegistry.upsert(workspaceRecord);
+        return workspaceRecord;
+    }
+    async function findOrCreateProjectForDirectory(cwd) {
+        const normalizedCwd = resolve(cwd);
+        const checkout = await workspaceGitService.getCheckout(normalizedCwd);
+        const membership = classifyDirectoryForProjectMembership({ cwd: normalizedCwd, checkout });
+        const projectRecord = await resolveProjectRecordForPlacement({
+            membership,
+            timestamp: new Date().toISOString(),
+        });
+        await projectRegistry.upsert(projectRecord);
+        return projectRecord;
+    }
+    async function ensureWorkspaceRecordUnarchived(workspace) {
+        const project = await 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 workspaceRegistry.upsert(unarchivedWorkspace);
+        }
+        if (project?.archivedAt) {
+            await projectRegistry.upsert({
+                ...project,
+                archivedAt: null,
+                updatedAt: timestamp,
+            });
+        }
+        return unarchivedWorkspace;
+    }
+    return {
+        findOrCreateWorkspaceForDirectory,
+        resolveOrCreateWorkspaceIdForCreateAgent,
+        createWorkspaceForDirectory,
+        findOrCreateProjectForDirectory,
+        ensureWorkspaceRecordUnarchived,
+    };
+}
+//# sourceMappingURL=workspace-provisioning-service.js.map

package/dist/server/server/session/workspace-scripts/workspace-scripts-service.d.ts

@@ -0,0 +1,41 @@
+import type pino from "pino";
+import type { SessionOutboundMessage, StartWorkspaceScriptRequest, WorkspaceDescriptorPayload } from "../../messages.js";
+import type { TerminalManager } from "../../../terminal/terminal-manager.js";
+import type { ServiceProxySubsystem } from "../../service-proxy.js";
+import type { WorkspaceScriptRuntimeStore } from "../../workspace-script-runtime-store.js";
+import type { ScriptHealthState } from "../../script-health-monitor.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+import type { WorkspaceRegistry } from "../../workspace-registry.js";
+import type { SpawnWorkspaceScriptOptions, WorktreeScriptResult } from "../../worktree-bootstrap.js";
+type WorkspaceScriptsPayload = WorkspaceDescriptorPayload["scripts"];
+/**
+ * The service-proxy-backed scripts a workspace exposes: build the scripts payload
+ * snapshot, emit a script_status_update to clients, and start a script.
+ *
+ * The workspace descriptor builder, the script-status emission path, and the
+ * start-script RPC all funnel through one assembly of buildWorkspaceScriptPayloads'
+ * inputs and one "scripts available on this daemon?" guard, instead of duplicating
+ * that assembly and guard across the session.
+ */
+export interface WorkspaceScriptsService {
+    buildSnapshot(workspaceId: string, workspaceDirectory: string): WorkspaceScriptsPayload;
+    emitStatusUpdate(workspaceId: string, workspaceDirectory: string): void;
+    start(request: StartWorkspaceScriptRequest): Promise<void>;
+}
+type WorkspaceScriptsGitSource = Pick<WorkspaceGitService, "peekSnapshot" | "getWorkspaceGitMetadata">;
+export declare function createWorkspaceScriptsService(deps: {
+    serviceProxy: ServiceProxySubsystem | null;
+    scriptRuntimeStore: WorkspaceScriptRuntimeStore | null;
+    terminalManager: TerminalManager | null;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get">;
+    workspaceGitService: WorkspaceScriptsGitSource;
+    getDaemonTcpPort: (() => number | null) | null;
+    getDaemonTcpHost: (() => string | null) | null;
+    serviceProxyPublicBaseUrl: string | null;
+    resolveScriptHealth: ((hostname: string) => ScriptHealthState | null) | null;
+    logger: pino.Logger;
+    emit: (message: SessionOutboundMessage) => void;
+    spawnWorkspaceScript: (options: SpawnWorkspaceScriptOptions) => Promise<WorktreeScriptResult>;
+}): WorkspaceScriptsService;
+export {};
+//# sourceMappingURL=workspace-scripts-service.d.ts.map

package/dist/server/server/session/workspace-scripts/workspace-scripts-service.js

@@ -0,0 +1,100 @@
+import { buildWorkspaceScriptPayloads, readPaseoConfigForProjection, } from "../../script-status-projection.js";
+import { deriveProjectSlug } from "../../workspace-git-metadata.js";
+export function createWorkspaceScriptsService(deps) {
+    const { serviceProxy, scriptRuntimeStore, terminalManager, workspaceRegistry, workspaceGitService, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, logger, emit, spawnWorkspaceScript, } = deps;
+    function resolveGitMetadata(workspaceDirectory) {
+        const snapshot = workspaceGitService.peekSnapshot(workspaceDirectory);
+        if (!snapshot) {
+            return undefined;
+        }
+        return {
+            projectSlug: deriveProjectSlug(workspaceDirectory, snapshot.git.isGit ? snapshot.git.remoteUrl : null),
+            currentBranch: snapshot.git.currentBranch,
+        };
+    }
+    function buildSnapshot(workspaceId, workspaceDirectory) {
+        if (!serviceProxy || !scriptRuntimeStore) {
+            return [];
+        }
+        return buildWorkspaceScriptPayloads({
+            workspaceId,
+            workspaceDirectory,
+            paseoConfig: readPaseoConfigForProjection(workspaceDirectory, logger),
+            serviceProxy,
+            runtimeStore: scriptRuntimeStore,
+            daemonPort: getDaemonTcpPort?.() ?? null,
+            serviceProxyPublicBaseUrl,
+            gitMetadata: resolveGitMetadata(workspaceDirectory),
+            resolveHealth: resolveScriptHealth ?? undefined,
+        });
+    }
+    function emitStatusUpdate(workspaceId, workspaceDirectory) {
+        emit({
+            type: "script_status_update",
+            payload: {
+                workspaceId,
+                scripts: buildSnapshot(workspaceId, workspaceDirectory),
+            },
+        });
+    }
+    async function start(request) {
+        try {
+            if (!terminalManager || !serviceProxy || !scriptRuntimeStore) {
+                throw new Error("Workspace scripts are not available on this daemon");
+            }
+            const workspace = await workspaceRegistry.get(request.workspaceId);
+            if (!workspace) {
+                throw new Error(`Workspace not found: ${request.workspaceId}`);
+            }
+            const gitMetadata = await workspaceGitService.getWorkspaceGitMetadata(workspace.cwd);
+            const serviceResult = await spawnWorkspaceScript({
+                repoRoot: workspace.cwd,
+                workspaceId: workspace.workspaceId,
+                projectSlug: gitMetadata.projectSlug,
+                branchName: gitMetadata.currentBranch,
+                scriptName: request.scriptName,
+                daemonPort: getDaemonTcpPort?.() ?? null,
+                daemonListenHost: getDaemonTcpHost?.() ?? null,
+                serviceProxyPublicBaseUrl,
+                serviceProxy,
+                runtimeStore: scriptRuntimeStore,
+                terminalManager,
+                logger,
+                onLifecycleChanged: () => {
+                    emitStatusUpdate(workspace.workspaceId, workspace.cwd);
+                },
+            });
+            emitStatusUpdate(workspace.workspaceId, workspace.cwd);
+            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";
+            logger.error({
+                err: error,
+                workspaceId: request.workspaceId,
+                scriptName: request.scriptName,
+            }, "Failed to start workspace script");
+            emit({
+                type: "start_workspace_script_response",
+                payload: {
+                    requestId: request.requestId,
+                    workspaceId: request.workspaceId,
+                    scriptName: request.scriptName,
+                    terminalId: null,
+                    error: message,
+                },
+            });
+        }
+    }
+    return { buildSnapshot, emitStatusUpdate, start };
+}
+//# sourceMappingURL=workspace-scripts-service.js.map

package/dist/server/server/session.d.ts

@@ -14,6 +14,7 @@ import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
 import type { AgentStorage } from "./agent/agent-storage.js";
 import { type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "./workspace-registry.js";
 import { type DaemonRuntimeConfig } from "./session/daemon/daemon-session.js";
+import type { DaemonWebSocketRuntimeDiagnosticSnapshot } from "./session/daemon/diagnostics.js";
 import { DownloadTokenStore } from "./file-download/token-store.js";
 import { PushTokenStore } from "./push/token-store.js";
 import type { ServiceProxySubsystem } from "./service-proxy.js";
@@ -103,6 +104,7 @@ export interface SessionOptions {
     serverId?: string;
     daemonVersion?: string;
     daemonRuntimeConfig?: DaemonRuntimeConfig;
+    getWebSocketRuntimeMetrics?: () => DaemonWebSocketRuntimeDiagnosticSnapshot | null;
 }
 export type SessionLifecycleIntent = {
     type: "shutdown";
@@ -131,8 +133,6 @@ export declare class Session {
     private readonly sessionLogger;
     private readonly paseoHome;
     private readonly worktreesRoot;
-    private agentMcpClient;
-    private agentTools;
     private agentManager;
     private readonly agentStorage;
     private readonly projectRegistry;
@@ -142,19 +142,19 @@ export declare class Session {
     private readonly renameCurrentBranch;
     private readonly generateWorkspaceName;
     private readonly workspaceGitService;
+    private readonly gitMutation;
+    private readonly workspaceProvisioning;
     private readonly daemonConfigStore;
-    private readonly mcpBaseUrl;
     private readonly pushTokenStore;
     private unsubscribeAgentEvents;
     private unsubscribeTerminalWorkspaceContributionEvents;
-    private agentUpdatesSubscription;
+    private readonly agentUpdates;
     private workspaceUpdatesSubscription;
     private clientActivity;
     private readonly terminalManager;
     private readonly providerSnapshotManager;
     private readonly serviceProxy;
     private readonly scriptRuntimeStore;
-    private readonly onBranchChanged?;
     private readonly getDaemonTcpPort;
     private readonly getDaemonTcpHost;
     private readonly serviceProxyPublicBaseUrl;
@@ -162,10 +162,8 @@ export declare class Session {
     private readonly terminalController;
     private inflightRequests;
     private peakInflightRequests;
-    private readonly workspaceGitWatchTargets;
     private readonly workspaceSetupSnapshots;
-    private readonly workspaceGitFetchSubscriptions;
-    private readonly workspaceGitSubscriptions;
+    private readonly workspaceGitObserver;
     private readonly workspaceDirectory;
     private readonly voiceSession;
     private readonly checkoutSession;
@@ -175,6 +173,7 @@ export declare class Session {
     private readonly agentConfigSession;
     private readonly projectConfigSession;
     private readonly daemonSession;
+    private readonly workspaceScripts;
     private readonly createAgentLifecycleDispatch;
     constructor(options: SessionOptions);
     updateAppVersion(appVersion: string | null): void;
@@ -217,10 +216,6 @@ export declare class Session {
     private interruptAgentIfRunning;
     private hasActiveAgentRun;
     private handleAgentRunError;
-    /**
-     * Initialize Agent MCP client for this session using the daemon's HTTP MCP endpoint.
-     */
-    private initializeAgentMcp;
     /**
      * Subscribe to AgentManager events and forward them to the client
      */
@@ -230,19 +225,9 @@ export declare class Session {
     private buildAgentPayload;
     private buildStoredAgentPayload;
     private isProviderVisibleToClient;
-    private agentThinkingOptionMatchesFilter;
-    private matchesAgentStructuralFilter;
-    private matchesAgentFilter;
-    private getAgentUpdateTargetId;
-    private bufferOrEmitAgentUpdate;
-    private emitStoredAgentUpdate;
-    private flushBootstrappedAgentUpdates;
-    private findExactWorkspaceByDirectory;
-    private resolveWorkspaceDirectory;
     private buildProjectPlacementForWorkspace;
     private buildProjectPlacementForWorkspaceId;
     private buildProjectPlacementForExistingWorkspaceProject;
-    private forwardAgentUpdate;
     /**
      * Main entry point for processing session messages
      */
@@ -295,16 +280,7 @@ export declare class Session {
     private generateWorkspaceTitleFromContext;
     private maybeAutoNameDirectoryWorkspaceTitle;
     private scheduleAutoNameLocalWorkspaceTitleForFirstAgent;
-    private assertSafeGitRef;
     private isPathWithinRoot;
-    private generateCommitMessage;
-    private generatePullRequestText;
-    private ensureCleanWorkingTree;
-    private isWorkingTreeDirty;
-    private checkoutExistingBranch;
-    private createBranchFromBase;
-    private doesLocalBranchExist;
-    private notifyGitMutation;
     /**
      * Handle clearing agent attention flag
      */
@@ -327,16 +303,6 @@ export declare class Session {
      */
     private handleAgentPermissionResponse;
     private handleDirectorySuggestionsRequest;
-    private closeWorkspaceGitWatchTarget;
-    private removeWorkspaceGitWatchTarget;
-    private removeWorkspaceGitSubscription;
-    private workspaceGitDescriptorStateKey;
-    private resolveWorkspaceGitWatchTarget;
-    private shouldSkipWorkspaceGitWatchUpdate;
-    private rememberWorkspaceGitDescriptorState;
-    private handleWorkspaceGitBranchSnapshot;
-    private syncWorkspaceGitObservers;
-    private syncWorkspaceGitObserver;
     private handlePaseoWorktreeListRequest;
     private handlePaseoWorktreeArchiveRequest;
     private listTerminalActivityContributions;
@@ -366,16 +332,9 @@ export declare class Session {
     private listFetchWorkspacesEntries;
     private bufferOrEmitWorkspaceUpdate;
     private flushBootstrappedWorkspaceUpdates;
-    private findOrCreateWorkspaceForDirectory;
-    private resolveOrCreateWorkspaceIdForCreateAgent;
-    private createWorkspaceForDirectory;
-    private findOrCreateProjectForDirectory;
     private buildProjectDescriptor;
-    private reclassifyOrUnarchiveWorkspaceForDirectory;
-    private resolveProjectRecordForPlacement;
     private unarchiveOwningWorkspaceForAgent;
     private recreateOwningWorktreeForRestore;
-    private ensureWorkspaceRecordUnarchived;
     private createPaseoWorktree;
     private listActiveWorkspaceRefs;
     private archiveWorkspaceRecord;
@@ -383,7 +342,6 @@ export declare class Session {
     private reconcileAndEmitWorkspaceUpdates;
     private reconcileActiveWorkspaceRecords;
     private emitWorkspaceUpdatesForWorkspaceIds;
-    private recordWorkspaceGitDescriptorState;
     private buildWorkspaceRemoveUpdatePayload;
     private resolveProjectWithoutActiveWorkspacesForArchivedWorkspace;
     private emitWorkspaceUpdateForTerminalContribution;
@@ -402,8 +360,6 @@ export declare class Session {
     private handleOpenProjectRequest;
     private handleProjectAddRequest;
     private buildWorkspaceScriptPayloadSnapshot;
-    private resolveWorkspaceScriptGitMetadata;
-    private emitWorkspaceScriptStatusUpdate;
     private handleStartWorkspaceScriptRequest;
     private handleLegacyListAvailableEditorsRequest;
     private handleLegacyOpenInEditorRequest;