pi-subagents 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.2] - 2026-01-25
+
+### Performance
+- **4x faster polling** - Reduced poll interval from 1000ms to 250ms (efficient with mtime caching)
+- **Mtime-based caching** - status.json and output tail reads cached to avoid redundant I/O
+- **Unified throttled updates** - All onUpdate calls consolidated under 50ms throttle
+- **Widget change detection** - Hash-based change detection skips no-op re-renders
+- **Array optimizations** - Use concat instead of spread for chain progress updates
+
+### Fixed
+- **Timer leaks** - Track and clear pendingTimer and cleanupTimers properly
+- **Updates after close** - processClosed flag prevents updates after process terminates  
+- **Session cleanup** - Clear cleanup timers on session_start/switch/branch/shutdown
+
 ## [0.3.1] - 2026-01-24
 
 ### Changed

package/chain-execution.ts

@@ -250,18 +250,22 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 						artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
 						artifactConfig,
 						onUpdate: onUpdate
-							? (p) =>
+							? (p) => {
+									// Use concat instead of spread for better performance
+									const stepResults = p.details?.results || [];
+									const stepProgress = p.details?.progress || [];
 									onUpdate({
 										...p,
 										details: {
 											mode: "chain",
-											results: [...results, ...(p.details?.results || [])],
-											progress: [...allProgress, ...(p.details?.progress || [])],
+											results: results.concat(stepResults),
+											progress: allProgress.concat(stepProgress),
 											chainAgents,
 											totalSteps,
 											currentStepIndex: stepIndex,
 										},
-									})
+									});
+								}
 							: undefined,
 					});
 
@@ -372,18 +376,22 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
 				artifactConfig,
 				onUpdate: onUpdate
-					? (p) =>
+					? (p) => {
+							// Use concat instead of spread for better performance
+							const stepResults = p.details?.results || [];
+							const stepProgress = p.details?.progress || [];
 							onUpdate({
 								...p,
 								details: {
 									mode: "chain",
-									results: [...results, ...(p.details?.results || [])],
-									progress: [...allProgress, ...(p.details?.progress || [])],
+									results: results.concat(stepResults),
+									progress: allProgress.concat(stepProgress),
 									chainAgents,
 									totalSteps,
 									currentStepIndex: stepIndex,
 								},
-							})
+							});
+						}
 					: undefined,
 			});
 

package/execution.ts

@@ -132,6 +132,50 @@ export async function runSync(
 		const proc = spawn("pi", args, { cwd: cwd ?? runtimeCwd, stdio: ["ignore", "pipe", "pipe"] });
 		let buf = "";
 
+		// Throttled update mechanism - consolidates all updates
+		let lastUpdateTime = 0;
+		let updatePending = false;
+		let pendingTimer: ReturnType<typeof setTimeout> | null = null;
+		let processClosed = false;
+		const UPDATE_THROTTLE_MS = 50; // Reduced from 75ms for faster responsiveness
+
+		const scheduleUpdate = () => {
+			if (!onUpdate || processClosed) return;
+			const now = Date.now();
+			const elapsed = now - lastUpdateTime;
+
+			if (elapsed >= UPDATE_THROTTLE_MS) {
+				// Enough time passed, update immediately
+				// Clear any pending timer to avoid double-updates
+				if (pendingTimer) {
+					clearTimeout(pendingTimer);
+					pendingTimer = null;
+				}
+				lastUpdateTime = now;
+				updatePending = false;
+				progress.durationMs = now - startTime;
+				onUpdate({
+					content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
+					details: { mode: "single", results: [result], progress: [progress] },
+				});
+			} else if (!updatePending) {
+				// Schedule update for later
+				updatePending = true;
+				pendingTimer = setTimeout(() => {
+					pendingTimer = null;
+					if (updatePending && !processClosed) {
+						updatePending = false;
+						lastUpdateTime = Date.now();
+						progress.durationMs = Date.now() - startTime;
+						onUpdate({
+							content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
+							details: { mode: "single", results: [result], progress: [progress] },
+						});
+					}
+				}, UPDATE_THROTTLE_MS - elapsed);
+			}
+		};
+
 		const processLine = (line: string) => {
 			if (!line.trim()) return;
 			jsonlLines.push(line);
@@ -144,11 +188,9 @@ export async function runSync(
 					progress.toolCount++;
 					progress.currentTool = evt.toolName;
 					progress.currentToolArgs = extractToolArgsPreview((evt.args || {}) as Record<string, unknown>);
-					if (onUpdate)
-						onUpdate({
-							content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-							details: { mode: "single", results: [result], progress: [progress] },
-						});
+					// Tool start is important - update immediately by forcing throttle reset
+					lastUpdateTime = 0;
+					scheduleUpdate();
 				}
 
 				if (evt.type === "tool_execution_end") {
@@ -164,11 +206,7 @@ export async function runSync(
 					}
 					progress.currentTool = undefined;
 					progress.currentToolArgs = undefined;
-					if (onUpdate)
-						onUpdate({
-							content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-							details: { mode: "single", results: [result], progress: [progress] },
-						});
+					scheduleUpdate();
 				}
 
 				if (evt.type === "message_end" && evt.message) {
@@ -193,15 +231,14 @@ export async function runSync(
 								.split("\n")
 								.filter((l) => l.trim())
 								.slice(-10);
-							// Append to existing recentOutput (keep last 50 total)
-							progress.recentOutput = [...progress.recentOutput, ...lines].slice(-50);
+							// Append to existing recentOutput (keep last 50 total) - mutate in place for efficiency
+							progress.recentOutput.push(...lines);
+							if (progress.recentOutput.length > 50) {
+								progress.recentOutput.splice(0, progress.recentOutput.length - 50);
+							}
 						}
 					}
-					if (onUpdate)
-						onUpdate({
-							content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-							details: { mode: "single", results: [result], progress: [progress] },
-						});
+					scheduleUpdate();
 				}
 				if (evt.type === "tool_result_end" && evt.message) {
 					result.messages.push(evt.message);
@@ -212,21 +249,18 @@ export async function runSync(
 							.split("\n")
 							.filter((l) => l.trim())
 							.slice(-10);
-						// Append to existing recentOutput (keep last 50 total)
-						progress.recentOutput = [...progress.recentOutput, ...toolLines].slice(-50);
+						// Append to existing recentOutput (keep last 50 total) - mutate in place for efficiency
+						progress.recentOutput.push(...toolLines);
+						if (progress.recentOutput.length > 50) {
+							progress.recentOutput.splice(0, progress.recentOutput.length - 50);
+						}
 					}
-					if (onUpdate)
-						onUpdate({
-							content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-							details: { mode: "single", results: [result], progress: [progress] },
-						});
+					scheduleUpdate();
 				}
 			} catch {}
 		};
 
 		let stderrBuf = "";
