taskplane 0.27.0 → 0.28.1

package/dashboard/public/app.js

@@ -241,6 +241,7 @@ let viewingHistoryId = null; // batchId if viewing history, null if live
 
 let viewerMode = null;   // "conversation" | "status-md" | null
 let viewerTarget = null; // session name (conversation) or taskId (status-md)
+let lastBatchId = null;  // TP-178: track batchId for stale viewer detection (#487)
 
 // ─── Repo Helpers ───────────────────────────────────────────────────────────
 
@@ -515,14 +516,18 @@ function renderSummary(batch) {
     const fillPct = ws.total > 0 ? (ws.checked / ws.total) * 100 : 0;
     const checkboxDone = ws.checked === ws.total && ws.total > 0;
     const pastWave = ws.waveIdx < currentWaveIdx;
-    const batchDone = batch.phase === "completed" || batch.phase === "merging";
+    const batchDone = batch.phase === "completed";
+    // TP-178: During merging, only past waves are done; current wave is merging, future waves are pending (#493)
+    const isMerging = batch.phase === "merging";
     const isDone = checkboxDone || pastWave || batchDone || ws.allSucceeded;
-    const isCurrent = ws.waveIdx === currentWaveIdx && (batch.phase === "executing" || batch.phase === "merging");
-    const isFuture = ws.waveIdx > currentWaveIdx && batch.phase === "executing";
+    const isMergingWave = isMerging && ws.waveIdx === currentWaveIdx;
+    const isCurrent = ws.waveIdx === currentWaveIdx && (batch.phase === "executing" || isMerging);
+    const isFuture = ws.waveIdx > currentWaveIdx && (batch.phase === "executing" || isMerging);
 
     const fillClass = isDone ? "pct-hi" : fillPct > 50 ? "pct-mid" : fillPct > 0 ? "pct-low" : "pct-0";
     const fillWidth = isDone ? 100 : fillPct;
-    const segClass = isCurrent ? "wave-seg-current" : isFuture ? "wave-seg-future" : "";
+    // TP-178: Add merging visual state for the wave currently being merged (#493)
+    const segClass = isMergingWave ? "wave-seg-current wave-seg-merging" : isCurrent ? "wave-seg-current" : isFuture ? "wave-seg-future" : "";
 
     // TP-148: Use segment-aware labels in tooltip when available
     const segLabels = waveSegmentLabels[ws.waveIdx] || new Map();
@@ -604,9 +609,11 @@ function renderSummary(batch) {
     const waveIdx = batch.currentWaveIndex || 0;
     let wavesHtml = '<span style="color:var(--text-muted); font-weight:600; margin-right:4px;">Waves</span>';
     batch.wavePlan.forEach((taskIds, i) => {
-      const isDone = i < waveIdx || batch.phase === "completed" || batch.phase === "merging";
-      const isCurrent = i === waveIdx && batch.phase === "executing";
-      const cls = isDone ? "done" : isCurrent ? "current" : "";
+      // TP-178: During merging, only past waves are done; current wave shows merging state (#493)
+      const isDone = i < waveIdx || batch.phase === "completed";
+      const isCurrent = i === waveIdx && (batch.phase === "executing" || batch.phase === "merging");
+      const isMergingChip = i === waveIdx && batch.phase === "merging";
+      const cls = isDone ? "done" : isMergingChip ? "current merging" : isCurrent ? "current" : "";
       wavesHtml += `<span class="wave-chip ${cls}">W${i + 1} [${taskIds.join(", ")}]</span>`;
     });
     $summaryWaves.innerHTML = wavesHtml;
@@ -699,21 +706,30 @@ function renderLanesTasks(batch, sessions) {
       const showPacketHome = !!packetHomeRepo && packetHomeRepo !== (tRepo || lane.repoId || "");
 
       // Progress cell
+      // TP-174: Prefer V2 snapshot progress (segment-scoped when available)
+      // over full STATUS.md counts when the task is actively running on this lane.
+      // TP-176: Succeeded tasks always show 100% regardless of sidecar/statusData (#491).
       let progressHtml = "";
-      if (sd) {
-        const fillClass = pctClass(sd.progress);
+      const v2p = ls && ls._v2Progress;
+      const useV2 = v2p && v2p.total > 0 && ls.taskId === task.taskId;
+      if (task.status === "succeeded") {
+        // #491 fix: succeeded tasks always show 100%
         progressHtml = `
           <div class="task-progress">
-            <div class="task-progress-bar">
-              <div class="task-progress-fill ${fillClass}" style="width:${sd.progress}%"></div>
-            </div>
-            <span class="task-progress-text">${sd.progress}% ${sd.checked}/${sd.total}</span>
+            <div class="task-progress-bar"><div class="task-progress-fill pct-hi" style="width:100%"></div></div>
+            <span class="task-progress-text">100%</span>
           </div>`;
-      } else if (task.status === "succeeded") {
+      } else if (sd || useV2) {
+        const displayChecked = useV2 ? v2p.checked : (sd ? sd.checked : 0);
+        const displayTotal = useV2 ? v2p.total : (sd ? sd.total : 0);
+        const displayProgress = displayTotal > 0 ? Math.round((displayChecked / displayTotal) * 100) : 0;
+        const fillClass = pctClass(displayProgress);
         progressHtml = `
           <div class="task-progress">
-            <div class="task-progress-bar"><div class="task-progress-fill pct-hi" style="width:100%"></div></div>
-            <span class="task-progress-text">100%</span>
+            <div class="task-progress-bar">
+              <div class="task-progress-fill ${fillClass}" style="width:${displayProgress}%"></div>
+            </div>
+            <span class="task-progress-text">${displayProgress}% ${displayChecked}/${displayTotal}</span>
           </div>`;
       } else if (task.status === "pending") {
         progressHtml = `
@@ -721,18 +737,32 @@ function renderLanesTasks(batch, sessions) {
             <div class="task-progress-bar"><div class="task-progress-fill pct-0" style="width:0%"></div></div>
             <span class="task-progress-text">0%</span>
           </div>`;
+      } else if (task.status === "running") {
+        // TP-178: Show executing indicator for running tasks without sidecar data (#494)
+        // This covers non-final segment execution where the sidecar hasn't started yet.
+        progressHtml = `
+          <div class="task-progress">
+            <div class="task-progress-bar"><div class="task-progress-fill pct-low task-progress-executing" style="width:100%"></div></div>
+            <span class="task-progress-text">executing…</span>
+          </div>`;
       } else {
         progressHtml = '<span style="color:var(--text-faint)">—</span>';
       }
 
       // Step cell
+      // TP-178: Prefer V2 snapshot currentStep (refreshed every sidecar poll) over
+      // server-parsed statusData which can lag behind (#488).
       let stepHtml = "";
-      if (sd) {
-        stepHtml = escapeHtml(sd.currentStep);
-        if (sd.iteration > 0) stepHtml += `<span class="task-iter">i${sd.iteration}</span>`;
-        if (sd.reviews > 0) stepHtml += `<span class="task-iter">r${sd.reviews}</span>`;
-      } else if (task.status === "succeeded") {
+      if (task.status === "succeeded") {
+        // TP-178: Succeeded tasks always show "Complete" regardless of sidecar data (#491)
         stepHtml = '<span style="color:var(--green)">Complete</span>';
+      } else if (sd || (useV2 && v2p)) {
+        const stepName = (useV2 && v2p && v2p.currentStep) ? v2p.currentStep : (sd ? sd.currentStep : "Unknown");
+        const iter = (useV2 && v2p && v2p.iteration != null) ? v2p.iteration : (sd ? sd.iteration : 0);
+        const revs = (useV2 && v2p && v2p.reviews != null) ? v2p.reviews : (sd ? sd.reviews : 0);
+        stepHtml = escapeHtml(stepName);
+        if (iter > 0) stepHtml += `<span class="task-iter">i${iter}</span>`;
+        if (revs > 0) stepHtml += `<span class="task-iter">r${revs}</span>`;
       } else if (task.status === "pending") {
         stepHtml = '<span style="color:var(--text-faint)">Waiting</span>';
       } else {
@@ -978,15 +1008,27 @@ function renderMergeAgents(batch, sessions) {
     const effectiveAlive = !!effectiveSession;
     if (effectiveSession) shownSessions.add(effectiveSession);
 
-    // Find merge telemetry: try sessions by lane number first
+    // TP-178: Find merge telemetry precisely using waveIndex (#498).
+    // First try matching by waveIndex from the telemetry entries (injected from merge snapshots).
+    // Then fall back to session-based matching (lane numbers), but never use a
+    // catch-all fallback that grabs any merge session's telemetry.
     let mergeTel = null;
-    for (const ln of waveLaneNums) {
-      const candidate = getMergeSessionName(ln);
-      if (telemetry[candidate]) { mergeTel = telemetry[candidate]; break; }
+    // Priority 1: Match by waveIndex in telemetry entries
+    for (const [telKey, tel] of Object.entries(telemetry)) {
+      if (tel._source === "merge-snapshot" && tel.waveIndex === mr.waveIndex) {
+        mergeTel = tel;
+        break;
+      }
+    }
+    // Priority 2: Match by lane number session
+    if (!mergeTel) {
+      for (const ln of waveLaneNums) {
+        const candidate = getMergeSessionName(ln);
+        if (telemetry[candidate]) { mergeTel = telemetry[candidate]; break; }
+      }
     }
-    // Fallback: effective session telemetry or any merge session
+    // Priority 3: Effective session telemetry only (no catch-all fallback)
     if (!mergeTel && effectiveSession) mergeTel = telemetry[effectiveSession] || null;
-    if (!mergeTel) mergeTel = mergeSessions.reduce((found, ms) => found || telemetry[ms] || null, null);
 
     html += `<tr>`;
     html += `<td class="merge-wave-cell">Wave ${mr.waveIndex + 1}</td>`;
@@ -1434,6 +1476,8 @@ function buildRecoveryTimeline(supervisor) {
     target: a.target || a.lane || a.taskId || "",
     outcome: a.outcome || a.result || "",
     reason: a.reason || "",
+    context: a.context || "",
+    detail: a.detail || "",
     source: "action"
   }));
 
@@ -1447,6 +1491,8 @@ function buildRecoveryTimeline(supervisor) {
       target: e.target || e.lane || e.taskId || "",
       outcome: e.outcome || e.result || "",
       reason: e.reason || e.message || "",
+      context: e.context || "",
+      detail: e.detail || "",
       source: "event"
     }));
 
@@ -1479,6 +1525,7 @@ function renderSupervisorActions(supervisor) {
     const target = entry.target;
     const outcome = entry.outcome;
     const reason = entry.reason;
+    const description = entry.context || entry.detail || "";
 
     const outcomeCls = outcome === "success" || outcome === "recovered"
       ? "action-success"
@@ -1498,6 +1545,11 @@ function renderSupervisorActions(supervisor) {
     if (target) html += `<span class="supervisor-action-target">${escapeHtml(target)}</span>`;
     if (outcome) html += `<span class="supervisor-action-outcome ${outcomeCls}">${escapeHtml(outcome)}</span>`;
     html += `    </div>`;
+    if (description) {
+      const fullDesc = escapeHtml(description);
+      const truncated = description.length > 100 ? escapeHtml(description.slice(0, 100)) + "\u2026" : fullDesc;
+      html += `<div class="supervisor-action-description" title="${fullDesc}">${truncated}</div>`;
+    }
     if (reason) {
       html += `<div class="supervisor-action-reason">${escapeHtml(reason)}</div>`;
     }
@@ -1558,6 +1610,9 @@ function render(data) {
   $lastUpdate.textContent = new Date().toLocaleTimeString();
 
   if (!batch) {
+    // TP-178: Clear viewer when batch disappears (#487)
+    if (lastBatchId && viewerMode) closeViewer();
+    lastBatchId = null;
     renderHeader(null);
     renderSummary(null);
     renderSupervisor(data);
@@ -1567,6 +1622,12 @@ function render(data) {
     return;
   }
 
+  // TP-178: Detect batchId change — clear stale viewer state (#487)
+  if (batch.batchId && lastBatchId && batch.batchId !== lastBatchId && viewerMode) {
+    closeViewer();
+  }
+  lastBatchId = batch.batchId || null;
+
   // Live batch is running — hide history panel, reset viewing state
   if (viewingHistoryId) {
     viewingHistoryId = null;
@@ -1881,6 +1942,127 @@ function renderV2Event(evt) {
   }
 }
 
+// ── Segment-Scoped STATUS.md Helpers (TP-176) ──────────────────────────────
+
+/**
+ * Resolve the active segment repoId for a given task.
+ * Uses runtimeLaneSnapshots (active segment) and falls back to
+ * taskSegmentProgress (batch state).
+ * Returns { repoId, segmentInfo } or null if single-segment / unresolvable.
+ */
+function resolveActiveSegmentForTask(taskId) {
+  if (!currentData) return null;
+  const batch = currentData.batch;
+  if (!batch) return null;
+  const task = (batch.tasks || []).find(t => t.taskId === taskId);
+  if (!task) return null;
+  const segmentIds = Array.isArray(task.segmentIds) ? task.segmentIds.filter(id => typeof id === "string") : [];
+  if (segmentIds.length <= 1) return null; // single-segment or no segments
+
+  // Try to get active segment from runtime lane snapshots
+  const v2Snapshots = currentData.runtimeLaneSnapshots || {};
+  for (const snap of Object.values(v2Snapshots)) {
+    if (snap && snap.taskId === taskId && snap.segmentId) {
+      const parsed = parseSegmentId(snap.segmentId);
+      if (parsed) {
+        const idx = segmentIds.indexOf(snap.segmentId);
+        return {
+          repoId: parsed.repoId,
+          segmentInfo: {
+            index: idx >= 0 ? idx + 1 : null,
+            total: segmentIds.length,
+            repoId: parsed.repoId,
+            segmentId: snap.segmentId,
+          },
+        };
+      }
+    }
+  }
+
+  // Fallback: use taskSegmentProgress (batch state)
+  const segmentStatusMap = buildSegmentStatusMap(batch);
+  const info = taskSegmentProgress(task, segmentStatusMap, null);
+  if (info && info.repoId) {
+    return { repoId: info.repoId, segmentInfo: info };
+  }
+  return null;
+}
+
+/**
+ * Filter STATUS.md content to show only the active segment's blocks.
+ * Within each `### Step N:` section, removes `#### Segment: <otherRepo>` blocks
+ * and keeps only the block matching `activeRepoId`.
+ * Non-step content (metadata, notes, reviews, etc.) is preserved.
+ *
+ * Returns the filtered markdown string, or the original if no segment markers found.
+ */
+function filterStatusMdForSegment(markdown, activeRepoId) {
+  if (!activeRepoId) return markdown;
+  const lines = markdown.split('\n');
+  const result = [];
+  let inStep = false;          // inside a ### Step section
+  let inSegmentBlock = false;  // inside a #### Segment: <repo> block
+  let segmentMatch = false;    // current segment block matches active repo
+  let foundAnySegmentHeader = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Detect step headers: ### Step N: ...
+    if (/^###\s+Step\s+\d+/.test(line)) {
+      inStep = true;
+      inSegmentBlock = false;
+      segmentMatch = false;
+      result.push(line);
+      continue;
+    }
+
+    // Detect non-step ### headers (e.g., ### Reviews, ### Notes)
+    if (/^###\s+/.test(line) && !/^###\s+Step\s+\d+/.test(line)) {
+      inStep = false;
+      inSegmentBlock = false;
+      segmentMatch = false;
+      result.push(line);
+      continue;
+    }
+
+    // Inside a step section, detect #### Segment: <repoId> headers
+    if (inStep && /^####\s+Segment:\s*/.test(line)) {
+      foundAnySegmentHeader = true;
+      const segRepo = line.replace(/^####\s+Segment:\s*/, '').trim();
+      inSegmentBlock = true;
+      segmentMatch = (segRepo === activeRepoId);
+      if (segmentMatch) {
+        result.push(line);
+      }
+      continue;
+    }
+
+    // Detect any other #### header (ends current segment block)
+    if (/^####\s+/.test(line)) {
+      inSegmentBlock = false;
+      segmentMatch = false;
+      result.push(line);
+      continue;
+    }
+
+    // If we're in a segment block, only include matching lines
+    if (inSegmentBlock) {
+      if (segmentMatch) {
+        result.push(line);
+      }
+      continue;
+    }
+
+    // Outside segment blocks: keep the line
+    result.push(line);
+  }
+
+  // If no segment headers were found, return original (fallback for single-segment)
+  if (!foundAnySegmentHeader) return markdown;
+  return result.join('\n');
+}
+
 // ── Open STATUS.md viewer ───────────────────────────────────────────────────
 
 function viewStatusMd(taskId) {
@@ -1897,7 +2079,15 @@ function viewStatusMd(taskId) {
   autoScrollOn = false;
   lastStatusMdText = '';
 
-  $terminalTitle.textContent = `STATUS.md — ${taskId}`;
+  // TP-176: Include segment context in title for multi-segment tasks
+  const segData = resolveActiveSegmentForTask(taskId);
+  if (segData && segData.segmentInfo) {
+    const label = segmentProgressText(segData.segmentInfo);
+    $terminalTitle.textContent = `STATUS.md — ${taskId} · ${label}`;
+  } else {
+    $terminalTitle.textContent = `STATUS.md — ${taskId}`;
+  }
+
   $autoScrollText.textContent = 'Track progress';
   $autoScrollCheckbox.checked = false;
   $terminalPanel.style.display = '';
@@ -1916,11 +2106,22 @@ function pollStatusMd() {
       return r.text();
     })
     .then(text => {
+      // TP-176: Apply segment-scoped filtering for multi-segment tasks.
+      // Re-resolve on each poll since the active segment may change.
+      const segData = resolveActiveSegmentForTask(viewerTarget);
+      let displayText = text;
+      if (segData && segData.repoId) {
+        displayText = filterStatusMdForSegment(text, segData.repoId);
+        // Update title with current segment context (may change between polls)
+        const label = segmentProgressText(segData.segmentInfo);
+        $terminalTitle.textContent = `STATUS.md \u2014 ${viewerTarget} \u00b7 ${label}`;
+      }
+
       // Diff-and-skip: no change, no DOM update
-      if (text === lastStatusMdText) return;
-      lastStatusMdText = text;
+      if (displayText === lastStatusMdText) return;
+      lastStatusMdText = displayText;
 
-      const { html, hasLastChecked } = renderStatusMd(text);
+      const { html, hasLastChecked } = renderStatusMd(displayText);
       $terminalBody.innerHTML = html;
 
       // Update tracking highlight

package/dashboard/public/style.css

@@ -415,6 +415,20 @@ body {
   color: var(--green);
 }
 
+/* TP-178: Merging wave indicator — pulsing accent to distinguish from executing (#493) */
+.wave-chip.merging {
+  animation: merge-pulse 1.5s ease-in-out infinite;
+}
+
+.wave-seg-merging {
+  animation: merge-pulse 1.5s ease-in-out infinite;
+}
+
+@keyframes merge-pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.5; }
+}
+
 /* ─── Content ──────────────────────────────────────────────────────────── */
 
 .content {
@@ -713,6 +727,16 @@ body {
 .task-progress-fill.pct-mid { background: var(--cyan); }
 .task-progress-fill.pct-hi  { background: var(--green); }
 
+/* TP-178: Pulsing indicator for executing tasks without sidecar progress (#494) */
+.task-progress-executing {
+  opacity: 0.4;
+  animation: executing-pulse 2s ease-in-out infinite;
+}
+@keyframes executing-pulse {
+  0%, 100% { opacity: 0.25; }
+  50% { opacity: 0.55; }
+}
+
 .task-progress-text {
   font-family: var(--font-mono);
   font-size: 0.75rem;
@@ -1555,6 +1579,18 @@ body {
   color: var(--yellow);
 }
 
+.supervisor-action-description {
+  font-size: 0.8rem;
+  color: var(--text-secondary, #b0b0b0);
+  margin-top: 3px;
+  line-height: 1.4;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  max-width: 600px;
+  cursor: default;
+}
+
 .supervisor-action-reason {
   font-size: 0.78rem;
   color: var(--text-muted);

package/dashboard/server.cjs

@@ -1153,6 +1153,8 @@ function buildDashboardState() {
         latestTotalTokens: (agent.inputTokens || 0) + (agent.outputTokens || 0),
         _updatedAt: snap.updatedAt,
         _source: "merge-snapshot",
+        // TP-178: Include waveIndex for precise wave-telemetry association (#498)
+        waveIndex: snap.waveIndex != null ? snap.waveIndex : undefined,
       };
     }
   }