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>>();