@ferris1225/pi-subagents 4.1.21 → 4.1.24

package/README.md

@@ -223,28 +223,44 @@ threads that had already finished keep only their delivered result.
 
 ## Live status and results
 
-The TUI widget renders one compact line per run in fixed columns — status icon,
-right-aligned `#id`, padded agent name, then the task label — so every label
-starts at the same column, with the live activity dimmed after ` — ` and one
-right-aligned telemetry column (worktree badge, model/thinking, wait state,
-elapsed) so times line up at the right edge. A managed workflow adds exactly
-one more line: a `└`-connected stage timeline that carries the live stage's
-telemetry instead of extra child rows:
+The TUI widget renders one line per participant in fixed identity columns —
+status icon, right-aligned `#id`, padded agent name, then the task label — so
+every label starts at the same column, with the live activity dimmed after
+` — ` and the rest of the telemetry flowing inline after ` · `: the worktree
+badge, the token flow in the footer vocabulary (`↑` input, `↓` output,
+`R`/`W` cache read/write), cost, the full `provider/model/thinking` ref, the
+wait state, and an elapsed time that always carries seconds. The first line is
+the parent session itself — what the current model is doing right now while
+its agent loop runs. A managed workflow (the automatic review / fix / re-review
+chain) renders as a tree: the parent line carries the workflow-wide token/cost
+totals and total elapsed, and every stage gets its own `├`/`└`-connected row
+with its own model, token flow, and elapsed — settled stages keep the
+telemetry frozen at settlement, the live stage shows its child's model and
+current activity. A live run renders two lines: what it is — agent, task,
+token flow, cost, provider/model, elapsed — and, dim under the label column,
+what it is doing right now:
 
 ```text
-◆ #12 worker    src/cache.ts                       wt:a91f3c · 1m42s
-  └ ✓ implement ─ ● review             read src/auth.ts · 10s
-● #15 explorer  src/models.ts — grep fallback    haiku-4-5/low · 22s
-○ #23 worker    src/config.ts                              repo lane
-○ #24 worker ↻  tests/config.test.ts                  queued · 5m02s
+●    pi        subagent Implement the login redirect fix · openai/gpt-5/max · 12m06s
+◆ #12 worker    src/cache.ts · wt:a91f3c · ↑5.2k ↓41.0k R210.0k W6.1k $1.9400 · 12m06s
+  ├ ✓ implement · ↑1.0k ↓12.0k R40.0k W1.2k $0.5100 · xai/grok-4/xhigh · 2m41s
+  ├ ! review · ↑0.9k ↓6.0k R38.0k W0.9k $0.3300 · openai/gpt-5 · 1m12s
+  ├ ● review fix — edit src/auth.ts · ↑0.2k ↓3.0k R12.0k $0.1200 · openai/gpt-5/medium · 41s
+  └ ○ re-review
+● #15 explorer  src/models.ts · ↑1.2k ↓8.4k R31.0k W1.1k $0.0900 · openai/gpt-5-mini · 3m07s
+                ↳ grep fallback
+○ #23 worker    src/config.ts · repo lane
+○ #24 worker ↻  tests/config.test.ts · queued · 5m02s
 ```
 
-Queued rows state what they actually wait for in the telemetry column —
-`queued` for a free process slot, `repo lane` for shared-checkout write
-serialization, or `starting` — and a resumed thread carries a dim `↻` in its
-agent column with its cumulative time. The widget is capped at ten lines: when
-many runs are live, the extra ones collapse into a `… +N more` marker so the
-editor keeps its space.
+Telemetry drops leftmost-first when a row runs out of width (badge, wait
+state, usage, model) while the elapsed survives every width. Queued rows state
+what they actually wait for — `queued` for a free process slot, `repo lane`
+for shared-checkout write serialization, or `starting` — and a resumed thread
+carries a dim `↻` in its agent column with its cumulative time. The widget is
+capped at ten lines: when many runs are live, extra roots collapse into a
+`… +N more` marker, and an oversized stage chain keeps a window anchored on
+the live stage so the editor keeps its space.
 
 Completions resume the main agent on their own, with a compact block of at most 40
 lines by default; longer output lands unchanged in a Markdown artifact whose path
