@gajae-code/coding-agent 0.4.2 → 0.4.4

package/src/tools/subagent-render.ts

@@ -0,0 +1,160 @@
+/**
+ * TUI renderer for the `subagent` tool.
+ *
+ * The await panel surfaces each awaited subagent's live streaming status at
+ * parity with the inline `task` panel by reusing `renderSubagentLiveProgress`.
+ * Falls back to a `running, no activity yet` placeholder when a live producer
+ * exists but has not emitted yet, and to a static status line when no live
+ * producer is available (resumed-from-disk or backward-compat records).
+ */
+import type { Component } from "@gajae-code/tui";
+import { Text } from "@gajae-code/tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import { renderSubagentLiveProgress } from "../task/render";
+import { Ellipsis, Hasher, type RenderCache, renderStatusLine } from "../tui";
+import {
+	formatDuration,
+	formatStatusIcon,
+	getPreviewLines,
+	replaceTabs,
+	type ToolUIStatus,
+	truncateToWidth,
+} from "./render-utils";
+import type { SubagentSnapshot, SubagentToolDetails } from "./subagent";
+
+const PREVIEW_LINES_COLLAPSED = 1;
+const PREVIEW_LINES_EXPANDED = 4;
+const PREVIEW_LINE_WIDTH = 80;
+
+function statusIconKind(status: SubagentSnapshot["status"]): ToolUIStatus {
+	switch (status) {
+		case "completed":
+		case "already_completed":
+			return "success";
+		case "failed":
+			return "error";
+		case "cancelled":
+		case "not_found":
+			return "warning";
+		case "queued":
+			return "pending";
+		default:
+			return "info";
+	}
+}
+
+function renderSubagentSnapshot(
+	snapshot: SubagentSnapshot,
+	expanded: boolean,
+	theme: Theme,
+	spinnerFrame: number | undefined,
+): string[] {
+	const lines: string[] = [];
+	const icon = formatStatusIcon(
+		statusIconKind(snapshot.status),
+		theme,
+		snapshot.status === "running" ? spinnerFrame : undefined,
+	);
+	const id = theme.fg("muted", snapshot.id);
+	const status = theme.fg("dim", snapshot.status);
+	const duration = theme.fg("dim", formatDuration(snapshot.durationMs));
+	lines.push(`${icon} ${id} ${status} ${duration}`);
+
+	// Static receipt fields (parity with the markdown content for non-await actions).
+	if (snapshot.jobId !== snapshot.id) lines.push(`  ${theme.fg("dim", `Job: ${snapshot.jobId}`)}`);
+	if (snapshot.agent && snapshot.agent !== "unknown") {
+		lines.push(`  ${theme.fg("dim", `Agent: ${snapshot.agent} (${snapshot.agentSource})`)}`);
+	}
+	if (snapshot.description) lines.push(`  ${theme.fg("dim", `Description: ${snapshot.description}`)}`);
+	if (snapshot.outputRef) lines.push(`  ${theme.fg("dim", `Output: ${snapshot.outputRef}`)}`);
+	if (snapshot.assignment) {
+		lines.push(`  ${theme.fg("dim", "Assignment:")}`);
+		for (const al of snapshot.assignment.split("\n")) lines.push(`    ${theme.fg("toolOutput", replaceTabs(al))}`);
+	}
+
+	if (snapshot.progress) {
+		// Live streaming panel (full task-panel parity), indented under the header.
+		for (const pl of renderSubagentLiveProgress(snapshot.progress, expanded, theme, spinnerFrame)) {
+			lines.push(`  ${pl}`);
+		}
+	} else if (snapshot.liveProgressAvailable && (snapshot.status === "running" || snapshot.status === "queued")) {
+		lines.push(`  ${theme.fg("dim", "running, no activity yet")}`);
+	}
+
+	const preview = snapshot.errorText?.trim() || snapshot.resultText?.trim();
+	if (preview) {
+		const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
+		const tone = snapshot.errorText ? "error" : "dim";
+		for (const pl of getPreviewLines(preview, maxLines, PREVIEW_LINE_WIDTH, Ellipsis.Unicode)) {
+			lines.push(`  ${theme.fg(tone, replaceTabs(pl))}`);
+		}
+		if (snapshot.truncated) {
+			lines.push(
+				`  ${theme.fg("dim", "Preview truncated; use the output ref or explicit ids with `verbosity=full` for more.")}`,
+			);
+		}
+	}
+
+	if (snapshot.guidance) lines.push(`  ${theme.fg("dim", snapshot.guidance)}`);
+	return lines;
+}
+
+export const subagentToolRenderer = {
+	inline: true,
+
+	renderCall(_args: unknown, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(renderStatusLine({ icon: "pending", title: "Subagent" }, theme), 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: SubagentToolDetails },
+		options: RenderResultOptions,
+		theme: Theme,
+	): Component {
+		const subagents = result.details?.subagents ?? [];
+		if (subagents.length === 0) {
+			const fallback = result.content.find(c => c.type === "text")?.text || "No subagents";
+			return new Text(theme.fg("dim", truncateToWidth(fallback, 100)), 0, 0);
+		}
+
+		const runningCount = subagents.filter(s => s.status === "running").length;
+
+		let cached: RenderCache | undefined;
+		return {
+			render(width: number): string[] {
+				const expanded = options.expanded;
+				const spinnerFrame = options.spinnerFrame ?? 0;
+				const key = new Hasher().bool(expanded).u32(width).u32(spinnerFrame).digest();
+				if (cached?.key === key) return cached.lines;
+
+				const header = renderStatusLine(
+					{
+						icon: runningCount > 0 ? "info" : "success",
+						spinnerFrame: runningCount > 0 ? options.spinnerFrame : undefined,
+						title: "Subagent",
+						description:
+							runningCount > 0
+								? `awaiting ${runningCount} of ${subagents.length}`
+								: `${subagents.length} ${subagents.length === 1 ? "subagent" : "subagents"}`,
+					},
+					theme,
+				);
+
+				const lines: string[] = [header];
+				for (const snapshot of subagents) {
+					lines.push(...renderSubagentSnapshot(snapshot, expanded, theme, options.spinnerFrame));
+				}
+
+				const out = lines.map(l => (l.length > 0 ? truncateToWidth(l, width, Ellipsis.Omit) : ""));
+				cached = { key, lines: out };
+				return out;
+			},
+			invalidate() {
+				cached = undefined;
+			},
+		};
+	},
+
+	mergeCallAndResult: true,
+};

