@getpaseo/server 0.1.96 → 0.1.97-beta.2

package/dist/server/server/auto-archive-on-merge/archive-if-safe.d.ts

@@ -2,31 +2,32 @@ import type { Logger } from "pino";
 import type { AgentManager } from "../agent/agent-manager.js";
 import type { AgentStorage } from "../agent/agent-storage.js";
 import type { DaemonConfigStore } from "../daemon-config-store.js";
-import { archivePaseoWorktree, killTerminalsUnderPath } from "../paseo-worktree-archive-service.js";
-import { isSameOrDescendantPath } from "../path-utils.js";
+import { archiveByScope, type ActiveWorkspaceRef, killTerminalsForWorkspace, resolveWorkspaceIdAtPath } from "../workspace-archive-service.js";
 import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitServiceImpl } from "../workspace-git-service.js";
 import type { GitHubService } from "../../services/github-service.js";
 import type { TerminalManager } from "../../terminal/terminal-manager.js";
 import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
 export interface AutoArchiveArchiveOptions {
     paseoHome: string;
-    worktreesRoot?: string;
+    paseoWorktreesBaseRoot?: string;
     daemonConfigStore: DaemonConfigStore;
     workspaceGitService: WorkspaceGitServiceImpl;
     github: GitHubService;
     agentManager: AgentManager;
     agentStorage: AgentStorage;
     terminalManager: TerminalManager;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
     archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
     markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
     clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
     emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
 }
 export interface ArchiveIfSafeDependencies {
-    archivePaseoWorktree: typeof archivePaseoWorktree;
+    archiveByScope: typeof archiveByScope;
+    resolveWorkspaceIdAtPath: typeof resolveWorkspaceIdAtPath;
     isPaseoOwnedWorktreeCwd: typeof isPaseoOwnedWorktreeCwd;
-    killTerminalsUnderPath: typeof killTerminalsUnderPath;
-    isPathWithinRoot: typeof isSameOrDescendantPath;
+    killTerminalsForWorkspace: typeof killTerminalsForWorkspace;
 }
 export declare function archiveIfSafe(input: {
     cwd: string;

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -1,11 +1,10 @@
-import { archivePaseoWorktree, killTerminalsUnderPath } from "../paseo-worktree-archive-service.js";
-import { isSameOrDescendantPath } from "../path-utils.js";
+import { archiveByScope, killTerminalsForWorkspace, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
 import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
 const defaultDependencies = {
-    archivePaseoWorktree,
+    archiveByScope,
+    resolveWorkspaceIdAtPath,
     isPaseoOwnedWorktreeCwd,
-    killTerminalsUnderPath,
-    isPathWithinRoot: isSameOrDescendantPath,
+    killTerminalsForWorkspace,
 };
 export async function archiveIfSafe(input) {
     const { cwd, pullRequest, inFlight, options, log } = input;
@@ -42,36 +41,42 @@ export async function archiveIfSafe(input) {
         }
         const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, {
             paseoHome: options.paseoHome,
-            worktreesRoot: options.worktreesRoot,
+            worktreesRoot: options.paseoWorktreesBaseRoot,
         });
         if (!ownership.allowed) {
             return;
         }
         try {
-            await deps.archivePaseoWorktree({
+            const workspaceId = await deps.resolveWorkspaceIdAtPath({
+                findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+                listActiveWorkspaces: options.listActiveWorkspaces,
+            }, cwd);
+            if (!workspaceId) {
+                log.warn({ cwd }, "Auto-archive could not resolve a workspace for cwd; skipping");
+                return;
+            }
+            await deps.archiveByScope({
                 paseoHome: options.paseoHome,
-                worktreesRoot: options.worktreesRoot,
+                paseoWorktreesBaseRoot: options.paseoWorktreesBaseRoot,
                 github: options.github,
                 workspaceGitService: options.workspaceGitService,
                 agentManager: options.agentManager,
                 agentStorage: options.agentStorage,
+                findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+                listActiveWorkspaces: options.listActiveWorkspaces,
                 archiveWorkspaceRecord: options.archiveWorkspaceRecord,
                 emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
                 markWorkspaceArchiving: options.markWorkspaceArchiving,
                 clearWorkspaceArchiving: options.clearWorkspaceArchiving,
-                isPathWithinRoot: deps.isPathWithinRoot,
-                killTerminalsUnderPath: (rootPath) => deps.killTerminalsUnderPath({
+                killTerminalsForWorkspace: (workspaceIdToKill) => deps.killTerminalsForWorkspace({
                     terminalManager: options.terminalManager,
-                    isPathWithinRoot: deps.isPathWithinRoot,
-                    killTrackedTerminal: () => { },
                     sessionLogger: log,
-                }, rootPath),
+                }, workspaceIdToKill),
                 sessionLogger: log,
             }, {
-                targetPath: cwd,
+                scope: { kind: "workspace", workspaceId },
                 repoRoot: ownership.repoRoot ?? null,
-                worktreesRoot: ownership.worktreeRoot,
-                worktreesBaseRoot: options.worktreesRoot,
+                paseoWorktreesBaseRoot: options.paseoWorktreesBaseRoot,
                 requestId: "auto-archive-on-merge",
             });
             log.info({ cwd }, "Auto-archived worktree after PR merge");

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

@@ -1,3 +1,4 @@
+import express from "express";
 import type { Logger } from "pino";
 export type ListenTarget = {
     type: "tcp";
@@ -26,6 +27,7 @@ import { type ServiceProxySubsystem } from "./service-proxy.js";
 import { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
 import { type HostnamesConfig } from "./hostnames.js";
 import { type DaemonAuthConfig } from "./auth.js";
+export declare function createTerminalActivityRouteHandler(terminalManager: TerminalManager): express.RequestHandler;
 export type PaseoOpenAIConfig = OpenAiSpeechProviderConfig;
 export type PaseoLocalSpeechConfig = LocalSpeechProviderConfig;
 export interface PaseoSpeechSttLanguages {
@@ -57,6 +59,7 @@ export interface PaseoDaemonConfig {
     mcpEnabled?: boolean;
     mcpInjectIntoAgents?: boolean;
     autoArchiveAfterMerge?: boolean;
+    enableTerminalAgentHooks?: boolean;
     appendSystemPrompt?: string;
     terminalProfiles?: TerminalProfile[];
     staticDir: string;

package/dist/server/server/bootstrap.js

@@ -6,7 +6,7 @@ import { randomUUID } from "node:crypto";
 import { hostname as getHostname } from "node:os";
 import path from "node:path";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
 import { createBranchChangeRouteHandler } from "./script-route-branch-handler.js";
 function resolveBoundListenTarget(listenTarget, httpServer) {
     if (listenTarget.type !== "tcp") {
@@ -72,7 +72,7 @@ function formatListenTarget(listenTarget) {
 }
 import { VoiceAssistantWebSocketServer } from "./websocket-server.js";
 import { createGitHubService } from "../services/github-service.js";
-import { createPaseoWorktree as createRegisteredPaseoWorktree } from "./paseo-worktree-service.js";
+import { createPaseoWorktree as createRegisteredPaseoWorktree, createLocalCheckoutWorkspace, } from "./paseo-worktree-service.js";
 import { createPaseoWorktreeWorkflow } from "./worktree-session.js";
 import { DownloadTokenStore } from "./file-download/token-store.js";
 import { createSpeechService } from "./speech/speech-runtime.js";
@@ -90,10 +90,12 @@ import { LoopService } from "./loop-service.js";
 import { ScheduleService } from "./schedule/service.js";
 import { DaemonConfigStore } from "./daemon-config-store.js";
 import { WorkspaceGitServiceImpl } from "./workspace-git-service.js";
-import { archivePersistedWorkspaceRecord } from "./workspace-archive-service.js";
+import { resolveWorkspaceIdForPath } from "./resolve-workspace-id-for-path.js";
+import { archivePersistedWorkspaceRecord, } from "./workspace-archive-service.js";
 import { setupAutoArchiveOnMerge } from "./auto-archive-on-merge/index.js";
 import { wrapSessionMessage } from "./messages.js";
 import { createConfiguredTerminalManager } from "../terminal/terminal-manager-factory.js";
+import { applyTerminalAgentHookSetting } from "../terminal/agent-hooks/terminal-agent-hook-setting.js";
 import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
 import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
 import { startRelayTransport } from "./relay-transport.js";
@@ -127,6 +129,56 @@ function createAgentMcpBaseUrl(listenTarget) {
     const host = resolveAgentMcpClientHost(listenTarget.host);
     return new URL("/mcp/agents", `http://${formatHostForHttpUrl(host)}:${listenTarget.port}`).toString();
 }
+function createTerminalActivityUrl(listenTarget) {
+    if (!listenTarget || listenTarget.type !== "tcp") {
+        return null;
+    }
+    const host = resolveAgentMcpClientHost(listenTarget.host);
+    return new URL("/api/terminal-activity", `http://${formatHostForHttpUrl(host)}:${listenTarget.port}`).toString();
+}
+const TerminalActivityReportSchema = z.object({
+    terminalId: z.string().min(1),
+    token: z.string().min(1),
+    state: z.enum(["running", "idle", "needs-input"]),
+});
+const TERMINAL_ACTIVITY_STATE_MAP = {
+    running: "working",
+    idle: "idle",
+    "needs-input": "attention",
+};
+const LOOPBACK_REMOTE_ADDRESSES = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
+function isLoopbackRemoteAddress(remoteAddress) {
+    return remoteAddress !== undefined && LOOPBACK_REMOTE_ADDRESSES.has(remoteAddress);
+}
+export function createTerminalActivityRouteHandler(terminalManager) {
+    return async (req, res) => {
+        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        const parsed = TerminalActivityReportSchema.safeParse(req.body);
+        if (!parsed.success) {
+            res.status(400).json({ error: "Invalid terminal activity report" });
+            return;
+        }
+        const validation = terminalManager.validateTerminalActivityToken(parsed.data.terminalId, parsed.data.token);
+        if (validation !== "valid") {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        try {
+            const updated = await terminalManager.setTerminalActivity(parsed.data.terminalId, TERMINAL_ACTIVITY_STATE_MAP[parsed.data.state]);
+            if (!updated) {
+                res.status(403).json({ error: "Forbidden" });
+                return;
+            }
+            res.status(204).end();
+        }
+        catch {
+            res.status(500).json({ error: "Failed to update terminal activity" });
+        }
+    };
+}
 function summarizeAgentMcpDebugMessage(body) {
     if (!body || typeof body !== "object" || Array.isArray(body)) {
         return {
@@ -173,6 +225,7 @@ export async function createPaseoDaemon(config, rootLogger) {
             providers: config.metadataGeneration?.providers ?? [],
         },
         autoArchiveAfterMerge: config.autoArchiveAfterMerge ?? false,
+        enableTerminalAgentHooks: config.enableTerminalAgentHooks ?? false,
         appendSystemPrompt: config.appendSystemPrompt ?? "",
         ...(config.terminalProfiles !== undefined
             ? { terminalProfiles: config.terminalProfiles }
@@ -198,6 +251,10 @@ export async function createPaseoDaemon(config, rootLogger) {
     const app = express();
     let boundListenTarget = null;
     let workspaceRegistry = null;
+    const terminalManager = createConfiguredTerminalManager({
+        getTerminalActivityUrl: () => createTerminalActivityUrl(boundListenTarget),
+    });
+    applyTerminalAgentHookSetting({ store: daemonConfigStore, logger });
     const serviceProxyPublicBaseUrl = config.serviceProxy?.publicBaseUrl
         ? config.serviceProxy.publicBaseUrl
         : null;
@@ -274,13 +331,14 @@ export async function createPaseoDaemon(config, rootLogger) {
         }
         next();
     });
+    // Local, harmless, and token-gated; deliberately skips daemon auth.
+    app.post("/api/terminal-activity", express.json(), createTerminalActivityRouteHandler(terminalManager));
     app.use(createRequireBearerMiddleware(config.auth, (context) => {
         logger.warn(context, "Rejected HTTP request with invalid daemon password");
     }));
+    app.use(express.json());
     // Serve static files from public directory
     app.use("/public", express.static(staticDir));
-    // Middleware
-    app.use(express.json());
     // Health check endpoint
     app.get("/api/health", (_req, res) => {
         res.json({ status: "ok", timestamp: new Date().toISOString() });
@@ -361,7 +419,6 @@ export async function createPaseoDaemon(config, rootLogger) {
         paseoHome: config.paseoHome,
         logger,
     });
-    const terminalManager = createConfiguredTerminalManager();
     const github = createGitHubService();
     const workspaceGitService = new WorkspaceGitServiceImpl({
         logger,
@@ -468,9 +525,27 @@ export async function createPaseoDaemon(config, rootLogger) {
         await archivePersistedWorkspaceRecord({
             workspaceId,
             workspaceRegistry,
-            projectRegistry,
         });
     };
+    // external path→workspace adapter, not ownership: archive-by-path requests that
+    // arrive with a worktree path and no workspaceId (old clients / CLI).
+    const findWorkspaceIdForCwdExternal = async (cwd) => {
+        return resolveWorkspaceIdForPath(cwd, await workspaceRegistry.list());
+    };
+    const ensureWorkspaceForCreateExternal = async (cwd) => {
+        const workspace = await createLocalCheckoutWorkspace({ cwd }, { projectRegistry, workspaceRegistry, workspaceGitService });
+        return workspace.workspaceId;
+    };
+    const listActiveWorkspacesExternal = async () => {
+        const workspaces = await workspaceRegistry.list();
+        return workspaces
+            .filter((workspace) => !workspace.archivedAt)
+            .map((workspace) => ({
+            workspaceId: workspace.workspaceId,
+            cwd: workspace.cwd,
+            kind: workspace.kind,
+        }));
+    };
     const markWorkspaceArchivingExternal = (workspaceIds, archivingAt) => {
         const workspaceIdList = Array.from(workspaceIds);
         for (const session of wsServer?.listActiveSessions() ?? []) {
@@ -492,7 +567,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     };
     setupAutoArchiveOnMerge({
         paseoHome: config.paseoHome,
-        worktreesRoot: config.worktreesRoot,
+        paseoWorktreesBaseRoot: config.worktreesRoot,
         daemonConfigStore,
         workspaceGitService,
         github,
@@ -500,6 +575,8 @@ export async function createPaseoDaemon(config, rootLogger) {
         agentStorage,
         terminalManager,
         logger,
+        findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+        listActiveWorkspaces: listActiveWorkspacesExternal,
         archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
         markWorkspaceArchiving: markWorkspaceArchivingExternal,
         clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
@@ -509,8 +586,7 @@ export async function createPaseoDaemon(config, rootLogger) {
     let agentMcpBaseUrl = null;
     if (mcpEnabled) {
         const agentMcpRoute = "/mcp/agents";
-        const agentMcpTransports = new Map();
-        const createAgentMcpTransport = async (callerAgentId) => {
+        const createAgentMcpSession = async (callerAgentId) => {
             const agentMcpServer = await createAgentMcpServer({
                 agentManager,
                 agentStorage,
@@ -520,10 +596,13 @@ export async function createPaseoDaemon(config, rootLogger) {
                 providerSnapshotManager,
                 github,
                 workspaceGitService,
+                findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
+                listActiveWorkspaces: listActiveWorkspacesExternal,
                 archiveWorkspaceRecord: archiveWorkspaceRecordExternal,
                 emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
                 markWorkspaceArchiving: markWorkspaceArchivingExternal,
                 clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
+                ensureWorkspaceForCreate: ensureWorkspaceForCreateExternal,
                 createPaseoWorktree: async (input, serviceOptions) => {
                     return createPaseoWorktreeWorkflow({
                         paseoHome: config.paseoHome,
@@ -546,11 +625,8 @@ export async function createPaseoDaemon(config, rootLogger) {
                                 ?.listActiveSessions()
                                 .map((session) => session.warmWorkspaceGitDataForWorkspace(workspace)) ?? []);
                         },
-                        emitWorkspaceUpdateForCwd: async (cwd, emitOptions) => {
-                            await Promise.all(wsServer
-                                ?.listActiveSessions()
-                                .map((session) => session.emitWorkspaceUpdatesForExternalCwds([cwd])) ?? []);
-                            void emitOptions;
+                        emitWorkspaceUpdateForWorkspaceId: async (workspaceId) => {
+                            await emitWorkspaceUpdatesExternal([workspaceId]);
                         },
                         cacheWorkspaceSetupSnapshot: () => { },
                         emit: emitExternalSessionMessage,
@@ -573,32 +649,24 @@ export async function createPaseoDaemon(config, rootLogger) {
                 resolveCallerContext: (agentId) => wsServer?.resolveVoiceCallerContext(agentId) ?? null,
                 logger,
             });
+            // Stateless mode: each HTTP request builds a fresh server + transport that is
+            // torn down when the response closes, so no per-session state is retained between
+            // requests. The agent control plane only lists and calls tools, neither of which
+            // needs cross-request state, so sessions would only pin memory for the life of the
+            // daemon (agents that exit without a clean DELETE never get reaped).
             const transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: () => randomUUID(),
-                onsessioninitialized: (sessionId) => {
-                    agentMcpTransports.set(sessionId, transport);
-                    logger.debug({ sessionId }, "Agent MCP session initialized");
-                },
-                onsessionclosed: (sessionId) => {
-                    agentMcpTransports.delete(sessionId);
-                    logger.debug({ sessionId }, "Agent MCP session closed");
-                },
+                sessionIdGenerator: undefined,
                 // NOTE: We enforce a Vite-like host allowlist at the app/websocket layer.
                 // StreamableHTTPServerTransport's built-in check requires exact Host header matches.
                 enableDnsRebindingProtection: false,
             });
             Object.assign(transport, {
-                onclose: () => {
-                    if (transport.sessionId) {
-                        agentMcpTransports.delete(transport.sessionId);
-                    }
-                },
                 onerror: (err) => {
                     logger.error({ err }, "Agent MCP transport error");
                 },
             });
             await agentMcpServer.connect(transport);
-            return transport;
+            return { server: agentMcpServer, transport };
         };
         const runAgentMcpRequest = async (req, res) => {
             // This route is exempt from the global daemon-password middleware, so it
@@ -623,41 +691,33 @@ export async function createPaseoDaemon(config, rootLogger) {
                 }, "Agent MCP request");
             }
             try {
-                const sessionId = req.header("mcp-session-id");
-                let transport = sessionId ? agentMcpTransports.get(sessionId) : undefined;
-                if (!transport) {
-                    if (req.method !== "POST") {
-                        res.status(400).json({
-                            jsonrpc: "2.0",
-                            error: {
-                                code: -32000,
-                                message: "Missing or invalid MCP session",
-                            },
-                            id: null,
-                        });
-                        return;
-                    }
-                    if (!isInitializeRequest(req.body)) {
-                        res.status(400).json({
-                            jsonrpc: "2.0",
-                            error: {
-                                code: -32000,
-                                message: "Initialization request expected",
-                            },
-                            id: null,
-                        });
-                        return;
-                    }
-                    const callerAgentIdRaw = req.query.callerAgentId;
-                    let callerAgentId;
-                    if (typeof callerAgentIdRaw === "string") {
-                        callerAgentId = callerAgentIdRaw;
-                    }
-                    else if (Array.isArray(callerAgentIdRaw) && typeof callerAgentIdRaw[0] === "string") {
-                        callerAgentId = callerAgentIdRaw[0];
-                    }
-                    transport = await createAgentMcpTransport(callerAgentId);
+                // Stateless: GET (standalone SSE) and DELETE (session termination) have no
+                // meaning without sessions. The MCP client tolerates 405 on the GET stream
+                // and never issues a DELETE because it is never handed a session id.
+                if (req.method !== "POST") {
+                    res.status(405).json({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: -32000,
+                            message: "Method not allowed",
+                        },
+                        id: null,
+                    });
+                    return;
                 }
+                const callerAgentIdRaw = req.query.callerAgentId;
+                let callerAgentId;
+                if (typeof callerAgentIdRaw === "string") {
+                    callerAgentId = callerAgentIdRaw;
+                }
+                else if (Array.isArray(callerAgentIdRaw) && typeof callerAgentIdRaw[0] === "string") {
+                    callerAgentId = callerAgentIdRaw[0];
+                }
+                const { server, transport } = await createAgentMcpSession(callerAgentId);
+                res.on("close", () => {
+                    void transport.close();
+                    void server.close();
+                });
                 await transport.handleRequest(req, res, req.body);
             }
             catch (err) {
@@ -762,6 +822,7 @@ export async function createPaseoDaemon(config, rootLogger) {
                         }, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, serviceProxy, scriptRuntimeStore, handleBranchChange, () => (boundListenTarget?.type === "tcp" ? boundListenTarget.port : null), () => (boundListenTarget?.type === "tcp" ? boundListenTarget.host : null), (hostname) => scriptHealthMonitor.getHealthForHostname(hostname), workspaceGitService, github, config.pushNotificationSender, providerSnapshotManager, {
                             listen: formatListenTarget(boundListenTarget ?? listenTarget),
                             worktreesRoot: config.worktreesRoot,
+                            appBaseUrl: config.appBaseUrl,
                             relay: {
                                 enabled: relayEnabled,
                                 endpoint: relayEndpoint,

package/dist/server/server/config.js

@@ -229,6 +229,7 @@ export function loadConfig(paseoHome, options) {
         mcpEnabled,
         mcpInjectIntoAgents,
         autoArchiveAfterMerge,
+        enableTerminalAgentHooks: persisted.daemon?.enableTerminalAgentHooks ?? false,
         appendSystemPrompt,
         terminalProfiles,
         mcpDebug: env.MCP_DEBUG === "1",

package/dist/server/server/daemon-config-store.js

@@ -146,6 +146,7 @@ function mergeMutableConfigIntoPersistedConfig(params) {
                 injectIntoAgents: mutable.mcp.injectIntoAgents,
             },
             autoArchiveAfterMerge: mutable.autoArchiveAfterMerge,
+            enableTerminalAgentHooks: mutable.enableTerminalAgentHooks,
             appendSystemPrompt: mutable.appendSystemPrompt,
             ...(mutable.terminalProfiles !== undefined
                 ? { terminalProfiles: mutable.terminalProfiles }

package/dist/server/server/exports.d.ts

@@ -14,7 +14,7 @@ export { DirectTcpHostConnectionSchema, type DirectTcpHostConnection, type Norma
 export { ensureLocalSpeechModels, listLocalSpeechModels, type LocalSpeechModelId, type LocalSttModelId, type LocalTtsModelId, } from "./speech/providers/local/models.js";
 export { applySherpaLoaderEnv, resolveSherpaLoaderEnv, sherpaLoaderEnvKey, sherpaPlatformArch, sherpaPlatformPackageName, type SherpaLoaderEnvKey, type SherpaLoaderEnvResolution, } from "./speech/providers/local/sherpa/sherpa-runtime-env.js";
 export { type ProviderOverride, type ProviderProfileModel, } from "./agent/provider-launch-config.js";
-export { findExecutable } from "../utils/executable.js";
+export { findExecutable } from "../executable-resolution/executable-resolution.js";
 export { execCommand, spawnProcess } from "../utils/spawn.js";
 export { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, type AgentProviderDefinition, } from "@getpaseo/protocol/provider-manifest";
 export type { AgentMode, AgentUsage, AgentCapabilityFlags, AgentPermissionRequest, AgentTimelineItem, ProviderSnapshotEntry, } from "./agent/agent-sdk-types.js";

package/dist/server/server/exports.js

@@ -14,7 +14,7 @@ export { PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
 export { DirectTcpHostConnectionSchema, } from "@getpaseo/protocol/host-connection-schema";
 export { ensureLocalSpeechModels, listLocalSpeechModels, } from "./speech/providers/local/models.js";
 export { applySherpaLoaderEnv, resolveSherpaLoaderEnv, sherpaLoaderEnvKey, sherpaPlatformArch, sherpaPlatformPackageName, } from "./speech/providers/local/sherpa/sherpa-runtime-env.js";
-export { findExecutable } from "../utils/executable.js";
+export { findExecutable } from "../executable-resolution/executable-resolution.js";
 export { execCommand, spawnProcess } from "../utils/spawn.js";
 // Provider manifest (source of truth for provider definitions)
 export { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, } from "@getpaseo/protocol/provider-manifest";