taskplane 0.5.12 → 0.6.0

package/dashboard/public/app.js

@@ -73,6 +73,26 @@ function tokenSummaryFromLaneState(ls) {
   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])
+ *  @returns {string} HTML string with badges, or "" if nothing to show
+ */
+function telemetryBadgesHtml(tel) {
+  if (!tel) return "";
+  let badges = "";
+  if (tel.retryActive) {
+    const err = tel.lastRetryError ? ` — ${tel.lastRetryError}` : "";
+    badges += `<span class="telem-badge telem-retry-active" title="Retry in progress${escapeHtml(err)}">🔄 retrying</span>`;
+  } else if (tel.retries > 0) {
+    badges += `<span class="telem-badge telem-retry" title="${tel.retries} auto-retry event(s)">🔄 ${tel.retries}</span>`;
+  }
+  if (tel.compactions > 0) {
+    badges += `<span class="telem-badge telem-compaction" title="${tel.compactions} context compaction(s)">🗜 ${tel.compactions}</span>`;
+  }
+  return badges;
+}
+
 // ─── Copy to Clipboard ──────────────────────────────────────────────────────
 
 let toastEl = null;
@@ -342,14 +362,19 @@ function renderSummary(batch) {
 
   // Aggregate tokens across all active lane states
   const laneStates = currentData?.laneStates || {};
-  let batchInput = 0, batchOutput = 0, batchCacheRead = 0, batchCacheWrite = 0, batchCost = 0;
+  let batchInput = 0, batchOutput = 0, batchCacheRead = 0, batchCacheWrite = 0, batchCostFromLanes = 0;
   for (const ls of Object.values(laneStates)) {
     batchInput += ls.workerInputTokens || 0;
     batchOutput += ls.workerOutputTokens || 0;
     batchCacheRead += ls.workerCacheReadTokens || 0;
     batchCacheWrite += ls.workerCacheWriteTokens || 0;
-    batchCost += ls.workerCostUsd || 0;
+    batchCostFromLanes += ls.workerCostUsd || 0;
   }
+  // Use server-computed batchTotalCost (includes telemetry for uncovered lanes);
+  // fallback to lane-state-only sum for backward compatibility (pre-telemetry server)
+  const batchCost = (currentData?.batchTotalCost != null && currentData.batchTotalCost > 0)
+    ? currentData.batchTotalCost
+    : batchCostFromLanes;
   const batchTotalIn = batchInput + batchCacheRead;
   if (batchTotalIn > 0 || batchOutput > 0) {
     let tokenStr = `  ·  tokens: ↑${formatTokens(batchTotalIn)} ↓${formatTokens(batchOutput)}`;
@@ -386,6 +411,7 @@ function renderLanesTasks(batch, tmuxSessions) {
   const tasks = batch.tasks || [];
   const tmuxSet = new Set(tmuxSessions || []);
   const laneStates = currentData?.laneStates || {};
+  const telemetry = currentData?.telemetry || {};
   const showRepos = knownRepos.length >= 2;
   let html = "";
 
@@ -432,8 +458,9 @@ function renderLanesTasks(batch, tmuxSessions) {
       html += `<div class="task-row"><span class="task-icon"></span><span style="color:var(--text-faint);grid-column:2/-1;">No tasks assigned</span></div>`;
     }
 
-    // Get lane state for worker stats
+    // Get lane state and telemetry for worker stats
     const ls = laneStates[lane.tmuxSessionName] || null;
+    const tel = telemetry[lane.tmuxSessionName] || null;
 
     for (const task of laneTasks) {
       // Repo filtering at task level
@@ -486,8 +513,9 @@ function renderLanesTasks(batch, tmuxSessions) {
         stepHtml = `<span style="color:var(--text-faint)">${escapeHtml(task.exitReason || "—")}</span>`;
       }
 
-      // Worker stats from lane state sidecar — only show for the active (running) task
+      // Worker stats from lane state sidecar + telemetry badges
       let workerHtml = "";
+      const telemBadges = task.status !== "pending" ? telemetryBadgesHtml(tel) : "";
       if (ls && ls.workerStatus === "running" && task.status === "running") {
         const elapsed = ls.workerElapsed ? `${Math.round(ls.workerElapsed / 1000)}s` : "";
         const tools = ls.workerToolCount || 0;
@@ -500,11 +528,22 @@ function renderLanesTasks(batch, tmuxSessions) {
         if (ctx) workerHtml += `<span class="worker-stat" title="Context window used">📊 ${ctx}</span>`;
         if (tokenStr) workerHtml += `<span class="worker-stat" title="Tokens: input↑ output↓ cacheRead(R) cacheWrite(W)">🪙 ${tokenStr}</span>`;
         if (lastTool) workerHtml += `<span class="worker-stat worker-last-tool" title="Last tool call">${escapeHtml(lastTool)}</span>`;
+        workerHtml += telemBadges;
+        workerHtml += `</div>`;
+      } else if (!ls && tel && task.status === "running") {
+        // Running task with telemetry but no lane-state yet (early startup)
+        const lastTool = tel.lastTool || "";
+        workerHtml = `<div class="worker-stats">`;
+        if (lastTool) workerHtml += `<span class="worker-stat worker-last-tool" title="Last tool call">${escapeHtml(lastTool)}</span>`;
+        workerHtml += telemBadges;
         workerHtml += `</div>`;
       } else if (ls && ls.workerStatus === "done" && task.status !== "pending") {
-        workerHtml = `<div class="worker-stats"><span class="worker-stat" style="color:var(--green)">✓ Worker done</span></div>`;
+        workerHtml = `<div class="worker-stats"><span class="worker-stat" style="color:var(--green)">✓ Worker done</span>${telemBadges}</div>`;
       } else if (ls && ls.workerStatus === "error" && task.status !== "pending") {
-        workerHtml = `<div class="worker-stats"><span class="worker-stat" style="color:var(--red)">✗ Worker error</span></div>`;
+        workerHtml = `<div class="worker-stats"><span class="worker-stat" style="color:var(--red)">✗ Worker error</span>${telemBadges}</div>`;
+      } else if (telemBadges && task.status !== "pending") {
+        // No lane-state but telemetry exists (done/error lane without sidecar)
+        workerHtml = `<div class="worker-stats">${telemBadges}</div>`;
       }
 
       const isViewingStatus = viewerMode === 'status-md' && viewerTarget === task.taskId;

package/dashboard/public/style.css

@@ -631,6 +631,37 @@ body {
   text-overflow: ellipsis;
 }
 
+/* ─── Telemetry Badges (retry, compaction) ─────────────────────────────── */
+
+.telem-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  font-family: var(--font-mono);
+  font-size: 0.65rem;
+  font-weight: 500;
+  padding: 1px 7px;
+  border-radius: 8px;
+  white-space: nowrap;
+  margin-left: 4px;
+}
+
+.telem-retry {
+  background: rgba(210,153,34,0.15);
+  color: var(--yellow);
+}
+
+.telem-retry-active {
+  background: rgba(210,153,34,0.25);
+  color: var(--yellow);
+  animation: pulse 1.5s infinite;
+}
+
+.telem-compaction {
+  background: rgba(188,140,255,0.15);
+  color: var(--magenta);
+}
+
 /* ─── Conversation Viewer ──────────────────────────────────────────────── */
 
 .conv-stream {

package/dashboard/server.cjs

@@ -213,14 +213,337 @@ function loadLaneStates() {
   return states;
 }
 
+// ─── Telemetry JSONL Tailing ────────────────────────────────────────────────
+
+/**
+ * Module-level tail state for incremental JSONL reading.
+ * Persists across poll ticks within this server process.
+ * Key: absolute file path → { offset, partial }
+ */
+const telemetryTailStates = new Map();
+
+/**
+ * Module-level accumulated telemetry per tmux prefix.
+ * Persists across poll ticks so incremental tail reads accumulate correctly.
+ * Key: tmux prefix → { inputTokens, outputTokens, ... }
+ */
+const telemetryAccumulators = new Map();
+
+/**
+ * Tracks which files are currently contributing to each prefix.
+ * Key: tmux prefix → Set of absolute file paths
+ * Used to detect file rotation: when files change, accumulator is reset.
+ */
+const telemetryPrefixFiles = new Map();
+
+/**
+ * Parse a telemetry JSONL filename to extract lane number and role.
+ * Pattern: {opId}-{batchId}-{repoId}[-{taskId}][-lane-{N}]-{role}.jsonl
+ * Returns { laneNumber: number|null, role: string } or null if unparseable.
+ */
+function parseTelemetryFilename(filename) {
+  // Remove .jsonl extension
+  const base = filename.replace(/\.jsonl$/, "");
+  // Role is always the last segment
+  const lastDash = base.lastIndexOf("-");
+  if (lastDash < 0) return null;
+  const role = base.slice(lastDash + 1);
+  if (role !== "worker" && role !== "reviewer") return null;
+
+  // Extract lane number from -lane-{N}- pattern
+  const laneMatch = base.match(/-lane-(\d+)-/);
+  const laneNumber = laneMatch ? parseInt(laneMatch[1], 10) : null;
+
+  return { laneNumber, role };
+}
+
+/**
+ * Incrementally read new bytes from a JSONL file, parse events, and return them.
+ * Handles: file not yet created, empty reads, partial trailing lines, malformed JSON.
+ * @param {string} filePath - Absolute path to the JSONL file
+ * @returns {object[]} Array of parsed event objects from new data
+ */
+function tailJsonlFile(filePath) {
+  // Get or create tail state for this file
+  let tailState = telemetryTailStates.get(filePath);
+  if (!tailState) {
+    tailState = { offset: 0, partial: "" };
+    telemetryTailStates.set(filePath, tailState);
+  }
+
+  // Check file size
+  let fileSize;
+  try {
+    fileSize = fs.statSync(filePath).size;
+  } catch {
+    return []; // File doesn't exist yet
+  }
+
+  // Handle file truncation/recreation (offset beyond current size)
+  if (fileSize < tailState.offset) {
+    tailState.offset = 0;
+    tailState.partial = "";
+    tailState.wasReset = true; // Signal to caller that accumulator should be reset
+  }
+
+  if (fileSize <= tailState.offset) {
+    return []; // No new data
+  }
+
+  // Read new bytes from offset to end of file
+  const bytesToRead = fileSize - tailState.offset;
+  const buf = Buffer.alloc(bytesToRead);
+  let fd;
+  try {
+    fd = fs.openSync(filePath, "r");
+  } catch {
+    return []; // File became inaccessible
+  }
+  try {
+    fs.readSync(fd, buf, 0, bytesToRead, tailState.offset);
+  } catch {
+    fs.closeSync(fd);
+    return []; // Read error — try again next tick
+  }
+  fs.closeSync(fd);
+  tailState.offset = fileSize;
+
+  // Split into lines, preserving partial trailing line
+  const chunk = tailState.partial + buf.toString("utf-8");
+  const lines = chunk.split("\n");
+  tailState.partial = lines.pop() || "";
+
+  const events = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const event = JSON.parse(trimmed);
+      if (event && event.type) events.push(event);
+    } catch {
+      // Malformed JSON — skip (concurrent write race, truncated line)
+    }
+  }
+  return events;
+}
+
+/**
+ * Load and accumulate telemetry from .pi/telemetry/*.jsonl files.
+ * Returns telemetry keyed by tmux session prefix (e.g., "orch-lane-1").
+ *
+ * Uses batch-state lanes to map lane numbers → tmux prefixes.
+ * For standalone /task mode (no lane number in filename), data is keyed as "standalone".
+ *
+ * @param {object|null} batchState - The batch state from batch-state.json
+ * @returns {object} Map of tmuxPrefix → accumulated telemetry
+ */
+function loadTelemetryData(batchState) {
+  const telemetryDir = path.join(REPO_ROOT, ".pi", "telemetry");
+  const result = {};
+
+  // Build lane number → tmux prefix mapping from batch state
+  const laneToPrefix = {};
+  if (batchState && batchState.lanes) {
+    for (const lane of batchState.lanes) {
+      if (lane.laneNumber != null && lane.tmuxSessionName) {
+        laneToPrefix[lane.laneNumber] = lane.tmuxSessionName;
+      }
+    }
+  }
+
+  // Scan telemetry directory for JSONL files
+  let files;
+  try {
+    files = fs.readdirSync(telemetryDir).filter(f => f.endsWith(".jsonl"));
+  } catch {
+    // .pi/telemetry/ may not exist (pre-RPC sessions) — degrade gracefully
+    return result;
+  }
+
+  // Track which files still exist for tail-state cleanup
+  const currentFiles = new Set();
+  // Track current file→prefix mapping to detect file rotation
+  const currentPrefixFiles = new Map(); // prefix → Set<filePath>
+
+  for (const file of files) {
+    const filePath = path.join(telemetryDir, file);
+    currentFiles.add(filePath);
+
+    // Parse filename to get lane number and role
+    const parsed = parseTelemetryFilename(file);
+    if (!parsed) continue;
+
+    // Determine the key (tmux prefix)
+    let prefix;
+    if (parsed.laneNumber != null && laneToPrefix[parsed.laneNumber]) {
+      prefix = laneToPrefix[parsed.laneNumber];
+    } else if (parsed.laneNumber != null) {
+      // Lane number found but no batch-state mapping — use heuristic
+      prefix = `orch-lane-${parsed.laneNumber}`;
+    } else {
+      // Standalone /task mode
+      prefix = "standalone";
+    }
+
+    // Track file→prefix mapping
+    if (!currentPrefixFiles.has(prefix)) currentPrefixFiles.set(prefix, new Set());
+    currentPrefixFiles.get(prefix).add(filePath);
+
+    // Check if file set for this prefix has changed (file rotation)
+    const prevFiles = telemetryPrefixFiles.get(prefix);
+    const isNewFile = !prevFiles || !prevFiles.has(filePath);
+
+    // Initialize persistent accumulator for this prefix if needed,
+    // or reset if files changed (new file appeared for same prefix)
+    if (!telemetryAccumulators.has(prefix) || (isNewFile && !telemetryTailStates.has(filePath))) {
+      const fresh = {
+        inputTokens: 0, outputTokens: 0, cacheReadTokens: 0,
+        cacheWriteTokens: 0, cost: 0, toolCalls: 0,
+        lastTool: "", retries: 0, retryActive: false,
+        lastRetryError: "", compactions: 0, latestTotalTokens: 0,
+      };
+      telemetryAccumulators.set(prefix, fresh);
+      // Also reset tail states for ALL files of this prefix to re-read from beginning
+      if (prevFiles) {
+        for (const pf of prevFiles) {
+          telemetryTailStates.delete(pf);
+        }
+      }
+    }
+
+    const acc = telemetryAccumulators.get(prefix);
+    result[prefix] = acc; // expose the persistent accumulator in the result
+
+    // Tail the file for new events
+    const events = tailJsonlFile(filePath);
+
+    // Check if file was truncated — reset accumulator
+    const ts = telemetryTailStates.get(filePath);
+    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.lastRetryError = ""; acc.compactions = 0; acc.latestTotalTokens = 0;
+      ts.wasReset = false;
+    }
+    for (const event of events) {
+      switch (event.type) {
+        case "message_end": {
+          const usage = event.message?.usage;
+          if (usage) {
+            acc.inputTokens += usage.input || 0;
+            acc.outputTokens += usage.output || 0;
+            acc.cacheReadTokens += usage.cacheRead || 0;
+            acc.cacheWriteTokens += usage.cacheWrite || 0;
+            if (usage.cost) {
+              acc.cost += typeof usage.cost === "object"
+                ? (usage.cost.total || 0)
+                : (typeof usage.cost === "number" ? usage.cost : 0);
+            }
+            const totalTokens = usage.totalTokens
+              || ((usage.input || 0) + (usage.output || 0));
+            if (totalTokens > acc.latestTotalTokens) {
+              acc.latestTotalTokens = totalTokens;
+            }
+          }
+          break;
+        }
+        case "tool_execution_start": {
+          acc.toolCalls++;
+          const toolDesc = event.toolName || "unknown";
+          let argPreview = "";
+          if (event.args) {
+            if (typeof event.args === "string") {
+              argPreview = event.args.slice(0, 80);
+            } else if (typeof event.args === "object") {
+              const firstVal = Object.values(event.args)[0];
+              if (typeof firstVal === "string") {
+                argPreview = firstVal.slice(0, 80);
+              }
+            }
+          }
+          acc.lastTool = argPreview ? `${toolDesc} ${argPreview}` : toolDesc;
+          break;
+        }
+        case "auto_retry_start": {
+          acc.retries++;
+          acc.retryActive = true;
+          acc.lastRetryError = event.errorMessage || event.error || "unknown";
+          break;
+        }
+        case "auto_retry_end": {
+          acc.retryActive = false;
+          break;
+        }
+        case "auto_compaction_start": {
+          acc.compactions++;
+          break;
+        }
+      }
+    }
+  }
+
+  // Clean up tail states for files that no longer exist
+  for (const [filePath] of telemetryTailStates) {
+    if (filePath.startsWith(telemetryDir) && !currentFiles.has(filePath)) {
+      telemetryTailStates.delete(filePath);
+    }
+  }
+
+  // Update prefix→files tracking for next call
+  // Clean up accumulators and tracking for prefixes that have no remaining files
+  const activePrefixes = new Set(Object.keys(result));
+  for (const [prefix] of telemetryAccumulators) {
+    if (!activePrefixes.has(prefix)) {
+      telemetryAccumulators.delete(prefix);
+      telemetryPrefixFiles.delete(prefix);
+    }
+  }
+  // Store current file mappings for next call's rotation detection
+  for (const [prefix, fileSet] of currentPrefixFiles) {
+    telemetryPrefixFiles.set(prefix, fileSet);
+  }
+
+  return result;
+}
+
+/**
+ * Compute batch total cost from lane states (primary) and telemetry (supplementary).
+ * Lane states are authoritative — telemetry provides additional data only for lanes
+ * that have no lane-state entry (e.g., very early in session startup).
+ */
+function computeBatchTotalCost(laneStates, telemetry) {
+  let totalCost = 0;
+  const coveredPrefixes = new Set();
+
+  // Primary: sum cost from lane states
+  for (const [prefix, ls] of Object.entries(laneStates)) {
+    if (ls.workerCostUsd) {
+      totalCost += ls.workerCostUsd;
+      coveredPrefixes.add(prefix);
+    }
+  }
+
+  // Supplementary: add cost from telemetry for uncovered lanes only
+  for (const [prefix, tel] of Object.entries(telemetry)) {
+    if (!coveredPrefixes.has(prefix) && tel.cost > 0) {
+      totalCost += tel.cost;
+    }
+  }
+
+  return totalCost;
+}
+
 /** Build full dashboard state object for the frontend. */
 function buildDashboardState() {
   const state = loadBatchState();
   const tmuxSessions = getTmuxSessions();
   const laneStates = loadLaneStates();
+  const telemetry = loadTelemetryData(state);
+  const batchTotalCost = computeBatchTotalCost(laneStates, telemetry);
 
   if (!state) {
-    return { batch: null, tmuxSessions, laneStates: {}, timestamp: Date.now() };
+    return { batch: null, tmuxSessions, laneStates: {}, telemetry: {}, batchTotalCost: 0, timestamp: Date.now() };
   }
 
   const tasks = (state.tasks || []).map((task) => {
@@ -237,6 +560,8 @@ function buildDashboardState() {
 
   return {
     laneStates,
+    telemetry,
+    batchTotalCost,
     batch: {
       batchId: state.batchId,
       phase: state.phase,