@intentic/sandbox-contract 1.314.0 → 1.315.0

package/src/models/plan-pools.ts

@@ -145,7 +145,7 @@ export interface ServiceFacts {
     // Why the sign-in needs renewing, where the provider said.
     readonly detail?: string | undefined;
     readonly seatRefusal?: string | undefined;
-    readonly cooling?: { readonly until?: number | undefined; readonly reason?: string | undefined } | undefined;
+    readonly cooling?: { readonly until?: number | undefined; readonly reason?: string | undefined; readonly verify?: string | undefined } | undefined;
     readonly usage?: AccountUsage | undefined;
 }
 
@@ -240,6 +240,11 @@ export const serviceState = (facts: ServiceFacts, refusal?: ProviderRefusal, mod
         return { kind: "blocked", fix: "admin", reason: refusal.message };
     }
     const cooling = facts.cooling;
+    // A bench the provider wants a person for: the account's owner confirms it on the provider's page, and no wait or
+    // reconnect here lifts it. Outranks the retry instant, which is only when the proxy will ask again.
+    if (cooling?.verify !== undefined) {
+        return { kind: "blocked", fix: "verify", reason: cooling.reason ?? "the provider wants this account verified", url: cooling.verify };
+    }
     // A bench with no instant is one no wait lifts (a Google account with no project): somebody has to connect again.
     if (cooling !== undefined && cooling.until === undefined) {
         return { kind: "blocked", fix: "reconnect", reason: cooling.reason ?? "benched by the translator" };

package/src/schemas/agents.ts

@@ -418,6 +418,13 @@ export const AgentSummarySchema = z.object({
         .describe(
             "When somebody last opened it, in milliseconds. Newer activity than this is what makes it unread. Kept by the sandbox rather than by a browser, so clearing site data or picking up a phone does not resurrect every badge.",
         ),
+    // Browser-side words the daemon cannot read, reported so the unattended archive sweep never files them away.
+    unsentAt: z
+        .number()
+        .optional()
+        .describe(
+            "Since when somebody's composer has held a message for it that they have not sent yet, in milliseconds. While set, the sandbox never archives it on its own for being idle.",
+        ),
     attention: AgentAttentionSchema.describe("Which kinds of waiting-for-you it is doing."),
     // Only the causes that still hold, re-read live (conversations/land/standing.ts), never the stored report's own list: a
     // blocker the user has since cleared is not something to offer them an action about.
@@ -448,7 +455,7 @@ export const AgentSummarySchema = z.object({
         })
         .optional()
         .describe(
-            "Subagents and child agents this one delegated to. Absent means it never has, which is most conversations. Their spend is their own and is not folded into this conversation's cost.",
+            "Subagents this one started, in-process and spawned alike. Absent means it never has, which is most conversations. Their spend is their own and is not folded into this conversation's cost.",
         ),
     // Cumulative output across every repo (base → branch tip), refreshed on each land; independent of what has actually
     // landed.
@@ -740,6 +747,14 @@ export const AgentAutoLandSchema = z.object({
             "Whether its work merges automatically when a turn finishes. Null clears the override and goes back to following the sandbox-wide setting, so a conversation does not sit holding a frozen copy of a default it has quietly stopped following.",
         ),
 });
+// A composer's unsent words, reported by the editor that holds them: the words themselves stay in the browser.
+export const AgentUnsentSchema = z.object({
+    id: z.string().min(1).describe("Which conversation."),
+    at: z
+        .number()
+        .nullable()
+        .describe("When the composer started holding the unsent message, in milliseconds. Null says it no longer holds one: it was sent or cleared."),
+});
 // Same `null`-clears-the-override shape as autoLand, for this conversation's own answer to one ending's question.
 // One route rather than one per ending: they are the same decision asked about different walls, and three near-identical
 // verbs is how the surfaces drifted apart in the first place.

package/src/schemas/personas.ts

@@ -134,7 +134,7 @@ export const TURN_BRIEFING_NOTES: readonly TurnBriefingNote[] = [
     },
     {
         id: "delegation",
-        label: "Spawning child agents",
+        label: "Spawning subagents",
         when: "First message, on a shell-only runtime, for a card that may delegate.",
         cost: "The agent does the work itself rather than handing parts of it to other conversations.",
     },

package/src/schemas/providers/plan-limits.ts

@@ -47,7 +47,7 @@ export const AccountUsageSchema = z.object({
 export type AccountUsage = z.infer<typeof AccountUsageSchema>;
 // Who has to act for a blocked account, which is the only thing a surface chooses its instruction by: the reason is the
 // words for a person, never a key.
-export const AccountFixSchema = z.enum(["reconnect", "admin", "wait"]);
+export const AccountFixSchema = z.enum(["reconnect", "admin", "verify", "wait"]);
 export type AccountFix = z.infer<typeof AccountFixSchema>;
 // Whether an account can serve a turn, decided once by the daemon (models/plan-pools.ts `serviceState`) from every fact
 // it holds about it: a revoked sign-in, a lost seat, a translator bench, a refusal still standing, and its plan limits.
@@ -69,10 +69,11 @@ export const AccountStateSchema = z.discriminatedUnion("kind", [
     z.object({
         kind: z.literal("blocked"),
         fix: AccountFixSchema.describe(
-            "Who can make it serve again: `reconnect` (sign in again on this sandbox), `admin` (an organisation admin hands the seat back), or `wait` (it lifts by itself, at `until` where known).",
+            "Who can make it serve again: `reconnect` (sign in again on this sandbox), `admin` (an organisation admin hands the seat back), `verify` (the account's owner confirms it on the provider's page, at `url`), or `wait` (it lifts by itself, at `until` where known).",
         ),
         reason: z.string().describe("Why, in words a person can act on: the provider's own sentence where it gave one."),
         until: z.number().optional().describe("When waiting lifts it, in epoch seconds, for `wait` only."),
+        url: z.string().optional().describe("The provider's page where the account's owner lifts it, for `verify` only."),
     }),
     z.object({ kind: z.literal("unknown").describe("Nothing blocks it and nothing has been measured: usable, never read as room.") }),
 ]);
@@ -151,6 +152,9 @@ export const TranslatorAccountSchema = z.object({
             // Why, in the words of what is missing: the proxy's own sentence where it gave one short enough to print,
             // else this sandbox's. Never a pasted upstream body.
             reason: z.string().optional(),
+            // The provider's page where the account's owner confirms it (Google's VALIDATION_REQUIRED). Present means
+            // a person has to act there: the proxy's retry fails until they do.
+            verify: z.string().optional(),
         })
         .optional(),
     state: AccountStateSchema.optional().describe(
@@ -205,7 +209,7 @@ export const AgentReplySchema = z.discriminatedUnion("kind", [
         feedback: z.string().optional().describe("Why not, which goes back to the model as the reason."),
         // Whole, not a patch: effort or an account named for one model means nothing on another.
         child: ChildRunSchema.optional().describe(
-            "For a request to start a child agent: what to start it on instead of what the agent asked for. It replaces the whole run (model, account, effort and the rest), not only the fields it names. Ignored with a no, and on any other request.",
+            "For a request to start a subagent: what to start it on instead of what the agent asked for. It replaces the whole run (model, account, effort and the rest), not only the fields it names. Ignored with a no, and on any other request.",
         ),
     }),
     z.object({
@@ -400,6 +404,12 @@ export const SwitchAccountSchema = z.object({
         .describe(
             "Keep the provider session across the move (the model keeps everything, and re-reads all of it once on the other account) rather than opening a fresh one seeded from the record.",
         ),
+    run: z
+        .boolean()
+        .optional()
+        .describe(
+            "Also run a turn that a spent allowance, a stop or a refusal is holding, at once on the new account. Leave it out to only move the conversation: a held turn stays held until something asks for it.",
+        ),
 });
 export type SwitchAccount = z.infer<typeof SwitchAccountSchema>;
 export const AccountSwitchedSchema = z.object({

package/src/schemas/terminal.ts

@@ -128,13 +128,15 @@ export const BrowsersListSchema = z.object({
 });
 export type BrowsersList = z.infer<typeof BrowsersListSchema>;
 export const BrowserNameParamSchema = z.object({ name: z.string().describe("Which browser.") });
-// Two kinds of started agent, listed together since from outside both are just another agent working that you did not
-// start:
-// subagent: the SDK's Agent/Task tool, tracked via SubagentStart/Stop hooks and task_* messages joined on toolUseId.
-// spawned: a full child agent on any provider, started through the daemon's spawn door (children/children.ts); the
-// daemon reports its life directly.
-// id is the spawning tool call's id for a subagent, the child's own conversation id for a spawned one. A kind changes
-// only how you watch it live.
+// A subagent is any agent another agent started, and every surface shows one the same way whichever mechanism started
+// it. The kind names the mechanism, never a second sort of thing:
+// subagent: in-process, the runtime's own Agent/Task tool, tracked via SubagentStart/Stop hooks and task_* messages
+// joined on toolUseId; it works in its parent's turn and tree, on its parent's provider.
+// spawned: a full agent on any provider, started through the daemon's spawn door (agent/subagents/children.ts) as a
+// conversation of its own, in its own worktree; the daemon reports its life directly, and it can outlive its parent's
+// turn, be steered, and land its own work.
+// id is the spawning tool call's id for an in-process one, its own conversation id for a spawned one. The kind changes
+// only where its record is read from and what else can be done with it, never how it looks.
 export const SubagentKindSchema = z.enum(["subagent", "spawned"]);
 export type SubagentKind = z.infer<typeof SubagentKindSchema>;
 // running/pending/blocked are live, the rest terminal. Uses the SDK's own task vocabulary rather than AgentStatus.
@@ -168,7 +170,7 @@ export const SubagentSessionSchema = z.object({
             "The id of the tool call that started it (an SDK child) or the child's own conversation id (a spawned one); either way both sides already hold it, so a card links to its subagent with the id it has and the subagent points back the same way.",
         ),
     kind: SubagentKindSchema.describe(
-        "What sort of subagent: one the runtime's own Task tool spawned in-process, or a full child agent the daemon started for the turn. It changes only how you watch it.",
+        "How it was started: in-process by the runtime's own Agent/Task tool, or spawned by the daemon as a conversation of its own, on any provider. It changes where its record is read from and what else can be done with it, never what it is.",
     ),
     // The conversation whose turn started it; how a card links back to the chat it belongs to.
     conversationId: z.string().describe("The conversation whose turn started it, and the way back to the chat it belongs to."),
@@ -177,7 +179,7 @@ export const SubagentSessionSchema = z.object({
     description: z.string().optional().describe("What it was asked to do, in one line."),
     model: z.string().optional().describe("Which model it runs on."),
     // Which provider serves a spawned child; an SDK subagent implies its own (its parent's).
-    provider: z.string().optional().describe("Which provider serves it, for a child agent spawned across providers."),
+    provider: z.string().optional().describe("Which provider serves it, for a subagent spawned across providers."),
     // How deep in the spawn tree; 1 means the turn itself started it. A subagent can itself delegate further.
     spawnDepth: z
         .number()
@@ -216,7 +218,7 @@ export const SubagentSessionSchema = z.object({
 });
 export type SubagentSession = z.infer<typeof SubagentSessionSchema>;
 export const SubagentsListSchema = z.object({
-    sessions: z.array(SubagentSessionSchema).describe("Every subagent and child agent this sandbox's conversations have started."),
+    sessions: z.array(SubagentSessionSchema).describe("Every subagent this sandbox's conversations have started, in-process and spawned alike."),
 });
 export type SubagentsList = z.infer<typeof SubagentsListSchema>;
 export const SubagentIdParamSchema = z.object({ id: z.string() });

package/src/text/transcript-fold.test.ts

@@ -108,6 +108,113 @@ describe("foldTurn", () => {
         ]);
     });
 
+    // A spawned subagent is named by its own conversation, not the call that started it; the spawn answers with that
+    // name, which is how its card is found, so it reads on its card exactly as an in-process one does.
+    it("puts a spawned subagent on the card of the call whose result names it", () => {
+        const events: AgentEvent[] = [
+            { kind: "tool_call", id: "call-9", name: "mcp__subagents__spawn", category: "other", status: "in_progress" },
+            { kind: "subagent", id: "sub-brave-otter", subagentKind: "spawned", agentType: "Codex", description: "Port the parser", provider: "codex", background: true },
+            { kind: "subagent_update", id: "sub-brave-otter", status: "pending", summary: "Waiting for memory." },
+            { kind: "tool_call_update", id: "call-9", status: "completed", content: [{ type: "text", text: '{"ok":true,"child":"sub-brave-otter"}' }] },
+            { kind: "subagent_update", id: "sub-brave-otter", status: "running", toolUses: 3, lastTool: "Edit" },
+        ];
+        expect(foldOf("fan out", events).at(-1)?.tools).toEqual([
+            {
+                id: "call-9",
+                name: "mcp__subagents__spawn",
+                category: "other",
+                status: "completed",
+                content: [{ type: "text", text: '{"ok":true,"child":"sub-brave-otter"}' }],
+                subagent: {
+                    id: "sub-brave-otter",
+                    kind: "spawned",
+                    agentType: "Codex",
+                    description: "Port the parser",
+                    provider: "codex",
+                    background: true,
+                    status: "running",
+                    summary: "Waiting for memory.",
+                    toolUses: 3,
+                    lastTool: "Edit",
+                },
+            },
+        ]);
+    });
+
+    // The shell door prints the new id on its first line, so a runtime with no spawn tool of its own gets the same card.
+    it("puts a subagent spawned from the shell on its command's card", () => {
+        const events: AgentEvent[] = [
+            { kind: "subagent", id: "sub-quiet-fox", subagentKind: "spawned", agentType: "Grok", description: "Draft the docs" },
+            { kind: "tool_call", id: "b1", name: "Bash", category: "execute", status: "in_progress", target: "agents spawn --provider grok --model grok-4 'Draft the docs'" },
+            { kind: "tool_call_update", id: "b1", status: "completed", content: [{ type: "text", text: "sub-quiet-fox\nStarted." }] },
+            { kind: "subagent_update", id: "sub-quiet-fox", status: "completed", summary: "Drafted." },
+        ];
+        expect(foldOf("fan out", events).at(-1)?.tools?.[0]?.subagent).toEqual({
+            id: "sub-quiet-fox",
+            kind: "spawned",
+            agentType: "Grok",
+            description: "Draft the docs",
+            status: "completed",
+            summary: "Drafted.",
+        });
+    });
+
+    // Parallel spawns answer in any order; each card takes the one its own result names, and a card holds one subagent.
+    it("keeps each of several spawned subagents on its own card", () => {
+        const events: AgentEvent[] = [
+            { kind: "tool_call", id: "s1", name: "mcp__subagents__spawn", category: "other", status: "in_progress" },
+            { kind: "tool_call", id: "s2", name: "mcp__subagents__spawn", category: "other", status: "in_progress" },
+            { kind: "subagent", id: "sub-a", subagentKind: "spawned", description: "A" },
+            { kind: "subagent", id: "sub-b", subagentKind: "spawned", description: "B" },
+            { kind: "tool_call_update", id: "s2", status: "completed", content: [{ type: "text", text: '{"ok":true,"child":"sub-b"}' }] },
+            { kind: "tool_call_update", id: "s1", status: "completed", content: [{ type: "text", text: '{"ok":true,"child":"sub-a"}' }] },
+            { kind: "tool_call", id: "w1", name: "mcp__subagents__wait", category: "other", status: "in_progress" },
+            { kind: "tool_call_update", id: "w1", status: "completed", content: [{ type: "text", text: '{"agent":{"id":"sub-a"},"also":"sub-b"}' }] },
+        ];
+        const tools = foldOf("fan out", events).at(-1)?.tools ?? [];
+        expect(tools.map((tool) => [tool.id, tool.subagent?.id, tool.subagent?.description])).toEqual([
+            ["s1", "sub-a", "A"],
+            ["s2", "sub-b", "B"],
+            ["w1", undefined, undefined],
+        ]);
+    });
+
+    // An in-process subagent heard a beat before its call still lands on that call, under the call's own id.
+    it("holds a subagent heard before its card until the card appears", () => {
+        const events: AgentEvent[] = [
+            { kind: "subagent", id: "task-2", subagentKind: "subagent", agentType: "Explore" },
+            { kind: "tool_call", id: "task-2", name: "Agent", category: "other", status: "in_progress" },
+        ];
+        expect(foldOf("delegate", events).at(-1)?.tools?.[0]?.subagent).toEqual({ kind: "subagent", agentType: "Explore", status: "running" });
+    });
+
+    // Live, the card's claim goes out as the patch of the result that made it, so a watching window draws the same card.
+    it("sends a spawned subagent's placement as the claiming card's own patch", () => {
+        const fold = new TranscriptFold(openingOf("fan out"));
+        fold.apply({ kind: "tool_call", id: "call-9", name: "mcp__subagents__spawn", category: "other", status: "in_progress" });
+        expect(fold.apply({ kind: "subagent", id: "sub-x", subagentKind: "spawned", description: "Port" })).toEqual([]);
+        const [patch] = fold.apply({ kind: "tool_call_update", id: "call-9", status: "completed", content: [{ type: "text", text: "sub-x" }] });
+        expect(patch).toEqual({
+            op: "tool",
+            index: 1,
+            tool: {
+                id: "call-9",
+                name: "mcp__subagents__spawn",
+                category: "other",
+                status: "completed",
+                content: [{ type: "text", text: "sub-x" }],
+                subagent: { id: "sub-x", kind: "spawned", description: "Port", status: "running" },
+            },
+        });
+        expect(fold.apply({ kind: "subagent_update", id: "sub-x", status: "blocked", summary: "Which port?" })).toEqual([
+            {
+                op: "tool",
+                index: 1,
+                tool: expect.objectContaining({ subagent: { id: "sub-x", kind: "spawned", description: "Port", status: "blocked", summary: "Which port?" } }),
+            },
+        ]);
+    });
+
     it("drops a subagent's frames when the card that spawned them is absent", () => {
         const events: AgentEvent[] = [
             { kind: "delta", text: "delegating" },

package/src/text/transcript-fold.ts

@@ -20,6 +20,11 @@ import { unspokenPromptRow } from "../events/agent-words.js";
 // Folds a turn's frames into rows once, live and for the settled record alike, so a reopened chat matches what was on
 // screen. `tag` selects the stream read: undefined is the main turn, a tool-call id is the subagent it spawned; other
 // frames nest under the card that spawned them. Rows mutate in place; every patch carries a copy of what it names.
+//
+// Every subagent lands on the card of the call that started it, whichever mechanism started it. An in-process one (the
+// runtime's own Agent/Task tool) is named by that call's id, so its card is found at once. A spawned one is named by its
+// own conversation id, and every door that spawns one answers with that id (the spawn tool's `child`, the `agents
+// spawn` CLI's first line), so its frames wait until a card's result names it, then ride that card from there on.
 
 export type TurnEnding = "settled" | "stopped";
 
@@ -40,6 +45,13 @@ const defined = <T extends object>(value: T): Partial<T> =>
 // A card's own fields: what a `tool` patch carries, so a delegation's growing subtree never rides one.
 const ownFields = ({ children: _children, thinking: _thinking, ...own }: TranscriptTool): TranscriptTool => own;
 
+// Everything a card's result said, as one string: what a subagent waiting for its card is looked for in.
+const resultWords = (tool: TranscriptTool): string =>
+    (tool.content ?? [])
+        .filter((entry) => entry.type === "text")
+        .map((entry) => entry.text)
+        .join("\n");
+
 const cardOf = (event: Extract<AgentEvent, { kind: "tool_call" }>): TranscriptTool => ({
     id: event.id,
     name: event.name,
@@ -212,6 +224,11 @@ export class TranscriptFold {
     // Index of the open assistant bubble; always the last row, since every other row kind closes it first.
     private bubble: number | undefined;
     private readonly cards = new Map<string, CardPlace>();
+    // A subagent's own id to the card of the call that started it, once that card is known.
+    private readonly placed = new Map<string, string>();
+    // A subagent heard before its card: born, and perhaps already moving, while the call that started it had not yet
+    // said its id. Placed as soon as a card claims it; dropped with the fold if none ever does.
+    private readonly unplaced = new Map<string, TranscriptSubagent>();
     // requestId to the row holding its card, for frames landing on it later (a reply, a late sentence, a receipt).
     private readonly parked = new Map<string, number>();
     // The turn's opening user row, where the checkpoint and daemon notes land; cleared once `retract` takes it back.
@@ -266,6 +283,7 @@ export class TranscriptFold {
                 const row = this.rows[index]!;
                 row.tools = [...(row.tools ?? []), tool];
                 this.cards.set(tool.id, { tool, row: index });
+                this.claimById(tool);
                 return [...opened, { op: "tool", index, tool: structuredClone(tool) }];
             }
             case "tool_call_update":
@@ -276,27 +294,16 @@ export class TranscriptFold {
                     }
                     if (event.content !== undefined) {
                         tool.content = event.content;
+                        this.claimByResult(tool);
                     }
                     if (event.locations !== undefined) {
                         tool.locations = event.locations;
                     }
                 });
-            case "subagent": {
-                // The frame's id is the spawning call's id, so the subagent record lands on that card.
-                const { kind: _kind, id, subagentKind, ...rest } = event;
-                return this.patchCard(id, (tool) => {
-                    tool.subagent = { ...rest, kind: subagentKind, status: "running" };
-                });
-            }
-            case "subagent_update": {
-                // Present fields replace, absent ones leave the child alone, as in tool_call_update.
-                const { kind: _kind, id, ...patch } = event;
-                return this.patchCard(id, (tool) => {
-                    if (tool.subagent !== undefined) {
-                        tool.subagent = { ...tool.subagent, ...(defined(patch) as Partial<TranscriptSubagent>) };
-                    }
-                });
-            }
+            case "subagent":
+                return this.subagentBorn(event);
+            case "subagent_update":
+                return this.subagentMoved(event);
             case "todos": {
                 const [index, opened] = this.open();
                 this.rows[index]!.todos = [...event.items];
@@ -561,11 +568,83 @@ export class TranscriptFold {
             const child = cardOf(event);
             place.tool.children = [...(place.tool.children ?? []), child];
             this.cards.set(child.id, { tool: child, row: place.row, parent });
+            this.claimById(child);
             return [{ op: "tool", index: place.row, tool: structuredClone(child), parent }];
         }
         return [];
     }
 
+    // A subagent starts: on its card when that is known, else held until a card claims it. A later birth under the same
+    // id (a follow-up turn of the same subagent) starts its card's state over.
+    private subagentBorn(event: Extract<AgentEvent, { kind: "subagent" }>): TranscriptPatch[] {
+        const { kind: _kind, id, subagentKind, ...rest } = event;
+        const born: TranscriptSubagent = { ...rest, kind: subagentKind, status: "running" };
+        const card = this.cardOfSubagent(id);
+        if (card === undefined) {
+            this.unplaced.set(id, born);
+            return [];
+        }
+        return this.patchCard(card, (tool) => this.place(tool, id, born));
+    }
+
+    // A subagent moves: present fields replace, absent ones leave it alone, as in tool_call_update; one still waiting for
+    // its card moves where it waits.
+    private subagentMoved(event: Extract<AgentEvent, { kind: "subagent_update" }>): TranscriptPatch[] {
+        const { kind: _kind, id, ...patch } = event;
+        const moved = defined(patch) as Partial<TranscriptSubagent>;
+        const card = this.cardOfSubagent(id);
+        if (card !== undefined) {
+            return this.patchCard(card, (tool) => {
+                if (tool.subagent !== undefined) {
+                    tool.subagent = { ...tool.subagent, ...moved };
+                }
+            });
+        }
+        const waiting = this.unplaced.get(id);
+        if (waiting !== undefined) {
+            this.unplaced.set(id, { ...waiting, ...moved });
+        }
+        return [];
+    }
+
+    // The card a subagent's frames land on: the one already carrying it, else the one sharing its id (an in-process
+    // subagent is named by the call that started it); undefined while the call that started it has not yet named it.
+    private cardOfSubagent(id: string): string | undefined {
+        return this.placed.get(id) ?? (this.cards.has(id) ? id : undefined);
+    }
+
+    // Puts a subagent on the card that started it. Its own id rides along only where it differs from the card's, so the
+    // card can still name it to the roster, `wait` and its own page.
+    private place(tool: TranscriptTool, id: string, subagent: TranscriptSubagent): void {
+        const { id: _id, ...state } = subagent;
+        tool.subagent = id === tool.id ? state : { ...state, id };
+        this.placed.set(id, tool.id);
+        this.unplaced.delete(id);
+    }
+
+    // A card appearing under the id a subagent was already heard by: the stream said the child before the call.
+    private claimById(tool: TranscriptTool): void {
+        const waiting = this.unplaced.get(tool.id);
+        if (waiting !== undefined) {
+            this.place(tool, tool.id, waiting);
+        }
+    }
+
+    // A call whose result names a subagent still waiting for its card is the call that started it. A card carries one
+    // subagent, so one that already has its own claims nothing more.
+    private claimByResult(tool: TranscriptTool): void {
+        if (this.unplaced.size === 0 || tool.subagent !== undefined) {
+            return;
+        }
+        const words = resultWords(tool);
+        for (const [id, waiting] of this.unplaced) {
+            if (words.includes(id)) {
+                this.place(tool, id, waiting);
+                return;
+            }
+        }
+    }
+
     // Returns the bubble frames write to, opening a fresh assistant row when the last one was retired.
     private open(): [number, TranscriptPatch[]] {
         if (this.bubble !== undefined) {