@bacnh85/pi-subagent 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.9.1 (2026-07-16)
+
+### Activity-aware timeouts
+
+- Child `timeout` values now define a sliding inactivity window (three minutes by default); real SDK lifecycle events reset it while a fixed 20-minute hard cap remains.
+- `/agent` distinguishes real activity from transport heartbeats and reports idle versus hard timeouts.
+
 ## 0.9.0 (2026-07-16)
 
 ### Model routing

package/README.md

@@ -86,12 +86,12 @@ Unknown or misspelled tool names produce clear diagnostics. Duplicate tool names
 
 Every child execution receives a timeout:
 
-- **Default:** 10 minutes (`DEFAULT_TIMEOUT_MS`)
-- **Maximum:** 60 minutes (`MAX_TIMEOUT_MS`)
-- Timeout values must be positive integers within the allowed range.
-- Timeout errors are distinguishable from parent cancellation.
-- Progress heartbeats keep the parent transport active during quiet model work; explicit timeouts remain hard deadlines.
-- Parallel tasks and chain steps may have per-item timeouts.
+- **Default inactivity window:** 3 minutes (`DEFAULT_TIMEOUT_MS`); real SDK lifecycle activity resets it.
+- **Absolute cap:** 20 minutes for every child, even when active.
+- **Maximum requested inactivity window:** 60 minutes (`MAX_TIMEOUT_MS`); values must be positive integers.
+- Timeout diagnostics distinguish `Idle timeout` from `Hard timeout` and parent cancellation.
+- 30-second progress heartbeats only keep the parent transport alive; they never reset inactivity.
+- `/agent` shows last real activity and the remaining idle window; parallel tasks and chain steps may have per-item windows.
 
 ### Output safety
 

package/extensions/index.ts

@@ -32,6 +32,7 @@ import { Type } from "typebox";
 
 import { type AgentColor, type AgentConfig, type AgentScope, discoverAgents, formatAgentList, getModelCandidates, invalidateAgentCache } from "./agents.ts";
 import {
+	type SubAgentProgress,
 	type SubAgentResult,
 	getFinalOutput,
 	getResultOutput,
@@ -94,14 +95,14 @@ const TaskItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
 	task: Type.String({ description: "Task to delegate to the agent" }),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent" })),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds for this task" })),
