taskplane 0.24.1 → 0.24.2

package/dashboard/public/app.js

@@ -101,6 +101,11 @@ function mergeV2LaneSnapshot(legacyLs, v2snap) {
   return base;
 }
 
+function isReviewerActiveForTask(ls, task) {
+  if (!ls || !task) return false;
+  return !!(ls.reviewerStatus === "running" && task.status === "running" && (!ls.taskId || ls.taskId === task.taskId));
+}
+
 /** Build a compact token summary string from lane state sidecar data.
  *  Display: ↑total_input ↓output (cost)
  *  Anthropic splits input into: uncached `input` + `cacheRead`.
@@ -612,10 +617,10 @@ function renderLanesTasks(batch, tmuxSessions) {
 
       // Worker stats from lane state sidecar + telemetry badges
       let workerHtml = "";
-      // Reviewer sub-row should only appear under the task currently being reviewed,
-      // not all tasks in the lane. The lane-state sidecar is per-lane (shared by all
-      // tasks in the lane), so check that the sidecar's current taskId matches this task.
-      const reviewerActive = ls && ls.reviewerStatus === "running" && ls.taskId === task.taskId;
+      // Reviewer sub-row should only appear under the active running task in this lane.
+      // Runtime V2 snapshots provide taskId; during early startup it can be briefly unset,
+      // so allow a task-status fallback while still avoiding duplicate rows.
+      const reviewerActive = isReviewerActiveForTask(ls, task);
       const telemBadges = task.status !== "pending" ? telemetryBadgesHtml(tel, reviewerActive) : "";
       if (ls && ls.workerStatus === "running" && task.status === "running") {
         const elapsed = ls.workerElapsed ? `${Math.round(ls.workerElapsed / 1000)}s` : "";

package/dashboard/server.cjs

@@ -997,6 +997,43 @@ function computeBatchTotalCost(laneStates, telemetry) {
   return totalCost;
 }
 
+function synthesizeLaneStateFromSnapshot(key, snap, fallbackBatchId) {
+  const w = snap.worker || {};
+  const r = snap.reviewer || null;
+  const statusMap = { running: "running", spawning: "running", exited: "done", crashed: "error", killed: "error", timed_out: "error", wrapping_up: "running" };
+  const reviewerStatusMap = { running: "running", spawning: "running", wrapping_up: "running", exited: "done", crashed: "done", killed: "done", timed_out: "done" };
+
+  return {
+    prefix: key,
+    taskId: snap.taskId || null,
+    phase: snap.status === "running" ? "worker-active" : snap.status === "complete" ? "complete" : "idle",
+    workerStatus: statusMap[w.status] || w.status || "idle",
+    workerElapsed: w.elapsedMs || 0,
+    workerContextPct: w.contextPct || 0,
+    workerLastTool: w.lastTool || "",
+    workerToolCount: w.toolCalls || 0,
+    workerInputTokens: w.inputTokens || 0,
+    workerOutputTokens: w.outputTokens || 0,
+    workerCacheReadTokens: w.cacheReadTokens || 0,
+    workerCacheWriteTokens: w.cacheWriteTokens || 0,
+    workerCostUsd: w.costUsd || 0,
+    reviewerStatus: r ? (reviewerStatusMap[r.status] || r.status || "running") : "idle",
+    reviewerElapsed: r?.elapsedMs || 0,
+    reviewerContextPct: r?.contextPct || 0,
+    reviewerLastTool: r?.lastTool || "",
+    reviewerToolCount: r?.toolCalls || 0,
+    reviewerCostUsd: r?.costUsd || 0,
+    reviewerInputTokens: r?.inputTokens || 0,
+    reviewerOutputTokens: r?.outputTokens || 0,
+    reviewerCacheReadTokens: r?.cacheReadTokens || 0,
+    reviewerCacheWriteTokens: r?.cacheWriteTokens || 0,
+    reviewerType: r?.reviewType || "",
+    reviewerStep: r?.reviewStep || 0,
+    batchId: snap.batchId || fallbackBatchId,
+    timestamp: snap.updatedAt || Date.now(),
+  };
+}
+
 /** Build full dashboard state object for the frontend. */
 function buildDashboardState() {
   const state = loadBatchState();
@@ -1046,26 +1083,7 @@ function buildDashboardState() {
       const laneRec = (state.lanes || []).find(l => l.laneNumber === Number(laneNum));
       const key = laneRec ? (laneRec.laneSessionId) : `lane-${laneNum}`;
       if (!laneStates[key] || (snap.updatedAt && snap.updatedAt > (laneStates[key].timestamp || 0))) {
-        const w = snap.worker || {};
-        const statusMap = { running: "running", spawning: "running", exited: "done", crashed: "error", killed: "error", timed_out: "error", wrapping_up: "running" };
-        laneStates[key] = {
-          prefix: key,
-          taskId: snap.taskId || null,
-          phase: snap.status === "running" ? "worker-active" : snap.status === "complete" ? "complete" : "idle",
-          workerStatus: statusMap[w.status] || w.status || "idle",
-          workerElapsed: w.elapsedMs || 0,
-          workerContextPct: w.contextPct || 0,
-          workerLastTool: w.lastTool || "",
-          workerToolCount: w.toolCalls || 0,
-          workerInputTokens: w.inputTokens || 0,
-          workerOutputTokens: w.outputTokens || 0,
-          workerCacheReadTokens: w.cacheReadTokens || 0,
-          workerCacheWriteTokens: w.cacheWriteTokens || 0,
-          workerCostUsd: w.costUsd || 0,
-          reviewerStatus: "idle",
-          batchId: snap.batchId || state.batchId,
-          timestamp: snap.updatedAt || Date.now(),
-        };
+        laneStates[key] = synthesizeLaneStateFromSnapshot(key, snap, state.batchId);
       }
     }
   }

