taskplane 0.22.12 → 0.22.13

package/dashboard/public/app.js

@@ -621,6 +621,58 @@ function renderLanesTasks(batch, tmuxSessions) {
 
 // ─── Render: Merge Agents ───────────────────────────────────────────────────
 
+/** Build full telemetry HTML for a merge agent (parity with worker stats).
+ *  Shows: elapsed, tool count, context %, cost, current tool, retry/compaction badges.
+ *  Returns empty string if no meaningful telemetry exists.
+ */
+function mergeTelemetryHtml(tel, alive) {
+  if (!tel) return '<span class="merge-no-data">—</span>';
+  const hasData = (tel.inputTokens || 0) > 0 || (tel.outputTokens || 0) > 0 ||
+    (tel.toolCalls || 0) > 0 || (tel.cost || 0) > 0;
+  if (!hasData) return '<span class="merge-no-data">—</span>';
+
+  let html = '<div class="merge-stats">';
+
+  // Elapsed time
+  if (tel.startedAt) {
+    const elapsed = Date.now() - tel.startedAt;
+    html += `<span class="worker-stat" title="Merge elapsed">⏱ ${formatDuration(elapsed)}</span>`;
+  }
+
+  // Tool calls
+  if (tel.toolCalls > 0) {
+    html += `<span class="worker-stat" title="Tool calls">🔧 ${tel.toolCalls}</span>`;
+  }
+
+  // Context %
+  if (tel.contextPct > 0) {
+    html += `<span class="worker-stat" title="Context window used">📊 ${Math.round(tel.contextPct)}%</span>`;
+  }
+
+  // Tokens + cost
+  const inp = (tel.inputTokens || 0) + (tel.cacheReadTokens || 0);
+  const out = tel.outputTokens || 0;
+  const cost = tel.cost || 0;
+  if (inp > 0 || out > 0) {
+    let tokenStr = `↑${formatTokens(inp)} ↓${formatTokens(out)}`;
+    if (cost > 0) tokenStr += ` ${formatCost(cost)}`;
+    html += `<span class="worker-stat" title="Tokens">🪙 ${tokenStr}</span>`;
+  }
+
+  // Current tool (if alive/active) or last tool (completed merges)
+  if (alive && tel.currentTool) {
+    html += `<span class="worker-stat worker-last-tool" title="Current tool">${escapeHtml(tel.currentTool)}</span>`;
+  } else if (!alive && tel.lastTool) {
+    html += `<span class="worker-stat worker-last-tool" title="Last tool">${escapeHtml(tel.lastTool)}</span>`;
+  }
+
+  // Retry/compaction badges (reuse shared helper)
+  html += telemetryBadgesHtml(tel);
+
+  html += '</div>';
+  return html;
+}
+
 function renderMergeAgents(batch, tmuxSessions) {
   const mergeResults = batch?.mergeResults || [];
   const tmuxSet = new Set(tmuxSessions || []);
@@ -642,8 +694,8 @@ function renderMergeAgents(batch, tmuxSessions) {
       mergePrefix = laneMatch[1] + "-merge";
     }
   }
-  // Helper: get merge session name for a lane number
-  const getMergeSessionName = (laneNum) => `${mergePrefix}-${laneNum}`;
+  // Helper: get merge session name for a merge number
+  const getMergeSessionName = (mergeNum) => `${mergePrefix}-${mergeNum}`;
 
   if (mergeResults.length === 0 && mergeSessions.length === 0) {
     $mergeBody.innerHTML = '<div class="empty-state">No merge agents active</div>';
@@ -671,49 +723,64 @@ function renderMergeAgents(batch, tmuxSessions) {
       : mr.status === "partial" ? "status-stalled"
       : "status-failed";
 
-    // Look for matching tmux merge sessions for this wave result.
-    // Merge sessions follow the naming pattern: {prefix}-{opId}-merge-{laneNumber}
-    // (e.g., "orch-henrylach-merge-1"). Find any alive merge sessions.
-    const waveMergeSessions = mergeSessions.filter(s => tmuxSet.has(s));
-    const sessionName = waveMergeSessions.length > 0 ? waveMergeSessions[0] : null;
-    const alive = sessionName !== null;
-    if (alive) shownSessions.add(sessionName);
+    // Merge session mapping: derive from lane numbers involved in this wave.
+    // Merge sessions are named by lane number (e.g., ...-merge-1), not wave index.
+    // Extract lane numbers from repoResults or from batch tasks for this wave.
+    const waveLaneNums = new Set();
+    const repoResults2 = mr.repoResults || [];
+    for (const rr of repoResults2) {
+      for (const ln of (rr.laneNumbers || [])) waveLaneNums.add(ln);
+    }
+    // Fallback: find lane numbers from tasks assigned to this wave
+    if (waveLaneNums.size === 0 && batch.wavePlan && batch.wavePlan[mr.waveIndex]) {
+      const waveTaskIds = new Set(batch.wavePlan[mr.waveIndex]);
+      for (const t of (batch.tasks || [])) {
+        if (waveTaskIds.has(t.taskId) && t.laneNumber != null) {
+          waveLaneNums.add(t.laneNumber);
+        }
+      }
+    }
+    // Find alive merge sessions matching the wave's lane numbers
+    let effectiveSession = null;
+    for (const ln of waveLaneNums) {
+      const candidate = getMergeSessionName(ln);
+      if (tmuxSet.has(candidate) && !shownSessions.has(candidate)) {
+        effectiveSession = candidate;
+        break;
+      }
+    }
+    // Fallback: any unshown alive merge session
+    if (!effectiveSession) {
+      effectiveSession = mergeSessions.find(s => tmuxSet.has(s) && !shownSessions.has(s)) || null;
+    }
+    const effectiveAlive = !!effectiveSession;
+    if (effectiveSession) shownSessions.add(effectiveSession);
 
-    // Look for merge telemetry data — check all merge sessions
+    // Find merge telemetry: try sessions by lane number first
     let mergeTel = null;
-    for (const ms of mergeSessions) {
-      if (telemetry[ms]) { mergeTel = telemetry[ms]; break; }
+    for (const ln of waveLaneNums) {
+      const candidate = getMergeSessionName(ln);
+      if (telemetry[candidate]) { mergeTel = telemetry[candidate]; break; }
     }
+    // Fallback: effective session telemetry or any merge session
+    if (!mergeTel && effectiveSession) mergeTel = telemetry[effectiveSession] || null;
+    if (!mergeTel) mergeTel = mergeSessions.reduce((found, ms) => found || telemetry[ms] || null, null);
 
     html += `<tr>`;
-    html += `<td style="font-family:var(--font-mono);">Wave ${mr.waveIndex + 1}</td>`;
+    html += `<td class="merge-wave-cell">Wave ${mr.waveIndex + 1}</td>`;
     html += `<td><span class="status-badge ${statusCls}">${mr.status}</span></td>`;
-    html += `<td style="font-family:var(--font-mono);font-size:0.8rem;">${alive ? escapeHtml(sessionName) : "—"}</td>`;
-    // Telemetry cell
-    html += `<td style="font-size:0.75rem;">`;
-    if (mergeTel) {
-      const totalTok = (mergeTel.inputTokens || 0) + (mergeTel.outputTokens || 0);
-      const cost = mergeTel.cost || 0;
-      if (totalTok > 0 || cost > 0) {
-        html += `<span style="color:var(--text-muted);">${totalTok > 0 ? totalTok.toLocaleString() + " tok" : ""}`;
-        if (cost > 0) html += ` · $${cost.toFixed(4)}`;
-        html += `</span>`;
-      } else {
-        html += '<span style="color:var(--text-faint);">—</span>';
-      }
-    } else {
-      html += '<span style="color:var(--text-faint);">—</span>';
-    }
-    html += `</td>`;
+    html += `<td class="merge-session-cell">${effectiveAlive ? escapeHtml(effectiveSession) : "—"}</td>`;
+    // Full telemetry cell
+    html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(mergeTel, effectiveAlive)}</td>`;
     html += `<td>`;
-    if (alive) {
-      const cmd = `tmux attach -t ${sessionName}`;
-      html += `<span class="tmux-cmd" data-tmux="${escapeHtml(sessionName)}" onclick="copyTmuxCmd('${escapeHtml(sessionName)}')" title="Click to copy">${escapeHtml(cmd)}</span>`;
+    if (effectiveAlive) {
+      const cmd = `tmux attach -t ${effectiveSession}`;
+      html += `<span class="tmux-cmd" data-tmux="${escapeHtml(effectiveSession)}" onclick="copyTmuxCmd('${escapeHtml(effectiveSession)}')" title="Click to copy">${escapeHtml(cmd)}</span>`;
     } else {
-      html += '<span style="color:var(--text-faint);">—</span>';
+      html += '<span class="merge-no-data">—</span>';
     }
     html += `</td>`;
-    html += `<td style="font-size:0.8rem;color:var(--text-muted);">${mr.failureReason ? escapeHtml(mr.failureReason) : "—"}</td>`;
+    html += `<td class="merge-detail-cell">${mr.failureReason ? escapeHtml(mr.failureReason) : "—"}</td>`;
     html += `</tr>`;
 
     // Per-repo sub-rows: show when workspace mode has repo results
@@ -732,10 +799,10 @@ function renderMergeAgents(batch, tmuxSessions) {
         html += `<tr class="merge-repo-row">`;
         html += `<td>${repoBadgeHtml(rr.repoId)}</td>`;
         html += `<td><span class="status-badge ${rrStatusCls}">${rr.status}</span></td>`;
-        html += `<td style="font-family:var(--font-mono);font-size:0.75rem;color:var(--text-faint);">${rrLanes}</td>`;
+        html += `<td class="merge-session-cell">${rrLanes}</td>`;
         html += `<td></td>`; /* telemetry placeholder */
         html += `<td></td>`; /* attach placeholder */
-        html += `<td style="font-size:0.75rem;color:var(--text-faint);">${rrDetail}</td>`;
+        html += `<td class="merge-detail-cell">${rrDetail}</td>`;
         html += `</tr>`;
       }
     }
@@ -748,25 +815,11 @@ function renderMergeAgents(batch, tmuxSessions) {
     const sessTel = telemetry[sess] || null;
     const cmd = `tmux attach -t ${sess}`;
     html += `<tr>`;
-    html += `<td style="font-family:var(--font-mono);">—</td>`;
+    html += `<td class="merge-wave-cell">—</td>`;
     html += `<td><span class="status-badge status-running"><span class="status-dot running"></span> merging</span></td>`;
-    html += `<td style="font-family:var(--font-mono);font-size:0.8rem;">${escapeHtml(sess)}</td>`;
-    // Telemetry cell for active merge session
-    html += `<td style="font-size:0.75rem;">`;
-    if (sessTel) {
-      const totalTok = (sessTel.inputTokens || 0) + (sessTel.outputTokens || 0);
-      const cost = sessTel.cost || 0;
-      if (totalTok > 0 || cost > 0) {
-        html += `<span style="color:var(--text-muted);">${totalTok > 0 ? totalTok.toLocaleString() + " tok" : ""}`;
-        if (cost > 0) html += ` · $${cost.toFixed(4)}`;
-        html += `</span>`;
-      } else {
-        html += '<span style="color:var(--text-faint);">—</span>';
-      }
-    } else {
-      html += '<span style="color:var(--text-faint);">—</span>';
-    }
-    html += `</td>`;
+    html += `<td class="merge-session-cell">${escapeHtml(sess)}</td>`;
+    // Full telemetry cell for active merge session
+    html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(sessTel, true)}</td>`;
     html += `<td><span class="tmux-cmd" data-tmux="${escapeHtml(sess)}" onclick="copyTmuxCmd('${escapeHtml(sess)}')" title="Click to copy">${escapeHtml(cmd)}</span></td>`;
     html += `<td>—</td>`;
     html += `</tr>`;

package/dashboard/public/style.css

@@ -712,6 +712,24 @@ body {
 .merge-table tr:last-child td { border-bottom: none; }
 .merge-table tr:hover td { background: var(--bg-surface-hover); }
 
+.merge-wave-cell { font-family: var(--font-mono); }
+.merge-session-cell { font-family: var(--font-mono); font-size: 0.8rem; }
+.merge-detail-cell { font-size: 0.8rem; color: var(--text-muted); }
+.merge-no-data { color: var(--text-faint); }
+
+.merge-stats {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 8px;
+  align-items: center;
+  font-size: 0.75rem;
+}
+
+.merge-telemetry-cell {
+  font-size: 0.75rem;
+  min-width: 120px;
+}
+
 /* ─── Terminal Panel ────────────────────────────────────────────────────── */
 
 .terminal-panel .panel-header {

package/dashboard/server.cjs

@@ -427,8 +427,9 @@ function loadTelemetryData(batchState) {
       const fresh = {
         inputTokens: 0, outputTokens: 0, cacheReadTokens: 0,
         cacheWriteTokens: 0, cost: 0, toolCalls: 0,
-        lastTool: "", retries: 0, retryActive: false,
+        lastTool: "", currentTool: "", retries: 0, retryActive: false,
         lastRetryError: "", compactions: 0, latestTotalTokens: 0,
+        contextPct: 0, startedAt: 0,
       };
       telemetryAccumulators.set(prefix, fresh);
       // Also reset tail states for ALL files of this prefix to re-read from beginning
@@ -450,8 +451,9 @@ function loadTelemetryData(batchState) {
     if (ts && ts.wasReset) {
       acc.inputTokens = 0; acc.outputTokens = 0; acc.cacheReadTokens = 0;
       acc.cacheWriteTokens = 0; acc.cost = 0; acc.toolCalls = 0;
-      acc.lastTool = ""; acc.retries = 0; acc.retryActive = false;
+      acc.lastTool = ""; acc.currentTool = ""; acc.retries = 0; acc.retryActive = false;
       acc.lastRetryError = ""; acc.compactions = 0; acc.latestTotalTokens = 0;
+      acc.contextPct = 0; acc.startedAt = 0;
       ts.wasReset = false;
     }
     for (const event of events) {
@@ -497,7 +499,31 @@ function loadTelemetryData(batchState) {
               }
             }
           }
-          acc.lastTool = argPreview ? `${toolDesc} ${argPreview}` : toolDesc;
+          const toolLabel = argPreview ? `${toolDesc} ${argPreview}` : toolDesc;
+          acc.lastTool = toolLabel;
+          acc.currentTool = toolLabel;
+          break;
+        }
+        case "tool_execution_end": {
+          acc.currentTool = "";
+          break;
+        }
+        case "agent_start": {
+          if (event.ts && !acc.startedAt) {
+            acc.startedAt = event.ts;
+          }
+          break;
+        }
+        case "response": {
+          // Extract context usage from get_session_stats responses
+          const ctxUsage = event.data?.contextUsage;
+          if (ctxUsage) {
+            // Support both percent (current) and percentUsed (legacy pi versions)
+            const pct = typeof ctxUsage.percent === "number" ? ctxUsage.percent
+              : typeof ctxUsage.percentUsed === "number" ? ctxUsage.percentUsed
+              : null;
+            if (pct !== null) acc.contextPct = pct;
+          }
           break;
         }
         case "auto_retry_start": {

package/extensions/task-runner.ts

@@ -456,6 +456,34 @@ function writeLaneState(state: TaskState): void {
 	}
 }
 
+/**
+ * Write a context % snapshot at worker iteration boundary (TP-094).
+ * Best-effort JSONL append to `.pi/context-snapshots/{batchId}/{sessionName}.jsonl`.
+ * Non-fatal on any failure — never blocks execution.
+ */
+function writeContextSnapshot(state: TaskState, contextWindow: number): void {
+	const batchId = process.env.ORCH_BATCH_ID || "standalone";
+	const sessionName = isOrchestratedMode() ? `${getTmuxPrefix()}-worker` : "task-worker";
+	try {
+		const dir = join(getSidecarDir(), "context-snapshots", batchId);
+		mkdirSync(dir, { recursive: true });
+		const filePath = join(dir, `${sessionName}.jsonl`);
+		const snapshot = {
+			iteration: state.totalIterations,
+			contextPct: state.workerContextPct,
+			tokens: state.workerInputTokens + state.workerOutputTokens + state.workerCacheReadTokens + state.workerCacheWriteTokens,
+			contextWindow,
+			cost: state.workerCostUsd,
+			toolCalls: state.workerToolCount,
+			exitReason: state.workerExitDiagnostic?.classification || null,
+			timestamp: Date.now(),
+		};
+		appendFileSync(filePath, JSON.stringify(snapshot) + "\n");
+	} catch {
+		// Best effort — don't crash the runner
+	}
+}
+
 /**
  * Append a JSON event to the conversation JSONL log file.
  * Used in orchestrated mode to capture the full worker conversation for the web dashboard.
@@ -1371,7 +1399,9 @@ interface SidecarTelemetryDelta {
 	/** Whether any sidecar events were parsed in this tick (used for callback gating) */
 	hadEvents: boolean;
 	/** Authoritative context usage from pi get_session_stats (pi ≥ 0.63.0, null if unavailable) */
-	contextUsage: { percentUsed: number; totalTokens: number; maxTokens: number } | null;
+	contextUsage: { percent: number; totalTokens: number; maxTokens: number } | null;
+	/** True when a get_session_stats response was seen but lacked contextUsage (older pi) */
+	sawStatsResponseWithoutContextUsage: boolean;
 }
 
 /**
@@ -1390,7 +1420,7 @@ function tailSidecarJsonl(filePath: string, tailState: SidecarTailState): Sideca
 		inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0,
 		cost: 0, latestTotalTokens: 0, toolCalls: 0, lastTool: "",
 		retryActive: tailState.retryActive, retriesStarted: 0, lastRetryError: "",
-		hadEvents: false, contextUsage: null,
+		hadEvents: false, contextUsage: null, sawStatsResponseWithoutContextUsage: false,
 	};
 
 	// Gracefully handle missing file (wrapper hasn't written yet)
@@ -1506,13 +1536,18 @@ function tailSidecarJsonl(filePath: string, tailState: SidecarTailState): Sideca
 				// get_session_stats response from pi ≥ 0.63.0 — authoritative context usage
 				if (event.success === true && event.data?.contextUsage) {
 					const cu = event.data.contextUsage;
-					if (typeof cu.percentUsed === "number") {
+					// pi sends `percent` (pi ≥ 0.63.0); accept `percentUsed` as legacy fallback
+					const pctValue = cu.percent ?? cu.percentUsed;
+					if (typeof pctValue === "number") {
 						delta.contextUsage = {
-							percentUsed: cu.percentUsed,
+							percent: pctValue,
 							totalTokens: cu.totalTokens || 0,
 							maxTokens: cu.maxTokens || 0,
 						};
 					}
+				} else if (event.success === true && event.data && !event.data.contextUsage) {
+					// Successful get_session_stats response but no contextUsage — older pi
+					delta.sawStatsResponseWithoutContextUsage = true;
 				}
 				break;
 			}
@@ -1656,6 +1691,25 @@ export function isLowRiskStep(stepNumber: number, totalSteps: number): boolean {
 
 // ── TMUX Agent Spawner ───────────────────────────────────────────────
 
+/**
+ * Synchronous sleep helper for tmux spawn stabilization checks.
+ *
+ * Uses Atomics.wait for cross-platform blocking delays without relying on
+ * shell `sleep` availability (important on Windows environments).
+ */
+function sleepSyncMs(ms: number): void {
+	if (!Number.isFinite(ms) || ms <= 0) return;
+	try {
+		const arr = new Int32Array(new SharedArrayBuffer(4));
+		Atomics.wait(arr, 0, 0, Math.floor(ms));
+	} catch {
+		const start = Date.now();
+		while (Date.now() - start < ms) {
+			// Busy-wait fallback (rare path)
+		}
+	}
+}
+
 /**
  * Spawns a Pi agent in a named TMUX session instead of a headless subprocess.
  * Returns the same interface shape as `spawnAgent()` for drop-in compatibility.
@@ -1890,6 +1944,73 @@ function spawnAgentTmux(opts: {
 		);
 	}
 
+	// ── TP-095: Post-spawn verification with retry (#335) ──────────
+	// On Windows/MSYS2, rapid sequential tmux session creation is unreliable.
+	// Pi process can exit with code 1 in 0 seconds on the first 3-5 attempts.
+	// Verify the session is alive after a brief delay, and retry if it died.
+	const SPAWN_VERIFY_DELAY_MS = 300;
+	const SPAWN_VERIFY_POLL_ATTEMPTS = 3;
+	const SPAWN_VERIFY_POLL_INTERVAL_MS = 200;
+	const SPAWN_MAX_RETRIES = 2;
+
+	const verifySessionAlive = (): boolean => {
+		for (let poll = 0; poll < SPAWN_VERIFY_POLL_ATTEMPTS; poll++) {
+			const check = spawnSync("tmux", ["has-session", "-t", opts.sessionName]);
+			if (check.status === 0) return true;
+			if (poll < SPAWN_VERIFY_POLL_ATTEMPTS - 1) {
+				sleepSyncMs(SPAWN_VERIFY_POLL_INTERVAL_MS);
+			}
+		}
+		return false;
+	};
+
+	// Wait briefly for session to stabilize, then verify
+	sleepSyncMs(SPAWN_VERIFY_DELAY_MS);
+
+	// Derive the stderr log path for diagnostic messages (mirrors execution.ts convention)
+	const stderrLogHint = `${sidecarPath.replace(/\.jsonl$/, "-stderr.log")}`;
+
+	let spawnRetries = 0;
+	while (!verifySessionAlive() && spawnRetries < SPAWN_MAX_RETRIES) {
+		spawnRetries++;
+		console.error(`[task-runner] tmux: session '${opts.sessionName}' died on startup — retrying (${spawnRetries}/${SPAWN_MAX_RETRIES}). Stderr log: ${stderrLogHint}`);
+
+		// Brief delay before retry (increases with each attempt)
+		const retryDelay = spawnRetries * 500;
+		sleepSyncMs(retryDelay);
+
+		// Kill any remnant and re-create
+		spawnSync("tmux", ["kill-session", "-t", opts.sessionName]);
+
+		const retryResult = spawnSync("tmux", [
+			"new-session", "-d",
+			"-s", opts.sessionName,
+			wrappedCommand,
+		]);
+
+		if (retryResult.status !== 0) {
+			const retryStderr = retryResult.stderr?.toString().trim() || "unknown error";
+			console.error(`[task-runner] tmux: retry ${spawnRetries} session creation failed: ${retryStderr}`);
+			continue;
+		}
+
+		// Wait for the retried session to stabilize
+		sleepSyncMs(SPAWN_VERIFY_DELAY_MS);
+	}
+
+	if (spawnRetries > 0) {
+		const finalAlive = verifySessionAlive();
+		if (!finalAlive) {
+			cleanupTmp();
+			console.error(`[task-runner] tmux: session '${opts.sessionName}' failed after ${SPAWN_MAX_RETRIES} retries. Stderr log: ${stderrLogHint}`);
+			throw new Error(
+				`TMUX session '${opts.sessionName}' died on startup after ${SPAWN_MAX_RETRIES} retries. ` +
+				`Stderr log: ${stderrLogHint}`
+			);
+		}
+		console.error(`[task-runner] tmux: session '${opts.sessionName}' alive after ${spawnRetries} retry(ies)`);
+	}
+
 	console.error(`[task-runner] tmux: session '${opts.sessionName}' created (cwd: ${opts.cwd})`);
 
 
@@ -2461,11 +2582,9 @@ export default function (pi: ExtensionAPI) {
 								state.reviewerLastTool = delta.lastTool;
 							}
 
-							// Context % — prefer authoritative contextUsage (pi ≥ 0.63.0)
+							// Context % — authoritative contextUsage only (pi ≥ 0.63.0, TP-094)
 							if (delta.contextUsage) {
-								state.reviewerContextPct = delta.contextUsage.percentUsed;
-							} else if (delta.latestTotalTokens > 0 && contextWindow > 0) {
-								state.reviewerContextPct = (delta.latestTotalTokens / contextWindow) * 100;
+								state.reviewerContextPct = delta.contextUsage.percent;
 							}
 
 							writeLaneState(state);
@@ -2668,11 +2787,9 @@ export default function (pi: ExtensionAPI) {
 								state.reviewerCostUsd += delta.cost;
 								state.reviewerToolCount += delta.toolCalls;
 								if (delta.lastTool) state.reviewerLastTool = delta.lastTool;
-								// Context % — prefer authoritative contextUsage (pi ≥ 0.63.0)
+								// Context % — authoritative contextUsage only (pi ≥ 0.63.0, TP-094)
 								if (delta.contextUsage) {
-									state.reviewerContextPct = delta.contextUsage.percentUsed;
-								} else if (delta.latestTotalTokens > 0 && contextWindow > 0) {
-									state.reviewerContextPct = (delta.latestTotalTokens / contextWindow) * 100;
+									state.reviewerContextPct = delta.contextUsage.percent;
 								}
 								writeLaneState(state);
 								updateWidgets();
@@ -2823,8 +2940,35 @@ export default function (pi: ExtensionAPI) {
 				if (isStepComplete(ss)) completedBefore.add(ss.number);
 			}
 
+			// ── TP-095: Reset stale lane-state fields before new worker spawn (#333) ──
+			// When a worker crashes and restarts, the lane-state JSON retains stale
+			// values (workerStatus: "done", phase: "error", workerExitDiagnostic from
+			// the crash). Reset STATUS fields BEFORE the new worker spawns so the
+			// dashboard immediately reflects the new running state.
+			// IMPORTANT: Do NOT reset telemetry counters (tokens, cost) here — they
+			// accumulate across worker iterations via += in onTelemetry (#334).
+			if (state.totalIterations > 1) {
+				state.phase = "running";
+				state.workerStatus = "idle"; // Will be set to "running" by runWorker()
+				state.workerExitDiagnostic = null;
+				state.workerElapsed = 0;
+				state.workerContextPct = 0;
+				state.workerLastTool = "";
+				state.workerRetryActive = false;
+				state.workerRetryCount = 0;
+				state.workerLastRetryError = "";
+				// Note: workerToolCount, workerInputTokens, workerOutputTokens,
+				// workerCacheReadTokens, workerCacheWriteTokens, workerCostUsd
+				// are intentionally NOT reset — they persist across iterations.
+				writeLaneState(state);
+			}
+
 			await runWorker(remainingSteps, ctx);
 
+			// Write context % snapshot at iteration boundary (TP-094)
+			const { contextWindow: snapshotContextWindow } = resolveContextWindow(config, ctx);
+			writeContextSnapshot(state, snapshotContextWindow);
+
 			if (state.phase === "error") {
 				await shutdownPersistentReviewer("worker error");
 				return;
@@ -3229,7 +3373,10 @@ export default function (pi: ExtensionAPI) {
 		state.workerElapsed = 0;
 		state.workerContextPct = 0;
 		state.workerLastTool = "";
-		state.workerToolCount = 0;
+		// TP-095: Don't reset workerToolCount — accumulate across iterations (#334).
+		// Previous behavior zeroed the counter on each iteration, losing totals
+		// when a worker crashed and restarted. Token/cost counters already
+		// accumulate via += in onTelemetry and were never reset here.
 		state.workerRetryActive = false;
 		state.workerRetryCount = 0;
 		state.workerLastRetryError = "";
@@ -3257,6 +3404,8 @@ export default function (pi: ExtensionAPI) {
 		const warnPct = config.context.warn_percent;
 		const killPct = config.context.kill_percent;
 		console.error(`[task-runner] worker context window: ${contextWindow} (${contextWindowSource})`);
+		// One-shot warning when pi doesn't provide authoritative contextUsage (TP-094)
+		let warnedNoContextUsage = false;
 
 		if (spawnMode === "tmux") {
 			// ── TMUX mode ────────────────────────────────────────
@@ -3295,14 +3444,10 @@ export default function (pi: ExtensionAPI) {
 						state.workerLastRetryError = delta.lastRetryError;
 					}
 
-					// Context % — prefer authoritative contextUsage from pi ≥ 0.63.0,
-					// fall back to manual calculation from totalTokens + cacheRead.
-					{
-						const pct = delta.contextUsage
-							? delta.contextUsage.percentUsed
-							: (delta.latestTotalTokens > 0 && contextWindow > 0)
-								? (delta.latestTotalTokens / contextWindow) * 100
-								: 0;
+					// Context % — authoritative contextUsage only (pi ≥ 0.63.0, TP-094)
+					// Manual token-based fallback removed: avoids false thresholds on older pi.
+					if (delta.contextUsage) {
+						const pct = delta.contextUsage.percent;
 						if (pct > 0) {
 							state.workerContextPct = pct;
 							if (pct >= warnPct) {
@@ -3314,6 +3459,10 @@ export default function (pi: ExtensionAPI) {
 								spawned.kill();
 							}
 						}
+					} else if (delta.sawStatsResponseWithoutContextUsage && !warnedNoContextUsage) {
+						// One-shot warning: pi responded to get_session_stats but omitted contextUsage (older pi)
+						warnedNoContextUsage = true;
+						console.error(`[task-runner] warning: pi did not provide contextUsage — context pressure thresholds disabled`);
 					}
 
 					updateWidgets();