From 3e34be12288034be79bbb033cf63c121b62a7e03 Mon Sep 17 00:00:00 2001 From: "paseo-bot[bot]" <266920839+paseo-bot[bot]@users.noreply.github.com> Date: Wed, 18 Nov 2026 05:09:17 +0000 Subject: [PATCH] Check the daemon's subagent list before closing an agent tab The app only holds provider subagents for agents it has rendered or heard about while connected. After a reload, a restored tab that was never activated had no subagents loaded, so closing it still archived the agent without asking while its background subagent ran. Before deciding, the tab close now refreshes that agent's subagent list from the daemon, and falls back to the loaded list if the request fails. Refs #10038 Co-Authored-By: Claude Opus 5.5 --- .../screens/workspace/workspace-screen.tsx | 18 +++-- .../src/subagents/close-tab-policy.test.ts | 80 ++++++++++++++++++- .../app/src/subagents/close-tab-policy.ts | 30 ++++++- packages/app/src/subagents/index.ts | 6 +- packages/app/src/subagents/provider-store.ts | 2 +- 5 files changed, 124 insertions(+), 12 deletions(-) diff --git a/packages/app/src/screens/workspace/workspace-screen.tsx b/packages/app/src/screens/workspace/workspace-screen.tsx index e223106afc..f6165317ad 100644 --- a/packages/app/src/screens/workspace/workspace-screen.tsx +++ b/packages/app/src/screens/workspace/workspace-screen.tsx @@ -211,7 +211,7 @@ import { classifyBulkClosableTabs, closeBulkWorkspaceTabs, } from "@/screens/workspace/workspace-bulk-close"; -import { resolveCloseAgentTabPolicy } from "@/subagents"; +import { loadCloseAgentTabPolicy, resolveCloseAgentTabPolicy } from "@/subagents"; import { useProviderSubagentStore } from "@/subagents/provider-store"; import { getPanelInstanceAttributes, @@ -246,6 +246,12 @@ const EMPTY_WORKSPACE_SCRIPTS: WorkspaceDescriptor["scripts"] = []; const EMPTY_PINNED_AGENT_IDS = new Set(); const EMPTY_SET = new Set(); +type WorkspaceSession = ReturnType["sessions"][string]; + +function providerSubagentListClient(session: WorkspaceSession | undefined) { + return session?.serverInfo?.features?.providerSubagents === true ? session.client : null; +} + function getWorkspaceSetupStatus(workspace: WorkspaceDescriptor | null | undefined) { return workspace?.setupStatus ?? null; } @@ -2001,12 +2007,12 @@ function WorkspaceScreenContent({ return; } - const agent = - useSessionStore.getState().sessions[normalizedServerId]?.agents?.get(agentId) ?? null; - let closePolicy = resolveCloseAgentTabPolicy( + const session = useSessionStore.getState().sessions[normalizedServerId]; + const agent = session?.agents?.get(agentId) ?? null; + let closePolicy = await loadCloseAgentTabPolicy({ agent, - useProviderSubagentStore.getState().descriptors, - ); + providerSubagents: providerSubagentListClient(session), + }); if (closePolicy.kind === "archive-on-close" && closePolicy.confirmArchive) { const confirmed = await confirmDialog({ diff --git a/packages/app/src/subagents/close-tab-policy.test.ts b/packages/app/src/subagents/close-tab-policy.test.ts index 367da0026c..e2af44572b 100644 --- a/packages/app/src/subagents/close-tab-policy.test.ts +++ b/packages/app/src/subagents/close-tab-policy.test.ts @@ -1,7 +1,7 @@ -import { describe, expect, it } from "vitest"; +import { afterEach, describe, expect, it } from "vitest"; import type { ProviderSubagentDescriptorPayload } from "@getpaseo/protocol/messages"; -import { resolveCloseAgentTabPolicy } from "./close-tab-policy"; -import { providerSubagentKey } from "./provider-store"; +import { loadCloseAgentTabPolicy, resolveCloseAgentTabPolicy } from "./close-tab-policy"; +import { providerSubagentKey, useProviderSubagentStore } from "./provider-store"; const SERVER_ID = "server-1"; const AGENT_ID = "agent-1"; @@ -17,6 +17,44 @@ function rootAgent(overrides: Partial) { + return { + listProviderSubagents: async (parentAgentId: string) => ({ + requestId: "request-1", + parentAgentId, + subagents: lists[parentAgentId] ?? [], + error: null, + }), + }; +} + +afterEach(() => { + useProviderSubagentStore.setState({ + descriptors: new Map(), + timelines: new Map(), + hiddenFromTrack: new Set(), + trackedParents: new Set(), + }); +}); + function providerSubagents( entries: Array<{ parentAgentId: string; @@ -100,3 +138,39 @@ describe("resolveCloseAgentTabPolicy", () => { }); }); }); + +describe("loadCloseAgentTabPolicy", () => { + it("asks for a background subagent this client has not loaded yet, such as a tab restored after a reload", async () => { + const daemon = fakeDaemon({ [AGENT_ID]: [descriptor(AGENT_ID, "sub-1", "running")] }); + + await expect( + loadCloseAgentTabPolicy({ agent: rootAgent(), providerSubagents: daemon }), + ).resolves.toEqual({ kind: "archive-on-close", confirmArchive: true }); + }); + + it("falls back to the subagents already loaded when the daemon cannot list them", async () => { + useProviderSubagentStore + .getState() + .applyUpdate(SERVER_ID, { + kind: "upsert", + subagent: descriptor(AGENT_ID, "sub-1", "running"), + }); + const disconnected = { + listProviderSubagents: async () => { + throw new Error("Transport not connected"); + }, + }; + + await expect( + loadCloseAgentTabPolicy({ agent: rootAgent(), providerSubagents: disconnected }), + ).resolves.toEqual({ kind: "archive-on-close", confirmArchive: true }); + }); + + it("archives without asking when the daemon lists no running subagent", async () => { + const daemon = fakeDaemon({ [AGENT_ID]: [descriptor(AGENT_ID, "sub-1", "completed")] }); + + await expect( + loadCloseAgentTabPolicy({ agent: rootAgent(), providerSubagents: daemon }), + ).resolves.toEqual({ kind: "archive-on-close", confirmArchive: false }); + }); +}); diff --git a/packages/app/src/subagents/close-tab-policy.ts b/packages/app/src/subagents/close-tab-policy.ts index b093777871..1037dfb720 100644 --- a/packages/app/src/subagents/close-tab-policy.ts +++ b/packages/app/src/subagents/close-tab-policy.ts @@ -1,6 +1,11 @@ import type { ProviderSubagentDescriptorPayload } from "@getpaseo/protocol/messages"; import type { Agent } from "@/stores/session-store"; -import { hasRunningProviderSubagents } from "./provider-store"; +import { + hasRunningProviderSubagents, + refreshProviderSubagents, + useProviderSubagentStore, + type ProviderSubagentListClient, +} from "./provider-store"; export type CloseAgentTabPolicy = | { kind: "archive-on-close"; confirmArchive: boolean } @@ -22,6 +27,29 @@ export function resolveCloseAgentTabPolicy( }; } +/** + * Resolves the policy against the daemon's current subagent list. This client only holds the + * subagents of agents it has rendered or heard about while connected, so a tab restored after a + * reload would otherwise close without asking while its background subagent runs. + */ +export async function loadCloseAgentTabPolicy(input: { + agent: CloseTabAgent | null | undefined; + /** Null when the host does not report provider subagents or no client is connected. */ + providerSubagents: ProviderSubagentListClient | null; +}): Promise { + const { agent, providerSubagents } = input; + const cached = resolveCloseAgentTabPolicy(agent, useProviderSubagentStore.getState().descriptors); + if (!agent || !providerSubagents || cached.kind !== "archive-on-close" || cached.confirmArchive) { + return cached; + } + try { + await refreshProviderSubagents(providerSubagents, agent.serverId, agent.id); + } catch { + return cached; + } + return resolveCloseAgentTabPolicy(agent, useProviderSubagentStore.getState().descriptors); +} + // Archiving stops the agent's process, which also stops work it left running after its turn // ended: background subagents and background shells. function hasRunningWork( diff --git a/packages/app/src/subagents/index.ts b/packages/app/src/subagents/index.ts index cd8ee753fb..09c0226111 100644 --- a/packages/app/src/subagents/index.ts +++ b/packages/app/src/subagents/index.ts @@ -2,7 +2,11 @@ export type { SubagentRow } from "./select"; export { selectSubagentsForParent, useSubagentsForParent } from "./select"; export { useArchiveSubagent } from "./use-archive-subagent"; export { useDetachSubagent } from "./use-detach-subagent"; -export { resolveCloseAgentTabPolicy, type CloseAgentTabPolicy } from "./close-tab-policy"; +export { + loadCloseAgentTabPolicy, + resolveCloseAgentTabPolicy, + type CloseAgentTabPolicy, +} from "./close-tab-policy"; export { isWorkspaceRootAgent } from "./workspace-root-policy"; export { useArchiveFinishedSubagents, diff --git a/packages/app/src/subagents/provider-store.ts b/packages/app/src/subagents/provider-store.ts index ee27f55fd1..05a9a7704e 100644 --- a/packages/app/src/subagents/provider-store.ts +++ b/packages/app/src/subagents/provider-store.ts @@ -69,7 +69,7 @@ export function providerSubagentLifecycleStatus( return "idle"; } -type ProviderSubagentListClient = Pick; +export type ProviderSubagentListClient = Pick; const pendingListRequests = new WeakMap>>();