package/extensions/taskplane/agent-bridge-extension.ts

@@ -24,7 +24,7 @@
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@mariozechner/pi-ai";
-import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync } from "fs";
+import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, unlinkSync } from "fs";
 import { join, dirname } from "path";
 import { spawn as nodeSpawn } from "child_process";
 import { randomBytes } from "crypto";
@@ -216,11 +216,44 @@ export default function (pi: ExtensionAPI) {
 		return basePrompt;
 	}
 
+	function reviewerStatePath(taskFolder: string): string {
+		return join(taskFolder, ".reviewer-state.json");
+	}
+
+	function writeReviewerState(taskFolder: string, state: {
+		status: "running" | "done" | "error";
+		elapsedMs: number;
+		toolCalls: number;
+		contextPct: number;
+		costUsd: number;
+		lastTool: string;
+		inputTokens: number;
+		outputTokens: number;
+		cacheReadTokens: number;
+		cacheWriteTokens: number;
+		updatedAt: number;
+		reviewType?: string;
+		reviewStep?: number;
+	}): void {
+		const filePath = reviewerStatePath(taskFolder);
+		const tmpPath = filePath + ".tmp";
+		writeFileSync(tmpPath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+		renameSync(tmpPath, filePath);
+	}
+
+	function removeReviewerState(taskFolder: string): void {
+		const filePath = reviewerStatePath(taskFolder);
+		if (!existsSync(filePath)) return;
+		try { unlinkSync(filePath); } catch { /* best effort */ }
+	}
+
 	/**
 	 * Spawn a reviewer Pi subprocess and wait for it to complete.
 	 * Returns the process exit code.
 	 */
-	function spawnReviewer(prompt: string, systemPrompt: string, cwd: string): Promise<number> {
+	function spawnReviewer(prompt: string, systemPrompt: string, cwd: string, taskFolder: string, reviewType?: string, reviewStep?: number): Promise<number> {
+		// Pre-clean stale reviewer state from prior interrupted review
+		removeReviewerState(taskFolder);
 		return new Promise((resolve) => {
 			const cliPath = resolvePiCli();
 			const args = [
@@ -235,23 +268,124 @@ export default function (pi: ExtensionAPI) {
 				env: { ...process.env },
 			});
 
-			// Send prompt and close stdin after delay
+			const startedAt = Date.now();
+			let inputTokens = 0;
+			let outputTokens = 0;
+			let cacheReadTokens = 0;
+			let cacheWriteTokens = 0;
+			let costUsd = 0;
+			let toolCalls = 0;
+			let lastTool = "";
+			let contextPct = 0;
+			let stdoutBuf = "";
+			let finalized = false;
+
+			const emitState = (status: "running" | "done" | "error") => {
+				try {
+					writeReviewerState(taskFolder, {
+						status,
+						elapsedMs: Date.now() - startedAt,
+						toolCalls,
+						contextPct,
+						costUsd,
+						lastTool,
+						inputTokens,
+						outputTokens,
+						cacheReadTokens,
+						cacheWriteTokens,
+						updatedAt: Date.now(),
+						reviewType,
+						reviewStep,
+					});
+				} catch { /* best effort */ }
+			};
+
+			// Write initial "running" state immediately so dashboard shows
+			// the reviewer sub-row before the first message_end arrives.
+			emitState("running");
+
+			const closeStdin = () => {
+				setTimeout(() => {
+					try { proc.stdin?.end(); } catch { /* ignore */ }
+				}, 100);
+			};
+
+			const finalize = (code: number) => {
+				if (finalized) return;
+				finalized = true;
+				emitState(code === 0 ? "done" : "error");
+				resolve(code);
+			};
+
+			const handleEvent = (event: any) => {
+				if (!event || typeof event.type !== "string") return;
+				switch (event.type) {
+					case "message_end": {
+						const usage = event.message?.usage;
+						if (usage) {
+							inputTokens += usage.input || 0;
+							outputTokens += usage.output || 0;
+							cacheReadTokens += usage.cacheRead || 0;
+							cacheWriteTokens += usage.cacheWrite || 0;
+							if (usage.cost) {
+								costUsd += typeof usage.cost === "object"
+									? (usage.cost.total || 0)
+									: (typeof usage.cost === "number" ? usage.cost : 0);
+							}
+						}
+						emitState("running");
+						break;
+					}
+					case "tool_execution_start": {
+						toolCalls++;
+						const toolName = event.toolName || "tool";
+						const argPreview = typeof event.args === "string"
+							? event.args.slice(0, 80)
+							: (event.args && typeof Object.values(event.args)[0] === "string"
+								? String(Object.values(event.args)[0]).slice(0, 80)
+								: "");
+						lastTool = argPreview ? `${toolName}: ${argPreview}` : toolName;
+						emitState("running");
+						break;
+					}
+					case "response": {
+						const pct = event.success === true ? event.data?.contextUsage?.percent : undefined;
+						if (typeof pct === "number" && Number.isFinite(pct)) {
+							contextPct = pct;
+						}
+						break;
+					}
+					case "agent_end": {
+						closeStdin();
+						break;
+					}
+				}
+			};
+
+			// Send prompt immediately
 			proc.stdin?.write(JSON.stringify({ type: "prompt", message: prompt }) + "\n");
 
-			// Watch for agent_end event to close stdin
-			let buf = "";
-			proc.stdout?.on("data", (chunk: Buffer) => {
-				buf += chunk.toString();
-				if (buf.includes('"agent_end"')) {
-					setTimeout(() => { try { proc.stdin?.end(); } catch {} }, 100);
+			proc.stdout?.on("data", (chunk: Buffer | string) => {
+				stdoutBuf += typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+				let idx = -1;
+				while ((idx = stdoutBuf.indexOf("\n")) >= 0) {
+					let line = stdoutBuf.slice(0, idx);
+					stdoutBuf = stdoutBuf.slice(idx + 1);
+					if (line.endsWith("\r")) line = line.slice(0, -1);
+					if (!line.trim()) continue;
+					let event: any;
+					try { event = JSON.parse(line); } catch { continue; }
+					handleEvent(event);
 				}
 			});
 
-			proc.on("close", (code) => resolve(code ?? 1));
-			proc.on("error", () => resolve(1));
+			proc.on("close", (code) => finalize(code ?? 1));
+			proc.on("error", () => finalize(1));
 
 			// Timeout: 10 minutes
-			setTimeout(() => { try { proc.kill("SIGTERM"); } catch {} }, 10 * 60 * 1000);
+			setTimeout(() => {
+				try { proc.kill("SIGTERM"); } catch { /* ignore */ }
+			}, 10 * 60 * 1000);
 		});
 	}
 
@@ -367,7 +501,7 @@ export default function (pi: ExtensionAPI) {
 
 			try {
 				const systemPrompt = loadReviewerPrompt();
-				const exitCode = await spawnReviewer(reviewPrompt, systemPrompt, cwd);
+				const exitCode = await spawnReviewer(reviewPrompt, systemPrompt, cwd, taskFolder, reviewType, stepNum);
 
 				// Update review counter in STATUS.md
 				try {
@@ -395,6 +529,8 @@ export default function (pi: ExtensionAPI) {
 						writeFileSync(statusPath, status.trimEnd() + "\n" + logEntry);
 					} catch { /* best effort */ }
 
+					removeReviewerState(taskFolder);
+
 					const reviewFile = `.reviews/R${num}-${reviewType}-step${stepNum}.md`;
 					if (verdict === "APPROVE") {
 						return { content: [{ type: "text" as const, text: `APPROVE` }], details: undefined };
@@ -408,9 +544,11 @@ export default function (pi: ExtensionAPI) {
 						return { content: [{ type: "text" as const, text: `Review complete (verdict unclear). See ${reviewFile}` }], details: undefined };
 					}
 				} else {
+					removeReviewerState(taskFolder);
 					return { content: [{ type: "text" as const, text: `UNAVAILABLE — reviewer exited (code ${exitCode}) but produced no output.` }], details: undefined };
 				}
 			} catch (err) {
+				removeReviewerState(taskFolder);
 				return {
 					content: [{ type: "text" as const, text: `UNAVAILABLE — reviewer failed: ${err instanceof Error ? err.message : String(err)}` }],
 					details: undefined,

package/extensions/taskplane/lane-runner.ts

@@ -283,6 +283,7 @@ export async function executeTaskV2(
 
 		// Context pressure: write wrap-up signal before kill
 		let workerKillReason: "context" | "timer" | null = null;
+		let iterationTelemetry: Partial<AgentHostResult> = {};
 
 		const spawned = spawnAgent(hostOpts, undefined, (telemetry) => {
 			// Context pressure check
@@ -298,12 +299,25 @@ export async function executeTaskV2(
 				}
 			}
 
+			iterationTelemetry = telemetry;
 			lastTelemetry = telemetry;
 			// Emit lane snapshot
 			emitSnapshot(config, taskId, "running", telemetry, statusPath);
 		});
 
-		const workerResult = await spawned.promise;
+		// Reviewer telemetry is written by the worker bridge during review_step.
+		// Poll snapshot refresh independently from worker message_end cadence so
+		// the dashboard sees reviewer activity while tool calls are in-flight.
+		const reviewerRefresh = setInterval(() => {
+			emitSnapshot(config, taskId, "running", iterationTelemetry, statusPath);
+		}, 1000);
+
+		let workerResult: AgentHostResult;
+		try {
+			workerResult = await spawned.promise;
+		} finally {
+			clearInterval(reviewerRefresh);
+		}
 
 		// TP-115: Update lastTelemetry with definitive final values from AgentHostResult
 		lastTelemetry = workerResult;
@@ -538,6 +552,59 @@ function makeResult(
 	return result;
 }
 
+/** Max age for reviewer state file before it's considered stale (2 minutes). */
+const REVIEWER_STATE_STALE_MS = 120_000;
+
+export function readReviewerTelemetrySnapshot(
+	config: LaneRunnerConfig,
+	statusPath: string,
+): (RuntimeAgentTelemetrySnapshot & { reviewType?: string; reviewStep?: number }) | null {
+	const reviewerPath = join(dirname(statusPath), ".reviewer-state.json");
+	if (!existsSync(reviewerPath)) return null;
+
+	try {
+		const raw = readFileSync(reviewerPath, "utf-8");
+		const parsed = JSON.parse(raw) as Partial<{
+			status: string;
+			elapsedMs: number;
+			toolCalls: number;
+			contextPct: number;
+			costUsd: number;
+			lastTool: string;
+			inputTokens: number;
+			outputTokens: number;
+			cacheReadTokens: number;
+			cacheWriteTokens: number;
+			updatedAt: number;
+			reviewType: string;
+			reviewStep: number;
+		}>;
+
+		if (parsed.status !== "running") return null;
+
+		// Stale guard: if updatedAt is present and older than threshold, ignore
+		if (parsed.updatedAt && (Date.now() - parsed.updatedAt) > REVIEWER_STATE_STALE_MS) return null;
+
+		return {
+			agentId: buildRuntimeAgentId(config.agentIdPrefix, config.laneNumber, "reviewer"),
+			status: "running",
+			elapsedMs: Number.isFinite(parsed.elapsedMs) ? Number(parsed.elapsedMs) : 0,
+			toolCalls: Number.isFinite(parsed.toolCalls) ? Number(parsed.toolCalls) : 0,
+			contextPct: Number.isFinite(parsed.contextPct) ? Number(parsed.contextPct) : 0,
+			costUsd: Number.isFinite(parsed.costUsd) ? Number(parsed.costUsd) : 0,
+			lastTool: typeof parsed.lastTool === "string" ? parsed.lastTool : "",
+			inputTokens: Number.isFinite(parsed.inputTokens) ? Number(parsed.inputTokens) : 0,
+			outputTokens: Number.isFinite(parsed.outputTokens) ? Number(parsed.outputTokens) : 0,
+			cacheReadTokens: Number.isFinite(parsed.cacheReadTokens) ? Number(parsed.cacheReadTokens) : 0,
+			cacheWriteTokens: Number.isFinite(parsed.cacheWriteTokens) ? Number(parsed.cacheWriteTokens) : 0,
+			reviewType: typeof parsed.reviewType === "string" ? parsed.reviewType : undefined,
+			reviewStep: Number.isFinite(parsed.reviewStep) ? Number(parsed.reviewStep) : undefined,
+		};
+	} catch {
+		return null;
+	}
+}
+
 function emitSnapshot(
 	config: LaneRunnerConfig,
 	taskId: string,
@@ -562,6 +629,8 @@ function emitSnapshot(
 		};
 	} catch { /* best effort */ }
 
+	const reviewerSnapshot = readReviewerTelemetrySnapshot(config, statusPath);
+
 	const snapshot: RuntimeLaneSnapshot = {
 		batchId: config.batchId,
 		laneNumber: config.laneNumber,
@@ -583,7 +652,7 @@ function emitSnapshot(
 			cacheReadTokens: telemetry.cacheReadTokens ?? 0,
 			cacheWriteTokens: telemetry.cacheWriteTokens ?? 0,
 		},
-		reviewer: null,
+		reviewer: reviewerSnapshot,
 		progress,
 		updatedAt: Date.now(),
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskplane",
-  "version": "0.24.1",
+  "version": "0.24.2",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",