taskplane 0.25.8 → 0.27.0

package/extensions/taskplane/path-resolver.ts

@@ -158,7 +158,7 @@ export function resolvePiCliPath(): string {
  *
  * @param repoRoot - Absolute path to the project root (used for local dev check)
  * @param relPath  - Relative path within the taskplane package, e.g.
- *                   `"extensions/task-runner.ts"` or `"templates/agents/task-worker.md"`
+ *                   `"extensions/task-orchestrator.ts"` or `"templates/agents/task-worker.md"`
  * @returns Absolute path to the resolved file. If not found in any location,
  *          returns the local path (`join(repoRoot, relPath)`) as a fallback — callers
  *          will fail at use time with a clear "file not found" error.

package/extensions/taskplane/persistence.ts

@@ -1359,6 +1359,9 @@ export function serializeBatchState(
 		endedAt: state.endedAt,
 		currentWaveIndex: state.currentWaveIndex,
 		totalWaves: state.totalWaves,
+		// TP-166: Persist task-level wave metadata for correct display after resume
+		...(state.taskLevelWaveCount != null ? { taskLevelWaveCount: state.taskLevelWaveCount } : {}),
+		...(state.roundToTaskWave != null ? { roundToTaskWave: [...state.roundToTaskWave] } : {}),
 		wavePlan,
 		lanes: laneRecords,
 		tasks: taskRecords,

package/extensions/taskplane/resume.ts

@@ -7,7 +7,7 @@ import { join } from "path";
 
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
-import { executeOrchBatch } from "./engine.ts";
+import { executeOrchBatch, resolveDisplayWaveNumber } from "./engine.ts";
 import { buildReviewerEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
 import { selectRuntimeBackend } from "./engine.ts";
@@ -158,9 +158,14 @@ export function reconstructAllocatedLanes(
 			if (persistedTask?.resolvedRepoId !== undefined) {
 				taskStub.resolvedRepoId = persistedTask.resolvedRepoId;
 			}
-			if (persistedTask?.taskFolder) {
-				taskStub.taskFolder = persistedTask.taskFolder;
-			}
+			// TP-169: Always set taskFolder on stub, even if empty string.
+			// Previously, the falsy check `if (persistedTask?.taskFolder)` skipped
+			// empty-string values, leaving taskFolder as `undefined` on the stub.
+			// This caused crashes in buildExecutionUnit and merge code when
+			// accessing `task.task.taskFolder` on dynamically-expanded segments
+			// whose persisted records had taskFolder="" (the default from
+			// serializeBatchState before enrichment).
+			taskStub.taskFolder = persistedTask?.taskFolder ?? "";
 			if ((persistedTask as any)?.packetRepoId !== undefined) {
 				(taskStub as any).packetRepoId = (persistedTask as any).packetRepoId;
 			}
@@ -1324,6 +1329,10 @@ export async function resumeOrchBatch(
 	// Preserve pauseSignal if already set during "launching" phase (TP-040)
 	if (!batchState.pauseSignal?.paused) batchState.pauseSignal = { paused: false };
 	batchState.totalWaves = persistedState.totalWaves;
+	// TP-166: Restore task-level wave metadata for correct display.
+	// Normalize: fall back to totalWaves for pre-TP-166 state files.
+	batchState.taskLevelWaveCount = persistedState.taskLevelWaveCount ?? persistedState.totalWaves;
+	batchState.roundToTaskWave = persistedState.roundToTaskWave ? [...persistedState.roundToTaskWave] : undefined;
 	batchState.totalTasks = persistedState.totalTasks;
 	batchState.succeededTasks = resumePoint.completedTaskIds.length;
 	batchState.failedTasks = resumePoint.failedTaskIds.length;
@@ -1372,6 +1381,42 @@ export async function resumeOrchBatch(
 		batchState._extraFields = persistedState._extraFields;
 	}
 
+	// ── 6b. TP-169: Verify orch branch exists in all workspace repos ────
+	// During the original batch start, the orch branch was created in every
+	// workspace repo. On resume, we verify it still exists. If it's missing
+	// in any repo (e.g., deleted by user, corrupted), re-create it from the
+	// repo's current branch so that worktree creation doesn't silently fall
+	// back to the base branch, bypassing orch branch isolation.
+	if (workspaceConfig && batchState.orchBranch) {
+		for (const [repoId, repoConf] of workspaceConfig.repos) {
+			const rRoot = repoConf.path;
+			const check = runGit(["rev-parse", "--verify", `refs/heads/${batchState.orchBranch}`], rRoot);
+			if (!check.ok) {
+				// Orch branch missing in this repo — re-create from current HEAD
+				const repoBranch = getCurrentBranch(rRoot) || "HEAD";
+				const createRes = runGit(["branch", batchState.orchBranch, repoBranch], rRoot);
+				if (createRes.ok) {
+					execLog("resume", batchState.batchId, `re-created missing orch branch in ${repoId}`, {
+						orchBranch: batchState.orchBranch,
+						base: repoBranch,
+					});
+					onNotify(
+						`⚠️ Orch branch "${batchState.orchBranch}" was missing in repo "${repoId}" — re-created from ${repoBranch}`,
+						"warning",
+					);
+				} else {
+					const errMsg = `Failed to re-create orch branch "${batchState.orchBranch}" in repo "${repoId}": ${createRes.stderr}. ` +
+						`Cannot resume without orch branch isolation.`;
+					execLog("resume", batchState.batchId, errMsg, {
+						orchBranch: batchState.orchBranch,
+						error: createRes.stderr,
+					});
+					throw new Error(errMsg);
+				}
+			}
+		}
+	}
+
 	// ── 7. Re-run discovery for ParsedTask metadata ──────────────
 	// We need fresh ParsedTask data (taskFolder, promptPath) for execution.
 	// Use "all" to discover all areas.
@@ -1767,12 +1812,17 @@ export async function resumeOrchBatch(
 		persistedState.tasks.map((task) => [task.taskId, task.status] as const),
 	);
 
+	// TP-166: Use task-level wave metadata for correct display.
+	const roundToTaskWave = batchState.roundToTaskWave;
+	const taskLevelWaveCount = batchState.taskLevelWaveCount;
+
 	for (let waveIdx = resumePoint.resumeWaveIndex; waveIdx < wavePlan.length; waveIdx++) {
 		// Check pause signal
 		if (batchState.pauseSignal.paused) {
 			batchState.phase = "paused";
 			persistRuntimeState("pause-before-wave", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
-			onNotify(`⏸️  Batch paused before wave ${waveIdx + 1}.`, "warning");
+			const { displayWave: pauseWave } = resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount);
+			onNotify(`⏸️  Batch paused before wave ${pauseWave}.`, "warning");
 			break;
 		}
 
@@ -1807,7 +1857,7 @@ export async function resumeOrchBatch(
 			// All tasks are terminal but the merge may have failed/been interrupted.
 			if (resumePoint.mergeRetryWaveIndexes.includes(waveIdx)) {
 				execLog("resume", batchState.batchId, `wave ${waveIdx + 1}: all tasks done but merge needs retry`);
-				onNotify(`🔀 Wave ${waveIdx + 1}: retrying merge (tasks already complete, merge was missing/failed)`, "info");
+				onNotify(`🔀 Wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave}: retrying merge (tasks already complete, merge was missing/failed)`, "info");
 
 				// Reconstruct lanes for this wave from persisted state
 				const waveTaskIds = new Set(wavePlan[waveIdx]);
@@ -1922,7 +1972,7 @@ export async function resumeOrchBatch(
 				batchState.mergeResults.push(mergeRetryResult);
 
 				if (mergeRetryResult.status === "succeeded") {
-					onNotify(`✅ Wave ${waveIdx + 1} merge retry succeeded`, "info");
+					onNotify(`✅ Wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave} merge retry succeeded`, "info");
 					// Clean up merged branches
 					for (const lr of mergeRetryResult.laneResults) {
 						if (!lr.error && (lr.result?.status === "SUCCESS" || lr.result?.status === "CONFLICT_RESOLVED")) {
@@ -1932,7 +1982,7 @@ export async function resumeOrchBatch(
 					}
 				} else {
 					onNotify(
-						`⚠️ Wave ${waveIdx + 1} merge retry ${mergeRetryResult.status}: ${mergeRetryResult.failureReason || "unknown"}`,
+						`⚠️ Wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave} merge retry ${mergeRetryResult.status}: ${mergeRetryResult.failureReason || "unknown"}`,
 						"warning",
 					);
 					// Apply merge failure policy (same as normal wave merge failure)
@@ -1954,10 +2004,13 @@ export async function resumeOrchBatch(
 			continue;
 		}
 
-		onNotify(
-			ORCH_MESSAGES.orchWaveStart(waveIdx + 1, wavePlan.length, waveTasks.length, Math.min(waveTasks.length, orchConfig.orchestrator.max_lanes)),
-			"info",
-		);
+		{
+			const { displayWave, displayTotal } = resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount);
+			onNotify(
+				ORCH_MESSAGES.orchWaveStart(displayWave, displayTotal, waveTasks.length, Math.min(waveTasks.length, orchConfig.orchestrator.max_lanes)),
+				"info",
+			);
+		}
 
 		const handleResumeMonitorUpdate: MonitorUpdateCallback = (monitorState) => {
 			const changed = syncTaskOutcomesFromMonitor(monitorState, allTaskOutcomes);
@@ -2064,7 +2117,7 @@ export async function resumeOrchBatch(
 					frontierSummary +
 					`  Lane: ${laneForTask?.laneId ?? "unknown"} (lane ${laneForTask?.laneNumber ?? "?"})\n` +
 					`  Partial progress preserved: ${hasPartialProgress ? "yes" : "no"}\n` +
-					`  Batch: wave ${waveIdx + 1}/${batchState.totalWaves}, ` +
+					`  Batch: wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave}/${taskLevelWaveCount ?? batchState.totalWaves}, ` +
 					`${batchState.succeededTasks} succeeded, ${batchState.failedTasks} failed\n\n` +
 					`Available actions:\n` +
 					`  - orch_status() to inspect current state\n` +
@@ -2088,16 +2141,19 @@ export async function resumeOrchBatch(
 		persistRuntimeState("wave-execution-complete", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
 
 		const elapsedSec = Math.round((waveResult.endedAt - waveResult.startedAt) / 1000);
-		onNotify(
-			ORCH_MESSAGES.orchWaveComplete(
-				waveIdx + 1,
-				waveResult.succeededTaskIds.length,
-				waveResult.failedTaskIds.length,
-				waveResult.skippedTaskIds.length,
-				elapsedSec,
-			),
-			waveResult.failedTaskIds.length > 0 ? "warning" : "info",
-		);
+		{
+			const { displayWave: completeDisplayWave } = resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount);
+			onNotify(
+				ORCH_MESSAGES.orchWaveComplete(
+					completeDisplayWave,
+					waveResult.succeededTaskIds.length,
+					waveResult.failedTaskIds.length,
+					waveResult.skippedTaskIds.length,
+					elapsedSec,
+				),
+				waveResult.failedTaskIds.length > 0 ? "warning" : "info",
+			);
+		}
 
 		// Check failure policy
 		if (waveResult.stoppedEarly) {
@@ -2144,7 +2200,7 @@ export async function resumeOrchBatch(
 			if (mergeableLaneCount > 0) {
 				batchState.phase = "merging";
 				persistRuntimeState("merge-start", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
-				onNotify(ORCH_MESSAGES.orchMergeStart(waveIdx + 1, mergeableLaneCount), "info");
+				onNotify(ORCH_MESSAGES.orchMergeStart(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergeableLaneCount), "info");
 
 				mergeResult = await mergeWaveByRepo(
 					waveResult.allocatedLanes,
@@ -2197,10 +2253,10 @@ export async function resumeOrchBatch(
 				const mergeTotalSec = Math.round(mergeResult.totalDurationMs / 1000);
 
 				if (mergeResult.status === "succeeded") {
-					onNotify(ORCH_MESSAGES.orchMergeComplete(waveIdx + 1, mergedCount, mergeTotalSec), "info");
+					onNotify(ORCH_MESSAGES.orchMergeComplete(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergedCount, mergeTotalSec), "info");
 				} else {
 					onNotify(
-						ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane ?? 0, mergeResult.failureReason || "unknown"),
+						ORCH_MESSAGES.orchMergeFailed(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergeResult.failedLane ?? 0, mergeResult.failureReason || "unknown"),
 						"error",
 					);
 
@@ -2231,14 +2287,14 @@ export async function resumeOrchBatch(
 				// Downstream retry/update paths assume the current wave has an entry.
 				batchState.mergeResults.push(mergeResult);
 				onNotify(
-					ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane, mergeResult.failureReason || "unknown"),
+					ORCH_MESSAGES.orchMergeFailed(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergeResult.failedLane, mergeResult.failureReason || "unknown"),
 					"error",
 				);
 			} else {
-				onNotify(ORCH_MESSAGES.orchMergeSkipped(waveIdx + 1), "info");
+				onNotify(ORCH_MESSAGES.orchMergeSkipped(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave), "info");
 			}
 		} else {
-			onNotify(ORCH_MESSAGES.orchMergeSkipped(waveIdx + 1), "info");
+			onNotify(ORCH_MESSAGES.orchMergeSkipped(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave), "info");
 		}
 
 		// ── TP-033: Safe-stop on rollback failure ─────────────────
@@ -2755,7 +2811,7 @@ export async function resumeOrchBatch(
 				summary:
 					`✅ Batch ${batchState.batchId} completed\n` +
 					`  ${batchState.succeededTasks}/${batchState.totalTasks} tasks succeeded\n` +
-					`  ${batchState.totalWaves} wave(s), duration: ${durationStr}\n` +
+					`  ${batchState.taskLevelWaveCount ?? batchState.totalWaves} wave(s), duration: ${durationStr}\n` +
 					`  Merged to orch branch: ${batchState.orchBranch}\n\n` +
 					`Ready for integration. Run orch_integrate() or review first.`,
 				context: {

package/extensions/taskplane/sidecar-telemetry.ts

@@ -0,0 +1,252 @@
+/**
+ * Sidecar Telemetry Utilities
+ *
+ * Canonical home for sidecar JSONL tailing and telemetry delta parsing.
+ *
+ * These utilities are used by the orchestrator to poll live worker telemetry
+ * (token usage, tool calls, retry state) from sidecar JSONL files written by
+ * the pi coding agent during task execution.
+ *
+ * @since TP-161
+ */
+
+import { existsSync, mkdirSync, statSync, openSync, readSync, closeSync } from "fs";
+import { join, dirname } from "path";
+
+// ── Sidecar Directory Resolution ──────────────────────────────────────
+
+/**
+ * Returns the .pi directory path for sidecar files (lane state, conversation logs).
+ * In orchestrated mode, the orchestrator passes ORCH_SIDECAR_DIR pointing to the
+ * MAIN repo's .pi/ directory (not the worktree's).
+ */
+export function getSidecarDir(): string {
+	// Orchestrator provides the main repo .pi path
+	const orchDir = process.env.ORCH_SIDECAR_DIR;
+	if (orchDir) {
+		if (!existsSync(orchDir)) mkdirSync(orchDir, { recursive: true });
+		return orchDir;
+	}
+	// Fallback: walk up from cwd
+	let dir = process.cwd();
+	for (let i = 0; i < 10; i++) {
+		const piDir = join(dir, ".pi");
+		if (existsSync(piDir)) return piDir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	const piDir = join(process.cwd(), ".pi");
+	if (!existsSync(piDir)) mkdirSync(piDir, { recursive: true });
+	return piDir;
+}
+
+// ── Sidecar Tail State ────────────────────────────────────────────────
+
+/**
+ * Mutable state for incremental byte-offset sidecar JSONL reading.
+ * One instance per sidecar file, persists across poll ticks within a session.
+ */
+export interface SidecarTailState {
+	/** Byte offset of the next unread position in the sidecar file */
+	offset: number;
+	/** Partial trailing line from the last read (incomplete JSONL line) */
+	partial: string;
+	/** Whether a retry is currently active (persisted across ticks) */
+	retryActive: boolean;
+}
+
+export function createSidecarTailState(): SidecarTailState {
+	return { offset: 0, partial: "", retryActive: false };
+}
+
+// ── Sidecar Telemetry Delta ───────────────────────────────────────────
+
+/**
+ * Parsed telemetry accumulated from sidecar JSONL events.
+ * Returned by tailSidecarJsonl() on each tick.
+ */
+export interface SidecarTelemetryDelta {
+	/** Per-turn input tokens (sum of new message_end events in this tick) */
+	inputTokens: number;
+	outputTokens: number;
+	cacheReadTokens: number;
+	cacheWriteTokens: number;
+	/** Incremental cost from new message_end events */
+	cost: number;
+	/** Most recent totalTokens from message_end usage (cumulative, for context %) */
+	latestTotalTokens: number;
+	/** Tool calls observed in this tick */
+	toolCalls: number;
+	/** Last tool description from tool_execution_start */
+	lastTool: string;
+	/** Whether a retry is currently active (persisted across ticks via SidecarTailState) */
+	retryActive: boolean;
+	/** Total retries started in this tick */
+	retriesStarted: number;
+	/** Error message from the most recent auto_retry_start */
+	lastRetryError: string;
+	/** Whether any sidecar events were parsed in this tick (used for callback gating) */
+	hadEvents: boolean;
+	/** Authoritative context usage from pi get_session_stats (pi ≥ 0.63.0, null if unavailable) */
+	contextUsage: { percent: number; totalTokens: number; maxTokens: number } | null;
+	/** True when a get_session_stats response was seen but lacked contextUsage (older pi) */
+	sawStatsResponseWithoutContextUsage: boolean;
+}
+
+// ── Incremental JSONL Tailing ─────────────────────────────────────────
+
+/**
+ * Incrementally read new lines from a sidecar JSONL file and parse telemetry events.
+ *
+ * O(new) per call — only reads bytes after the previous offset. Handles:
+ * - File not yet created (returns zero delta)
+ * - Empty reads (no new data since last tick)
+ * - Partial trailing lines (buffered for next call)
+ * - Malformed JSON lines (skipped with stderr warning, does not break iteration)
+ *
+ * The caller (poll loop) accumulates the returned deltas into TaskState.
+ */
+export function tailSidecarJsonl(filePath: string, tailState: SidecarTailState): SidecarTelemetryDelta {
+	const delta: SidecarTelemetryDelta = {
+		inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0,
+		cost: 0, latestTotalTokens: 0, toolCalls: 0, lastTool: "",
+		retryActive: tailState.retryActive, retriesStarted: 0, lastRetryError: "",
+		hadEvents: false, contextUsage: null, sawStatsResponseWithoutContextUsage: false,
+	};
+
+	// Gracefully handle missing file (wrapper hasn't written yet)
+	let fileSize: number;
+	try {
+		fileSize = statSync(filePath).size;
+	} catch {
+		return delta; // File doesn't exist yet — no-op
+	}
+
+	if (fileSize <= tailState.offset) {
+		return delta; // No new data
+	}
+
+	// Read new bytes from offset to end of file
+	const bytesToRead = fileSize - tailState.offset;
+	const buf = Buffer.alloc(bytesToRead);
+	let fd: number;
+	try {
+		fd = openSync(filePath, "r");
+	} catch {
+		return delta; // File became inaccessible between stat and open
+	}
+	try {
+		readSync(fd, buf, 0, bytesToRead, tailState.offset);
+	} catch {
+		closeSync(fd);
+		return delta; // Read error — try again next tick
+	}
+	closeSync(fd);
+	tailState.offset = fileSize;
+
+	// Split into lines, preserving any partial trailing line
+	const chunk = tailState.partial + buf.toString("utf-8");
+	const lines = chunk.split("\n");
+	// Last element is either "" (if chunk ended with \n) or a partial line
+	tailState.partial = lines.pop() || "";
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+
+		let event: any;
+		try {
+			event = JSON.parse(trimmed);
+		} catch {
+			// Malformed JSON — skip silently (concurrent write race, truncated line)
+			continue;
+		}
+
+		if (!event || !event.type) continue;
+
+		delta.hadEvents = true;
+
+		switch (event.type) {
+			case "message_end": {
+				const usage = event.message?.usage;
+				if (usage) {
+					delta.inputTokens += usage.input || 0;
+					delta.outputTokens += usage.output || 0;
+					delta.cacheReadTokens += usage.cacheRead || 0;
+					delta.cacheWriteTokens += usage.cacheWrite || 0;
+					if (usage.cost) {
+						delta.cost += typeof usage.cost === "object"
+							? (usage.cost.total || 0)
+							: (typeof usage.cost === "number" ? usage.cost : 0);
+					}
+					// totalTokens is cumulative (grows each turn) — use latest value.
+					// Include cacheRead tokens: pi's totalTokens and the
+					// input+output fallback both exclude cache reads, but cached
+					// tokens still consume context window capacity.
+					const rawTotal = usage.totalTokens
+						|| ((usage.input || 0) + (usage.output || 0));
+					const totalTokens = rawTotal + (usage.cacheRead || 0);
+					if (totalTokens > delta.latestTotalTokens) {
+						delta.latestTotalTokens = totalTokens;
+					}
+				}
+				break;
+			}
+
+			case "tool_execution_start": {
+				delta.toolCalls++;
+				const toolDesc = event.toolName || "unknown";
+				let argPreview = "";
+				if (event.args) {
+					if (typeof event.args === "string") {
+						argPreview = event.args.slice(0, 80);
+					} else if (typeof event.args === "object") {
+						const firstVal = Object.values(event.args)[0];
+						if (typeof firstVal === "string") {
+							argPreview = (firstVal as string).slice(0, 80);
+						}
+					}
+				}
+				delta.lastTool = argPreview ? `${toolDesc} ${argPreview}` : toolDesc;
+				break;
+			}
+
+			case "auto_retry_start": {
+				delta.retriesStarted++;
+				delta.lastRetryError = event.errorMessage || event.error || "unknown";
+				tailState.retryActive = true;
+				break;
+			}
+
+			case "auto_retry_end": {
+				tailState.retryActive = false;
+				break;
+			}
+
+			case "response": {
+				// get_session_stats response from pi ≥ 0.63.0 — authoritative context usage
+				if (event.success === true && event.data?.contextUsage) {
+					const cu = event.data.contextUsage;
+					// pi sends `percent` (pi ≥ 0.63.0); accept `percentUsed` as legacy fallback
+					const pctValue = cu.percent ?? cu.percentUsed;
+					if (typeof pctValue === "number") {
+						delta.contextUsage = {
+							percent: pctValue,
+							totalTokens: cu.totalTokens || 0,
+							maxTokens: cu.maxTokens || 0,
+						};
+					}
+				} else if (event.success === true && event.data && !event.data.contextUsage) {
+					// Successful get_session_stats response but no contextUsage — older pi
+					delta.sawStatsResponseWithoutContextUsage = true;
+				}
+				break;
+			}
+		}
+	}
+
+	// Reflect persisted retry state into the delta for the caller
+	delta.retryActive = tailState.retryActive;
+	return delta;
+}

package/extensions/taskplane/supervisor-primer.md

@@ -335,6 +335,7 @@ git log --oneline orch/{branch}..task/{lane-branch}  # empty = already merged
    cd /tmp/verify && cd extensions && node --experimental-strip-types --experimental-test-module-mocks --no-warnings --import ./tests/loader.mjs --test tests/*.test.ts
    ```
 5. Update batch state and advance.
+6. **IMPORTANT:** After any manual merge that completes the batch integration, always call `orch_integrate()` to record integration metadata (`integratedAt`, orch branch cleanup, batch history). Without this step, the dashboard will continue showing the batch in the active view rather than the history view, and `batch-state.json` will not reflect the completed integration.
 
 ### Pattern 1b: Merge Agent Stall (TP-056)
 
@@ -379,6 +380,7 @@ completion.
    - Add `mergeResults[N] = { waveIndex: N, status: "succeeded", ... }`
    - Advance `currentWaveIndex` past the merged wave
    - Set `phase = "paused"` for clean resume
+5. **IMPORTANT:** Once all waves are merged and the batch is complete, call `orch_integrate()` to record integration metadata. This ensures the dashboard moves the batch to history view and `integratedAt` is written to `batch-state.json`.
 
 ### Pattern 3: Resume Marks Pending Tasks as Failed
 
@@ -716,6 +718,7 @@ or check status manually. The engine wakes you up when you're needed.
 | `task-failure` | ⚠️ | A task failed after deterministic recovery was exhausted |
 | `merge-failure` | ⚠️ | Wave merge failed and batch paused |
 | `batch-complete` | ✅/⚠️ | Batch finished (all waves done, with or without failures) |
+| `worker-exit-intercept` | 🔄 | A worker exited without making progress — session still alive, awaiting instructions |
 
 ### Alert Format
 
@@ -1009,6 +1012,60 @@ BATCH COMPLETE: {batchId}
 | merge-failure | Agent timeout, no result | `orch_resume(force=true)` to retry | Automatic |
 | batch-complete | All succeeded | Report → suggest `orch_integrate` | Report only |
 | batch-complete | Some failed | Report with failure details | Report only |
+| worker-exit-intercept | Worker analyzing, not editing | `send_agent_message` with targeted instructions | Automatic |
+| worker-exit-intercept | Worker genuinely stuck | "skip" or "let it fail" to close session | Supervised |
+| worker-exit-intercept | Unknown reason | Read STATUS.md, diagnose, then instruct or close | Automatic |
+
+---
+
+## 13c. Worker Exit Interception (TP-172)
+
+When a worker agent produces a text-only response (no tool calls, no file
+edits) without having made visible progress (no checkbox updates), the
+lane-runner **intercepts the exit** instead of closing the session. The worker
+process remains alive with its full conversation context preserved.
+
+**You receive a `worker-exit-intercept` alert** with:
+- Lane number and task ID
+- Current step and unchecked checkboxes
+- Worker's last assistant message (truncated to 500 chars)
+- Iteration count and no-progress count
+
+### Response Protocol
+
+1. **Read the worker's message** — understand why it wants to exit.
+   Common patterns:
+   - "I've analyzed the code and I'm not sure how to proceed"
+   - "I need more information about X"
+   - Generic summary without any file edits
+
+2. **Decide** — based on diagnosis:
+   - **If the worker needs direction:** Send targeted instructions via
+     `send_agent_message(to, content)` with specific guidance on what to
+     implement, which file to edit, or which approach to take.
+   - **If the task is genuinely blocked:** Reply with `"skip"` or
+     `"let it fail"` to close the session normally.
+
+3. **Send your response** — The lane-runner polls for your reply for
+   60 seconds. If you don't respond in time, the session closes and
+   the normal corrective re-spawn mechanism takes over.
+
+### Example Instructions
+
+```
+send_agent_message(
+  to: "orch-henrylach-lane-1-worker",
+  content: "Stop analyzing and start implementing. Edit agent-host.ts line 605:
+    replace the closeStdin() call with the interception logic described in
+    PROMPT.md Step 1. Write the code now — don't read more files."
+)
+```
+
+### Interception Limits
+
+Each worker session can be intercepted at most **2 times** (configurable via
+`maxExitInterceptions`). After the limit is reached, the session closes
+normally and the stall detector handles subsequent iterations.
 
 ---
 

package/extensions/taskplane/supervisor.ts

@@ -1958,7 +1958,7 @@ function parseSupervisorTemplate(filePath: string): { fm: Record<string, string>
 /**
  * Load a supervisor template: base (from package) + local override (from project).
  *
- * Follows the same composition pattern as `loadAgentDef()` in task-runner.ts:
+ * Follows the same composition pattern as `loadAgentDef()`:
  * - Base template: shipped in `templates/agents/{name}.md`
  * - Local override: `.pi/agents/{name}.md` in the project
  * - If local has `standalone: true`, use it exclusively

package/extensions/taskplane/task-executor-core.ts

@@ -1,13 +1,11 @@
 /**
  * Task Executor Core — Headless execution semantics for Runtime V2
  *
- * This module owns the deterministic task execution logic that was
- * previously embedded inside the Pi extension host (task-runner.ts).
+ * This module owns the deterministic task execution logic for headless lane execution.
  * It has NO dependency on Pi's ExtensionAPI, ExtensionContext, UI
  * widgets, session lifecycle, TMUX, or TASK_AUTOSTART.
  *
  * Consumers:
- *   - task-runner.ts (deprecated /task compatibility wrapper)
  *   - lane-runner.ts (Runtime V2 headless lane execution, TP-105)
  *
  * Design rules:
@@ -29,8 +27,7 @@ import { spawnSync } from "child_process";
 /**
  * Parsed step information from PROMPT.md or STATUS.md.
  *
- * Re-exported from the core so consumers don't need to import
- * task-runner.ts for the type definition.
+ * Re-exported from the core for downstream consumers.
  */
 export interface StepInfo {
 	number: number;