@getpaseo/server 0.1.82 → 0.1.84

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

@@ -7,52 +7,18 @@ import { curateAgentActivity } from "./activity-curator.js";
 import { selectItemsByProjectedLimit } from "./timeline-projection.js";
 import { ensureAgentLoaded } from "./agent-loading.js";
 import { isStoredAgentProviderAvailable } from "../persistence-hooks.js";
-import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "./timeline-append.js";
-import { getPaseoWorktreesRoot } from "../../utils/worktree.js";
-import { archivePaseoWorktree, killTerminalsUnderPath, } from "../paseo-worktree-archive-service.js";
+import { killTerminalsUnderPath, } from "../paseo-worktree-archive-service.js";
 import { WaitForAgentTracker } from "./wait-for-agent-tracker.js";
-import { scheduleAgentMetadataGeneration } from "./agent-metadata-generator.js";
+import { createAgentCommand } from "./create-agent/create.js";
 import { expandUserPath, isSameOrDescendantPath, resolvePathFromBase } from "../path-utils.js";
-import { PARENT_AGENT_ID_LABEL } from "../../shared/agent-labels.js";
-import { ScheduleRunSchema, ScheduleSummarySchema, StoredScheduleSchema, } from "../schedule/types.js";
-import { getAgentProviderDefinition } from "./provider-manifest.js";
-import { resolveAndValidateCreateAgentMode } from "./create-agent-mode.js";
+import { ScheduleRunSchema, ScheduleSummarySchema, StoredScheduleSchema, } from "@getpaseo/protocol/schedule/types";
 import { resolveSnapshotCwd } from "./provider-snapshot-manager.js";
 import { AgentModelSchema, AgentProviderEnum, AgentStatusEnum, ProviderModeSchema, ProviderSummarySchema, parseDurationString, resolveRequiredProviderModel, sanitizePermissionRequest, serializeSnapshotWithMetadata, toScheduleSummary, waitForAgentWithTimeout, } from "./mcp-shared.js";