@@ -292,6 +308,7 @@ strength per agent. Everything else is config-file only, stored at
 ```json
 {
   "enabledAgents": ["explorer", "worker", "cleaner", "documenter", "synthesizer", "reviewer"],
+  "knownAgents": ["explorer", "worker", "cleaner", "documenter", "synthesizer", "reviewer"],
   "agentModels": { "explorer": "anthropic/claude-haiku-4-5" },
   "agentThinkingLevels": { "reviewer": "high" },
   "notifyOnReviewPass": false,
@@ -304,6 +321,7 @@ strength per agent. Everything else is config-file only, stored at
 | Field                 | Meaning                                                                           |
 | --------------------- | --------------------------------------------------------------------------------- |
 | `enabledAgents`       | Agents available for discovery and delegation. `[]` disables all.                 |
+| `knownAgents`         | Built-ins this config has seen; automatic bookkeeping — never edit it.            |
 | `agentModels`         | Optional `provider/model-id` per agent; missing = current main model.             |
 | `agentThinkingLevels` | Optional manual level per agent; missing = Auto.                                  |
 | `notifyOnReviewPass`  | Deliver a standalone passing gate without waking the main agent. Default `false`. |
@@ -318,6 +336,13 @@ start, model overrides pi no longer reports are removed with a one-time notice.
 pi's own session compaction fails mid-thread, a notice surfaces the error and the
 automatic retry instead of failing quietly.
 
+Agents shipped by a newer package version turn themselves on at the next
+session: a built-in the config has never seen is adopted into `enabledAgents`
+and follows explorer's configured model and thinking level — the fast lane
+these light roles need — while an agent you disabled stays disabled
+(`knownAgents` is what tells the two cases apart). Enabling a role in
+`/subagents-setup` adopts the same explorer route.
+
 ## Custom agents
 
 Built-ins ship with the package. Add or replace them with Markdown files:

package/package.json

@@ -1,55 +1,55 @@
-{
-  "name": "@ferris1225/pi-subagents",
-  "version": "4.1.21",
-  "description": "A managed sub-agent team for pi: specialized roles, pre-commit documentation sync, retained threads, auto-fix chains, model fallback, and Git worktree isolation.",
-  "type": "module",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "pi-package",
-    "pi-extension",
-    "subagent",
-    "sub-agent",
-    "delegation",
-    "code-cleanup",
-    "dead-code"
-  ],
-  "files": [
-    "src",
-    "agents",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./src/index.ts"
-    ]
-  },
-  "scripts": {
-    "check": "tsc --noEmit",
-    "test": "vitest run tests",
-    "prepack": "npm run check && npm test"
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-agent-core": ">=0.84.4",
-    "@earendil-works/pi-ai": ">=0.84.4",
-    "@earendil-works/pi-coding-agent": ">=0.84.4",
-    "@earendil-works/pi-tui": ">=0.84.4",
-    "typebox": "*"
-  },
-  "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.4",
-    "@earendil-works/pi-ai": "^0.84.4",
-    "@earendil-works/pi-coding-agent": "^0.84.4",
-    "@earendil-works/pi-tui": "^0.84.4",
-    "@types/node": "^22.10.0",
-    "typebox": "^1.3.9",
-    "typescript": "^5.9.0",
-    "vitest": "^4.1.0"
-  },
-  "engines": {
-    "node": ">=22.19.0"
-  }
-}
+{
+  "name": "@ferris1225/pi-subagents",
+  "version": "4.1.24",
+  "description": "A managed sub-agent team for pi: specialized roles, pre-commit documentation sync, retained threads, auto-fix chains, model fallback, and Git worktree isolation.",
+  "type": "module",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "subagent",
+    "sub-agent",
+    "delegation",
+    "code-cleanup",
+    "dead-code"
+  ],
+  "files": [
+    "src",
+    "agents",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "vitest run tests",
+    "prepack": "npm run check && npm test"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": ">=0.84.4",
+    "@earendil-works/pi-ai": ">=0.84.4",
+    "@earendil-works/pi-coding-agent": ">=0.84.4",
+    "@earendil-works/pi-tui": ">=0.84.4",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-agent-core": "^0.84.4",
+    "@earendil-works/pi-ai": "^0.84.4",
+    "@earendil-works/pi-coding-agent": "^0.84.4",
+    "@earendil-works/pi-tui": "^0.84.4",
+    "@types/node": "^22.10.0",
+    "typebox": "^1.3.9",
+    "typescript": "^5.9.0",
+    "vitest": "^4.1.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  }
+}

package/src/announcements.ts

@@ -4,6 +4,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { existsSync } from "node:fs";
 import { loadConfig, saveConfig } from "./config.ts";
 import { availableModelsInScope, filterUnavailableModelOverrides } from "./models.ts";
+import { formatToolActivity, monitor } from "./monitor.ts";
 import { announceRecoveryRecords } from "./recovery.ts";
 import type { SubagentRuntime } from "./runtime.ts";
 import { installActiveRunsWidget } from "./widget.ts";
@@ -35,7 +36,32 @@ async function migrateUnavailableAgentModels(
 	}
 }
 
+/** Track the parent pi session itself as the widget's first row: what the
+ * current model is doing while its agent loop runs. Same activity vocabulary
+ * as subagent rows (thinking / responding / tool + target), fed by the
+ * session's own extension events; the row disappears when the loop settles. */
+function trackMainActivity(pi: ExtensionAPI): void {
+	pi.on("agent_start", () => monitor.setMainAgentActive(true));
+	pi.on("agent_end", () => monitor.setMainAgentActive(false));
+	pi.on("agent_settled", () => monitor.setMainAgentActive(false));
+	pi.on("model_select", (event) => monitor.setMainModel(event.model?.id));
+	pi.on("thinking_level_select", (event) => monitor.setMainThinking(event.level));
+	pi.on("message_update", (event) => {
+		if (event.message.role !== "assistant") return;
+		const kind = event.assistantMessageEvent.type;
+		if (kind === "text_start" || kind === "text_delta") monitor.setMainActivity("responding");
+		else if (kind === "thinking_start" || kind === "thinking_delta") monitor.setMainActivity("thinking");
+	});
+	pi.on("tool_execution_start", (event) =>
+		monitor.recordMainToolStart(event.toolName, formatToolActivity(event.toolName, event.args)));
+	pi.on("tool_execution_end", (event) => monitor.recordMainToolEnd(event.toolName, event.isError));
+}
+
 export function registerAnnouncements(pi: ExtensionAPI, runtime: SubagentRuntime): void {
+	// Registered at extension load (not session_start) so a model selection
+	// made during restore is already captured when the widget appears.
+	trackMainActivity(pi);
+
 	pi.on("session_start", async (_event, ctx) => {
 		if (!existsSync(runtime.configPath)) {
 			ctx.ui.notify(

package/src/config.ts

@@ -47,6 +47,11 @@ export const IDLE_TIMEOUT_SEC_LIMIT = 600;
 export interface SubagentsConfig {
 	/** Agent names that are discoverable and injected. Fresh-install default: every built-in agent. */
 	enabledAgents: string[];
+	/** Built-in names this config has already surfaced. A shipped agent outside
+	 * this set is new in an upgrade: loadConfig enables it instead of leaving it
+	 * dark behind a stale allow-list. Bookkeeping only — maintained automatically,
+	 * and it is what keeps an explicit disable from being undone. */
+	knownAgents: string[];
 	/** Per-agent model override, keyed by agent name, as "provider/model-id". */
 	agentModels: Record<string, string>;
 	/** Optional per-agent thinking preference. Runtime clamps it to the effective model's supported levels. */
@@ -74,6 +79,7 @@ export interface SubagentsConfig {
 
 export const DEFAULT_CONFIG: SubagentsConfig = {
 	enabledAgents: [...DEFAULT_ENABLED_AGENTS],
+	knownAgents: [...BUILTIN_AGENT_NAMES],
 	agentModels: {},
 	agentThinkingLevels: {},
 	notifyOnReviewPass: false,
@@ -123,6 +129,20 @@ export function normalizeConfig(raw: unknown): SubagentsConfig {
 		config.enabledAgents = [...new Set(names.map((name) => name.trim()))];
 	}
 
+	// Known-agent bookkeeping starts empty for a parsed record (not the fresh
+	// default) so loadConfig can still tell which shipped agents this config
+	// has never seen. Every enabled name was necessarily surfaced.
+	config.knownAgents = [];
+	if (Array.isArray(raw.knownAgents)) {
+		const names = raw.knownAgents.filter(
+			(name): name is string => typeof name === "string" && name.trim().length > 0,
+		);
+		config.knownAgents = [...new Set(names.map((name) => name.trim()))];
+	}
+	for (const name of config.enabledAgents) {
+		if (!config.knownAgents.includes(name)) config.knownAgents.push(name);
+	}
+
 	if (isRecord(raw.agentModels)) {
 		for (const [rawKey, value] of Object.entries(raw.agentModels)) {
 			const key = rawKey.trim();
@@ -173,11 +193,39 @@ function defaultConfig(): SubagentsConfig {
 	};
 }
 
+/**
+ * A shipped agent the config has never recorded is new in this release; the
+ * stale allow-list must not keep it dark. Enable it and adopt explorer's
+ * configured model and thinking level, so an upgrade surfaces the new role on
+ * the fast light-task lane instead of silently spending the main model.
+ */
+function adoptNewBuiltins(config: SubagentsConfig): SubagentsConfig {
+	const known = new Set(config.knownAgents);
+	const fresh = BUILTIN_AGENT_NAMES.filter((name) => !known.has(name));
+	if (fresh.length === 0) return config;
+	const agentModels = { ...config.agentModels };
+	const agentThinkingLevels = { ...config.agentThinkingLevels };
+	for (const name of fresh) {
+		if (!agentModels[name] && config.agentModels.explorer) agentModels[name] = config.agentModels.explorer;
+		if (!agentThinkingLevels[name] && config.agentThinkingLevels.explorer) {
+			agentThinkingLevels[name] = config.agentThinkingLevels.explorer;
+		}
+	}
+	return {
+		...config,
+		enabledAgents: [...config.enabledAgents, ...fresh],
+		knownAgents: [...known, ...fresh],
+		agentModels,
+		agentThinkingLevels,
+	};
+}
+
 /**
  * Load config. A missing file is a normal state and yields the defaults (not an error).
  * A corrupt file also falls back to defaults rather than throwing, so startup never breaks.
  * A file from an older version (missing newer keys or holding extra keys) is
- * normalized and persisted back, so the on-disk config stays current.
+ * normalized and persisted back, so the on-disk config stays current. Built-in
+ * agents the file has never seen are adopted: enabled with explorer's route.
  */
 export async function loadConfig(configPath: string = getConfigPath()): Promise<SubagentsConfig> {
 	let text: string;
@@ -195,7 +243,7 @@ export async function loadConfig(configPath: string = getConfigPath()): Promise<
 		return defaultConfig();
 	}
 
-	const config = normalizeConfig(parsed);
+	const config = adoptNewBuiltins(normalizeConfig(parsed));
 
 	// Schema upgrade: persist the normalized shape when the file gained fields
 	// (new version) or dropped invalid ones.

package/src/dispatch.ts

@@ -30,6 +30,7 @@ import {
 	monitor,
 	statusIcon,
 	type RunChainMeta,
+	type RunView,
 	type RunWaitReason,
 	type WorkflowStage,
 	type WorkflowStageStatus,
@@ -239,18 +240,21 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 	const environmentRef: { current: DispatchEnvironment | undefined } = { current: undefined };
 
 	// Finished runs leave the active monitor immediately. Their final findings
-	// are sent as a custom message that starts a follow-up turn.
+	// are sent as a custom message that starts a follow-up turn. Returns the
+	// removed row so workflow callers can freeze its exact elapsed time onto
+	// the stage projection before the row is gone.
 	const finishRun = (
 		runId: number,
 		status: "done" | "failed",
 		opts?: { silent?: boolean },
-	): void => {
+	): RunView | undefined => {
 		monitor.setStatus(runId, status); // stamps endedAt for the elapsed time
 		const run = monitor.removeRun(runId);
-		if (!run) return; // already finished — stay idempotent
-		if (opts?.silent || !runtime.sessionActive) return;
+		if (!run) return undefined; // already finished — stay idempotent
+		if (opts?.silent || !runtime.sessionActive) return run;
 		const icon = status === "done" ? "✓" : "✗";
 		environmentRef.current?.ctx.ui.notify(`${icon} #${run.id} ${monitor.summarize(run)}`, status === "done" ? "info" : "error");
