@gajae-code/coding-agent 0.4.2 → 0.4.4

package/src/tools/browser/actions.ts

@@ -0,0 +1,189 @@
+/**
+ * Structured browser action space.
+ *
+ * Adapts the SOTA computer-use / browser-use pattern: instead of authoring raw
+ * JavaScript for every interaction, the model emits a list of structured verbs
+ * (navigate / click / type / …) that reference elements by the numeric `id`
+ * returned from {@link Observation}. Each verb is compiled onto the existing
+ * in-tab `tab.*` helpers and executed through the same worker `run` path, so the
+ * worker protocol is unchanged and the raw-JS `run` escape hatch still works.
+ */
+
+export type BrowserActionVerb =
+	| "navigate"
+	| "click"
+	| "type"
+	| "fill"
+	| "select"
+	| "press"
+	| "scroll"
+	| "back"
+	| "wait"
+	| "observe"
+	| "extract"
+	| "screenshot";
+
+export interface BrowserActionStep {
+	verb: BrowserActionVerb;
+	/** Element id from a prior `observe` (preferred for click/type). */
+	id?: number;
+	/** CSS / puppeteer selector when not addressing by `id`. */
+	selector?: string;
+	/** Text to type. */
+	text?: string;
+	/** Value for `fill`. */
+	value?: string;
+	/** Option value(s) for `select`. */
+	values?: string[];
+	/** URL for `navigate`. */
+	url?: string;
+	/** Key for `press` (e.g. "Enter"). */
+	key?: string;
+	/** Horizontal scroll delta. */
+	dx?: number;
+	/** Vertical scroll delta. */
+	dy?: number;
+	/** Sleep duration for `wait` when no selector is given. */
+	ms?: number;
+	/** Extract format. */
+	format?: "markdown" | "text" | "html";
+	/** Navigation wait condition for `navigate`. */
+	wait_until?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+	/** Only return interactive/viewport elements for `observe`. */
+	viewport_only?: boolean;
+	include_all?: boolean;
+}
+
+const VERBS: ReadonlySet<BrowserActionVerb> = new Set([
+	"navigate",
+	"click",
+	"type",
+	"fill",
+	"select",
+	"press",
+	"scroll",
+	"back",
+	"wait",
+	"observe",
+	"extract",
+	"screenshot",
+]);
+
+/**
+ * Validate a single step's required fields. Returns an error string, or
+ * `undefined` when the step is well-formed.
+ */
+export function validateActionStep(step: BrowserActionStep, index: number): string | undefined {
+	const where = `actions[${index}] (${step.verb})`;
+	if (!VERBS.has(step.verb)) return `${where}: unknown verb`;
+	switch (step.verb) {
+		case "navigate":
+			if (!step.url?.trim()) return `${where}: 'url' is required`;
+			return undefined;
+		case "click":
+			if (step.id === undefined && !step.selector?.trim()) return `${where}: 'id' or 'selector' is required`;
+			return undefined;
+		case "type":
+			if (step.id === undefined && !step.selector?.trim()) return `${where}: 'id' or 'selector' is required`;
+			if (step.text === undefined) return `${where}: 'text' is required`;
+			return undefined;
+		case "fill":
+			if (!step.selector?.trim()) return `${where}: 'selector' is required`;
+			if (step.value === undefined) return `${where}: 'value' is required`;
+			return undefined;
+		case "select":
+			if (!step.selector?.trim()) return `${where}: 'selector' is required`;
+			if (!step.values?.length) return `${where}: 'values' is required`;
+			return undefined;
+		case "press":
+			if (!step.key?.trim()) return `${where}: 'key' is required`;
+			return undefined;
+		case "scroll":
+			if (step.dx === undefined && step.dy === undefined) return `${where}: 'dx' or 'dy' is required`;
+			return undefined;
+		case "wait":
+			if (!step.selector?.trim() && step.ms === undefined) return `${where}: 'selector' or 'ms' is required`;
+			return undefined;
+		default:
+			// back / observe / extract / screenshot take no required fields
+			return undefined;
+	}
+}
+
+/** Validate the full step list. Throws on the first invalid step. */
+export function validateActionSteps(steps: readonly BrowserActionStep[]): void {
+	if (steps.length === 0) throw new Error("browser 'act' requires a non-empty 'actions' list");
+	for (let i = 0; i < steps.length; i += 1) {
+		const error = validateActionStep(steps[i]!, i);
+		if (error) throw new Error(error);
+	}
+}
+
+/**
+ * Compile structured steps into a JS program for the in-tab `run` worker. Steps
+ * are embedded as parsed JSON (no string interpolation, so values cannot inject
+ * code) and dispatched by a fixed interpreter against the `tab` / `page` helpers.
+ */
+export function compileActionSteps(steps: readonly BrowserActionStep[]): string {
+	validateActionSteps(steps);
+	const stepsLiteral = JSON.stringify(JSON.stringify(steps));
+	return `
+const __steps = JSON.parse(${stepsLiteral});
+const __results = [];
+for (const s of __steps) {
+	switch (s.verb) {
+		case "navigate":
+			await tab.goto(s.url, s.wait_until ? { waitUntil: s.wait_until } : undefined);
+			__results.push({ verb: "navigate", url: s.url });
+			break;
+		case "click":
+			if (s.id !== undefined && s.id !== null) { await (await tab.id(s.id)).click(); }
+			else { await tab.click(s.selector); }
+			__results.push({ verb: "click", id: s.id ?? null, selector: s.selector ?? null });
+			break;
+		case "type":
+			if (s.id !== undefined && s.id !== null) { await (await tab.id(s.id)).type(s.text); }
+			else { await tab.type(s.selector, s.text); }
+			__results.push({ verb: "type", id: s.id ?? null, selector: s.selector ?? null });
+			break;
+		case "fill":
+			await tab.fill(s.selector, s.value);
+			__results.push({ verb: "fill", selector: s.selector });
+			break;
+		case "select":
+			__results.push({ verb: "select", selected: await tab.select(s.selector, ...(s.values || [])) });
+			break;
+		case "press":
+			await tab.press(s.key, s.selector ? { selector: s.selector } : undefined);
+			__results.push({ verb: "press", key: s.key });
+			break;
+		case "scroll":
+			await tab.scroll(s.dx || 0, s.dy || 0);
+			__results.push({ verb: "scroll", dx: s.dx || 0, dy: s.dy || 0 });
+			break;
+		case "back":
+			await page.goBack();
+			__results.push({ verb: "back" });
+			break;
+		case "wait":
+			if (s.selector) { await tab.waitFor(s.selector); }
+			else { await new Promise(r => setTimeout(r, s.ms)); }
+			__results.push({ verb: "wait", selector: s.selector ?? null, ms: s.ms ?? null });
+			break;
+		case "observe":
+			__results.push({ verb: "observe", observation: await tab.observe({ viewportOnly: s.viewport_only === true, includeAll: s.include_all === true }) });
+			break;
+		case "extract":
+			__results.push({ verb: "extract", content: await tab.extract(s.format || "markdown") });
+			break;
+		case "screenshot":
+			await tab.screenshot({});
+			__results.push({ verb: "screenshot" });
+			break;
+		default:
+			throw new Error("Unknown browser action verb: " + s.verb);
+	}
+}
+return __results;
+`;
+}

