@hyperdrive.bot/fleet-server 0.3.159 → 0.3.160

package/dist/server/server/session.js

@@ -426,6 +426,57 @@ function fileAttachmentErrorMessage(error, fileId) {
             return `Attachment file is no longer available: ${fileId}`;
     }
 }
+/**
+ * Stored-agent payload projection, memoized per record object and shared by
+ * every Session in the daemon. AgentStorage replaces a record object on every
+ * write (never mutates it), so identity plus the other projection inputs
+ * (registered providers, schedule facts) is an exact key. Before this, every
+ * agent_state event re-projected the same stored records once per connected
+ * client. Payloads are shared: treat them as read-only.
+ */
+const storedAgentPayloadMemo = new WeakMap();
+/**
+ * The stored records a workspace descriptor for `workspaceIds` can depend on:
+ * records owned by one of those workspaces, running delegated records (they roll
+ * up to their delegation root, see WorkspaceDirectory), and the ancestor chain of
+ * every delegated record or live agent so the root can be resolved.
+ */
+export function selectRecordsForWorkspaces(records, liveAgents, workspaceIds) {
+    const selected = new Set();
+    const pendingParentIds = [];
+    for (const record of records) {
+        const parentId = getParentAgentIdFromLabels(record.labels);
+        const owned = record.workspaceId !== undefined && workspaceIds.has(record.workspaceId);
+        if (owned || (parentId !== null && record.lastStatus === "running")) {
+            selected.add(record);
+            if (parentId)
+                pendingParentIds.push(parentId);
+        }
+    }
+    for (const agent of liveAgents) {
+        const parentId = getParentAgentIdFromLabels(agent.labels);
+        if (parentId)
+            pendingParentIds.push(parentId);
+    }
+    if (pendingParentIds.length > 0) {
+        const byId = new Map(records.map((record) => [record.id, record]));
+        const seen = new Set();
+        while (pendingParentIds.length > 0) {
+            const id = pendingParentIds.pop();
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const parent = byId.get(id);
+            if (!parent)
+                continue;
+            selected.add(parent);
+            const next = getParentAgentIdFromLabels(parent.labels);
+            if (next)
+                pendingParentIds.push(next);
+        }
+    }
+    return records.filter((record) => selected.has(record));
+}
 /**
  * Session represents a single connected client session.
  * It owns all state management, orchestration logic, and message processing.
@@ -727,7 +778,7 @@ export class Session {
             logger: this.sessionLogger,
             projectRegistry: this.projectRegistry,
             workspaceRegistry: this.workspaceRegistry,
-            listAgentPayloads: () => this.listAgentPayloads(),
+            listAgentPayloads: (filter) => this.listAgentPayloads(filter),
             listTerminalActivityContributions: () => this.listTerminalActivityContributions(),
             isProviderVisibleToClient: (provider) => this.isProviderVisibleToClient(provider),
             buildWorkspaceDescriptor: (input) => this.buildWorkspaceDescriptor(input),
@@ -1079,14 +1130,24 @@ export class Session {
         payload.snooze = storedRecord?.snooze ?? null;
         return payload;
     }
-    buildStoredAgentPayload(record, registeredProviderIds = new Set(this.providerSnapshotManager.listRegisteredProviderIds())) {
+    buildStoredAgentPayload(record, registeredProviderIds = new Set(this.providerSnapshotManager.listRegisteredProviderIds()), providersKey) {
         const nextFireAt = this.scheduleService.peekNextFireAt(record.id);
         const hasRoutine = this.scheduleService.peekHasRoutine(record.id);
+        const memoKey = providersKey ?? [...registeredProviderIds].join("\u0000");
+        const memo = storedAgentPayloadMemo.get(record);
+        if (memo &&
+            memo.providersKey === memoKey &&
+            memo.nextFireAt === nextFireAt &&
+            memo.hasRoutine === hasRoutine) {
+            return memo.payload;
+        }
         const scheduleOptions = {
             ...(nextFireAt !== undefined ? { nextFireAt } : {}),
             ...(hasRoutine !== undefined ? { hasRoutine } : {}),
         };
-        return buildStoredAgentPayload(record, registeredProviderIds, Object.keys(scheduleOptions).length > 0 ? scheduleOptions : undefined);
+        const payload = buildStoredAgentPayload(record, registeredProviderIds, Object.keys(scheduleOptions).length > 0 ? scheduleOptions : undefined);
+        storedAgentPayloadMemo.set(record, { providersKey: memoKey, nextFireAt, hasRoutine, payload });
+        return payload;
     }
     isProviderVisibleToClient(provider) {
         if (clientSupportsAllProviders(this.appVersion)) {
@@ -2551,7 +2612,7 @@ export class Session {
     }
     async handleArchiveAgentRequest(agentId, requestId) {
         this.sessionLogger.info({ agentId }, `Archiving agent ${agentId}`);
-        const { archivedAt } = await this.archiveAgentForClose(agentId);
+        const { archivedAt, background } = await this.archiveAgentForClose(agentId);
         this.emit({
             type: "agent_archived",
             payload: {
@@ -2560,6 +2621,8 @@ export class Session {
                 requestId,
             },
         });
+        // Teardown and the workspace delta finish after the reply; failures are logged.
+        void background;
     }
     /**
      * List background shells -- one agent's, or every agent's when `agentId` is
@@ -2711,19 +2774,44 @@ export class Session {
             payload: { agentId, taskId, dismissed, requestId },
         });
     }
+    /**
+     * Persist the archive and emit the archived agent, then hand back the rest
+     * (process teardown, then the workspace delta) as `background` so the caller
+     * can reply first. Stopping a busy agent and rebuilding its workspace used to
+     * sit in front of the reply.
+     */
     async archiveAgentForClose(agentId) {
-        const { archivedAt, record: archivedRecord } = await archiveAgentCommand({
+        const { archivedAt, record: archivedRecord, teardown, } = await archiveAgentCommand({
             agentManager: this.agentManager,
             agentStorage: this.agentStorage,
             logger: this.sessionLogger,
-        }, agentId);
-        if (this.agentUpdates.hasSubscription()) {
-            const payload = await this.agentUpdates.emitStoredRecord(archivedRecord);
-            if (payload.workspaceId) {
+        }, agentId, { deferTeardown: true });
+        const payload = this.agentUpdates.hasSubscription()
+            ? await this.agentUpdates.emitStoredRecord(archivedRecord)
+            : null;
+        const background = (async () => {
+            const teardownError = await teardown;
+            if (teardownError) {
+                // Surface it: clients otherwise hold an archived record whose process is
+                // still alive, and the only trace would be a daemon log line.
+                this.emit({
+                    type: "rpc_error",
+                    payload: {
+                        requestId: `archive-teardown:${agentId}`,
+                        requestType: "archive_agent_request",
+                        error: `Archived, but stopping the agent failed: ${teardownError.message}`,
+                        code: "archive_teardown_failed",
+                    },
+                });
+                await this.emitAgentUpsertFromStorage(agentId);
+            }
+            if (payload?.workspaceId) {
                 await this.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
             }
-        }
-        return { agentId, archivedAt };
+        })().catch((error) => {
+            this.sessionLogger.error({ err: error, agentId }, "Failed to emit workspace update after archiving agent");
+        });
+        return { agentId, archivedAt, background };
     }
     async handleDetachAgentRequest(agentId, requestId) {
         this.sessionLogger.info({ agentId, requestId }, "Detaching agent from parent");
@@ -2775,10 +2863,12 @@ export class Session {
     async handleCloseItemsRequest(msg) {
         const archiveResults = await Promise.allSettled(msg.agentIds.map((agentId) => this.archiveAgentForClose(agentId)));
         const agents = [];
+        const background = [];
         for (let i = 0; i < archiveResults.length; i += 1) {
             const result = archiveResults[i];
             if (result.status === "fulfilled") {
-                agents.push(result.value);
+                agents.push({ agentId: result.value.agentId, archivedAt: result.value.archivedAt });
+                background.push(result.value.background);
             }
             else {
                 this.sessionLogger.warn({ err: result.reason, agentId: msg.agentIds[i], requestId: msg.requestId }, "Failed to archive agent during close_items batch");
@@ -2805,6 +2895,8 @@ export class Session {
                 requestId: msg.requestId,
             },
         });
+        // Teardown and the workspace deltas finish after the reply; failures are logged.
+        void Promise.all(background);
     }
     async unarchiveAgentByHandle(handle) {
         const records = await this.agentStorage.list();
@@ -3585,7 +3677,7 @@ export class Session {
                     this.sessionLogger.warn({ err, agentId: snapshot.id, resumeSessionId }, "resume timeline hydration failed");
                 }
             }
-            await this.agentUpdates.forwardLiveAgent(snapshot);
+            await this.agentUpdates.forwardLiveAgent(snapshot, { immediate: true });
             if (createdDirectoryWorkspaceForAgent && trimmedPrompt) {
                 this.workspaceAutoName.scheduleForDirectory({
                     workspaceId,
@@ -3664,8 +3756,8 @@ export class Session {
             const snapshot = await this.agentManager.resumeAgentFromPersistence(handle, overrides);
             await unarchiveAgentState(this.agentStorage, this.agentManager, snapshot.id);
             await this.agentManager.hydrateTimelineFromProvider(snapshot.id);
-            await this.agentUpdates.forwardLiveAgent(snapshot);
-            const timelineSize = this.agentManager.getTimeline(snapshot.id).length;
+            await this.agentUpdates.forwardLiveAgent(snapshot, { immediate: true });
+            const timelineSize = this.agentManager.getTimelineSize(snapshot.id);
             if (requestId) {
                 const agentPayload = await this.buildAgentPayload(snapshot);
                 this.emit({
@@ -3805,8 +3897,8 @@ export class Session {
                 snapshot = await this.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
-            await this.agentUpdates.forwardLiveAgent(snapshot);
-            const timelineSize = this.agentManager.getTimeline(agentId).length;
+            await this.agentUpdates.forwardLiveAgent(snapshot, { immediate: true });
+            const timelineSize = this.agentManager.getTimelineSize(agentId);
             if (requestId) {
                 this.emit({
                     type: "status",
@@ -4855,9 +4947,13 @@ export class Session {
         const liveAgents = await Promise.all(agentSnapshots.map((agent) => this.buildAgentPayload(agent)));
         // Add persisted agents that have not been lazily initialized yet
         // (excluding internal agents which are for ephemeral system tasks)
-        const registryRecords = await this.agentStorage.list();
+        const allRegistryRecords = await this.agentStorage.list();
+        const registryRecords = filter?.workspaceIds
+            ? selectRecordsForWorkspaces(allRegistryRecords, agentSnapshots, filter.workspaceIds)
+            : allRegistryRecords;
         const liveIds = new Set(agentSnapshots.map((a) => a.id));
         const registeredProviderIds = new Set(this.providerSnapshotManager.listRegisteredProviderIds());
+        const providersKey = [...registeredProviderIds].join("\u0000");
         const persistedAgents = registryRecords
             .filter((record) => !liveIds.has(record.id) && !record.internal)
             // Keep raw-record filters ahead of projection; seeded homes can carry thousands of archived agents.
@@ -4865,7 +4961,7 @@ export class Session {
             .filter((record) => labelEntries.every(([key, value]) => record.labels?.[key] === value))
             .filter((record) => filter?.includeUnavailablePersisted === true ||
             isStoredAgentProviderAvailable(record, registeredProviderIds))
-            .map((record) => this.buildStoredAgentPayload(record, registeredProviderIds));
+            .map((record) => this.buildStoredAgentPayload(record, registeredProviderIds, providersKey));
         let agents = [...liveAgents, ...persistedAgents];
         agents = agents.filter((agent) => this.isProviderVisibleToClient(agent.provider));
         if (!includeArchived) {

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

@@ -50,6 +50,11 @@ interface WebSocketLike {
     on: (event: "message" | "close" | "error", listener: (...args: unknown[]) => void) => void;
     once: (event: "close" | "error", listener: (...args: unknown[]) => void) => void;
 }
+/**
+ * Requests designed to block until something happens (a long-poll). They stay
+ * out of the request latency stats and the slow-request log.
+ */
+export declare const LONG_POLL_REQUEST_TYPES: ReadonlySet<string>;
 export declare class MissingDaemonVersionError extends Error {
     constructor();
 }

package/dist/server/server/websocket-server.js

@@ -197,6 +197,11 @@ function getBrowserHostCapability(capabilities) {
     return parsed.success ? parsed.data : null;
 }
 const SLOW_REQUEST_THRESHOLD_MS = 500;
+/**
+ * Requests designed to block until something happens (a long-poll). They stay
+ * out of the request latency stats and the slow-request log.
+ */
+export const LONG_POLL_REQUEST_TYPES = new Set(["wait_for_finish_request"]);
 const EXTERNAL_SESSION_DISCONNECT_GRACE_MS = 90000;
 const HELLO_TIMEOUT_MS = 15000;
 const WS_CLOSE_HELLO_TIMEOUT = 4001;
@@ -1385,6 +1390,11 @@ export class VoiceAssistantWebSocketServer {
         }
         const startMs = performance.now();
         await activeConnection.session.handleMessage(message.message);
+        if (LONG_POLL_REQUEST_TYPES.has(message.message.type)) {
+            // Blocking until the agent finishes IS the contract; counting it as request
+            // latency (or as a slow request) reports the design as a regression.
+            return;
+        }
         const durationMs = performance.now() - startMs;
         this.recordRequestLatency(message.message.type, durationMs);
         if (durationMs >= SLOW_REQUEST_THRESHOLD_MS) {

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

@@ -21,7 +21,10 @@ export interface WorkspaceDirectoryDeps {
     workspaceRegistry: {
         list(): Promise<PersistedWorkspaceRecord[]>;
     };
-    listAgentPayloads(): Promise<AgentSnapshotPayload[]>;
+    /** With `workspaceIds`, may omit stored agents no descriptor for them depends on. */
+    listAgentPayloads(options?: {
+        workspaceIds?: ReadonlySet<string>;
+    }): Promise<AgentSnapshotPayload[]>;
     listTerminalActivityContributions(): Promise<Array<{
         cwd: string;
         workspaceId?: string;

package/dist/server/server/workspace-directory.js

@@ -108,8 +108,9 @@ export class WorkspaceDirectory {
         }
     }
     async buildDescriptorMap(options) {
+        const requestedWorkspaceIds = options.workspaceIds ? new Set(options.workspaceIds) : null;
         const [agents, persistedWorkspaces, persistedProjects, terminalContributions] = await Promise.all([
-            this.deps.listAgentPayloads(),
+            this.deps.listAgentPayloads(requestedWorkspaceIds ? { workspaceIds: requestedWorkspaceIds } : undefined),
             this.deps.workspaceRegistry.list(),
             this.deps.projectRegistry.list(),
             this.deps.listTerminalActivityContributions(),
@@ -120,7 +121,7 @@ export class WorkspaceDirectory {
         const archivedProjectIds = new Set(persistedProjects.filter((project) => project.archivedAt).map((project) => project.projectId));
         const activeRecords = persistedWorkspaces.filter((workspace) => !workspace.archivedAt && !archivedProjectIds.has(workspace.projectId));
         const descriptorsByWorkspaceId = new Map();
-        const workspaceIds = options.workspaceIds ? new Set(options.workspaceIds) : null;
+        const workspaceIds = requestedWorkspaceIds;
         const activeWorkspaceIds = new Set(activeRecords.map((workspace) => workspace.workspaceId));
         const includedWorkspaces = activeRecords.filter((workspace) => !workspaceIds || workspaceIds.has(workspace.workspaceId));
         const activeRecordsByWorkspaceId = new Map(activeRecords.map((workspace) => [workspace.workspaceId, workspace]));