taskplane 0.29.2 → 0.30.1

package/dashboard/public/app.js

@@ -382,6 +382,53 @@ function taskSegmentProgress(task, segmentStatusMap, forcedActiveSegmentId) {
   };
 }
 
+// TP-197 (#464): Render a horizontal pill row of per-segment status badges for a
+// multi-segment task. Each pill shows an icon + repoId for one segment. The icon
+// reflects the segment's status (succeeded / running / pending / failed / stalled /
+// skipped). The current segment (the one actively executing on its lane) gets an
+// emphasis class. Returns "" for single-segment tasks so the rendered DOM is
+// byte-identical to today for the non-segmented common case (no regression).
+//
+// Consumes:
+//   - task.segmentIds: string[] (ordered, from PersistedTaskRecord)
+//   - segmentStatusMap: Map<segmentId, PersistedSegmentStatus> built by
+//     buildSegmentStatusMap() from batch.segments[]
+//   - activeSegmentId: string|null — current executing segment (from V2 lane
+//     snapshot's segmentId, or the task's activeSegmentId field)
+function taskSegmentPillRow(task, segmentStatusMap, activeSegmentId) {
+  const segmentIds = Array.isArray(task?.segmentIds)
+    ? task.segmentIds.filter(id => typeof id === "string")
+    : [];
+  if (segmentIds.length <= 1) return "";
+
+  // Status -> { icon, className } table. Keep emoji simple/monospace-friendly.
+  // ✅ succeeded, ⏳ running, ⬚ pending, ❌ failed, ⏸ stalled, ↷ skipped.
+  const styles = {
+    succeeded: { icon: "\u2705", cls: "seg-succeeded" },
+    running:   { icon: "\u23F3", cls: "seg-running" },
+    pending:   { icon: "\u2B1A", cls: "seg-pending" },
+    failed:    { icon: "\u274C", cls: "seg-failed" },
+    stalled:   { icon: "\u23F8", cls: "seg-stalled" },
+    skipped:   { icon: "\u21B7", cls: "seg-skipped" },
+  };
+
+  const pills = segmentIds.map((segId) => {
+    const status = segmentStatusMap.get(segId) || "pending";
+    const style = styles[status] || styles.pending;
+    const parsed = parseSegmentId(segId);
+    const repoLabel = parsed?.repoId || segId;
+    const isCurrent = activeSegmentId && segId === activeSegmentId;
+    const currentCls = isCurrent ? " seg-pill-current" : "";
+    const title = `${segId} \u00b7 ${status}`;
+    return `<span class="seg-pill ${style.cls}${currentCls}" title="${escapeHtml(title)}">`
+      + `<span class="seg-pill-icon">${style.icon}</span>`
+      + `<span class="seg-pill-label">${escapeHtml(repoLabel)}</span>`
+      + `</span>`;
+  }).join("");
+
+  return `<div class="task-segment-row">${pills}</div>`;
+}
+
 function laneActiveSegmentInfo(v2snap, laneTasks, segmentStatusMap) {
   if (!v2snap || !v2snap.segmentId) return null;
   const parsed = parseSegmentId(v2snap.segmentId);
@@ -620,7 +667,13 @@ function renderSummary(batch) {
       // their assigned lane: tasks on the same lane render with `→` (serial),
       // tasks on different lanes render with ` | ` (parallel). Tooltip shows
       // the expanded lane breakdown.
-      const { compact, tooltip } = formatWaveLaneBreakdown(taskIds, batch.lanes || [], i + 1);
+      // TP-197 post-merge fold: pass `batch.tasks` as the task→lane source.
+      // The previous arg `batch.lanes` only carries live Runtime V2 lane
+      // state for the *currently active* wave — past/future wave chips
+      // would fall back to comma-separated. `batch.tasks[].laneNumber` is
+      // persisted for the entire batch lifecycle, so all waves render with
+      // the correct parallelization separator regardless of active state.
+      const { compact, tooltip } = formatWaveLaneBreakdown(taskIds, batch.lanes || [], batch.tasks || [], i + 1);
       const titleAttr = tooltip ? ` title="${escapeHtml(tooltip)}"` : "";
       wavesHtml += `<span class="wave-chip ${cls}"${titleAttr}>W${i + 1} [${compact}]</span>`;
     });
