@getpaseo/server 0.1.101 → 0.1.102-beta.2

package/dist/server/server/agent/providers/claude/agent.js

@@ -22,6 +22,7 @@ import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
 import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { withTimeout } from "../../../../utils/promise-timeout.js";
+import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 import { execCommand } from "../../../../utils/spawn.js";
 import { composeSystemPromptParts } from "../../system-prompt.js";
 const fsPromises = promises;
@@ -1289,6 +1290,13 @@ function readLegacyResultUsageTokens(usage) {
 function isClaudeSubagentToolName(name) {
     return name === "Task" || name === "Agent";
 }
+function readClaudeParentToolUseId(message) {
+    if (!("parent_tool_use_id" in message)) {
+        return null;
+    }
+    const parentToolUseId = message.parent_tool_use_id;
+    return typeof parentToolUseId === "string" && parentToolUseId.length > 0 ? parentToolUseId : null;
+}
 class ClaudeContextUsageState {
     constructor(initialContextWindowMaxTokens) {
         this.completedResultTurns = 0;
@@ -1414,6 +1422,7 @@ class ClaudeAgentSession {
         this.provider = "claude";
         this.capabilities = CLAUDE_CAPABILITIES;
         this.query = null;
+        this.childProcess = null;
         this.input = null;
         this.planResumeMode = null;
         this.availableModes = DEFAULT_MODES;
@@ -1887,6 +1896,19 @@ class ClaudeAgentSession {
         await this.awaitWithTimeout(this.query?.return?.(), "close query return");
         this.query = null;
         this.input = null;
+        // Terminate the entire process tree (claude + MCP children) to prevent
+        // orphan accumulation. The SDK's internal cleanup may only kill the
+        // direct child process.
+        if (this.childProcess) {
+            const result = await terminateWithTreeKill(this.childProcess, {
+                gracefulTimeoutMs: 2000,
+                forceTimeoutMs: 2000,
+            });
+            if (result === "kill-timeout") {
+                this.logger.warn({ pid: this.childProcess.pid, agentId: this.agentId }, "Claude process tree did not report exit after SIGKILL");
+            }
+            this.childProcess = null;
+        }
         if (this.persistSession === false && this.claudeSessionId) {
             // Claude Code currently ignores --no-session-persistence outside --print mode
             // (see `claude --help`), so the SDK's persistSession=false is silently dropped
@@ -2225,6 +2247,18 @@ class ClaudeAgentSession {
             catch {
                 /* ignore */
             }
+            // Tree-kill the old process tree now that the SDK has cleaned up.
+            // If we skip this, MCP children of the previous claude process can
+            // survive as orphans when the session spawns a replacement query.
+            if (this.childProcess) {
+                await terminateWithTreeKill(this.childProcess, {
+                    gracefulTimeoutMs: 2000,
+                    forceTimeoutMs: 2000,
+                }).catch(() => {
+                    /* process may already be dead */
+                });
+                this.childProcess = null;
+            }
         }
         // Preserve claudeSessionId across query recreation so buildOptions() passes
         // resume: sessionId and the new query continues the existing conversation.
@@ -2237,6 +2271,9 @@ class ClaudeAgentSession {
             runtimeSettings: this.runtimeSettings,
             launchEnv: this.launchEnv,
             queryFactory: this.queryFactory,
+            onChildProcess: (child) => {
+                this.childProcess = child;
+            },
         });
         const fastMode = this.resolveFastModeSetting();
         if (fastMode !== null) {
@@ -2809,17 +2846,19 @@ class ClaudeAgentSession {
             suppressAssistantText: true,
             suppressReasoning: true,
         });
-        const assistantTimelineEvents = this.timelineAssembler
-            .consume({
-            message,
-            runId: turnId,
-            messageIdHint,
-        })
-            .map((item) => ({
-            type: "timeline",
-            item,
-            provider: "claude",
-        }));
+        const assistantTimelineEvents = readClaudeParentToolUseId(message)
+            ? []
+            : this.timelineAssembler
+                .consume({
+                message,
+                runId: turnId,
+                messageIdHint,
+            })
+                .map((item) => ({
+                type: "timeline",
+                item,
+                provider: "claude",
+            }));
         return [...messageEvents, ...assistantTimelineEvents];
     }
     async handleMissingResumedConversation(message, activeQuery) {
@@ -2867,9 +2906,7 @@ class ClaudeAgentSession {
         }
     }
     translateMessageToEvents(message, options) {
-        const parentToolUseId = "parent_tool_use_id" in message
-            ? message.parent_tool_use_id
-            : null;
+        const parentToolUseId = readClaudeParentToolUseId(message);
         if (parentToolUseId) {
             return this.sidechainTracker.handleMessage(message, parentToolUseId);
         }

package/dist/server/server/agent/providers/claude/query.d.ts

@@ -1,3 +1,4 @@
+import { type ChildProcess } from "node:child_process";
 import { query, type Options, type Query } from "@anthropic-ai/claude-agent-sdk";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export type ClaudeOptions = Options;
@@ -9,6 +10,8 @@ export interface ClaudeQueryContext {
     runtimeSettings?: ProviderRuntimeSettings;
     launchEnv?: Record<string, string>;
     queryFactory?: ClaudeQueryFactory;
+    /** Called with the spawned child process so the caller can tree-kill it on close. */
+    onChildProcess?: (child: ChildProcess) => void;
 }
 export declare function claudeQuery(input: ClaudeQueryInput, context?: ClaudeQueryContext): Query;
 //# sourceMappingURL=query.d.ts.map

package/dist/server/server/agent/providers/claude/query.js

@@ -24,7 +24,8 @@ function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
         args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
     };
 }
-function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
+function applyRuntimeSettingsToClaudeOptions(options, context) {
+    const { runtimeSettings, launchEnv, onChildProcess } = context;
     return {
         ...options,
         spawnClaudeCodeProcess: (spawnOptions) => {
@@ -62,6 +63,7 @@ function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv
                 // The command is always a resolved binary path, so shell routing is unnecessary.
                 shell: false,
             });
+            onChildProcess?.(child);
             if (typeof options.stderr === "function") {
                 child.stderr?.on("data", (chunk) => {
                     options.stderr?.(chunk.toString());
@@ -78,7 +80,7 @@ export function claudeQuery(input, context = {}) {
     const launchQuery = context.queryFactory ?? query;
     return launchQuery({
         ...input,
-        options: applyRuntimeSettingsToClaudeOptions(input.options, context.runtimeSettings, context.launchEnv),
+        options: applyRuntimeSettingsToClaudeOptions(input.options, context),
     });
 }
 //# sourceMappingURL=query.js.map

package/dist/server/server/agent/providers/mock-load-test-agent.js

@@ -439,12 +439,14 @@ export class MockLoadTestAgentSession {
         }
         const profile = resolveModelProfile(this.modelId);
         const turnId = randomUUID();
+        const assistantMessageId = randomUUID();
         let resolve;
         const completed = new Promise((promiseResolve) => {
             resolve = promiseResolve;
         });
         const turn = {
             turnId,
+            assistantMessageId,
             prompt,
             startedAt: Date.now(),
             cycle: 0,
@@ -655,6 +657,7 @@ export class MockLoadTestAgentSession {
         this.emitTimeline(turn.turnId, {
             type: "assistant_message",
             text: finalText,
+            messageId: turn.assistantMessageId,
         });
         this.activeTurn = null;
         this.emit({
@@ -669,6 +672,7 @@ export class MockLoadTestAgentSession {
                 {
                     type: "assistant_message",
                     text: finalText,
+                    messageId: turn.assistantMessageId,
                 },
             ],
             canceled: false,
@@ -768,6 +772,7 @@ export class MockLoadTestAgentSession {
                 ? {
                     type: "assistant_message",
                     text: `stress-update-${index}`,
+                    messageId: turn.assistantMessageId,
                 }
                 : {
                     type: "todo",
@@ -834,6 +839,7 @@ export class MockLoadTestAgentSession {
             this.emitTimeline(turn.turnId, {
                 type: "assistant_message",
                 text: `data:image/png;base64,${payload}`,
+                messageId: turn.assistantMessageId,
             });
         }
         this.activeTurn = null;
@@ -892,6 +898,7 @@ export class MockLoadTestAgentSession {
                 this.emitTimeline(turn.turnId, {
                     type: "assistant_message",
                     text: event.text,
+                    messageId: turn.assistantMessageId,
                 });
                 return;
             }
@@ -933,6 +940,7 @@ export class MockLoadTestAgentSession {
         this.emitTimeline(turn.turnId, {
             type: "assistant_message",
             text: "\n\n_(end of synthetic stream)_\n",
+            messageId: turn.assistantMessageId,
         });
         this.finishTurnWithText(turn, "Synthetic load test complete");
     }

package/dist/server/server/agent/providers/opencode/paths.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveOpenCodeHomeDir(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/server/server/agent/providers/opencode/paths.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { resolvePaseoHome } from "../../../paseo-home.js";
+const OPENCODE_HOME_DIRNAME = "opencode-home";
+export function resolveOpenCodeHomeDir(env = process.env) {
+    return path.join(resolvePaseoHome(env), OPENCODE_HOME_DIRNAME);
+}
+//# sourceMappingURL=paths.js.map

package/dist/server/server/agent/providers/opencode/server-manager.d.ts

@@ -46,6 +46,7 @@ export interface OpenCodeServerManagerOptions {
     terminateProcess?: ProcessTerminator;
     portAllocator?: OpenCodePortAllocator;
     resolveCommandPrefix?: OpenCodeCommandPrefixResolver;
+    resolveHomeDir?: () => string;
     spawnServerProcess?: OpenCodeServerProcessSpawner;
 }
 export declare class OpenCodeServerManager implements OpenCodeServerManagerLike {
@@ -62,6 +63,7 @@ export declare class OpenCodeServerManager implements OpenCodeServerManagerLike
     private readonly terminateProcess;
     private readonly portAllocator;
     private readonly resolveCommandPrefix;
+    private readonly resolveHomeDir;
     private readonly spawnServerProcess;
     constructor(options: OpenCodeServerManagerOptions);
     static getInstance(logger: Logger, runtimeSettings?: ProviderRuntimeSettings, options?: Omit<OpenCodeServerManagerOptions, "logger" | "runtimeSettings">): OpenCodeServerManager;

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

@@ -1,9 +1,12 @@
+import { mkdirSync } from "node:fs";
+import { stat } from "node:fs/promises";
 import net from "node:net";
-import os from "node:os";
+import path from "node:path";
 import { findExecutable } from "../../../../executable-resolution/executable-resolution.js";
 import { spawnProcess } from "../../../../utils/spawn.js";
 import { terminateWithTreeKill } from "../../../../utils/tree-kill.js";
 import { createProviderEnvSpec, resolveProviderCommandPrefix, } from "../../provider-launch-config.js";
+import { resolveOpenCodeHomeDir } from "./paths.js";
 const OPENCODE_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT_MS = 5000;
 const OPENCODE_SERVER_FORCE_SHUTDOWN_TIMEOUT_MS = 1000;
 export class OpenCodeServerManager {
@@ -21,6 +24,7 @@ export class OpenCodeServerManager {
         this.resolveCommandPrefix =
             options.resolveCommandPrefix ??
                 (() => resolveProviderCommandPrefix(this.runtimeSettings?.command, resolveOpenCodeBinary));
+        this.resolveHomeDir = options.resolveHomeDir ?? resolveOpenCodeHomeDir;
         this.spawnServerProcess = options.spawnServerProcess ?? spawnProcess;
     }
     static getInstance(logger, runtimeSettings, options = {}) {
@@ -164,7 +168,11 @@ export class OpenCodeServerManager {
         const url = `http://127.0.0.1:${port}`;
         const launchPrefix = await this.resolveCommandPrefix();
         const serverArgs = [...launchPrefix.args, "serve", "--port", String(port)];
-        const serverCwd = os.homedir();
+        // Use a neutral OpenCode home as the server cwd. Launching from the user's
+        // home directory causes OpenCode to treat it as the default workspace and
+        // index the entire home tree.
+        const serverCwd = this.resolveHomeDir();
+        mkdirSync(serverCwd, { recursive: true });
         const serverProcess = this.spawnServerProcess(launchPrefix.command, serverArgs, {
             cwd: serverCwd,
             detached: process.platform !== "win32",
@@ -371,10 +379,31 @@ OpenCodeServerManager.instance = null;
 OpenCodeServerManager.exitHandlerRegistered = false;
 async function resolveOpenCodeBinary() {
     const found = await findExecutable("opencode");
-    if (found) {
-        return found;
+    if (!found) {
+        throw new Error("OpenCode binary not found. Install OpenCode (https://github.com/opencode-ai/opencode) and ensure it is available in your shell PATH.");
+    }
+    if (process.platform === "win32" && path.extname(found).toLowerCase() === ".cmd") {
+        // Global npm: <prefix>/opencode.cmd → <prefix>/node_modules/opencode-ai/bin/opencode.exe
+        const globalCandidate = path.join(path.dirname(found), "node_modules", "opencode-ai", "bin", "opencode.exe");
+        if (await pathExists(globalCandidate))
+            return globalCandidate;
+        // Local/pnpm: <project>/node_modules/.bin/opencode.cmd → <project>/node_modules/opencode-ai/bin/opencode.exe
+        const localCandidate = path.join(path.dirname(found), "..", "opencode-ai", "bin", "opencode.exe");
+        if (await pathExists(localCandidate))
+            return localCandidate;
+        console.warn("[opencode-server] Found opencode.cmd but could not resolve the real opencode.exe. " +
+            "The process may not be properly terminated on exit. Path: %s", found);
+    }
+    return found;
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
     }
-    throw new Error("OpenCode binary not found. Install OpenCode (https://github.com/opencode-ai/opencode) and ensure it is available in your shell PATH.");
 }
 function findAvailablePort() {
     return new Promise((resolve, reject) => {

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

@@ -4,6 +4,7 @@ import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOpt
 import { isDefaultAgentCreateConfigUnattended } from "../create-agent-mode.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type OpenCodeServerManagerLike } from "./opencode/server-manager.js";
+import { resolveOpenCodeHomeDir } from "./opencode/paths.js";
 import type { ManagedProcessRegistry } from "../../managed-processes/managed-processes.js";
 declare function resolveOpenCodeCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
 declare function isOpenCodeCreateConfigUnattended(input: Parameters<typeof isDefaultAgentCreateConfigUnattended>[0]): boolean;
@@ -100,11 +101,13 @@ export declare const __openCodeInternals: {
     resolveOpenCodeSelectedModelContextWindow: typeof resolveOpenCodeSelectedModelContextWindow;
     isSelectableOpenCodeAgent: typeof isSelectableOpenCodeAgent;
     mapOpenCodeAgentToMode: typeof mapOpenCodeAgentToMode;
+    resolveOpenCodeHomeDir: typeof resolveOpenCodeHomeDir;
     readonly OpenCodeAgentSession: typeof OpenCodeAgentSession;
 };
 interface OpenCodeAgentClientDeps {
     serverManager?: OpenCodeServerManagerLike;
     createClient?: OpenCodeClientFactory;
+    resolveHomeDir?: () => string;
     managedProcesses?: ManagedProcessRegistry;
 }
 type OpenCodeClientFactory = (options: {
@@ -118,6 +121,7 @@ export declare class OpenCodeAgentClient implements AgentClient {
     readonly isCreateConfigUnattended: typeof isOpenCodeCreateConfigUnattended;
     private readonly serverManager;
     private readonly createOpenCodeClient;
+    private readonly resolveHomeDir;
     private readonly logger;
     private readonly runtimeSettings?;
     private readonly modelContextWindows;

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

@@ -1,4 +1,5 @@
 import { createOpencodeClient, } from "@opencode-ai/sdk/v2/client";
+import fs from "node:fs/promises";
 import { createPathEquivalenceMatcher } from "../../../utils/path.js";
 import pLimit from "p-limit";
 import { z } from "zod";
@@ -11,6 +12,7 @@ import { execCommand } from "../../../utils/spawn.js";
 import { buildToolCallDisplayModel } from "@getpaseo/protocol/tool-call-display";
 import { mapOpencodeToolCall } from "./opencode/tool-call-mapper.js";
 import { OpenCodeServerManager, } from "./opencode/server-manager.js";
+import { resolveOpenCodeHomeDir } from "./opencode/paths.js";
 import { formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 import { runProviderTurn } from "./provider-runner.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
@@ -847,6 +849,7 @@ export const __openCodeInternals = {
     resolveOpenCodeSelectedModelContextWindow,
     isSelectableOpenCodeAgent,
     mapOpenCodeAgentToMode,
+    resolveOpenCodeHomeDir,
     get OpenCodeAgentSession() {
         return OpenCodeAgentSession;
     },
@@ -867,8 +870,10 @@ export class OpenCodeAgentClient {
             deps.serverManager ??
                 OpenCodeServerManager.getInstance(this.logger, runtimeSettings, {
                     managedProcesses: deps.managedProcesses,
+                    resolveHomeDir: deps.resolveHomeDir,
                 });
         this.createOpenCodeClient = deps.createClient ?? createSdkOpenCodeClient;
+        this.resolveHomeDir = deps.resolveHomeDir ?? resolveOpenCodeHomeDir;
     }
     async createSession(config, launchContext, options) {
         const openCodeConfig = this.assertConfig(config);
@@ -930,9 +935,16 @@ export class OpenCodeAgentClient {
             ? await this.serverManager.acquireNew()
             : await this.serverManager.acquireCurrent();
         const { url } = acquisition.server;
-        const directory = options.cwd;
-        const client = this.createOpenCodeClient({ baseUrl: url, directory });
+        const isGlobalCatalog = options.scope === "global";
         try {
+            // OpenCode treats the catalog directory as a workspace. The global catalog
+            // is not a project, so use the neutral OpenCode home instead of user home.
+            const directory = isGlobalCatalog ? this.resolveHomeDir() : options.cwd;
+            if (isGlobalCatalog) {
+                await fs.mkdir(directory, { recursive: true });
+                this.logger.debug({ directory }, "opencode catalog refresh: using opencode-home for global provider catalog");
+            }
+            const client = this.createOpenCodeClient({ baseUrl: url, directory });
             const [models, modes] = await Promise.all([
                 this.fetchModelsFromClient(client, directory),
                 this.fetchModesFromClient(client, directory),

package/dist/server/server/agent/providers/pi/agent.d.ts

@@ -6,6 +6,7 @@ import type { PiRuntime, PiRuntimeSession } from "./runtime.js";
 import type { PiCommandsRpcType, PiSessionState } from "./rpc-types.js";
 export declare const PiProviderParamsSchema: z.ZodObject<{
     sessionDir: z.ZodOptional<z.ZodString>;
+    extensionTimeoutMs: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
 interface PiRpcAgentClientOptions {
     logger: Logger;
@@ -23,6 +24,7 @@ interface PiRpcAgentSessionOptions {
     initialState: PiSessionState;
     capabilities: AgentCapabilityFlags;
     cleanup?: () => void;
+    extensionTimeoutMs?: number;
 }
 export declare function transformPiModels(models: AgentModelDefinition[]): AgentModelDefinition[];
 export declare class PiRpcAgentSession implements AgentSession {
@@ -50,6 +52,7 @@ export declare class PiRpcAgentSession implements AgentSession {
     private readonly runtimeSession;
     private readonly config;
     private readonly cleanup?;
+    private readonly extensionTimeoutMs;
     get id(): string | null;
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
     startTurn(prompt: AgentPromptInput, _options?: AgentRunOptions): Promise<StartTurnResult>;

package/dist/server/server/agent/providers/pi/agent.js

@@ -22,7 +22,7 @@ const PASEO_PI_TREE_EXTENSION_COMMAND = "paseo_tree";
 const PASEO_PI_CAPTURE_EXTENSION_COMMAND = "paseo_capture_entries";
 const PASEO_PI_ENTRY_CAPTURE_MARKER = "PASEO_ENTRY_CAPTURE";
 const PASEO_PI_COMMAND_RESULT_MARKER = "PASEO_COMMAND_RESULT";
-const PASEO_PI_EXTENSION_RESULT_TIMEOUT_MS = 10000;
+const DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS = 30000;
 const QUESTION_RESPONSE_HEADER = "Response";
 const QUESTION_COMMENT_HEADER = "Comment";
 const PI_ASK_USER_FREEFORM_SENTINEL = "✏️ Type custom response...";
@@ -30,6 +30,7 @@ const COMBINED_ASK_USER_METADATA = "ask_user_select_optional_comment";
 export const PiProviderParamsSchema = z
     .object({
     sessionDir: z.string().min(1).optional(),
+    extensionTimeoutMs: z.number().int().positive().default(DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS),
 })
     .strict();
 const PI_HANDLED_BUILTIN_SLASH_COMMANDS = [
@@ -715,6 +716,7 @@ export class PiRpcAgentSession {
             normalizePiThinkingOption(options.config.thinkingOptionId) ??
                 this.state.thinkingLevel ??
                 null;
+        this.extensionTimeoutMs = options.extensionTimeoutMs ?? DEFAULT_PI_EXTENSION_RESULT_TIMEOUT_MS;
         this.runtimeSession.onEvent((event) => {
             this.handleRuntimeEvent(event);
         });
@@ -1065,7 +1067,7 @@ export class PiRpcAgentSession {
             const timer = setTimeout(() => {
                 this.pendingExtensionResults.delete(requestId);
                 reject(new Error(`Pi extension result timed out for request ${requestId}`));
-            }, PASEO_PI_EXTENSION_RESULT_TIMEOUT_MS);
+            }, this.extensionTimeoutMs);
             this.pendingExtensionResults.set(requestId, { resolve, reject, timer });
         });
     }
@@ -1489,6 +1491,7 @@ export class PiRpcAgentClient {
                 initialState: await runtimeSession.getState(),
                 capabilities: withPiMcpCapability(mcpConfig !== null),
                 cleanup: combineCleanup([mcpConfig?.cleanup, paseoExtension.cleanup]),
+                extensionTimeoutMs: this.providerParams.extensionTimeoutMs,
             });
         }
         catch (error) {
@@ -1531,6 +1534,7 @@ export class PiRpcAgentClient {
                 initialState: await runtimeSession.getState(),
                 capabilities: withPiMcpCapability(mcpConfig !== null),
                 cleanup: combineCleanup([mcpConfig?.cleanup, paseoExtension.cleanup]),
+                extensionTimeoutMs: this.providerParams.extensionTimeoutMs,
             });
         }
         catch (error) {
@@ -1541,7 +1545,9 @@ export class PiRpcAgentClient {
         }
     }
     async fetchCatalog(options) {
-        const runtimeSession = await this.runtime.startSession({ cwd: options.cwd });
+        const runtimeSession = await this.runtime.startSession({
+            cwd: options.scope === "global" ? homedir() : options.cwd,
+        });
         try {
             const models = transformPiModels((await runtimeSession.getAvailableModels(PI_CATALOG_REQUEST_TIMEOUT_MS)).map(mapPiModel));
             return { models, modes: [] };

package/dist/server/server/agent/providers/provider-image-output.js

@@ -44,11 +44,10 @@ export function materializeProviderImage(image) {
     fsSync.writeFileSync(filePath, bytes);
     return { path: filePath };
 }
-// Recognizes the markdown renderProviderImageOutputAsAssistantMarkdown emits for a materialized
-// provider image: its source is a content-hashed file in the attachments dir. Matching the full
-// <hash>.<ext> shape (not just a leading "![") keeps user-authored text from being mistaken for a
-// provider image when it reaches the history-replay filter. The separator class allows one-or-more
-// because on Windows the path uses "\\" and escapeMarkdownImageSource doubles each backslash.
+// Recognizes markdown rendered for a materialized provider image: its source is a content-hashed
+// file in the attachments dir. Matching the full <hash>.<ext> shape (not just a leading "![")
+// keeps user-authored text from being mistaken for a provider image during history replay. The
+// separator still accepts old doubled-backslash Windows history; new Windows output uses file URIs.
 const PROVIDER_IMAGE_MARKDOWN = new RegExp(`^!\\[[^\\]]*\\]\\([^)]*${PROVIDER_IMAGE_ATTACHMENT_DIR}[/\\\\]+[0-9a-f]{64}\\.[a-z0-9]+\\)`);
 export function isProviderImageMarkdown(text) {
     return PROVIDER_IMAGE_MARKDOWN.test(text);
@@ -63,8 +62,14 @@ function isDataImageSource(source) {
 function escapeMarkdownImageAlt(value) {
     return value.replace(/\\/g, "\\\\").replace(/\]/g, "\\]");
 }
+function markdownImageSource(value) {
+    if (/^[A-Za-z]:[\\/]/.test(value)) {
+        return `file:///${value.replace(/\\/g, "/")}`;
+    }
+    return value;
+}
 function escapeMarkdownImageSource(value) {
-    return value.replace(/\\/g, "\\\\").replace(/\)/g, "\\)");
+    return markdownImageSource(value).replace(/\\/g, "\\\\").replace(/\)/g, "\\)");
 }
 export function renderProviderImageOutputAsAssistantMarkdown(image, options = {}) {
     const source = nonEmptyString(image.path) ?? nonEmptyString(image.url);

package/dist/server/server/agent/tools/paseo-tools.d.ts

@@ -6,7 +6,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 ProviderSnapshotManager } from "../provider-snapshot-manager.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";
 import type { PaseoToolCatalog } from "./types.js";

package/dist/server/server/agent/tools/paseo-tools.js

@@ -11,7 +11,6 @@ import { WaitForAgentTracker } from "../wait-for-agent-tracker.js";
 import { createAgentCommand } from "../create-agent/create.js";
 import { expandUserPath, isSameOrDescendantPath, resolvePathFromBase } from "../../path-utils.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 } from "../agent-prompt.js";
 import { respondToAgentPermission } from "../permission-response.js";
@@ -1760,7 +1759,6 @@ export function createPaseoToolCatalog(options) {
         },
     }, async ({ provider }) => {
         const models = await providerSnapshotManager.listModels({
-            cwd: resolveSnapshotCwd(),
             provider,
             wait: true,
         });

package/dist/server/server/bootstrap.d.ts

@@ -44,11 +44,12 @@ export type DaemonLifecycleIntent = {
     type: "shutdown";
     clientId: string;
     requestId: string;
+    reason: string;
 } | {
     type: "restart";
     clientId: string;
     requestId: string;
-    reason?: string;
+    reason: string;
 };
 export interface PaseoDaemonConfig {
     listen: string;
@@ -57,6 +58,7 @@ export interface PaseoDaemonConfig {
     corsAllowedOrigins: string[];
     allowedHosts?: HostnamesConfig;
     hostnames?: HostnamesConfig;
+    trustedProxies?: true | string[];
     mcpEnabled?: boolean;
     mcpInjectIntoAgents?: boolean;
     autoArchiveAfterMerge?: boolean;
@@ -77,6 +79,10 @@ export interface PaseoDaemonConfig {
         publicBaseUrl: string | null;
         standaloneListen: string | null;
     };
+    webUi?: {
+        enabled: boolean;
+        distDir: string | null;
+    };
     appBaseUrl?: string;
     auth?: DaemonAuthConfig;
     openai?: PaseoOpenAIConfig;

package/dist/server/server/bootstrap.js

@@ -113,6 +113,7 @@ import { createManagedProcessRegistry, createSystemManagedProcessTable, } from "
 import { terminateWithTreeKill } from "../utils/tree-kill.js";
 import { isHostnameAllowed } from "./hostnames.js";
 import { createRequireBearerMiddleware, isAgentMcpRequestAuthorized, } from "./auth.js";
+import { createWebUiMiddleware } from "./web-ui.js";
 const MAX_MCP_DEBUG_BATCH_ITEMS = 10;
 const REDACTED_LOG_VALUE = "[redacted]";
 const DOWNLOAD_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NOFOLLOW;
@@ -230,6 +231,17 @@ async function reconcileManagedProcessLedger(managedProcesses, logger) {
         logger.info(reapResult, "Managed helper process ledger reconciled");
     }
 }
+function mountWebUi(app, config, logger) {
+    app.use(createWebUiMiddleware({
+        enabled: config.webUi?.enabled ?? false,
+        distDir: config.webUi?.distDir ?? null,
+        label: getHostname(),
+        logger,
+    }));
+}
+function resolveExpressTrustProxySetting(config) {
+    return config.trustedProxies ?? ["loopback"];
+}
 export async function createPaseoDaemon(config, rootLogger) {
     const logger = rootLogger.child({ module: "bootstrap" });
     const bootstrapStart = performance.now();
@@ -279,6 +291,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     const agentMcpAuthToken = randomUUID();
     const listenTarget = parseListenString(config.listen);
     const app = express();
+    app.set("trust proxy", resolveExpressTrustProxySetting(config));
     let boundListenTarget = null;
     let workspaceRegistry = null;
     const terminalManager = createConfiguredTerminalManager({
@@ -363,6 +376,11 @@ export async function createPaseoDaemon(config, rootLogger) {
     });
     // Local, harmless, and token-gated; deliberately skips daemon auth.
     app.post("/api/terminal-activity", express.json(), createTerminalActivityRouteHandler(terminalManager));
+    // Serve the bundled browser web UI when enabled. Mounted after service-proxy
+    // classification and host/CORS handling, but before daemon bearer auth, so
+    // static app files load without the daemon password while API/WebSocket calls
+    // remain protected.
+    mountWebUi(app, config, logger);
     app.use(createRequireBearerMiddleware(config.auth, (context) => {
         logger.warn(context, "Rejected HTTP request with invalid daemon password");
     }));

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

@@ -1,11 +1,13 @@
 import type { PaseoDaemonConfig } from "./bootstrap.js";
 import { type HostnamesConfig } from "./hostnames.js";
+export declare function resolveBundledWebUiDistDir(moduleUrl?: string | URL): string;
 export type CliConfigOverrides = Partial<{
     listen: string;
     relayEnabled: boolean;
     relayUseTls: boolean;
     mcpEnabled: boolean;
     mcpInjectIntoAgents: boolean;
+    webUiEnabled: boolean;
     hostnames: HostnamesConfig;
 }>;
 export declare function loadConfig(paseoHome: string, options?: {