@arhen/pi-core-subagent 1.3.64 → 1.3.66

package/README.md

@@ -1,7 +1,7 @@
 # @arhen/pi-core-subagent
 
 [![npm version](https://img.shields.io/npm/v/%40arhen%2Fpi-core-subagent?color=cb3837&logo=npm)](https://www.npmjs.com/package/@arhen/pi-core-subagent)
-[![CI](https://img.shields.io/github/actions/workflow/status/arhen/pi-core-subagent/ci.yml?branch=main&logo=github&label=CI)](https://github.com/arhen/pi-core-subagent/actions/workflows/ci.yml)
+[![CI](https://img.shields.io/github/actions/workflow/status/arhen/pi-extensions/pi-core-subagent.yml?branch=main&logo=github&label=CI)](https://github.com/arhen/pi-extensions/actions/workflows/pi-core-subagent.yml)
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![pi extension](https://img.shields.io/badge/pi-extension-7c3aed)](https://github.com/earendil-works/pi)
 
@@ -82,7 +82,7 @@ The dotted arrows are the whole point: a child may burn 200k tokens reading file
 
 ## Usage — the leader invents the agents
 
-Define agents inline per call, or reference a named agent file (see [Agent files](#agent-files)). Model resolution: explicit `model` → agent-file `model` (validated against the pi model registry) → the parent's current model → settings default.
+Define agents inline per call, or reference a named agent file (see [Agent files](#agent-files)). Model resolution: explicit `model` → agent-file `model` (validated against the pi model registry) → the parent's current model → settings default. Any model that is not the session model is preflight-probed; if the provider rejects it, the task falls back to the session model and the result carries a `Model:` note.
 
 ```json
 {
@@ -133,7 +133,7 @@ You are a strict API reviewer. Check auth, rate limiting, and error handling. Ci
 1. `.agents/agents/` then `.claude/agents/` then `.pi/agents/` in each directory from the task `cwd` up to the filesystem root (nearest ancestor wins).
 2. Home: `~/.agents/agents/` (single source) → `~/.claude/agents/` → `~/.pi/agents/`.
 
-Within a directory the file with the highest description-overlap score wins (≥2 shared meaningful tokens). A file `model` is validated against the pi model registry (unknown model fails the task with a catalog message). Files without a `description` frontmatter never match.
+Within a directory the file with the highest description-overlap score wins (≥2 shared meaningful tokens and ≥40% coverage of the shorter token set). A file `model` is validated against the pi model registry (unknown model fails the task with a catalog message). File bodies are capped at 64,000 characters. Files without a `description` frontmatter never match.
 
 ## Worktree isolation (write agents)
 
@@ -184,7 +184,6 @@ The call line renders the graph in §2 notation as the model types it:
 
 ```
 subagent graph 3
-  6 at a time
   wave1[api ∥ db] → gate → wave2[doc]
   api api-mapper Map every route in src/api/
   db  db-mapper Map the schema in src/db/
@@ -292,7 +291,7 @@ Background (default) + intercom — the run returns a runId immediately; you sta
 |---|---|
 | `subagent_models` | list the models a subagent task may name, each with the exact `model` value, thinking levels the runtime honors, context window, and catalog price; scoped to the session's enabled set when scoping is configured, else the full available catalogue (the output says which) |
 | `subagent` | single / `tasks` (parallel or graph via `needs`) / `chain` (`{previous}`); every run is background — returns a runId, completion notifies you; `autoAwait:true` parks the call until the run finishes and returns the final result inline; children always carry talk tools (ask/notify/mailbox); `notifyPerTask` (default true) wakes you as each task completes |
-| `subagent_status` | live per-task snapshot (non-blocking), including each child's session file path |
+| `subagent_status` | live per-task snapshot (non-blocking), including each child's session file path; call it once right after spawning — a child that died on spawn is invisible until far later otherwise |
 | `subagent_result` | full output of a run or one task |
 | `await_subagent` | block until a run finishes (optional `timeoutMs`) |
 | `reply_subagent` | answer a child's `ask_parent` question |
@@ -302,20 +301,20 @@ Background (default) + intercom — the run returns a runId immediately; you sta
 
 ### Per-task fields
 
-`agent` (name you invent — required), `task` (required), `prompt` (system prompt, optional — minimal default used), `write` (toolset, default read-only), plus optional `model` (`provider/model-id`; omitted → the leader's current session model, a matched agent file's frontmatter wins), `thinking` (validated enum: `off|minimal|low|medium|high|xhigh|max`), `tools` (explicit allowlist), `cwd`, `maxRuntimeMs`, `id`, `needs` (dependency edges — see [Graph mode](#graph-mode--needs)). Top-level only: `autoAwait`, `notifyPerTask`, `concurrency`.
+`agent` (name you invent — required), `task` (required), `prompt` (system prompt, optional — minimal default used), `write` (toolset, default read-only), plus optional `model` (`provider/model-id`; omitted → the leader's current session model, a matched agent file's frontmatter wins), `thinking` (validated enum: `off|minimal|low|medium|high|xhigh|max`), `tools` (explicit allowlist), `cwd`, `maxRuntimeMs`, `id`, `needs` (dependency edges — see [Graph mode](#graph-mode--needs)). Top-level only: `autoAwait`, `notifyPerTask`, `concurrency` (default 3, max 8). A call carries at most 16 tasks.
 
 ### Child talk tools (always on)
 
 | Tool | Meaning |
 |---|---|
 | `ask_parent` | blocking question to the leader; delivered mid-turn as a **steering** message labelled `[URGENT]` or `[not urgent]`, parent answers via `reply_subagent` |
-| `notify_parent` | one-way message to the leader |
+| `notify_parent` | one-way message to the leader; identical updates coalesce, `final: true` declares the complete report |
 | `send_agent_message` | message to a sibling subagent's mailbox (`to` = its task id, or `"leader"`) |
 | `poll_agent_messages` | drain this subagent's mailbox |
 
 > **Intercom anti-deadlock:** children are told to never block indefinitely on intercom replies — an unanswered `ask_parent` times out after 10 minutes (the child is told to proceed with best judgment), and sibling polls are capped (~5 tries) with the same fallback. Gated siblings (later waves) may not be running yet — waiting on them is the top stall cause, so children are instructed not to.
 
-> **Ask urgency:** `ask_parent` takes `urgent` (default `false`). Both variants steer into the leader's current turn so the question is never deferred to the end of a long turn. `[URGENT]` tells the leader to answer before its next step; `[not urgent]` tells it that the child keeps waiting, so it may finish its current step first. Failures steer for the same reason; completions and aborts queue as follow-ups.
+> **Ask urgency:** `ask_parent` takes `urgent` (default `false`). Both variants steer into the leader's current turn so the question is never deferred to the end of a long turn. `[URGENT]` tells the leader to answer before its next step; `[not urgent]` tells it that the child keeps waiting, so it may finish its current step first. Failures steer for the same reason. Completions, aborts, and informational updates are held in an extension outbox and delivered as follow-ups when the leader settles; a receipt confirms against the finalized leader transcript, so a report the leader already consumed (or an awaited result that already rendered the outcome) suppresses its redundant queued notice. See [docs/notification-policy.md](docs/notification-policy.md).
 
 ## Tool exposure and opt-in codemode
 
@@ -328,9 +327,12 @@ still applies Pi\'s global script-only policy; this extension does not override
 - `/subagents mode codemode` — explicitly select script-based routing (direct fallback when unavailable).
 - `/subagents mode direct` — return to legacy direct behavior.
 
-Choice is stored per session branch. New sessions/branches without a preference start direct;
-existing explicit choices remain intact. Published 1.3.63 defaulted to `auto`: this compatibility
-correction requires the corrected source/package, not a retroactive change to that npm release.
+Choice is stored globally in `~/.pi/agent/subagents-config.json` (the same file as `auto-limit`,
+written with a merge, never a clobber) and applies to every session — reload, resume, fork and tree
+navigation included. Sessions that chose a mode before the preference moved into that file keep their
+branch entry only while the config has no `mode`; the built-in default is still `direct`. Published
+1.3.63 defaulted to `auto`: this compatibility correction requires the corrected source/package, not
+a retroactive change to that npm release.
 
 ## Commands
 
@@ -375,6 +377,7 @@ The extension has no multiplexer integration and does not want one: it exposes t
 ## Context budget
 
 - Parent tools: 9 schemas with short descriptions. **No catalog, no context hook** — nothing injected per request.
+- The widget shows live work only: settled runs are pruned from it and stay reachable through `subagent_status` / `subagent_result`.
 - Background completion: 3-line notice. Full text only via `subagent_result`.
 - Children: isolated sessions; talk tools always injected; each child's prompt states its own task id and its siblings' so mailbox addressing works. Model resolution: explicit `provider/model-id` or bare id via the pi model registry → the parent's current model → settings default. Thinking levels validated against the resolved model's `thinkingLevelMap`; `subagent_models` lists the levels the runtime honors when you need a safe set.
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@arhen/pi-core-subagent",
-	"version": "1.3.64",
+	"version": "1.3.66",
 	"type": "module",
 	"description": "pi extension: fast in-process subagents with a dependency-graph scheduler (needs edges gate tasks and carry upstream output into dependent prompts), plus background runs, intercom and agent-to-agent mailbox. Leader defines agents inline.",
 	"license": "MIT",

package/src/child.ts

@@ -5,10 +5,17 @@ import type { MailboxMessage } from "./mailbox.ts";
 
 export const CHILD_TALK_TOOLS = ["ask_parent", "notify_parent", "send_agent_message", "poll_agent_messages"] as const;
 
+type ParentNotifyHandler = (
+	taskId: string,
+	message: string,
+	level: "info" | "warning" | "error",
+	final?: boolean,
+) => boolean;
+
 export interface ChildHandlers {
 	onAskParent(taskId: string, question: string, urgent: boolean): Promise<string>;
-	onNotifyParent(taskId: string, message: string, level: "info" | "warning" | "error"): void;
-	onSendMessage(taskId: string, to: string, text: string): boolean;
+	onNotifyParent: ParentNotifyHandler | ((...args: Parameters<ParentNotifyHandler>) => void);
+	onSendMessage(taskId: string, to: string, text: string, final?: boolean): boolean;
 	onPollMailbox(taskId: string): MailboxMessage[];
 }
 
@@ -45,16 +52,37 @@ export function createChildTools(taskId: string, handlers: ChildHandlers): ToolD
 			name: "notify_parent",
 			label: "Notify Parent",
 			description:
-				"Send a non-blocking message to the parent agent (a finding, a risk, a heads-up). Your run continues immediately; the parent sees it on its next turn.",
+				"Send a non-blocking update to the parent. Identical updates send once per task attempt. Set final:true only for your complete final report, as your last tool call; repeat that exact report as your final answer. A received final report suppresses redundant success follow-ups, not new results or failures.",
 			promptSnippet: "Send the parent a non-blocking update or finding.",
 			parameters: Type.Object({
 				message: Type.String({ description: "The message content for the parent" }),
 				level: Type.Optional(StringEnum(["info", "warning", "error"] as const, { default: "info" })),
+				final: Type.Optional(
+					Type.Boolean({
+						description: "Complete final report; no further tool work. Repeat this exact message as your final answer.",
+						default: false,
+					}),
+				),
 			}),
 			async execute(_toolCallId, params) {
-				const { message, level } = params as { message: string; level?: "info" | "warning" | "error" };
-				handlers.onNotifyParent(taskId, message, level ?? "info");
-				return { content: [{ type: "text" as const, text: "Sent." }], details: {} };
+				const { message, level, final } = params as {
+					message: string;
+					level?: "info" | "warning" | "error";
+					final?: boolean;
+				};
+				const submitted = handlers.onNotifyParent(taskId, message, level ?? "info", final === true) !== false;
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: submitted
+								? "Submitted to parent (or already submitted). Receipt is tracked separately."
+								: "Parent notification could not be submitted; retry or include it in your final answer.",
+						},
+					],
+					isError: !submitted,
+					details: {},
+				};
 			},
 		},
 		{
@@ -68,19 +96,42 @@ export function createChildTools(taskId: string, handlers: ChildHandlers): ToolD
 					description: "Target task id of another subagent in this run (e.g. task_2), or 'leader' for the parent agent",
 				}),
 				message: Type.String({ description: "Short message content (keep under ~500 chars)" }),
+				final: Type.Optional(
+					Type.Boolean({
+						description: "For to:leader only: complete final report, same contract as notify_parent final:true.",
+						default: false,
+					}),
+				),
 			}),
 			async execute(_toolCallId, params) {
-				const { to, message } = params as { to: string; message: string };
-				if (!handlers.onSendMessage(taskId, to, message)) {
+				const { to, message, final } = params as { to: string; message: string; final?: boolean };
+				if (!handlers.onSendMessage(taskId, to, message, final === true)) {
 					return {
 						content: [
-							{ type: "text" as const, text: `Unknown target '${to}'. Use a sibling task id in this run or 'leader'.` },
+							{
+								type: "text" as const,
+								text:
+									to === "leader"
+										? "Parent notification could not be submitted; retry or include it in your final answer."
+										: `Unknown target '${to}'. Use a sibling task id in this run or 'leader'.`,
+							},
 						],
 						isError: true,
 						details: {},
 					};
 				}
-				return { content: [{ type: "text" as const, text: "Sent." }], details: {} };
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text:
+								to === "leader"
+									? "Submitted to leader (or already submitted). Receipt is tracked separately."
+									: "Sent.",
+						},
+					],
+					details: {},
+				};
 			},
 		},
 		{

package/src/config.ts

@@ -0,0 +1,60 @@
+import { readFileSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Shared user config for the extension: exposure mode plus the auto-limit ceiling. One file, so a
+ * write of one key must never drop the other — every writer merges through `writeSubagentConfig`.
+ */
+export const SUBAGENT_CONFIG_FILENAME = "subagents-config.json";
+
+/**
+ * Presentation preference for the subagent toolset, stored globally in `subagents-config.json`.
+ * - auto: native codemode presentation when the codemode tool is active, direct otherwise.
+ * - direct (default): legacy native declarations and active-tool script callability.
+ * - codemode: subagent tools are callable from codemode scripts but not declared or listed.
+ */
+export type SubagentMode = "auto" | "direct" | "codemode";
+
+export const DEFAULT_SUBAGENT_MODE: SubagentMode = "direct";
+
+export function isSubagentMode(value: unknown): value is SubagentMode {
+	return value === "auto" || value === "direct" || value === "codemode";
+}
+
+/** Resolved per call, so a test or `PI_CODING_AGENT_DIR` override applies to the running process. */
+export function subagentConfigPath(): string {
+	return join(getAgentDir(), SUBAGENT_CONFIG_FILENAME);
+}
+
+/**
+ * Tolerant read: a missing, unreadable or non-object file degrades to an empty object, so a config
+ * typo can neither break delegation nor hide the built-in defaults.
+ */
+export function readSubagentConfig(path = subagentConfigPath()): Record<string, unknown> {
+	try {
+		const raw: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {};
+		return raw as Record<string, unknown>;
+	} catch {
+		return {};
+	}
+}
+
+/** The stored exposure mode, or undefined when the file has no usable one. */
+export function readStoredMode(path = subagentConfigPath()): SubagentMode | undefined {
+	const mode = readSubagentConfig(path).mode;
+	return isSubagentMode(mode) ? mode : undefined;
+}
+
+let writeQueue: Promise<unknown> = Promise.resolve();
+
+/** Read-modify-write on a single queue, so concurrent writers of different keys cannot clobber each other. */
+export function writeSubagentConfig(patch: Record<string, unknown>, path = subagentConfigPath()): Promise<void> {
+	const write = writeQueue.then(async () => {
+		await writeFile(path, `${JSON.stringify({ ...readSubagentConfig(path), ...patch }, null, 2)}\n`);
+	});
+	writeQueue = write.catch(() => {});
+	return write;
+}

package/src/format.ts

@@ -208,6 +208,9 @@ function worktreeLine(task: TaskSnapshot, siblings?: TaskSnapshot[]): string {
 }
 
 export function makeSummary(run: RunSnapshot): string {
+	return makeSummaryWithCoverage(run).text;
+}
+export function makeSummaryWithCoverage(run: RunSnapshot): { text: string; coveredTaskIds: Set<string> } {
 	const succeeded = run.tasks.filter((t) => t.status === "completed").length;
 	const failed = run.tasks.filter((t) => t.status === "failed").length;
 	const aborted = run.tasks.filter((t) => t.status === "aborted").length;
@@ -217,6 +220,7 @@ export function makeSummary(run: RunSnapshot): string {
 	];
 	const usage = formatUsage(run.aggregateUsage);
 	if (usage) lines.push(`Usage: ${usage}`);
+	const taskEnds = new Map<string, number>();
 	for (const task of run.tasks) {
 		const edge = task.needs?.length ? ` (${task.id}, needs ${task.needs.join(", ")})` : ` (${task.id})`;
 		const fileNote = task.agentFile ? ` [${task.agentFile}]` : "";
@@ -225,9 +229,14 @@ export function makeSummary(run: RunSnapshot): string {
 		lines.push(
 			`\n## ${task.agent}${edge}${fileNote} ${statusIcon(task.status)}${swap}${tools}${task.error ? `\nError: ${task.error}` : `\n${truncateText(task.finalText || "(no output)")}`}${worktreeLine(task, run.tasks)}`,
 		);
+		taskEnds.set(task.id, lines.join("\n").length);
 	}
 
-	return truncateText(lines.join("\n"));
+	const fullText = lines.join("\n");
+	const text = truncateText(fullText);
+	let prefix = 0;
+	while (prefix < fullText.length && prefix < text.length && fullText[prefix] === text[prefix]) prefix++;
+	return { text, coveredTaskIds: new Set([...taskEnds].filter(([, end]) => end <= prefix).map(([id]) => id)) };
 }
 export function isStartupFailure(task: TaskSnapshot, kind: string): boolean {
 	return kind === "failed" && !task.finalText?.trim();
@@ -244,7 +253,7 @@ export function makeTaskNotice(run: RunSnapshot, task: TaskSnapshot, kind: strin
 	const tools = task.toolsNote ? `\nTools: ${task.toolsNote}` : "";
 	return [
 		`Task ${task.agent} (${task.id}) ${kind} in run ${run.id}: ${detail}${wt}`,
-		`Goal: ${goal}${src}${swap}${tools}`,
+		`Goal: ${goal}${src}${swap}${tools}${task.worktreeError ? `\nWorktree: ${task.worktreeError}` : ""}`,
 		isStartupFailure(task, kind)
 			? "Never started — stop and diagnose before spawning anything else: a config-level error (model, plan, auth, agent file) fails identically on every respawn."
 			: kind === "completed"
@@ -252,6 +261,9 @@ export function makeTaskNotice(run: RunSnapshot, task: TaskSnapshot, kind: strin
 				: `Session file kept — resume_subagent({ runId: "${run.id}", taskId: "${task.id}", model?: ... }) revives it with full context. subagent_result for what it produced so far.`,
 	].join("\n");
 }
+export function makeTaskArtifactNotice(run: RunSnapshot, task: TaskSnapshot): string {
+	return `Task ${task.agent} (${task.id}) completed in run ${run.id}; result already delivered.${worktreeLine(task, run.tasks)}\nUse subagent_result({ runId: "${run.id}", taskId: "${task.id}" }) for artifacts.`;
+}
 export function makeAskNotice(
 	run: RunSnapshot,
 	extra: { taskId?: string; agent?: string; question?: string; urgent?: boolean },
@@ -263,12 +275,14 @@ export function makeAskNotice(
 		: `[not urgent] Subagent ${who} asks: ${extra.question ?? ""}\nIt waits while you keep working — finish your current step first if you want, then answer with ${reply}.`;
 }
 
-export function makeNotice(run: RunSnapshot, kind: string): string {
+export function makeNotice(run: RunSnapshot, kind: string, tasks = run.tasks): string {
 	const lines = [
 		`Background subagent run ${run.id} ${kind}: ${run.tasks.filter((t) => t.status === "completed").length}/${run.tasks.length} succeeded.`,
 	];
-	for (const task of run.tasks) {
-		lines.push(`- ${task.agent}: ${task.status}${task.error ? ` — ${truncateText(task.error, 200)}` : ""}`);
+	for (const task of tasks) {
+		lines.push(
+			`- ${task.agent}: ${task.status}${task.error ? ` — ${truncateText(task.error, 200)}` : ""}${worktreeLine(task, run.tasks)}`,
+		);
 	}
 	lines.push(`Use subagent_result({ runId: "${run.id}" }) for full output.`);
 	return lines.join("\n");

package/src/index.ts

@@ -4,7 +4,7 @@ import type { TSchema } from "typebox";
 import {
 	compactLines,
 	formatUsage,
-	makeSummary,
+	makeSummaryWithCoverage,
 	renderModelCatalog,
 	statusIcon,
 	taskLine,
@@ -29,6 +29,24 @@ import {
 import { type ModelCatalog, type RunDetails, type RunSnapshot, TERMINAL } from "./types.ts";
 import { cleanupMerged, ownerAlive, reapDeadWorktrees, repoRoot, sweepStale } from "./worktree.ts";
 
+function unreportedIntercom(run: RunSnapshot, messages: ParkedMsg[], covered: ReadonlySet<string>): ParkedMsg[] {
+	return messages.filter((message) => {
+		const task = run.tasks.find((task) => task.id === message.taskId);
+		return (
+			!covered.has(message.taskId) ||
+			task?.status !== "completed" ||
+			!(
+				message.kind === "done" ||
+				(message.kind === "notify" && message.final && task.finalText?.trim() === message.text.trim())
+			)
+		);
+	});
+}
+
+function intercomLine(message: ParkedMsg): string {
+	return `- [${message.kind === "notify" && message.final ? "final" : message.kind}] ${message.agent} (${message.taskId}): ${truncateText(message.text)}`;
+}
+
 export default function (pi: ExtensionAPI) {
 	const manager = new SubagentManager(pi);
 	const definitions: AnyToolDefinition[] = [];
@@ -74,7 +92,7 @@ export default function (pi: ExtensionAPI) {
 	};
 	pi.registerCommand("subagents", {
 		description:
-			"List subagent runs. `/subagents peek` opens the browsable pane; `/subagents mode [auto|direct|codemode]` reports or switches the tool exposure profile; `/subagents auto-limit on|off` toggles the 1 h default runtime ceiling (default off = 6 h).",
+			"List subagent runs. `/subagents peek` opens the browsable pane; `/subagents mode [auto|direct|codemode]` reports or switches the globally stored tool exposure profile; `/subagents auto-limit on|off` toggles the 1 h default runtime ceiling (default off = 6 h).",
 		handler: async (args, ctx) => {
 			const arg = String(args ?? "")
 				.trim()
@@ -127,10 +145,24 @@ export default function (pi: ExtensionAPI) {
 	pi.registerShortcut("ctrl+shift+a", { description: "Peek at running subagents", handler: openPeek });
 
 	pi.on("agent_start", (_event, ctx) => {
+		manager.noteAgentStart();
 		if (!manager.turnActivity && !manager.hasActiveRun()) manager.clearWidget(ctx);
 		manager.turnActivity = false;
 	});
 
+	pi.on("context", (_event, ctx) => {
+		manager.confirmLeaderMessages(ctx);
+	});
+	pi.on("agent_end", (_event, ctx) => {
+		manager.confirmLeaderMessages(ctx);
+		manager.scheduleNotificationFlush(ctx);
+	});
+	// Settlement is the last automatic boundary: anything still held (a busy flush stopped earlier)
+	// must be released here, and receipts confirmed against the finalized projection.
+	pi.on("agent_settled", (_event, ctx) => {
+		manager.confirmLeaderMessages(ctx);
+		manager.flushPendingNotifications(ctx);
+	});
 	pi.on("before_agent_start", () => {
 		presentation.sync();
 	});
@@ -226,13 +258,15 @@ export default function (pi: ExtensionAPI) {
 					if (awaited.intercom.some((m) => m.kind === "ask")) break;
 				}
 
+				const summary = makeSummaryWithCoverage(run);
+				manager.markAwaitCoverage(run, summary.coveredTaskIds);
 				const asks = intercom.filter((m) => m.kind === "ask");
-				const heard = intercom.filter((m) => m.kind !== "ask");
+				const heard = unreportedIntercom(run, intercom, summary.coveredTaskIds).filter(
+					(message) => message.kind !== "ask",
+				);
 				const text = [
-					makeSummary(run),
-					heard.length > 0
-						? `\nIntercom while waiting:\n${heard.map((m) => `- [${m.kind}] ${m.agent} (${m.taskId}): ${truncateText(m.text)}`).join("\n")}`
-						: "",
+					summary.text,
+					heard.length > 0 ? `\nIntercom while waiting:\n${heard.map(intercomLine).join("\n")}` : "",
 					asks.length > 0
 						? `\n${asks.length} child(ren) waiting for your answer:\n${asks
 								.map(
@@ -384,13 +418,11 @@ export default function (pi: ExtensionAPI) {
 			if (!awaited) return { content: [{ type: "text", text: `Unknown runId: ${runId}` }], isError: true, details: {} };
 			const { run, intercom } = awaited;
 			if (!run) return { content: [{ type: "text", text: `Unknown runId: ${runId}` }], isError: true, details: {} };
-			const intercomText =
-				intercom.length > 0
-					? `\n\nIntercom while waiting:\n${intercom
-							.map((m) => `- [${m.kind}] ${m.agent} (${m.taskId}): ${truncateText(m.text)}`)
-							.join("\n")}`
-					: "";
-			return { content: [{ type: "text", text: makeSummary(run) + intercomText }], details: { run } };
+			const summary = makeSummaryWithCoverage(run);
+			manager.markAwaitCoverage(run, summary.coveredTaskIds);
+			const heard = unreportedIntercom(run, intercom, summary.coveredTaskIds);
+			const intercomText = heard.length > 0 ? `\n\nIntercom while waiting:\n${heard.map(intercomLine).join("\n")}` : "";
+			return { content: [{ type: "text", text: summary.text + intercomText }], details: { run } };
 		},
 	});