taskplane 0.24.7 → 0.24.9

package/extensions/taskplane/resume.ts

@@ -34,12 +34,12 @@ function terminateAliveV2Agents(stateRoot: string, batchId: string, sessionName:
 }
 import { getCurrentBranch, runGit } from "./git.ts";
 import { mergeWaveByRepo } from "./merge.ts";
-import { applyMergeRetryLoop, computeCleanupGatePolicy, computeMergeFailurePolicy, formatRepoMergeSummary, ORCH_MESSAGES } from "./messages.ts";
+import { applyMergeRetryLoop, computeCleanupGatePolicy, computeMergeFailurePolicy, extractFailedRepoId, formatRepoMergeSummary, ORCH_MESSAGES } from "./messages.ts";
 import type { CleanupGateRepoFailure } from "./messages.ts";
 import { resolveOperatorId } from "./naming.ts";
 import { applyPartialProgressToOutcomes, deleteBatchState, hasTaskDoneMarker, loadBatchState, persistRuntimeState, seedPendingOutcomesForAllocatedLanes, syncTaskOutcomesFromMonitor, upsertTaskOutcome } from "./persistence.ts";
-import { buildBatchProgressSnapshot, defaultResilienceState, StateFileError } from "./types.ts";
-import type { AllocatedLane, AllocatedTask, LaneExecutionResult, LaneTaskOutcome, LaneTaskStatus, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, ParsedTask, PersistedBatchState, PersistedLaneRecord, ReconciledTaskState, ResumeEligibility, ResumePoint, TaskRunnerConfig, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
+import { buildBatchProgressSnapshot, buildSupervisorSegmentFrontierSnapshot, defaultResilienceState, StateFileError } from "./types.ts";
+import type { AllocatedLane, AllocatedTask, LaneExecutionResult, LaneTaskOutcome, LaneTaskStatus, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, ParsedTask, PersistedBatchState, PersistedLaneRecord, PersistedSegmentRecord, ReconciledTaskState, ResumeEligibility, ResumePoint, TaskRunnerConfig, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
 import { buildDependencyGraph, resolveBaseBranch, resolveRepoRoot } from "./waves.ts";
 import { deleteBranchBestEffort, forceCleanupWorktree, listWorktrees, preserveFailedLaneProgress, removeAllWorktrees, removeWorktree, safeResetWorktree, sleepSync } from "./worktree.ts";
 
@@ -161,6 +161,18 @@ export function reconstructAllocatedLanes(
 			if (persistedTask?.taskFolder) {
 				taskStub.taskFolder = persistedTask.taskFolder;
 			}
+			if ((persistedTask as any)?.packetRepoId !== undefined) {
+				(taskStub as any).packetRepoId = (persistedTask as any).packetRepoId;
+			}
+			if ((persistedTask as any)?.packetTaskPath !== undefined) {
+				(taskStub as any).packetTaskPath = (persistedTask as any).packetTaskPath;
+			}
+			if ((persistedTask as any)?.segmentIds !== undefined) {
+				(taskStub as any).segmentIds = (persistedTask as any).segmentIds;
+			}
+			if ((persistedTask as any)?.activeSegmentId !== undefined) {
+				(taskStub as any).activeSegmentId = (persistedTask as any).activeSegmentId;
+			}
 			return {
 				taskId,
 				order: 0,
@@ -211,6 +223,39 @@ export function collectAllRepoRoots(
 
 // ── Resume Pure Functions ────────────────────────────────────────────
 
+/**
+ * Collect task IDs with authoritative .DONE markers.
+ *
+ * Segment frontier state does not suppress .DONE authority. If a marker exists,
+ * resume reconciliation will mark the task complete regardless of segment state.
+ */
+export function collectDoneTaskIdsForResume(
+	persistedState: PersistedBatchState,
+	repoRoot: string,
+	workspaceConfig?: WorkspaceConfig | null,
+): Set<string> {
+	const doneTaskIds = new Set<string>();
+	for (const task of persistedState.tasks) {
+		if (task.taskFolder && hasTaskDoneMarker(task.taskFolder)) {
+			doneTaskIds.add(task.taskId);
+			continue;
+		}
+		const laneRec = persistedState.lanes.find(l => l.taskIds.includes(task.taskId));
+		if (laneRec?.worktreePath && task.taskFolder) {
+			const resolved = resolveCanonicalTaskPaths(
+				task.taskFolder,
+				laneRec.worktreePath,
+				repoRoot,
+				!!workspaceConfig,
+			);
+			if (existsSync(resolved.donePath)) {
+				doneTaskIds.add(task.taskId);
+			}
+		}
+	}
+	return doneTaskIds;
+}
+
 /**
  * Check whether a persisted batch state is eligible for resume.
  *
@@ -333,6 +378,126 @@ export function checkResumeEligibility(state: PersistedBatchState, force: boolea
 	}
 }
 
+interface SegmentFrontierResumeTaskState {
+	taskId: string;
+	completedSegmentIds: string[];
+	inFlightSegmentIds: string[];
+	pendingSegmentIds: string[];
+	failedSegmentIds: string[];
+	nextSegmentId: string | null;
+	allSucceeded: boolean;
+	dependencyBySegmentId: Map<string, string[]>;
+}
+
+function classifySegmentStatus(status: PersistedSegmentRecord["status"] | undefined): "completed" | "failed" | "in-flight" | "pending" {
+	if (status === "succeeded" || status === "skipped") return "completed";
+	if (status === "failed" || status === "stalled") return "failed";
+	if (status === "running") return "in-flight";
+	return "pending";
+}
+
+/**
+ * Reconstruct per-task segment frontier from persisted segment records.
+ *
+ * Mutates persisted task records in-place to reflect the segment frontier:
+ * - sets `activeSegmentId` to running or next pending segment
+ * - normalizes task `status` to pending/running/terminal based on segments
+ */
+export function reconstructSegmentFrontier(
+	persistedState: PersistedBatchState,
+): Map<string, SegmentFrontierResumeTaskState> {
+	const byTask = new Map<string, SegmentFrontierResumeTaskState>();
+	const segmentRecordById = new Map<string, PersistedSegmentRecord>();
+	for (const segment of persistedState.segments ?? []) {
+		segmentRecordById.set(segment.segmentId, segment);
+	}
+
+	for (const task of persistedState.tasks) {
+		const segmentIds = task.segmentIds ?? [];
+		if (segmentIds.length === 0) continue;
+
+		const dependencyBySegmentId = new Map<string, string[]>();
+		const completedSegmentIds: string[] = [];
+		const inFlightSegmentIds: string[] = [];
+		const pendingSegmentIds: string[] = [];
+		const failedSegmentIds: string[] = [];
+		let hasConcreteSegmentRecord = false;
+
+		for (let idx = 0; idx < segmentIds.length; idx++) {
+			const segmentId = segmentIds[idx];
+			const record = segmentRecordById.get(segmentId);
+			if (record) hasConcreteSegmentRecord = true;
+			const recordDeps = record?.dependsOnSegmentIds ?? [];
+			const fallbackDeps = idx > 0 ? [segmentIds[idx - 1]] : [];
+			const deps = (recordDeps.length > 0 ? recordDeps : fallbackDeps)
+				.filter(dep => segmentIds.includes(dep));
+			dependencyBySegmentId.set(segmentId, [...new Set(deps)].sort((a, b) => a.localeCompare(b)));
+
+			switch (classifySegmentStatus(record?.status)) {
+				case "completed":
+					completedSegmentIds.push(segmentId);
+					break;
+				case "in-flight":
+					inFlightSegmentIds.push(segmentId);
+					break;
+				case "failed":
+					failedSegmentIds.push(segmentId);
+					break;
+				default:
+					pendingSegmentIds.push(segmentId);
+					break;
+			}
+		}
+
+		const completedSet = new Set(completedSegmentIds);
+		const readyPending = pendingSegmentIds.filter((segmentId) => {
+			const deps = dependencyBySegmentId.get(segmentId) ?? [];
+			return deps.every(dep => completedSet.has(dep));
+		});
+
+		const nextSegmentId = inFlightSegmentIds[0]
+			?? readyPending[0]
+			?? pendingSegmentIds[0]
+			?? null;
+		const allSucceeded = segmentIds.every((segmentId) => {
+			const status = segmentRecordById.get(segmentId)?.status;
+			return status === "succeeded";
+		});
+
+		if (hasConcreteSegmentRecord) {
+			if (failedSegmentIds.length > 0) {
+				task.status = task.status === "skipped" ? "skipped" : "failed";
+				task.activeSegmentId = null;
+			} else if (inFlightSegmentIds.length > 0) {
+				task.status = "running";
+				task.activeSegmentId = inFlightSegmentIds[0];
+			} else if (pendingSegmentIds.length > 0) {
+				task.status = "pending";
+				task.activeSegmentId = nextSegmentId;
+			} else if (allSucceeded) {
+				task.status = "succeeded";
+				task.activeSegmentId = null;
+			} else {
+				task.status = task.status === "skipped" ? "skipped" : "failed";
+				task.activeSegmentId = null;
+			}
+		}
+
+		byTask.set(task.taskId, {
+			taskId: task.taskId,
+			completedSegmentIds,
+			inFlightSegmentIds,
+			pendingSegmentIds,
+			failedSegmentIds,
+			nextSegmentId,
+			allSucceeded,
+			dependencyBySegmentId,
+		});
+	}
+
+	return byTask;
+}
+
 /**
  * Reconcile persisted task states against live signals.
  *
@@ -504,6 +669,33 @@ export function computeResumePoint(
 		reconciledMap.set(task.taskId, task);
 	}
 
+	const segmentStatusBySegmentId = new Map<string, PersistedSegmentRecord["status"]>();
+	for (const segment of persistedState.segments ?? []) {
+		segmentStatusBySegmentId.set(segment.segmentId, segment.status);
+	}
+	const persistedTasks = Array.isArray((persistedState as { tasks?: unknown }).tasks)
+		? persistedState.tasks
+		: [];
+	const segmentIdsByTaskId = new Map<string, string[]>();
+	for (const task of persistedTasks) {
+		if (task.segmentIds && task.segmentIds.length > 0) {
+			segmentIdsByTaskId.set(task.taskId, task.segmentIds);
+		}
+	}
+	const waveSegmentIdByTaskOccurrence = new Map<string, string>();
+	const occurrenceByTaskId = new Map<string, number>();
+	for (let waveIdx = 0; waveIdx < persistedState.wavePlan.length; waveIdx++) {
+		for (const taskId of persistedState.wavePlan[waveIdx]) {
+			const segmentIds = segmentIdsByTaskId.get(taskId);
+			if (!segmentIds || segmentIds.length === 0) continue;
+			const occurrence = occurrenceByTaskId.get(taskId) ?? 0;
+			if (occurrence < segmentIds.length) {
+				waveSegmentIdByTaskOccurrence.set(`${waveIdx}:${taskId}`, segmentIds[occurrence]);
+			}
+			occurrenceByTaskId.set(taskId, occurrence + 1);
+		}
+	}
+
 	// Categorize tasks
 	const completedTaskIds: string[] = [];
 	const pendingTaskIds: string[] = [];
@@ -551,6 +743,14 @@ export function computeResumePoint(
 	for (let i = 0; i < persistedState.wavePlan.length; i++) {
 		const waveTasks = persistedState.wavePlan[i];
 		const allDone = waveTasks.every((taskId) => {
+			const waveSegmentId = waveSegmentIdByTaskOccurrence.get(`${i}:${taskId}`);
+			if (waveSegmentId && segmentStatusBySegmentId.has(waveSegmentId)) {
+				const segmentStatus = segmentStatusBySegmentId.get(waveSegmentId)!;
+				return segmentStatus === "succeeded"
+					|| segmentStatus === "failed"
+					|| segmentStatus === "stalled"
+					|| segmentStatus === "skipped";
+			}
 			const reconciled = reconciledMap.get(taskId);
 			if (!reconciled) return false;
 			// A task is "done" for wave-skip purposes if it's terminal:
@@ -579,6 +779,10 @@ export function computeResumePoint(
 		// Only check merge status if the wave had any succeeded tasks (waves with
 		// only failures/skips don't produce merges and can be safely skipped).
 		const hasSucceededTasks = waveTasks.some((taskId) => {
+			const waveSegmentId = waveSegmentIdByTaskOccurrence.get(`${i}:${taskId}`);
+			if (waveSegmentId && segmentStatusBySegmentId.has(waveSegmentId)) {
+				return segmentStatusBySegmentId.get(waveSegmentId) === "succeeded";
+			}
 			const reconciled = reconciledMap.get(taskId);
 			if (!reconciled) return false;
 			if (reconciled.action === "mark-complete") return true;
@@ -603,6 +807,15 @@ export function computeResumePoint(
 	const actualPendingTaskIds: string[] = [];
 	for (let i = resumeWaveIndex; i < persistedState.wavePlan.length; i++) {
 		for (const taskId of persistedState.wavePlan[i]) {
+			const waveSegmentId = waveSegmentIdByTaskOccurrence.get(`${i}:${taskId}`);
+			if (waveSegmentId && segmentStatusBySegmentId.has(waveSegmentId)) {
+				const segmentStatus = segmentStatusBySegmentId.get(waveSegmentId)!;
+				if (segmentStatus === "running" || segmentStatus === "pending") {
+					actualPendingTaskIds.push(taskId);
+				}
+				continue;
+			}
+
 			const reconciled = reconciledMap.get(taskId);
 			if (!reconciled) {
 				actualPendingTaskIds.push(taskId); // Unknown task — treat as pending
@@ -872,6 +1085,24 @@ export async function resumeOrchBatch(
 		"info",
 	);
 
+	const segmentFrontierByTask = reconstructSegmentFrontier(persistedState);
+	if (segmentFrontierByTask.size > 0) {
+		let completedSegments = 0;
+		let inFlightSegments = 0;
+		let pendingSegments = 0;
+		for (const frontier of segmentFrontierByTask.values()) {
+			completedSegments += frontier.completedSegmentIds.length;
+			inFlightSegments += frontier.inFlightSegmentIds.length;
+			pendingSegments += frontier.pendingSegmentIds.length;
+		}
+		execLog("resume", persistedState.batchId, `segment frontier reconstructed`, {
+			tasks: segmentFrontierByTask.size,
+			completedSegments,
+			inFlightSegments,
+			pendingSegments,
+		});
+	}
+
 	// TP-108/112: Runtime V2 backend selection for resumed batches.
 	// MUST be computed before any backend-aware branch (section 3+).
 	const resumeBackend: RuntimeBackend = selectRuntimeBackend(
@@ -903,27 +1134,7 @@ export async function resumeOrchBatch(
 	// TP-109: In workspace mode or V2 execution, .DONE is written in the worktree
 	// at the resolved packet path, not the original discovery path. Resume must
 	// check both locations for authoritative completion detection.
-	const doneTaskIds = new Set<string>();
-	for (const task of persistedState.tasks) {
-		// Check original task folder path
-		if (task.taskFolder && hasTaskDoneMarker(task.taskFolder)) {
-			doneTaskIds.add(task.taskId);
-			continue;
-		}
-		// Check worktree-relative path (packet-home authority)
-		const laneRec = persistedState.lanes.find(l => l.taskIds.includes(task.taskId));
-		if (laneRec?.worktreePath && task.taskFolder) {
-			const resolved = resolveCanonicalTaskPaths(
-				task.taskFolder,
-				laneRec.worktreePath,
-				repoRoot,
-				!!workspaceConfig,
-			);
-			if (existsSync(resolved.donePath)) {
-				doneTaskIds.add(task.taskId);
-			}
-		}
-	}
+	const doneTaskIds = collectDoneTaskIdsForResume(persistedState, repoRoot, workspaceConfig);
 
 	// ── 3b. Detect existing worktrees ────────────────────────────
 	const existingWorktreeTaskIds = new Set<string>();
@@ -1710,13 +1921,36 @@ export async function resumeOrchBatch(
 		for (const taskId of waveResult.failedTaskIds) {
 			const outcome = allTaskOutcomes.find(o => o.taskId === taskId);
 			const laneForTask = latestAllocatedLanes.find(l => l.tasks.some(t => t.taskId === taskId));
+			const taskRecord = batchState.tasks.find((task) => task.taskId === taskId);
 			const exitReason = outcome?.exitReason || "unknown";
 			const hasPartialProgress = (outcome?.partialProgressCommits ?? 0) > 0;
+			const segmentFrontier = buildSupervisorSegmentFrontierSnapshot(
+				taskId,
+				taskRecord?.segmentIds,
+				taskRecord?.activeSegmentId,
+				batchState.segments,
+				outcome?.segmentId,
+			);
+			const segmentId = outcome?.segmentId
+				?? taskRecord?.activeSegmentId
+				?? segmentFrontier?.activeSegmentId
+				?? undefined;
+			const repoId = segmentId
+				? (segmentFrontier?.segments.find((segment) => segment.segmentId === segmentId)?.repoId ?? laneForTask?.repoId)
+				: laneForTask?.repoId;
+			const segmentSummary = segmentId
+				? `  Segment: ${segmentId}${repoId ? ` (repo: ${repoId})` : ""}\n`
+				: "";
+			const frontierSummary = segmentFrontier
+				? `  Segment frontier: ${segmentFrontier.terminalSegments}/${segmentFrontier.totalSegments} terminal\n`
+				: "";
 			emitAlert({
 				category: "task-failure",
 				summary:
 					`⚠️ Task failure: ${taskId}\n` +
 					`  Exit reason: ${exitReason}\n` +
+					segmentSummary +
+					frontierSummary +
 					`  Lane: ${laneForTask?.laneId ?? "unknown"} (lane ${laneForTask?.laneNumber ?? "?"})\n` +
 					`  Partial progress preserved: ${hasPartialProgress ? "yes" : "no"}\n` +
 					`  Batch: wave ${waveIdx + 1}/${batchState.totalWaves}, ` +
@@ -1727,6 +1961,9 @@ export async function resumeOrchBatch(
 					`  - Read STATUS.md and lane logs for diagnosis`,
 				context: {
 					taskId,
+					segmentId,
+					repoId,
+					segmentFrontier,
 					laneId: laneForTask?.laneId,
 					laneNumber: laneForTask?.laneNumber,
 					waveIndex: waveIdx,
@@ -1928,6 +2165,7 @@ export async function resumeOrchBatch(
 			);
 
 			// ── TP-076: Emit supervisor alert for rollback safe-stop ──
+			const rollbackRepoId = extractFailedRepoId(mergeResult) ?? undefined;
 			emitAlert({
 				category: "merge-failure",
 				summary:
@@ -1941,6 +2179,7 @@ export async function resumeOrchBatch(
 				context: {
 					waveIndex: waveIdx,
 					laneNumber: mergeResult.failedLane ?? undefined,
+					repoId: rollbackRepoId,
 					mergeError: `Safe-stop: verification rollback failed at wave ${waveIdx + 1}`,
 					batchProgress: buildBatchProgressSnapshot(batchState),
 				},
@@ -1958,6 +2197,7 @@ export async function resumeOrchBatch(
 				batchState.resilience = defaultResilienceState();
 			}
 
+			const mergeRepoId = extractFailedRepoId(mergeResult) ?? undefined;
 			const retryOutcome = await applyMergeRetryLoop(
 				mergeResult,
 				waveIdx,
@@ -2017,6 +2257,7 @@ export async function resumeOrchBatch(
 					context: {
 						waveIndex: waveIdx,
 						laneNumber: mergeResult.failedLane ?? undefined,
+						repoId: mergeRepoId,
 						mergeError: retryOutcome.errorMessage,
 						batchProgress: buildBatchProgressSnapshot(batchState),
 					},
@@ -2056,6 +2297,7 @@ export async function resumeOrchBatch(
 					context: {
 						waveIndex: waveIdx,
 						laneNumber: mergeResult.failedLane ?? undefined,
+						repoId: mergeRepoId,
 						mergeError: exhaustionMsg,
 						batchProgress: buildBatchProgressSnapshot(batchState),
 					},
@@ -2092,6 +2334,7 @@ export async function resumeOrchBatch(
 					context: {
 						waveIndex: waveIdx,
 						laneNumber: mergeResult.failedLane ?? undefined,
+						repoId: mergeRepoId,
 						mergeError: mergeResult.failureReason || "unknown",
 						batchProgress: buildBatchProgressSnapshot(batchState),
 					},

package/extensions/taskplane/supervisor-primer.md

@@ -724,6 +724,11 @@ Each alert contains:
   are available. This is what you see in the conversation.
 - **Context**: Structured data (taskId, laneId, waveIndex, exitReason,
   batchProgress, etc.) embedded in the message for your reference.
+  - `task-failure` alerts include segment-aware fields when available:
+    `segmentId`, `repoId`, and `segmentFrontier`.
+  - `segmentFrontier` shows ordered segment status for that task
+    (`pending/running/succeeded/failed/skipped/stalled`) so you can quickly
+    tell whether the failure happened early or near completion.
 
 ### Response Protocol
 
@@ -799,6 +804,11 @@ you observe. Do not skip steps; each observation narrows the diagnosis.
 **Trigger:** `task-failure` alert — a task failed after the engine exhausted
 deterministic recovery (retries, context resets).
 
+**Segment-aware triage:** If alert context includes `segmentId`/`repoId`, treat
+that as the failing execution unit. Use `segmentFrontier` to decide whether to
+retry immediately (early segment failure) or inspect downstream impact first
+(late-segment failure after prior segments succeeded).
+
 ```
 TASK FAILED: {taskId}
 │

package/extensions/taskplane/supervisor.ts

@@ -1121,6 +1121,27 @@ export interface BatchSummaryData {
 		failedLane: number | null;
 		failureReason: string | null;
 	}>;
+	/** Segment-level outcomes (when segment tracking is available). */
+	segmentOutcomes: {
+		totalSegments: number;
+		succeeded: number;
+		failed: number;
+		stalled: number;
+		skipped: number;
+		running: number;
+		pending: number;
+		multiSegmentTasks: Array<{
+			taskId: string;
+			totalSegments: number;
+			terminalSegments: number;
+			succeeded: number;
+			failed: number;
+			stalled: number;
+			skipped: number;
+			running: number;
+			pending: number;
+		}>;
+	} | null;
 	/** Audit trail entries for the batch */
 	auditEntries: AuditTrailEntry[];
 	/** Tier 0 events from events.jsonl (recovery attempts, successes, exhausted, escalations) */
@@ -1311,6 +1332,51 @@ export function collectBatchSummaryData(
 		overallStatus: wr.overallStatus || "unknown",
 	}));
 
+	const segmentRecords = batchState.segments || [];
+	let segmentOutcomes: BatchSummaryData["segmentOutcomes"] = null;
+	if (segmentRecords.length > 0) {
+		const byTaskId = new Map<string, typeof segmentRecords>();
+		for (const segment of segmentRecords) {
+			const existing = byTaskId.get(segment.taskId) || [];
+			existing.push(segment);
+			byTaskId.set(segment.taskId, existing);
+		}
+
+		const multiSegmentTasks: NonNullable<BatchSummaryData["segmentOutcomes"]>["multiSegmentTasks"] = [];
+		for (const [taskId, taskSegments] of [...byTaskId.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+			if (taskSegments.length <= 1) continue;
+			const succeeded = taskSegments.filter((segment) => segment.status === "succeeded").length;
+			const failed = taskSegments.filter((segment) => segment.status === "failed").length;
+			const stalled = taskSegments.filter((segment) => segment.status === "stalled").length;
+			const skipped = taskSegments.filter((segment) => segment.status === "skipped").length;
+			const running = taskSegments.filter((segment) => segment.status === "running").length;
+			const pending = taskSegments.filter((segment) => segment.status === "pending").length;
+			const terminalSegments = succeeded + failed + stalled + skipped;
+			multiSegmentTasks.push({
+				taskId,
+				totalSegments: taskSegments.length,
+				terminalSegments,
+				succeeded,
+				failed,
+				stalled,
+				skipped,
+				running,
+				pending,
+			});
+		}
+
+		segmentOutcomes = {
+			totalSegments: segmentRecords.length,
+			succeeded: segmentRecords.filter((segment) => segment.status === "succeeded").length,
+			failed: segmentRecords.filter((segment) => segment.status === "failed").length,
+			stalled: segmentRecords.filter((segment) => segment.status === "stalled").length,
+			skipped: segmentRecords.filter((segment) => segment.status === "skipped").length,
+			running: segmentRecords.filter((segment) => segment.status === "running").length,
+			pending: segmentRecords.filter((segment) => segment.status === "pending").length,
+			multiSegmentTasks,
+		};
+	}
+
 	return {
 		batchId: batchState.batchId,
 		phase: batchState.phase,
@@ -1328,6 +1394,7 @@ export function collectBatchSummaryData(
 		waveResults,
 		taskExits: diagnostics?.taskExits ?? {},
 		mergeResults: mergeResults ?? [],
+		segmentOutcomes,
 		auditEntries,
 		tier0Events,
 		errors: batchState.errors || [],
@@ -1421,6 +1488,36 @@ export function formatBatchSummary(data: BatchSummaryData): string {
 	}
 	lines.push("");
 
+	// ── Segment Outcomes ─────────────────────────────────────────
+	lines.push("## Segment Outcomes");
+	lines.push("");
+	if (!data.segmentOutcomes) {
+		lines.push("Segment data not available.");
+	} else if (data.segmentOutcomes.multiSegmentTasks.length === 0) {
+		lines.push(`No multi-segment task outcomes recorded (${data.segmentOutcomes.totalSegments} segment record(s) total).`);
+	} else {
+		const statusParts = [
+			`${data.segmentOutcomes.succeeded} succeeded`,
+			`${data.segmentOutcomes.failed} failed`,
+		];
+		if (data.segmentOutcomes.running > 0) statusParts.push(`${data.segmentOutcomes.running} running`);
+		if (data.segmentOutcomes.pending > 0) statusParts.push(`${data.segmentOutcomes.pending} pending`);
+		if (data.segmentOutcomes.skipped > 0) statusParts.push(`${data.segmentOutcomes.skipped} skipped`);
+		if (data.segmentOutcomes.stalled > 0) statusParts.push(`${data.segmentOutcomes.stalled} stalled`);
+		lines.push(`- **Tracked segments:** ${data.segmentOutcomes.totalSegments}`);
+		lines.push(`- **Status mix:** ${statusParts.join(", ")}`);
+		lines.push(`- **Multi-segment tasks:** ${data.segmentOutcomes.multiSegmentTasks.length}`);
+		for (const task of data.segmentOutcomes.multiSegmentTasks) {
+			const taskParts = [`${task.succeeded}✓`, `${task.failed}✗`];
+			if (task.running > 0) taskParts.push(`${task.running} running`);
+			if (task.pending > 0) taskParts.push(`${task.pending} pending`);
+			if (task.skipped > 0) taskParts.push(`${task.skipped} skipped`);
+			if (task.stalled > 0) taskParts.push(`${task.stalled} stalled`);
+			lines.push(`  - ${task.taskId}: ${task.terminalSegments}/${task.totalSegments} terminal (${taskParts.join(", ")})`);
+		}
+	}
+	lines.push("");
+
 	// ── Incidents & Recoveries ───────────────────────────────────
 	lines.push("## Incidents");
 	lines.push("");

package/extensions/taskplane/types.ts

@@ -684,6 +684,8 @@ export interface LaneTaskOutcome {
 	taskId: string;
 	/** Final task status */
 	status: LaneTaskStatus;
+	/** Segment identifier for segment-aware execution (null for whole-task units). */
+	segmentId?: string | null;
 	/** When execution started (epoch ms), null if never started (skipped) */
 	startTime: number | null;
 	/** When execution ended (epoch ms), null if still pending */
@@ -1949,9 +1951,31 @@ export type SupervisorAlertCategory = "task-failure" | "merge-failure" | "batch-
  *
  * @since TP-076
  */
+export interface SupervisorSegmentFrontierSnapshot {
+	/** Parent task identifier */
+	taskId: string;
+	/** Total number of ordered segments for the task */
+	totalSegments: number;
+	/** Number of segments that reached a terminal status */
+	terminalSegments: number;
+	/** Active (or most recently active) segment ID */
+	activeSegmentId: string | null;
+	/** Segment-level execution snapshot in deterministic order */
+	segments: Array<{
+		segmentId: string;
+		repoId: string;
+		status: PersistedSegmentStatus;
+		dependsOnSegmentIds: string[];
+	}>;
+}
+
 export interface SupervisorAlertContext {
 	/** Task ID (for task-failure alerts) */
 	taskId?: string;
+	/** Segment ID (for segment-aware task-failure alerts) */
+	segmentId?: string;
+	/** Repo ID associated with the failure (task segment or merge target) */
+	repoId?: string;
 	/** Lane ID, e.g., "lane-1" (for task-failure alerts) */
 	laneId?: string;
 	/** Lane number (for task-failure and merge-failure alerts) */
@@ -1960,6 +1984,8 @@ export interface SupervisorAlertContext {
 	waveIndex?: number;
 	/** Exit reason string (for task-failure alerts) */
 	exitReason?: string;
+	/** Segment frontier snapshot for task-failure diagnosis */
+	segmentFrontier?: SupervisorSegmentFrontierSnapshot;
 	/** Agent ID (for agent-message alerts) */
 	agentId?: string;
 	/** Mailbox message ID (for agent-message alerts) */
@@ -2041,6 +2067,70 @@ export function buildBatchProgressSnapshot(
 	};
 }
 
+function repoIdFromSegmentId(segmentId: string): string {
+	const idx = segmentId.indexOf("::");
+	if (idx <= 0 || idx >= segmentId.length - 2) return "unknown";
+	return segmentId.slice(idx + 2);
+}
+
+/**
+ * Build a task-level segment frontier snapshot for supervisor failure alerts.
+ *
+ * Returns `undefined` when the task has no segment metadata.
+ */
+export function buildSupervisorSegmentFrontierSnapshot(
+	taskId: string,
+	segmentIds: string[] | undefined,
+	activeSegmentId: string | null | undefined,
+	persistedSegments: PersistedSegmentRecord[] | undefined,
+	preferredSegmentId?: string | null,
+): SupervisorSegmentFrontierSnapshot | undefined {
+	const orderedSegmentIds = Array.isArray(segmentIds)
+		? segmentIds.filter((segmentId): segmentId is string => typeof segmentId === "string" && segmentId.trim().length > 0)
+		: [];
+	if (orderedSegmentIds.length === 0) return undefined;
+
+	const bySegmentId = new Map<string, PersistedSegmentRecord>();
+	for (const segment of persistedSegments ?? []) {
+		if (segment && segment.taskId === taskId) {
+			bySegmentId.set(segment.segmentId, segment);
+		}
+	}
+
+	const resolvedActiveSegmentId = (activeSegmentId && orderedSegmentIds.includes(activeSegmentId))
+		? activeSegmentId
+		: (preferredSegmentId && orderedSegmentIds.includes(preferredSegmentId)
+			? preferredSegmentId
+			: null);
+
+	const segments = orderedSegmentIds.map((segmentId) => {
+		const persisted = bySegmentId.get(segmentId);
+		const status: PersistedSegmentStatus = persisted?.status
+			?? (resolvedActiveSegmentId === segmentId ? "running" : "pending");
+		return {
+			segmentId,
+			repoId: persisted?.repoId ?? repoIdFromSegmentId(segmentId),
+			status,
+			dependsOnSegmentIds: persisted?.dependsOnSegmentIds ?? [],
+		};
+	});
+
+	const terminalSegments = segments.filter((segment) =>
+		segment.status === "succeeded"
+		|| segment.status === "failed"
+		|| segment.status === "stalled"
+		|| segment.status === "skipped",
+	).length;
+
+	return {
+		taskId,
+		totalSegments: segments.length,
+		terminalSegments,
+		activeSegmentId: resolvedActiveSegmentId,
+		segments,
+	};
+}
+
 /**
  * Build the base fields for an engine event.
  *