package/src/tools/subagent.ts

@@ -4,7 +4,7 @@ import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { type AsyncJob, AsyncJobManager, type SubagentRecord } from "../async";
 import subagentDescription from "../prompts/tools/subagent.md" with { type: "text" };
-import type { AgentSource } from "../task/types";
+import type { AgentProgress, AgentSource } from "../task/types";
 import { Ellipsis, truncateToWidth } from "../tui";
 import type { ToolSession } from "./index";
 import { replaceTabs } from "./render-utils";
@@ -63,6 +63,10 @@ export interface SubagentSnapshot {
 	outputRef?: string;
 	truncated?: boolean;
 	guidance?: string;
+	/** Live streaming progress for the awaited subagent (await panel only; UI detail). */
+	progress?: AgentProgress;
+	/** True when a live in-session progress producer exists for this subagent. */
+	liveProgressAvailable?: boolean;
 }
 
 export interface SubagentToolDetails {
@@ -322,10 +326,10 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		manager.watchJobs(watchedJobIds);
 		const progressTimer = onUpdate
 			? setInterval(() => {
-					onUpdate(this.#progressResult(manager, records));
+					onUpdate(this.#progressResult(manager, records, true));
 				}, 500)
 			: undefined;
-		onUpdate?.(this.#progressResult(manager, records));
+		onUpdate?.(this.#progressResult(manager, records, true));
 
 		let timedOut = false;
 		try {
@@ -355,6 +359,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			notFoundIds,
 			timedOut,
 			verbosity: params.verbosity ?? "receipt",
+			attachLiveProgress: true,
 		});
 	}
 
@@ -450,17 +455,29 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		return ids.filter(id => !this.#findVisibleRecord(manager, id, ownerFilter));
 	}
 
-	#progressResult(manager: AsyncJobManager, records: SubagentRecord[]): AgentToolResult<SubagentToolDetails> {
+	#progressResult(
+		manager: AsyncJobManager,
+		records: SubagentRecord[],
+		attachLiveProgress = false,
+	): AgentToolResult<SubagentToolDetails> {
 		return {
 			content: [{ type: "text", text: "" }],
-			details: { subagents: this.#recordSnapshots(manager, records, false, "receipt", new Set()) },
+			details: {
+				subagents: this.#recordSnapshots(manager, records, false, "receipt", new Set(), attachLiveProgress),
+			},
 		};
 	}
 
 	async #buildRecordResult(
 		manager: AsyncJobManager,
 		records: SubagentRecord[],
-		options: { title: string; notFoundIds?: string[]; timedOut?: boolean; verbosity?: SubagentParams["verbosity"] },
+		options: {
+			title: string;
+			notFoundIds?: string[];
+			timedOut?: boolean;
+			verbosity?: SubagentParams["verbosity"];
+			attachLiveProgress?: boolean;
+		},
 	): Promise<AgentToolResult<SubagentToolDetails>> {
 		const verifiedOutputIds = await this.#verifiedOutputIds(records);
 		const snapshots = this.#recordSnapshots(
@@ -469,6 +486,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			options.timedOut,
 			options.verbosity ?? "receipt",
 			verifiedOutputIds,
+			options.attachLiveProgress ?? false,
 		);
 		for (const id of options.notFoundIds ?? []) {
 			snapshots.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
@@ -513,8 +531,28 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		timedOut = false,
 		verbosity: SubagentParams["verbosity"] = "receipt",
 		verifiedOutputIds: ReadonlySet<string>,
+		attachLiveProgress = false,
 	): SubagentSnapshot[] {
-		return records.map(record => this.#recordSnapshot(manager, record, timedOut, verbosity, verifiedOutputIds));
+		return records.map(record =>
+			this.#recordSnapshot(manager, record, timedOut, verbosity, verifiedOutputIds, attachLiveProgress),
+		);
+	}
+
+	#liveProgressFields(
+		manager: AsyncJobManager,
+		record: SubagentRecord,
+		attachLiveProgress: boolean,
+	): Pick<SubagentSnapshot, "progress" | "liveProgressAvailable"> {
+		if (!attachLiveProgress) return {};
+		const liveProgressAvailable = manager.hasLiveSubagent(record.subagentId);
+		// Only surface progress when a live producer exists; stale/retained progress
+		// for a record with no live producer must degrade to a static snapshot (AC5).
+		if (!liveProgressAvailable) return { liveProgressAvailable: false };
+		const progress = manager.getSubagentProgress(record.subagentId);
+		return {
+			liveProgressAvailable: true,
+			...(progress ? { progress } : {}),
+		};
 	}
 
 	#recordSnapshot(
@@ -523,7 +561,9 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		timedOut = false,
 		verbosity: SubagentParams["verbosity"] = "receipt",
 		verifiedOutputIds: ReadonlySet<string>,
+		attachLiveProgress = false,
 	): SubagentSnapshot {
+		const liveFields = this.#liveProgressFields(manager, record, attachLiveProgress);
 		const job = record.currentJobId ? manager.getJob(record.currentJobId) : undefined;
 		if (job) {
 			return {
@@ -531,6 +571,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 				id: record.subagentId,
 				jobId: record.currentJobId ?? job.id,
 				status: record.status,
+				...liveFields,
 			};
 		}
 		return {
@@ -542,6 +583,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			agentSource: "bundled",
 			durationMs: 0,
 			...(verifiedOutputIds.has(record.subagentId) ? { outputRef: `agent://${record.subagentId}` } : {}),
+			...liveFields,
 		};
 	}
 

package/src/utils/commit-message-generator.ts

@@ -1,5 +1,5 @@
 /**
- * Generate commit messages from diffs using a smol, fast model.
+ * Generate commit messages from diffs using the default model.
  * Follows the same pattern as title-generator.ts.
  */
 import type { ThinkingLevel } from "@gajae-code/agent-core";
@@ -9,7 +9,6 @@ import { logger, prompt } from "@gajae-code/utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveModelRoleValue } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
-import MODEL_PRIO from "../priority.json" with { type: "json" };
 import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
 import { toReasoningEffort } from "../thinking";
 
@@ -36,7 +35,7 @@ function filterDiffNoise(diff: string): string {
 	return filtered.join("\n");
 }
 
-function getSmolModelCandidates(
+function getModelCandidates(
 	registry: ModelRegistry,
 	settings: Settings,
 ): Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> {
@@ -51,18 +50,12 @@ function getSmolModelCandidates(
 	};
 
 	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
-	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
+	const configured = resolveModelRoleValue(settings.getModelRole("default"), availableModels, {
 		settings,
 		matchPreferences,
 		modelRegistry: registry,
 	});
-	addCandidate(configuredSmol.model, configuredSmol.thinkingLevel);
-
-	for (const pattern of MODEL_PRIO.smol) {
-		const needle = pattern.toLowerCase();
-		addCandidate(availableModels.find(m => m.id.toLowerCase() === needle));
-		addCandidate(availableModels.find(m => m.id.toLowerCase().includes(needle)));
-	}
+	addCandidate(configured.model, configured.thinkingLevel);
 
 	for (const model of availableModels) {
 		addCandidate(model);
@@ -81,9 +74,9 @@ export async function generateCommitMessage(
 	settings: Settings,
 	sessionId?: string,
 ): Promise<string | null> {
-	const candidates = getSmolModelCandidates(registry, settings);
+	const candidates = getModelCandidates(registry, settings);
 	if (candidates.length === 0) {
-		logger.debug("commit-msg-generator: no smol model found");
+		logger.debug("commit-msg-generator: no model found");
 		return null;
 	}
 

package/src/utils/title-generator.ts

@@ -40,7 +40,7 @@ function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel
 	const availableModels = registry.getAvailable();
 	if (availableModels.length === 0) return undefined;
 
-	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry)?.model;
+	const titleModel = resolveRoleSelection(["default"], settings, availableModels, registry)?.model;
 	if (titleModel) return titleModel;
 
 	if (currentModel) return currentModel;

package/dist/types/harness-control-plane/frame-mapper.d.ts

@@ -1,29 +0,0 @@
-/**
- * Pure mapping from `gjc --mode rpc` event frames (docs/rpc.md) to bounded owner event kinds
- * and {@link ObservedSignal}s. The owner feeds raw frames through this mapper and emits the
- * result via its single-writer #emit — the mapper itself performs NO IO and NO appends.
- *
- * Hard rule: evidence is BOUNDED — only ids, names, categories, statuses, cursors, timestamps,
- * and short codes/messages. Never assistant text, message deltas, command output, or raw args.
- */
-import type { ObservedSignal } from "./types";
-export interface MappedFrame {
-    /** Owner event kind (rpc_*). */
-    kind: string;
-    /** Bounded observed signal, or null when the frame carries no user-facing signal. */
-    signal: ObservedSignal | null;
-    /** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
-    evidence: Record<string, unknown>;
-    /** Severity for the emitted event. */
-    severity: "info" | "warn" | "critical";
-    /** Never-drop frames (must be enqueued in order, never coalesced away). */
-    semantic: boolean;
-    /** Coalescing key for high-frequency non-semantic frames (message id / tool id); null otherwise. */
-    coalesceKey: string | null;
-}
-export declare function isTestRunnerTool(toolName?: unknown, command?: unknown): boolean;
-/**
- * Map a single RPC frame. Returns null for frames that carry no observability value
- * (or that the adapter handles itself: `ready`, `response`).
- */
-export declare function mapRpcFrame(frame: Record<string, unknown>): MappedFrame | null;

package/src/harness-control-plane/frame-mapper.ts

@@ -1,286 +0,0 @@
-/**
- * Pure mapping from `gjc --mode rpc` event frames (docs/rpc.md) to bounded owner event kinds
- * and {@link ObservedSignal}s. The owner feeds raw frames through this mapper and emits the
- * result via its single-writer #emit — the mapper itself performs NO IO and NO appends.
- *
- * Hard rule: evidence is BOUNDED — only ids, names, categories, statuses, cursors, timestamps,
- * and short codes/messages. Never assistant text, message deltas, command output, or raw args.
- */
-import type { ObservedSignal } from "./types";
-
-export interface MappedFrame {
-	/** Owner event kind (rpc_*). */
-	kind: string;
-	/** Bounded observed signal, or null when the frame carries no user-facing signal. */
-	signal: ObservedSignal | null;
-	/** Bounded evidence — ids/names/statuses/cursors/timestamps/short codes only. */
-	evidence: Record<string, unknown>;
-	/** Severity for the emitted event. */
-	severity: "info" | "warn" | "critical";
-	/** Never-drop frames (must be enqueued in order, never coalesced away). */
-	semantic: boolean;
-	/** Coalescing key for high-frequency non-semantic frames (message id / tool id); null otherwise. */
-	coalesceKey: string | null;
-}
-
-const TEST_RE = /\b(bun test|npm test|yarn test|pnpm test|jest|vitest|pytest|go test|cargo test|mocha|ava)\b/i;
-const TOOL_STATUS_CODES = new Set([
-	"aborted",
-	"blocked",
-	"cancelled",
-	"complete",
-	"completed",
-	"error",
-	"failed",
-	"ok",
-	"pending",
-	"running",
-	"skipped",
-	"success",
-	"timeout",
-]);
-
-export function isTestRunnerTool(toolName?: unknown, command?: unknown): boolean {
-	const name = typeof toolName === "string" ? toolName : "";
-	const cmd = typeof command === "string" ? command : "";
-	if (/test/i.test(name) && name !== "edit" && name !== "read") return true;
-	return TEST_RE.test(cmd);
-}
-
-function str(v: unknown): string | undefined {
-	return typeof v === "string" ? v : undefined;
-}
-function num(v: unknown): number | undefined {
-	return typeof v === "number" ? v : undefined;
-}
-function boundedMessage(v: unknown): string | undefined {
-	const s = typeof v === "string" ? v : undefined;
-	return s === undefined ? undefined : s.slice(0, 200);
-}
-function boundedStatus(v: unknown): string | undefined {
-	if (typeof v !== "string") return undefined;
-	const status = v.trim().toLowerCase();
-	return TOOL_STATUS_CODES.has(status) ? status : undefined;
-}
-function recordObject(v: unknown): Record<string, unknown> | undefined {
-	return v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;
-}
-/** Extract a tool command from real AgentSessionEvent `args` or a flat fixture frame. Bounded use only — never persisted. */
-function toolCommand(frame: Record<string, unknown>): string | undefined {
-	const args = recordObject(frame.args);
-	const c = args?.command ?? args?.cmd ?? args?.commandLine;
-	if (typeof c === "string") return c;
-	return str(frame.command) ?? str(frame.commandLine);
-}
-/** Derive a tool status, honoring real `isError` booleans as well as bounded status strings. */
-function toolStatus(frame: Record<string, unknown>): string | undefined {
-	if (frame.isError === true) return "error";
-	const flatStatus = boundedStatus(frame.status);
-	if (flatStatus) return flatStatus;
-	for (const candidate of [frame.result, frame.partialResult]) {
-		const result = recordObject(candidate);
-		if (!result) continue;
-		if (result.isError === true) return "error";
-		const status = boundedStatus(result.status) ?? boundedStatus(recordObject(result.details)?.status);
-		if (status) return status;
-	}
-	return undefined;
-}
-
-/**
- * Map a single RPC frame. Returns null for frames that carry no observability value
- * (or that the adapter handles itself: `ready`, `response`).
- */
-export function mapRpcFrame(frame: Record<string, unknown>): MappedFrame | null {
-	const type = str(frame.type);
-	if (!type || type === "ready" || type === "response") return null;
-
-	switch (type) {
-		case "agent_start":
-			return {
-				kind: "rpc_agent_started",
-				signal: "SessionStart",
-				evidence: {},
-				severity: "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "turn_start":
-			return {
-				kind: "rpc_turn_started",
-				signal: "prompt-accepted",
-				evidence: {},
-				severity: "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "turn_end":
-			return {
-				kind: "rpc_turn_ended",
-				signal: null,
-				evidence: {},
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "message_start":
-		case "message_update":
-		case "message_end":
-			return {
-				kind: "rpc_message_activity",
-				signal: null,
-				evidence: { phase: type, messageId: str(frame.messageId) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: `message:${str(frame.messageId) ?? "msg"}`,
-			};
-		case "tool_execution_start": {
-			const toolName = str(frame.toolName);
-			const test = isTestRunnerTool(toolName, toolCommand(frame));
-			return {
-				kind: "rpc_tool_started",
-				signal: test ? "test-running" : "tool-call",
-				evidence: { toolId: str(frame.toolCallId) ?? null, toolName: toolName ?? null },
-				severity: "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		}
-		case "tool_execution_update": {
-			const toolName = str(frame.toolName);
-			const test = isTestRunnerTool(toolName, toolCommand(frame));
-			return {
-				kind: "rpc_tool_updated",
-				signal: test ? "test-running" : null,
-				evidence: { toolId: str(frame.toolCallId) ?? null, status: toolStatus(frame) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: `tool:${str(frame.toolCallId) ?? "tool"}`,
-			};
-		}
-		case "tool_execution_end": {
-			const toolName = str(frame.toolName);
-			const test = isTestRunnerTool(toolName, toolCommand(frame));
-			const status = toolStatus(frame);
-			return {
-				kind: "rpc_tool_ended",
-				signal: test ? "test-running" : "tool-call",
-				evidence: {
-					toolId: str(frame.toolCallId) ?? null,
-					toolName: toolName ?? null,
-					status: status ?? null,
-					exitCode: num(frame.exitCode) ?? null,
-				},
-				severity: status === "error" ? "warn" : "info",
-				semantic: true,
-				coalesceKey: null,
-			};
-		}
-		case "host_tool_call":
-		case "host_tool_cancel":
-			return {
-				kind: "rpc_host_tool",
-				signal: "tool-call",
-				evidence: { toolName: str(frame.toolName) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "host_uri_request":
-		case "host_uri_cancel":
-			return {
-				kind: "rpc_host_uri",
-				signal: "tool-call",
-				evidence: { operation: str(frame.operation) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "auto_compaction_start":
-		case "auto_compaction_end":
-			return {
-				kind: "rpc_compaction",
-				signal: null,
-				evidence: { phase: type },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "auto_retry_start":
-		case "auto_retry_end":
-			return {
-				kind: "rpc_retry",
-				signal: null,
-				evidence: { phase: type, reason: boundedMessage(frame.reason) ?? null },
-				severity: "warn",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "ttsr_triggered":
-			return {
-				kind: "rpc_ttsr",
-				signal: "error",
-				evidence: { reason: boundedMessage(frame.reason) ?? null },
-				severity: "warn",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "todo_reminder":
-		case "todo_auto_clear":
-			return {
-				kind: "rpc_todo",
-				signal: null,
-				evidence: { phase: type },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "extension_ui_request":
-			return {
-				kind: "rpc_extension_request",
-				signal: "tool-call",
-				evidence: { method: str(frame.method) ?? null },
-				severity: "info",
-				semantic: false,
-				coalesceKey: null,
-			};
-		case "extension_error":
-			return {
-				kind: "rpc_extension_error",
-				signal: "error",
-				evidence: {
-					code: str(frame.error) ? boundedMessage(frame.error) : null,
-					extensionPath: str(frame.extensionPath) ?? null,
-				},
-				severity: "critical",
-				semantic: true,
-				coalesceKey: null,
-			};
-		case "agent_end": {
-			const failed =
-				Boolean(frame.error) ||
-				frame.aborted === true ||
-				str(frame.outcome) === "failed" ||
-				str(frame.outcome) === "aborted";
-			return failed
-				? {
-						kind: "rpc_agent_failed",
-						signal: "error",
-						evidence: { outcome: str(frame.outcome) ?? "failed" },
-						severity: "critical",
-						semantic: true,
-						coalesceKey: null,
-					}
-				: {
-						kind: "rpc_agent_completed",
-						signal: "completed",
-						evidence: { outcome: "completed" },
-						severity: "info",
-						semantic: true,
-						coalesceKey: null,
-					};
-		}
-		default:
-			return null;
-	}
-}