taskplane 0.24.0 → 0.24.2

package/extensions/taskplane/execution.ts

@@ -853,18 +853,26 @@ export async function resolveTaskMonitorState(
 	runtimeBackend?: RuntimeBackend,
 	v2Context?: { stateRoot: string; batchId: string; laneNumber: number },
 ): Promise<TaskMonitorSnapshot> {
-	// TP-115: Backend-aware liveness check.
+	// TP-115/TP-127: Backend-aware liveness check.
 	// V2: read the lane snapshot file written by lane-runner every second.
-	// Snapshot status is authoritative — no PID probing needed.
 	// If snapshot doesn't exist yet, assume alive (lane-runner startup race).
+	// If snapshot belongs to a different task, it's stale transition data from
+	// the previous wave/task and should be treated like startup grace (alive).
 	// Legacy: check lane-session liveness.
 	let sessionAlive: boolean;
 	if (runtimeBackend === "v2" && v2Context) {
 		const snap = readLaneSnapshot(v2Context.stateRoot, v2Context.batchId, v2Context.laneNumber);
-		if (snap == null) {
-			// Snapshot not written yet — lane-runner is still starting up.
-			// Assume alive to avoid false "failed" from monitor racing lane startup.
-			sessionAlive = true;
+		if (snap == null || snap.taskId !== taskId) {
+			// Snapshot not written yet OR snapshot still points to a prior task.
+			// Assume alive initially, but if stale for >30s consult the registry
+			// to avoid indefinite false "running" if the lane-runner died.
+			const staleMs = snap?.updatedAt ? (now - snap.updatedAt) : 0;
+			if (staleMs > 30_000) {
+				// Snapshot hasn't been updated for 30s+ — check registry as fallback
+				sessionAlive = isV2AgentAlive(sessionName, runtimeBackend);
+			} else {
+				sessionAlive = true;
+			}
 		} else {
 			sessionAlive = snap.status === "running";
 		}

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/extensions/taskplane/process-registry.ts

@@ -353,7 +353,7 @@ export function readLaneSnapshot(
 	stateRoot: string,
 	batchId: string,
 	laneNumber: number,
-): { status: string; updatedAt?: number } | null {
+): { taskId?: string | null; status: string; updatedAt?: number } | null {
 	try {
 		const p = runtimeLaneSnapshotPath(stateRoot, batchId, laneNumber);
 		if (!existsSync(p)) return null;

package/package.json

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