@getpaseo/server 0.1.101 → 0.1.102-beta.2

package/dist/scripts/supervisor.js

@@ -11,7 +11,11 @@ function parseLifecycleMessage(msg) {
     }
     const type = msg.type;
     if (type === "paseo:shutdown") {
-        return { type: "paseo:shutdown" };
+        const reason = msg.reason;
+        return {
+            type: "paseo:shutdown",
+            ...(typeof reason === "string" && reason.trim().length > 0 ? { reason } : {}),
+        };
     }
     if (type === "paseo:ready") {
         const listen = msg.listen;
@@ -169,12 +173,14 @@ export function runSupervisor(options) {
                 return;
             }
             if (lifecycleMessage.type === "paseo:shutdown") {
-                writeLifecycleLog("Worker requested shutdown");
-                requestShutdown("Shutdown requested by worker");
+                const reason = lifecycleMessage.reason ?? "worker_requested_shutdown";
+                writeLifecycleLog("Worker requested shutdown", { reason });
+                requestShutdown(reason);
                 return;
             }
-            writeLifecycleLog("Worker requested restart", lifecycleMessage.reason ? { reason: lifecycleMessage.reason } : {});
-            requestRestart("Restart requested by worker");
+            const reason = lifecycleMessage.reason ?? "worker_requested_restart";
+            writeLifecycleLog("Worker requested restart", { reason });
+            requestRestart(reason);
         });
         child.on("close", (code, signal) => {
             clearInterval(heartbeat);
@@ -199,6 +205,18 @@ export function runSupervisor(options) {
             exitSupervisor(typeof code === "number" ? code : 1);
         });
     };
+    const signalWorker = (signal, reason) => {
+        if (!child) {
+            return;
+        }
+        writeLifecycleLog("Supervisor sending signal to worker", {
+            reason,
+            signal,
+            supervisorPid: process.pid,
+            workerPid: child.pid ?? null,
+        });
+        child.kill(signal);
+    };
     const requestRestart = (reason) => {
         if (!child || restarting || shuttingDown) {
             return;
@@ -206,7 +224,7 @@ export function runSupervisor(options) {
         restarting = true;
         writeLifecycleLog("Restart requested", { reason });
         log(`${reason}. Stopping worker for restart...`);
-        child.kill("SIGTERM");
+        signalWorker("SIGTERM", reason);
     };
     const requestShutdown = (reason) => {
         if (shuttingDown) {
@@ -220,10 +238,10 @@ export function runSupervisor(options) {
             exitSupervisor(0);
             return;
         }
-        child.kill("SIGTERM");
+        signalWorker("SIGTERM", reason);
     };
     const forwardSignal = (signal) => {
-        requestShutdown(`Received ${signal}`);
+        requestShutdown(`supervisor_received_${signal}`);
     };
     process.on("SIGINT", () => forwardSignal("SIGINT"));
     process.on("SIGTERM", () => forwardSignal("SIGTERM"));

package/dist/server/server/agent/activity-curator.d.ts

@@ -1,11 +1,28 @@
 import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
 interface ActivityCuratorOptions {
     maxItems?: number;
     labelAssistantMessages?: boolean;
+    includeKinds?: readonly AgentTimelineItem["type"][];
+    includeExternalToolInput?: boolean;
 }
+type TextAgentAttachment = Extract<AgentAttachment, {
+    type: "text";
+}>;
 /**
  * Convert normalized agent timeline items into a concise text summary.
  */
 export declare function curateAgentActivity(timeline: AgentTimelineItem[], options?: ActivityCuratorOptions): string;
+export declare function buildAgentForkContextAttachment(input: {
+    rows: readonly AgentTimelineRow[];
+    boundaryMessageId?: string | null;
+    agentTitle?: string | null;
+    cwd?: string | null;
+}): {
+    attachment: TextAgentAttachment;
+    itemCount: number;
+    boundaryMessageId: string | null;
+};
 export {};
 //# sourceMappingURL=activity-curator.d.ts.map

package/dist/server/server/agent/activity-curator.js

@@ -71,16 +71,42 @@ function projectForCuration(items) {
     }));
     return projectTimelineRows({ rows, mode: "projected" }).map((entry) => entry.item);
 }
