@getpaseo/server 0.1.83 → 0.1.85

package/dist/server/server/agent/create-agent/create.js

@@ -0,0 +1,264 @@
+import { PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
+import { expandUserPath, resolvePathFromBase } from "../../path-utils.js";
+import { toWorktreeRequestError } from "../../worktree-errors.js";
+import { scheduleAgentMetadataGeneration } from "../agent-metadata-generator.js";
+import { setupFinishNotification, startCreatedAgentInitialPrompt } from "../agent-prompt.js";
+import { resolveClientMessageId } from "../../client-message-id.js";
+import { resolveRequiredProviderModel } from "../mcp-shared.js";
+import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "../timeline-append.js";
+export async function createAgentCommand(dependencies, input) {
+    const resolved = input.kind === "session"
+        ? await resolveSessionCreateAgent(dependencies, input)
+        : await resolveMcpCreateAgent(dependencies, input);
+    const snapshot = await dependencies.agentManager.createAgent(resolved.config, undefined, resolved.createOptions);
+    resolved.setupContinuation?.startAfterAgentCreate({
+        agentId: snapshot.id,
+    });
+    let liveSnapshot = snapshot;
+    let initialPromptStarted = false;
+    if (resolved.prompt !== undefined) {
+        const sendResult = await sendInitialPrompt(dependencies, resolved, snapshot);
+        initialPromptStarted = sendResult.started;
+        liveSnapshot = sendResult.liveSnapshot;
+    }
+    if (input.kind === "mcp" && input.notifyOnFinish && input.callerAgentId && initialPromptStarted) {
+        setupFinishNotification({
+            agentManager: dependencies.agentManager,
+            agentStorage: dependencies.agentStorage,
+            childAgentId: snapshot.id,
+            callerAgentId: input.callerAgentId,
+            logger: dependencies.logger,
+        });
+    }
+    return {
+        snapshot,
+        liveSnapshot,
+        background: resolved.background,
+        initialPromptStarted,
+    };
+}
+async function resolveSessionCreateAgent(dependencies, input) {
+    const trimmedPrompt = input.initialPrompt?.trim();
+    const { sessionConfig, setupContinuation } = await input.buildSessionConfig(input.config, input.git, input.worktreeName, input.firstAgentContext);
+    const workspace = await input.resolveWorkspace({
+        cwd: sessionConfig.cwd,
+        workspaceId: input.workspaceId,
+    });
+    const prompt = buildAgentPrompt(trimmedPrompt ?? "", input.images, input.attachments);
+    const hasPromptContent = Array.isArray(prompt) ? prompt.length > 0 : prompt.length > 0;
+    return {
+        config: sessionConfig,
+        createOptions: {
+            labels: input.labels,
+            workspaceId: workspace.workspaceId,
+            initialPrompt: trimmedPrompt,
+            env: input.env,
+            initialTitle: input.provisionalTitle,
+        },
+        metadataInitialPrompt: trimmedPrompt,
+        prompt: hasPromptContent ? prompt : undefined,
+        runOptions: input.outputSchema ? { outputSchema: input.outputSchema } : undefined,
+        explicitTitle: input.explicitTitle,
+        setupContinuation,
+        background: true,
+        promptFailure: "throw",
+        promptLogger: dependencies.logger.child({
+            clientMessageId: resolveClientMessageId(input.clientMessageId),
+        }),
+    };
+}
+async function resolveMcpCreateAgent(dependencies, input) {
+    const resolvedProviderModel = resolveRequiredProviderModel(input.provider);
+    const provider = resolvedProviderModel.provider;
+    const parentAgent = input.callerAgentId
+        ? requireParentAgent(dependencies.agentManager, input.callerAgentId)
+        : null;
+    const cwd = parentAgent
+        ? resolveChildAgentCwd({
+            parentCwd: parentAgent.cwd,
+            requestedCwd: input.cwd,
+            lockedCwd: input.callerContext?.lockedCwd,
+            allowCustomCwd: input.callerContext?.allowCustomCwd ?? true,
+        })
+        : expandUserPath(input.cwd ?? process.cwd());
+    const { resolvedCwd, setupContinuation } = await resolveMcpCwd({
+        dependencies,
+        cwd,
+        worktree: input.worktree,
+        initialPrompt: input.initialPrompt,
+    });
+    const { modeId: resolvedMode, featureValues: resolvedFeatures } = await dependencies.providerSnapshotManager.resolveCreateConfig({
+        cwd: resolvedCwd,
+        provider,
+        requestedMode: input.mode,
+        featureValues: input.features,
+        parent: parentAgent,
+    });
+    const labels = mergeLabels(input.callerAgentId, input.callerContext?.childAgentDefaultLabels, input.labels);
+    const trimmedPrompt = input.initialPrompt.trim();
+    return {
+        config: {
+            provider,
+            cwd: resolvedCwd,
+            modeId: resolvedMode,
+            title: input.title.trim(),
+            model: resolvedProviderModel.model,
+            thinkingOptionId: input.thinking,
+            ...(resolvedFeatures ? { featureValues: resolvedFeatures } : {}),
+        },
+        createOptions: labels ? { labels } : undefined,
+        metadataInitialPrompt: trimmedPrompt,
+        prompt: trimmedPrompt,
+        explicitTitle: input.title.trim(),
+        setupContinuation,
+        background: input.background,
+        promptFailure: "log",
+    };
+}
+async function sendInitialPrompt(dependencies, resolved, snapshot) {
+    scheduleAgentMetadataGeneration({
+        agentManager: dependencies.agentManager,
+        agentId: snapshot.id,
+        cwd: snapshot.cwd,
+        workspaceGitService: dependencies.workspaceGitService,
+        initialPrompt: resolved.metadataInitialPrompt,
+        explicitTitle: resolved.explicitTitle,
+        paseoHome: dependencies.paseoHome,
+        logger: dependencies.logger,
+    });
+    try {
+        const prompt = resolved.prompt;
+        if (prompt === undefined) {
+            return { started: false, liveSnapshot: snapshot };
+        }
+        const liveSnapshot = await startCreatedAgentInitialPrompt({
+            agentManager: dependencies.agentManager,
+            agentId: snapshot.id,
+            snapshot,
+            prompt,
+            runOptions: resolved.runOptions,
+            logger: resolved.promptLogger ?? dependencies.logger,
+        });
+        return { started: true, liveSnapshot };
+    }
+    catch (error) {
+        if (resolved.promptFailure === "throw") {
+            throw error;
+        }
+        dependencies.logger.error({ err: error, agentId: snapshot.id }, "Failed to run initial prompt");
+        return { started: false, liveSnapshot: snapshot };
+    }
+}
+function buildAgentPrompt(text, images, attachments) {
+    const normalized = text.trim();
+    const hasImages = (images?.length ?? 0) > 0;
+    const hasAttachments = (attachments?.length ?? 0) > 0;
+    if (!hasImages && !hasAttachments) {
+        return normalized;
+    }
+    const blocks = [];
+    if (normalized.length > 0) {
+        blocks.push({ type: "text", text: normalized });
+    }
+    for (const image of images ?? []) {
+        blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+    }
+    for (const attachment of attachments ?? []) {
+        blocks.push(attachment);
+    }
+    return blocks;
+}
+function requireParentAgent(agentManager, parentAgentId) {
+    const parentAgent = agentManager.getAgent(parentAgentId);
+    if (!parentAgent) {
+        throw new Error(`Parent agent ${parentAgentId} not found`);
+    }
+    return parentAgent;
+}
+function resolveChildAgentCwd(params) {
+    const lockedCwd = params.lockedCwd?.trim();
+    if (lockedCwd) {
+        return expandUserPath(lockedCwd);
+    }
+    const requestedCwd = params.requestedCwd?.trim();
+    if (!requestedCwd || !params.allowCustomCwd) {
+        return params.parentCwd;
+    }
+    return resolvePathFromBase(params.parentCwd, requestedCwd);
+}
+async function resolveMcpCwd(params) {
+    const { dependencies, worktree } = params;
+    if (!worktree) {
+        return { resolvedCwd: params.cwd };
+    }
+    const shouldCreateWorktree = Boolean(worktree.worktreeName || worktree.refName || worktree.action || worktree.githubPrNumber);
+    if (!shouldCreateWorktree) {
+        return { resolvedCwd: params.cwd };
+    }
+    if (worktree.worktreeName &&
+        !worktree.baseBranch &&
+        !worktree.refName &&
+        !worktree.action &&
+        worktree.githubPrNumber === undefined) {
+        throw new Error("baseBranch is required when creating a worktree");
+    }
+    const baseBranch = worktree.baseBranch;
+    const createdWorktree = await createMcpWorktree({
+        input: {
+            cwd: params.cwd,
+            worktreeSlug: worktree.worktreeName,
+            refName: worktree.refName,
+            action: worktree.action,
+            githubPrNumber: worktree.githubPrNumber,
+            ...(params.initialPrompt ? { firstAgentContext: { prompt: params.initialPrompt } } : {}),
+            runSetup: false,
+            paseoHome: dependencies.paseoHome,
+        },
+        createPaseoWorktree: dependencies.createPaseoWorktree,
+        resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
+        setupContinuation: {
+            kind: "agent",
+            terminalManager: dependencies.terminalManager ?? null,
+            appendTimelineItem: ({ agentId, item }) => appendTimelineItemIfAgentKnown({
+                agentManager: dependencies.agentManager,
+                agentId,
+                item,
+            }),
+            emitLiveTimelineItem: ({ agentId, item }) => emitLiveTimelineItemIfAgentKnown({
+                agentManager: dependencies.agentManager,
+                agentId,
+                item,
+            }),
+            logger: dependencies.logger,
+        },
+    });
+    return {
+        resolvedCwd: createdWorktree.worktree.worktreePath,
+        setupContinuation: createdWorktree.setupContinuation,
+    };
+}
+async function createMcpWorktree(options) {
+    try {
+        if (!options.createPaseoWorktree) {
+            throw new Error("Paseo worktree service is not configured");
+        }
+        return await options.createPaseoWorktree(options.input, {
+            ...(options.resolveDefaultBranch
+                ? { resolveDefaultBranch: options.resolveDefaultBranch }
+                : {}),
+            ...(options.setupContinuation ? { setupContinuation: options.setupContinuation } : {}),
+        });
+    }
+    catch (error) {
+        throw toWorktreeRequestError(error);
+    }
+}
+function mergeLabels(callerAgentId, childAgentDefaultLabels, labels) {
+    const mergedLabels = {
+        ...(callerAgentId ? { [PARENT_AGENT_ID_LABEL]: callerAgentId } : {}),
+        ...childAgentDefaultLabels,
+        ...labels,
+    };
+    return Object.keys(mergedLabels).length > 0 ? mergedLabels : undefined;
+}
+//# sourceMappingURL=create.js.map

package/dist/server/server/agent/create-agent-lifecycle-dispatch.js

@@ -119,7 +119,6 @@ export class CreateAgentLifecycleDispatch {
             agentManager: this.dependencies.agentManager,
             agentStorage: this.dependencies.agentStorage,
             archiveWorkspaceRecord: this.dependencies.archiveWorkspaceRecord,
-            emit: this.dependencies.emit,
             emitWorkspaceUpdatesForWorkspaceIds: this.dependencies.emitWorkspaceUpdatesForWorkspaceIds,
             markWorkspaceArchiving: this.dependencies.markWorkspaceArchiving,
             clearWorkspaceArchiving: this.dependencies.clearWorkspaceArchiving,

package/dist/server/server/agent/create-agent-mode.d.ts

@@ -1,4 +1,4 @@
-import type { AgentProvider } from "./agent-sdk-types.js";
+import type { AgentCreateConfigUnattendedInput, AgentProvider, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
 interface CreateAgentModeParent {
     provider: AgentProvider;
     modeId: string | null;
@@ -12,5 +12,7 @@ export interface ResolveCreateAgentModeInput {
     targetUnattendedMode: string | undefined;
 }
 export declare function resolveAndValidateCreateAgentMode(input: ResolveCreateAgentModeInput): string | undefined;
+export declare function resolveDefaultAgentCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
+export declare function isDefaultAgentCreateConfigUnattended(input: AgentCreateConfigUnattendedInput): boolean;
 export {};
 //# sourceMappingURL=create-agent-mode.d.ts.map

package/dist/server/server/agent/create-agent-mode.js

@@ -23,4 +23,26 @@ export function resolveAndValidateCreateAgentMode(input) {
     }
     throw new Error(`cannot inherit mode '${parent.modeId ?? "<none>"}' from caller (provider '${parent.provider}') for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`);
 }
+export function resolveDefaultAgentCreateConfig(input) {
+    const availableModeIds = input.availableModes?.map((mode) => mode.id);
+    return {
+        modeId: resolveAndValidateCreateAgentMode({
+            requestedMode: input.requestedMode,
+            targetProvider: input.provider,
+            parent: input.parent,
+            availableModes: availableModeIds,
+            targetUnattendedMode: input.availableModes?.find(isUnattendedMode)?.id,
+        }),
+        featureValues: input.featureValues,
+    };
+}
+export function isDefaultAgentCreateConfigUnattended(input) {
+    if (input.modeId === null) {
+        return false;
+    }
+    return input.availableModes.some((mode) => mode.id === input.modeId && isUnattendedMode(mode));
+}
+function isUnattendedMode(mode) {
+    return mode.isUnattended === true;
+}
 //# sourceMappingURL=create-agent-mode.js.map

package/dist/server/server/agent/create-agent-title.js

@@ -1,4 +1,4 @@
-import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "./agent-title-limits.js";
+import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "@getpaseo/protocol/agent-title-limits";
 const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
 function deriveInitialAgentTitle(prompt) {
     const firstContentLine = prompt

package/dist/server/server/agent/import-sessions.d.ts

@@ -1,10 +1,10 @@
 import type { z } from "zod";
 import type { Logger } from "pino";
-import type { ProviderDefinition } from "./provider-registry.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
 import type { AgentManager, ManagedAgent } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
 import { scheduleAgentMetadataGeneration } from "./agent-metadata-generator.js";
-import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "../../shared/messages.js";
+import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@getpaseo/protocol/messages";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
 export interface NormalizedImportAgentRequest {
@@ -22,7 +22,7 @@ export interface ListImportableProviderSessionsInput {
     request: FetchRecentProviderSessionsRequestMessage;
     agentManager: Pick<AgentManager, "listAgents" | "listImportablePersistedAgents">;
     agentStorage: Pick<AgentStorage, "list">;
-    providerRegistry: Record<string, Pick<ProviderDefinition, "label"> | undefined>;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "getProviderLabel">;
 }
 export interface ListImportableProviderSessionsResult {
     entries: RecentProviderSessionDescriptorPayload[];

package/dist/server/server/agent/import-sessions.js

@@ -31,7 +31,7 @@ export function normalizeImportAgentRequest(msg) {
     };
 }
 export async function listImportableProviderSessions(input) {
-    const { request, agentManager, agentStorage, providerRegistry } = input;
+    const { request, agentManager, agentStorage, providerSnapshotManager } = input;
     const limit = request.limit ?? 20;
     const sinceTimestamp = parseRecentProviderSessionsSince(request.since);
     const providerFilter = request.providers ? new Set(request.providers) : undefined;
@@ -68,7 +68,7 @@ export async function listImportableProviderSessions(input) {
         .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
         .slice(0, limit)
         .map((descriptor) => toRecentProviderSessionDescriptorPayload(descriptor, {
-        providerLabel: providerRegistry[descriptor.provider]?.label ?? descriptor.provider,
+        providerLabel: providerSnapshotManager.getProviderLabel(descriptor.provider),
     }));
     return { entries, filteredAlreadyImportedCount };
 }

package/dist/server/server/agent/lifecycle-command.d.ts

@@ -0,0 +1,59 @@
+import type { Logger } from "pino";
+import type { ManagedAgent } from "./agent-manager.js";
+import type { StoredAgentRecord } from "./agent-storage.js";
+export type LifecycleAgentSnapshot = Pick<ManagedAgent, "id" | "cwd" | "lifecycle">;
+export interface LifecycleAgentManager {
+    getAgent(agentId: string): LifecycleAgentSnapshot | null;
+    hasInFlightRun(agentId: string): boolean;
+    cancelAgentRun(agentId: string): Promise<boolean>;
+    clearAgentAttention(agentId: string): Promise<void>;
+    archiveAgent(agentId: string): Promise<{
+        archivedAt: string;
+    }>;
+    archiveSnapshot(agentId: string, archivedAt: string): Promise<StoredAgentRecord>;
+    closeAgent(agentId: string): Promise<void>;
+    setLabels(agentId: string, labels: Record<string, string>): Promise<void>;
+    notifyAgentState(agentId: string): void;
+    setAgentMode(agentId: string, modeId: string): Promise<void>;
+    updateAgentMetadata(agentId: string, updates: {
+        title?: string;
+        labels?: Record<string, string>;
+    }): Promise<void>;
+}
+export interface LifecycleAgentStorage {
+    get(agentId: string): Promise<StoredAgentRecord | null>;
+    upsert(record: StoredAgentRecord): Promise<void>;
+}
+export interface AgentLifecycleCommandDependencies {
+    agentManager: LifecycleAgentManager;
+    agentStorage: LifecycleAgentStorage;
+    logger: Logger;
+}
+export interface CancelAgentRunResult {
+    agent: LifecycleAgentSnapshot;
+    cancelled: boolean;
+}
+export declare function cancelAgentRunCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager" | "logger">, agentId: string): Promise<CancelAgentRunResult>;
+export interface ArchiveAgentResult {
+    agentId: string;
+    archivedAt: string;
+    record: StoredAgentRecord;
+}
+export declare function archiveAgentCommand(dependencies: AgentLifecycleCommandDependencies, agentId: string): Promise<ArchiveAgentResult>;
+export declare function closeAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, agentId: string): Promise<void>;
+export interface UpdateAgentResult {
+    accepted: boolean;
+    error: string | null;
+}
+export declare function updateAgentCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, input: {
+    agentId: string;
+    name?: string;
+    labels?: Record<string, string>;
+}): Promise<UpdateAgentResult>;
+export declare function setAgentModeCommand(dependencies: Pick<AgentLifecycleCommandDependencies, "agentManager">, input: {
+    agentId: string;
+    modeId: string;
+}): Promise<{
+    modeId: string;
+}>;
+//# sourceMappingURL=lifecycle-command.d.ts.map

package/dist/server/server/agent/lifecycle-command.js

@@ -0,0 +1,84 @@
+export async function cancelAgentRunCommand(dependencies, agentId) {
+    const { agentManager, logger } = dependencies;
+    const agent = agentManager.getAgent(agentId);
+    if (!agent) {
+        logger.trace({ agentId }, "cancelAgentRunCommand: agent not found");
+        throw new Error(`Agent ${agentId} not found`);
+    }
+    const hasInFlightRun = agentManager.hasInFlightRun(agentId);
+    if (!hasInFlightRun) {
+        logger.trace({ agentId, lifecycle: agent.lifecycle, hasInFlightRun }, "cancelAgentRunCommand: skipping because agent is not running");
+        return { agent, cancelled: false };
+    }
+    logger.debug({ agentId, lifecycle: agent.lifecycle, hasInFlightRun }, "cancelAgentRunCommand: interrupting");
+    const startedAt = Date.now();
+    const cancelled = await agentManager.cancelAgentRun(agentId);
+    logger.debug({ agentId, cancelled, durationMs: Date.now() - startedAt }, "cancelAgentRunCommand: cancelAgentRun completed");
+    if (!cancelled) {
+        logger.warn({ agentId }, "cancelAgentRunCommand: reported running but no active run was cancelled");
+    }
+    return {
+        agent,
+        cancelled,
+    };
+}
+export async function archiveAgentCommand(dependencies, agentId) {
+    const liveAgent = dependencies.agentManager.getAgent(agentId);
+    if (liveAgent) {
+        await cancelAgentRunCommand(dependencies, agentId);
+        await dependencies.agentManager.clearAgentAttention(agentId).catch(() => undefined);
+        await dependencies.agentManager.archiveAgent(agentId);
+    }
+    else {
+        await archiveStoredAgent(dependencies, agentId);
+    }
+    const record = await dependencies.agentStorage.get(agentId);
+    if (!record) {
+        throw new Error(`Agent not found in storage after archive: ${agentId}`);
+    }
+    if (!record.archivedAt) {
+        throw new Error(`Agent missing archivedAt after archive: ${agentId}`);
+    }
+    return {
+        agentId,
+        archivedAt: record.archivedAt,
+        record,
+    };
+}
+export async function closeAgentCommand(dependencies, agentId) {
+    await dependencies.agentManager.closeAgent(agentId);
+}
+export async function updateAgentCommand(dependencies, input) {
+    const title = input.name?.trim();
+    const labels = input.labels && Object.keys(input.labels).length > 0 ? input.labels : undefined;
+    if (!title && !labels) {
+        return {
+            accepted: false,
+            error: "Nothing to update (provide name and/or labels)",
+        };
+    }
+    await dependencies.agentManager.updateAgentMetadata(input.agentId, {
+        ...(title ? { title } : {}),
+        ...(labels ? { labels } : {}),
+    });
+    return {
+        accepted: true,
+        error: null,
+    };
+}
+export async function setAgentModeCommand(dependencies, input) {
+    await dependencies.agentManager.setAgentMode(input.agentId, input.modeId);
+    return { modeId: input.modeId };
+}
+async function archiveStoredAgent(dependencies, agentId) {
+    const existing = await dependencies.agentStorage.get(agentId);
+    if (!existing) {
+        throw new Error(`Agent not found: ${agentId}`);
+    }
+    if (existing.archivedAt) {
+        return;
+    }
+    const archivedAt = new Date().toISOString();
+    await dependencies.agentManager.archiveSnapshot(agentId, archivedAt);
+}
+//# sourceMappingURL=lifecycle-command.js.map

package/dist/server/server/agent/mcp-server.d.ts

@@ -1,6 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Logger } from "pino";
-import type { AgentProvider } from "./agent-sdk-types.js";
 import type { AgentManager } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
 import { type ArchivePaseoWorktreeDependencies } from "../paseo-worktree-archive-service.js";
@@ -8,7 +7,7 @@ import type { VoiceCallerContext, VoiceSpeakHandler } from "../voice-types.js";
 import type { TerminalManager } from "../../terminal/terminal-manager.js";
 import type { CreatePaseoWorktreeWorkflowFn } from "../worktree-session.js";
 import type { ScheduleService } from "../schedule/service.js";
-import type { ProviderDefinition } from "./provider-registry.js";
+import { type ProviderSnapshotManager } from "./provider-snapshot-manager.js";
 import type { GitHubService } from "../../services/github-service.js";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 export interface AgentMcpServerOptions {
@@ -17,14 +16,13 @@ export interface AgentMcpServerOptions {
     terminalManager?: TerminalManager | null;
     getDaemonTcpPort?: () => number | null;
     scheduleService?: ScheduleService | null;
-    providerRegistry?: Record<AgentProvider, ProviderDefinition> | null;
+    providerSnapshotManager: ProviderSnapshotManager;
     github?: GitHubService;
     workspaceGitService?: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees" | "resolveRepoRoot">;
     archiveWorkspaceRecord?: ArchivePaseoWorktreeDependencies["archiveWorkspaceRecord"];
     emitWorkspaceUpdatesForWorkspaceIds?: ArchivePaseoWorktreeDependencies["emitWorkspaceUpdatesForWorkspaceIds"];
     markWorkspaceArchiving?: ArchivePaseoWorktreeDependencies["markWorkspaceArchiving"];
     clearWorkspaceArchiving?: ArchivePaseoWorktreeDependencies["clearWorkspaceArchiving"];
-    emitSessionMessage?: ArchivePaseoWorktreeDependencies["emit"];
     createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
     paseoHome?: string;
     /**