@@ -648,16 +701,46 @@ function renderSummary(batch) {
  * are shown with the previous flat formatting and no tooltip is generated
  * — this preserves backward compatibility with future-wave display.
  */
-function formatWaveLaneBreakdown(taskIds, lanes, waveNumber) {
+function formatWaveLaneBreakdown(taskIds, lanes, tasks, waveNumber) {
   if (!Array.isArray(taskIds) || taskIds.length === 0) {
     return { compact: "", tooltip: "" };
   }
-  // Build taskId → laneNumber map for the lanes that have any of these tasks.
+  // Build taskId → laneNumber map. Prefer the persisted-per-task
+  // `tasks[i].laneNumber` (covers all waves, lifecycle-stable). Fall back
+  // to live `lanes[]` only when tasks data is missing or doesn't carry
+  // laneNumber for a given task.
+  //
+  // TP-197 post-merge fold: the previous implementation read ONLY from
+  // `lanes`, which is Runtime V2 live state and only populated for the
+  // currently active wave. That caused inactive waves' chips to fall back
+  // to comma-separated display (no parallelization indicator), giving the
+  // impression that the separator changed as the batch progressed. Using
+  // the persisted `tasks[].laneNumber` makes the indicator stable across
+  // all waves regardless of active state.
   const taskToLane = new Map();
+  if (Array.isArray(tasks)) {
+    for (const t of tasks) {
+      // Persistence assigns `laneNumber: 0` as a sentinel meaning
+      // "unallocated" (see persistence.ts:1378 — `lane?.laneNumber ??
+      // outcome?.laneNumber ?? 0`). Real lane numbers start at 1. We must
+      // skip 0 here so future-wave tasks (which all have the 0 sentinel
+      // until their wave starts) don't get falsely grouped under a fake
+      // "lane 0" and rendered as serial.
+      if (
+        t &&
+        t.taskId &&
+        typeof t.laneNumber === "number" &&
+        t.laneNumber >= 1 &&
+        !taskToLane.has(t.taskId)
+      ) {
+        taskToLane.set(t.taskId, t.laneNumber);
+      }
+    }
+  }
+  // Fallback: anything `tasks` didn't cover, try `lanes` (live state).
   for (const lane of lanes) {
     if (!lane || !Array.isArray(lane.taskIds)) continue;
     for (const tid of lane.taskIds) {
-      // First lane to claim a task wins (lanes shouldn't overlap, but be defensive).
       if (!taskToLane.has(tid)) taskToLane.set(tid, lane.laneNumber);
     }
   }
@@ -859,8 +942,24 @@ function renderLanesTasks(batch, sessions) {
         stepHtml = `<span style="color:var(--text-faint)">${escapeHtml(task.exitReason || "—")}</span>`;
       }
 
+      // TP-197 (#464): Compute the per-segment pill row for multi-segment tasks.
+      // Returns "" for single-segment tasks (no DOM regression for the common case).
+      // For multi-segment tasks we render the pill row in the task-row's grid row 3
+      // (via .task-segment-row CSS) and suppress the inline "Segment N/T: repo" text
+      // in detailBits to avoid duplicating signal — the pill row already shows the
+      // current segment (via seg-pill-current) and total count (via pill count).
+      const segmentPillRowHtml = taskSegmentPillRow(
+        task,
+        segmentStatusMap,
+        v2snap && v2snap.taskId === task.taskId ? v2snap.segmentId : (segmentInfo?.segmentId || null),
+      );
+      const hasSegmentPillRow = segmentPillRowHtml !== "";
+
       const detailBits = [];
-      if (segmentInfo) {
+      if (segmentInfo && !hasSegmentPillRow) {
+        // Single-segment + non-segmented tasks: existing inline text (unchanged).
+        // Multi-segment tasks: suppressed because the new pill row carries the same
+        // information more legibly.
         detailBits.push(`<span class="task-segment-progress" title="${escapeHtml(segmentInfo.segmentId || segmentProgressText(segmentInfo))}">${escapeHtml(segmentProgressText(segmentInfo))}</span>`);
       }
       if (showPacketHome) {
@@ -950,8 +1049,17 @@ function renderLanesTasks(batch, sessions) {
       const titleHtml = task.taskTitle
         ? `<div class="task-title-subtitle">${escapeHtml(task.taskTitle)}</div>`
         : "";
+      // TP-197 (#464): segmentPillRowHtml is empty for single-segment tasks so
+      // the rendered DOM is byte-identical to today for non-segmented tasks.
+      // For multi-segment tasks it renders as grid-row 3 of .task-row.
+      // Sage post-merge fold: the .has-segments class opts the .task-row
+      // grid into a 3-row template only when we actually have a pill row;
+      // otherwise the default 2-row template preserves single-segment task
+      // spacing exactly (an unconditional 3-row template would add an 8px
+      // row-gap even when row 3 is empty, breaking the no-regression contract).
+      const taskRowClass = hasSegmentPillRow ? "task-row has-segments" : "task-row";
       html += `
-        <div class="task-row">
+        <div class="${taskRowClass}">
           <span class="task-icon"><span class="status-dot ${task.status}"></span></span>
           <span class="task-actions">${eyeHtml}</span>
           <span class="task-id status-${task.status}">${escapeHtml(task.taskId)}${showRepos ? repoBadgeHtml(tRepo, "repo-badge-task") : ""}</span>
@@ -960,6 +1068,7 @@ function renderLanesTasks(batch, sessions) {
           <span>${progressHtml}</span>
           <span class="task-step">${stepHtml}${workerHtml}</span>
           ${titleHtml}
+          ${segmentPillRowHtml}
         </div>`;
       html += reviewerRowHtml;
     }
@@ -1054,7 +1163,15 @@ function renderMergeAgents(batch, sessions) {
   }
 
   let html = '<table class="merge-table"><thead><tr>';
-  html += '<th>Wave</th><th>Status</th><th>Session</th><th>Telemetry</th><th>Session ID</th><th>Details</th>';
+  // TP-197 post-merge fold: removed 'Session ID' and 'Details' columns.
+  // SESSION ID was hardcoded to '—' in every row — dead weight.
+  // DETAILS only populated for `mr.failureReason` (rare failure cases);
+  // for the common all-merges-succeeded case it's always '—' too.
+  // When a real failure happens, the operator sees status='failed' in
+  // the Status column and can dig into engine logs for the reason —
+  // we'll re-add a focused DETAILS column if/when we have meaningful
+  // structured failure-reason data to surface in the dashboard table.
+  html += '<th>Wave</th><th>Status</th><th>Session</th><th>Telemetry</th>';
   html += '</tr></thead><tbody>';
 
   // Track sessions shown in wave result rows so we don't duplicate them below
@@ -1135,10 +1252,6 @@ function renderMergeAgents(batch, sessions) {
     html += `<td class="merge-session-cell">${effectiveAlive ? escapeHtml(effectiveSession) : "—"}</td>`;
     // Full telemetry cell
     html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(mergeTel, effectiveAlive)}</td>`;
-    html += `<td>`;
-    html += '<span class="merge-no-data">—</span>';
-    html += `</td>`;
-    html += `<td class="merge-detail-cell">${mr.failureReason ? escapeHtml(mr.failureReason) : "—"}</td>`;
     html += `</tr>`;
 
     // Per-repo sub-rows: show when workspace mode has repo results
@@ -1159,8 +1272,6 @@ function renderMergeAgents(batch, sessions) {
         html += `<td><span class="status-badge ${rrStatusCls}">${rr.status}</span></td>`;
         html += `<td class="merge-session-cell">${rrLanes}</td>`;
         html += `<td></td>`; /* telemetry placeholder */
-        html += `<td></td>`; /* attach placeholder */
-        html += `<td class="merge-detail-cell">${rrDetail}</td>`;
         html += `</tr>`;
       }
     }
@@ -1177,8 +1288,6 @@ function renderMergeAgents(batch, sessions) {
     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>—</td>`;
-    html += `<td>—</td>`;
     html += `</tr>`;
   }
 

package/dashboard/public/style.css

@@ -608,7 +608,13 @@ body {
   display: grid;
   grid-template-columns: 36px 24px 100px 90px 80px 200px 1fr;
   /* #485 (revised): row 1 holds the primary cells; row 2 (auto, collapses to
-   * 0 when empty) holds the optional task-title-subtitle spanning cols 3–6. */
+   * 0 when empty) holds the optional task-title-subtitle spanning cols 3–6.
+   * Default: 2 rows. TP-197 (#464) adds the optional per-segment pill row in
+   * grid-row 3 ONLY when the .has-segments class is set (multi-segment tasks).
+   * Non-segmented tasks keep the pre-TP-197 2-row layout exactly — 'auto'
+   * row tracks don't fully collapse with row-gap declared, so adding a third
+   * row track unconditionally would introduce an 8px visible gap for every
+   * single-segment task (sage post-merge fold). */
   grid-template-rows: auto auto;
   align-items: center;
   gap: 8px 8px;
@@ -617,6 +623,13 @@ body {
   transition: background 0.15s;
 }
 
+/* TP-197 (#464): multi-segment tasks opt-in to a 3-row grid for the segment-
+ * pill row. JS adds .has-segments to .task-row only when the pill row is
+ * non-empty (see app.js taskSegmentPillRow + task-row template). */
+.task-row.has-segments {
+  grid-template-rows: auto auto auto;
+}
+
 .task-row:last-child { border-bottom: none; }
 .task-row:hover { background: var(--bg-surface-hover); }
 
@@ -652,6 +665,71 @@ body {
   margin-top: -2px;
 }
 
+/* ─── TP-197 (#464): Per-segment pill row for multi-segment tasks ─────── */
+
+.task-segment-row {
+  /* Sub-row beneath the primary task row, mirroring the title-subtitle pattern
+   * (TP-485). Spans cols 3 → 7 so it shares the title area's horizontal space.
+   * Placed at grid row 3 so it sits *below* the optional title-subtitle.
+   * Container collapses to 0 height when not rendered (single-segment tasks),
+   * so non-segmented tasks render with identical row height to today.
+   * Lives OUTSIDE .task-step intentionally so the @media (max-width: 900px)
+   * rule that hides .task-step does NOT hide the pill row — keeps segment
+   * context visible at narrow viewports. */
+  grid-column: 3 / 7;
+  grid-row: 3;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 4px;
+  margin-top: 2px;
+  min-width: 0;
+}
+
+.seg-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+  font-family: var(--font-mono);
+  font-size: 0.68rem;
+  font-weight: 500;
+  line-height: 1.4;
+  padding: 1px 7px;
+  border-radius: 8px;
+  border: 1px solid transparent;
+  max-width: 140px;
+  white-space: nowrap;
+}
+
+.seg-pill .seg-pill-icon {
+  font-size: 0.72rem;
+  line-height: 1;
+  flex-shrink: 0;
+}
+
+.seg-pill .seg-pill-label {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  min-width: 0;
+}
+
+/* Status variants — reuse the existing status-badge color tokens for
+ * consistency with .status-badge.status-{succeeded,running,failed,…}. */
+.seg-pill.seg-succeeded { background: var(--badge-succeeded-bg); color: var(--green); }
+.seg-pill.seg-running   { background: var(--badge-running-bg);   color: var(--accent); }
+.seg-pill.seg-pending   { background: var(--bg-surface);         color: var(--text-muted); border-color: var(--border-default, var(--border-subtle)); }
+.seg-pill.seg-failed    { background: var(--badge-failed-bg);    color: var(--red); }
+.seg-pill.seg-stalled   { background: var(--badge-failed-bg);    color: var(--yellow, var(--red)); opacity: 0.85; }
+.seg-pill.seg-skipped   { background: var(--bg-surface);         color: var(--text-muted); opacity: 0.7; }
+
+/* Current-segment emphasis: brighter border + slight weight bump so operator
+ * can spot "we're here right now" at a glance independent of icon. */
+.seg-pill.seg-pill-current {
+  border-color: var(--accent);
+  font-weight: 600;
+  box-shadow: 0 0 0 1px var(--accent-dim, transparent);
+}
+
 .task-duration {
   font-family: var(--font-mono);
   font-size: 0.8rem;
@@ -783,7 +861,10 @@ body {
   font-weight: 600;
   text-transform: uppercase;
   letter-spacing: 0.05em;
-  color: var(--text-faint);
+  /* TP-197 post-merge fold: bumped --text-faint → --text-muted for
+   * readability. Matches other dashboard section headers (lines 224, 248,
+   * 458 of this file already use --text-muted for the same role). */
+  color: var(--text-muted);
   border-bottom: 1px solid var(--border);
   background: var(--bg-surface);
 }

package/extensions/reviewer-extension.ts

@@ -48,7 +48,8 @@ export default function reviewerExtension(pi: ExtensionAPI) {
 			"Block until the next review request is available, then return its content. " +
 			"Call this after completing each review to wait for the next one. " +
 			"Returns 'SHUTDOWN' when the task is complete and you should exit.",
-		promptSnippet: "wait_for_review() — block until the next review request arrives (persistent reviewer mode)",
+		promptSnippet:
+			"wait_for_review() — block until the next review request arrives (persistent reviewer mode)",
 		promptGuidelines: [
 			"Call wait_for_review() to receive each review request.",
 			"After writing your review to the specified output file, call wait_for_review() again.",
@@ -82,11 +83,14 @@ export default function reviewerExtension(pi: ExtensionAPI) {
 					if (!existsSync(requestPath)) {
 						// Signal fired but request file doesn't exist (race condition or error)
 						return {
-							content: [{
-								type: "text" as const,
-								text: `ERROR — Signal file ${REVIEWER_SIGNAL_PREFIX}${signalNum} found but ` +
-									`${signalContent} does not exist. Waiting for next signal.`,
-							}],
+							content: [
+								{
+									type: "text" as const,
+									text:
+										`ERROR — Signal file ${REVIEWER_SIGNAL_PREFIX}${signalNum} found but ` +
+										`${signalContent} does not exist. Waiting for next signal.`,
+								},
+							],
 							details: undefined,
 						};
 					}
@@ -103,16 +107,18 @@ export default function reviewerExtension(pi: ExtensionAPI) {
 				// Check timeout
 				if (Date.now() - startTime > REVIEWER_WAIT_TIMEOUT_MS) {
 					return {
-						content: [{
-							type: "text" as const,
-							text: "TIMEOUT — No review request received within the timeout period. Exit cleanly.",
-						}],
+						content: [
+							{
+								type: "text" as const,
+								text: "TIMEOUT — No review request received within the timeout period. Exit cleanly.",
+							},
+						],
 						details: undefined,
 					};
 				}
 
 				// Wait before next poll
-				await new Promise(resolve => setTimeout(resolve, REVIEWER_POLL_INTERVAL_MS));
+				await new Promise((resolve) => setTimeout(resolve, REVIEWER_POLL_INTERVAL_MS));
 			}
 		},
 	});

package/extensions/taskplane/abort.ts

@@ -8,7 +8,18 @@ import { join } from "path";
 import { execLog, killV2LaneAgents, resolveCanonicalTaskPaths } from "./execution.ts";
 import { killMergeAgentV2, killAllMergeAgentsV2 } from "./merge.ts";
 import { deleteBatchState, persistRuntimeState } from "./persistence.ts";
-import type { AbortActionStep, AbortErrorCode, AbortLaneResult, AbortMode, AbortResult, AbortTargetSession, AllocatedLane, OrchBatchRuntimeState, PersistedBatchState, PersistedLaneRecord } from "./types.ts";
+import type {
+	AbortActionStep,
+	AbortErrorCode,
+	AbortLaneResult,
+	AbortMode,
+	AbortResult,
+	AbortTargetSession,
+	AllocatedLane,
+	OrchBatchRuntimeState,
+	PersistedBatchState,
+	PersistedLaneRecord,
+} from "./types.ts";
 
 // ── Abort Pure Functions ─────────────────────────────────────────────
 
@@ -37,7 +48,7 @@ export function selectAbortTargetSessions(
 	// Filter to only lane and merge sessions for the exact orchestrator prefix.
 	// Handles both repo-mode (`<prefix>-lane-<N>`) and workspace-mode
 	// (`<prefix>-<repoId>-lane-<N>`) session name formats.
-	const targetNames = allSessionNames.filter(name => {
+	const targetNames = allSessionNames.filter((name) => {
 		const prefixWithDash = `${prefix}-`;
 		if (!name.startsWith(prefixWithDash)) return false;
 		const suffix = name.slice(prefixWithDash.length);
@@ -78,7 +89,10 @@ export function selectAbortTargetSessions(
 	}
 
 	// Build lookup from runtime lanes
-	const runtimeLookup = new Map<string, { laneId: string; taskId: string | null; worktreePath: string; taskFolder: string | null }>();
+	const runtimeLookup = new Map<
+		string,
+		{ laneId: string; taskId: string | null; worktreePath: string; taskFolder: string | null }
+	>();
 	for (const lane of runtimeLanes) {
 		const currentTask = lane.tasks.length > 0 ? lane.tasks[0] : null;
 		runtimeLookup.set(lane.laneSessionId, {
@@ -90,7 +104,7 @@ export function selectAbortTargetSessions(
 		});
 	}
 
-	return targetNames.map(sessionName => {
+	return targetNames.map((sessionName) => {
 		const runtime = runtimeLookup.get(sessionName);
 		const persisted = persistedLookup.get(sessionName);
 
@@ -184,7 +198,6 @@ export function discoverAbortSessionNames(
 	return [...names];
 }
 
-
 // ── Abort Orchestration Functions ────────────────────────────────────
 
 /**
@@ -207,10 +220,18 @@ export function writeWrapUpFiles(
 		if (!target.taskFolderInWorktree) {
 			// Skip child sessions (workers, reviewers) — only main lane sessions have task folders
 			// Also skip merge sessions (no task folder)
-			if (target.sessionName.endsWith("-worker") || target.sessionName.endsWith("-reviewer") || target.sessionName.includes("merge")) {
+			if (
+				target.sessionName.endsWith("-worker") ||
+				target.sessionName.endsWith("-reviewer") ||
+				target.sessionName.includes("merge")
+			) {
 				results.push({ sessionName: target.sessionName, written: false, error: null });
 			} else {
-				results.push({ sessionName: target.sessionName, written: false, error: "No task folder resolved" });
+				results.push({
+					sessionName: target.sessionName,
+					written: false,
+					error: "No task folder resolved",
+				});
 			}
 			continue;
 		}
@@ -220,7 +241,11 @@ export function writeWrapUpFiles(
 
 			// Ensure directory exists
 			if (!existsSync(target.taskFolderInWorktree)) {
-				results.push({ sessionName: target.sessionName, written: false, error: `Task folder does not exist: ${target.taskFolderInWorktree}` });
+				results.push({
+					sessionName: target.sessionName,
+					written: false,
+					error: `Task folder does not exist: ${target.taskFolderInWorktree}`,
+				});
 				continue;
 			}
 
@@ -262,7 +287,7 @@ export async function waitForSessionExit(
 	const deadline = Date.now() + gracePeriodMs;
 	while (Date.now() < deadline) {
 		const sleepMs = Math.max(1, Math.min(pollIntervalMs, deadline - Date.now()));
-		await new Promise(r => setTimeout(r, sleepMs));
+		await new Promise((r) => setTimeout(r, sleepMs));
 	}
 
 	return { exited: [], remaining: [...sessionNames] };
@@ -357,7 +382,11 @@ export async function executeAbort(
 			repoRoot,
 		);
 	} catch (err) {
-		execLog("abort", batchState.batchId, `Failed to persist state during abort: ${err instanceof Error ? err.message : String(err)}`);
+		execLog(
+			"abort",
+			batchState.batchId,
+			`Failed to persist state during abort: ${err instanceof Error ? err.message : String(err)}`,
+		);
 	}
 
 	// TP-108: Kill all V2 merge agents (process-owned, not TMUX)
@@ -370,7 +399,11 @@ export async function executeAbort(
 	// Step 3: Discover target sessions from Runtime V2 state sources.
 	const allSessionNames = discoverAbortSessionNames(prefix, persistedState, batchState.currentLanes);
 	if (allSessionNames.length === 0) {
-		execLog("abort", batchState.batchId, `No abort targets discovered for prefix "${prefix}" from runtime/persisted state.`);
+		execLog(
+			"abort",
+			batchState.batchId,
+			`No abort targets discovered for prefix "${prefix}" from runtime/persisted state.`,
+		);
 	}
 
 	// Step 4: Select and enrich target sessions
@@ -400,7 +433,7 @@ export async function executeAbort(
 		}
 
 		// Step 5b: Wait for sessions to exit
-		const allTargetNames = targets.map(t => t.sessionName);
+		const allTargetNames = targets.map((t) => t.sessionName);
 		const waitResult = await waitForSessionExit(allTargetNames, gracePeriodMs, pollIntervalMs);
 		gracefulExits = waitResult.exited.length;
 
@@ -414,7 +447,7 @@ export async function executeAbort(
 			for (const kr of killResults) {
 				killResultBySession.set(kr.sessionName, { killed: kr.killed, error: kr.error });
 			}
-			const killFailures = killResults.filter(kr => !kr.killed);
+			const killFailures = killResults.filter((kr) => !kr.killed);
 			if (killFailures.length > 0) {
 				errors.push({
 					code: "ABORT_KILL_FAILED",
@@ -426,7 +459,7 @@ export async function executeAbort(
 		// Build lane results
 		const exitedSet = new Set(waitResult.exited);
 		for (const target of targets) {
-			const wrapUp = wrapUpResults.find(wr => wr.sessionName === target.sessionName);
+			const wrapUp = wrapUpResults.find((wr) => wr.sessionName === target.sessionName);
 			const wasGraceful = exitedSet.has(target.sessionName);
 			const killResult = killResultBySession.get(target.sessionName);
 			const sessionKilled = wasGraceful || killResult?.killed === true;
@@ -443,7 +476,7 @@ export async function executeAbort(
 		}
 	} else {
 		// Hard mode: kill all immediately
-		const allTargetNames = targets.map(t => t.sessionName);
+		const allTargetNames = targets.map((t) => t.sessionName);
 		const killResults = killOrchSessions(allTargetNames, {
 			stateRoot: repoRoot,
 			batchId: batchState.batchId,
@@ -452,7 +485,7 @@ export async function executeAbort(
 		for (const kr of killResults) {
 			killResultBySession.set(kr.sessionName, { killed: kr.killed, error: kr.error });
 		}
-		const killFailures = killResults.filter(kr => !kr.killed);
+		const killFailures = killResults.filter((kr) => !kr.killed);
 		if (killFailures.length > 0) {
 			errors.push({
 				code: "ABORT_KILL_FAILED",
@@ -490,7 +523,7 @@ export async function executeAbort(
 	return {
 		mode,
 		sessionsFound: targets.length,
-		sessionsKilled: laneResults.filter(lr => lr.sessionKilled).length,
+		sessionsKilled: laneResults.filter((lr) => lr.sessionKilled).length,
 		gracefulExits,
 		laneResults,
 		wrapUpFailures,
@@ -499,4 +532,3 @@ export async function executeAbort(
 		durationMs: Date.now() - startTime,
 	};
 }
-