-import { sendPromptToAgent, setupFinishNotification, startAgentRun } from "./agent-prompt.js";
-import { toWorktreeRequestError } from "../worktree-errors.js";
-import { join } from "node:path";
-const CLAUDE_TO_CODEX_MODE = {
-    plan: "read-only",
-    default: "auto",
-    acceptEdits: "auto",
-    bypassPermissions: "full-access",
-};
-const CODEX_TO_CLAUDE_MODE = {
-    "read-only": "plan",
-    auto: "default",
-    "full-access": "bypassPermissions",
-};
-function mapModeAcrossProviders(sourceMode, sourceProvider, targetProvider) {
-    if (sourceProvider === targetProvider) {
-        return sourceMode;
-    }
-    if (sourceProvider === "claude" && targetProvider === "codex") {
-        const mapped = CLAUDE_TO_CODEX_MODE[sourceMode];
-        if (mapped) {
-            return mapped;
-        }
-        return "auto";
-    }
-    if (sourceProvider === "codex" && targetProvider === "claude") {
-        const mapped = CODEX_TO_CLAUDE_MODE[sourceMode];
-        if (mapped) {
-            return mapped;
-        }
-        return "default";
-    }
-    return sourceMode;
-}
+import { sendPromptToAgent, setupFinishNotification } from "./agent-prompt.js";
+import { respondToAgentPermission } from "./permission-response.js";
+import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./lifecycle-command.js";
+import { WorktreeRequestError } from "../worktree-errors.js";
+import { archivePaseoWorktreeCommand, createPaseoWorktreeCommand, listPaseoWorktreesCommand, } from "../worktree/commands.js";
 function addModelVisibleStructuredContent(result) {
     if (result.structuredContent === undefined || result.content.length > 0) {
         return result;
@@ -92,6 +58,27 @@ function formatStructuredContentForModel(structuredContent) {
     const json = JSON.stringify(structuredContent, null, 2);
     return summary.length > 0 ? `${summary.join("\n")}\n\n${json}` : json;
 }
+function isZodSchema(value) {
+    return (typeof value === "object" && value !== null && "_def" in value && "safeParseAsync" in value);
+}
+function relaxMcpOutputSchema(outputSchema) {
+    if (!outputSchema) {
+        return outputSchema;
+    }
+    if (isZodSchema(outputSchema)) {
+        return outputSchema instanceof z.ZodObject ? outputSchema.passthrough() : outputSchema;
+    }
+    return z.object(outputSchema).passthrough();
+}
+function relaxMcpToolOutputSchema(config) {
+    if (config.outputSchema === undefined) {
+        return config;
+    }
+    return {
+        ...config,
+        outputSchema: relaxMcpOutputSchema(config.outputSchema),
+    };
+}
 function parseTimestamp(value) {
     if (!value) {
         return 0;
@@ -102,31 +89,16 @@ function parseTimestamp(value) {
 function resolveAgentListActivityTime(agent) {
     return Math.max(parseTimestamp(agent.updatedAt), parseTimestamp(agent.lastUserMessageAt), parseTimestamp(agent.attentionTimestamp), parseTimestamp(agent.archivedAt), parseTimestamp(agent.createdAt));
 }
-function resolveRegisteredProviderIds(agentManager, providerRegistry) {
-    return providerRegistry ? Object.keys(providerRegistry) : agentManager.getRegisteredProviderIds();
-}
-async function resolveProviderSummary(provider, logger) {
-    const base = {
-        id: provider.id,
-        label: provider.label,
-        description: provider.description,
-        modes: provider.modes,
+function toProviderSummary(entry) {
+    return {
+        id: entry.provider,
+        label: entry.label ?? entry.provider,
+        description: entry.description ?? "",
+        enabled: entry.enabled,
+        modes: entry.modes ?? [],
+        status: entry.status === "ready" ? "available" : entry.status,
+        ...(entry.error ? { error: entry.error } : {}),
     };
-    if (!provider.enabled) {
-        return { ...base, enabled: false, status: "unavailable" };
-    }
-    try {
-        const available = await provider.createClient(logger).isAvailable();
-        return { ...base, enabled: true, status: available ? "available" : "unavailable" };
-    }
-    catch (availabilityError) {
-        return {
-            ...base,
-            enabled: true,
-            status: "unavailable",
-            error: availabilityError instanceof Error ? availabilityError.message : String(availabilityError),
-        };
-    }
 }
 function compareAgentListItems(a, b) {
     const attentionDelta = Number(b.requiresAttention ?? false) - Number(a.requiresAttention ?? false);
@@ -194,15 +166,27 @@ function resolveScheduleUpdateProviderAndModel(params) {
         model: modelInput ?? modelFromProvider,
     };
 }
+function normalizeScheduleCadenceArg(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed;
+}
 function resolveScheduleUpdateCadence(input) {
-    if (input.every !== undefined && input.cron !== undefined) {
+    const every = normalizeScheduleCadenceArg(input.every);
+    const cron = normalizeScheduleCadenceArg(input.cron);
+    if (every !== undefined && cron !== undefined) {
         throw new Error("Specify at most one of every or cron");
     }
-    if (input.every !== undefined) {
-        return { type: "every", everyMs: parseDurationString(input.every) };
+    if (every !== undefined) {
+        return { type: "every", everyMs: parseDurationString(every) };
     }
-    if (input.cron !== undefined) {
-        return { type: "cron", expression: input.cron.trim() };
+    if (cron !== undefined) {
+        return { type: "cron", expression: cron };
     }
     return undefined;
 }
@@ -295,7 +279,7 @@ function resolveTerminalKeyToken(key, literal) {
     }
 }
 export async function createAgentMcpServer(options) {
-    const { agentManager, agentStorage, terminalManager, scheduleService, providerRegistry, callerAgentId, resolveSpeakHandler, resolveCallerContext, logger, } = options;
+    const { agentManager, agentStorage, terminalManager, scheduleService, providerSnapshotManager, callerAgentId, resolveSpeakHandler, resolveCallerContext, logger, } = options;
     const childLogger = logger.child({ module: "agent", component: "mcp-server" });
     const waitTracker = new WaitForAgentTracker(logger);
     const callerContext = callerAgentId ? (resolveCallerContext?.(callerAgentId) ?? null) : null;
@@ -304,7 +288,7 @@ export async function createAgentMcpServer(options) {
         version: "2.0.0",
     });
     const registerRawTool = server.registerTool.bind(server);
-    const registerTool = (name, config, handler) => registerRawTool(name, config, (async (args, extra) => addModelVisibleStructuredContent(await handler(args, extra))));
+    const registerTool = (name, config, handler) => registerRawTool(name, relaxMcpToolOutputSchema(config), (async (args, extra) => addModelVisibleStructuredContent(await handler(args, extra))));
     const resolveCallerAgent = () => {
         if (!callerAgentId) {
             return null;
@@ -351,6 +335,9 @@ export async function createAgentMcpServer(options) {
                 : {}),
             ...(callerAgent.config.title ? { title: callerAgent.config.title } : {}),
             ...(callerAgent.config.extra ? { extra: callerAgent.config.extra } : {}),
+            ...(callerAgent.config.featureValues
+                ? { featureValues: callerAgent.config.featureValues }
+                : {}),
             ...(callerAgent.config.systemPrompt ? { systemPrompt: callerAgent.config.systemPrompt } : {}),
             ...(callerAgent.config.mcpServers ? { mcpServers: callerAgent.config.mcpServers } : {}),
         };
@@ -374,9 +361,9 @@ export async function createAgentMcpServer(options) {
         return {
             provider: resolvedProvider,
             cwd: params?.cwd?.trim() ? expandUserPath(params.cwd) : callerAgent.cwd,
-            ...(callerAgent.currentModeId
+            ...(callerAgent.currentModeId && callerAgent.provider === resolvedProvider
                 ? {
-                    modeId: mapModeAcrossProviders(callerAgent.currentModeId, callerAgent.provider, resolvedProvider),
+                    modeId: callerAgent.currentModeId,
                 }
                 : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
@@ -592,140 +579,6 @@ export async function createAgentMcpServer(options) {
     if (options.voiceOnly) {
         return server;
     }
-    const getProviderModes = (provider) => {
-        const fromRegistry = providerRegistry?.[provider];
-        if (fromRegistry) {
-            return fromRegistry.modes;
-        }
-        try {
-            return getAgentProviderDefinition(provider).modes;
-        }
-        catch {
-            return undefined;
-        }
-    };
-    const getAvailableModeIds = (provider) => {
-        return getProviderModes(provider)?.map((mode) => mode.id);
-    };
-    const getUnattendedModeId = (provider) => {
-        return getProviderModes(provider)?.find((mode) => mode.isUnattended)?.id;
-    };
-    const isParentInUnattendedMode = (provider, modeId) => {
-        if (modeId === null)
-            return false;
-        const modes = getProviderModes(provider);
-        if (!modes)
-            return false;
-        return modes.some((mode) => mode.id === modeId && mode.isUnattended === true);
-    };
-    const resolveCallerCreateAgentArgs = (args, parentAgentId) => {
-        const callerArgs = agentToAgentCreateAgentArgsSchema.parse(args);
-        const resolvedProviderModel = resolveRequiredProviderModel(callerArgs.provider);
-        const parentAgent = agentManager.getAgent(parentAgentId);
-        if (!parentAgent) {
-            throw new Error(`Parent agent ${parentAgentId} not found`);
-        }
-        const provider = resolvedProviderModel.provider;
-        const settings = callerArgs.settings;
-        const resolvedCwd = resolveChildAgentCwd({
-            parentCwd: parentAgent.cwd,
-            requestedCwd: callerArgs.cwd,
-            lockedCwd: callerContext?.lockedCwd,
-            allowCustomCwd: callerContext?.allowCustomCwd ?? true,
-        });
-        const resolvedMode = resolveAndValidateCreateAgentMode({
-            requestedMode: settings?.modeId,
-            targetProvider: provider,
-            parent: {
-                provider: parentAgent.provider,
-                modeId: parentAgent.currentModeId,
-                isUnattended: isParentInUnattendedMode(parentAgent.provider, parentAgent.currentModeId),
-            },
-            availableModes: getAvailableModeIds(provider),
-            targetUnattendedMode: getUnattendedModeId(provider),
-        });
-        return {
-            provider,
-            initialPrompt: callerArgs.initialPrompt,
-            background: callerArgs.background ?? false,
-            normalizedTitle: callerArgs.title.trim(),
-            model: resolvedProviderModel.model,
-            thinkingOptionId: settings?.thinkingOptionId,
-            features: settings?.features,
-            labels: callerArgs.labels,
-            notifyOnFinish: callerArgs.notifyOnFinish ?? false,
-            resolvedCwd,
-            resolvedMode,
-            setupContinuation: undefined,
-        };
-    };
-    const resolveTopLevelCreateAgentArgs = async (args) => {
-        const topLevelArgs = topLevelCreateAgentArgsSchema.parse(args);
-        const resolvedProviderModel = resolveRequiredProviderModel(topLevelArgs.provider);
-        const { cwd, settings, worktreeName, baseBranch, refName, action, githubPrNumber } = topLevelArgs;
-        const resolvedMode = resolveAndValidateCreateAgentMode({
-            requestedMode: settings?.modeId,
-            targetProvider: resolvedProviderModel.provider,
-            parent: null,
-            availableModes: getAvailableModeIds(resolvedProviderModel.provider),
-            targetUnattendedMode: getUnattendedModeId(resolvedProviderModel.provider),
-        });
-        let resolvedCwd = expandUserPath(cwd);
-        let setupContinuation;
-        const shouldCreateWorktree = Boolean(worktreeName || refName || action || githubPrNumber);
-        if (shouldCreateWorktree) {
-            if (worktreeName && !baseBranch && !refName && !action && githubPrNumber === undefined) {
-                throw new Error("baseBranch is required when creating a worktree");
-            }
-            const createdWorktree = await createMcpWorktree({
-                input: {
-                    cwd: resolvedCwd,
-                    worktreeSlug: worktreeName,
-                    refName,
-                    action,
-                    githubPrNumber,
-                    ...(topLevelArgs.initialPrompt
-                        ? { firstAgentContext: { prompt: topLevelArgs.initialPrompt } }
-                        : {}),
-                    runSetup: false,
-                    paseoHome: options.paseoHome,
-                },
-                createPaseoWorktree: options.createPaseoWorktree,
-                resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
-                setupContinuation: {
-                    kind: "agent",
-                    terminalManager: terminalManager ?? null,
-                    appendTimelineItem: ({ agentId, item }) => appendTimelineItemIfAgentKnown({
-                        agentManager,
-                        agentId,
-                        item,
-                    }),
-                    emitLiveTimelineItem: ({ agentId, item }) => emitLiveTimelineItemIfAgentKnown({
-                        agentManager,
-                        agentId,
-                        item,
-                    }),
-                    logger: childLogger,
-                },
-            });
-            resolvedCwd = createdWorktree.worktree.worktreePath;
-            setupContinuation = createdWorktree.setupContinuation;
-        }
-        return {
-            provider: resolvedProviderModel.provider,
-            initialPrompt: topLevelArgs.initialPrompt,
-            background: topLevelArgs.background ?? false,
-            normalizedTitle: topLevelArgs.title.trim(),
-            model: resolvedProviderModel.model,
-            thinkingOptionId: settings?.thinkingOptionId,
-            features: settings?.features,
-            labels: topLevelArgs.labels,
-            notifyOnFinish: topLevelArgs.notifyOnFinish ?? false,
-            resolvedCwd,
-            resolvedMode,
-            setupContinuation,
-        };
-    };
     registerTool("create_agent", {
         title: "Create agent",
         description: "Create an agent tied to a working directory. Requires provider/model, for example codex/gpt-5.4. Do not guess; call list_providers and list_models first if uncertain. Optionally run an initial prompt immediately or create a git worktree for the agent.",
@@ -736,71 +589,50 @@ export async function createAgentMcpServer(options) {
             status: AgentStatusEnum,
             cwd: z.string(),
             currentModeId: z.string().nullable(),
-            availableModes: z.array(z.object({
-                id: z.string(),
-                label: z.string(),
-                description: z.string().nullable().optional(),
-            })),
+            availableModes: z.array(ProviderModeSchema),
             lastMessage: z.string().nullable().optional(),
             permission: AgentPermissionRequestPayloadSchema.nullable().optional(),
         },
     }, async (args) => {
-        const resolved = callerAgentId
-            ? resolveCallerCreateAgentArgs(args, callerAgentId)
-            : await resolveTopLevelCreateAgentArgs(args);
-        const { provider, initialPrompt, background, normalizedTitle, model, thinkingOptionId, features, labels, notifyOnFinish, resolvedCwd, resolvedMode, setupContinuation, } = resolved;
-        const childAgentDefaultLabels = callerContext?.childAgentDefaultLabels;
-        const mergedLabels = {
-            ...(callerAgentId ? { [PARENT_AGENT_ID_LABEL]: callerAgentId } : {}),
-            ...childAgentDefaultLabels,
-            ...labels,
-        };
-        const snapshot = await agentManager.createAgent({
-            provider,
-            cwd: resolvedCwd,
-            modeId: resolvedMode,
-            title: normalizedTitle ?? undefined,
-            model,
-            thinkingOptionId,
-            featureValues: features,
-        }, undefined, Object.keys(mergedLabels).length > 0 ? { labels: mergedLabels } : undefined);
-        setupContinuation?.startAfterAgentCreate({
-            agentId: snapshot.id,
-        });
-        const trimmedPrompt = initialPrompt.trim();
-        scheduleAgentMetadataGeneration({
+        const { parsedArgs, worktree } = resolveCreateAgentToolArgs(args);
+        const { snapshot, background, initialPromptStarted } = await createAgentCommand({
             agentManager,
-            agentId: snapshot.id,
-            cwd: snapshot.cwd,
-            workspaceGitService: options.workspaceGitService,
-            initialPrompt: trimmedPrompt,
-            explicitTitle: snapshot.config.title,
-            paseoHome: options.paseoHome,
+            agentStorage,
             logger: childLogger,
+            paseoHome: options.paseoHome,
+            workspaceGitService: options.workspaceGitService,
+            terminalManager,
+            providerSnapshotManager,
+            createPaseoWorktree: options.createPaseoWorktree,
+        }, {
+            kind: "mcp",
+            provider: parsedArgs.provider,
+            title: parsedArgs.title,
+            initialPrompt: parsedArgs.initialPrompt,
+            cwd: parsedArgs.cwd,
+            thinking: parsedArgs.settings?.thinkingOptionId,
+            features: parsedArgs.settings?.features,
+            labels: parsedArgs.labels,
+            mode: parsedArgs.settings?.modeId,
+            background: parsedArgs.background ?? false,
+            notifyOnFinish: parsedArgs.notifyOnFinish ?? false,
+            callerAgentId,
+            callerContext,
+            worktree,
         });
         try {
-            startAgentRun(agentManager, snapshot.id, trimmedPrompt, childLogger);
-            if (notifyOnFinish && callerAgentId) {
-                setupFinishNotification({
-                    agentManager,
-                    agentStorage,
-                    childAgentId: snapshot.id,
-                    callerAgentId,
-                    logger: childLogger,
-                });
-            }
-            // If not running in background, wait for completion
-            if (!background) {
+            if (!background && initialPromptStarted) {
                 const result = await waitForAgentWithTimeout(agentManager, snapshot.id, {
                     waitForActive: true,
                 });
+                const liveSnapshot = agentManager.getAgent(snapshot.id) ?? snapshot;
                 const responseData = {
                     agentId: snapshot.id,
-                    type: provider,
+                    type: snapshot.provider,
                     status: result.status,
-                    cwd: snapshot.cwd,
-                    currentModeId: snapshot.currentModeId,
-                    availableModes: snapshot.availableModes,
+                    cwd: liveSnapshot.cwd,
+                    currentModeId: liveSnapshot.currentModeId,
+                    availableModes: liveSnapshot.availableModes,
                     lastMessage: result.lastMessage,
                     permission: sanitizePermissionRequest(result.permission),
                 };
@@ -814,23 +646,47 @@ export async function createAgentMcpServer(options) {
         }
         catch (error) {
             childLogger.error({ err: error, agentId: snapshot.id }, "Failed to run initial prompt");
+            throw error;
         }
         // Return immediately if background=true
+        const currentSnapshot = agentManager.getAgent(snapshot.id) ?? snapshot;
         const response = {
             content: [],
             structuredContent: ensureValidJson({
-                agentId: snapshot.id,
-                type: provider,
-                status: snapshot.lifecycle,
-                cwd: snapshot.cwd,
-                currentModeId: snapshot.currentModeId,
-                availableModes: snapshot.availableModes,
+                agentId: currentSnapshot.id,
+                type: snapshot.provider,
+                status: currentSnapshot.lifecycle,
+                cwd: currentSnapshot.cwd,
+                currentModeId: currentSnapshot.currentModeId,
+                availableModes: currentSnapshot.availableModes,
                 lastMessage: null,
                 permission: null,
             }),
         };
         return response;
     });
+    function resolveCreateAgentToolArgs(args) {
+        if (callerAgentId) {
+            return {
+                parsedArgs: agentToAgentCreateAgentArgsSchema.parse(args),
+                worktree: undefined,
+            };
+        }
+        const parsedArgs = topLevelCreateAgentArgsSchema.parse(args);
+        return {
+            parsedArgs,
+            worktree: resolveTopLevelCreateAgentWorktree(parsedArgs),
+        };
+    }
+    function resolveTopLevelCreateAgentWorktree(args) {
+        return {
+            worktreeName: args.worktreeName,
+            baseBranch: args.baseBranch,
+            refName: args.refName,
+            action: args.action,
+            githubPrNumber: args.githubPrNumber,
+        };
+    }
     registerTool("wait_for_agent", {
         title: "Wait for agent",
         description: "Block until the agent requests permission or the current run completes. Returns the pending permission (if any) and recent activity summary.",
@@ -1006,7 +862,7 @@ export async function createAgentMcpServer(options) {
         if (!record || record.internal) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        const structuredSnapshot = buildStoredAgentPayload(record, resolveRegisteredProviderIds(agentManager, providerRegistry));
+        const structuredSnapshot = buildStoredAgentPayload(record, providerSnapshotManager.listRegisteredProviderIds());
         return {
             content: [],
             structuredContent: ensureValidJson({
@@ -1043,7 +899,7 @@ export async function createAgentMcpServer(options) {
         const liveAgents = await Promise.all(liveSnapshots.map((snapshot) => serializeSnapshotWithMetadata(agentStorage, snapshot, childLogger)));
         const liveIds = new Set(liveSnapshots.map((snapshot) => snapshot.id));
         const storedRecords = await agentStorage.list();
-        const registeredProviderIds = resolveRegisteredProviderIds(agentManager, providerRegistry);
+        const registeredProviderIds = providerSnapshotManager.listRegisteredProviderIds();
         const storedAgents = storedRecords
             .filter((record) => !record.internal && !liveIds.has(record.id))
             .filter((record) => includeArchived || !record.archivedAt)
@@ -1071,13 +927,13 @@ export async function createAgentMcpServer(options) {
             success: z.boolean(),
         },
     }, async ({ agentId }) => {
-        const success = await agentManager.cancelAgentRun(agentId);
-        if (success) {
+        const { cancelled } = await cancelAgentRunCommand({ agentManager, logger: childLogger }, agentId);
+        if (cancelled) {
             waitTracker.cancel(agentId, "Agent run cancelled");
         }
         return {
             content: [],
-            structuredContent: ensureValidJson({ success }),
+            structuredContent: ensureValidJson({ success: cancelled }),
         };
     });
     registerTool("archive_agent", {
@@ -1090,7 +946,11 @@ export async function createAgentMcpServer(options) {
             success: z.boolean(),
         },
     }, async ({ agentId }) => {
-        await agentManager.archiveAgent(agentId);
+        await archiveAgentCommand({
+            agentManager,
+            agentStorage,
+            logger: childLogger,
+        }, agentId);
         waitTracker.cancel(agentId, "Agent archived");
         return {
             content: [],
@@ -1107,7 +967,7 @@ export async function createAgentMcpServer(options) {
             success: z.boolean(),
         },
     }, async ({ agentId }) => {
-        await agentManager.closeAgent(agentId);
+        await closeAgentCommand({ agentManager }, agentId);
         waitTracker.cancel(agentId, "Agent terminated");
         return {
             content: [],
@@ -1141,22 +1001,7 @@ export async function createAgentMcpServer(options) {
                 await agentManager.setAgentFeature(agentId, featureId, value);
             }
         }
-        const trimmedName = name?.trim();
-        if (trimmedName) {
-            const record = await agentStorage.get(agentId);
-            if (!record) {
-                throw new Error(`Agent ${agentId} not found`);
-            }
-            await agentStorage.upsert({
-                ...record,
-                title: trimmedName,
-                updatedAt: new Date().toISOString(),
-            });
-            agentManager.notifyAgentState(agentId);
-        }
-        if (labels) {
-            await agentManager.setLabels(agentId, labels);
-        }
+        await updateAgentCommand({ agentManager }, { agentId, name, labels });
         return {
             content: [],
             structuredContent: ensureValidJson({ success: true }),
@@ -1329,7 +1174,9 @@ export async function createAgentMcpServer(options) {
         if (!scheduleService) {
             throw new Error("Schedule service is not configured");
         }
-        const cadenceCount = Number(every !== undefined) + Number(cron !== undefined);
+        const normalizedEvery = normalizeScheduleCadenceArg(every);
+        const normalizedCron = normalizeScheduleCadenceArg(cron);
+        const cadenceCount = Number(normalizedEvery !== undefined) + Number(normalizedCron !== undefined);
         if (cadenceCount !== 1) {
             throw new Error("Specify exactly one of every or cron");
         }
@@ -1360,9 +1207,9 @@ export async function createAgentMcpServer(options) {
             })();
         const schedule = await scheduleService.create({
             prompt: prompt.trim(),
-            cadence: every
-                ? { type: "every", everyMs: parseDurationString(every) }
-                : { type: "cron", expression: cron.trim() },
+            cadence: normalizedEvery !== undefined
+                ? { type: "every", everyMs: parseDurationString(normalizedEvery) }
+                : { type: "cron", expression: normalizedCron },
             target: scheduleTarget,
             ...(name?.trim() ? { name: name.trim() } : {}),
             ...(maxRuns === undefined ? {} : { maxRuns }),
@@ -1547,7 +1394,7 @@ export async function createAgentMcpServer(options) {
             providers: z.array(ProviderSummarySchema),
         },
     }, async () => {
-        const providers = await Promise.all(Object.values(providerRegistry ?? {}).map((provider) => resolveProviderSummary(provider, childLogger)));
+        const providers = (await providerSnapshotManager.listProviders({ wait: true })).map(toProviderSummary);
         return {
             content: [],
             structuredContent: ensureValidJson({ providers }),
@@ -1564,17 +1411,11 @@ export async function createAgentMcpServer(options) {
             models: z.array(AgentModelSchema),
         },
     }, async ({ provider }) => {
-        if (!providerRegistry) {
-            throw new Error("Provider registry is not configured");
-        }
-        const definition = providerRegistry[provider];
-        if (!definition) {
-            throw new Error(`Provider ${provider} is not configured`);
-        }
-        if (!definition.enabled) {
-            throw new Error(`Provider '${provider}' is disabled`);
-        }
-        const models = await definition.fetchModels({ cwd: resolveSnapshotCwd(), force: false });
+        const models = await providerSnapshotManager.listModels({
+            cwd: resolveSnapshotCwd(),
+            provider,
+            wait: true,
+        });
         return {
             content: [],
             structuredContent: ensureValidJson({
@@ -1603,21 +1444,19 @@ export async function createAgentMcpServer(options) {
             defaultProvider: provider,
         });
         const providerId = resolvedProviderModel.provider;
-        if (!providerRegistry) {
-            throw new Error("Provider registry is not configured");
-        }
-        const definition = providerRegistry[providerId];
-        if (!definition) {
-            throw new Error(`Provider ${providerId} is not configured`);
-        }
-        const summary = await resolveProviderSummary(definition, childLogger);
-        if (!definition.enabled) {
+        const resolvedCwd = resolveScopedCwd(cwd, { required: true });
+        const entry = await providerSnapshotManager.getProvider({
+            cwd: resolvedCwd,
+            provider: providerId,
+            wait: true,
+        });
+        const summary = toProviderSummary(entry);
+        if (!entry.enabled) {
             throw new Error(`Provider '${providerId}' is disabled`);
         }
-        if (summary.status !== "available") {
-            throw new Error(summary.error ?? `Provider '${providerId}' is unavailable`);
+        if (entry.status !== "ready") {
+            throw new Error(entry.error ?? `Provider '${providerId}' is unavailable`);
         }
-        const resolvedCwd = resolveScopedCwd(cwd, { required: true });
         const selectedModel = settings?.model ?? resolvedProviderModel.model;
         const features = await agentManager.listDraftFeatures({
             provider: providerId,
@@ -1658,7 +1497,8 @@ export async function createAgentMcpServer(options) {
         if (!options.workspaceGitService) {
             throw new Error("WorkspaceGitService is required to list worktrees");
         }
-        const worktrees = await options.workspaceGitService.listWorktrees(resolvedCwd, {
+        const worktrees = await listPaseoWorktreesCommand({ workspaceGitService: options.workspaceGitService }, {
+            cwd: resolvedCwd,
             reason: "mcp:list-worktrees",
         });
         return {
@@ -1705,13 +1545,14 @@ export async function createAgentMcpServer(options) {
         },
     }, async ({ cwd, target }) => {
         const repoRoot = resolveScopedCwd(cwd, { required: true });
-        const mcpInput = mcpCreateWorktreeInput(repoRoot, target, options.paseoHome);
-        const createdWorktree = await createMcpWorktree({
-            input: mcpInput.input,
-            createPaseoWorktree: options.createPaseoWorktree,
-            resolveDefaultBranch: mcpInput.resolveDefaultBranch,
-        });
-        const { worktree } = createdWorktree;
+        const commandResult = await createPaseoWorktreeCommand({
+            paseoHome: options.paseoHome,
+            createPaseoWorktreeWorkflow: options.createPaseoWorktree,
+        }, createMcpWorktreeCommandInput(repoRoot, target));
+        if (!commandResult.ok) {
+            throw new WorktreeRequestError(commandResult.error);
+        }
+        const { worktree } = commandResult.createdWorktree;
         await options.workspaceGitService?.listWorktrees?.(repoRoot, {
             force: true,
             reason: "mcp:create-worktree",
@@ -1743,54 +1584,24 @@ export async function createAgentMcpServer(options) {
         if (!worktreePath && !worktreeSlug) {
             throw new Error("worktreePath or worktreeSlug is required");
         }
-        if (!options.github) {
-            throw new Error("GitHub service is required to archive worktrees");
-        }
         if (!options.workspaceGitService) {
             throw new Error("WorkspaceGitService is required to archive worktrees");
         }
-        if (!options.archiveWorkspaceRecord) {
-            throw new Error("Workspace registry archiver is required to archive worktrees");
-        }
-        if (!options.emitWorkspaceUpdatesForWorkspaceIds) {
-            throw new Error("Workspace update emitter is required to archive worktrees");
-        }
-        if (!options.markWorkspaceArchiving) {
-            throw new Error("Workspace archiving marker is required to archive worktrees");
-        }
-        if (!options.clearWorkspaceArchiving) {
-            throw new Error("Workspace archiving clearer is required to archive worktrees");
-        }
-        if (!options.emitSessionMessage) {
-            throw new Error("Session message emitter is required to archive worktrees");
-        }
         const repoRoot = await options.workspaceGitService.resolveRepoRoot(resolvedCwd);
-        const targetPath = worktreePath ??
-            join(await getPaseoWorktreesRoot(repoRoot, options.paseoHome), worktreeSlug);
-        await archivePaseoWorktree({
-            paseoHome: options.paseoHome,
-            github: options.github,
-            workspaceGitService: options.workspaceGitService,
+        const result = await archivePaseoWorktreeCommand(archiveWorktreeDependencies(options, {
             agentManager,
             agentStorage,
-            archiveWorkspaceRecord: options.archiveWorkspaceRecord,
-            emit: options.emitSessionMessage,
-            emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
-            markWorkspaceArchiving: options.markWorkspaceArchiving,
-            clearWorkspaceArchiving: options.clearWorkspaceArchiving,
-            isPathWithinRoot: isSameOrDescendantPath,
-            killTerminalsUnderPath: (rootPath) => killTerminalsUnderPath({
-                terminalManager: terminalManager ?? null,
-                isPathWithinRoot: isSameOrDescendantPath,
-                killTrackedTerminal: () => { },
-                sessionLogger: childLogger,
-            }, rootPath),
-            sessionLogger: childLogger,
-        }, {
-            targetPath,
-            repoRoot,
+            terminalManager: terminalManager ?? null,
+            logger: childLogger,
+        }), {
             requestId: "mcp:archive_worktree",
+            repoRoot,
+            worktreePath,
+            worktreeSlug,
         });
+        if (!result.ok) {
+            throw new Error(result.message);
+        }
         await options.workspaceGitService.listWorktrees(repoRoot, {
             force: true,
             reason: "mcp:archive-worktree",
@@ -1858,10 +1669,10 @@ export async function createAgentMcpServer(options) {
             newMode: z.string(),
         },
     }, async ({ agentId, modeId }) => {
-        await agentManager.setAgentMode(agentId, modeId);
+        const result = await setAgentModeCommand({ agentManager }, { agentId, modeId });
         return {
             content: [],
-            structuredContent: ensureValidJson({ success: true, newMode: modeId }),
+            structuredContent: ensureValidJson({ success: true, newMode: result.modeId }),
         };
     });
     registerTool("list_pending_permissions", {
@@ -1901,7 +1712,13 @@ export async function createAgentMcpServer(options) {
             success: z.boolean(),
         },
     }, async ({ agentId, requestId, response }) => {
-        await agentManager.respondToPermission(agentId, requestId, response);
+        await respondToAgentPermission({
+            agentManager,
+            agentId,
+            requestId,
+            response,
+            logger: childLogger,
+        });
         return {
             content: [],
             structuredContent: ensureValidJson({ success: true }),
@@ -1909,45 +1726,65 @@ export async function createAgentMcpServer(options) {
     });
     return server;
 }
-function mcpCreateWorktreeInput(repoRoot, target, paseoHome) {
-    const base = { cwd: repoRoot, runSetup: false, paseoHome };
+function archiveWorktreeDependencies(options, context) {
+    if (!options.github) {
+        throw new Error("GitHub service is required to archive worktrees");
+    }
+    if (!options.workspaceGitService) {
+        throw new Error("WorkspaceGitService is required to archive worktrees");
+    }
+    if (!options.archiveWorkspaceRecord) {
+        throw new Error("Workspace registry archiver is required to archive worktrees");
+    }
+    if (!options.emitWorkspaceUpdatesForWorkspaceIds) {
+        throw new Error("Workspace update emitter is required to archive worktrees");
+    }
+    if (!options.markWorkspaceArchiving) {
+        throw new Error("Workspace archiving marker is required to archive worktrees");
+    }
+    if (!options.clearWorkspaceArchiving) {
+        throw new Error("Workspace archiving clearer is required to archive worktrees");
+    }
+    if (!options.emitSessionMessage) {
+        throw new Error("Session message emitter is required to archive worktrees");
+    }
+    return {
+        paseoHome: options.paseoHome,
+        github: options.github,
+        workspaceGitService: options.workspaceGitService,
+        agentManager: context.agentManager,
+        agentStorage: context.agentStorage,
+        archiveWorkspaceRecord: options.archiveWorkspaceRecord,
+        emit: options.emitSessionMessage,
+        emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
+        markWorkspaceArchiving: options.markWorkspaceArchiving,
+        clearWorkspaceArchiving: options.clearWorkspaceArchiving,
+        isPathWithinRoot: isSameOrDescendantPath,
+        killTerminalsUnderPath: (rootPath) => killTerminalsUnderPath({
+            terminalManager: context.terminalManager,
+            isPathWithinRoot: isSameOrDescendantPath,
+            killTrackedTerminal: () => { },
+            sessionLogger: context.logger,
+        }, rootPath),
+        sessionLogger: context.logger,
+    };
+}
+function createMcpWorktreeCommandInput(repoRoot, target) {
+    const base = { cwd: repoRoot };
     switch (target.mode) {
         case "branch-off":
             return {
-                input: {
-                    ...base,
-                    worktreeSlug: target.newBranch,
-                    action: "branch-off",
-                    ...(target.base ? { refName: target.base } : {}),
-                },
+                ...base,
+                worktreeSlug: target.newBranch,
+                action: "branch-off",
+                ...(target.base ? { refName: target.base } : {}),
             };
         case "checkout-branch":
-            return {
-                input: { ...base, action: "checkout", refName: target.branch },
-            };
+            return { ...base, action: "checkout", refName: target.branch };
         case "checkout-pr":
-            return {
-                input: { ...base, action: "checkout", githubPrNumber: target.prNumber },
-            };
+            return { ...base, action: "checkout", githubPrNumber: target.prNumber };
         default:
             throw new Error("unreachable");
     }
 }
-async function createMcpWorktree(options) {
-    try {
-        if (!options.createPaseoWorktree) {
-            throw new Error("Paseo worktree service is not configured");
-        }
-        const result = await options.createPaseoWorktree(options.input, {
-            ...(options.resolveDefaultBranch
-                ? { resolveDefaultBranch: options.resolveDefaultBranch }
-                : {}),
-            ...(options.setupContinuation ? { setupContinuation: options.setupContinuation } : {}),
-        });
-        return result;
-    }
-    catch (error) {
-        throw toWorktreeRequestError(error);
-    }
-}
 //# sourceMappingURL=mcp-server.js.map