+		return run;
 	};
 
 	// Live sub-agent activity → concise one-line status ("thinking",
@@ -354,7 +358,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 			agentOverride?: AgentConfig;
 			session?: { sessionId: string; sessionDir: string };
 		} = {},
-	): Promise<{ runId: number; result: SingleResult }> => {
+	): Promise<{ runId: number; result: SingleResult; elapsedMs?: number }> => {
 		const discoveredAgent = request.agents.find((candidate) => candidate.name === agentName);
 		if (!discoveredAgent) {
 			throw new Error(`Managed workflow requires enabled agent "${agentName}", but discovery did not provide it.`);
@@ -411,11 +415,11 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 			runtime.retainSession(result);
 			monitor.setModel(runId, result.model, result.modelFallbackFrom);
 			monitor.setThinking(runId, result.thinking);
-			finishRun(runId, isFailedResult(result) ? "failed" : "done", { silent: true });
+			const finished = finishRun(runId, isFailedResult(result) ? "failed" : "done", { silent: true });
 			runtime.registerRunResult(runId, result);
-			return { runId, result };
+			return { runId, result, elapsedMs: finished?.elapsedMs };
 		} catch (error) {
-			finishRun(runId, "failed", { silent: true });
+			const finished = finishRun(runId, "failed", { silent: true });
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			const crashed: SingleResult = {
 				...queuedResult(route.agent, task, thinkingLevel),
@@ -473,6 +477,11 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 			agent: initialStepResult.agent,
 			relation: initialStageRelation,
 			status: workflowStageStatus(initialStepResult),
+			// The initial stage is the parent's own run; freeze its telemetry now,
+			// before the reopened parent row starts counting workflow-wide time.
+			model: initialStepResult.model,
+			usage: initialStepResult.usage,
+			elapsedMs: monitor.getElapsedMs(request.parentRunId),
 		}];
 		let reviewStage: WorkflowStage | undefined;
 		if (enabled("reviewer")) {
@@ -484,6 +493,14 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 		};
 		publishWorkflowStages();
 
+		/** Freeze the settled step's telemetry onto its stage: once the child row
+		 * leaves the monitor, this snapshot is the only per-stage record. */
+		const settleStage = (stage: WorkflowStage, step: { result: SingleResult; elapsedMs?: number }): void => {
+			stage.model = step.result.model;
+			stage.usage = step.result.usage;
+			if (step.elapsedMs !== undefined) stage.elapsedMs = step.elapsedMs;
+		};
+
 		const launchStep = async (
 			agentName: string,
 			task: string,
@@ -506,6 +523,7 @@ export function registerSubagentTool(pi: ExtensionAPI, runtime: SubagentRuntime)
 					parentRunId: request.parentRunId,
 				}, stageOptions);
 				stage.status = workflowStageStatus(step.result, relation);
