taskplane 0.24.5 → 0.24.6

package/bin/rpc-wrapper.mjs

@@ -5,7 +5,7 @@
  *
  * Spawns pi in RPC mode, sends a prompt, captures RPC events to a sidecar JSONL
  * file, and writes a final exit summary JSON on process exit. Displays minimal
- * live progress on stderr for tmux pane visibility.
+ * live progress on stderr for dashboard/session visibility.
  *
  * Usage:
  *   node bin/rpc-wrapper.mjs \
@@ -271,7 +271,7 @@ function writeSidecarEvent(sidecarPath, event) {
 // ── Progress Display ─────────────────────────────────────────────────
 
 /**
- * Display minimal progress on stderr for tmux pane visibility.
+ * Display minimal progress on stderr for dashboard/session visibility.
  */
 function displayProgress(state) {
 	const parts = [];
@@ -774,8 +774,8 @@ piArgs.push(...args.passthrough);
 // Windows CreateProcess has a ~32K command line limit. Orchestrated worker
 // system prompts routinely exceed this (PROMPT.md + context docs + steps).
 // When the system prompt is large, write it to a temp file and use shell
-// expansion `$(cat file)` to pass it. This works in MSYS2/Git Bash tmux
-// (where the lane sessions run) without hitting the Win32 limit.
+// expansion `$(cat file)` to pass it. This works in MSYS2/Git Bash shells
+// used by lane sessions without hitting the Win32 limit.
 //
 // For small system prompts (< 8K), pass inline for simplicity.
 const SYSTEM_PROMPT_FILE_THRESHOLD = 8192;

package/dashboard/public/app.js

@@ -126,6 +126,20 @@ function tokenSummaryFromLaneState(ls) {
   return s;
 }
 
+function tokenSummaryFromReviewerLaneState(ls) {
+  if (!ls) return "";
+  const inp = ls.reviewerInputTokens || 0;
+  const out = ls.reviewerOutputTokens || 0;
+  const cr = ls.reviewerCacheReadTokens || 0;
+  const cw = ls.reviewerCacheWriteTokens || 0;
+  const cost = ls.reviewerCostUsd || 0;
+  const totalIn = inp + cr; // uncached + cached = total input processed
+  if (totalIn === 0 && out === 0) return "";
+  let s = `↑${formatTokens(totalIn)} ↓${formatTokens(out)}`;
+  if (cost > 0) s += ` ${formatCost(cost)}`;
+  return s;
+}
+
 /** Build compact telemetry badge HTML for retry/compaction indicators.
  *  Only shows badges when telemetry data has meaningful values.
  *  @param {object|null} tel - Telemetry data for a lane (from currentData.telemetry[prefix])
@@ -311,10 +325,10 @@ $repoFilter.addEventListener("change", (e) => {
   // Re-render with current data
   if (currentData) {
     const batch = currentData.batch;
-    const tmux = currentData.tmuxSessions || [];
+    const sessions = currentData.sessions ?? currentData.tmuxSessions ?? [];
     if (batch) {
-      renderLanesTasks(batch, tmux);
-      renderMergeAgents(batch, tmux);
+      renderLanesTasks(batch, sessions);
+      renderMergeAgents(batch, sessions);
     }
   }
 });
@@ -496,14 +510,14 @@ function renderSummary(batch) {
 
 // ─── Render: Lanes + Tasks (integrated) ─────────────────────────────────────
 
-function renderLanesTasks(batch, tmuxSessions) {
+function renderLanesTasks(batch, sessions) {
   if (!batch || !batch.lanes || batch.lanes.length === 0) {
     $lanesTasksBody.innerHTML = '<div class="empty-state">No lanes</div>';
     return;
   }
 
   const tasks = batch.tasks || [];
-  const tmuxSet = new Set(tmuxSessions || []);
+  const sessionSet = new Set(sessions || []);
   const laneStates = currentData?.laneStates || {};
   const telemetry = currentData?.telemetry || {};
   // TP-107: V2 lane snapshots take precedence over legacy lane states when present
@@ -520,10 +534,10 @@ function renderLanesTasks(batch, tmuxSessions) {
       if (!laneMatchesRepo) continue;
     }
 
-    // TP-107: check V2 registry for liveness first, fall back to tmux
+    // TP-107: check Runtime V2 registry for liveness first, fall back to session list
     const laneSessionId = lane.laneSessionId;
     const v2Alive = isLaneAliveV2(lane.laneNumber);
-    const alive = v2Alive !== null ? v2Alive : tmuxSet.has(laneSessionId);
+    const alive = v2Alive !== null ? v2Alive : sessionSet.has(laneSessionId);
     const sessionChip = `session: ${laneSessionId}`;
 
     // Lane header
@@ -538,14 +552,14 @@ function renderLanesTasks(batch, tmuxSessions) {
     }
     html += `  </div>`;
     html += `  <div class="lane-right">`;
-    html += `    <span class="tmux-dot ${alive ? "alive" : "dead"}" title="${alive ? "session alive" : "session not active"}"></span>`;
+    html += `    <span class="session-dot ${alive ? "alive" : "dead"}" title="${alive ? "session alive" : "session not active"}"></span>`;
     // View button: shows conversation stream when available
     const isViewingConv = viewerMode === 'conversation' && viewerTarget === laneSessionId;
-    html += `    <button class="tmux-view-btn${isViewingConv ? ' active' : ''}" onclick="viewConversation('${escapeHtml(laneSessionId)}')" title="View worker conversation">👁 View</button>`;
+    html += `    <button class="session-view-btn${isViewingConv ? ' active' : ''}" onclick="viewConversation('${escapeHtml(laneSessionId)}')" title="View worker conversation">👁 View</button>`;
     if (alive) {
-      html += `    <span class="tmux-cmd" data-session="${escapeHtml(laneSessionId)}" onclick="copySessionId('${escapeHtml(laneSessionId)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span>`;
+      html += `    <span class="session-cmd" data-session="${escapeHtml(laneSessionId)}" onclick="copySessionId('${escapeHtml(laneSessionId)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span>`;
     } else {
-      html += `    <span class="tmux-cmd dead-session">${escapeHtml(sessionChip)}</span>`;
+      html += `    <span class="session-cmd dead-session">${escapeHtml(sessionChip)}</span>`;
     }
     html += `  </div>`;
     html += `</div>`;
@@ -659,7 +673,7 @@ function renderLanesTasks(batch, tmuxSessions) {
         const rTools = ls.reviewerToolCount || 0;
         const rCtx = ls.reviewerContextPct ? `${Math.round(ls.reviewerContextPct)}%` : "";
         const rLastTool = ls.reviewerLastTool || "";
-        const rCost = ls.reviewerCostUsd ? `$${ls.reviewerCostUsd.toFixed(2)}` : "";
+        const rTokenStr = tokenSummaryFromReviewerLaneState(ls);
         const rType = ls.reviewerType || "review";
         const rStep = ls.reviewerStep || "?";
         reviewerRowHtml = `
@@ -668,13 +682,14 @@ function renderLanesTasks(batch, tmuxSessions) {
             <span class="task-actions"></span>
             <span class="reviewer-label">📋 Reviewer</span>
             <span class="reviewer-type">${escapeHtml(rType)} · Step ${rStep}</span>
-            <span class="task-duration">${rElapsed}</span>
+            <span class="task-duration"></span>
             <span></span>
             <span class="task-step">
               <div class="worker-stats reviewer-stats">
+                <span class="worker-stat" title="Reviewer elapsed">⏱ ${rElapsed}</span>
                 <span class="worker-stat" title="Reviewer tool calls">🔧 ${rTools}</span>
                 ${rCtx ? `<span class="worker-stat" title="Reviewer context used">📊 ${rCtx}</span>` : ""}
-                ${rCost ? `<span class="worker-stat" title="Reviewer cost">${rCost}</span>` : ""}
+                ${rTokenStr ? `<span class="worker-stat" title="Reviewer tokens: input↑ output↓ cacheRead(R) cacheWrite(W)">🪙 ${rTokenStr}</span>` : ""}
                 ${rLastTool ? `<span class="worker-stat worker-last-tool" title="Reviewer last tool">${escapeHtml(rLastTool)}</span>` : ""}
               </div>
             </span>
@@ -759,14 +774,14 @@ function mergeTelemetryHtml(tel, alive) {
   return html;
 }
 
-function renderMergeAgents(batch, tmuxSessions) {
+function renderMergeAgents(batch, sessions) {
   const mergeResults = batch?.mergeResults || [];
-  const tmuxSet = new Set(tmuxSessions || []);
+  const sessionSet = new Set(sessions || []);
   const showRepos = knownRepos.length >= 2;
   const telemetry = currentData?.telemetry || {};
 
   // Check for active merge sessions (convention: {prefix}-{opId}-merge-{N})
-  const mergeSessions = (tmuxSessions || []).filter(s => s.includes("-merge-"));
+  const mergeSessions = (sessions || []).filter(s => s.includes("-merge-"));
 
   // Derive merge session name from lane session naming pattern.
   // Lane sessions: "{prefix}-{opId}-lane-{N}", merge sessions: "{prefix}-{opId}-merge-{N}".
@@ -830,14 +845,14 @@ function renderMergeAgents(batch, tmuxSessions) {
     let effectiveSession = null;
     for (const ln of waveLaneNums) {
       const candidate = getMergeSessionName(ln);
-      if (tmuxSet.has(candidate) && !shownSessions.has(candidate)) {
+      if (sessionSet.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;
+      effectiveSession = mergeSessions.find(s => sessionSet.has(s) && !shownSessions.has(s)) || null;
     }
     const effectiveAlive = !!effectiveSession;
     if (effectiveSession) shownSessions.add(effectiveSession);
@@ -861,7 +876,7 @@ function renderMergeAgents(batch, tmuxSessions) {
     html += `<td>`;
     if (effectiveAlive) {
       const sessionChip = `session: ${effectiveSession}`;
-      html += `<span class="tmux-cmd" data-session="${escapeHtml(effectiveSession)}" onclick="copySessionId('${escapeHtml(effectiveSession)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span>`;
+      html += `<span class="session-cmd" data-session="${escapeHtml(effectiveSession)}" onclick="copySessionId('${escapeHtml(effectiveSession)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span>`;
     } else {
       html += '<span class="merge-no-data">—</span>';
     }
@@ -906,7 +921,7 @@ function renderMergeAgents(batch, tmuxSessions) {
     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-session="${escapeHtml(sess)}" onclick="copySessionId('${escapeHtml(sess)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span></td>`;
+    html += `<td><span class="session-cmd" data-session="${escapeHtml(sess)}" onclick="copySessionId('${escapeHtml(sess)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span></td>`;
     html += `<td>—</td>`;
     html += `</tr>`;
   }
@@ -1374,7 +1389,7 @@ let currentData = null;
 function render(data) {
   currentData = data;
   const batch = data.batch;
-  const tmux = data.tmuxSessions || [];
+  const sessions = data.sessions ?? data.tmuxSessions ?? [];
 
   $lastUpdate.textContent = new Date().toLocaleTimeString();
 
@@ -1408,8 +1423,8 @@ function render(data) {
   updateRepoFilter(repos);
 
   renderSupervisor(data);
-  renderLanesTasks(batch, tmux);
-  renderMergeAgents(batch, tmux);
+  renderLanesTasks(batch, sessions);
+  renderMergeAgents(batch, sessions);
   // TP-107: Runtime V2 panels
   renderAgentsPanel(data.runtimeRegistry);
   renderMessagesPanel(data.mailbox);
@@ -1477,7 +1492,7 @@ let lastStatusMdText = "";
 // ── Open conversation viewer (TP-107: V2 events preferred, legacy fallback) ──
 
 /**
- * Resolve a lane's tmux session name to a Runtime V2 agent ID via the registry.
+ * Resolve a lane session ID to a Runtime V2 agent ID via the registry.
  * Returns null if no V2 registry data is available.
  */
 function resolveV2AgentId(sessionName) {
@@ -1485,7 +1500,7 @@ function resolveV2AgentId(sessionName) {
   const agents = currentData.runtimeRegistry.agents;
   // Direct match on agentId
   if (agents[sessionName]) return sessionName;
-  // Match by tmux session prefix + "-worker" suffix (common V2 naming)
+  // Match by session ID prefix + "-worker" suffix (common V2 naming)
   const workerKey = sessionName + '-worker';
   if (agents[workerKey]) return workerKey;
   // Search by laneNumber match from lane snapshots

package/dashboard/public/style.css

@@ -134,8 +134,8 @@ body {
 .status-badge,
 .count-chip,
 .wave-chip,
-.tmux-view-btn,
-.tmux-cmd,
+.session-view-btn,
+.session-cmd,
 .repo-filter-select,
 .history-select,
 .task-row,
@@ -513,17 +513,17 @@ body {
   gap: 10px;
 }
 
-.tmux-dot {
+.session-dot {
   width: 8px;
   height: 8px;
   border-radius: 50%;
   flex-shrink: 0;
 }
 
-.tmux-dot.alive { background: var(--green); }
-.tmux-dot.dead  { background: var(--red); opacity: 0.6; }
+.session-dot.alive { background: var(--green); }
+.session-dot.dead  { background: var(--red); opacity: 0.6; }
 
-.tmux-view-btn {
+.session-view-btn {
   font-family: var(--font-sans);
   font-size: 0.72rem;
   font-weight: 600;
@@ -537,12 +537,12 @@ body {
   transition: background 0.2s, border-color 0.2s;
 }
 
-.tmux-view-btn:hover {
+.session-view-btn:hover {
   background: var(--accent);
   border-color: var(--accent);
 }
 
-.tmux-cmd {
+.session-cmd {
   font-family: var(--font-mono);
   font-size: 0.7rem;
   padding: 3px 8px;
@@ -556,17 +556,17 @@ body {
   transition: border-color 0.2s, color 0.2s;
 }
 
-.tmux-cmd:hover {
+.session-cmd:hover {
   border-color: var(--accent-dim);
   color: var(--accent);
 }
 
-.tmux-cmd.copied {
+.session-cmd.copied {
   border-color: var(--green-dim);
   color: var(--green);
 }
 
-.tmux-cmd.dead-session {
+.session-cmd.dead-session {
   color: var(--text-muted);
   cursor: default;
 }
@@ -945,7 +945,7 @@ body {
   box-shadow: 0 0 0 1px var(--accent-dim);
 }
 
-.tmux-view-btn.active {
+.session-view-btn.active {
   background: var(--accent);
   border-color: var(--accent);
 }

package/dashboard/server.cjs

@@ -75,6 +75,8 @@ function normalizeBatchStateIngress(state) {
 
   for (const lane of state.lanes) {
     if (!lane || typeof lane !== "object") continue;
+    // Legacy compatibility: older persisted states stored lane session IDs under
+    // `tmuxSessionName`. Normalize to `laneSessionId` at ingress and drop legacy key.
     const laneSessionId = typeof lane.laneSessionId === "string"
       ? lane.laneSessionId
       : (typeof lane.tmuxSessionName === "string" ? lane.tmuxSessionName : undefined);
@@ -191,9 +193,9 @@ function parseStatusMd(taskFolder) {
   return null;
 }
 
-function getTmuxSessions() {
-  // Runtime V2 no longer relies on TMUX sessions.
-  // Keep field shape stable for dashboard clients that still read `tmuxSessions`.
+function getActiveSessions() {
+  // Runtime V2 no longer relies on external terminal multiplexers for liveness.
+  // Dashboard session data is driven by runtime registry + persisted state.
   return [];
 }
 
@@ -236,15 +238,15 @@ function loadLaneStates() {
 const telemetryTailStates = new Map();
 
 /**
- * Module-level accumulated telemetry per tmux prefix.
+ * Module-level accumulated telemetry per session prefix.
  * Persists across poll ticks so incremental tail reads accumulate correctly.
- * Key: tmux prefix → { inputTokens, outputTokens, ... }
+ * Key: session prefix → { inputTokens, outputTokens, ... }
  */
 const telemetryAccumulators = new Map();
 
 /**
  * Tracks which files are currently contributing to each prefix.
- * Key: tmux prefix → Set of absolute file paths
+ * Key: session prefix → Set of absolute file paths
  * Used to detect file rotation: when files change, accumulator is reset.
  */
 const telemetryPrefixFiles = new Map();
@@ -530,7 +532,7 @@ function loadTelemetryData(batchState) {
   const telemetryDir = path.join(REPO_ROOT, ".pi", "telemetry");
   const result = {};
 
-  // Build lane number → tmux prefix mapping from batch state
+  // Build lane number → session prefix mapping from batch state
   const laneToPrefix = {};
   if (batchState && batchState.lanes) {
     for (const lane of batchState.lanes) {
@@ -563,11 +565,11 @@ function loadTelemetryData(batchState) {
     const parsed = parseTelemetryFilename(file);
     if (!parsed) continue;
 
-    // Determine the key (tmux prefix)
+    // Determine the key (session prefix)
     let prefix;
     if (parsed.role === "merger") {
-      // Merge agent — derive prefix from lane naming so it matches the tmux
-      // session name used by the client (e.g. "orch-henrylach-merge-1").
+      // Merge agent — derive prefix from lane naming so it matches the
+      // session ID used by the client (e.g. "orch-henrylach-merge-1").
       // Lane sessions: "orch-{opId}-lane-{N}" → merge sessions: "orch-{opId}-merge-{N}".
       const firstLanePrefix = Object.values(laneToPrefix)[0]; // e.g. "orch-henrylach-lane-1"
       const opPrefix = firstLanePrefix?.replace(/-lane-\d+$/, ""); // "orch-henrylach"
@@ -1029,7 +1031,7 @@ function synthesizeLaneStateFromSnapshot(key, snap, fallbackBatchId) {
 /** Build full dashboard state object for the frontend. */
 function buildDashboardState() {
   const state = loadBatchState();
-  const tmuxSessions = getTmuxSessions();
+  const sessions = getActiveSessions();
   const rawLaneStates = loadLaneStates();
   // Filter stale lane states from previous batches.
   // Lane state files persist across batches (same filename), so without
@@ -1046,7 +1048,16 @@ function buildDashboardState() {
   const supervisor = loadSupervisorData(state);
 
   if (!state) {
-    return { batch: null, tmuxSessions, laneStates: {}, telemetry: {}, batchTotalCost: 0, supervisor: null, timestamp: Date.now() };
+    return {
+      batch: null,
+      sessions,
+      tmuxSessions: sessions, // Legacy compatibility field for older dashboard clients
+      laneStates: {},
+      telemetry: {},
+      batchTotalCost: 0,
+      supervisor: null,
+      timestamp: Date.now(),
+    };
   }
 
   const tasks = (state.tasks || []).map((task) => {
@@ -1108,7 +1119,8 @@ function buildDashboardState() {
       // Additive field — absent in v1 state files, frontend must default to "repo".
       mode: state.mode || "repo",
     },
-    tmuxSessions,
+    sessions,
+    tmuxSessions: sessions, // Legacy compatibility field for older dashboard clients
     timestamp: Date.now(),
   };
 }
@@ -1157,68 +1169,6 @@ function serveStatic(req, res) {
 
 const sseClients = new Set();
 
-// ─── Pane Capture SSE ───────────────────────────────────────────────────
-
-const paneClients = new Map(); // sessionName → Set<res>
-
-function handlePaneSSE(req, res, sessionName) {
-  // Validate session name (alphanumeric, dashes, underscores only)
-  if (!/^[\w-]+$/.test(sessionName)) {
-    res.writeHead(400, { "Content-Type": "text/plain" });
-    res.end("Invalid session name");
-    return;
-  }
-
-  res.writeHead(200, {
-    "Content-Type": "text/event-stream",
-    "Cache-Control": "no-cache",
-    Connection: "keep-alive",
-    "Access-Control-Allow-Origin": "*",
-  });
-
-  if (!paneClients.has(sessionName)) {
-    paneClients.set(sessionName, new Set());
-  }
-  paneClients.get(sessionName).add(res);
-
-  // Send initial capture immediately
-  const initial = captureTmuxPane(sessionName);
-  if (initial !== null) {
-    res.write(`data: ${JSON.stringify({ output: initial, session: sessionName })}\n\n`);
-  } else {
-    res.write(`data: ${JSON.stringify({ error: "Session not found or not accessible", session: sessionName })}\n\n`);
-  }
-
-  req.on("close", () => {
-    const clients = paneClients.get(sessionName);
-    if (clients) {
-      clients.delete(res);
-      if (clients.size === 0) paneClients.delete(sessionName);
-    }
-  });
-}
-
-function captureTmuxPane(_sessionName) {
-  // Runtime V2 no longer captures TMUX panes.
-  return null;
-}
-
-function broadcastPaneCaptures() {
-  for (const [sessionName, clients] of paneClients) {
-    if (clients.size === 0) continue;
-    const output = captureTmuxPane(sessionName);
-    if (output === null) continue;
-    const payload = `data: ${JSON.stringify({ output, session: sessionName })}\n\n`;
-    for (const client of clients) {
-      try {
-        client.write(payload);
-      } catch {
-        clients.delete(client);
-      }
-    }
-  }
-}
-
 // ─── Conversation JSONL ─────────────────────────────────────────────────
 
 function serveConversation(req, res, prefix) {
@@ -1441,9 +1391,6 @@ function createServer() {
 
     if (pathname === "/api/stream" && req.method === "GET") {
       handleSSE(req, res);
-    } else if (pathname.startsWith("/api/pane/") && req.method === "GET") {
-      const sessionName = pathname.slice("/api/pane/".length);
-      handlePaneSSE(req, res, sessionName);
     } else if (pathname.startsWith("/api/conversation/") && req.method === "GET") {
       const prefix = pathname.slice("/api/conversation/".length);
       serveConversation(req, res, prefix);
@@ -1594,9 +1541,6 @@ async function main() {
   // Broadcast state to all SSE clients on interval
   const pollTimer = setInterval(broadcastState, POLL_INTERVAL);
 
-  // Broadcast pane captures more frequently (1s) for smooth terminal viewing
-  const paneTimer = setInterval(broadcastPaneCaptures, 1000);
-
   // Also watch batch-state.json for immediate push on change
   try {
     const batchDir = path.dirname(BATCH_STATE_PATH);
@@ -1621,12 +1565,6 @@ async function main() {
   // Graceful shutdown
   function cleanup() {
     clearInterval(pollTimer);
-    clearInterval(paneTimer);
-    for (const [, clients] of paneClients) {
-      for (const client of clients) {
-        try { client.end(); } catch {}
-      }
-    }
     for (const client of sseClients) {
       try { client.end(); } catch {}
     }

package/extensions/task-orchestrator.ts

@@ -12,7 +12,7 @@
  *   /orch-resume                   — Resume a paused batch
  *   /orch-abort [--hard]           — Abort batch (graceful or immediate)
  *   /orch-deps <areas|paths|all>   — Show dependency graph
- *   /orch-sessions                 — List active TMUX sessions
+ *   /orch-sessions                 — List active lane sessions
  *
  * Configuration:
  *   .pi/task-orchestrator.yaml  — orchestrator-specific settings

package/extensions/taskplane/agent-host.ts

@@ -314,7 +314,8 @@ export function spawnAgent(
 	let timedOut = false;
 	let agentEnded = false;
 	let stdinClosed = false;
-	let statsRequested = false;
+	let assistantMessageEnds = 0;
+	const STATS_REFRESH_EVERY_ASSISTANT_MESSAGES = 5;
 	let inputTokens = 0, outputTokens = 0, cacheReadTokens = 0, cacheWriteTokens = 0;
 	let costUsd = 0, toolCalls = 0, retries = 0, compactions = 0;
 	let lastTool = "", error: string | null = null;
@@ -586,10 +587,13 @@ export function spawnAgent(
 								emitEvent("assistant_message", { text: truncatePayload(content, MAX_CONV_PAYLOAD_CHARS) });
 							}
 						}
-						// Request session stats after first assistant message
-						if (!statsRequested && event.message?.role === "assistant") {
-							statsRequested = true;
-							try { proc.stdin?.write(JSON.stringify({ type: "get_session_stats" }) + "\n"); } catch { /* ignore */ }
+						// Request session stats immediately on first assistant message,
+						// then periodically at a bounded cadence to refresh context usage.
+						if (event.message?.role === "assistant") {
+							assistantMessageEnds += 1;
+							if (assistantMessageEnds === 1 || assistantMessageEnds % STATS_REFRESH_EVERY_ASSISTANT_MESSAGES === 0) {
+								try { proc.stdin?.write(JSON.stringify({ type: "get_session_stats" }) + "\n"); } catch { /* ignore */ }
+							}
 						}
 						// Check mailbox
 						checkMailbox();
@@ -636,6 +640,8 @@ export function spawnAgent(
 						if (event.success === true && event.data?.contextUsage) {
 							contextUsage = event.data.contextUsage;
 							emitEvent("context_usage", { ...event.data.contextUsage });
+							// Emit telemetry immediately so context % is live in dashboard
+							onTelemetry({ inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, costUsd, toolCalls, lastTool, contextUsage });
 						}
 						break;
 					}

package/extensions/taskplane/engine-worker.ts

@@ -32,6 +32,8 @@ import type {
 /**
  * Messages sent FROM the worker TO the main thread.
  */
+export type WorkerErrorSource = "enginePromise" | "uncaughtException" | "unhandledRejection";
+
 export type WorkerToMainMessage =
 	| { type: "notify"; msg: string; level: "info" | "warning" | "error" }
 	| { type: "monitor-update"; state: MonitorState }
@@ -39,7 +41,7 @@ export type WorkerToMainMessage =
 	| { type: "supervisor-alert"; alert: SupervisorAlert }
 	| { type: "state-sync"; state: SerializedBatchState }
 	| { type: "complete"; state: SerializedBatchState }
-	| { type: "error"; message: string };
+	| { type: "error"; message: string; stack?: string; source?: WorkerErrorSource };
 
 /**
  * Messages sent FROM the main thread TO the worker.
@@ -194,12 +196,73 @@ export function applySerializedState(
 
 // Guard: only run engine main when launched via fork() with the sentinel env var.
 if (process.env.TASKPLANE_ENGINE_FORK === "1" && typeof process.send === "function") {
-	const send = (msg: WorkerToMainMessage) => process.send!(msg);
+	const send = (msg: WorkerToMainMessage) => {
+		try {
+			process.send?.(msg);
+		} catch {
+			// best effort only
+		}
+	};
+
+	const sendWithAck = (msg: WorkerToMainMessage, onFlushed: () => void) => {
+		if (typeof process.send !== "function" || !process.connected) {
+			onFlushed();
+			return;
+		}
+
+		let flushed = false;
+		const done = () => {
+			if (flushed) return;
+			flushed = true;
+			onFlushed();
+		};
+
+		try {
+			(process.send as (
+				message: WorkerToMainMessage,
+				sendHandle?: unknown,
+				options?: unknown,
+				callback?: (error: Error | null) => void,
+			) => boolean)(msg, undefined, undefined, () => done());
+			setTimeout(done, 75).unref();
+		} catch {
+			done();
+		}
+	};
+
+	const normalizeError = (err: unknown): { message: string; stack?: string } => {
+		if (err instanceof Error) return { message: err.message, stack: err.stack };
+		return { message: String(err) };
+	};
 
 	// Wait for the init message carrying workerData, then start the engine.
 	process.once("message", async (initMsg: { type: string; data: EngineWorkerData }) => {
 		if (initMsg?.type !== "init") return;
 
+		let batchState: OrchBatchRuntimeState | null = null;
+		let fatalHandled = false;
+		const reportFatalAndExit = (source: WorkerErrorSource, err: unknown) => {
+			if (fatalHandled) return;
+			fatalHandled = true;
+
+			const normalized = normalizeError(err);
+			if (batchState && batchState.phase !== "completed" && batchState.phase !== "failed") {
+				batchState.phase = "failed";
+				batchState.endedAt = Date.now();
+				batchState.errors.push(`[${source}] ${normalized.message}`);
+			}
+
+			if (batchState) send({ type: "state-sync", state: serializeBatchState(batchState) });
+			sendWithAck(
+				{ type: "error", source, message: normalized.message, stack: normalized.stack },
+				() => process.exit(1),
+			);
+			setTimeout(() => process.exit(1), 200).unref();
+		};
+
+		process.once("uncaughtException", (err: unknown) => reportFatalAndExit("uncaughtException", err));
+		process.once("unhandledRejection", (reason: unknown) => reportFatalAndExit("unhandledRejection", reason));
+
 		// Dynamic imports — only loaded in engine context to avoid circular
 		// dependencies when this module is imported from extension.ts
 		const { executeOrchBatch } = await import("./engine.ts");
@@ -209,7 +272,7 @@ if (process.env.TASKPLANE_ENGINE_FORK === "1" && typeof process.send === "functi
 		const data = initMsg.data;
 
 		// Create a fresh batch state for this process
-		const batchState: OrchBatchRuntimeState = freshOrchBatchState();
+		batchState = freshOrchBatchState();
 		batchState.phase = "launching";
 		batchState.startedAt = Date.now();
 
@@ -220,6 +283,7 @@ if (process.env.TASKPLANE_ENGINE_FORK === "1" && typeof process.send === "functi
 		// Main process sends pause/resume/abort signals via IPC.
 		// We apply them to the in-process batchState.pauseSignal.
 		process.on("message", (msg: WorkerInMessage) => {
+			if (!batchState) return;
 			switch (msg.type) {
 				case "pause":
 					batchState.pauseSignal.paused = true;
@@ -236,6 +300,7 @@ if (process.env.TASKPLANE_ENGINE_FORK === "1" && typeof process.send === "functi
 		// ── Callback factories (replace ctx-dependent callbacks) ─────
 		const onNotify = (message: string, level: "info" | "warning" | "error") => {
 			send({ type: "notify", msg: message, level });
+			if (!batchState) return;
 			// Sync batch state on every notify (lightweight — just the summary fields)
 			send({ type: "state-sync", state: serializeBatchState(batchState) });
 		};
@@ -292,15 +357,15 @@ if (process.env.TASKPLANE_ENGINE_FORK === "1" && typeof process.send === "functi
 				process.disconnect?.();
 			})
 			.catch((err: unknown) => {
-				const errMsg = err instanceof Error ? err.message : String(err);
+				const normalized = normalizeError(err);
 				// Ensure batch state reflects the failure
 				if (batchState.phase !== "completed" && batchState.phase !== "failed") {
 					batchState.phase = "failed";
 					batchState.endedAt = Date.now();
-					batchState.errors.push(`Unhandled engine error: ${errMsg}`);
+					batchState.errors.push(`Unhandled engine error: ${normalized.message}`);
 				}
 				send({ type: "state-sync", state: serializeBatchState(batchState) });
-				send({ type: "error", message: errMsg });
+				send({ type: "error", source: "enginePromise", message: normalized.message, stack: normalized.stack });
 				process.disconnect?.();
 			});
 	});

package/extensions/taskplane/extension.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-age
 import { Type } from "@mariozechner/pi-ai";
 
 import { execSync, execFileSync } from "child_process";
-import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync, readFileSync, statSync, createWriteStream } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { fork, type ChildProcess } from "child_process";
@@ -964,6 +964,7 @@ export function startBatchInWorker(
 		child = fork(workerPath, [], {
 			env: { ...process.env, TASKPLANE_ENGINE_FORK: "1" },
 			serialization: "advanced",
+			stdio: ["inherit", "inherit", "pipe", "ipc"],
 		});
 	} catch (spawnErr: unknown) {
 		const errMsg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
@@ -1007,11 +1008,78 @@ export function startBatchInWorker(
 		return null;
 	}
 
+	const telemetryDir = join(wkData.cwd, ".pi", "telemetry");
+	if (!existsSync(telemetryDir)) mkdirSync(telemetryDir, { recursive: true });
+	const pendingBatchId = `pending-${Date.now()}`;
+	const toSafeBatchId = (batchId: string) => batchId.replace(/[^a-zA-Z0-9._-]/g, "_");
+	let stderrBatchId = toSafeBatchId(batchState.batchId || pendingBatchId);
+	let stderrLogPath = join(telemetryDir, `${stderrBatchId}-engine-worker-stderr.log`);
+	let stderrLogStream = createWriteStream(stderrLogPath, { flags: "a" });
+	stderrLogStream.on("error", () => { /* non-fatal: telemetry stream */ });
+	let stderrTailBuffer = "";
+
+	const appendStderr = (chunk: Buffer | string) => {
+		const text = Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : chunk;
+		if (!text) return;
+		process.stderr.write(text);
+		stderrLogStream.write(text);
+		stderrTailBuffer = (stderrTailBuffer + text).slice(-24_000);
+	};
+
+	const rotateStderrLogToBatch = (batchId: string | undefined) => {
+		if (!batchId) return;
+		const resolvedBatchId = toSafeBatchId(batchId.trim());
+		if (!resolvedBatchId || resolvedBatchId === stderrBatchId) return;
+
+		const nextPath = join(telemetryDir, `${resolvedBatchId}-engine-worker-stderr.log`);
+		try {
+			// Flush pending writes before rotating. cork→uncork ensures buffered
+			// data is flushed synchronously before we read the file contents.
+			stderrLogStream.cork();
+			stderrLogStream.uncork();
+			stderrLogStream.end();
+			const pendingContent = existsSync(stderrLogPath) ? readFileSync(stderrLogPath, "utf-8") : "";
+			if (pendingContent) writeFileSync(nextPath, pendingContent, { flag: "a" });
+			if (existsSync(stderrLogPath)) unlinkSync(stderrLogPath);
+		} catch {
+			// best effort rename/copy
+		}
+
+		stderrBatchId = resolvedBatchId;
+		stderrLogPath = nextPath;
+		stderrLogStream = createWriteStream(stderrLogPath, { flags: "a" });
+		stderrLogStream.on("error", () => { /* non-fatal: telemetry stream */ });
+	};
+
+	const readStderrTail = (lineCount = 25): string => {
+		// Prefer in-memory tail buffer (always has the freshest unflushed data)
+		// over the disk file (which may lag behind due to stream buffering).
+		let content = stderrTailBuffer;
+		if (!content) {
+			try {
+				if (existsSync(stderrLogPath)) content = readFileSync(stderrLogPath, "utf-8");
+			} catch { /* fallback: empty */ }
+		}
+		const lines = content.split(/\r?\n/).filter(Boolean);
+		if (lines.length === 0) return "(no stderr output captured)";
+		return lines.slice(-lineCount).join("\n");
+	};
+
+	child.stderr?.on("data", appendStderr);
+	child.on("close", () => {
+		try {
+			stderrLogStream.end();
+		} catch {
+			// ignore
+		}
+	});
+
 	// Send workerData as first IPC message
 	child.send({ type: "init", data: wkData });
 
 	// Terminal settlement guard (R001 §3): ensures onTerminal fires at most once.
 	let settled = false;
+	let errorReceivedViaIpc = false;
 	const settle = () => {
 		if (settled) return;
 		settled = true;
@@ -1039,32 +1107,42 @@ export function startBatchInWorker(
 
 			case "state-sync":
 				applySerializedState(batchState, msg.state);
+				rotateStderrLogToBatch(msg.state.batchId);
 				updateWidget();
 				break;
 
 			case "complete":
 				applySerializedState(batchState, msg.state);
+				rotateStderrLogToBatch(msg.state.batchId);
 				updateWidget();
 				settle();
 				break;
 
-			case "error":
+			case "error": {
+				errorReceivedViaIpc = true;
+				const sourceLabel = msg.source ? ` (${msg.source})` : "";
+				const stackLine = msg.stack?.split("\n")[0]?.trim();
 				if (batchState.phase !== "completed" && batchState.phase !== "failed") {
 					batchState.phase = "failed";
 					batchState.endedAt = Date.now();
-					batchState.errors.push(`Unhandled engine error: ${msg.message}`);
+					batchState.errors.push(`Unhandled engine error${sourceLabel}: ${msg.message}`);
+					if (stackLine) batchState.errors.push(`Engine stack: ${stackLine}`);
 				}
 				ctx.ui.notify(
-					`❌ Engine crashed with unhandled error: ${msg.message}\n` +
+					`❌ Engine crashed with unhandled error${sourceLabel}: ${msg.message}\n` +
+					(stackLine ? `   ${stackLine}\n` : "") +
 					`   Batch ${batchState.batchId} marked as failed.`,
 					"error",
 				);
 				updateWidget();
 				break;
+			}
 		}
 	});
 
 	child.on("error", (err: Error) => {
+		rotateStderrLogToBatch(batchState.batchId || undefined);
+		const stderrTail = readStderrTail();
 		if (batchState.phase !== "completed" && batchState.phase !== "failed") {
 			batchState.phase = "failed";
 			batchState.endedAt = Date.now();
@@ -1082,6 +1160,7 @@ export function startBatchInWorker(
 			summary:
 				`🔴 Engine process error — batch ${batchState.batchId} marked as failed\n` +
 				`  Error: ${err.message}\n\n` +
+				`Engine stderr tail (${stderrLogPath}):\n${stderrTail}\n\n` +
 				`This is a critical engine failure. The batch cannot continue.\n` +
 				`Available actions:\n` +
 				`  - orch_status() to inspect state\n` +
@@ -1103,6 +1182,14 @@ export function startBatchInWorker(
 
 	child.on("exit", (code: number | null) => {
 		if (code !== 0 && !settled) {
+			// If we already received an error IPC with diagnostics, the exit is expected
+			// (the worker calls process.exit(1) after sending the error). Skip duplicate alert.
+			if (errorReceivedViaIpc) {
+				settle();
+				return;
+			}
+			rotateStderrLogToBatch(batchState.batchId || undefined);
+			const stderrTail = readStderrTail();
 			if (batchState.phase !== "completed" && batchState.phase !== "failed") {
 				batchState.phase = "failed";
 				batchState.endedAt = Date.now();
@@ -1119,6 +1206,7 @@ export function startBatchInWorker(
 				summary:
 					`🔴 Engine process died unexpectedly (exit code ${code})\n` +
 					`  Batch ${batchState.batchId} marked as failed.\n\n` +
+					`Engine stderr tail (${stderrLogPath}):\n${stderrTail}\n\n` +
 					`This is a critical engine failure. The batch cannot continue.\n` +
 					`Available actions:\n` +
 					`  - orch_status() to inspect state\n` +

package/extensions/taskplane/lane-runner.ts

@@ -312,8 +312,24 @@ export async function executeTaskV2(
 		// 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.
+		let reviewerSnapshotFailures = 0;
+		const reviewerRefreshFailureThreshold = 5;
 		const reviewerRefresh = setInterval(() => {
-			try { emitSnapshot(config, taskId, "running", iterationTelemetry, statusPath); } catch { /* non-fatal */ }
+			const ok = emitSnapshot(config, taskId, "running", iterationTelemetry, statusPath);
+			if (ok) {
+				reviewerSnapshotFailures = 0;
+				return;
+			}
+
+			reviewerSnapshotFailures += 1;
+			if (reviewerSnapshotFailures >= reviewerRefreshFailureThreshold) {
+				clearInterval(reviewerRefresh);
+				logExecution(
+					statusPath,
+					"Snapshot refresh disabled",
+					`Lane ${config.laneNumber}, task ${taskId}: ${reviewerSnapshotFailures} consecutive emitSnapshot failures`,
+				);
+			}
 		}, 1000);
 
 		let workerResult: AgentHostResult;
@@ -614,6 +630,8 @@ export function readReviewerTelemetrySnapshot(
  * caught and logged. This function is called from setInterval callbacks
  * and onTelemetry callbacks where an unhandled throw would trigger
  * uncaughtException and crash the engine-worker process.
+ *
+ * @returns true when snapshot write succeeds, false when it fails.
  */
 function emitSnapshot(
 	config: LaneRunnerConfig,
@@ -621,7 +639,7 @@ function emitSnapshot(
 	status: "running" | "idle" | "complete" | "failed",
 	telemetry: Partial<AgentHostResult>,
 	statusPath: string,
-): void {
+): boolean {
 	try {
 		// Parse progress from STATUS.md
 		let progress: RuntimeTaskProgress | null = null;
@@ -669,9 +687,11 @@ function emitSnapshot(
 		};
 
 		writeLaneSnapshot(config.stateRoot, config.batchId, config.laneNumber, snapshot as any);
+		return true;
 	} catch {
 		// Non-fatal: snapshot is telemetry, not execution-critical.
 		// Swallow to prevent uncaughtException crash in setInterval/callback contexts.
+		return false;
 	}
 }
 

package/package.json

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

package/templates/config/task-runner.yaml

@@ -48,8 +48,7 @@ worker:
   model: ""                    # empty = inherit from parent pi session
   tools: "read,write,edit,bash,grep,find,ls"
   thinking: "off"
-  # spawn_mode: "subprocess"   # "subprocess" (default) or "tmux"
-  # tmux_prefix: "task"        # used only in tmux mode
+  # spawn_mode: "subprocess"   # currently supported runtime mode
 
 reviewer:
   model: ""
@@ -63,7 +62,7 @@ context:
   max_worker_iterations: 20
   max_review_cycles: 2
   no_progress_limit: 3
-  # max_worker_minutes: 30      # used only in tmux mode
+  # max_worker_minutes: 30      # optional wall-clock guard for long worker runs
 
 # ── Task Creation / Discovery ─────────────────────────────────────────