package/src/tools/browser.ts

@@ -3,6 +3,7 @@ import { prompt, untilAborted } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
+import { type BrowserActionStep, compileActionSteps } from "./browser/actions";
 import { acquireBrowser, type BrowserHandle, type BrowserKind, type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import { acquireTab, dropHeadlessTabs, getTab, releaseAllTabs, releaseTab, runInTab } from "./browser/tab-supervisor";
@@ -24,8 +25,44 @@ const appSchema = z.object({
 	target: z.string().describe("substring to pick a window").optional(),
 });
 
+const actionStepSchema = z.object({
+	verb: z
+		.enum([
+			"navigate",
+			"click",
+			"type",
+			"fill",
+			"select",
+			"press",
+			"scroll",
+			"back",
+			"wait",
+			"observe",
+			"extract",
+			"screenshot",
+		])
+		.describe("structured action verb"),
+	id: z.number().describe("element id from a prior observe").optional(),
+	selector: z.string().describe("css/puppeteer selector").optional(),
+	text: z.string().describe("text to type").optional(),
+	value: z.string().describe("value for fill").optional(),
+	values: z.array(z.string()).describe("option value(s) for select").optional(),
+	url: z.string().describe("url for navigate").optional(),
+	key: z.string().describe("key for press, e.g. Enter").optional(),
+	dx: z.number().describe("horizontal scroll delta").optional(),
+	dy: z.number().describe("vertical scroll delta").optional(),
+	ms: z.number().describe("sleep ms for wait without selector").optional(),
+	format: z.enum(["markdown", "text", "html"]).describe("extract format").optional(),
+	wait_until: z
+		.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"])
+		.describe("navigation wait condition for navigate")
+		.optional(),
+	viewport_only: z.boolean().describe("observe: only viewport elements").optional(),
+	include_all: z.boolean().describe("observe: include non-interactive elements").optional(),
+});
+
 const browserSchema = z.object({
-	action: z.enum(["open", "close", "run"] as const).describe("operation"),
+	action: z.enum(["open", "close", "run", "act"] as const).describe("operation"),
 	name: z.string().describe("tab id (default 'main')").optional(),
 	url: z.string().describe("url to open").optional(),
 	app: appSchema.optional(),
@@ -45,6 +82,7 @@ const browserSchema = z.object({
 		.describe("auto-handle dialogs")
 		.optional(),
 	code: z.string().describe("js body to run in tab").optional(),
+	actions: z.array(actionStepSchema).describe("structured action steps for action 'act'").optional(),
 	timeout: z.number().default(30).describe("timeout in seconds (default 30, max 300)").optional(),
 	all: z.boolean().describe("close every tab").optional(),
 	kill: z.boolean().describe("also kill spawned-app browsers").optional(),
@@ -126,6 +164,8 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 					return await this.#close(name, params, details, signal);
 				case "run":
 					return await this.#run(name, params, details, timeoutMs, signal);
+				case "act":
+					return await this.#act(name, params, details, timeoutMs, signal);
 				default:
 					throw new ToolError(`Unsupported action: ${(params as BrowserParams).action}`);
 			}
@@ -259,6 +299,56 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		details.result = textOnly;
 		return toolResult(details).content(content).done();
 	}
+
+	async #act(
+		name: string,
+		params: BrowserParams,
+		details: BrowserToolDetails,
+		timeoutMs: number,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<BrowserToolDetails>> {
+		const steps = (params.actions ?? []) as BrowserActionStep[];
+		if (steps.length === 0) {
+			throw new ToolError("Missing required parameter 'actions' for action 'act'.");
+		}
+		const tab = getTab(name);
+		if (!tab) {
+			throw new ToolError(`No tab named ${JSON.stringify(name)}. Open it first with action 'open'.`);
+		}
+		details.browser = tab.browser.kind.kind;
+		details.url = tab.info.url;
+
+		// compileActionSteps validates each step and produces injection-safe code
+		// (steps embedded as parsed JSON) for the existing in-tab run worker.
+		let code: string;
+		try {
+			code = compileActionSteps(steps);
+		} catch (error) {
+			throw new ToolError(error instanceof Error ? error.message : String(error));
+		}
+
+		const { displays, returnValue, screenshots } = await runInTab(name, {
+			code,
+			timeoutMs,
+			signal,
+			session: this.session,
+		});
+
+		if (screenshots.length) details.screenshots = screenshots;
+		const content = [...displays];
+		if (returnValue !== undefined) {
+			content.push({ type: "text", text: stringifyReturnValue(returnValue) });
+		}
+		if (!content.length) {
+			content.push({ type: "text", text: `Ran ${steps.length} action(s) on tab ${JSON.stringify(name)}` });
+		}
+		const textOnly = content
+			.filter((c): c is { type: "text"; text: string } => c.type === "text")
+			.map(c => c.text)
+			.join("\n");
+		details.result = textOnly;
+		return toolResult(details).content(content).done();
+	}
 }
 
 function describeBrowser(handle: BrowserHandle): string {

package/src/tools/image-gen.ts

@@ -401,23 +401,39 @@ export function setPreferredImageProvider(provider: ImageProvider | "auto"): voi
 
 interface ParsedAntigravityCredentials {
 	accessToken: string;
-	projectId: string;
+	projectId?: string;
 }
 
 function parseAntigravityCredentials(raw: string): ParsedAntigravityCredentials | null {
 	try {
-		const parsed = JSON.parse(raw) as { token?: string; projectId?: string };
-		if (parsed.token && parsed.projectId) {
-			return { accessToken: parsed.token, projectId: parsed.projectId };
+		const parsed = JSON.parse(raw) as { token?: string; accessToken?: string; projectId?: string };
+		const token = parsed.token ?? parsed.accessToken;
+		if (typeof token === "string" && token.trim().length > 0) {
+			return { accessToken: token.trim(), projectId: parsed.projectId };
 		}
+		// Parsed as JSON but no usable token field.
+		return null;
 	} catch {
-		// Invalid JSON
+		// Not JSON: treat the value as a raw bearer token.
 	}
-	return null;
+	const rawToken = raw.trim();
+	return rawToken.length > 0 ? { accessToken: rawToken } : null;
 }
 
-async function findAntigravityCredentials(modelRegistry: ModelRegistry): Promise<ImageApiKey | null> {
-	const apiKey = await modelRegistry.getApiKeyForProvider("google-antigravity");
+async function findAntigravityCredentials(
+	modelRegistry: ModelRegistry,
+	sessionId?: string,
+): Promise<ImageApiKey | null> {
+	const oauthAccess = await modelRegistry.authStorage.getOAuthAccess("google-antigravity", sessionId);
+	if (oauthAccess?.accessToken) {
+		return {
+			provider: "antigravity",
+			apiKey: oauthAccess.accessToken,
+			projectId: oauthAccess.projectId,
+		};
+	}
+
+	const apiKey = await modelRegistry.getApiKeyForProvider("google-antigravity", sessionId);
 	if (!apiKey) return null;
 
 	const parsed = parseAntigravityCredentials(apiKey);
@@ -457,7 +473,7 @@ async function findImageApiKey(
 		if (openAI) return openAI;
 		// Fall through to auto-detect if preferred provider key not found.
 	} else if (preferredImageProvider === "antigravity" && modelRegistry) {
-		const antigravity = await findAntigravityCredentials(modelRegistry);
+		const antigravity = await findAntigravityCredentials(modelRegistry, sessionId);
 		if (antigravity) return antigravity;
 		// Fall through to auto-detect if preferred provider key not found.
 	} else if (preferredImageProvider === "gemini") {
@@ -477,7 +493,7 @@ async function findImageApiKey(
 	if (openAI) return openAI;
 
 	if (modelRegistry) {
-		const antigravity = await findAntigravityCredentials(modelRegistry);
+		const antigravity = await findAntigravityCredentials(modelRegistry, sessionId);
 		if (antigravity) return antigravity;
 	}
 
@@ -589,12 +605,21 @@ function collectInlineImages(parts: GeminiPart[]): InlineImageData[] {
 	return images;
 }
 
-function isOpenAIHostedImageModel(model: Model | undefined): model is Model {
+export function isOpenAIHostedImageModel(model: Model | undefined): model is Model {
 	if (!model) return false;
-	if (model.provider !== "openai" && model.provider !== "openai-codex") return false;
+	// The hosted image_generation tool is only available over the Responses API.
 	if (model.api !== "openai-responses" && model.api !== "openai-codex-responses") return false;
-	const modelId = model.id.toLowerCase();
-	return modelId.startsWith("gpt-") || modelId === "o3" || modelId.startsWith("o3-");
+	// Declarative capability: any provider (e.g. an OpenAI-compatible proxy
+	// fronting gpt-image) whose model advertises image output can drive
+	// generate_image, routed to the model's own baseUrl with registry auth.
+	if (model.output?.includes("image")) return true;
+	// First-party heuristic: OpenAI/OpenAI code GPT and o3 models generate
+	// images inline through the hosted tool without a declared output modality.
+	if (model.provider === "openai" || model.provider === "openai-codex") {
+		const modelId = model.id.toLowerCase();
+		return modelId.startsWith("gpt-") || modelId === "o3" || modelId.startsWith("o3-");
+	}
+	return false;
 }
 
 function getOpenAIHostedImageProvider(model: Model): ImageProvider {
@@ -995,7 +1020,9 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 
 			if (provider === "antigravity") {
 				if (!apiKey.projectId) {
-					throw new Error("Missing projectId in antigravity credentials");
+					throw new Error(
+						"Antigravity image generation requires a projectId, but the stored google-antigravity credential only contains an access token. Run the google-antigravity login flow again so the projectId is stored, then retry.",
+					);
 				}
 
 				const prompt = assemblePrompt(params);

package/src/tools/index.ts

@@ -13,7 +13,11 @@ import { LspTool } from "../lsp";
 import type { WorkflowGateEmitter } from "../modes/shared/agent-wire/unattended-session";
 import type { PlanModeState } from "../plan-mode/state";
 import type { AgentRegistry } from "../registry/agent-registry";
-import type { ForkContextSeed, ForkContextSeedOptions } from "../session/agent-session";
+import type {
+	ForkContextSeed,
+	ForkContextSeedOptions,
+	PurgeQueuedCustomMessagesResult,
+} from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { ClientBridge } from "../session/client-bridge";
 import type { CustomMessage } from "../session/messages";
@@ -162,6 +166,8 @@ export interface ToolSession {
 	/** Agent identity used for IRC routing. Returns the registry id (e.g. "0-Main", "0-AuthLoader"). */
 	getAgentId?: () => string | null;
 	/** Look up a registered tool by name (used by the eval js backend's tool bridge). */
+	/** Purge undelivered queued custom messages matching the predicate. Returns counts. */
+	purgeQueuedCustomMessages?: (predicate: (message: CustomMessage) => boolean) => PurgeQueuedCustomMessagesResult;
 	getToolByName?: (name: string) => AgentTool | undefined;
 	/** Agent registry for IRC routing across live sessions. */
 	agentRegistry?: AgentRegistry;

package/src/tools/inspect-image.ts

@@ -78,19 +78,21 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 		};
 
 		const activeModelPattern = this.session.getActiveModelString?.() ?? this.session.getModelString?.();
-		const model =
-			resolvePattern("pi/vision") ??
-			resolvePattern("pi/default") ??
-			resolvePattern(activeModelPattern) ??
-			availableModels[0];
+		let model = resolvePattern("pi/default") ?? resolvePattern(activeModelPattern) ?? availableModels[0];
 		if (!model) {
 			throw new ToolError("Unable to resolve a model for inspect_image.");
 		}
 
+		// inspect_image requires image input; if the resolved model is text-only,
+		// fall back to any available vision-capable model before failing.
 		if (!model.input.includes("image")) {
-			throw new ToolError(
-				`Resolved model ${model.provider}/${model.id} does not support image input. Configure a vision-capable model for modelRoles.vision.`,
-			);
+			const visionModel = availableModels.find(candidate => candidate.input.includes("image"));
+			if (!visionModel) {
+				throw new ToolError(
+					`Resolved model ${model.provider}/${model.id} does not support image input, and no vision-capable model is available. Configure a vision-capable model.`,
+				);
+			}
+			model = visionModel;
 		}
 
 		const apiKey = await modelRegistry.getApiKey(model);

package/src/tools/job.ts

@@ -52,7 +52,7 @@ interface JobSnapshot {
 	errorText?: string;
 }
 
-type CancelStatus = "cancelled" | "not_found" | "already_completed";
+type CancelStatus = "cancelled" | "not_found" | "already_completed" | "already_cancelled";
 
 interface CancelOutcome {
 	id: string;
@@ -115,10 +115,20 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 		for (const id of cancelIds) {
 			const existing = manager.getJob(id);
 			if (!existing || (ownerId && existing.ownerId !== ownerId)) {
-				cancelOutcomes.push({ id, status: "not_found", message: `Background job not found: ${id}` });
+				const tombstone = manager.purgeMonitorTombstone(id, ownerFilter);
+				cancelOutcomes.push(
+					tombstone.found
+						? {
+								id,
+								status: tombstone.status === "cancelled" ? "already_cancelled" : "already_completed",
+								message: `Monitor job ${id} already gone; purged queued notifications.`,
+							}
+						: { id, status: "not_found", message: `Background job not found: ${id}` },
+				);
 				continue;
 			}
 			if (existing.status !== "running") {
+				if (existing.metadata?.monitor) manager.purgeMonitorTombstone(id, ownerFilter);
 				cancelOutcomes.push({
 					id,
 					status: "already_completed",

package/src/tools/monitor.ts

@@ -47,6 +47,7 @@ export interface MonitorToolDetails {
 }
 
 const MONITOR_LABEL_MAX = 120;
+const MAX_PENDING_MONITOR_NOTIFICATIONS = 3;
 
 function buildMonitorLabel(params: MonitorParams): string {
 	const base = `[monitor:${params.kind}] ${params.description}`;
@@ -89,36 +90,116 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 		const ownerId = this.session.getAgentId?.() ?? undefined;
 		const bash = new BashTool(this.session);
 		let deliveredFirstLine = false;
+		const controller = { closed: false };
+		let currentJobId = "";
+		let sequence = 0;
+		let latestLine: string | undefined;
+		let coalescedCount = 0;
+		let flushScheduled = false;
+		// Count of notification *sends* (not live queue depth): once it exceeds the
+		// cap, each new send first purges older queued notifications for this task,
+		// keeping the queue bounded and latest-biased.
+		let pendingNotifications = 0;
+		const isMonitorMessage = (message: { customType?: string; details?: unknown }) =>
+			message.customType === "task-notification" &&
+			(message.details as { taskId?: string } | undefined)?.taskId === currentJobId;
+		const flushLatest = () => {
+			if (!persistent || latestLine === undefined) return;
+			const line = latestLine;
+			const count = coalescedCount;
+			latestLine = undefined;
+			coalescedCount = 0;
+			flushScheduled = false;
+			sendNotification(line, currentJobId, count);
+		};
+		const closeMonitor = (mode: "purge" | "flush") => {
+			// "flush" (natural process exit): deliver the newest pending line so the
+			// final state is never lost, then stop. "purge" (explicit cancel / registry
+			// eviction): drop the queued backlog. Non-persistent monitors keep their one
+			// notification, so they never purge.
+			if (mode === "flush") {
+				flushLatest();
+				controller.closed = true;
+				return;
+			}
+			controller.closed = true;
+			if (!persistent) return;
+			return this.session.purgeQueuedCustomMessages?.(isMonitorMessage);
+		};
+		const sendNotification = (line: string, jobId: string, count: number) => {
+			if (controller.closed) return;
+			const notificationId = `${jobId}:${sequence}`;
+			const suffix = count > 0 ? `\n(+${count} earlier lines)` : "";
+			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${line}${suffix}\n</task-notification>`;
+			const details = {
+				taskId: jobId,
+				kind: params.kind,
+				description: params.description,
+				monitor: true,
+				notificationId,
+				sequence,
+				coalescedCount: count,
+			};
+			pendingNotifications += 1;
+			if (pendingNotifications > MAX_PENDING_MONITOR_NOTIFICATIONS) {
+				this.session.purgeQueuedCustomMessages?.(
+					m =>
+						m.customType === "task-notification" &&
+						(m.details as { taskId?: string; notificationId?: string } | undefined)?.taskId === jobId &&
+						(m.details as { notificationId?: string } | undefined)?.notificationId !== notificationId,
+				);
+				pendingNotifications = MAX_PENDING_MONITOR_NOTIFICATIONS;
+			}
+			const sendPromise = this.session.sendCustomMessage?.(
+				{ customType: "task-notification", content, display: false, attribution: "agent", details },
+				{ triggerTurn: true, deliverAs: "followUp" },
+			);
+			if (sendPromise) {
+				void sendPromise.catch(error => {
+					logger.warn("Monitor task-notification delivery failed", {
+						error: error instanceof Error ? error.message : String(error),
+					});
+				});
+			} else {
+				this.session.steer?.({ customType: "task-notification", content, details });
+			}
+		};
+		const schedulePersistentNotification = (line: string) => {
+			latestLine = line;
+			sequence += 1;
+			coalescedCount += flushScheduled ? 1 : 0;
+			if (flushScheduled) return;
+			flushScheduled = true;
+			queueMicrotask(flushLatest);
+		};
 		const monitorJob = await bash.startMonitorJob(
 			{ command: params.command, timeout: params.timeout },
 			{
 				ownerId,
 				label,
 				ctx: context,
+				shouldAcceptRawLine: () => !controller.closed,
+				lifecycle: {
+					onCancel: () => closeMonitor("purge"),
+					onTerminal: () => closeMonitor("flush"),
+					onEvict: () => closeMonitor("purge"),
+					onTombstonePurge: () => closeMonitor("purge"),
+				},
 				onRawLine: (line, jobId) => {
+					if (controller.closed) return;
+					currentJobId = jobId;
 					if (!persistent && deliveredFirstLine) return;
 					deliveredFirstLine = true;
-					const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted:\n${line}\n</task-notification>`;
-					const details = { taskId: jobId, kind: params.kind, description: params.description };
-					const sendPromise = this.session.sendCustomMessage?.(
-						{ customType: "task-notification", content, display: false, attribution: "agent", details },
-						{ triggerTurn: true, deliverAs: "followUp" },
-					);
-					if (sendPromise) {
-						void sendPromise.catch(error => {
-							logger.warn("Monitor task-notification delivery failed", {
-								error: error instanceof Error ? error.message : String(error),
-							});
-						});
-					} else {
-						this.session.steer?.({ customType: "task-notification", content, details });
-					}
-					if (!persistent) {
-						manager.cancel(jobId, ownerId ? { ownerId } : undefined);
+					if (persistent) {
+						schedulePersistentNotification(line);
+						return;
 					}
+					sendNotification(line, jobId, 0);
+					manager.cancel(jobId, ownerId ? { ownerId } : undefined);
 				},
 			},
 		);
+		currentJobId = monitorJob.jobId;
 
 		const startedText = `Monitor started · task ${monitorJob.jobId} · persistent: ${persistent}`;
 

package/src/tools/renderers.ts

@@ -29,6 +29,7 @@ import { resolveToolRenderer } from "./resolve";
 import { searchToolRenderer } from "./search";
 import { searchToolBm25Renderer } from "./search-tool-bm25";
 import { sshToolRenderer } from "./ssh";
+import { subagentToolRenderer } from "./subagent-render";
 import { todoWriteToolRenderer } from "./todo-write";
 import { writeToolRenderer } from "./write";
 
@@ -66,6 +67,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	resolve: resolveToolRenderer as ToolRenderer,
 	search_tool_bm25: searchToolBm25Renderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,
+	subagent: subagentToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,
 	todo_write: todoWriteToolRenderer as ToolRenderer,
 	github: githubToolRenderer as ToolRenderer,