taskplane 0.28.0 → 0.28.2

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,20 @@ 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 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 batchDone = batch.phase === "completed";
+    // TP-178: During merging, only past waves are truly done. The current wave's
+    // checkboxDone/allSucceeded can be true (tasks finished) but the wave itself
+    // isn't done until the merge completes. (#493)
+    const isMerging = batch.phase === "merging";
+    const isDone = batchDone || pastWave || (!isMerging && (checkboxDone || ws.allSucceeded));
+    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 +611,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;
@@ -704,7 +713,10 @@ function renderLanesTasks(batch, sessions) {
       // TP-176: Succeeded tasks always show 100% regardless of sidecar/statusData (#491).
       let progressHtml = "";
       const v2p = ls && ls._v2Progress;
-      const useV2 = v2p && v2p.total > 0 && ls.taskId === task.taskId;
+      const taskMatch = v2p && ls.taskId === task.taskId;
+      // Split V2 usage: progress needs totals > 0, but step/iter can be used whenever present
+      const useV2Progress = taskMatch && v2p.total > 0;
+      const useV2Step = taskMatch && !!v2p.currentStep;
       if (task.status === "succeeded") {
         // #491 fix: succeeded tasks always show 100%
         progressHtml = `
@@ -712,9 +724,9 @@ function renderLanesTasks(batch, sessions) {
             <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 (sd || useV2) {
-        const displayChecked = useV2 ? v2p.checked : (sd ? sd.checked : 0);
-        const displayTotal = useV2 ? v2p.total : (sd ? sd.total : 0);
+      } else if (useV2Progress || (sd && sd.total > 0)) {
+        const displayChecked = useV2Progress ? v2p.checked : sd.checked;
+        const displayTotal = useV2Progress ? v2p.total : sd.total;
         const displayProgress = displayTotal > 0 ? Math.round((displayChecked / displayTotal) * 100) : 0;
         const fillClass = pctClass(displayProgress);
         progressHtml = `
@@ -724,6 +736,14 @@ function renderLanesTasks(batch, sessions) {
             </div>
             <span class="task-progress-text">${displayProgress}% ${displayChecked}/${displayTotal}</span>
           </div>`;
+      } else if (task.status === "running") {
+        // #494 fix: running tasks without meaningful totals show executing indicator
+        // This covers non-final segments, early execution before sidecar captures, and stale 0/0 data
+        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 if (task.status === "pending") {
         progressHtml = `
           <div class="task-progress">
@@ -735,13 +755,20 @@ function renderLanesTasks(batch, sessions) {
       }
 
       // 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 || useV2Step) {
+        // #488 fix: prefer V2 step name whenever present (even if totals are 0)
+        const stepName = useV2Step ? v2p.currentStep : (sd ? sd.currentStep : "Unknown");
+        const iter = (useV2Step && v2p.iteration != null) ? v2p.iteration : (sd ? sd.iteration : 0);
+        const revs = (useV2Step && 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 {
@@ -987,15 +1014,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>`;
@@ -1443,6 +1482,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"
   }));
 
@@ -1456,6 +1497,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"
     }));
 
@@ -1488,6 +1531,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"
@@ -1507,6 +1551,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>`;
     }
@@ -1567,6 +1616,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);
@@ -1576,6 +1628,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;

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,
       };
     }
   }

package/extensions/taskplane/discovery.ts