+				settleStage(stage, step);
 				publishWorkflowStages();
 				request.rememberLatest(step.result);
 				steps.push({ ...step, relation });

package/src/monitor.ts

@@ -38,6 +38,11 @@ export interface WorkflowStage {
 	agent: string;
 	relation: string;
 	status: WorkflowStageStatus;
+	/** Telemetry snapshot frozen when the stage settled (the live child row
+	 * leaves the monitor at that moment); the active stage reads its live child. */
+	model?: string;
+	usage?: UsageStats;
+	elapsedMs?: number;
 }
 
 export function isRunActiveStatus(status: RunStatus): boolean {
@@ -111,6 +116,17 @@ export interface RunChainMeta {
 	waitReason?: RunWaitReason;
 }
 
+/** Ephemeral activity of the parent pi model while its agent loop runs: the
+ * live model/thinking ref and a one-line "what is it doing now". Not a run —
+ * no id, usage, or chain machinery; the view disappears when the loop settles. */
+export interface MainActivity {
+	model?: string;
+	thinking?: string;
+	activity?: string;
+	/** Epoch ms when the current agent loop started. */
+	activeSince: number;
+}
+
 // ---------------------------------------------------------------------------
 // Formatting helpers
 // ---------------------------------------------------------------------------
@@ -283,20 +299,43 @@ export function runLabel(task: string): string {
 		: `${takeGraphemes(chars, RUN_LABEL_MAX - 1)}${TASK_SUMMARY_ELLIPSIS}`;
 }
 
+/** Narrow an already-extracted run label to a smaller budget, keeping its
+ * tail: runLabel tail-weights path fragments because the filename is the
+ * recognisable part, and a second squeeze must not trade that tail away.
+ * Grapheme-safe. */
+export function shrinkRunLabel(text: string, maxWidth: number): string {
+	if (maxWidth <= 0) return "";
+	if (visibleWidth(text) <= maxWidth) return text;
+	const chars = [...graphemeSegmenter.segment(text)].map((s) => s.segment);
+	return `${TASK_SUMMARY_ELLIPSIS}${tailGraphemes(chars, maxWidth - 1)}`;
+}
+
 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);
 }
 
