@getpaseo/server 0.1.89 → 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();
@@ -764,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;
@@ -1328,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":
@@ -4532,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;
     }
@@ -4734,6 +4714,7 @@ export class Session {
             name: workspace.displayName,
             archivingAt: null,
             status: "done",
+            statusEnteredAt: null,
             activityAt: null,
             diffStat,
             scripts: this.serviceProxy && this.scriptRuntimeStore
@@ -4809,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: [],
@@ -4879,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({
@@ -5317,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: {
@@ -5335,7 +5320,7 @@ export class Session {
                 },
             });
             if (subscriptionId && this.workspaceUpdatesSubscription?.subscriptionId === subscriptionId) {
-                this.flushBootstrappedWorkspaceUpdates({ snapshotLatestActivityByWorkspaceId });
+                this.flushBootstrappedWorkspaceUpdates(snapshot);
                 void this.reconcileAndEmitWorkspaceUpdates();
             }
         }
@@ -5357,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);
@@ -5440,15 +5443,6 @@ 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.serviceProxy || !this.scriptRuntimeStore) {
@@ -5507,58 +5501,25 @@ 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({
@@ -5637,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/workspace-bootstrap-dedupe.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure dedupe decision for the bootstrap flush.
+ *
+ * During the bootstrap window the session buffers workspace updates that
+ * race with the initial `fetch_workspaces_response`. The flush step decides
+ * which buffered updates still carry new information and which are
+ * redundant with what the client just received in the snapshot.
+ *
+ * Returns `true` (emit) when ANY of:
+ *   - the status changed from the snapshot
+ *   - the statusEnteredAt changed from the snapshot (including the
+ *     null↔value transition that the unmask case produces)
+ *   - the update's activityAtMs is strictly newer than the snapshot's
+ *   - the snapshot has no activityAtMs and the update has one (new activity
+ *     where there was none)
+ *
+ * Returns `false` (drop) when the status pair is unchanged AND the update
+ * is not strictly newer than the snapshot in activity. The both-null
+ * activity case falls through to drop — there is genuinely no new info.
+ */
+export interface BootstrapUpdateSnapshot {
+    status: string;
+    statusEnteredAt: string | null;
+    activityAtMs: number | null;
+}
+export interface BootstrapUpdateCheckInput {
+    /** Snapshot captured from the fetch_workspaces_response. `null` means
+     * the workspace was not in the snapshot (first-time subscription). */
+    snapshot: BootstrapUpdateSnapshot | null;
+    /** Pending update buffered during the bootstrap window. */
+    update: BootstrapUpdateSnapshot;
+}
+export declare function shouldEmitPendingBootstrapUpdate(input: BootstrapUpdateCheckInput): boolean;
+//# sourceMappingURL=workspace-bootstrap-dedupe.d.ts.map

package/dist/server/server/workspace-bootstrap-dedupe.js

@@ -0,0 +1,23 @@
+export function shouldEmitPendingBootstrapUpdate(input) {
+    const { snapshot, update } = input;
+    if (!snapshot) {
+        return true;
+    }
+    if (snapshot.status !== update.status) {
+        return true;
+    }
+    const snapshotEnteredAt = snapshot.statusEnteredAt ?? null;
+    const updateEnteredAt = update.statusEnteredAt ?? null;
+    if (snapshotEnteredAt !== updateEnteredAt) {
+        return true;
+    }
+    // Status pair is unchanged. The only remaining signal is activity.
+    if (update.activityAtMs === null) {
+        return false;
+    }
+    if (snapshot.activityAtMs === null) {
+        return true;
+    }
+    return update.activityAtMs > snapshot.activityAtMs;
+}
+//# sourceMappingURL=workspace-bootstrap-dedupe.js.map

package/dist/server/server/workspace-directory.d.ts

@@ -44,6 +44,12 @@ export declare function summarizeFetchWorkspacesEntries(entries: Iterable<FetchW
 export declare class WorkspaceDirectory {
     private readonly deps;
     private readonly archivingByWorkspaceId;
+    /**
+     * Per-workspace last-seen winning bucket + entered-at. Persists across
+     * `buildDescriptorMap` calls inside the daemon process; reset on cold start.
+     * Server-internal; never crosses the wire.
+     */
+    private readonly bucketHistoryByWorkspaceId;
     private readonly pager;
     constructor(deps: WorkspaceDirectoryDeps);
     markArchiving(workspaceIds: Iterable<string>, archivingAt: string): void;
@@ -52,6 +58,8 @@ export declare class WorkspaceDirectory {
         includeGitData: boolean;
         workspaceIds?: Iterable<string>;
     }): Promise<Map<string, WorkspaceDescriptorPayload>>;
+    private resolveStatusEnteredAt;
+    private findNewestAgentTimestampInBucket;
     resolveRegisteredWorkspaceIdForCwd(cwd: string, workspaces: PersistedWorkspaceRecord[]): string;
     listDescriptors(): Promise<WorkspaceDescriptorPayload[]>;
     matchesFilter(input: {