@getpaseo/server 0.1.88 → 0.1.90

package/dist/server/server/session.js

@@ -1,13 +1,11 @@
 import equal from "fast-deep-equal";
 import { v4 as uuidv4 } from "uuid";
-import { TTLCache } from "@isaacs/ttlcache";
-import pMemoize from "p-memoize";
 import { realpathSync } from "node:fs";
 import { basename, resolve, sep } from "path";
 import { homedir } from "node:os";
 import { z } from "zod";
 import { CLIENT_CAPS } from "@getpaseo/protocol/client-capabilities";
-import { isLegacyEditorTargetId, serializeAgentStreamEvent, } from "./messages.js";
+import { serializeAgentStreamEvent, } from "./messages.js";
 import { TerminalSessionController } from "../terminal/terminal-session-controller.js";
 import { encodeFileTransferFrame, FileTransferOpcode, } from "@getpaseo/protocol/binary-frames/index";
 import { CursorError } from "./pagination/cursor.js";
@@ -16,7 +14,6 @@ import { TTSManager } from "./agent/tts-manager.js";
 import { STTManager } from "./agent/stt-manager.js";
 import { maybePersistTtsDebugAudio } from "./agent/tts-debug.js";
 import { isPaseoDictationDebugEnabled } from "./agent/recordings-debug.js";
-import { listAvailableEditorTargets, openInEditorTarget } from "./editor-targets.js";
 import { getPidLockInfo } from "./pid-lock.js";
 import { generateLocalPairingOffer } from "./pairing-offer.js";
 import { DictationStreamManager, } from "./dictation/dictation-stream-manager.js";
@@ -65,6 +62,7 @@ import { notifyChatMentions, prepareChatMentionFanout } from "./chat/chat-mentio
 import { execCommand } from "../utils/spawn.js";
 import { assertPullRequestAutoMergeDisableReady, assertPullRequestAutoMergeEnableReady, createGitHubService, } from "../services/github-service.js";
 import { summarizeFetchWorkspacesEntries, WorkspaceDirectory, } from "./workspace-directory.js";
+import { shouldEmitPendingBootstrapUpdate } from "./workspace-bootstrap-dedupe.js";
 import { attemptFirstAgentBranchAutoName, createPaseoWorktree, } from "./paseo-worktree-service.js";
 import { generateBranchNameFromFirstAgentContext } from "./worktree-branch-name-generator.js";
 import { assertSafeGitRef as assertWorktreeSafeGitRef, buildAgentSessionConfig as buildWorktreeAgentSessionConfig, createPaseoWorktreeWorkflow as createWorktreeWorkflow, handleCreatePaseoWorktreeRequest as handleCreateWorktreeRequest, handlePaseoWorktreeArchiveRequest as handleWorktreeArchiveRequest, handlePaseoWorktreeListRequest as handleWorktreeListRequest, handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage, } from "./worktree-session.js";
@@ -114,7 +112,6 @@ const LEGACY_MODE_ICONS = new Set([
     "ShieldQuestionMark",
 ]);
 const MIN_VERSION_ALL_PROVIDERS = "0.1.45";