-export function formatUsageCompact(usage: UsageStats): string {
+/** Token flow in the pi-footer vocabulary: ↑input ↓output, R cache-read,
+ * W cache-write; zero components are omitted. No cost — callers place it as
+ * its own droppable part. */
+export function formatUsageTokens(usage: UsageStats | undefined): string | undefined {
+	if (!usage) return undefined;
 	const parts: string[] = [];
 	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
 	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
 	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
 	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	return parts.join(" ");
+	return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+export function formatUsageCompact(usage: UsageStats): string {
+	return [formatUsageTokens(usage), usageCostPart(usage)].filter(Boolean).join(" ");
+}
+
+/** Cost as its own droppable part: `$0.0421`, undefined when nothing accrued. */
+export function usageCostPart(usage: UsageStats | undefined): string | undefined {
+	return usage?.cost ? `$${usage.cost.toFixed(4)}` : undefined;
 }
 
 /** Aggregate usage across several runs (chain steps or a completion group). */
@@ -319,9 +358,11 @@ export function formatDuration(ms: number): string {
 	if (totalSeconds < 60) return `${totalSeconds}s`;
 	const minutes = Math.floor(totalSeconds / 60);
 	const seconds = totalSeconds % 60;
+	// Seconds stay visible at every magnitude: a long-running chain is judged
+	// by whether it is still moving, and "5s ago" is exactly that signal.
 	if (minutes < 60) return `${minutes}m${String(seconds).padStart(2, "0")}s`;
 	const hours = Math.floor(minutes / 60);
-	return `${hours}h${String(minutes % 60).padStart(2, "0")}m`;
+	return `${hours}h${String(minutes % 60).padStart(2, "0")}m${String(seconds).padStart(2, "0")}s`;
 }
 
 /** Cumulative active time across generations; parked gaps never count. */
@@ -453,6 +494,71 @@ export class MonitorStore {
 	private runs: RunView[] = [];
 	private nextId = 1;
 	private subscribers = new Set<() => void>();
+	private mainModel?: string;
+	private mainThinking?: string;
+	private mainActivity?: string;
+	private mainActiveSince?: number;
+
+	// --- parent pi model activity ------------------------------------------
+	// Fed by the parent session's extension events (agent loop, streaming,
+	// tool executions); rendered as the widget's first line. Change-guarded so
+	// per-token streaming deltas do not flood subscribers.
+
+	setMainModel(model?: string): void {
+		if (!model || this.mainModel === model) return;
+		this.mainModel = model;
+		this.notify();
+	}
+
+	setMainThinking(thinking?: string): void {
+		if (!thinking || this.mainThinking === thinking) return;
+		this.mainThinking = thinking;
+		this.notify();
+	}
+
+	setMainActivity(text: string): void {
+		const activity = sanitizeActivityText(text) || undefined;
+		if (!activity || this.mainActivity === activity) return;
+		this.mainActivity = activity;
+		this.notify();
+	}
+
+	/** Record the main model starting a tool; the activity shows the tool's
+	 * most telling argument, same vocabulary as subagent rows. */
+	recordMainToolStart(toolName: string, activity: string): void {
+		const safeToolName = sanitizeActivityText(toolName) || "tool";
+		this.setMainActivity(activity || safeToolName);
+	}
+
+	/** Record a failed main-model tool; successful completions keep their last
+	 * activity until the next model event supplies a better description. */
+	recordMainToolEnd(toolName: string, isError: boolean): void {
+		if (isError) this.setMainActivity(`✗ ${sanitizeActivityText(toolName) || "tool"} failed`);
+	}
+
+	/** Track the parent agent loop: started at agent_start, cleared when the
+	 * loop settles (agent_end / agent_settled). */
+	setMainAgentActive(active: boolean): void {
+		if ((this.mainActiveSince !== undefined) === active) return;
+		this.mainActiveSince = active ? Date.now() : undefined;
+		this.mainActivity = undefined;
+		this.notify();
+	}
+
+	/** Live view of the parent model while its agent loop runs; undefined when idle. */
+	getMainActivity(): MainActivity | undefined {
+		if (this.mainActiveSince === undefined) return undefined;
+		return {
+			...(this.mainModel ? { model: this.mainModel } : {}),
+			...(this.mainThinking ? { thinking: this.mainThinking } : {}),
+			...(this.mainActivity ? { activity: this.mainActivity } : {}),
+			activeSince: this.mainActiveSince,
+		};
+	}
+
+	isMainAgentActive(): boolean {
+		return this.mainActiveSince !== undefined;
+	}
 
 	beginTurn(): void {
 		// Clear finished runs from a previous turn, but keep active and parked
@@ -719,6 +825,10 @@ export class MonitorStore {
 	 * finishRun calls from the old session remain safe no-ops. */
 	clear(): void {
 		this.runs = [];
+		this.mainModel = undefined;
+		this.mainThinking = undefined;
+		this.mainActivity = undefined;
+		this.mainActiveSince = undefined;
 		this.notify();
 	}