@@ -659,11 +659,11 @@ export function parsePromptForOrchestrator(
 
 		// Check for "None" variants
 		if (!/\*?\*?None\*?\*?/i.test(depBody) && depBody.length > 0) {
-			// Pattern 1: "**Requires:** COMP-005 ..." or "**Requires:** time-off/TO-014 ..."
-			const requiresMatches = depBody.matchAll(
-				/\*?\*?Requires:?\*?\*?\s*((?:[a-z0-9-]+\/)?[A-Z]+-\d+)/gi,
+			// Pattern 1: "**Requires:** COMP-005 ..." or "**Task:** TO-014 ..."
+			const labeledMatches = depBody.matchAll(
+				/\*?\*?(?:Requires|Task):?\*?\*?\s*((?:[a-z0-9-]+\/)?[A-Z]+-\d+)/gi,
 			);
-			for (const m of requiresMatches) {
+			for (const m of labeledMatches) {
 				const dep = normalizeDependencyReference(m[1]);
 				if (!dependencies.includes(dep)) dependencies.push(dep);
 			}

package/extensions/taskplane/extension.ts

@@ -15,7 +15,7 @@ import { ORCH_MESSAGES, computeIntegrateCleanupResult } from "./messages.ts";
 import type { IntegrateCleanupRepoFindings } from "./messages.ts";
 import { computeWaveAssignments } from "./waves.ts";
 import { createOrchWidget, formatDependencyGraph, formatWavePlan } from "./formatting.ts";
-import { deleteBatchState, loadBatchState, saveBatchState, detectOrphanSessions } from "./persistence.ts";
+import { deleteBatchState, loadBatchState, saveBatchState, detectOrphanSessions, updateBatchHistoryIntegration } from "./persistence.ts";
 import { deleteStaleBranches, listWorktrees, resolveWorktreeBasePath, formatPreflightResults, runPreflight } from "./worktree.ts";
 import { computeTransitiveDependents, resolveCanonicalTaskPaths } from "./execution.ts";
 import { executeOrchBatch } from "./engine.ts";
@@ -1385,7 +1385,7 @@ export function buildIntegrationExecutor(repoRoot: string, opId?: string, stateR
 				}
 			},
 			deleteBatchState: () => {
-				try { deleteBatchState(repoRoot); } catch { /* best effort */ }
+				try { deleteBatchState(stateRoot ?? repoRoot); } catch { /* best effort */ }
 			},
 		};
 
@@ -1411,6 +1411,11 @@ export function buildIntegrationExecutor(repoRoot: string, opId?: string, stateR
 			try {
 				cleanupPostIntegrate(stateRoot ?? repoRoot, context.batchId);
 			} catch { /* best effort — don't fail integration for cleanup errors */ }
+
+			// TP-179: Write integratedAt to batch history before state is gone
+			try {
+				updateBatchHistoryIntegration(stateRoot ?? repoRoot, context.batchId, Date.now());
+			} catch { /* best effort */ }
 		}
 
 		return result;
@@ -1428,7 +1433,7 @@ export function buildIntegrationExecutor(repoRoot: string, opId?: string, stateR
  *
  * @since TP-043
  */
-export function buildCiDeps(repoRoot: string): CiDeps {
+export function buildCiDeps(repoRoot: string, stateRoot?: string): CiDeps {
 	return {
 		runCommand: (cmd: string, cmdArgs: string[]) => {
 			try {
@@ -1450,7 +1455,7 @@ export function buildCiDeps(repoRoot: string): CiDeps {
 		},
 		runGit: (gitArgs: string[]) => runGit(gitArgs, repoRoot),
 		deleteBatchState: () => {
-			try { deleteBatchState(repoRoot); } catch { /* best effort */ }
+			try { deleteBatchState(stateRoot ?? repoRoot); } catch { /* best effort */ }
 		},
 	};
 }
@@ -2149,7 +2154,7 @@ export default function (pi: ExtensionAPI) {
 						mode,
 						repoRoot,
 						buildIntegrationExecutor(repoRoot, opId, execCtx!.workspaceRoot),
-						buildCiDeps(repoRoot),
+						buildCiDeps(repoRoot, execCtx!.workspaceRoot),
 						sDeps,
 					);
 					return;
@@ -2486,7 +2491,7 @@ export default function (pi: ExtensionAPI) {
 						mode,
 						execCtx!.repoRoot,
 						buildIntegrationExecutor(execCtx!.repoRoot, opId, execCtx!.workspaceRoot),
-						buildCiDeps(execCtx!.repoRoot),
+						buildCiDeps(execCtx!.repoRoot, execCtx!.workspaceRoot),
 						sDeps,
 					);
 					return;
@@ -3320,7 +3325,12 @@ export default function (pi: ExtensionAPI) {
 			hasWarning = true;
 		}
 
-		try { deleteBatchState(repoRoot); } catch { /* best effort */ }
+		// TP-179: Write integratedAt to batch history before deleting state
+		if (batchId) {
+			try { updateBatchHistoryIntegration(stateRoot, batchId, Date.now()); } catch { /* best effort */ }
+		}
+
+		try { deleteBatchState(stateRoot); } catch { /* best effort */ }
 
 		// ── TP-065: Post-integrate artifact cleanup (Layer 1) ────
 		// Delete batch-specific telemetry and merge result files.

package/extensions/taskplane/persistence.ts

@@ -1876,6 +1876,35 @@ export function saveBatchHistory(repoRoot: string, summary: BatchHistorySummary)
 	}
 }
 
+/**
+ * Update an existing batch history entry with the integration timestamp.
+ *
+ * Sets `integratedAt` on the matching entry (by batchId). If no entry
+ * is found, this is a no-op — the batch may predate the history feature.
+ *
+ * @since TP-179
+ */
+export function updateBatchHistoryIntegration(repoRoot: string, batchId: string, integratedAt: number): void {
+	const filePath = batchHistoryPath(repoRoot);
+	try {
+		const history = loadBatchHistory(repoRoot);
+		const entry = history.find(e => e.batchId === batchId);
+		if (!entry) {
+			execLog("batch", "history", `no history entry found for batchId=${batchId}, skipping integratedAt update`);
+			return;
+		}
+		entry.integratedAt = integratedAt;
+		const dir = dirname(filePath);
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const tmpPath = filePath + ".tmp";
+		writeFileSync(tmpPath, JSON.stringify(history, null, 2));
+		renameSync(tmpPath, filePath);
+		execLog("batch", "history", `updated integratedAt for batchId=${batchId}`);
+	} catch (err) {
+		execLog("batch", "history", `failed to update integratedAt: ${err}`);
+	}
+}
+
 
 // ── Tier 0 Supervisor Event Logging (TP-039 Step 2) ─────────────────
 

package/extensions/taskplane/types.ts

@@ -3295,6 +3295,8 @@ export interface BatchHistorySummary {
 	tokens: TokenCounts;
 	tasks: BatchTaskSummary[];
 	waves: BatchWaveSummary[];
+	/** Timestamp (ms since epoch) when the batch was integrated. Set by orch-integrate. */
+	integratedAt?: number;
 }
 
 /** Max number of batch history entries to retain. */

package/package.json

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