-		let lastUpdateTime = 0;
-		const UPDATE_THROTTLE_MS = 75;
 
 		proc.stdout.on("data", (d) => {
 			buf += d.toString();
@@ -234,21 +268,18 @@ export async function runSync(
 			buf = lines.pop() || "";
 			lines.forEach(processLine);
 
-			// Throttled periodic update for smoother progress display
-			const now = Date.now();
-			if (onUpdate && now - lastUpdateTime > UPDATE_THROTTLE_MS) {
-				lastUpdateTime = now;
-				progress.durationMs = now - startTime;
-				onUpdate({
-					content: [{ type: "text", text: getFinalOutput(result.messages) || "(running...)" }],
-					details: { mode: "single", results: [result], progress: [progress] },
-				});
-			}
+			// Also schedule an update on data received (handles streaming output)
+			scheduleUpdate();
 		});
 		proc.stderr.on("data", (d) => {
 			stderrBuf += d.toString();
 		});
 		proc.on("close", (code) => {
+			processClosed = true;
+			if (pendingTimer) {
+				clearTimeout(pendingTimer);
+				pendingTimer = null;
+			}
 			if (buf.trim()) processLine(buf);
 			if (code !== 0 && stderrBuf.trim() && !result.error) {
 				result.error = stderrBuf.trim();

package/index.ts

@@ -73,6 +73,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	let baseCwd = process.cwd();
 	let currentSessionId: string | null = null;
 	const asyncJobs = new Map<string, AsyncJobState>();
+	const cleanupTimers = new Map<string, ReturnType<typeof setTimeout>>(); // Track cleanup timeouts
 	let lastUiContext: ExtensionContext | null = null;
 	let poller: NodeJS.Timeout | null = null;
 
@@ -88,6 +89,10 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			}
 
 			for (const job of asyncJobs.values()) {
+				// Skip status reads for finished jobs - they won't change
+				if (job.status === "complete" || job.status === "failed") {
+					continue;
+				}
 				const status = readStatus(job.asyncDir);
 				if (status) {
 					job.status = status.state;
@@ -589,10 +594,13 @@ For "scout → planner" or multi-step flows, use chain (not multiple single call
 		if (lastUiContext) {
 			renderWidget(lastUiContext, Array.from(asyncJobs.values()));
 		}
-		setTimeout(() => {
+		// Schedule cleanup after 10 seconds (track timer for cleanup on shutdown)
+		const timer = setTimeout(() => {
+			cleanupTimers.delete(asyncId);
 			asyncJobs.delete(asyncId);
 			if (lastUiContext) renderWidget(lastUiContext, Array.from(asyncJobs.values()));
 		}, 10000);
+		cleanupTimers.set(asyncId, timer);
 	});
 
 	pi.on("tool_result", (event, ctx) => {
@@ -608,6 +616,8 @@ For "scout → planner" or multi-step flows, use chain (not multiple single call
 	pi.on("session_start", (_event, ctx) => {
 		baseCwd = ctx.cwd;
 		currentSessionId = ctx.sessionManager.getSessionFile() ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		for (const timer of cleanupTimers.values()) clearTimeout(timer);
+		cleanupTimers.clear();
 		asyncJobs.clear();
 		if (ctx.hasUI) {
 			lastUiContext = ctx;
@@ -617,6 +627,8 @@ For "scout → planner" or multi-step flows, use chain (not multiple single call
 	pi.on("session_switch", (_event, ctx) => {
 		baseCwd = ctx.cwd;
 		currentSessionId = ctx.sessionManager.getSessionFile() ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		for (const timer of cleanupTimers.values()) clearTimeout(timer);
+		cleanupTimers.clear();
 		asyncJobs.clear();
 		if (ctx.hasUI) {
 			lastUiContext = ctx;
@@ -626,6 +638,8 @@ For "scout → planner" or multi-step flows, use chain (not multiple single call
 	pi.on("session_branch", (_event, ctx) => {
 		baseCwd = ctx.cwd;
 		currentSessionId = ctx.sessionManager.getSessionFile() ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		for (const timer of cleanupTimers.values()) clearTimeout(timer);
+		cleanupTimers.clear();
 		asyncJobs.clear();
 		if (ctx.hasUI) {
 			lastUiContext = ctx;
@@ -636,6 +650,11 @@ For "scout → planner" or multi-step flows, use chain (not multiple single call
 		watcher.close();
 		if (poller) clearInterval(poller);
 		poller = null;
+		// Clear all pending cleanup timers
+		for (const timer of cleanupTimers.values()) {
+			clearTimeout(timer);
+		}
+		cleanupTimers.clear();
 		asyncJobs.clear();
 		if (lastUiContext?.hasUI) {
 			lastUiContext.ui.setWidget(WIDGET_KEY, undefined);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",

package/render.ts

@@ -16,21 +16,46 @@ import { getFinalOutput, getDisplayItems, getOutputTail, getLastActivity } from
 
 type Theme = ExtensionContext["ui"]["theme"];
 
+// Track last rendered widget state to avoid no-op re-renders
+let lastWidgetHash = "";
+
+/**
+ * Compute a simple hash of job states for change detection
+ */
+function computeWidgetHash(jobs: AsyncJobState[]): string {
+	return jobs.slice(0, MAX_WIDGET_JOBS).map(job =>
+		`${job.asyncId}:${job.status}:${job.currentStep}:${job.updatedAt}:${job.totalTokens?.total ?? 0}`
+	).join("|");
+}
+
 /**
  * Render the async jobs widget
  */
 export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
 	if (!ctx.hasUI) return;
 	if (jobs.length === 0) {
-		ctx.ui.setWidget(WIDGET_KEY, undefined);
+		if (lastWidgetHash !== "") {
+			lastWidgetHash = "";
+			ctx.ui.setWidget(WIDGET_KEY, undefined);
+		}
 		return;
 	}
 
+	// Check if anything changed since last render
+	// Always re-render if any displayed job is running (output tail updates constantly)
+	const displayedJobs = jobs.slice(0, MAX_WIDGET_JOBS);
+	const hasRunningJobs = displayedJobs.some(job => job.status === "running");
+	const newHash = computeWidgetHash(jobs);
+	if (!hasRunningJobs && newHash === lastWidgetHash) {
+		return; // Skip re-render, nothing changed
+	}
+	lastWidgetHash = newHash;
+
 	const theme = ctx.ui.theme;
 	const lines: string[] = [];
 	lines.push(theme.fg("accent", "Async subagents"));
 
-	for (const job of jobs.slice(0, MAX_WIDGET_JOBS)) {
+	for (const job of displayedJobs) {
 		const id = job.asyncId.slice(0, 6);
 		const status =
 			job.status === "complete"

package/types.ts

@@ -222,7 +222,7 @@ export const MAX_CONCURRENCY = 4;
 export const RESULTS_DIR = "/tmp/pi-async-subagent-results";
 export const ASYNC_DIR = "/tmp/pi-async-subagent-runs";
 export const WIDGET_KEY = "subagent-async";
-export const POLL_INTERVAL_MS = 1000;
+export const POLL_INTERVAL_MS = 250;
 export const MAX_WIDGET_JOBS = 4;
 
 // ============================================================================

package/utils.ts

@@ -12,37 +12,71 @@ import type { AsyncStatus, DisplayItem, ErrorInfo } from "./types.js";
 // File System Utilities
 // ============================================================================
 
+// Cache for status file reads - avoid re-reading unchanged files
+const statusCache = new Map<string, { mtime: number; status: AsyncStatus }>();
+
 /**
- * Read async job status from disk
+ * Read async job status from disk (with mtime-based caching)
  */
 export function readStatus(asyncDir: string): AsyncStatus | null {
 	const statusPath = path.join(asyncDir, "status.json");
-	if (!fs.existsSync(statusPath)) return null;
 	try {
+		const stat = fs.statSync(statusPath);
+		const cached = statusCache.get(statusPath);
+		if (cached && cached.mtime === stat.mtimeMs) {
+			return cached.status;
+		}
 		const content = fs.readFileSync(statusPath, "utf-8");
-		return JSON.parse(content) as AsyncStatus;
+		const status = JSON.parse(content) as AsyncStatus;
+		statusCache.set(statusPath, { mtime: stat.mtimeMs, status });
+		// Limit cache size to prevent memory leaks
+		if (statusCache.size > 50) {
+			const firstKey = statusCache.keys().next().value;
+			if (firstKey) statusCache.delete(firstKey);
+		}
+		return status;
 	} catch {
 		return null;
 	}
 }
 
+// Cache for output tail reads - avoid re-reading unchanged files
+const outputTailCache = new Map<string, { mtime: number; size: number; lines: string[] }>();
+
 /**
- * Get the last N lines from an output file
+ * Get the last N lines from an output file (with mtime/size-based caching)
  */
 export function getOutputTail(outputFile: string | undefined, maxLines: number = 3): string[] {
-	if (!outputFile || !fs.existsSync(outputFile)) return [];
+	if (!outputFile) return [];
 	let fd: number | null = null;
 	try {
 		const stat = fs.statSync(outputFile);
 		if (stat.size === 0) return [];
+
+		// Check cache using both mtime and size (size changes more frequently during writes)
+		const cached = outputTailCache.get(outputFile);
+		if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
+			return cached.lines;
+		}
+
 		const tailBytes = 4096;
 		const start = Math.max(0, stat.size - tailBytes);
 		fd = fs.openSync(outputFile, "r");
 		const buffer = Buffer.alloc(Math.min(tailBytes, stat.size));
 		fs.readSync(fd, buffer, 0, buffer.length, start);
 		const content = buffer.toString("utf-8");
-		const lines = content.split("\n").filter((l) => l.trim());
-		return lines.slice(-maxLines).map((l) => l.slice(0, 120) + (l.length > 120 ? "..." : ""));
+		const allLines = content.split("\n").filter((l) => l.trim());
+		const lines = allLines.slice(-maxLines).map((l) => l.slice(0, 120) + (l.length > 120 ? "..." : ""));
+
+		// Cache the result
+		outputTailCache.set(outputFile, { mtime: stat.mtimeMs, size: stat.size, lines });
+		// Limit cache size
+		if (outputTailCache.size > 20) {
+			const firstKey = outputTailCache.keys().next().value;
+			if (firstKey) outputTailCache.delete(firstKey);
+		}
+
+		return lines;
 	} catch {
 		return [];
 	} finally {
@@ -58,8 +92,9 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
  * Get human-readable last activity time for a file
  */
 export function getLastActivity(outputFile: string | undefined): string {
-	if (!outputFile || !fs.existsSync(outputFile)) return "";
+	if (!outputFile) return "";
 	try {
+		// Single stat call - throws if file doesn't exist
 		const stat = fs.statSync(outputFile);
 		const ago = Date.now() - stat.mtimeMs;
 		if (ago < 1000) return "active now";
@@ -91,11 +126,14 @@ export function findLatestSessionFile(sessionDir: string): string | null {
 	if (!fs.existsSync(sessionDir)) return null;
 	const files = fs.readdirSync(sessionDir)
 		.filter((f) => f.endsWith(".jsonl"))
-		.map((f) => ({
-			name: f,
-			path: path.join(sessionDir, f),
-			mtime: fs.statSync(path.join(sessionDir, f)).mtimeMs,
-		}))
+		.map((f) => {
+			const filePath = path.join(sessionDir, f);
+			return {
+				name: f,
+				path: filePath,
+				mtime: fs.statSync(filePath).mtimeMs,
+			};
+		})
 		.sort((a, b) => b.mtime - a.mtime);
 	return files.length > 0 ? files[0].path : null;
 }