+	timeout: Type.Optional(Type.Number({ description: "Inactivity timeout in milliseconds for this task; real child activity resets it (default 3 minutes, absolute cap 20 minutes)" })),
 });
 
 const ChainItem = Type.Object({
 	agent: Type.String({ description: "Name of the agent to invoke" }),
 	task: Type.String({ description: "Task with optional {previous} placeholder for prior output" }),
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent" })),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds for this step" })),
+	timeout: Type.Optional(Type.Number({ description: "Inactivity timeout in milliseconds for this step; real child activity resets it (default 3 minutes, absolute cap 20 minutes)" })),
 });
 
 const AgentScopeSchema = StringEnum(["user", "project", "both"] as const, {
@@ -126,7 +127,7 @@ const SubagentParams = Type.Object({
 	// Project-agent confirmation is enforced via trusted configuration.
 	// See Security model section in README.
 	cwd: Type.Optional(Type.String({ description: "Working directory (single mode, must be inside workspace)" })),
-	timeout: Type.Optional(Type.Number({ description: "Global timeout in milliseconds for all sub-agents (overridden by per-task/step timeouts)" })),
+	timeout: Type.Optional(Type.Number({ description: "Global inactivity timeout in milliseconds (default 3 minutes; real activity resets it; fixed 20-minute absolute cap)" })),
 	instructions: Type.Optional(Type.String({ description: "Bounded repository/task instructions passed to each child (max 16 KB)" })),
 	abortOnFailure: Type.Optional(Type.Boolean({ description: "In parallel mode, cancel remaining tasks when one fails. Default: false.", default: false })),
 });
@@ -208,6 +209,7 @@ export default function (pi: ExtensionAPI) {
 			instructions: request.instructions,
 			signal: request.signal,
 			onMessage: (result) => threadStore.updateThread(thread.id, { result }),
+			onProgress: (progress) => { threadStore.updateProgress(thread.id, progress); request.onProgress?.(progress); },
 		}).then((result) => {
 			threadStore.updateThread(thread.id, {
 				status: isFailedResult(result) ? (result.stopReason === "aborted" ? "aborted" : "failed") : "completed",
@@ -520,7 +522,9 @@ export default function (pi: ExtensionAPI) {
 				parentSignal?: AbortSignal,
 				timeoutMs?: number,
 				onProgress?: (partial: SubAgentResult) => void,
+				onActivity?: (progress: SubAgentProgress) => void,
 				heartbeatDetails?: () => SubagentDetails,
+				onHeartbeat?: () => void,
 				isReadOnly?: boolean,
 			): Promise<SubAgentResult> {
 				const agent = agents.find((a) => a.name === agentName);
@@ -582,10 +586,10 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
-				const stopHeartbeat = onUpdate ? startHeartbeat(() => onUpdate({
-					content: [{ type: "text", text: `Subagent ${agentName} is still running…` }],
-					details: heartbeatDetails?.() ?? makeDetails("single")([]),
-				})) : undefined;
+				const stopHeartbeat = onUpdate ? startHeartbeat(() => {
+					onHeartbeat?.();
+					onUpdate({ content: [{ type: "text", text: `Subagent ${agentName} is still running…` }], details: heartbeatDetails?.() ?? makeDetails("single")([]) });
+				}) : undefined;
 				try {
 					return await runSubAgent({
 						cwd: safeCwd,
@@ -602,6 +606,7 @@ export default function (pi: ExtensionAPI) {
 						agentName,
 						thinkingLevel: agent.thinking,
 						onMessage: onProgress,
+						onProgress: onActivity,
 					});
 				} finally {
 					stopHeartbeat?.();
@@ -628,7 +633,9 @@ export default function (pi: ExtensionAPI) {
 						step.agent, taskWithContext, step.cwd,
 						signal, step.timeout ?? params.timeout,
 						(partial) => threadStore.updateThread(thread.id, { result: partial }),
+						(progress) => threadStore.updateProgress(thread.id, progress),
 						() => makeDetails("chain")(results),
+						() => threadStore.refreshHeartbeat(thread.id),
 					);
 					threadStore.updateThread(thread.id, {
 						status: isFailedResult(result) ? (result.stopReason === "aborted" ? "aborted" : "failed") : "completed",
@@ -782,7 +789,9 @@ export default function (pi: ExtensionAPI) {
 									t.agent, t.task, t.cwd,
 									parallelController.signal, t.timeout ?? params.timeout,
 									(partial) => threadStore.updateThread(parallelThreads[index].id, { result: partial }),
+									(progress) => threadStore.updateProgress(parallelThreads[index].id, progress),
 									() => makeDetails("parallel")([...allResults]),
+									() => threadStore.refreshHeartbeat(parallelThreads[index].id),
 								);
 								allResults[index] = result;
 								threadStore.updateThread(parallelThreads[index].id, {
@@ -838,7 +847,9 @@ export default function (pi: ExtensionAPI) {
 					params.agent, params.task, params.cwd,
 					signal, params.timeout,
 					(partial) => threadStore.updateThread(thread.id, { result: partial }),
+					(progress) => threadStore.updateProgress(thread.id, progress),
 					() => makeDetails("single")([]),
+					() => threadStore.refreshHeartbeat(thread.id),
 				);
 				threadStore.updateThread(thread.id, {
 					status: isFailedResult(result) ? (result.stopReason === "aborted" ? "aborted" : "failed") : "completed",

package/extensions/runner.ts

@@ -45,6 +45,18 @@ export interface UsageStats {
 	turns: number;
 }
 
+export const DEFAULT_INACTIVITY_TIMEOUT_MS = 3 * 60 * 1000;
+export const HARD_TIMEOUT_MS = 20 * 60 * 1000;
+
+export interface SubAgentProgress {
+	label: string;
+	at: number;
+	elapsedMs: number;
+	inactivityDeadline: number;
+	hardDeadline: number;
+	result: SubAgentResult;
+}
+
 export interface SubAgentResult {
 	agent: string;
 	task: string;
@@ -81,231 +93,110 @@ export async function runSubAgent(options: {
 	agentName?: string;
 	thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 	onMessage?: (partialResult: SubAgentResult) => void;
-	/** Pre-validated timeout in ms. When provided, an abort signal will be created. */
+	onProgress?: (progress: SubAgentProgress) => void;
 	timeoutMs?: number;
+	hardTimeoutMs?: number;
 }): Promise<SubAgentResult> {
 	const {
-		cwd,
-		systemPrompt,
-		task,
-		tools,
-		model,
-		authStorage,
-		modelRegistry,
-		signal,
-		agentName = "subagent",
-		thinkingLevel = "off",
-		onMessage,
-		timeoutMs,
+		cwd, systemPrompt, task, tools, model, authStorage, modelRegistry, signal,
+		agentName = "subagent", thinkingLevel = "off", onMessage, onProgress,
+		timeoutMs = DEFAULT_INACTIVITY_TIMEOUT_MS, hardTimeoutMs = HARD_TIMEOUT_MS,
 	} = options;
-
 	const result: SubAgentResult = {
-		agent: agentName,
-		task,
-		exitCode: 0,
-		messages: [],
-		stderr: "",
+		agent: agentName, task, exitCode: 0, messages: [], stderr: "",
 		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
-		model: `${model.provider}/${model.id}`,
-		status: undefined,
+		model: `${model.provider}/${model.id}`, status: undefined,
 	};
-
-	// Build a minimal resource loader. The sub-agent sees ONLY the agent's
-	// system prompt — no pi defaults, no AGENTS.md, no extensions, no skills.
 	const resourceLoader: ResourceLoader = {
 		getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
-		getSkills: () => ({ skills: [], diagnostics: [] }),
-		getPrompts: () => ({ prompts: [], diagnostics: [] }),
-		getThemes: () => ({ themes: [], diagnostics: [] }),
-		getAgentsFiles: () => ({ agentsFiles: [] }),
-		getSystemPrompt: () => systemPrompt,
-		getAppendSystemPrompt: () => [],
-		extendResources: () => {},
-		reload: async () => {},
+		getSkills: () => ({ skills: [], diagnostics: [] }), getPrompts: () => ({ prompts: [], diagnostics: [] }),
+		getThemes: () => ({ themes: [], diagnostics: [] }), getAgentsFiles: () => ({ agentsFiles: [] }),
+		getSystemPrompt: () => systemPrompt, getAppendSystemPrompt: () => [], extendResources: () => {}, reload: async () => {},
 	};
-
-	const settingsManager = SettingsManager.inMemory({
-		compaction: { enabled: false },
-		retry: { enabled: true, maxRetries: 1 },
-	});
-
-	// Hoisted so the outer catch can clean up on early failure.
-	let timeoutController: AbortController | undefined;
-	let timeoutId: ReturnType<typeof setTimeout> | undefined;
+	const settingsManager = SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: true, maxRetries: 1 } });
+	const startedAt = Date.now();
+	let inactivityDeadline = startedAt + timeoutMs;
+	const hardDeadline = startedAt + hardTimeoutMs;
+	let timeoutKind: "idle" | "hard" | undefined;
+	const timeoutController = new AbortController();
+	let idleTimer: ReturnType<typeof setTimeout> | undefined;
+	let hardTimer: ReturnType<typeof setTimeout> | undefined;
 	let cleanupCombined: (() => void) | undefined;
-
+	const clearTimers = () => { if (idleTimer) clearTimeout(idleTimer); if (hardTimer) clearTimeout(hardTimer); };
+	const armIdle = () => {
+		if (idleTimer) clearTimeout(idleTimer);
+		inactivityDeadline = Date.now() + timeoutMs;
+		idleTimer = setTimeout(() => { timeoutKind = "idle"; timeoutController.abort(new Error(`Idle timeout after ${timeoutMs}ms`)); }, timeoutMs);
+	};
+	const snapshot = (label: string): SubAgentProgress => ({ label, at: Date.now(), elapsedMs: Date.now() - startedAt, inactivityDeadline, hardDeadline, result: { ...result, messages: [...result.messages] } });
 	try {
-		// Build combined signal from parent signal and timeout
-		const signalsToCombine: (AbortSignal | undefined | null | false)[] = [signal];
-
-		// Create timeout controller
-		if (timeoutMs && timeoutMs > 0) {
-			timeoutController = new AbortController();
-			timeoutId = setTimeout(() => timeoutController!.abort(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs);
-			signalsToCombine.push(timeoutController.signal);
-		}
-
-		const { signal: combinedSignal, cleanup: cleanupCb } = createCombinedAbortSignal(signalsToCombine);
-		cleanupCombined = cleanupCb;
-
+		armIdle();
+		hardTimer = setTimeout(() => { timeoutKind = "hard"; timeoutController.abort(new Error(`Hard timeout after ${hardTimeoutMs}ms`)); }, hardTimeoutMs);
+		const { signal: combinedSignal, cleanup } = createCombinedAbortSignal([signal, timeoutController.signal]);
+		cleanupCombined = cleanup;
 		if (combinedSignal.aborted) {
 			result.exitCode = 1;
-			const isTimeout = timeoutController?.signal.aborted === true && signal?.aborted !== true;
-			result.stopReason = isTimeout ? "timeout" : "aborted";
-			result.errorMessage = combinedSignal.reason instanceof Error ? combinedSignal.reason.message : "Sub-agent aborted before start";
-			result.status = classifyStopReason(result.stopReason, !isTimeout, isTimeout);
-			cleanupCombined?.();
-			if (timeoutId) clearTimeout(timeoutId);
+			const timedOut = timeoutController.signal.aborted && !signal?.aborted;
+			result.stopReason = timedOut ? "timeout" : "aborted";
+			result.errorMessage = timedOut ? `${timeoutKind === "idle" ? "Idle" : "Hard"} timeout after ${timeoutKind === "idle" ? timeoutMs : hardTimeoutMs}ms` : "Sub-agent aborted before start";
+			result.status = classifyStopReason(result.stopReason, !timedOut, timedOut);
 			return result;
 		}
-
-		const { session } = await createAgentSession({
-			cwd,
-			model,
-			thinkingLevel,
-			authStorage,
-			modelRegistry,
-			resourceLoader,
-			tools,
-			sessionManager: SessionManager.inMemory(cwd),
-			settingsManager,
-		});
-
-		let cleanupAbort: (() => void) | undefined;
-		let cleanupEventAbort: (() => void) | undefined;
-		let abortedBySignal = false;
-		let timedOut = false;
-		let eventUnsubscribe: (() => void) | undefined;
-
+		const { session } = await createAgentSession({ cwd, model, thinkingLevel, authStorage, modelRegistry, resourceLoader, tools, sessionManager: SessionManager.inMemory(cwd), settingsManager });
+		let unsubscribe: (() => void) | undefined;
+		let removeAbort: (() => void) | undefined;
 		try {
-			// Wire combined abort signal to session
-			const onAbort = () => {
-				session.abort();
-			};
-			if (combinedSignal.aborted) {
-				abortedBySignal = true;
-				timedOut = timeoutController?.signal.aborted === true && signal?.aborted !== true;
-				onAbort();
-				return result;
-			}
-			combinedSignal.addEventListener("abort", onAbort, { once: true });
-			cleanupAbort = () => combinedSignal.removeEventListener("abort", onAbort);
-
-			// Collect all messages and usage stats from events
-			const eventPromise = new Promise<void>((resolve, reject) => {
-				let settled = false;
-				const finish = (fn: () => void) => {
-					if (settled) return;
-					settled = true;
-					fn();
-				};
-
-				let unsubscribe: (() => void) | undefined;
+			const eventDone = new Promise<void>((resolve, reject) => {
+				let done = false;
+				const finish = (fn: () => void) => { if (!done) { done = true; unsubscribe?.(); fn(); } };
 				unsubscribe = session.subscribe((event) => {
 					try {
-						switch (event.type) {
-							case "message_end": {
-								const msg = event.message as AgentMessage;
-								if (msg.role === "assistant") {
-									result.usage.turns++;
-									if (msg.usage) {
-										result.usage.input += msg.usage.input || 0;
-										result.usage.output += msg.usage.output || 0;
-										result.usage.cacheRead += msg.usage.cacheRead || 0;
-										result.usage.cacheWrite += msg.usage.cacheWrite || 0;
-										result.usage.cost += msg.usage.cost?.total || 0;
-										result.usage.contextTokens = msg.usage.totalTokens || 0;
-									}
-									if (!result.model && msg.model) {
-										result.model = `${msg.provider || "?"}/${msg.model}`;
-									}
-									if (msg.stopReason) result.stopReason = msg.stopReason;
-									result.errorMessage = msg.errorMessage;
-								}
-								// Collect all messages for extraction
-								result.messages.push(msg as unknown as Message);
-								if (onMessage) onMessage({ ...result, messages: [...result.messages] });
-								break;
-							}
-							case "agent_end": {
-								if (event.willRetry) break;
-								// agent_end carries all messages; use them if we haven't collected
-								if (result.messages.length === 0 && event.messages) {
-									result.messages = event.messages as unknown as Message[];
-								}
-								finish(() => {
-									unsubscribe?.();
-									resolve();
-								});
-								break;
+						// Any SDK session lifecycle event is actual child activity, unlike a parent heartbeat.
+						armIdle(); onProgress?.(snapshot(event.type));
+						if (event.type === "message_end") {
+							const msg = event.message as AgentMessage;
+							if (msg.role === "assistant") {
+								result.usage.turns++;
+								if (msg.usage) { result.usage.input += msg.usage.input || 0; result.usage.output += msg.usage.output || 0; result.usage.cacheRead += msg.usage.cacheRead || 0; result.usage.cacheWrite += msg.usage.cacheWrite || 0; result.usage.cost += msg.usage.cost?.total || 0; result.usage.contextTokens = msg.usage.totalTokens || 0; }
+								if (!result.model && msg.model) result.model = `${msg.provider || "?"}/${msg.model}`;
+								if (msg.stopReason) result.stopReason = msg.stopReason;
+								result.errorMessage = msg.errorMessage;
 							}
+							result.messages.push(msg as unknown as Message);
+							onMessage?.({ ...result, messages: [...result.messages] });
+						} else if (event.type === "agent_end" && !event.willRetry) {
+							if (!result.messages.length && event.messages) result.messages = event.messages as unknown as Message[];
+							finish(resolve);
 						}
-					} catch (err) {
-						finish(() => {
-							unsubscribe?.();
-							reject(err);
-						});
-					}
+					} catch (error) { finish(() => reject(error)); }
 				});
-				eventUnsubscribe = unsubscribe;
-
-				// Resolve on abort so the eventPromise doesn't hang
-				const onAbortResolve = () => {
-					finish(() => {
-						result.exitCode = 1;
-						if (!result.errorMessage) result.errorMessage = "Sub-agent aborted";
-						unsubscribe?.();
-						resolve();
-					});
-				};
-				combinedSignal.addEventListener("abort", onAbortResolve, { once: true });
-				cleanupEventAbort = () => combinedSignal.removeEventListener("abort", onAbortResolve);
+				const abort = () => finish(resolve);
+				combinedSignal.addEventListener("abort", abort, { once: true });
+				removeAbort = () => combinedSignal.removeEventListener("abort", abort);
 			});
-
-			await Promise.race([
-				session.prompt(task),
-				eventPromise,
-			]);
-
-			// Detect timeout vs. parent abort.
-			timedOut = timeoutController?.signal.aborted === true && signal?.aborted !== true;
-			abortedBySignal = combinedSignal.aborted && !timedOut;
-
-			if (timedOut) {
-				result.stopReason = "timeout";
-				result.errorMessage = `Timeout after ${timeoutMs}ms`;
-			} else if (abortedBySignal) {
-				result.stopReason = "aborted";
-				result.errorMessage ||= "Sub-agent aborted";
-			}
-
-			// Classify canonical status and keep the legacy exit code consistent.
+			const abortSession = () => session.abort();
+			combinedSignal.addEventListener("abort", abortSession, { once: true });
+			const removeSessionAbort = () => combinedSignal.removeEventListener("abort", abortSession);
+			await Promise.race([session.prompt(task), eventDone]);
+			removeSessionAbort();
+			const timedOut = timeoutController.signal.aborted && !signal?.aborted;
+			if (timedOut) { result.stopReason = "timeout"; result.errorMessage = `${timeoutKind === "idle" ? "Idle" : "Hard"} timeout after ${timeoutKind === "idle" ? timeoutMs : hardTimeoutMs}ms`; }
+			else if (combinedSignal.aborted) { result.stopReason = "aborted"; result.errorMessage ||= "Sub-agent aborted"; }
 			result.status = classifyStopReason(result.stopReason, result.stopReason === "aborted", result.stopReason === "timeout");
 			result.exitCode = result.status === "success" || result.status === "partial" ? 0 : 1;
-
 			return result;
 		} finally {
-			cleanupAbort?.();
-			cleanupEventAbort?.();
-			cleanupCombined();
-			eventUnsubscribe?.();
-			if (timeoutId) clearTimeout(timeoutId);
-			try {
-				session.dispose();
-			} catch {
-				// Best-effort cleanup
-			}
+			unsubscribe?.(); removeAbort?.();
+			try { session.dispose(); } catch { /* best effort */ }
 		}
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
+	} catch (error) {
 		result.exitCode = 1;
-		result.errorMessage = message;
-		if (!result.stopReason) result.stopReason = "error";
-		result.status = classifyStopReason("error", false, false);
-		// Ensure cleanup runs even when the outer try fails before the inner finally.
-		cleanupCombined?.();
-		if (timeoutId) clearTimeout(timeoutId);
+		result.errorMessage = error instanceof Error ? error.message : String(error);
+		result.stopReason ||= "error";
+		result.status = classifyStopReason(result.stopReason, false, false);
 		return result;
+	} finally {
+		clearTimers(); cleanupCombined?.();
 	}
 }
 

package/extensions/security.ts

@@ -28,11 +28,10 @@ export const MUTATION_TOOLS: readonly string[] = ["edit", "write"];
 export const EXECUTION_TOOLS: readonly string[] = ["bash"];
 
 /**
- * Default timeout applied to every child execution unless an explicit timeout
- * is provided. Children may request a shorter-but-not-longer timeout within
- * the allowed range.
+ * Default inactivity timeout. Real SDK lifecycle activity resets this window;
+ * the runner separately enforces a fixed 20-minute absolute cap.
  */
-export const DEFAULT_TIMEOUT_MS = 10 * 60 * 1_000; // 10 minutes
+export const DEFAULT_TIMEOUT_MS = 3 * 60 * 1_000; // 3 minutes
 
 /**
  * Absolute maximum timeout. Any requested value above this cap is rejected

package/extensions/service.ts

@@ -1,6 +1,6 @@
 import { AuthStorage, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type AgentConfig, getModelCandidates } from "./agents.ts";
-import { runSubAgent, type SubAgentResult } from "./runner.ts";
+import { runSubAgent, type SubAgentProgress, type SubAgentResult } from "./runner.ts";
 import { resolveModel } from "./model.ts";
 import {
 	validateAgentTools,
@@ -23,6 +23,7 @@ export interface SubagentRunRequest {
 	signal?: AbortSignal;
 	accept?: () => boolean;
 	respond: (response: SubagentRunResponse) => void;
+	onProgress?: (progress: SubAgentProgress) => void;
 }
 
 export type SubagentRunResponse =
@@ -38,6 +39,7 @@ export async function runNamedAgent(options: {
 	instructions?: string;
 	signal?: AbortSignal;
 	onMessage?: (result: SubAgentResult) => void;
+	onProgress?: (progress: SubAgentProgress) => void;
 }): Promise<SubAgentResult> {
 	const { model, attempted } = await resolveModel(getModelCandidates(options.agent), options.ctx.model, options.ctx.modelRegistry);
 	if (!model) throw new Error(`No model resolved for agent "${options.agent.name}" (tried: ${attempted.join(", ") || "none"})`);
@@ -88,6 +90,7 @@ export async function runNamedAgent(options: {
 			agentName: options.agent.name,
 			thinkingLevel: options.agent.thinking,
 			onMessage: options.onMessage,
+			onProgress: options.onProgress,
 		});
 		return result;
 	} finally {

package/extensions/thread-viewer.ts

@@ -146,6 +146,14 @@ export class ThreadViewer {
 		lines.push(truncateToWidth(t.fg("dim", this.thread.task), width));
 		lines.push("");
 
+		if (status === "running") {
+			const now = Date.now();
+			const elapsed = Math.floor((now - this.thread.createdAt) / 1000);
+			const activity = this.thread.lastActivityAt ? `${Math.floor((now - this.thread.lastActivityAt) / 1000)}s ago (${this.thread.lastActivityLabel})` : "none yet";
+			const idleMs = this.thread.inactivityDeadline ? this.thread.inactivityDeadline - now : 0;
+			const idle = this.thread.inactivityDeadline ? `${Math.max(0, Math.ceil(idleMs / 1000))}s remaining` : "pending";
+			lines.push(truncateToWidth(t.fg(idleMs < 30_000 ? "warning" : "muted", `Elapsed ${elapsed}s · last activity ${activity} · idle ${idle}`), width));
+		}
 		if (status === "running" && (!result || result.messages.length === 0)) {
 			lines.push(truncateToWidth(t.fg("muted", "(waiting for first message...)"), width));
 		} else if (result) {

package/extensions/threads.ts

@@ -6,7 +6,7 @@
  * Supports subscriptions so UIs can react to thread status changes.
  */
 
-import type { SubAgentResult } from "./runner.ts";
+import type { SubAgentProgress, SubAgentResult } from "./runner.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -26,6 +26,11 @@ export interface SubagentThread {
 	color?: string;
 	createdAt: number;
 	updatedAt: number;
+	lastActivityAt?: number;
+	lastActivityLabel?: string;
+	lastHeartbeatAt?: number;
+	inactivityDeadline?: number;
+	hardDeadline?: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -84,6 +89,26 @@ export class ThreadStore {
 		this.notify();
 	}
 
+	updateProgress(id: string, progress: SubAgentProgress): void {
+		const thread = this.threads.get(id);
+		if (!thread) return;
+		thread.result = progress.result;
+		thread.lastActivityAt = progress.at;
+		thread.lastActivityLabel = progress.label;
+		thread.inactivityDeadline = progress.inactivityDeadline;
+		thread.hardDeadline = progress.hardDeadline;
+		thread.updatedAt = Date.now();
+		this.notify();
+	}
+
+	refreshHeartbeat(id: string): void {
+		const thread = this.threads.get(id);
+		if (!thread) return;
+		thread.lastHeartbeatAt = Date.now();
+		thread.updatedAt = thread.lastHeartbeatAt;
+		this.notify();
+	}
+
 	getThread(id: string): SubagentThread | undefined {
 		return this.threads.get(id);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-subagent",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "In-process subagents for Pi with isolated SDK sessions, parallel and chained delegation, and inspectable threads.",
   "type": "module",
   "license": "MIT",