taskplane 0.24.7 → 0.24.9

package/extensions/taskplane/execution.ts

@@ -1182,8 +1182,10 @@ export async function monitorLanes(
 					currentTaskId = task.taskId;
 
 					const tracker = getOrCreateTracker(task.taskId, now);
-					const donePath = resolveTaskDonePath(task.task.taskFolder, lane.worktreePath, repoRoot, isWorkspaceMode);
-					const statusResult = await parseWorktreeStatusMdAsync(task.task.taskFolder, lane.worktreePath, repoRoot, isWorkspaceMode);
+					const unit = buildExecutionUnit(lane, task, repoRoot, isWorkspaceMode);
+					const donePath = unit.packet.donePath;
+					const statusPath = unit.packet.statusPath;
+					const statusResult = await parseWorktreeStatusMdAsync(dirname(statusPath), lane.worktreePath, repoRoot, false);
 
 					const snapshot = await resolveTaskMonitorState(
 						task.taskId,
@@ -1966,6 +1968,16 @@ export function buildExecutionUnit(
 	const segmentId = task.task.activeSegmentId ?? null;
 	const id = segmentId ?? task.taskId;
 
+	const packet = task.task.packetTaskPath
+		? resolvePacketPaths(task.task.packetTaskPath)
+		: {
+			promptPath: resolved.taskFolderResolved + "/PROMPT.md",
+			statusPath: resolved.statusPath,
+			donePath: resolved.donePath,
+			reviewsDir: resolved.taskFolderResolved + "/.reviews",
+			taskFolder: resolved.taskFolderResolved,
+		};
+
 	return {
 		id,
 		taskId: task.taskId,
@@ -1973,13 +1985,7 @@ export function buildExecutionUnit(
 		executionRepoId,
 		packetHomeRepoId,
 		worktreePath: lane.worktreePath,
-		packet: {
-			promptPath: resolved.taskFolderResolved + "/PROMPT.md",
-			statusPath: resolved.statusPath,
-			donePath: resolved.donePath,
-			reviewsDir: resolved.taskFolderResolved + "/.reviews",
-			taskFolder: resolved.taskFolderResolved,
-		},
+		packet,
 		task: task.task,
 	};
 }
@@ -2181,11 +2187,13 @@ export async function executeLaneV2(
 	});
 
 	for (const task of lane.tasks) {
+		const taskSegmentId = task.task.activeSegmentId ?? null;
 		if (shouldSkipRemaining || pauseSignal.paused) {
 			const reason = pauseSignal.paused ? "Skipped due to pause signal" : "Skipped due to prior task failure in lane";
 			outcomes.push({
 				taskId: task.taskId,
 				status: "skipped",
+				segmentId: taskSegmentId,
 				startTime: null,
 				endTime: null,
 				exitReason: reason,
@@ -2246,6 +2254,7 @@ export async function executeLaneV2(
 			outcomes.push({
 				taskId: task.taskId,
 				status: "failed",
+				segmentId: taskSegmentId,
 				startTime: Date.now(),
 				endTime: Date.now(),
 				exitReason: `Runtime V2 execution error: ${errMsg}`,

package/extensions/taskplane/extension.ts

@@ -1120,6 +1120,8 @@ export function startBatchInWorker(
 
 			case "error": {
 				errorReceivedViaIpc = true;
+				rotateStderrLogToBatch(batchState.batchId || undefined);
+				const stderrTail = readStderrTail();
 				const sourceLabel = msg.source ? ` (${msg.source})` : "";
 				const stackLine = msg.stack?.split("\n")[0]?.trim();
 				if (batchState.phase !== "completed" && batchState.phase !== "failed") {
@@ -1134,6 +1136,36 @@ export function startBatchInWorker(
 					`   Batch ${batchState.batchId} marked as failed.`,
 					"error",
 				);
+				// Alert supervisor — this is the PRIMARY notification path for engine
+				// crashes caught by uncaughtException/unhandledRejection handlers.
+				// The child.on("exit") handler is suppressed when errorReceivedViaIpc
+				// is true, so this is the only path that reaches the supervisor.
+				onSupervisorAlert?.({
+					category: "task-failure",
+					summary:
+						`🔴 Engine crashed with unhandled error${sourceLabel}: ${msg.message}\n` +
+						(stackLine ? `  Stack: ${stackLine}\n` : "") +
+						`  Batch ${batchState.batchId} marked as failed.\n\n` +
+						`Engine stderr tail (${stderrLogPath}):\n${stderrTail}\n\n` +
+						`This is a critical engine failure. The batch cannot continue.\n` +
+						`Available actions:\n` +
+						`  - orch_status() to inspect state\n` +
+						`  - orch_resume(force=true) to retry from last checkpoint`,
+					context: {
+						batchProgress: batchState.totalTasks > 0 ? {
+							succeededTasks: batchState.succeededTasks,
+							failedTasks: batchState.failedTasks,
+							skippedTasks: batchState.skippedTasks,
+							blockedTasks: batchState.blockedTasks,
+							totalTasks: batchState.totalTasks,
+							currentWave: batchState.currentWaveIndex + 1,
+							totalWaves: batchState.totalWaves,
+						} : undefined,
+					},
+				});
+				// Persist failed state to disk so dashboard/resume see it.
+				// The engine-worker is dead and can't persist — we must do it here.
+				try { saveBatchState(JSON.stringify(batchState, null, 2), wkData.cwd); } catch { /* best effort */ }
 				updateWidget();
 				break;
 			}
@@ -1223,6 +1255,8 @@ export function startBatchInWorker(
 					} : undefined,
 				},
 			});
+			// Persist failed state to disk (engine is dead, can't persist itself)
+			try { saveBatchState(JSON.stringify(batchState, null, 2), wkData.cwd); } catch { /* best effort */ }
 		}
 		settle();
 	});
@@ -2085,6 +2119,42 @@ export default function (pi: ExtensionAPI) {
 		};
 	}
 
+	function repoIdFromSegmentId(segmentId: string): string {
+		const idx = segmentId.indexOf("::");
+		if (idx <= 0 || idx >= segmentId.length - 2) return "unknown";
+		return segmentId.slice(idx + 2);
+	}
+
+	function buildTaskSegmentProgressLabel(
+		task: { taskId: string; segmentIds?: string[]; activeSegmentId?: string | null; status?: string } | undefined,
+		segments: Array<{ taskId: string; segmentId: string; status: string; repoId: string }> | undefined,
+		preferredSegmentId?: string | null,
+	): string | null {
+		if (!task || !Array.isArray(task.segmentIds) || task.segmentIds.length <= 1) return null;
+
+		const segmentIds = task.segmentIds.filter(segmentId => typeof segmentId === "string" && segmentId.trim().length > 0);
+		if (segmentIds.length <= 1) return null;
+
+		const bySegmentId = new Map<string, { status: string; repoId: string }>();
+		for (const segment of segments ?? []) {
+			if (segment.taskId === task.taskId) {
+				bySegmentId.set(segment.segmentId, { status: segment.status, repoId: segment.repoId });
+			}
+		}
+
+		let activeSegmentId = task.activeSegmentId ?? preferredSegmentId ?? null;
+		if (!activeSegmentId || !segmentIds.includes(activeSegmentId)) {
+			activeSegmentId = segmentIds.find((segmentId) => {
+				const status = bySegmentId.get(segmentId)?.status;
+				return !["succeeded", "failed", "stalled", "skipped"].includes(status || "pending");
+			}) || segmentIds[segmentIds.length - 1];
+		}
+
+		const index = Math.max(0, segmentIds.indexOf(activeSegmentId));
+		const repoId = bySegmentId.get(activeSegmentId)?.repoId ?? repoIdFromSegmentId(activeSegmentId);
+		return `Segment ${index + 1}/${segmentIds.length}: ${repoId}`;
+	}
+
 	/**
 	 * Core logic for orch-status. Returns a formatted status string.
 	 * Reads in-memory state first, falls back to disk if idle.
@@ -2114,6 +2184,41 @@ export default function (pi: ExtensionAPI) {
 				`   Elapsed: ${elapsedSec}s`,
 			];
 
+			const segmentRecords = diskState.segments || [];
+			const multiSegmentTasks = (diskState.tasks || []).filter((task) => Array.isArray(task.segmentIds) && task.segmentIds.length > 1);
+			if (multiSegmentTasks.length > 0) {
+				const byStatus = {
+					succeeded: segmentRecords.filter((segment) => segment.status === "succeeded").length,
+					failed: segmentRecords.filter((segment) => segment.status === "failed").length,
+					running: segmentRecords.filter((segment) => segment.status === "running").length,
+					pending: segmentRecords.filter((segment) => segment.status === "pending").length,
+					skipped: segmentRecords.filter((segment) => segment.status === "skipped").length,
+					stalled: segmentRecords.filter((segment) => segment.status === "stalled").length,
+				};
+				const segParts = [`${byStatus.succeeded} succeeded`];
+				if (byStatus.failed > 0) segParts.push(`${byStatus.failed} failed`);
+				if (byStatus.running > 0) segParts.push(`${byStatus.running} running`);
+				if (byStatus.pending > 0) segParts.push(`${byStatus.pending} pending`);
+				if (byStatus.skipped > 0) segParts.push(`${byStatus.skipped} skipped`);
+				if (byStatus.stalled > 0) segParts.push(`${byStatus.stalled} stalled`);
+				lines.push(`   Segments: ${segParts.join(", ")} (${multiSegmentTasks.length} multi-segment task(s))`);
+			}
+
+			const sortedDiskLanes = [...(diskState.lanes || [])].sort((a, b) => a.laneNumber - b.laneNumber);
+			if (sortedDiskLanes.length > 0) {
+				lines.push("   Lanes:");
+				for (const laneRec of sortedDiskLanes) {
+					const laneTasks = (diskState.tasks || []).filter((task) => task.laneNumber === laneRec.laneNumber);
+					const runningTask = laneTasks.find((task) => task.status === "running");
+					const activeTask = runningTask || laneTasks[laneTasks.length - 1];
+					const taskLabel = activeTask ? `${activeTask.taskId} (${activeTask.status})` : "idle";
+					const segmentLabel = buildTaskSegmentProgressLabel(activeTask, segmentRecords, activeTask?.activeSegmentId ?? null);
+					const segmentPart = segmentLabel ? ` · ${segmentLabel}` : "";
+					const repoPart = laneRec.repoId ? ` · repo: ${laneRec.repoId}` : "";
+					lines.push(`   - Lane ${laneRec.laneNumber}: ${taskLabel}${segmentPart}${repoPart}`);
+				}
+			}
+
 			if (diskState.errors.length > 0) {
 				lines.push(`   Errors: ${diskState.errors.length}`);
 			}
@@ -2132,6 +2237,51 @@ export default function (pi: ExtensionAPI) {
 			`   Elapsed: ${elapsedSec}s`,
 		];
 
+		const segmentRecords = orchBatchState.segments || [];
+		const multiSegmentTaskCount = orchBatchState.currentLanes.reduce((count, laneRec) => {
+			return count + laneRec.tasks.filter((task) => Array.isArray(task.task.segmentIds) && task.task.segmentIds.length > 1).length;
+		}, 0);
+		if (multiSegmentTaskCount > 0) {
+			const byStatus = {
+				succeeded: segmentRecords.filter((segment) => segment.status === "succeeded").length,
+				failed: segmentRecords.filter((segment) => segment.status === "failed").length,
+				running: segmentRecords.filter((segment) => segment.status === "running").length,
+				pending: segmentRecords.filter((segment) => segment.status === "pending").length,
+				skipped: segmentRecords.filter((segment) => segment.status === "skipped").length,
+				stalled: segmentRecords.filter((segment) => segment.status === "stalled").length,
+			};
+			const segParts = [`${byStatus.succeeded} succeeded`];
+			if (byStatus.failed > 0) segParts.push(`${byStatus.failed} failed`);
+			if (byStatus.running > 0) segParts.push(`${byStatus.running} running`);
+			if (byStatus.pending > 0) segParts.push(`${byStatus.pending} pending`);
+			if (byStatus.skipped > 0) segParts.push(`${byStatus.skipped} skipped`);
+			if (byStatus.stalled > 0) segParts.push(`${byStatus.stalled} stalled`);
+			lines.push(`   Segments: ${segParts.join(", ")} (${multiSegmentTaskCount} multi-segment task(s))`);
+		}
+
+		if (orchBatchState.currentLanes.length > 0) {
+			lines.push("   Lanes:");
+			const sortedLanes = [...orchBatchState.currentLanes].sort((a, b) => a.laneNumber - b.laneNumber);
+			for (const laneRec of sortedLanes) {
+				const monLane = latestMonitorState?.lanes.find((laneState) => laneState.laneNumber === laneRec.laneNumber);
+				const currentTaskId = monLane?.currentTaskId || laneRec.tasks[0]?.taskId;
+				const allocatedTask = currentTaskId
+					? laneRec.tasks.find((task) => task.taskId === currentTaskId)
+					: laneRec.tasks[0];
+				const taskLabel = allocatedTask
+					? `${allocatedTask.taskId} (${monLane?.currentTaskSnapshot?.status || "running"})`
+					: "idle";
+				const segmentLabel = buildTaskSegmentProgressLabel(
+					allocatedTask?.task,
+					segmentRecords,
+					allocatedTask?.task.activeSegmentId ?? null,
+				);
+				const segmentPart = segmentLabel ? ` · ${segmentLabel}` : "";
+				const repoPart = laneRec.repoId ? ` · repo: ${laneRec.repoId}` : "";
+				lines.push(`   - Lane ${laneRec.laneNumber}: ${taskLabel}${segmentPart}${repoPart}`);
+			}
+		}
+
 		if (orchBatchState.errors.length > 0) {
 			lines.push(`   Errors: ${orchBatchState.errors.length}`);
 		}
@@ -4154,6 +4304,14 @@ export default function (pi: ExtensionAPI) {
 
 			if (currentTask) {
 				lines.push(`**Task:** ${currentTask.taskId} (${currentTask.status})`);
+				const segmentLabel = buildTaskSegmentProgressLabel(currentTask, state.segments || [], currentTask.activeSegmentId ?? null);
+				if (segmentLabel) lines.push(`**Segment:** ${segmentLabel}`);
+				if (currentTask.activeSegmentId) lines.push(`**Segment ID:** ${currentTask.activeSegmentId}`);
+				const packetHomeRepo = typeof currentTask.packetRepoId === "string" ? currentTask.packetRepoId : "";
+				const effectiveTaskRepo = currentTask.resolvedRepoId || currentTask.repoId || laneRec.repoId || "";
+				if (packetHomeRepo && packetHomeRepo !== effectiveTaskRepo) {
+					lines.push(`**Packet Home Repo:** ${packetHomeRepo}`);
+				}
 
 				// Read STATUS.md from canonical task paths (workspace-safe, cross-repo-safe)
 				try {

package/extensions/taskplane/lane-runner.ts

@@ -16,7 +16,7 @@
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
-import { join, dirname, resolve } from "path";
+import { join, dirname, resolve, basename } from "path";
 import { fileURLToPath } from "url";
 
 import {
@@ -158,7 +158,9 @@ export async function executeTaskV2(
 	const donePath = unit.packet.donePath;
 	const promptPath = unit.packet.promptPath;
 	const taskFolder = unit.packet.taskFolder;
+	const reviewerStatePath = join(taskFolder, ".reviewer-state.json");
 	const taskId = unit.taskId;
+	const segmentId = unit.segmentId;
 	const workerAgentId = buildRuntimeAgentId(config.agentIdPrefix, config.laneNumber, "worker");
 
 	// ── 1. Ensure STATUS.md exists ──────────────────────────────────
@@ -183,8 +185,8 @@ export async function executeTaskV2(
 	for (let iter = 0; iter < config.maxIterations; iter++) {
 		if (pauseSignal.paused) {
 			logExecution(statusPath, "Paused", `User paused at iteration ${totalIterations}`);
-			return makeResult(taskId, workerAgentId, "skipped", startTime,
-				"Paused by user", false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath);
+			return makeResult(taskId, segmentId, workerAgentId, "skipped", startTime,
+				"Paused by user", false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath);
 		}
 
 		// Determine remaining steps
@@ -225,11 +227,38 @@ export async function executeTaskV2(
 			`Iteration: ${totalIterations}`,
 			`Wrap-up signal file: ${wrapUpFile}`,
 			``,
+			`Execution repo context:`,
+			`- Execution repo ID: ${unit.executionRepoId}`,
+			`- Execution worktree (worker cwd): ${unit.worktreePath}`,
+			`- Lane repo ID: ${config.repoId}`,
+			`- Active segment ID: ${segmentId ?? "(none / whole-task execution)"}`,
+			``,
+			`Packet home context:`,
+			`- Packet home repo ID: ${unit.packetHomeRepoId}`,
+			`- Packet task folder: ${taskFolder}`,
+			`- Packet PROMPT path: ${promptPath}`,
+			`- Packet STATUS path: ${statusPath}`,
+			`- Packet .DONE path: ${donePath}`,
+			`- Packet .reviews path: ${unit.packet.reviewsDir}`,
+			``,
 			`⚠️ ORCHESTRATED RUN: Do NOT archive or move the task folder. The orchestrator handles post-merge archival.`,
 			``,
 			`⚠️ CHECKPOINT RULE: After completing EACH checkbox item, immediately edit STATUS.md to check it off (- [ ] → - [x]) BEFORE starting the next item. Do NOT batch checkbox updates at the end of a step.`,
 		];
 
+		const segmentDag = unit.task.explicitSegmentDag;
+		if (segmentDag && segmentDag.repoIds.length > 0) {
+			const edgeSummary = segmentDag.edges.length > 0
+				? segmentDag.edges.map(edge => `${edge.fromRepoId}->${edge.toRepoId}`).join(", ")
+				: "(no explicit edges)";
+			promptLines.push(
+				``,
+				`Segment DAG context (from PROMPT metadata):`,
+				`- Repos: ${segmentDag.repoIds.join(", ")}`,
+				`- Edges: ${edgeSummary}`,
+			);
+		}
+
 		if (totalIterations > 1 && remainingSteps.length > 0) {
 			const remainingSet = new Set(remainingSteps.map(s => s.number));
 			const completedSteps = parsed.steps.filter(s => !remainingSet.has(s.number));
@@ -260,7 +289,7 @@ export async function executeTaskV2(
 			laneNumber: config.laneNumber,
 			taskId,
 			repoId: config.repoId,
-			cwd: config.worktreePath,
+			cwd: unit.worktreePath,
 			prompt: promptLines.join("\n"),
 			systemPrompt: config.workerSystemPrompt || undefined,
 			model: config.workerModel || undefined,
@@ -278,6 +307,10 @@ export async function executeTaskV2(
 				TASKPLANE_OUTBOX_DIR: outboxDir,
 				TASKPLANE_AGENT_ID: workerAgentId,
 				TASKPLANE_TASK_FOLDER: taskFolder,
+				TASKPLANE_STATUS_PATH: statusPath,
+				TASKPLANE_PROMPT_PATH: promptPath,
+				TASKPLANE_REVIEWS_DIR: unit.packet.reviewsDir,
+				TASKPLANE_REVIEWER_STATE_PATH: reviewerStatePath,
 				TASKPLANE_PROJECT_NAME: config.projectName || "project",
 				ORCH_BATCH_ID: config.batchId,
 			},
@@ -305,7 +338,7 @@ export async function executeTaskV2(
 				iterationTelemetry = telemetry;
 				lastTelemetry = telemetry;
 				// Emit lane snapshot
-				emitSnapshot(config, taskId, "running", telemetry, statusPath);
+				emitSnapshot(config, taskId, segmentId, "running", telemetry, statusPath, reviewerStatePath);
 			} catch { /* non-fatal: telemetry callback must never crash the engine */ }
 		});
 
@@ -315,7 +348,7 @@ export async function executeTaskV2(
 		let reviewerSnapshotFailures = 0;
 		const reviewerRefreshFailureThreshold = 5;
 		const reviewerRefresh = setInterval(() => {
-			const ok = emitSnapshot(config, taskId, "running", iterationTelemetry, statusPath);
+			const ok = emitSnapshot(config, taskId, segmentId, "running", iterationTelemetry, statusPath, reviewerStatePath);
 			if (ok) {
 				reviewerSnapshotFailures = 0;
 				return;
@@ -445,8 +478,8 @@ export async function executeTaskV2(
 				`Iteration ${totalIterations}: 0 new checkboxes (${noProgressCount}/${config.noProgressLimit} stall limit)`);
 			if (noProgressCount >= config.noProgressLimit) {
 				logExecution(statusPath, "Task blocked", `No progress after ${noProgressCount} iterations`);
-				return makeResult(taskId, workerAgentId, "failed", startTime,
-					`No progress after ${noProgressCount} iterations`, false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, lastTelemetry);
+				return makeResult(taskId, segmentId, workerAgentId, "failed", startTime,
+					`No progress after ${noProgressCount} iterations`, false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
 			}
 		} else {
 			noProgressCount = 0;
@@ -485,9 +518,9 @@ export async function executeTaskV2(
 			.map(s => `Step ${s.number}`)
 			.join(", ");
 		logExecution(statusPath, "Task incomplete", `Max iterations reached. Incomplete: ${incomplete}`);
-		return makeResult(taskId, workerAgentId, "failed", startTime,
+		return makeResult(taskId, segmentId, workerAgentId, "failed", startTime,
 			`Max iterations (${config.maxIterations}) reached with incomplete steps: ${incomplete}`,
-			false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, lastTelemetry);
+			false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
 	}
 
 	// Create .DONE if not already present
@@ -497,8 +530,8 @@ export async function executeTaskV2(
 	updateStatusField(statusPath, "Status", "✅ Complete");
 	logExecution(statusPath, "Task complete", ".DONE created");
 
-	return makeResult(taskId, workerAgentId, "succeeded", startTime,
-		".DONE file created by lane-runner", true, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, lastTelemetry);
+	return makeResult(taskId, segmentId, workerAgentId, "succeeded", startTime,
+		".DONE file created by lane-runner", true, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
 }
 
 // ── Helpers ──────────────────────────────────────────────────────────
@@ -522,6 +555,7 @@ export function mapLaneSnapshotStatusToWorkerStatus(
 
 function makeResult(
 	taskId: string,
+	segmentId: string | null,
 	sessionName: string,
 	status: LaneTaskStatus,
 	startTime: number,
@@ -532,6 +566,7 @@ function makeResult(
 	totalTokens: number,
 	config?: LaneRunnerConfig,
 	statusPath?: string,
+	reviewerStatePath?: string,
 	finalTelemetry?: Partial<AgentHostResult>,
 ): LaneRunnerTaskResult {
 	const telemetry = status === "skipped"
@@ -550,6 +585,7 @@ function makeResult(
 		outcome: {
 			taskId,
 			status,
+			segmentId,
 			startTime,
 			endTime: Date.now(),
 			exitReason,
@@ -564,9 +600,9 @@ function makeResult(
 	};
 
 	// TP-115: Emit terminal snapshot with real telemetry from agent-host result
-	if (config && statusPath) {
+	if (config && statusPath && reviewerStatePath) {
 		const terminalStatus = mapLaneTaskStatusToTerminalSnapshotStatus(status);
-		emitSnapshot(config, taskId, terminalStatus, finalTelemetry ?? {}, statusPath);
+		emitSnapshot(config, taskId, segmentId, terminalStatus, finalTelemetry ?? {}, statusPath, reviewerStatePath);
 	}
 
 	return result;
@@ -577,9 +613,11 @@ const REVIEWER_STATE_STALE_MS = 120_000;
 
 export function readReviewerTelemetrySnapshot(
 	config: LaneRunnerConfig,
-	statusPath: string,
+	reviewerStatePathOrStatusPath: string,
 ): (RuntimeAgentTelemetrySnapshot & { reviewType?: string; reviewStep?: number }) | null {
-	const reviewerPath = join(dirname(statusPath), ".reviewer-state.json");
+	const reviewerPath = basename(reviewerStatePathOrStatusPath).toLowerCase() === "status.md"
+		? join(dirname(reviewerStatePathOrStatusPath), ".reviewer-state.json")
+		: reviewerStatePathOrStatusPath;
 	if (!existsSync(reviewerPath)) return null;
 
 	try {
@@ -636,9 +674,11 @@ export function readReviewerTelemetrySnapshot(
 function emitSnapshot(
 	config: LaneRunnerConfig,
 	taskId: string,
+	segmentId: string | null,
 	status: "running" | "idle" | "complete" | "failed",
 	telemetry: Partial<AgentHostResult>,
 	statusPath: string,
+	reviewerStatePath: string,
 ): boolean {
 	try {
 		// Parse progress from STATUS.md
@@ -658,7 +698,7 @@ function emitSnapshot(
 			};
 		} catch { /* best effort */ }
 
-		const reviewerSnapshot = readReviewerTelemetrySnapshot(config, statusPath);
+		const reviewerSnapshot = readReviewerTelemetrySnapshot(config, reviewerStatePath);
 
 		const snapshot: RuntimeLaneSnapshot = {
 			batchId: config.batchId,
@@ -666,7 +706,7 @@ function emitSnapshot(
 			laneId: `lane-${config.laneNumber}`,
 			repoId: config.repoId,
 			taskId,
-			segmentId: null,
+			segmentId,
 			status,
 			worker: {
 				agentId: buildRuntimeAgentId(config.agentIdPrefix, config.laneNumber, "worker"),

package/extensions/taskplane/persistence.ts

@@ -319,6 +319,18 @@ export function persistRuntimeState(
 					if (taskRecord.resolvedRepoId === undefined && parsedTask.resolvedRepoId !== undefined) {
 						taskRecord.resolvedRepoId = parsedTask.resolvedRepoId;
 					}
+					if ((taskRecord as any).packetRepoId === undefined && parsedTask.packetRepoId !== undefined) {
+						(taskRecord as any).packetRepoId = parsedTask.packetRepoId;
+					}
+					if ((taskRecord as any).packetTaskPath === undefined && parsedTask.packetTaskPath !== undefined) {
+						(taskRecord as any).packetTaskPath = parsedTask.packetTaskPath;
+					}
+					if ((taskRecord as any).segmentIds === undefined && parsedTask.segmentIds !== undefined) {
+						(taskRecord as any).segmentIds = parsedTask.segmentIds;
+					}
+					if ((taskRecord as any).activeSegmentId === undefined && parsedTask.activeSegmentId !== undefined) {
+						(taskRecord as any).activeSegmentId = parsedTask.activeSegmentId;
+					}
 				}
 			}
 			const enrichedJson = JSON.stringify(parsed, null, 2);