-const MIN_VERSION_FLEXIBLE_EDITOR_IDS = "0.1.50";
 function errorToFriendlyMessage(error) {
     if (error instanceof Error)
         return error.message;
@@ -190,9 +187,6 @@ function isAppVersionAtLeast(appVersion, minVersion) {
 function clientSupportsAllProviders(appVersion) {
     return isAppVersionAtLeast(appVersion, MIN_VERSION_ALL_PROVIDERS);
 }
-function clientSupportsFlexibleEditorIds(appVersion) {
-    return isAppVersionAtLeast(appVersion, MIN_VERSION_FLEXIBLE_EDITOR_IDS);
-}
 function beginAgentDeleteIfSupported(agentStorage, agentId) {
     if ("beginDelete" in agentStorage && typeof agentStorage.beginDelete === "function") {
         agentStorage.beginDelete(agentId);
@@ -220,8 +214,6 @@ const PCM_BYTES_PER_MS = (PCM_SAMPLE_RATE * PCM_CHANNELS * (PCM_BITS_PER_SAMPLE
 const MIN_STREAMING_SEGMENT_DURATION_MS = 1000;
 const MIN_STREAMING_SEGMENT_BYTES = Math.round(PCM_BYTES_PER_MS * MIN_STREAMING_SEGMENT_DURATION_MS);
 const AgentIdSchema = z.string().uuid();
-const AVAILABLE_EDITOR_TARGETS_CACHE_TTL_MS = 60000;
-const AVAILABLE_EDITOR_TARGETS_CACHE_KEY = "available";
 class VoiceFeatureUnavailableError extends Error {
     constructor(context) {
         super(context.message);
@@ -296,15 +288,6 @@ export class Session {
         this.unsubscribeProviderSnapshotEvents = null;
         this.inflightRequests = 0;
         this.peakInflightRequests = 0;
-        this.availableEditorTargetsCache = new TTLCache({
-            ttl: AVAILABLE_EDITOR_TARGETS_CACHE_TTL_MS,
-            max: 1,
-            checkAgeOnGet: true,
-        });
-        this.getMemoizedAvailableEditorTargets = pMemoize(async () => this.resolveAvailableEditorTargets(), {
-            cache: this.availableEditorTargetsCache,
-            cacheKey: () => AVAILABLE_EDITOR_TARGETS_CACHE_KEY,
-        });
         this.checkoutDiffSubscriptions = new Map();
         this.workspaceGitWatchTargets = new Map();
         this.workspaceGitFetchSubscriptions = new Map();
@@ -334,7 +317,7 @@ export class Session {
                 }
             },
         });
-        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, scriptRouteStore, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, voice, voiceBridge, dictation, serverId, daemonVersion, daemonRuntimeConfig, } = options;
+        const { clientId, appVersion, clientCapabilities, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, worktreesRoot, agentManager, agentStorage, projectRegistry, workspaceRegistry, chatService, scheduleService, loopService, checkoutDiffManager, github, workspaceGitService, daemonConfigStore, mcpBaseUrl, stt, sttLanguage, tts, terminalManager, providerSnapshotManager, serviceProxy, scriptRuntimeStore, workspaceSetupSnapshots, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, serviceProxyPublicBaseUrl, resolveScriptHealth, voice, voiceBridge, dictation, serverId, daemonVersion, daemonRuntimeConfig, } = options;
         this.clientId = clientId;
         this.appVersion = appVersion ?? null;
         this.clientCapabilities = parseClientCapabilities(clientCapabilities);
@@ -345,6 +328,7 @@ export class Session {
         this.downloadTokenStore = downloadTokenStore;
         this.pushTokenStore = pushTokenStore;
         this.paseoHome = paseoHome;
+        this.worktreesRoot = worktreesRoot;
         this.sessionLogger = logger.child({
             module: "session",
             clientId: this.clientId,
@@ -374,6 +358,7 @@ export class Session {
         });
         this.createAgentLifecycleDispatch = new CreateAgentLifecycleDispatch({
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
             agentManager: this.agentManager,
             agentStorage: this.agentStorage,
             github: this.github,
@@ -398,12 +383,13 @@ export class Session {
             logger: this.sessionLogger,
         });
         this.providerSnapshotManager = providerSnapshotManager;
-        this.scriptRouteStore = scriptRouteStore ?? null;
+        this.serviceProxy = serviceProxy ?? null;
         this.scriptRuntimeStore = scriptRuntimeStore ?? null;
         this.workspaceSetupSnapshots = workspaceSetupSnapshots ?? new Map();
         this.onBranchChanged = onBranchChanged;
         this.getDaemonTcpPort = getDaemonTcpPort ?? null;
         this.getDaemonTcpHost = getDaemonTcpHost ?? null;
+        this.serviceProxyPublicBaseUrl = serviceProxyPublicBaseUrl ?? null;
         this.resolveScriptHealth = resolveScriptHealth ?? null;
         this.sttLanguage = sttLanguage ?? "en";
         this.subscribeToOptionalManagers();
@@ -761,12 +747,6 @@ export class Session {
         }
         return LEGACY_PROVIDER_IDS.has(provider);
     }
-    filterEditorsForClient(editors) {
-        if (clientSupportsFlexibleEditorIds(this.appVersion)) {
-            return editors;
-        }
-        return editors.filter((editor) => isLegacyEditorTargetId(editor.id));
-    }
     agentThinkingOptionMatchesFilter(agent, filter) {
         if (filter.thinkingOptionId === undefined) {
             return true;
@@ -1325,14 +1305,17 @@ export class Session {
                 return this.handleCreatePaseoWorktreeRequest(msg);
             case "workspace_setup_status_request":
                 return this.handleWorkspaceSetupStatusRequest(msg);
+            // COMPAT(desktopEditorBridge): added in v0.1.88, remove after 2026-12-03 once old clients no longer call daemon editor RPCs.
             case "list_available_editors_request":
-                return this.handleListAvailableEditorsRequest(msg);
+                return this.handleLegacyListAvailableEditorsRequest(msg);
             case "open_in_editor_request":
-                return this.handleOpenInEditorRequest(msg);
+                return this.handleLegacyOpenInEditorRequest(msg);
             case "open_project_request":
                 return this.handleOpenProjectRequest(msg);
             case "archive_workspace_request":
                 return this.handleArchiveWorkspaceRequest(msg);
+            case "workspace.clear_attention.request":
+                return this.handleWorkspaceClearAttentionRequest(msg);
             case "file_explorer_request":
                 return this.handleFileExplorerRequest(msg);
             case "project_icon_request":
@@ -2094,6 +2077,7 @@ export class Session {
                 agentStorage: this.agentStorage,
                 logger: this.sessionLogger,
                 paseoHome: this.paseoHome,
+                worktreesRoot: this.worktreesRoot,
                 workspaceGitService: this.workspaceGitService,
                 providerSnapshotManager: this.providerSnapshotManager,
                 daemonConfig: this.readStructuredGenerationDaemonConfig(),
@@ -2428,6 +2412,7 @@ export class Session {
     async buildAgentSessionConfig(config, gitOptions, legacyWorktreeName, firstAgentContext) {
         return buildWorktreeAgentSessionConfig({
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
             sessionLogger: this.sessionLogger,
             workspaceGitService: this.workspaceGitService,
             createPaseoWorktree: (input, serviceOptions) => this.createPaseoWorktreeWorkflow(input, {
@@ -3873,7 +3858,7 @@ export class Session {
             const mutatedCwd = await mergeToBase(cwd, {
                 baseRef,
                 mode: msg.strategy === "squash" ? "squash" : "merge",
-            }, { paseoHome: this.paseoHome });
+            }, { paseoHome: this.paseoHome, worktreesRoot: this.worktreesRoot });
             await Promise.all([
                 this.notifyGitMutation(mutatedCwd, "merge-to-base", { invalidateGithub: true }),
                 ...(mutatedCwd !== cwd ? [this.notifyGitMutation(cwd, "merge-to-base")] : []),
@@ -4293,6 +4278,7 @@ export class Session {
     async handlePaseoWorktreeArchiveRequest(msg) {
         return handleWorktreeArchiveRequest({
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
             github: this.github,
             workspaceGitService: this.workspaceGitService,
             agentManager: this.agentManager,
@@ -4526,7 +4512,7 @@ export class Session {
         // Filter by labels if filter provided
         if (filter?.labels) {
             const filterLabels = filter.labels;
-            agents = agents.filter((agent) => Object.entries(filterLabels).every(([key, value]) => agent.labels[key] === value));
+            agents = agents.filter((agent) => Object.entries(filterLabels).every(([key, _value]) => agent.labels[key] === filterLabels[key]));
         }
         return agents;
     }
@@ -4728,16 +4714,18 @@ export class Session {
             name: workspace.displayName,
             archivingAt: null,
             status: "done",
+            statusEnteredAt: null,
             activityAt: null,
             diffStat,
-            scripts: this.scriptRouteStore && this.scriptRuntimeStore
+            scripts: this.serviceProxy && this.scriptRuntimeStore
                 ? buildWorkspaceScriptPayloads({
                     workspaceId: workspace.workspaceId,
                     workspaceDirectory: workspace.cwd,
                     paseoConfig: readPaseoConfigForProjection(workspace.cwd, this.sessionLogger),
-                    routeStore: this.scriptRouteStore,
+                    serviceProxy: this.serviceProxy,
                     runtimeStore: this.scriptRuntimeStore,
                     daemonPort: this.getDaemonTcpPort?.() ?? null,
+                    serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
                     gitMetadata: this.resolveWorkspaceScriptGitMetadata(workspace.cwd),
                     resolveHealth: this.resolveScriptHealth ?? undefined,
                 })
@@ -4802,6 +4790,7 @@ export class Session {
             name: result.worktree.branchName || result.workspace.displayName,
             archivingAt: null,
             status: "done",
+            statusEnteredAt: null,
             activityAt: null,
             diffStat: { additions: 0, deletions: 0 },
             scripts: [],
@@ -4872,15 +4861,26 @@ export class Session {
         subscription.pendingUpdatesByWorkspaceId.clear();
         for (const payload of pending) {
             if (payload.kind === "upsert") {
-                const snapshotLatestActivity = options?.snapshotLatestActivityByWorkspaceId?.get(payload.workspace.id);
-                if (typeof snapshotLatestActivity === "number") {
-                    const updateLatestActivity = payload.workspace.activityAt
-                        ? Date.parse(payload.workspace.activityAt)
-                        : Number.NEGATIVE_INFINITY;
-                    if (!Number.isNaN(updateLatestActivity) &&
-                        updateLatestActivity <= snapshotLatestActivity) {
-                        continue;
-                    }
+                const snapshot = options?.snapshotByWorkspaceId?.get(payload.workspace.id);
+                const updateActivityAtMs = payload.workspace.activityAt
+                    ? Date.parse(payload.workspace.activityAt)
+                    : null;
+                const shouldEmit = shouldEmitPendingBootstrapUpdate({
+                    snapshot: snapshot
+                        ? {
+                            status: snapshot.status,
+                            statusEnteredAt: snapshot.statusEnteredAt,
+                            activityAtMs: snapshot.activityAtMs,
+                        }
+                        : null,
+                    update: {
+                        status: payload.workspace.status,
+                        statusEnteredAt: payload.workspace.statusEnteredAt ?? null,
+                        activityAtMs: Number.isNaN(updateActivityAtMs) ? null : updateActivityAtMs,
+                    },
+                });
+                if (!shouldEmit) {
+                    continue;
                 }
             }
             this.emit({
@@ -5310,15 +5310,7 @@ export class Session {
                 pageInfo: payload.pageInfo,
                 payload: summarizeFetchWorkspacesEntries(payload.entries),
             }, "fetch_workspaces_response_ready");
-            const snapshotLatestActivityByWorkspaceId = new Map();
-            for (const entry of payload.entries) {
-                const parsedLatestActivity = entry.activityAt
-                    ? Date.parse(entry.activityAt)
-                    : Number.NEGATIVE_INFINITY;
-                if (!Number.isNaN(parsedLatestActivity)) {
-                    snapshotLatestActivityByWorkspaceId.set(entry.id, parsedLatestActivity);
-                }
-            }
+            const snapshot = this.buildBootstrapSnapshot(payload.entries);
             this.emit({
                 type: "fetch_workspaces_response",
                 payload: {
@@ -5328,7 +5320,7 @@ export class Session {
                 },
             });
             if (subscriptionId && this.workspaceUpdatesSubscription?.subscriptionId === subscriptionId) {
-                this.flushBootstrappedWorkspaceUpdates({ snapshotLatestActivityByWorkspaceId });
+                this.flushBootstrappedWorkspaceUpdates(snapshot);
                 void this.reconcileAndEmitWorkspaceUpdates();
             }
         }
@@ -5350,6 +5342,24 @@ export class Session {
             });
         }
     }
+    // Build the bootstrap snapshot used by `flushBootstrappedWorkspaceUpdates`
+    // to decide which pending updates to drop. Captures the status,
+    // statusEnteredAt, and activityAt (parsed to ms) for each workspace entry
+    // so a status-only change (e.g. the unmask case), a statusEnteredAt-only
+    // change (e.g. a fresh unmask time), AND a fresher activity all still
+    // ship to the client.
+    buildBootstrapSnapshot(entries) {
+        const snapshotByWorkspaceId = new Map();
+        for (const entry of entries) {
+            const parsedActivity = entry.activityAt ? Date.parse(entry.activityAt) : null;
+            snapshotByWorkspaceId.set(entry.id, {
+                status: entry.status,
+                statusEnteredAt: entry.statusEnteredAt ?? null,
+                activityAtMs: Number.isNaN(parsedActivity) ? null : parsedActivity,
+            });
+        }
+        return { snapshotByWorkspaceId };
+    }
     async registerWorkspaceForImportedAgent(cwd) {
         try {
             const workspace = await this.findOrCreateWorkspaceForDirectory(cwd);
@@ -5399,16 +5409,17 @@ export class Session {
         }
     }
     buildWorkspaceScriptPayloadSnapshot(workspaceId, workspaceDirectory) {
-        if (!this.scriptRouteStore || !this.scriptRuntimeStore) {
+        if (!this.serviceProxy || !this.scriptRuntimeStore) {
             return [];
         }
         return buildWorkspaceScriptPayloads({
             workspaceId,
             workspaceDirectory,
             paseoConfig: readPaseoConfigForProjection(workspaceDirectory, this.sessionLogger),
-            routeStore: this.scriptRouteStore,
+            serviceProxy: this.serviceProxy,
             runtimeStore: this.scriptRuntimeStore,
             daemonPort: this.getDaemonTcpPort?.() ?? null,
+            serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
             gitMetadata: this.resolveWorkspaceScriptGitMetadata(workspaceDirectory),
             resolveHealth: this.resolveScriptHealth ?? undefined,
         });
@@ -5432,18 +5443,9 @@ export class Session {
             },
         });
     }
-    async resolveAvailableEditorTargets() {
-        return listAvailableEditorTargets();
-    }
-    async getAvailableEditorTargets() {
-        return this.filterEditorsForClient(await this.getMemoizedAvailableEditorTargets());
-    }
-    async openEditorTarget(options) {
-        await openInEditorTarget(options);
-    }
     async handleStartWorkspaceScriptRequest(request) {
         try {
-            if (!this.terminalManager || !this.scriptRouteStore || !this.scriptRuntimeStore) {
+            if (!this.terminalManager || !this.serviceProxy || !this.scriptRuntimeStore) {
                 throw new Error("Workspace scripts are not available on this daemon");
             }
             const workspace = await this.workspaceRegistry.get(request.workspaceId);
@@ -5459,7 +5461,8 @@ export class Session {
                 scriptName: request.scriptName,
                 daemonPort: this.getDaemonTcpPort?.() ?? null,
                 daemonListenHost: this.getDaemonTcpHost?.() ?? null,
-                routeStore: this.scriptRouteStore,
+                serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
+                serviceProxy: this.serviceProxy,
                 runtimeStore: this.scriptRuntimeStore,
                 terminalManager: this.terminalManager,
                 logger: this.sessionLogger,
@@ -5498,62 +5501,30 @@ export class Session {
             });
         }
     }
-    async handleListAvailableEditorsRequest(request) {
-        try {
-            const editors = await this.getAvailableEditorTargets();
-            this.emit({
-                type: "list_available_editors_response",
-                payload: {
-                    requestId: request.requestId,
-                    editors,
-                    error: null,
-                },
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to list available editors";
-            this.sessionLogger.error({ err: error, requestType: request.type }, "Failed to list available editors");
-            this.emit({
-                type: "list_available_editors_response",
-                payload: {
-                    requestId: request.requestId,
-                    editors: [],
-                    error: message,
-                },
-            });
-        }
+    // COMPAT(desktopEditorBridge): added in v0.1.88, remove after 2026-12-03 once old clients no longer call daemon editor RPCs.
+    async handleLegacyListAvailableEditorsRequest(request) {
+        this.emit({
+            type: "list_available_editors_response",
+            payload: {
+                requestId: request.requestId,
+                editors: [],
+                error: "Editor opening moved to the desktop app and is no longer supported by the daemon",
+            },
+        });
     }
-    async handleOpenInEditorRequest(request) {
-        try {
-            await this.openEditorTarget({ editorId: request.editorId, path: request.path });
-            this.emit({
-                type: "open_in_editor_response",
-                payload: {
-                    requestId: request.requestId,
-                    error: null,
-                },
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : "Failed to open in editor";
-            this.sessionLogger.error({
-                err: error,
-                editorId: request.editorId,
-                path: request.path,
-                requestType: request.type,
-            }, "Failed to open in editor");
-            this.emit({
-                type: "open_in_editor_response",
-                payload: {
-                    requestId: request.requestId,
-                    error: message,
-                },
-            });
-        }
+    async handleLegacyOpenInEditorRequest(request) {
+        this.emit({
+            type: "open_in_editor_response",
+            payload: {
+                requestId: request.requestId,
+                error: "Editor opening moved to the desktop app and is no longer supported by the daemon",
+            },
+        });
     }
     async handleCreatePaseoWorktreeRequest(request) {
         return handleCreateWorktreeRequest({
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
             describeWorkspaceRecord: (result) => this.describeCreatedWorktreeWorkspace(result),
             emit: (message) => this.emit(message),
             sessionLogger: this.sessionLogger,
@@ -5563,6 +5534,7 @@ export class Session {
     async createPaseoWorktreeWorkflow(input, options) {
         return createWorktreeWorkflow({
             paseoHome: this.paseoHome,
+            worktreesRoot: this.worktreesRoot,
             createPaseoWorktree: (workflowInput, serviceOptions) => this.createPaseoWorktree(workflowInput, serviceOptions),
             warmWorkspaceGitData: (workspace) => this.warmWorkspaceGitDataForWorkspace(workspace),
             autoNameWorkspaceBranchForFirstAgent: (autoNameInput) => this.scheduleAutoNameWorkspaceBranchForFirstAgent(autoNameInput),
@@ -5574,10 +5546,11 @@ export class Session {
             sessionLogger: this.sessionLogger,
             terminalManager: this.terminalManager,
             archiveWorkspaceRecord: (workspaceId) => this.archiveWorkspaceRecord(workspaceId),
-            scriptRouteStore: this.scriptRouteStore,
+            serviceProxy: this.serviceProxy,
             scriptRuntimeStore: this.scriptRuntimeStore,
             getDaemonTcpPort: this.getDaemonTcpPort,
             getDaemonTcpHost: this.getDaemonTcpHost,
+            serviceProxyPublicBaseUrl: this.serviceProxyPublicBaseUrl,
             onScriptsChanged: (workspaceId, workspaceDirectory) => {
                 this.emitWorkspaceScriptStatusUpdate(workspaceId, workspaceDirectory);
             },
@@ -5625,6 +5598,122 @@ export class Session {
             });
         }
     }
+    async handleWorkspaceClearAttentionRequest(request) {
+        const { requestId, workspaceId } = request;
+        const requestedWorkspaceIds = Array.isArray(workspaceId) ? workspaceId : [workspaceId];
+        let agents;
+        try {
+            agents = await this.listAgentPayloads();
+        }
+        catch (error) {
+            const message = getErrorMessage(error);
+            const results = requestedWorkspaceIds.map((requestedWorkspaceId) => ({
+                workspaceId: requestedWorkspaceId,
+                clearedAgentIds: [],
+                success: false,
+                error: message,
+            }));
+            this.emit({
+                type: "workspace.clear_attention.response",
+                payload: {
+                    requestId,
+                    workspaceId,
+                    clearedAgentIds: [],
+                    results,
+                    success: false,
+                    error: message,
+                },
+            });
+            return;
+        }
+        const results = [];
+        for (const requestedWorkspaceId of requestedWorkspaceIds) {
+            const clearedAgentIds = [];
+            try {
+                const workspace = await this.workspaceRegistry.get(requestedWorkspaceId);
+                if (!workspace || workspace.archivedAt) {
+                    throw new Error(`Workspace not found: ${requestedWorkspaceId}`);
+                }
+                const workspaceCwd = normalizePersistedWorkspaceId(workspace.cwd);
+                const clearableAgentIds = agents
+                    .filter((agent) => !agent.archivedAt)
+                    .filter((agent) => normalizePersistedWorkspaceId(agent.cwd) === workspaceCwd)
+                    .filter((agent) => agent.requiresAttention === true)
+                    .filter((agent) => (agent.pendingPermissions?.length ?? 0) === 0)
+                    .filter((agent) => agent.attentionReason !== "permission")
+                    .map((agent) => agent.id);
+                for (const agentId of clearableAgentIds) {
+                    const liveAgent = this.agentManager.getAgent(agentId);
+                    if (liveAgent) {
+                        await this.agentManager.clearAgentAttention(agentId);
+                        clearedAgentIds.push(agentId);
+                        continue;
+                    }
+                    const record = await this.agentStorage.get(agentId);
+                    if (!record ||
+                        record.internal ||
+                        record.archivedAt ||
+                        record.requiresAttention !== true) {
+                        continue;
+                    }
+                    const nextRecord = {
+                        ...record,
+                        updatedAt: new Date().toISOString(),
+                        requiresAttention: false,
+                        attentionReason: null,
+                        attentionTimestamp: null,
+                    };
+                    await this.agentStorage.upsert(nextRecord);
+                    const agent = this.buildStoredAgentPayload(nextRecord);
+                    const project = await this.buildProjectPlacementForCwd(agent.cwd);
+                    this.emit({
+                        type: "agent_update",
+                        payload: {
+                            kind: "upsert",
+                            agent,
+                            project,
+                        },
+                    });
+                    clearedAgentIds.push(agentId);
+                }
+                await this.emitWorkspaceUpdateForWorkspaceId(workspace.workspaceId);
+                results.push({
+                    workspaceId: requestedWorkspaceId,
+                    clearedAgentIds,
+                    success: true,
+                    error: null,
+                });
+            }
+            catch (error) {
+                const message = getErrorMessage(error);
+                this.sessionLogger.error({ err: error, workspaceId: requestedWorkspaceId }, "Failed to clear workspace attention");
+                results.push({
+                    workspaceId: requestedWorkspaceId,
+                    clearedAgentIds,
+                    success: false,
+                    error: message,
+                });
+            }
+        }
+        const clearedAgentIds = results.flatMap((result) => result.clearedAgentIds);
+        const failedResults = results.filter((result) => !result.success);
+        this.emit({
+            type: "workspace.clear_attention.response",
+            payload: {
+                requestId,
+                workspaceId,
+                clearedAgentIds,
+                results,
+                success: failedResults.length === 0,
+                error: failedResults.length === 0
+                    ? null
+                    : failedResults
+                        .map((result) => result.error)
+                        .filter((error) => error !== null)
+                        .join("; "),
+            },
+        });
+    }
     async handleFetchAgent(agentIdOrIdentifier, requestId) {
         const resolved = await this.resolveAgentIdentifier(agentIdOrIdentifier);
         if (!resolved.ok) {

package/dist/server/server/speech/providers/local/worker-client.js

@@ -174,7 +174,7 @@ export class LocalSpeechWorkerClient {
                 reject,
                 timeout,
             });
-            const sent = worker.send(message, (error) => {
+            worker.send(message, (error) => {
                 if (!error) {
                     return;
                 }
@@ -188,16 +188,6 @@ export class LocalSpeechWorkerClient {
                 this.scheduleIdleShutdownIfReady();
                 pending.reject(error);
             });
-            if (!sent) {
-                const pending = this.pendingRequests.get(requestId);
-                if (pending) {
-                    clearTimeout(pending.timeout);
-                    this.pendingRequests.delete(requestId);
-                    this.inFlightRequests = Math.max(0, this.inFlightRequests - 1);
-                    this.scheduleIdleShutdownIfReady();
-                    pending.reject(new Error("Local speech worker IPC channel is not writable"));
-                }
-            }
         });
     }
     ensureWorker() {

package/dist/server/server/websocket-server.d.ts

@@ -17,7 +17,7 @@ import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
 import type { WorkspaceGitService } from "./workspace-git-service.js";
 import { type PushNotificationSender } from "./push/notifications.js";
 import type { ScriptHealthState } from "./script-health-monitor.js";
-import type { ScriptRouteStore } from "./script-proxy.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
 import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
 import type { SpeechReadinessSnapshot, SpeechService } from "./speech/speech-runtime.js";
 import type { VoiceCallerContext, VoiceSpeakHandler } from "./voice-types.js";
@@ -66,16 +66,18 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly workspaceGitService;
     private readonly downloadTokenStore;
     private readonly paseoHome;
+    private readonly worktreesRoot;
     private readonly daemonConfigStore;
     private readonly pushTokenStore;
     private readonly pushNotificationSender;
     private readonly mcpBaseUrl;
     private speech;
     private terminalManager;
-    private scriptRouteStore;
+    private serviceProxy;
     private scriptRuntimeStore;
     private getDaemonTcpPort;
     private getDaemonTcpHost;
+    private serviceProxyPublicBaseUrl;
     private resolveScriptHealth;
     private dictation;
     private readonly voiceSpeakHandlers;
@@ -91,8 +93,9 @@ export declare class VoiceAssistantWebSocketServer {
     private unsubscribeDaemonConfigChange;
     constructor(server: HTTPServer, logger: pino.Logger, serverId: string, agentManager: AgentManager, agentStorage: AgentStorage, downloadTokenStore: DownloadTokenStore, paseoHome: string, daemonConfigStore: DaemonConfigStore, mcpBaseUrl: string | null, wsConfig: WebSocketServerConfig, auth?: DaemonAuthConfig, speech?: SpeechService | null, terminalManager?: TerminalManager | null, dictation?: {
         finalTimeoutMs?: number;
-    }, daemonVersion?: string, onLifecycleIntent?: (intent: SessionLifecycleIntent) => void, projectRegistry?: ProjectRegistry, workspaceRegistry?: WorkspaceRegistry, chatService?: FileBackedChatService, loopService?: LoopService, scheduleService?: ScheduleService, checkoutDiffManager?: CheckoutDiffManager, scriptRouteStore?: ScriptRouteStore | null, scriptRuntimeStore?: WorkspaceScriptRuntimeStore | null, onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void, getDaemonTcpPort?: () => number | null, getDaemonTcpHost?: () => string | null, resolveScriptHealth?: (hostname: string) => ScriptHealthState | null, workspaceGitService?: WorkspaceGitService, github?: GitHubService, pushNotificationSender?: PushNotificationSender, providerSnapshotManager?: ProviderSnapshotManager, daemonRuntimeConfig?: {
+    }, daemonVersion?: string, onLifecycleIntent?: (intent: SessionLifecycleIntent) => void, projectRegistry?: ProjectRegistry, workspaceRegistry?: WorkspaceRegistry, chatService?: FileBackedChatService, loopService?: LoopService, scheduleService?: ScheduleService, checkoutDiffManager?: CheckoutDiffManager, serviceProxy?: ServiceProxySubsystem | null, scriptRuntimeStore?: WorkspaceScriptRuntimeStore | null, onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void, getDaemonTcpPort?: () => number | null, getDaemonTcpHost?: () => string | null, resolveScriptHealth?: (hostname: string) => ScriptHealthState | null, workspaceGitService?: WorkspaceGitService, github?: GitHubService, pushNotificationSender?: PushNotificationSender, providerSnapshotManager?: ProviderSnapshotManager, daemonRuntimeConfig?: {
         listen: string | null;
+        worktreesRoot?: string;
         relay: {
             enabled: boolean;
             endpoint: string;
@@ -100,7 +103,7 @@ export declare class VoiceAssistantWebSocketServer {
             useTls: boolean;
             publicUseTls: boolean;
         };
-    });
+    }, serviceProxyPublicBaseUrl?: string | null);
     private assignOptionalServices;
     private createWebSocketServer;
     private startRuntimeMetricsInterval;