-function curateAgentActivityEntries(timeline, options) {
-    if (timeline.length === 0) {
+function shouldIncludeItem(item, options) {
+    if (!options?.includeKinds) {
+        return true;
+    }
+    return options.includeKinds.includes(item.type);
+}
+function formatToolCallEntry(item, options) {
+    const inputJson = formatToolInputJson(inputFromUnknownDetail(item.detail));
+    const display = buildToolCallDisplayModel({
+        name: item.name,
+        status: item.status,
+        error: item.error,
+        detail: item.detail,
+        metadata: item.metadata,
+    });
+    const displayName = display.displayName;
+    const summary = formatToolSummary(display.summary);
+    if ((options?.includeExternalToolInput ?? true) &&
+        isLikelyExternalToolName(item.name) &&
+        inputJson) {
+        return activityEntry(`[${displayName}] ${inputJson}`);
+    }
+    return activityEntry(summary ? `[${displayName}] ${summary}` : `[${displayName}]`);
+}
+function curateProjectedActivityEntries(items, options) {
+    if (items.length === 0) {
         return [];
     }
-    const collapsed = projectForCuration(timeline);
     const maxItems = options?.maxItems ?? DEFAULT_MAX_ITEMS;
-    const recentItems = maxItems > 0 && collapsed.length > maxItems ? collapsed.slice(-maxItems) : collapsed;
+    const recentItems = maxItems > 0 && items.length > maxItems ? items.slice(-maxItems) : items;
     const entries = [];
     const buffers = { message: "", thought: "" };
     for (const item of recentItems) {
+        if (!shouldIncludeItem(item, options)) {
+            continue;
+        }
         switch (item.type) {
             case "user_message":
                 flushBuffers(entries, buffers, options);
@@ -94,26 +120,7 @@ function curateAgentActivityEntries(timeline, options) {
                 break;
             case "tool_call": {
                 flushBuffers(entries, buffers, options);
-                const inputJson = formatToolInputJson(inputFromUnknownDetail(item.detail));
-                const display = buildToolCallDisplayModel({
-                    name: item.name,
-                    status: item.status,
-                    error: item.error,
-                    detail: item.detail,
-                    metadata: item.metadata,
-                });
-                const displayName = display.displayName;
-                const summary = formatToolSummary(display.summary);
-                if (isLikelyExternalToolName(item.name) && inputJson) {
-                    entries.push(activityEntry(`[${displayName}] ${inputJson}`));
-                    break;
-                }
-                if (summary) {
-                    entries.push(activityEntry(`[${displayName}] ${summary}`));
-                }
-                else {
-                    entries.push(activityEntry(`[${displayName}]`));
-                }
+                entries.push(formatToolCallEntry(item, options));
                 break;
             }
             case "todo":
@@ -138,6 +145,10 @@ function curateAgentActivityEntries(timeline, options) {
     flushBuffers(entries, buffers, options);
     return entries;
 }
+function curateAgentActivityEntries(timeline, options) {
+    const collapsed = projectForCuration(timeline);
+    return curateProjectedActivityEntries(collapsed, options);
+}
 /**
  * Convert normalized agent timeline items into a concise text summary.
  */
@@ -147,4 +158,70 @@ export function curateAgentActivity(timeline, options) {
         ? entries.map((entry) => entry.text).join("\n")
         : "No activity to display.";
 }
+function selectForkContextRows(input) {
+    const boundaryMessageId = input.boundaryMessageId?.trim() || null;
+    if (!boundaryMessageId) {
+        const projected = projectTimelineRows({ rows: input.rows, mode: "projected" });
+        return {
+            items: projected.map((entry) => entry.item),
+            boundaryMessageId: null,
+        };
+    }
+    const boundaryIndex = input.rows.findLastIndex((row) => row.item.type === "assistant_message" && row.item.messageId === boundaryMessageId);
+    if (boundaryIndex < 0) {
+        throw new Error("Selected assistant message is no longer available.");
+    }
+    const selectedRows = input.rows.slice(0, boundaryIndex + 1);
+    const projected = projectTimelineRows({ rows: selectedRows, mode: "projected" });
+    return {
+        items: projected.map((entry) => entry.item),
+        boundaryMessageId,
+    };
+}
+function trimContextMetadata(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : null;
+}
+function buildForkContextText(input) {
+    const header = ["Chat history from a previous Paseo agent."];
+    const agentTitle = trimContextMetadata(input.agentTitle);
+    const cwd = trimContextMetadata(input.cwd);
+    if (agentTitle) {
+        header.push(`Source agent: ${agentTitle}`);
+    }
+    if (cwd) {
+        header.push(`Source directory: ${cwd}`);
+    }
+    return `${header.join("\n")}\n\n${input.body}`;
+}
+export function buildAgentForkContextAttachment(input) {
+    const selected = selectForkContextRows({
+        rows: input.rows,
+        boundaryMessageId: input.boundaryMessageId,
+    });
+    const entries = curateProjectedActivityEntries(selected.items, {
+        maxItems: 0,
+        labelAssistantMessages: true,
+        includeKinds: ["user_message", "assistant_message", "tool_call"],
+        includeExternalToolInput: false,
+    });
+    const body = entries.length > 0
+        ? entries.map((entry) => entry.text).join("\n")
+        : "No chat history to display.";
+    return {
+        attachment: {
+            type: "text",
+            mimeType: "text/plain",
+            contextKind: "chat_history",
+            title: "Chat history",
+            text: buildForkContextText({
+                body,
+                agentTitle: input.agentTitle,
+                cwd: input.cwd,
+            }),
+        },
+        itemCount: selected.items.length,
+        boundaryMessageId: selected.boundaryMessageId,
+    };
+}
 //# sourceMappingURL=activity-curator.js.map

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

@@ -2623,7 +2623,11 @@ export class AgentManager {
             return undefined;
         }
         try {
-            const catalog = await client.fetchCatalog({ cwd: config.cwd, force: false });
+            const catalog = await client.fetchCatalog({
+                scope: "workspace",
+                cwd: config.cwd,
+                force: false,
+            });
             return (catalog.models.find((model) => model.isDefault) ?? catalog.models[0])?.id;
         }
         catch {

package/dist/server/server/agent/agent-sdk-types.d.ts

@@ -585,11 +585,16 @@ export interface AgentSession {
         }): Promise<void>;
     } | null;
 }
-export interface FetchCatalogOptions {
+export type FetchCatalogOptions = {
+    scope: "global";
+    force: boolean;
+    timeoutMs?: number;
+} | {
+    scope: "workspace";
     cwd: string;
     force: boolean;
     timeoutMs?: number;
-}
+};
 export interface ProviderCatalog {
     models: AgentModelDefinition[];
     modes: AgentMode[];

package/dist/server/server/agent/provider-snapshot-manager.d.ts

@@ -5,6 +5,7 @@ import type { WorkspaceGitService } from "../workspace-git-service.js";
 import type { ManagedProcessRegistry } from "../managed-processes/managed-processes.js";
 import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
 import type { MutableDaemonConfig } from "../daemon-config-store.js";
+export declare const GLOBAL_PROVIDER_SNAPSHOT_KEY = "paseo:global";
 type ProviderSnapshotChangeListener = (entries: ProviderSnapshotEntry[], cwd: string) => void;
 export interface ProviderSnapshotManagerOptions {
     logger: Logger;
@@ -21,6 +22,10 @@ interface ProviderSnapshotRefreshOptions {
     cwd: string;
     providers?: AgentProvider[];
 }
+interface ProviderSnapshotWarmUpOptions {
+    cwd?: string | null;
+    providers?: AgentProvider[];
+}
 interface ProviderSnapshotReadOptions {
     cwd?: string | null;
     providers?: AgentProvider[];
@@ -80,7 +85,7 @@ export declare class ProviderSnapshotManager {
     getSnapshot(cwd?: string): ProviderSnapshotEntry[];
     refreshSnapshotForCwd(options: ProviderSnapshotRefreshOptions): Promise<void>;
     refreshSettingsSnapshot(options?: Omit<ProviderSnapshotRefreshOptions, "cwd">): Promise<void>;
-    warmUpSnapshotForCwd(options: ProviderSnapshotRefreshOptions): Promise<void>;
+    warmUpSnapshotForCwd(options: ProviderSnapshotWarmUpOptions): Promise<void>;
     refresh(options: ProviderSnapshotRefreshOptions): Promise<void>;
     listRegisteredProviderIds(): AgentProvider[];
     hasProvider(provider: AgentProvider): boolean;
@@ -101,6 +106,7 @@ export declare class ProviderSnapshotManager {
     destroy(): void;
     private buildRegistry;
     private resolveParent;
+    private getSnapshotForTarget;
     private getReadyProvider;
     private requireProvider;
     private refreshDiagnosticSnapshotEntry;
@@ -124,5 +130,6 @@ export declare class ProviderSnapshotManager {
     private resolveRefreshProviders;
 }
 export declare function resolveSnapshotCwd(cwd?: string | null): string;
+export declare function isGlobalProviderSnapshotKey(cwd: string): boolean;
 export {};
 //# sourceMappingURL=provider-snapshot-manager.d.ts.map

package/dist/server/server/agent/provider-snapshot-manager.js

@@ -9,6 +9,7 @@ import { formatProviderDiagnostic, formatProviderDiagnosticError, } from "./prov
 const DEFAULT_REFRESH_TIMEOUT_MS = 60000;
 const DEFAULT_DIAGNOSTIC_TIMEOUT_MS = 120000;
 const REFRESH_TIMEOUT_ENV_VAR = "PASEO_PROVIDER_REFRESH_TIMEOUT_MS";
+export const GLOBAL_PROVIDER_SNAPSHOT_KEY = "paseo:global";
 // Provider refresh probes can be slow on cold starts (e.g. Copilot's first
 // `copilot --acp` invocation, OpenCode workspace probes with many MCP servers).
 // Allow operators to bump the ceiling via env var without rebuilding.
@@ -52,31 +53,30 @@ export class ProviderSnapshotManager {
         this.providerClients = { ...this.extraClients };
     }
     getSnapshot(cwd) {
-        const resolvedCwd = resolveSnapshotCwd(cwd);
-        const providersToWarm = this.resolveProvidersToWarm(resolvedCwd);
-        if (providersToWarm.length > 0) {
-            void this.warmUp(resolvedCwd, providersToWarm);
-        }
-        return entriesToArray(this.getOrCreateSnapshot(resolvedCwd));
+        const target = resolveProviderSnapshotTarget(cwd);
+        return this.getSnapshotForTarget(target);
     }
     async refreshSnapshotForCwd(options) {
         const snapshotCwd = resolveSnapshotCwd(options.cwd);
+        const target = createWorkspaceSnapshotTarget(snapshotCwd);
         const providers = this.resolveRefreshProviders(options.providers);
         this.resetSnapshotToLoading(snapshotCwd, providers, { preserveExisting: false });
         this.emitChange(snapshotCwd);
-        await this.refreshProviders(snapshotCwd, providers ?? this.getProviderIds());
+        await this.refreshProviders(target, providers ?? this.getProviderIds());
     }
     async refreshSettingsSnapshot(options = {}) {
-        const homeCwd = resolveSnapshotCwd();
+        const target = createGlobalSnapshotTarget();
+        const homeCwd = target.snapshotCwd;
         const providers = this.resolveRefreshProviders(options.providers);
         const providersToRefresh = providers ?? this.getProviderIds();
         this.clearCachedProviders(providers);
         this.resetSnapshotToLoading(homeCwd, providers, { preserveExisting: false });
         this.emitChange(homeCwd);
-        await this.refreshProviders(homeCwd, providersToRefresh);
+        await this.refreshProviders(target, providersToRefresh);
     }
     async warmUpSnapshotForCwd(options) {
-        const snapshotCwd = resolveSnapshotCwd(options.cwd);
+        const target = resolveProviderSnapshotTarget(options.cwd);
+        const snapshotCwd = target.snapshotCwd;
         const providers = this.resolveRefreshProviders(options.providers);
         if (options.providers && providers?.length === 0) {
             return;
@@ -85,7 +85,7 @@ export class ProviderSnapshotManager {
         if (providersToWarm.length === 0) {
             return;
         }
-        await this.warmUp(snapshotCwd, providersToWarm);
+        await this.warmUp(target, providersToWarm);
     }
     async refresh(options) {
         await this.refreshSnapshotForCwd(options);
@@ -128,12 +128,12 @@ export class ProviderSnapshotManager {
         return client;
     }
     async listProviders(input = {}) {
-        const cwd = resolveSnapshotCwd(input.cwd);
+        const target = resolveProviderSnapshotTarget(input.cwd);
         if (input.wait) {
-            await this.warmUpSnapshotForCwd({ cwd, providers: input.providers });
+            await this.warmUpSnapshotForCwd({ cwd: input.cwd, providers: input.providers });
         }
         const providerFilter = input.providers ? new Set(input.providers) : null;
-        const entries = this.getSnapshot(cwd);
+        const entries = this.getSnapshotForTarget(target);
         return providerFilter ? entries.filter((entry) => providerFilter.has(entry.provider)) : entries;
     }
     async getProvider(input) {
@@ -276,6 +276,13 @@ export class ProviderSnapshotManager {
             }),
         };
     }
+    getSnapshotForTarget(target) {
+        const providersToWarm = this.resolveProvidersToWarm(target.snapshotCwd);
+        if (providersToWarm.length > 0) {
+            void this.warmUp(target, providersToWarm);
+        }
+        return entriesToArray(this.getOrCreateSnapshot(target.snapshotCwd));
+    }
     async getReadyProvider(input) {
         const entry = await this.getProvider(input);
         if (!entry.enabled) {
@@ -298,9 +305,11 @@ export class ProviderSnapshotManager {
     }
     async refreshDiagnosticSnapshotEntry(provider, definition) {
         try {
-            const cwd = resolveSnapshotCwd();
-            await this.refreshSnapshotForCwd({ cwd, providers: [provider] });
-            return await this.getProvider({ cwd, provider, wait: false });
+            const target = createGlobalSnapshotTarget();
+            this.resetSnapshotToLoading(target.snapshotCwd, [provider], { preserveExisting: false });
+            this.emitChange(target.snapshotCwd);
+            await this.refreshProviders(target, [provider]);
+            return await this.getProvider({ provider, wait: false });
         }
         catch (error) {
             return {
@@ -371,16 +380,22 @@ export class ProviderSnapshotManager {
         }
         return entries;
     }
-    async warmUp(cwd, providers) {
+    async warmUp(target, providers) {
         const providersToRefresh = providers ?? this.getProviderIds();
         await this.loadProviders({
-            cwd,
+            snapshotCwd: target.snapshotCwd,
+            catalogScope: target.catalogScope,
             providers: providersToRefresh,
             force: false,
         });
     }
-    async refreshProviders(cwd, providers) {
-        await this.loadProviders({ cwd, providers, force: true });
+    async refreshProviders(target, providers) {
+        await this.loadProviders({
+            snapshotCwd: target.snapshotCwd,
+            catalogScope: target.catalogScope,
+            providers,
+            force: true,
+        });
     }
     resolveProvidersToWarm(cwd, providers) {
         const providersToInspect = providers ?? this.getProviderIds();
@@ -440,40 +455,41 @@ export class ProviderSnapshotManager {
         if (!definition) {
             return Promise.resolve();
         }
-        const existingLoad = this.getProviderLoad(options.cwd, options.provider);
+        const existingLoad = this.getProviderLoad(options.snapshotCwd, options.provider);
         if (existingLoad && !options.force) {
             return existingLoad.promise;
         }
-        const existingEntry = this.snapshots.get(options.cwd)?.get(options.provider);
+        const existingEntry = this.snapshots.get(options.snapshotCwd)?.get(options.provider);
         if (existingEntry && existingEntry.status !== "loading" && !options.force) {
             return Promise.resolve();
         }
         const load = {
             promise: Promise.resolve(),
         };
-        this.setProviderLoad(options.cwd, options.provider, load);
+        this.setProviderLoad(options.snapshotCwd, options.provider, load);
         load.promise = Promise.resolve()
             .then(() => this.refreshProvider({
-            cwd: options.cwd,
+            snapshotCwd: options.snapshotCwd,
+            catalogScope: options.catalogScope,
             provider: options.provider,
             definition,
             load,
             force: options.force,
         }))
             .finally(() => {
-            const providerLoads = this.providerLoads.get(options.cwd);
+            const providerLoads = this.providerLoads.get(options.snapshotCwd);
             if (providerLoads?.get(options.provider) === load) {
                 providerLoads.delete(options.provider);
             }
             if (providerLoads?.size === 0) {
-                this.providerLoads.delete(options.cwd);
+                this.providerLoads.delete(options.snapshotCwd);
             }
         });
         return load.promise;
     }
     async refreshProvider(options) {
-        const { cwd, provider, definition, load, force } = options;
-        const snapshot = this.getOrCreateSnapshot(options.cwd);
+        const { snapshotCwd, catalogScope, provider, definition, load, force } = options;
+        const snapshot = this.getOrCreateSnapshot(snapshotCwd);
         const base = {
             provider,
             label: definition.label,
@@ -481,11 +497,11 @@ export class ProviderSnapshotManager {
             defaultModeId: definition.defaultModeId,
         };
         const setEntry = (entry) => {
-            if (!this.isCurrentProviderLoad(cwd, provider, load)) {
+            if (!this.isCurrentProviderLoad(snapshotCwd, provider, load)) {
                 return false;
             }
             snapshot.set(provider, entry);
-            this.emitChange(cwd);
+            this.emitChange(snapshotCwd);
             return true;
         };
         try {
@@ -499,7 +515,8 @@ export class ProviderSnapshotManager {
                 setEntry({ ...base, status: "unavailable", enabled: true });
                 return;
             }
-            const catalog = await withTimeout(definition.fetchCatalog({ cwd, force, timeoutMs: this.refreshTimeoutMs }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
+            const catalogOptions = createFetchCatalogOptions(catalogScope, force);
+            const catalog = await withTimeout(definition.fetchCatalog({ ...catalogOptions, timeoutMs: this.refreshTimeoutMs }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
             setEntry({
                 ...base,
                 status: "ready",
@@ -517,7 +534,7 @@ export class ProviderSnapshotManager {
                 error: toErrorMessage(error),
             });
             if (emitted) {
-                this.logger.warn({ err: error, provider, cwd }, "Failed to refresh provider snapshot");
+                this.logger.warn({ err: error, provider, cwd: snapshotCwd }, "Failed to refresh provider snapshot");
             }
         }
     }
@@ -609,6 +626,34 @@ export function resolveSnapshotCwd(cwd) {
     }
     return resolved;
 }
+function resolveProviderSnapshotTarget(cwd) {
+    const trimmed = cwd?.trim();
+    if (!trimmed) {
+        return createGlobalSnapshotTarget();
+    }
+    return createWorkspaceSnapshotTarget(resolveSnapshotCwd(trimmed));
+}
+function createGlobalSnapshotTarget() {
+    return {
+        snapshotCwd: GLOBAL_PROVIDER_SNAPSHOT_KEY,
+        catalogScope: { scope: "global" },
+    };
+}
+function createWorkspaceSnapshotTarget(cwd) {
+    const snapshotCwd = resolveSnapshotCwd(cwd);
+    return {
+        snapshotCwd,
+        catalogScope: { scope: "workspace", cwd: snapshotCwd },
+    };
+}
+function createFetchCatalogOptions(scope, force) {
+    return scope.scope === "global"
+        ? { scope: "global", force }
+        : { scope: "workspace", cwd: scope.cwd, force };
+}
+export function isGlobalProviderSnapshotKey(cwd) {
+    return cwd === GLOBAL_PROVIDER_SNAPSHOT_KEY;
+}
 function entriesToArray(entries) {
     return Array.from(entries.values(), cloneEntry);
 }

package/dist/server/server/agent/providers/acp-agent.d.ts

@@ -261,6 +261,13 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     constructor(config: AgentSessionConfig, options: ACPAgentSessionOptions);
     get id(): string | null;
     initializeNewSession(): Promise<void>;
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
     initializeResumedSession(): Promise<void>;
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
     startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{

package/dist/server/server/agent/providers/acp-agent.js

@@ -386,7 +386,7 @@ export class ACPAgentClient {
         return session;
     }
     async fetchCatalog(options) {
-        const { cwd } = options;
+        const cwd = options.scope === "global" ? homedir() : options.cwd;
         const timeoutMs = options.timeoutMs ?? ACP_CATALOG_TIMEOUT_MS;
         let probe = null;
         try {
@@ -802,6 +802,13 @@ export class ACPAgentSession {
         this.applySessionState(response);
         await this.applyConfiguredOverrides();
     }
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
     async initializeResumedSession() {
         const handle = this.initialHandle;
         if (!handle) {