@ferris1225/pi-subagents 0.32.2 → 1.0.1

package/src/fixloop.ts

@@ -86,22 +86,6 @@ export function chainKeyFragments(result: SingleResult): string[] {
 	return extractKeyFragments(getResultOutput(result)).slice(0, CHAIN_SUMMARY_FRAGMENTS_MAX);
 }
 
-/**
- * Compact one-line outcome for a finished chain run, shown in the widget so
- * each round reads as what it did: a reviewer reports its verdict plus the
- * key fragments of what it found ("fail · src/index.ts · render()"), a worker
- * the fragments of what it changed. Failed runs and runs with nothing
- * distinctive get no summary.
- */
-export function summarizeChainResult(result: SingleResult): string | undefined {
-	if (isFailedResult(result)) return undefined;
-	const verdict = result.agent === "reviewer" ? reviewVerdict(getResultOutput(result)) : undefined;
-	if (verdict === "pass") return "pass";
-	const fragments = chainKeyFragments(result);
-	if (verdict === "fail") return fragments.length > 0 ? `fail · ${fragments.join(" · ")}` : "fail";
-	return fragments.length > 0 ? fragments.join(" · ") : undefined;
-}
-
 /**
  * Condensed, readable summary of a completed auto-fix chain: one line per step
  * (run id, role, verdict / what changed) plus aggregate usage. Full per-step

package/src/format.ts

@@ -6,6 +6,7 @@
 
 import type { AgentConfig } from "./agents.ts";
 import { formatTaskSummary } from "./monitor.ts";
+import { emptyUsage } from "./rpc-run.ts";
 import {
 	getResultOutput,
 	isFailedResult,
@@ -15,14 +16,9 @@ import {
 	type UsageStats,
 } from "./spawn.ts";
 
-export function emptyUsage(): UsageStats {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
-}
-
 export function queuedResult(agent: AgentConfig, task: string, thinking?: string): SingleResult {
 	return {
 		agent: agent.name,
-		agentSource: agent.source,
 		task,
 		exitCode: -1,
 		messages: [],
@@ -36,7 +32,6 @@ export function queuedResult(agent: AgentConfig, task: string, thinking?: string
 export function failedStartResult(agentName: string, task: string, errorMessage: string): SingleResult {
 	return {
 		agent: agentName,
-		agentSource: "unknown",
 		task,
 		exitCode: 1,
 		messages: [],
@@ -61,7 +56,7 @@ export function dispatchFailedResult(agent: AgentConfig, task: string, error: un
 	};
 }
 
-export function formatTokens(count: number): string {
+function formatTokens(count: number): string {
 	if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
 	if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
 	return String(count);
@@ -103,7 +98,8 @@ export function formatCompletionBlock(result: SingleResult, maxResultLines: numb
 		(result.forkChildRunIds?.length ?? 0) > 0 ? `fork children ${result.forkChildRunIds!.map((id) => `#${id}`).join(", ")}` : undefined,
 	].filter((value): value is string => Boolean(value));
 	const relationNote = relations.length > 0 ? ` · ${relations.join(" · ")}` : "";
-	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${modelRetryNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
+	const runNote = result.runId !== undefined ? ` · run #${result.runId}` : "";
+	const lines = [`### [${result.agent}] ${status}${usage ? ` (${usage})` : ""}${fallbackNote}${startupRetryNote}${modelRetryNote}${runNote}`, "", `Task: ${formatTaskSummary(result.task, 80, false)}`, ""];
 	if (result.isolation === "worktree") {
 		const isolation =
 			result.integrationStatus === "integrated"

package/src/index.ts

@@ -5,8 +5,9 @@
  * The heavy lifting lives in focused modules:
  *   - dispatch.ts  — the `subagent` tool (spawn, auto-fix chain, vision model)
  *   - tools.ts     — subagent_control / subagent_wait / status / stop
- *   - widget.ts    — session_start widget + one-time feature announcements
- *   - runtime.ts   — shared per-session state
+ *   - announcements.ts — session-start recovery, notices, and widget install
+ *   - widget.ts        — active-only TUI run status
+ *   - runtime.ts       — shared per-session state
  *
  * Also registers the `/subagents-setup` command and a `before_agent_start` hook
  * that injects a delegation directive into the parent system prompt so the main
@@ -19,16 +20,16 @@
 import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { discoverAgents } from "./agents.ts";
+import { registerAnnouncements } from "./announcements.ts";
 import { getConfigPath, loadConfig } from "./config.ts";
 import { registerSubagentTool } from "./dispatch.ts";
 import { matchRunIds } from "./format.ts";
-import { registerInspectorCommand } from "./inspector-panel.ts";
 import { buildDelegationDirective } from "./prompt.ts";
 import { createRuntime } from "./runtime.ts";
 import { runSetup } from "./setup.ts";
 import { currentSubagentDepth } from "./spawn.ts";
 import { registerLookupTools } from "./tools.ts";
-import { registerWidget } from "./widget.ts";
+import { clearActiveRunsWidget } from "./widget.ts";
 
 export { matchRunIds };
 
@@ -58,13 +59,13 @@ export default function (pi: ExtensionAPI): void {
 		),
 	);
 
-	pi.on("session_shutdown", async () => {
+	pi.on("session_shutdown", async (_event, ctx) => {
+		clearActiveRunsWidget(ctx);
 		await runtime.shutdown();
 	});
 
 	registerSubagentTool(pi, runtime);
 	registerLookupTools(pi, runtime);
-	registerInspectorCommand(pi, runtime);
 
 	pi.registerCommand("subagents-setup", {
 		description: "Configure pi-subagents: enabled agents, primary/backup model pools, and runtime settings",
@@ -73,9 +74,7 @@ export default function (pi: ExtensionAPI): void {
 		},
 	});
 
-	// Persistent widget above the editor showing live sub-agent status, plus
-	// one-time feature announcements after updates.
-	registerWidget(pi, runtime);
+	registerAnnouncements(pi, runtime);
 
 	// Proactive dispatch: inject the delegation directive into the parent system prompt.
 	pi.on("before_agent_start", async (event, ctx) => {

package/src/models.ts

@@ -22,8 +22,6 @@ export interface ModelPickerItem {
 	value: string;
 	label: string;
 	description?: string;
-	/** Visible for diagnosis/search, but cannot be selected. */
-	disabled?: boolean;
 }
 
 export type ModelListEntry = Pick<
