pi-subagents 0.3.1 → 0.3.3

package/settings.ts

@@ -198,42 +198,46 @@ export function buildChainInstructions(
 	chainDir: string,
 	isFirstProgressAgent: boolean,
 	previousSummary?: string,
-): string {
-	const instructions: string[] = [];
+): { prefix: string; suffix: string } {
+	const prefixParts: string[] = [];
+	const suffixParts: string[] = [];
 
-	// Include previous step's summary if available (prose output from prior agent)
-	if (previousSummary && previousSummary.trim()) {
-		instructions.push(`Previous step summary:\n\n${previousSummary.trim()}`);
-	}
-
-	// Reads (supports both absolute and relative paths)
+	// READS - prepend to override any hardcoded filenames in task text
 	if (behavior.reads && behavior.reads.length > 0) {
-		const files = behavior.reads.map((f) => resolveChainPath(f, chainDir)).join(", ");
-		instructions.push(`Read these files: ${files}`);
+		const files = behavior.reads.map((f) => resolveChainPath(f, chainDir));
+		prefixParts.push(`[Read from: ${files.join(", ")}]`);
 	}
 
-	// Output (supports both absolute and relative paths)
+	// OUTPUT - prepend so agent knows where to write
 	if (behavior.output) {
 		const outputPath = resolveChainPath(behavior.output, chainDir);
-		instructions.push(`Write your output to: ${outputPath}`);
+		prefixParts.push(`[Write to: ${outputPath}]`);
 	}
 
-	// Progress
+	// Progress instructions in suffix (less critical)
 	if (behavior.progress) {
 		const progressPath = `${chainDir}/progress.md`;
 		if (isFirstProgressAgent) {
-			instructions.push(`Create and maintain: ${progressPath}`);
-			instructions.push("Format: Status, Tasks (checkboxes), Files Changed, Notes");
+			suffixParts.push(`Create and maintain progress at: ${progressPath}`);
 		} else {
-			instructions.push(`Read and update: ${progressPath}`);
+			suffixParts.push(`Update progress at: ${progressPath}`);
 		}
 	}
 
-	if (instructions.length === 0) return "";
+	// Include previous step's summary in suffix if available
+	if (previousSummary && previousSummary.trim()) {
+		suffixParts.push(`Previous step output:\n${previousSummary.trim()}`);
+	}
+
+	const prefix = prefixParts.length > 0 
+		? prefixParts.join("\n") + "\n\n"
+		: "";
+	
+	const suffix = suffixParts.length > 0
+		? "\n\n---\n" + suffixParts.join("\n")
+		: "";
 
-	return (
-		"\n\n---\n**Chain Instructions:**\n" + instructions.map((i) => `- ${i}`).join("\n")
-	);
+	return { prefix, suffix };
 }
 
 // =============================================================================

package/types.ts

@@ -193,6 +193,8 @@ export interface RunSyncOptions {
 	index?: number;
 	sessionDir?: string;
 	share?: boolean;
+	/** Override the agent's default model (format: "provider/id" or just "id") */
+	modelOverride?: string;
 }
 
 export interface ExtensionConfig {
@@ -222,7 +224,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;
 }