@getpaseo/server 0.1.100 → 0.1.101

package/dist/server/server/agent/tools/types.d.ts

@@ -0,0 +1,36 @@
+import type { z } from "zod";
+export interface PaseoToolExecutionContext {
+    signal?: AbortSignal;
+}
+export interface PaseoToolResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    structuredContent?: unknown;
+    isError?: boolean;
+}
+export interface PaseoToolConfig {
+    title?: string;
+    description?: string;
+    inputSchema?: z.ZodRawShape | z.ZodType;
+    outputSchema?: z.ZodRawShape | z.ZodType;
+}
+export interface PaseoToolDefinition extends PaseoToolConfig {
+    name: string;
+    description: string;
+    handler: (input: unknown, context: PaseoToolExecutionContext) => Promise<PaseoToolResult>;
+}
+export interface PaseoToolCatalog {
+    tools: ReadonlyMap<string, PaseoToolDefinition>;
+    getTool(name: string): PaseoToolDefinition | undefined;
+    executeTool(name: string, input: unknown, context?: PaseoToolExecutionContext): Promise<PaseoToolResult>;
+}
+export interface PaseoToolRuntimeContext {
+    callerAgentId?: string;
+    enableVoiceTools?: boolean;
+    voiceOnly?: boolean;
+}
+export type PaseoToolCatalogFactory = (context: PaseoToolRuntimeContext) => PaseoToolCatalog | Promise<PaseoToolCatalog>;
+//# sourceMappingURL=types.d.ts.map

package/dist/server/server/agent/tools/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/server/server/bootstrap.js

@@ -83,6 +83,7 @@ import { AgentManager } from "./agent/agent-manager.js";
 import { AgentStorage } from "./agent/agent-storage.js";
 import { attachAgentStoragePersistence } from "./persistence-hooks.js";
 import { createAgentMcpServer } from "./agent/mcp-server.js";
+import { createPaseoToolCatalog, } from "./agent/tools/paseo-tools.js";
 import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
 import { bootstrapWorkspaceRegistries } from "./workspace-registry-bootstrap.js";
 import { WorkspaceReconciliationService } from "./workspace-reconciliation-service.js";
@@ -612,73 +613,79 @@ export async function createPaseoDaemon(config, rootLogger) {
         clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
         emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
     });