@@ -72,19 +70,18 @@ export function currentModelRef(ctx: Pick<ModelContext, "model">): string | unde
 }
 
 /**
- * Models usable by this main window. Scoped models replace the full available
- * registry, matching pi's built-in model picker semantics.
+ * Current authenticated registry models narrowed by the session scope. Scope
+ * entries are a session snapshot, so they act only as a whitelist; the live
+ * registry remains the source of truth for availability and model metadata.
  */
-export function availableModelRefs(ctx: ModelContext): string[] {
+export function availableModelsInScope(ctx: ModelContext): readonly Model<Api>[] {
+	const models = ctx.modelRegistry.getAvailable();
 	// scopedModels was added after the declared Pi 0.80.6 minimum. Treat a
-	// missing field exactly like an empty scope and use the registry fallback.
+	// missing field exactly like an empty scope and use the full live registry.
 	const scopedModels = ctx.scopedModels ?? [];
-	const scoped = scopedModels.length > 0 ? scopedModels.map((entry) => entry.model) : undefined;
-	const models = scoped ?? ctx.modelRegistry.getAvailable();
-	const refs = [...new Set(models.map(modelRef))];
-	const currentRef = currentModelRef(ctx);
-	if (!currentRef) return refs;
-	return [currentRef, ...refs.filter((ref) => ref !== currentRef)];
+	if (scopedModels.length === 0) return models;
+	const scopedRefs = new Set(scopedModels.map((entry) => modelRef(entry.model)));
+	return models.filter((model) => scopedRefs.has(modelRef(model)));
 }
 
 /**
@@ -118,7 +115,9 @@ function modelCapabilities(model: ModelListEntry): string {
 	return capabilities.join(" + ");
 }
 
-/** Build the single searchable model list shared by primary/backup/vision picks. */
+/** Build the single searchable model list shared by primary/backup/vision picks.
+ * Only refs Pi currently reports as available are shown, which means providers
+ * without a configured API key/OAuth session never flood the setup picker. */
 export function buildModelPickerItems(options: {
 	models: readonly ModelListEntry[];
 	availableRefs: readonly string[];
@@ -132,21 +131,16 @@ export function buildModelPickerItems(options: {
 	const byRef = new Map<string, ModelListEntry>();
 	for (const model of options.models) {
 		const ref = modelRef(model);
-		if (!byRef.has(ref)) byRef.set(ref, model);
+		if (available.has(ref) && !byRef.has(ref)) byRef.set(ref, model);
 	}
 
 	const refs = [...byRef.keys()]
-		.filter((ref) =>
-			options.slot !== "vision" ||
-			byRef.get(ref)?.input.includes("image") === true ||
-			ref === configuredRef,
-		)
+		.filter((ref) => options.slot !== "vision" || byRef.get(ref)?.input.includes("image") === true)
 		.sort((left, right) => {
 			const leftRank = left === configuredRef ? 0 : left === mainRef ? 1 : 2;
 			const rightRank = right === configuredRef ? 0 : right === mainRef ? 1 : 2;
 			return leftRank - rightRank || left.localeCompare(right);
 		});
-	if (configuredRef && !byRef.has(configuredRef)) refs.unshift(configuredRef);
 
 	const dynamic = options.slot === "backup"
 		? {
@@ -164,31 +158,15 @@ export function buildModelPickerItems(options: {
 
 	const items: ModelPickerItem[] = [dynamic];
 	for (const ref of refs) {
-		const model = byRef.get(ref);
-		const tags = [available.has(ref) ? "available" : "unavailable"];
+		const model = byRef.get(ref)!;
+		const tags = ["available"];
 		if (ref === configuredRef) tags.push("configured");
 		if (ref === mainRef) tags.push("current main");
-		if (!model) {
-			const compatibility = options.slot === "vision"
-				? "incompatible with vision (capability unknown)"
-				: undefined;
-			items.push({
-				value: ref,
-				label: ref,
-				description: [...tags, compatibility, "saved model reference"].filter(Boolean).join(" · "),
-				...(options.slot === "vision" ? { disabled: true } : {}),
-			});
-			continue;
-		}
 		const name = model.name.trim() && model.name !== model.id ? model.name.trim() : undefined;
-		const compatibility = options.slot === "vision" && !model.input.includes("image")
-			? "incompatible with vision"
-			: undefined;
 		items.push({
 			value: ref,
 			label: ref,
-			description: [name, modelCapabilities(model), compatibility, ...tags].filter(Boolean).join(" · "),
-			...(compatibility ? { disabled: true } : {}),
+			description: [name, modelCapabilities(model), ...tags].filter(Boolean).join(" · "),
 		});
 	}
 	return items;

package/src/monitor.ts

@@ -2,18 +2,16 @@
  * Sub-agent monitor: a module-level singleton store that tracks subagent runs
  * for the current turn.
  *
- * The store notifies subscribers on every mutation so the persistent widget
- * above the editor can re-render. Each run carries timing information
- * (started/ended) plus a concise activity string describing what the run is
- * doing right now ("thinking", "read src/index.ts", ...). Runs are removed
- * as soon as they finish: the tool result is the durable record in the main
- * conversation, so a stale "done" row must not linger in the widget.
+ * The store notifies wait/status consumers on every mutation. Each run carries
+ * timing information plus a concise activity string ("thinking",
+ * "read src/index.ts", ...). Runs are removed after publication; tool results
+ * and the finished-run registry are the durable user-facing records.
  */
 
 import { stripVTControlCharacters } from "node:util";
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import type { UsageStats } from "./spawn.ts";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { emptyUsage, type UsageStats } from "./rpc-run.ts";
 import type { IsolationMode, WorktreeFinalizationStatus } from "./worktree.ts";
 
 // ---------------------------------------------------------------------------
@@ -26,20 +24,6 @@ export function isRunActiveStatus(status: RunStatus): boolean {
 	return status === "queued" || status === "running" || status === "steering" || status === "interrupting";
 }
 
-/** Soft state-awareness signals, complementary to the hard idle-kill: a run may
- * be alive (stdout streaming) yet "stuck thinking" (no tool running for a while),
- * or simply taking a long time. Both are surfaced as widget annotations so the
- * user can tell a healthy busy run from one that needs a nudge. */
-export type ActivityState = "needs_attention" | "active_long_running";
-
-/** A run with no tool running and no activity for this long is "needs attention"
- * (the model may be stuck between turns). Below the idle-kill threshold so the
- * soft signal always fires before the hard kill. */
-export const NEEDS_ATTENTION_AFTER_MS = 60_000;
-/** A run whose total elapsed time exceeds this is "long-running": still active
- * but worth flagging so the user can decide whether to wait or steer. */
-export const ACTIVE_LONG_RUNNING_AFTER_MS = 240_000;
-
 export interface RunView {
 	id: number;
 	agent: string;
@@ -61,14 +45,6 @@ export interface RunView {
 	usage: UsageStats;
 	/** Concise current activity ("thinking", "read src/index.ts"); last writer wins. */
 	activity?: string;
-	/** Total tool calls started by the run so far (a progress signal). */
-	toolCount?: number;
-	/** Tool currently executing (set on tool_start, cleared on tool_end). When set,
-	 * the run is NOT idle for needs-attention purposes. */
-	currentTool?: string;
-	/** Epoch ms of the last live activity (tool, usage, status). Used to derive
-	 * the needs-attention state: no tool running AND now - lastActivityAt > threshold. */
-	lastActivityAt?: number;
 	/** Epoch ms when the run started executing (set on first "running" status). */
 	startedAt?: number;
 	/** Epoch ms when the run finished (set on "done"/"failed"). */
@@ -77,17 +53,6 @@ export interface RunView {
 	groupId?: string;
 	/** Human-readable role within a chain, e.g. "fix round 1" or "re-review round 1". */
 	relationLabel?: string;
-	/** Free-form note shown in the widget next to the status label (e.g. "auto-fix chain running"). */
-	annotation?: string;
-	/** One-line outcome summary of a finished chain run, shown in the widget so
-	 * each auto-fix round reads as what it did: a reviewer reports its verdict
-	 * plus key fragments of what it found ("fail · src/index.ts · render()"), a
-	 * worker the fragments of what it changed. Unset for non-chain runs. */
-	summary?: string;
-	/** True when a finished run is intentionally kept in the widget (e.g. an
-	 * auto-fix chain parent whose chain is still running). beginTurn preserves
-	 * retained runs so they are not swept between turns. */
-	retained?: boolean;
 }
 
 /** Optional chain metadata for runs spawned by an auto-fix loop. */
@@ -107,7 +72,7 @@ const TASK_SUMMARY_ELLIPSIS = "…";
 /** Columns reserved at the END of a truncated summary so the distinguishing
  * keywords (paths, symbols, ...) survive; the head gets the rest. */
 const TASK_SUMMARY_TAIL_MAX = 28;
-/** Tail share of a non-default maxWidth (narrow widgets keep a usable tail). */
+/** Tail share of a non-default maxWidth (narrow summaries keep a usable tail). */
 const TASK_SUMMARY_TAIL_SHARE = 0.35;
 const TASK_SUMMARY_TAIL_MIN = 8;
 const TASK_SUMMARY_KEY_SEP = " · ";
@@ -296,72 +261,49 @@ export function formatDuration(ms: number): string {
 /** Elapsed wall time of a run: live while running, final once finished. */
 export function formatElapsed(run: RunView, now: number = Date.now()): string {
 	if (run.startedAt === undefined) return "";
-	// A retained row (e.g. an auto-fix chain parent whose chain is still running)
-	// must keep ticking: its `endedAt` was stamped when the review itself
-	// finished, but the work is ongoing, so show live elapsed until the chain
-	// resolves and the row is removed. Without this, subagent_status would show a
-	// frozen elapsed for a run the UI otherwise presents as still active.
-	const end = run.retained ? now : (run.endedAt ?? now);
-	return formatDuration(end - run.startedAt);
-}
-
-/** Strip the provider prefix from a "provider/model-id" reference for compact
- * widget display ("anthropic/claude-sonnet-4" → "claude-sonnet-4"). A bare id is
- * left unchanged. */
-export function compactModelRef(model: string | undefined): string {
-	if (!model) return "";
-	const slash = model.lastIndexOf("/");
-	return slash >= 0 ? model.slice(slash + 1) : model;
+	return formatDuration((run.endedAt ?? now) - run.startedAt);
 }
 
-/** Human-readable label for a soft activity-state annotation. */
-export function activityStateLabel(state: ActivityState): string {
-	return state === "needs_attention" ? "idle" : "long-running";
-}
+/** Max length of the argument target inside a formatted activity line. */
+export const ACTIVITY_TARGET_MAX = 60;
 
-/** Derive the soft activity state of a run at render time: needs_attention
- * (no tool running, idle past the threshold) takes priority over
- * active_long_running (total elapsed past its threshold). Both are suppressed
- * for non-running runs. */
-export function deriveActivityState(run: RunView, now: number = Date.now()): ActivityState | undefined {
-	if (run.status !== "running" && run.status !== "steering") return undefined;
-	if (!run.currentTool) {
-		const since = run.lastActivityAt ?? run.startedAt ?? now;
-		if (now - since >= NEEDS_ATTENTION_AFTER_MS) return "needs_attention";
-	}
-	if (run.startedAt !== undefined && now - run.startedAt >= ACTIVE_LONG_RUNNING_AFTER_MS) {
-		return "active_long_running";
-	}
-	return undefined;
-}
+const REDACTED = "<redacted>";
 
-/** Left/right split a widget line so the right side (status, elapsed) is always
- * visible and the left side (title) clips on overflow instead of pushing it off.
- * `left`/`right` may carry ANSI styling; widths are measured display-column-wise. */
-export function rightAlign(left: string, right: string, width: number): string {
-	const rightWidth = visibleWidth(right);
-	const leftMax = Math.max(0, width - rightWidth - 1);
-	const leftClipped = truncateToWidth(left, leftMax);
-	const gap = Math.max(1, width - visibleWidth(leftClipped) - rightWidth);
-	return truncateToWidth(`${leftClipped}${" ".repeat(gap)}${right}`, width);
+/** Remove credentials embedded in otherwise ordinary activity strings such as
+ * shell commands and HTTP headers. */
+function redactSensitiveText(value: string): string {
+	let text = stripVTControlCharacters(value);
+	text = text.replace(
+		/(\bauthorization\s*:\s*(?:bearer|basic)\s+)([^\s'"`;,]+)/giu,
+		`$1${REDACTED}`,
+	);
+	text = text.replace(
+		/(\bbearer\s+)([A-Za-z0-9._~+/=-]{6,})/giu,
+		`$1${REDACTED}`,
+	);
+	text = text.replace(
+		/(\b(?:api[-_]?key|apikey|access[-_]?token|refresh[-_]?token|token|password|passwd|secret|credential|cookie)\b\s*(?:=|:)\s*)(?:"[^"]*"|'[^']*'|[^\s;&,]+)/giu,
+		`$1${REDACTED}`,
+	);
+	text = text.replace(
+		/((?:--?(?:api[-_]?key|access[-_]?token|token|password|secret|credential))\s+)(?:"[^"]*"|'[^']*'|\S+)/giu,
+		`$1${REDACTED}`,
+	);
+	return text.replace(
+		/\b(?:sk-[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9]{8,}|AKIA[A-Z0-9]{16})\b/gu,
+		REDACTED,
+	);
 }
 
-/** Concatenate `left` and `right` (no center padding) and clip the combined line
- * to `width`. Unlike {@link rightAlign}, the right side trails the left side
- * instead of being pinned to the far edge, so a short header leaves no gap in
- * the middle. `right` should carry its own leading separator (e.g. ` \u00b7 `);
- * pass an empty string when there is nothing to append. Styled strings are
- * measured by display width. */
-export function compactLine(left: string, right: string, width: number): string {
-	return truncateToWidth(`${left}${right}`, width);
+/** Monitor activity is returned to the parent model and rendered in the terminal,
+ * so treat every live string as untrusted before it reaches store state. */
+function sanitizeActivityText(value: string): string {
+	return redactSensitiveText(value).replace(/\s+/g, " ").trim();
 }
 
-/** Max length of the argument target inside a formatted activity line. */
-export const ACTIVITY_TARGET_MAX = 60;
-
 function shortTarget(value: unknown): string {
 	if (typeof value !== "string") return "";
-	const oneLine = value.replace(/\s+/g, " ").trim();
+	const oneLine = sanitizeActivityText(value);
 	// Slice by code point so emoji / CJK-ext never leave a lone surrogate.
 	const chars = [...oneLine];
 	return chars.length > ACTIVITY_TARGET_MAX ? `${chars.slice(0, ACTIVITY_TARGET_MAX - 1).join("")}…` : oneLine;
@@ -410,7 +352,8 @@ export function formatToolActivity(toolName: string, args: unknown): string {
 		default:
 			target = pick("path", "command", "query", "pattern", "url", "file", "task");
 	}
-	return target ? `${toolName} ${target}` : toolName;
+	const safeToolName = sanitizeActivityText(toolName) || "tool";
+	return target ? `${safeToolName} ${target}` : safeToolName;
 }
 
 // ---------------------------------------------------------------------------
@@ -423,19 +366,22 @@ export class MonitorStore {
 	private subscribers = new Set<() => void>();
 
 	beginTurn(): void {
-		// Clear finished runs from a previous turn, but keep any still-active
-		// (queued/running) ones so a concurrent sub-agent call is not wiped.
-		// Retained runs (e.g. an auto-fix chain parent whose chain is still
-		// running) are also preserved — their status is "done" but they must
-		// stay visible until the chain resolves.
+		// Clear finished runs from a previous turn, but keep active and parked
+		// threads so concurrent work is not wiped between parent turns.
 		this.runs = this.runs.filter(
-			(r) => isRunActiveStatus(r.status) || r.status === "parked" || r.retained,
+			(r) => isRunActiveStatus(r.status) || r.status === "parked",
 		);
 		this.notify();
 	}
 
+	/** Reserve a stable id for a durable result that must remain independently
+	 * addressable without appearing as a live monitor row. */
+	reserveRunId(): number {
+		return this.nextId++;
+	}
+
 	addRun(agent: string, task: string, model?: string, thinking?: string, meta?: RunChainMeta): number {
-		const id = this.nextId++;
+		const id = this.reserveRunId();
 		this.runs.push({
 			id,
 			agent,
@@ -444,7 +390,7 @@ export class MonitorStore {
 			model,
 			thinking,
 			status: "queued",
-			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+			usage: emptyUsage(),
 			...(meta?.groupId ? { groupId: meta.groupId } : {}),
 			...(meta?.relationLabel ? { relationLabel: meta.relationLabel } : {}),
 			...(meta?.isolation ? { isolation: meta.isolation, integrationStatus: meta.isolation === "worktree" ? "pending" : undefined } : {}),
@@ -463,7 +409,6 @@ export class MonitorStore {
 			// A model-fallback retry or resumed generation restarts the clock; a
 			// stale endedAt would freeze the elapsed display at the first attempt.
 			if (run.endedAt !== undefined) run.endedAt = undefined;
-			run.lastActivityAt = Date.now();
 		} else if ((status === "parked" || status === "done" || status === "failed") && run.endedAt === undefined) {
 			run.endedAt = Date.now();
 		}
@@ -474,7 +419,6 @@ export class MonitorStore {
 		if (!run) return;
 		run.usage = { ...usage };
 		if (model) run.model = model;
-		run.lastActivityAt = Date.now();
 		this.notify();
 	}
 
@@ -491,56 +435,25 @@ export class MonitorStore {
 	setActivity(id: number, text: string): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.activity = text;
-		run.lastActivityAt = Date.now();
+		run.activity = sanitizeActivityText(text) || undefined;
 		this.notify();
 	}
 
-	/** Record a tool starting: counts it, marks it current, and updates activity.
-	 * A running tool means the run is NOT idle, so needs-attention is suppressed
-	 * while it stays current. */
+	/** Record a tool starting and update the run's visible activity. */
 	recordToolStart(id: number, toolName: string, activity: string): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.toolCount = (run.toolCount ?? 0) + 1;
-		run.currentTool = toolName;
-		run.activity = activity;
-		run.lastActivityAt = Date.now();
+		const safeToolName = sanitizeActivityText(toolName) || "tool";
+		run.activity = sanitizeActivityText(activity) || safeToolName;
 		this.notify();
 	}
 
-	/** Record a tool ending: clears the current-tool marker (so the run becomes
-	 * eligible for needs-attention again) and notes the failure in activity. */
+	/** Record a failed tool; successful completions keep their last activity
+	 * until the next model event supplies a more useful description. */
 	recordToolEnd(id: number, toolName: string, isError: boolean): void {
 		const run = this.find(id);
 		if (!run) return;
-		run.currentTool = undefined;
-		run.lastActivityAt = Date.now();
-		if (isError) run.activity = `✗ ${toolName} failed`;
-		this.notify();
-	}
-
-	/** Set a widget note on the run (e.g. that its auto-fix chain is still running). */
-	setAnnotation(id: number, text: string): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.annotation = text;
-		this.notify();
-	}
-
-	/** Set the run's one-line outcome summary (what a finished chain round did). */
-	setSummary(id: number, text: string | undefined): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.summary = text;
-		this.notify();
-	}
-
-	/** Mark a run as retained (kept in the widget despite being finished). */
-	setRetained(id: number, retained: boolean): void {
-		const run = this.find(id);
-		if (!run) return;
-		run.retained = retained;
+		if (isError) run.activity = `✗ ${sanitizeActivityText(toolName) || "tool"} failed`;
 		this.notify();
 	}
 
@@ -585,7 +498,7 @@ export class MonitorStore {
 				thinking,
 				...(isolation ? { isolation, integrationStatus: isolation === "worktree" ? "pending" as const : undefined } : {}),
 				status: "queued",
-				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+				usage: emptyUsage(),
 			});
 			this.notify();
 			return;
@@ -598,16 +511,10 @@ export class MonitorStore {
 		if (isolation) run.isolation = isolation;
 		run.integrationStatus = isolation === "worktree" ? "pending" : undefined;
 		run.status = "queued";
-		run.usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
+		run.usage = emptyUsage();
 		run.activity = undefined;
-		run.toolCount = undefined;
-		run.currentTool = undefined;
-		run.lastActivityAt = undefined;
 		run.startedAt = undefined;
 		run.endedAt = undefined;
-		run.annotation = undefined;
-		run.summary = undefined;
-		run.retained = undefined;
 		this.notify();
 	}
 
@@ -624,7 +531,7 @@ export class MonitorStore {
 		this.notify();
 	}
 
-	/** Remove a run (finished runs leave the widget). Returns the removed run. */
+	/** Remove a run after publication. Returns the removed run. */
 	removeRun(id: number): RunView | undefined {
 		const index = this.runs.findIndex((r) => r.id === id);
 		if (index === -1) return undefined;
@@ -648,7 +555,6 @@ export class MonitorStore {
 		const usage = formatUsageCompact(run.usage);
 		const parts = [run.agent];
 		if (run.relationLabel) parts.push(run.relationLabel);
-		if (run.summary) parts.push(run.summary);
 		if (run.model) parts.push(run.model);
 		if (run.thinking) parts.push(`thinking ${run.thinking}`);
 		if (run.isolation === "worktree") parts.push(`worktree ${run.integrationStatus ?? "active"}`);
@@ -698,7 +604,7 @@ export function statusIcon(status: RunStatus, theme: Theme): string {
 	}
 }
 
-/** User-facing status label shown in the widget. */
+/** User-facing status label used by tool/status rendering. */
 export function statusLabel(status: RunStatus): string {
 	switch (status) {
 		case "queued":
@@ -717,20 +623,3 @@ export function statusLabel(status: RunStatus): string {
 			return "stopped";
 	}
 }
-
-/** Theme color matching the status label. */
-export function statusColor(status: RunStatus): "accent" | "success" | "error" | "warning" | "dim" {
-	switch (status) {
-		case "running":
-		case "steering":
-			return "accent";
-		case "interrupting":
-			return "warning";
-		case "done":
-			return "success";
-		case "failed":
-			return "error";
-		default:
-			return "dim";
-	}
-}