+    const createPaseoWorktreeForTools = async (input, serviceOptions) => {
+        return createPaseoWorktreeWorkflow({
+            paseoHome: config.paseoHome,
+            worktreesRoot: config.worktreesRoot,
+            createPaseoWorktree: async (workflowInput, workflowOptions) => {
+                return createRegisteredPaseoWorktree(workflowInput, {
+                    github,
+                    ...(workflowOptions?.resolveDefaultBranch
+                        ? {
+                            resolveDefaultBranch: workflowOptions.resolveDefaultBranch,
+                        }
+                        : {}),
+                    projectRegistry,
+                    workspaceRegistry,
+                    workspaceGitService,
+                });
+            },
+            warmWorkspaceGitData: async (workspace) => {
+                await Promise.all(wsServer
+                    ?.listActiveSessions()
+                    .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
+            },
+            emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
+                await emitWorkspaceUpdatesExternal([workspaceId]);
+            },
+            cacheWorkspaceSetupSnapshot: () => { },
+            emit: emitExternalSessionMessage,
+            sessionLogger: logger,
+            terminalManager,
+            archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+            serviceProxy,
+            scriptRuntimeStore,
+            getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+            getDaemonTcpHost: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.host : null),
+            serviceProxyPublicBaseUrl,
+            onScriptsChanged: null,
+        }, input, serviceOptions);
+    };
+    const createAgentToolHostDependencies = (runtime) => ({
+        agentManager,
+        agentStorage,
+        terminalManager,
+        getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
+        scheduleService,
+        providerSnapshotManager,
+        github,
+        workspaceGitService,
+        findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+        listActiveWorkspaces: listActiveWorkspacesExternal,
+        archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
+        emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
+        markWorkspaceArchiving: markWorkspaceArchivingExternal,
+        clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
+        ensureWorkspaceForCreate: ensureWorkspaceForCreateExternal,
+        createPaseoWorktree: createPaseoWorktreeForTools,
+        paseoHome: config.paseoHome,
+        worktreesRoot: config.worktreesRoot,
+        callerAgentId: runtime.callerAgentId,
+        enableVoiceTools: runtime.enableVoiceTools,
+        voiceOnly: runtime.voiceOnly,
+        resolveSpeakHandler: (agentId) => wsServer?.resolveVoiceSpeakHandler(agentId) ?? null,
+        resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
+        logger,
+    });
+    const createAgentToolCatalog = (runtime) => createPaseoToolCatalog(createAgentToolHostDependencies(runtime));
+    agentManager.setPaseoToolCatalogFactory(createAgentToolCatalog);
+    agentManager.setPaseoToolsEnabled(config.mcpInjectIntoAgents !== false);
     const mcpEnabled = config.mcpEnabled ?? true;
     let agentMcpBaseUrl = null;
     if (mcpEnabled) {
         const agentMcpRoute = "/mcp/agents";
         const createAgentMcpSession = async (callerAgentId) => {
-            const agentMcpServer = await createAgentMcpServer({
-                agentManager,
-                agentStorage,
-                terminalManager,
-                getDaemonTcpPort: () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null),
-                scheduleService,
-                providerSnapshotManager,
-                github,
-                workspaceGitService,
-                findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
-                listActiveWorkspaces: listActiveWorkspacesExternal,
-                archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
-                emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
-                markWorkspaceArchiving: markWorkspaceArchivingExternal,
-                clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
-                ensureWorkspaceForCreate: ensureWorkspaceForCreateExternal,
-                createPaseoWorktree: async (input, serviceOptions) => {
-                    return createPaseoWorktreeWorkflow({
-                        paseoHome: config.paseoHome,
-                        worktreesRoot: config.worktreesRoot,
-                        createPaseoWorktree: async (workflowInput, workflowOptions) => {
-                            return createRegisteredPaseoWorktree(workflowInput, {
-                                github,
-                                ...(workflowOptions?.resolveDefaultBranch
-                                    ? {
-                                        resolveDefaultBranch: workflowOptions.resolveDefaultBranch,
-                                    }
-                                    : {}),
-                                projectRegistry,
-                                workspaceRegistry,
-                                workspaceGitService,
-                            });
-                        },
-                        warmWorkspaceGitData: async (workspace) => {
-                            await Promise.all(wsServer
-                                ?.listActiveSessions()
-                                .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
-                        },
-                        emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
-                            await emitWorkspaceUpdatesExternal([workspaceId]);
-                        },
-                        cacheWorkspaceSetupSnapshot: () => { },
-                        emit: emitExternalSessionMessage,
-                        sessionLogger: logger,
-                        terminalManager,
-                        archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
-                        serviceProxy,
-                        scriptRuntimeStore,
-                        getDaemonTcpPort: () => boundListenTarget?.type === "tcp" ? boundListenTarget.port : null,
-                        getDaemonTcpHost: () => boundListenTarget?.type === "tcp" ? boundListenTarget.host : null,
-                        serviceProxyPublicBaseUrl,
-                        onScriptsChanged: null,
-                    }, input, serviceOptions);
-                },
-                paseoHome: config.paseoHome,
-                worktreesRoot: config.worktreesRoot,
-                callerAgentId,
-                enableVoiceTools: false,
-                resolveSpeakHandler: (agentId) => wsServer?.resolveVoiceSpeakHandler(agentId) ?? null,
-                resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
-                logger,
-            });
+            const agentMcpServer = await createAgentMcpServer(createAgentToolHostDependencies({ callerAgentId }));
             // Stateless mode: each HTTP request builds a fresh server + transport that is
             // torn down when the response closes, so no per-session state is retained between
             // requests. The agent control plane only lists and calls tools, neither of which
@@ -810,8 +817,10 @@ export async function createPaseoDaemon(config, rootLogger) {
                         const mcpBaseUrl = mcpEnabled ? createAgentMcpBaseUrl(boundListenTarget) : null;
                         agentMcpBaseUrl = config.mcpInjectIntoAgents === false ? null : mcpBaseUrl;
                         agentManager.setMcpBaseUrl(agentMcpBaseUrl);
+                        agentManager.setPaseoToolsEnabled(config.mcpInjectIntoAgents !== false);
                         daemonConfigStore.onFieldChange("mcp.injectIntoAgents", (value) => {
                             agentManager.setMcpBaseUrl(value ? mcpBaseUrl : null);
+                            agentManager.setPaseoToolsEnabled(value !== false);
                         });
                         daemonConfigStore.onFieldChange("appendSystemPrompt", (value) => {
                             agentManager.setAppendSystemPrompt(typeof value === "string" ? value : "");

package/dist/server/server/persisted-config.d.ts

@@ -133,6 +133,11 @@ export declare const PersistedConfigSchema: z.ZodObject<{
     providers: z.ZodOptional<z.ZodObject<{
         openai: z.ZodOptional<z.ZodObject<{
             apiKey: z.ZodOptional<z.ZodString>;
+            voice: z.ZodOptional<z.ZodObject<{
+                apiKey: z.ZodOptional<z.ZodString>;
+                baseUrl: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            baseUrl: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         local: z.ZodOptional<z.ZodObject<{
             modelsDir: z.ZodOptional<z.ZodString>;

package/dist/server/server/persisted-config.js

@@ -34,9 +34,17 @@ const LogConfigSchema = z
         .optional(),
 })
     .strict();
-const ProviderCredentialsSchema = z
+const OpenAiVoiceProviderSchema = z
+    .object({
+    apiKey: z.string().trim().min(1).optional(),
+    baseUrl: z.string().trim().min(1).optional(),
+})
+    .strict();
+const OpenAiProviderSchema = z
     .object({
     apiKey: z.string().min(1).optional(),
+    voice: OpenAiVoiceProviderSchema.optional(),
+    baseUrl: z.string().trim().min(1).optional(),
 })
     .strict();
 const LocalSpeechProviderSchema = z
@@ -46,7 +54,7 @@ const LocalSpeechProviderSchema = z
     .strict();
 const ProvidersSchema = z
     .object({
-    openai: ProviderCredentialsSchema.optional(),
+    openai: OpenAiProviderSchema.optional(),
     local: LocalSpeechProviderSchema.optional(),
 })
     .strict();

package/dist/server/server/session/agent-updates/agent-updates-service.d.ts

@@ -0,0 +1,59 @@
+import type pino from "pino";
+import type { AgentSnapshotPayload, ProjectPlacementPayload, SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import type { StoredAgentRecord } from "../../agent/agent-storage.js";
+type AgentUpdatesFilter = NonNullable<Extract<SessionInboundMessage, {
+    type: "fetch_agents_request";
+}>["filter"]>;
+/**
+ * Owns the single per-client `agent_update` subscription: when a client subscribes
+ * via `fetch_agents_request`, every later agent lifecycle change (live forward,
+ * stored-record archive/detach, delete) is filtered against the subscription's
+ * filter and either emitted or — while the initial snapshot is still being built —
+ * buffered and replayed on flush. Keeping the mutable subscription state, the
+ * bootstrap buffer, the provider-visibility gate, and the filter predicate behind
+ * one interface stops the rest of session.ts from poking the subscription shape or
+ * hand-rolling `agent_update` payloads, and the (previously untested) filter/buffer/
+ * flush branches become exercisable through injected fakes.
+ *
+ * The snapshot listing path applies the SAME filter via the pure
+ * `matchesAgentUpdatesFilter` so a subscription's initial page and its live updates
+ * stay consistent.
+ */
+export interface AgentUpdatesService {
+    beginSubscription(input: {
+        subscriptionId: string;
+        filter?: AgentUpdatesFilter;
+    }): void;
+    flushBootstrapped(subscriptionId: string, options?: {
+        snapshotUpdatedAtByAgentId?: Map<string, number>;
+    }): void;
+    clearSubscription(subscriptionId: string): void;
+    hasSubscription(): boolean;
+    forwardLiveAgent(agent: ManagedAgent): Promise<void>;
+    emitStoredRecord(record: StoredAgentRecord): Promise<AgentSnapshotPayload>;
+    removeAgent(agentId: string): void;
+    dispose(): void;
+}
+export interface AgentUpdatesServiceDeps {
+    emit(message: SessionOutboundMessage): void;
+    buildAgentPayload(agent: ManagedAgent): Promise<AgentSnapshotPayload>;
+    buildStoredAgentPayload(record: StoredAgentRecord): AgentSnapshotPayload;
+    isProviderVisibleToClient(provider: string): boolean;
+    buildProjectPlacementForWorkspaceId(workspaceId: string): Promise<ProjectPlacementPayload | null>;
+    emitWorkspaceUpdateForWorkspaceId(workspaceId: string): Promise<void>;
+    logger: pino.Logger;
+}
+/**
+ * Pure predicate shared by the live subscription stream and the snapshot listing
+ * pager: does an agent (with its resolved project placement) satisfy a
+ * `fetch_agents` filter?
+ */
+export declare function matchesAgentUpdatesFilter(input: {
+    agent: AgentSnapshotPayload;
+    project: ProjectPlacementPayload;
+    filter?: AgentUpdatesFilter;
+}): boolean;
+export declare function createAgentUpdatesService(deps: AgentUpdatesServiceDeps): AgentUpdatesService;
+export {};
+//# sourceMappingURL=agent-updates-service.d.ts.map

package/dist/server/server/session/agent-updates/agent-updates-service.js

@@ -0,0 +1,220 @@
+import { resolveEffectiveThinkingOptionId } from "../../agent/agent-projections.js";
+function 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;
+}
+function 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;
+}
+/**
+ * Pure predicate shared by the live subscription stream and the snapshot listing
+ * pager: does an agent (with its resolved project placement) satisfy a
+ * `fetch_agents` filter?
+ */
+export function matchesAgentUpdatesFilter(input) {
+    const { agent, project, filter } = input;
+    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 && !agentThinkingOptionMatchesFilter(agent, filter)) {
+        return false;
+    }
+    if (filter && !matchesAgentStructuralFilter(agent, project, filter)) {
+        return false;
+    }
+    return true;
+}
+function agentUpdateTargetId(update) {
+    return update.kind === "remove" ? update.agentId : update.agent.id;
+}
+export function createAgentUpdatesService(deps) {
+    let subscription = null;
+    function bufferOrEmit(sub, payload) {
+        if (payload.kind === "upsert" && !deps.isProviderVisibleToClient(payload.agent.provider)) {
+            return;
+        }
+        if (sub.isBootstrapping) {
+            sub.pendingUpdatesByAgentId.set(agentUpdateTargetId(payload), payload);
+            return;
+        }
+        deps.emit({
+            type: "agent_update",
+            payload,
+        });
+    }
+    function beginSubscription(input) {
+        subscription = {
+            subscriptionId: input.subscriptionId,
+            filter: input.filter,
+            isBootstrapping: true,
+            pendingUpdatesByAgentId: new Map(),
+        };
+    }
+    function flushBootstrapped(subscriptionId, options) {
+        if (!subscription || subscription.subscriptionId !== subscriptionId) {
+            return;
+        }
+        if (!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;
+                    }
+                }
+            }
+            deps.emit({
+                type: "agent_update",
+                payload,
+            });
+        }
+    }
+    function clearSubscription(subscriptionId) {
+        if (subscription && subscription.subscriptionId === subscriptionId) {
+            subscription = null;
+        }
+    }
+    function hasSubscription() {
+        return subscription !== null;
+    }
+    function removeAgent(agentId) {
+        if (!subscription) {
+            return;
+        }
+        bufferOrEmit(subscription, { kind: "remove", agentId });
+    }
+    async function emitStoredRecord(record) {
+        const payload = deps.buildStoredAgentPayload(record);
+        const sub = subscription;
+        if (!sub) {
+            return payload;
+        }
+        const project = payload.workspaceId
+            ? await deps.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+            : null;
+        if (!project) {
+            bufferOrEmit(sub, {
+                kind: "remove",
+                agentId: payload.id,
+            });
+            return payload;
+        }
+        const matches = matchesAgentUpdatesFilter({
+            agent: payload,
+            project,
+            filter: sub.filter,
+        });
+        bufferOrEmit(sub, matches
+            ? {
+                kind: "upsert",
+                agent: payload,
+                project,
+            }
+            : {
+                kind: "remove",
+                agentId: payload.id,
+            });
+        return payload;
+    }
+    async function forwardLiveAgent(agent) {
+        try {
+            const sub = subscription;
+            const payload = await deps.buildAgentPayload(agent);
+            if (sub) {
+                const project = payload.workspaceId
+                    ? await deps.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+                    : null;
+                if (!project) {
+                    bufferOrEmit(sub, {
+                        kind: "remove",
+                        agentId: payload.id,
+                    });
+                }
+                else {
+                    const matches = matchesAgentUpdatesFilter({
+                        agent: payload,
+                        project,
+                        filter: sub.filter,
+                    });
+                    if (matches) {
+                        bufferOrEmit(sub, {
+                            kind: "upsert",
+                            agent: payload,
+                            project,
+                        });
+                    }
+                    else {
+                        bufferOrEmit(sub, {
+                            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 deps.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
+            }
+        }
+        catch (error) {
+            deps.logger.error({ err: error }, "Failed to emit agent update");
+        }
+    }
+    function dispose() {
+        subscription = null;
+    }
+    return {
+        beginSubscription,
+        flushBootstrapped,
+        clearSubscription,
+        hasSubscription,
+        forwardLiveAgent,
+        emitStoredRecord,
+        removeAgent,
+        dispose,
+    };
+}
+//# sourceMappingURL=agent-updates-service.js.map

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

@@ -2,32 +2,26 @@ import type pino from "pino";
 import type { BranchSuggestionsRequest, CheckoutRefreshRequest, CheckoutRenameBranchRequest, CheckoutStatusRequest, SessionInboundMessage, SessionOutboundMessage, SubscribeCheckoutDiffRequest, UnsubscribeCheckoutDiffRequest, ValidateBranchRequest } from "../../messages.js";
 import type { CheckoutDiffCompareInput, CheckoutDiffSnapshotPayload } from "../../checkout-diff-manager.js";
 import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitService } from "../../workspace-git-service.js";
+import type { GitMutationService } from "../git-mutation/git-mutation-service.js";
 import { type GitHubService } from "../../../services/github-service.js";
-import { type CheckoutExistingBranchResult, type GitMutationRefreshReason } from "../../../utils/checkout-git.js";
+import type { GitMetadataGenerator } from "./git-metadata-generator.js";
 /**
  * The collaborators a checkout command reaches that are NOT part of the checkout
- * domain: the git-mutation refresh primitive and workspace-update emitters owned
- * by the Session shell (also used by worktree/workspace creation), the injected
- * branch operations, and the LLM-backed commit/PR text generators. CheckoutSession
- * orchestrates them but does not own them.
+ * domain and stay owned by the Session shell: client emit, workspace-update
+ * emission, the git branch-snapshot notifier, and the current-branch rename
+ * primitive. CheckoutSession orchestrates them but does not own them. The
+ * git-mutation primitives it performs (switch branch, force snapshot refresh) are
+ * injected separately as `gitMutation`, since they are shared with worktree and
+ * workspace creation.
  */
 export interface CheckoutSessionHost {
     emit(msg: SessionOutboundMessage): void;
-    notifyGitMutation(cwd: string, reason: GitMutationRefreshReason, options?: {
-        invalidateGithub?: boolean;
-    }): Promise<void>;
     emitWorkspaceUpdateForCwd(cwd: string): Promise<void>;
     handleWorkspaceGitBranchSnapshot(cwd: string, branchName: string | null): void;
     renameCurrentBranch(cwd: string, branch: string): Promise<{
         previousBranch: string | null;
         currentBranch: string | null;
     }>;
-    checkoutExistingBranch(cwd: string, branch: string): Promise<CheckoutExistingBranchResult>;
-    generateCommitMessage(cwd: string): Promise<string>;
-    generatePullRequestText(cwd: string, baseRef?: string): Promise<{
-        title: string;
-        body: string;
-    }>;
 }
 /**
  * The slice of CheckoutDiffManager that CheckoutSession needs: open a live diff
@@ -46,9 +40,11 @@ export interface CheckoutDiffSubscriber {
 }
 export interface CheckoutSessionOptions {
     host: CheckoutSessionHost;
+    gitMutation: Pick<GitMutationService, "checkoutExistingBranch" | "notifyGitMutation">;
     workspaceGitService: WorkspaceGitService;
     github: GitHubService;
     checkoutDiffManager: CheckoutDiffSubscriber;
+    gitMetadataGenerator: GitMetadataGenerator;
     paseoHome: string;
     worktreesRoot: string | undefined;
     logger: pino.Logger;
@@ -60,15 +56,17 @@ export interface CheckoutSessionOptions {
  * merge/pull/push/stash and the GitHub-PR operations).
  *
  * Command operations keep the live diff in sync by calling scheduleDiffRefresh()
- * and refresh the workspace git snapshot through host.notifyGitMutation(); the
+ * and refresh the workspace git snapshot through gitMutation.notifyGitMutation(); the
  * workspace git observer streams branch changes through emitStatusUpdate().
  */
 export declare class CheckoutSession {
     private static readonly PASEO_STASH_PREFIX;
     private readonly host;
+    private readonly gitMutation;
     private readonly workspaceGitService;
     private readonly github;
     private readonly checkoutDiffManager;
+    private readonly gitMetadataGenerator;
     private readonly paseoHome;
     private readonly worktreesRoot;
     private readonly logger;