taskplane 0.29.2 → 0.30.0

package/extensions/taskplane/persistence.ts

@@ -2,13 +2,50 @@
  * State persistence, serialization, orphan detection
  * @module orch/persistence
  */
-import { readFileSync, writeFileSync, existsSync, unlinkSync, renameSync, mkdirSync, appendFileSync, readdirSync, statSync } from "fs";
+import {
+	readFileSync,
+	writeFileSync,
+	existsSync,
+	unlinkSync,
+	renameSync,
+	mkdirSync,
+	appendFileSync,
+	readdirSync,
+	statSync,
+} from "fs";
 import { join, dirname, basename } from "path";
 
 import { execLog } from "./execution.ts";
-import { BATCH_STATE_SCHEMA_VERSION, StateFileError, batchStatePath, BATCH_HISTORY_MAX_ENTRIES, defaultResilienceState, defaultBatchDiagnostics, runtimeRoot, runtimeManifestPath } from "./types.ts";
+import {
+	BATCH_STATE_SCHEMA_VERSION,
+	StateFileError,
+	batchStatePath,
+	BATCH_HISTORY_MAX_ENTRIES,
+	defaultResilienceState,
+	defaultBatchDiagnostics,
+	runtimeRoot,
+	runtimeManifestPath,
+} from "./types.ts";
 import type { BatchHistorySummary, RuntimeAgentManifest } from "./types.ts";
-import type { AllocatedLane, DiscoveryResult, EngineEvent, EscalationContext, LaneTaskOutcome, LaneTaskStatus, MonitorState, OrchBatchPhase, OrchBatchRuntimeState, PersistedBatchState, PersistedLaneRecord, PersistedMergeResult, PersistedSegmentRecord, PersistedTaskRecord, TaskMonitorSnapshot, Tier0RecoveryPattern, WorkspaceMode } from "./types.ts";
+import type {
+	AllocatedLane,
+	DiscoveryResult,
+	EngineEvent,
+	EscalationContext,
+	LaneTaskOutcome,
+	LaneTaskStatus,
+	MonitorState,
+	OrchBatchPhase,
+	OrchBatchRuntimeState,
+	PersistedBatchState,
+	PersistedLaneRecord,
+	PersistedMergeResult,
+	PersistedSegmentRecord,
+	PersistedTaskRecord,
+	TaskMonitorSnapshot,
+	Tier0RecoveryPattern,
+	WorkspaceMode,
+} from "./types.ts";
 import { sleepSync } from "./worktree.ts";
 import type { PreserveFailedLaneProgressResult } from "./worktree.ts";
 import { normalizeLaneSessionAlias, readLaneSessionAliases } from "./tmux-compat.ts";
@@ -53,23 +90,28 @@ export function hasTaskDoneMarker(taskFolder: string): boolean {
 /**
  * Compare optional embedded outcome telemetry.
  */
-function sameOutcomeTelemetry(a: LaneTaskOutcome["telemetry"], b: LaneTaskOutcome["telemetry"]): boolean {
+function sameOutcomeTelemetry(
+	a: LaneTaskOutcome["telemetry"],
+	b: LaneTaskOutcome["telemetry"],
+): boolean {
 	if (!a && !b) return true;
 	if (!a || !b) return false;
-	return a.inputTokens === b.inputTokens
-		&& a.outputTokens === b.outputTokens
-		&& a.cacheReadTokens === b.cacheReadTokens
-		&& a.cacheWriteTokens === b.cacheWriteTokens
-		&& a.costUsd === b.costUsd
-		&& a.toolCalls === b.toolCalls
-		&& a.durationMs === b.durationMs;
+	return (
+		a.inputTokens === b.inputTokens &&
+		a.outputTokens === b.outputTokens &&
+		a.cacheReadTokens === b.cacheReadTokens &&
+		a.cacheWriteTokens === b.cacheWriteTokens &&
+		a.costUsd === b.costUsd &&
+		a.toolCalls === b.toolCalls &&
+		a.durationMs === b.durationMs
+	);
 }
 
 /**
  * Upsert a task outcome in-place. Returns true if changed.
  */
 export function upsertTaskOutcome(outcomes: LaneTaskOutcome[], next: LaneTaskOutcome): boolean {
-	const idx = outcomes.findIndex(o => o.taskId === next.taskId);
+	const idx = outcomes.findIndex((o) => o.taskId === next.taskId);
 	if (idx < 0) {
 		outcomes.push(next);
 		return true;
@@ -120,7 +162,7 @@ export function applyPartialProgressToOutcomes(
 	let updated = 0;
 	for (const r of ppResult.results) {
 		if (!r.saved || !r.savedBranch) continue;
-		const outcome = outcomes.find(o => o.taskId === r.taskId);
+		const outcome = outcomes.find((o) => o.taskId === r.taskId);
 		if (outcome) {
 			outcome.partialProgressCommits = r.commitCount;
 			outcome.partialProgressBranch = r.savedBranch;
@@ -143,18 +185,19 @@ export function seedPendingOutcomesForAllocatedLanes(
 	let changed = false;
 	for (const lane of lanes) {
 		for (const laneTask of lane.tasks) {
-			const existing = outcomes.find(o => o.taskId === laneTask.taskId);
+			const existing = outcomes.find((o) => o.taskId === laneTask.taskId);
 			if (existing) continue;
-			changed = upsertTaskOutcome(outcomes, {
-				taskId: laneTask.taskId,
-				status: "pending",
-				startTime: null,
-				endTime: null,
-				exitReason: "Pending execution",
-				sessionName: lane.laneSessionId,
-				doneFileFound: false,
-				laneNumber: lane.laneNumber,
-			}) || changed;
+			changed =
+				upsertTaskOutcome(outcomes, {
+					taskId: laneTask.taskId,
+					status: "pending",
+					startTime: null,
+					endTime: null,
+					exitReason: "Pending execution",
+					sessionName: lane.laneSessionId,
+					doneFileFound: false,
+					laneNumber: lane.laneNumber,
+				}) || changed;
 		}
 	}
 	return changed;
@@ -175,70 +218,78 @@ export function syncTaskOutcomesFromMonitor(
 	for (const lane of monitorState.lanes) {
 		// Remaining tasks => pending
 		for (const taskId of lane.remainingTasks) {
-			const existing = outcomes.find(o => o.taskId === taskId);
-			if (existing && (existing.status === "succeeded" || existing.status === "failed" || existing.status === "stalled")) {
+			const existing = outcomes.find((o) => o.taskId === taskId);
+			if (
+				existing &&
+				(existing.status === "succeeded" ||
+					existing.status === "failed" ||
+					existing.status === "stalled")
+			) {
 				continue;
 			}
-			changed = upsertTaskOutcome(outcomes, {
-				taskId,
-				status: "pending",
-				startTime: existing?.startTime ?? null,
-				endTime: null,
-				exitReason: existing?.exitReason || "Pending execution",
-				sessionName: existing?.sessionName || lane.sessionName,
-				doneFileFound: false,
-				laneNumber: existing?.laneNumber ?? lane.laneNumber,
-				telemetry: existing?.telemetry,
-				partialProgressCommits: existing?.partialProgressCommits,
-				partialProgressBranch: existing?.partialProgressBranch,
-				exitDiagnostic: existing?.exitDiagnostic,
-			}) || changed;
+			changed =
+				upsertTaskOutcome(outcomes, {
+					taskId,
+					status: "pending",
+					startTime: existing?.startTime ?? null,
+					endTime: null,
+					exitReason: existing?.exitReason || "Pending execution",
+					sessionName: existing?.sessionName || lane.sessionName,
+					doneFileFound: false,
+					laneNumber: existing?.laneNumber ?? lane.laneNumber,
+					telemetry: existing?.telemetry,
+					partialProgressCommits: existing?.partialProgressCommits,
+					partialProgressBranch: existing?.partialProgressBranch,
+					exitDiagnostic: existing?.exitDiagnostic,
+				}) || changed;
 		}
 
 		// Completed tasks => succeeded
 		// Use existing endTime if already set — prevents changed=true on every
 		// poll tick (lastPollTime differs each tick, causing persist log spam).
 		for (const taskId of lane.completedTasks) {
-			const existing = outcomes.find(o => o.taskId === taskId);
-			changed = upsertTaskOutcome(outcomes, {
-				taskId,
-				status: "succeeded",
-				startTime: existing?.startTime ?? null,
-				endTime: existing?.endTime ?? monitorState.lastPollTime,
-				exitReason: existing?.exitReason || ".DONE file created by task-runner",
-				sessionName: existing?.sessionName || lane.sessionName,
-				doneFileFound: true,
-				laneNumber: existing?.laneNumber ?? lane.laneNumber,
-				telemetry: existing?.telemetry,
-				partialProgressCommits: existing?.partialProgressCommits,
-				partialProgressBranch: existing?.partialProgressBranch,
-				exitDiagnostic: existing?.exitDiagnostic,
-			}) || changed;
+			const existing = outcomes.find((o) => o.taskId === taskId);
+			changed =
+				upsertTaskOutcome(outcomes, {
+					taskId,
+					status: "succeeded",
+					startTime: existing?.startTime ?? null,
+					endTime: existing?.endTime ?? monitorState.lastPollTime,
+					exitReason: existing?.exitReason || ".DONE file created by task-runner",
+					sessionName: existing?.sessionName || lane.sessionName,
+					doneFileFound: true,
+					laneNumber: existing?.laneNumber ?? lane.laneNumber,
+					telemetry: existing?.telemetry,
+					partialProgressCommits: existing?.partialProgressCommits,
+					partialProgressBranch: existing?.partialProgressBranch,
+					exitDiagnostic: existing?.exitDiagnostic,
+				}) || changed;
 		}
 
 		// Failed tasks => failed
 		for (const taskId of lane.failedTasks) {
-			const existing = outcomes.find(o => o.taskId === taskId);
-			changed = upsertTaskOutcome(outcomes, {
-				taskId,
-				status: "failed",
-				startTime: existing?.startTime ?? null,
-				endTime: existing?.endTime ?? monitorState.lastPollTime,
-				exitReason: existing?.exitReason || "Task failed or stalled",
-				sessionName: existing?.sessionName || lane.sessionName,
-				doneFileFound: false,
-				laneNumber: existing?.laneNumber ?? lane.laneNumber,
-				telemetry: existing?.telemetry,
-				partialProgressCommits: existing?.partialProgressCommits,
-				partialProgressBranch: existing?.partialProgressBranch,
-				exitDiagnostic: existing?.exitDiagnostic,
-			}) || changed;
+			const existing = outcomes.find((o) => o.taskId === taskId);
+			changed =
+				upsertTaskOutcome(outcomes, {
+					taskId,
+					status: "failed",
+					startTime: existing?.startTime ?? null,
+					endTime: existing?.endTime ?? monitorState.lastPollTime,
+					exitReason: existing?.exitReason || "Task failed or stalled",
+					sessionName: existing?.sessionName || lane.sessionName,
+					doneFileFound: false,
+					laneNumber: existing?.laneNumber ?? lane.laneNumber,
+					telemetry: existing?.telemetry,
+					partialProgressCommits: existing?.partialProgressCommits,
+					partialProgressBranch: existing?.partialProgressBranch,
+					exitDiagnostic: existing?.exitDiagnostic,
+				}) || changed;
 		}
 
 		// Current task snapshot => running/stalled/succeeded/failed/skipped
 		if (lane.currentTaskId && lane.currentTaskSnapshot) {
 			const snap = lane.currentTaskSnapshot;
-			const existing = outcomes.find(o => o.taskId === lane.currentTaskId);
+			const existing = outcomes.find((o) => o.taskId === lane.currentTaskId);
 			const monitorToLane: Record<TaskMonitorSnapshot["status"], LaneTaskStatus> = {
 				pending: "pending",
 				running: "running",
@@ -249,26 +300,35 @@ export function syncTaskOutcomesFromMonitor(
 				unknown: existing?.status || "running",
 			};
 			const mappedStatus = monitorToLane[snap.status];
-			const terminal = mappedStatus === "succeeded" || mappedStatus === "failed" || mappedStatus === "stalled" || mappedStatus === "skipped";
+			const terminal =
+				mappedStatus === "succeeded" ||
+				mappedStatus === "failed" ||
+				mappedStatus === "stalled" ||
+				mappedStatus === "skipped";
 
 			// TP-051: Use snap.observedAt (Date.now() from monitor poll) instead of
 			// snap.lastHeartbeat (STATUS.md mtime) for task start time. The mtime
 			// reflects when STATUS.md was last edited, which may be long before
 			// actual execution started (e.g., during task staging).
-			changed = upsertTaskOutcome(outcomes, {
-				taskId: lane.currentTaskId,
-				status: mappedStatus,
-				startTime: existing?.startTime ?? snap.observedAt,
-				endTime: terminal ? (existing?.endTime ?? snap.observedAt) : null,
-				exitReason: existing?.exitReason || (mappedStatus === "running" ? "Task in progress" : (snap.stallReason || "Task reached terminal state")),
-				sessionName: existing?.sessionName || lane.sessionName,
-				doneFileFound: snap.doneFileFound,
-				laneNumber: existing?.laneNumber ?? lane.laneNumber,
-				telemetry: existing?.telemetry,
-				partialProgressCommits: existing?.partialProgressCommits,
-				partialProgressBranch: existing?.partialProgressBranch,
-				exitDiagnostic: existing?.exitDiagnostic,
-			}) || changed;
+			changed =
+				upsertTaskOutcome(outcomes, {
+					taskId: lane.currentTaskId,
+					status: mappedStatus,
+					startTime: existing?.startTime ?? snap.observedAt,
+					endTime: terminal ? (existing?.endTime ?? snap.observedAt) : null,
+					exitReason:
+						existing?.exitReason ||
+						(mappedStatus === "running"
+							? "Task in progress"
+							: snap.stallReason || "Task reached terminal state"),
+					sessionName: existing?.sessionName || lane.sessionName,
+					doneFileFound: snap.doneFileFound,
+					laneNumber: existing?.laneNumber ?? lane.laneNumber,
+					telemetry: existing?.telemetry,
+					partialProgressCommits: existing?.partialProgressCommits,
+					partialProgressBranch: existing?.partialProgressBranch,
+					exitDiagnostic: existing?.exitDiagnostic,
+				}) || changed;
 		}
 	}
 
@@ -322,13 +382,19 @@ export function persistRuntimeState(
 					if ((taskRecord as any).packetRepoId === undefined && parsedTask.packetRepoId !== undefined) {
 						(taskRecord as any).packetRepoId = parsedTask.packetRepoId;
 					}
-					if ((taskRecord as any).packetTaskPath === undefined && parsedTask.packetTaskPath !== undefined) {
+					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) {
+					if (
+						(taskRecord as any).activeSegmentId === undefined &&
+						parsedTask.activeSegmentId !== undefined
+					) {
 						(taskRecord as any).activeSegmentId = parsedTask.activeSegmentId;
 					}
 				}
@@ -344,9 +410,12 @@ export function persistRuntimeState(
 			waveIndex: batchState.currentWaveIndex,
 		});
 	} catch (err: unknown) {
-		const msg = err instanceof StateFileError
-			? `[${err.code}] ${err.message}`
-			: (err instanceof Error ? err.message : String(err));
+		const msg =
+			err instanceof StateFileError
+				? `[${err.code}] ${err.message}`
+				: err instanceof Error
+					? err.message
+					: String(err);
 		execLog("state", batchState.batchId, `write failed: ${msg}`, {
 			reason,
 			phase: batchState.phase,
@@ -355,22 +424,36 @@ export function persistRuntimeState(
 	}
 }
 
-
 // ── State Validation ─────────────────────────────────────────────────
 
 /** All valid OrchBatchPhase values for validation. */
 export const VALID_BATCH_PHASES: ReadonlySet<string> = new Set([
-	"idle", "launching", "planning", "executing", "merging", "paused", "stopped", "completed", "failed",
+	"idle",
+	"launching",
+	"planning",
+	"executing",
+	"merging",
+	"paused",
+	"stopped",
+	"completed",
+	"failed",
 ]);
 
 /** All valid LaneTaskStatus values for validation. */
 export const VALID_TASK_STATUSES: ReadonlySet<string> = new Set([
-	"pending", "running", "succeeded", "failed", "stalled", "skipped",
+	"pending",
+	"running",
+	"succeeded",
+	"failed",
+	"stalled",
+	"skipped",
 ]);
 
 /** All valid merge result statuses for persisted state. */
 export const VALID_PERSISTED_MERGE_STATUSES: ReadonlySet<string> = new Set([
-	"succeeded", "failed", "partial",
+	"succeeded",
+	"failed",
+	"partial",
 ]);
 
 /**
@@ -462,10 +545,7 @@ export function upconvertV3toV4(obj: Record<string, unknown>): void {
  */
 export function validatePersistedState(data: unknown): PersistedBatchState {
 	if (!data || typeof data !== "object") {
-		throw new StateFileError(
-			"STATE_SCHEMA_INVALID",
-			"Batch state must be a non-null object",
-		);
+		throw new StateFileError("STATE_SCHEMA_INVALID", "Batch state must be a non-null object");
 	}
 
 	const obj = data as Record<string, unknown>;
@@ -484,8 +564,8 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 		throw new StateFileError(
 			"STATE_SCHEMA_INVALID",
 			`Unsupported schema version ${obj.schemaVersion} (expected ${BATCH_STATE_SCHEMA_VERSION}). ` +
-			`Upgrade taskplane to a version that supports schema v${obj.schemaVersion}, ` +
-			`or delete .pi/batch-state.json and re-run the batch.`,
+				`Upgrade taskplane to a version that supports schema v${obj.schemaVersion}, ` +
+				`or delete .pi/batch-state.json and re-run the batch.`,
 		);
 	}
 	const isV1 = obj.schemaVersion === 1;
@@ -552,8 +632,15 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 
 	// ── Required number fields ───────────────────────────────────
 	for (const field of [
-		"startedAt", "updatedAt", "currentWaveIndex", "totalWaves",
-		"totalTasks", "succeededTasks", "failedTasks", "skippedTasks", "blockedTasks",
+		"startedAt",
+		"updatedAt",
+		"currentWaveIndex",
+		"totalWaves",
+		"totalTasks",
+		"succeededTasks",
+		"failedTasks",
+		"skippedTasks",
+		"blockedTasks",
 	] as const) {
 		if (typeof obj[field] !== "number") {
 			throw new StateFileError(
@@ -572,7 +659,14 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	}
 
 	// ── Required arrays ──────────────────────────────────────────
-	for (const field of ["wavePlan", "lanes", "tasks", "mergeResults", "blockedTaskIds", "errors"] as const) {
+	for (const field of [
+		"wavePlan",
+		"lanes",
+		"tasks",
+		"mergeResults",
+		"blockedTaskIds",
+		"errors",
+	] as const) {
 		if (!Array.isArray(obj[field])) {
 			throw new StateFileError(
 				"STATE_SCHEMA_INVALID",
@@ -585,10 +679,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	const wavePlan = obj.wavePlan as unknown[];
 	for (let i = 0; i < wavePlan.length; i++) {
 		if (!Array.isArray(wavePlan[i])) {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`wavePlan[${i}] is not an array`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `wavePlan[${i}] is not an array`);
 		}
 		for (const taskId of wavePlan[i] as unknown[]) {
 			if (typeof taskId !== "string") {
@@ -605,10 +696,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	for (let i = 0; i < tasks.length; i++) {
 		const t = tasks[i] as Record<string, unknown>;
 		if (!t || typeof t !== "object") {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`tasks[${i}] is not an object`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `tasks[${i}] is not an object`);
 		}
 		for (const field of ["taskId", "sessionName", "taskFolder", "exitReason"] as const) {
 			if (typeof t[field] !== "string") {
@@ -637,10 +725,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 			);
 		}
 		if (t.endedAt !== null && typeof t.endedAt !== "number") {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`tasks[${i}].endedAt is not a number or null`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `tasks[${i}].endedAt is not a number or null`);
 		}
 		if (typeof t.doneFileFound !== "boolean") {
 			throw new StateFileError(
@@ -676,7 +761,11 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 		}
 		// TP-026 optional field: exitDiagnostic (object with classification string | undefined)
 		if (t.exitDiagnostic !== undefined) {
-			if (typeof t.exitDiagnostic !== "object" || t.exitDiagnostic === null || Array.isArray(t.exitDiagnostic)) {
+			if (
+				typeof t.exitDiagnostic !== "object" ||
+				t.exitDiagnostic === null ||
+				Array.isArray(t.exitDiagnostic)
+			) {
 				throw new StateFileError(
 					"STATE_SCHEMA_INVALID",
 					`tasks[${i}].exitDiagnostic is not a plain object (got ${Array.isArray(t.exitDiagnostic) ? "array" : typeof t.exitDiagnostic})`,
@@ -697,10 +786,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	for (let i = 0; i < lanes.length; i++) {
 		const l = lanes[i] as Record<string, unknown>;
 		if (!l || typeof l !== "object") {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`lanes[${i}] is not an object`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `lanes[${i}] is not an object`);
 		}
 		for (const field of ["laneId", "worktreePath", "branch"] as const) {
 			if (typeof l[field] !== "string") {
@@ -763,7 +849,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	if (legacyTmuxSessionLaneIndexes.length > 0) {
 		console.error(
 			"[taskplane] migration: detected legacy lanes[].tmuxSessionName in .pi/batch-state.json; " +
-			"normalized to lanes[].laneSessionId for this release. Re-save state (or re-run /orch-resume) to persist canonical fields.",
+				"normalized to lanes[].laneSessionId for this release. Re-save state (or re-run /orch-resume) to persist canonical fields.",
 		);
 	}
 
@@ -772,10 +858,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	for (let i = 0; i < mergeResults.length; i++) {
 		const m = mergeResults[i] as Record<string, unknown>;
 		if (!m || typeof m !== "object") {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`mergeResults[${i}] is not an object`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `mergeResults[${i}] is not an object`);
 		}
 		if (typeof m.waveIndex !== "number") {
 			throw new StateFileError(
@@ -824,10 +907,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	// ── Validate lastError ───────────────────────────────────────
 	if (obj.lastError !== null) {
 		if (typeof obj.lastError !== "object") {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`lastError is not an object or null`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `lastError is not an object or null`);
 		}
 		const le = obj.lastError as Record<string, unknown>;
 		if (typeof le.code !== "string" || typeof le.message !== "string") {
@@ -881,7 +961,11 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 			`resilience.resumeForced must be a boolean (got ${typeof res.resumeForced})`,
 		);
 	}
-	if (!res.retryCountByScope || typeof res.retryCountByScope !== "object" || Array.isArray(res.retryCountByScope)) {
+	if (
+		!res.retryCountByScope ||
+		typeof res.retryCountByScope !== "object" ||
+		Array.isArray(res.retryCountByScope)
+	) {
 		throw new StateFileError(
 			"STATE_SCHEMA_INVALID",
 			`resilience.retryCountByScope must be an object (got ${typeof res.retryCountByScope})`,
@@ -1064,7 +1148,11 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 			}
 		}
 		// v4 optional field: activeSegmentId (string | null | undefined)
-		if (t.activeSegmentId !== undefined && t.activeSegmentId !== null && typeof t.activeSegmentId !== "string") {
+		if (
+			t.activeSegmentId !== undefined &&
+			t.activeSegmentId !== null &&
+			typeof t.activeSegmentId !== "string"
+		) {
 			throw new StateFileError(
 				"STATE_SCHEMA_INVALID",
 				`tasks[${i}].activeSegmentId is not a string or null (got ${typeof t.activeSegmentId})`,
@@ -1083,13 +1171,19 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	for (let i = 0; i < segments.length; i++) {
 		const s = segments[i] as Record<string, unknown>;
 		if (!s || typeof s !== "object") {
-			throw new StateFileError(
-				"STATE_SCHEMA_INVALID",
-				`segments[${i}] is not an object`,
-			);
+			throw new StateFileError("STATE_SCHEMA_INVALID", `segments[${i}] is not an object`);
 		}
 		// Required string fields
-		for (const field of ["segmentId", "taskId", "repoId", "laneId", "sessionName", "worktreePath", "branch", "exitReason"] as const) {
+		for (const field of [
+			"segmentId",
+			"taskId",
+			"repoId",
+			"laneId",
+			"sessionName",
+			"worktreePath",
+			"branch",
+			"exitReason",
+		] as const) {
 			if (typeof s[field] !== "string") {
 				throw new StateFileError(
 					"STATE_SCHEMA_INVALID",
@@ -1153,7 +1247,11 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 		}
 		// Optional exitDiagnostic
 		if (s.exitDiagnostic !== undefined) {
-			if (!s.exitDiagnostic || typeof s.exitDiagnostic !== "object" || Array.isArray(s.exitDiagnostic)) {
+			if (
+				!s.exitDiagnostic ||
+				typeof s.exitDiagnostic !== "object" ||
+				Array.isArray(s.exitDiagnostic)
+			) {
 				throw new StateFileError(
 					"STATE_SCHEMA_INVALID",
 					`segments[${i}].exitDiagnostic is not a plain object (got ${Array.isArray(s.exitDiagnostic) ? "array" : typeof s.exitDiagnostic})`,
@@ -1173,12 +1271,31 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 	// serialization. This protects against data loss from future schema
 	// extensions or external tools writing additional fields.
 	const KNOWN_TOP_LEVEL_FIELDS = new Set([
-		"schemaVersion", "phase", "batchId", "baseBranch", "orchBranch", "mode",
-		"startedAt", "updatedAt", "endedAt", "currentWaveIndex", "totalWaves",
-		"wavePlan", "lanes", "tasks", "mergeResults",
-		"totalTasks", "succeededTasks", "failedTasks", "skippedTasks", "blockedTasks",
-		"blockedTaskIds", "lastError", "errors",
-		"resilience", "diagnostics",
+		"schemaVersion",
+		"phase",
+		"batchId",
+		"baseBranch",
+		"orchBranch",
+		"mode",
+		"startedAt",
+		"updatedAt",
+		"endedAt",
+		"currentWaveIndex",
+		"totalWaves",
+		"wavePlan",
+		"lanes",
+		"tasks",
+		"mergeResults",
+		"totalTasks",
+		"succeededTasks",
+		"failedTasks",
+		"skippedTasks",
+		"blockedTasks",
+		"blockedTaskIds",
+		"lastError",
+		"errors",
+		"resilience",
+		"diagnostics",
 		"segments",
 		"_extraFields",
 	]);
@@ -1241,69 +1358,70 @@ export function serializeBatchState(
 	}
 
 	// Build a lookup from taskId → AllocatedTask (which holds the ParsedTask with repo fields).
-	const allocatedTaskByTaskId = new Map<string, { allocatedTask: import("./types.ts").AllocatedTask; lane: AllocatedLane }>();
+	const allocatedTaskByTaskId = new Map<
+		string,
+		{ allocatedTask: import("./types.ts").AllocatedTask; lane: AllocatedLane }
+	>();
 	for (const lane of lanes) {
 		for (const allocTask of lane.tasks) {
 			allocatedTaskByTaskId.set(allocTask.taskId, { allocatedTask: allocTask, lane });
 		}
 	}
 
-	const taskRecords: PersistedTaskRecord[] = [...taskIdSet]
-		.sort()
-		.map((taskId) => {
-			const lane = laneByTaskId.get(taskId);
-			const outcome = outcomeByTaskId.get(taskId);
-			const allocated = allocatedTaskByTaskId.get(taskId);
+	const taskRecords: PersistedTaskRecord[] = [...taskIdSet].sort().map((taskId) => {
+		const lane = laneByTaskId.get(taskId);
+		const outcome = outcomeByTaskId.get(taskId);
+		const allocated = allocatedTaskByTaskId.get(taskId);
 
-			const record: PersistedTaskRecord = {
-				taskId,
-				laneNumber: lane?.laneNumber ?? outcome?.laneNumber ?? 0,
-				sessionName: outcome?.sessionName || lane?.laneSessionId || "",
-				status: outcome?.status ?? "pending",
-				taskFolder: "", // Enriched by caller from discovery
-				startedAt: outcome?.startTime ?? null,
-				endedAt: outcome?.endTime ?? null,
-				doneFileFound: outcome?.doneFileFound ?? false,
-				exitReason: outcome?.exitReason ?? "",
-			};
+		const record: PersistedTaskRecord = {
+			taskId,
+			laneNumber: lane?.laneNumber ?? outcome?.laneNumber ?? 0,
+			sessionName: outcome?.sessionName || lane?.laneSessionId || "",
+			status: outcome?.status ?? "pending",
+			taskFolder: "", // Enriched by caller from discovery
+			startedAt: outcome?.startTime ?? null,
+			endedAt: outcome?.endTime ?? null,
+			doneFileFound: outcome?.doneFileFound ?? false,
+			exitReason: outcome?.exitReason ?? "",
+		};
 
-			// v2: Serialize repo-aware fields from the ParsedTask
-			if (allocated?.allocatedTask.task?.promptRepoId !== undefined) {
-				record.repoId = allocated.allocatedTask.task.promptRepoId;
-			}
-			if (allocated?.allocatedTask.task?.resolvedRepoId !== undefined) {
-				record.resolvedRepoId = allocated.allocatedTask.task.resolvedRepoId;
-			}
+		// v2: Serialize repo-aware fields from the ParsedTask
+		if (allocated?.allocatedTask.task?.promptRepoId !== undefined) {
+			record.repoId = allocated.allocatedTask.task.promptRepoId;
+		}
+		if (allocated?.allocatedTask.task?.resolvedRepoId !== undefined) {
+			record.resolvedRepoId = allocated.allocatedTask.task.resolvedRepoId;
+		}
 
-			// TP-028: Serialize partial progress fields from task outcome
-			if (outcome?.partialProgressCommits !== undefined) {
-				record.partialProgressCommits = outcome.partialProgressCommits;
-			}
-			if (outcome?.partialProgressBranch !== undefined) {
-				record.partialProgressBranch = outcome.partialProgressBranch;
-			}
+		// TP-028: Serialize partial progress fields from task outcome
+		if (outcome?.partialProgressCommits !== undefined) {
+			record.partialProgressCommits = outcome.partialProgressCommits;
+		}
+		if (outcome?.partialProgressBranch !== undefined) {
+			record.partialProgressBranch = outcome.partialProgressBranch;
+		}
 
-			// TP-030 v3: Serialize exit diagnostic from task outcome
-			if (outcome?.exitDiagnostic !== undefined) {
-				record.exitDiagnostic = outcome.exitDiagnostic;
-			}
+		// TP-030 v3: Serialize exit diagnostic from task outcome
+		if (outcome?.exitDiagnostic !== undefined) {
+			record.exitDiagnostic = outcome.exitDiagnostic;
+		}
 
-			// TP-081 v4: Serialize segment-level fields from ParsedTask or existing state
-			if (allocated?.allocatedTask.task?.packetRepoId !== undefined) {
-				(record as any).packetRepoId = allocated.allocatedTask.task.packetRepoId;
-			}
-			if (allocated?.allocatedTask.task?.packetTaskPath !== undefined) {
-				(record as any).packetTaskPath = allocated.allocatedTask.task.packetTaskPath;
-			}
-			if (allocated?.allocatedTask.task?.segmentIds !== undefined) {
-				(record as any).segmentIds = allocated.allocatedTask.task.segmentIds;
-			}
-			if (allocated?.allocatedTask.task?.activeSegmentId !== undefined) {
-				(record as any).activeSegmentId = allocated.allocatedTask.task.activeSegmentId;
-			}
+		// TP-081 v4: Serialize segment-level fields from ParsedTask or existing state
+		if (allocated?.allocatedTask.task?.packetRepoId !== undefined) {
+			(record as any).packetRepoId = allocated.allocatedTask.task.packetRepoId;
+		}
+		if (allocated?.allocatedTask.task?.packetTaskPath !== undefined) {
+			(record as any).packetTaskPath = allocated.allocatedTask.task.packetTaskPath;
+		}
+		if (allocated?.allocatedTask.task?.segmentIds !== undefined) {
+			(record as any).segmentIds = allocated.allocatedTask.task.segmentIds;
+		}
+		if (allocated?.allocatedTask.task?.activeSegmentId !== undefined) {
+			(record as any).activeSegmentId = allocated.allocatedTask.task.activeSegmentId;
+		}
 
-			return record;
-		});
+		return record;
+	});
 
 	// Build lane records
 	const laneRecords: PersistedLaneRecord[] = lanes.map((lane) => {
@@ -1326,26 +1444,25 @@ export function serializeBatchState(
 	// 0-based for PersistedMergeResult (dashboard renders as "Wave N+1").
 	// Clamp to 0 minimum: resume re-exec merges use sentinel waveIndex -1,
 	// which would produce -2 without clamping.
-	const mergeResults: PersistedMergeResult[] = (state.mergeResults || [])
-		.map((mr) => {
-			const record: PersistedMergeResult = {
-				waveIndex: Math.max(0, mr.waveIndex - 1),
-				status: mr.status,
-				failedLane: mr.failedLane,
-				failureReason: mr.failureReason,
-			};
-			// v2 (TP-009): Serialize per-repo merge outcomes when available (workspace mode).
-			if (mr.repoResults && mr.repoResults.length > 0) {
-				record.repoResults = mr.repoResults.map((rr) => ({
-					repoId: rr.repoId,
-					status: rr.status,
-					laneNumbers: rr.laneResults.map((lr) => lr.laneNumber),
-					failedLane: rr.failedLane,
-					failureReason: rr.failureReason,
-				}));
-			}
-			return record;
-		});
+	const mergeResults: PersistedMergeResult[] = (state.mergeResults || []).map((mr) => {
+		const record: PersistedMergeResult = {
+			waveIndex: Math.max(0, mr.waveIndex - 1),
+			status: mr.status,
+			failedLane: mr.failedLane,
+			failureReason: mr.failureReason,
+		};
+		// v2 (TP-009): Serialize per-repo merge outcomes when available (workspace mode).
+		if (mr.repoResults && mr.repoResults.length > 0) {
+			record.repoResults = mr.repoResults.map((rr) => ({
+				repoId: rr.repoId,
+				status: rr.status,
+				laneNumbers: rr.laneResults.map((lr) => lr.laneNumber),
+				failedLane: rr.failedLane,
+				failureReason: rr.failureReason,
+			}));
+		}
+		return record;
+	});
 
 	const persisted: PersistedBatchState = {
 		schemaVersion: BATCH_STATE_SCHEMA_VERSION,
@@ -1372,9 +1489,10 @@ export function serializeBatchState(
 		skippedTasks: state.skippedTasks,
 		blockedTasks: state.blockedTasks,
 		blockedTaskIds: [...state.blockedTaskIds],
-		lastError: state.errors.length > 0
-			? { code: "BATCH_ERROR", message: state.errors[state.errors.length - 1] }
-			: null,
+		lastError:
+			state.errors.length > 0
+				? { code: "BATCH_ERROR", message: state.errors[state.errors.length - 1] }
+				: null,
 		errors: [...state.errors],
 		resilience: state.resilience ?? defaultResilienceState(),
 		diagnostics: state.diagnostics ?? defaultBatchDiagnostics(),
@@ -1385,7 +1503,11 @@ export function serializeBatchState(
 	// Extra fields are placed at the end of the object (after known schema fields)
 	// and will not overwrite any known field.
 	if (state._extraFields) {
-		const output = persisted as Record<string, unknown>;
+		// TP-195: 2-step `as unknown as` widening. PersistedBatchState is
+		// structurally a string-keyed record at runtime; the cast lets us
+		// add unknown extra fields for serialization roundtrip fidelity
+		// without TypeScript requiring sufficient type overlap.
+		const output = persisted as unknown as Record<string, unknown>;
 		for (const [key, value] of Object.entries(state._extraFields)) {
 			if (!(key in output)) {
 				output[key] = value;
@@ -1461,12 +1583,16 @@ export function saveBatchState(json: string, repoRoot: string): void {
 	}
 
 	// All retries exhausted — clean up temp file if possible
-	try { unlinkSync(tmpPath); } catch { /* ignore cleanup errors */ }
+	try {
+		unlinkSync(tmpPath);
+	} catch {
+		/* ignore cleanup errors */
+	}
 
 	throw new StateFileError(
 		"STATE_FILE_IO_ERROR",
 		`Failed to atomically save state file "${finalPath}" after ` +
-		`${STATE_WRITE_MAX_RETRIES} attempts: ${lastError?.message ?? "unknown error"}`,
+			`${STATE_WRITE_MAX_RETRIES} attempts: ${lastError?.message ?? "unknown error"}`,
 	);
 }
 
@@ -1533,7 +1659,6 @@ export function deleteBatchState(repoRoot: string): void {
 	}
 }
 
-
 // ── Orphan Detection (TS-009 Step 3) ─────────────────────────────────
 
 /**
@@ -1555,7 +1680,12 @@ export type OrphanStateStatus = "valid" | "missing" | "invalid" | "io-error";
  * - "paused-corrupt" — No orphans + corrupt/unreadable state file: do NOT auto-delete; notify user to inspect or manually remove
  * - "start-fresh"    — No orphans, no state file: proceed normally
  */
-export type OrphanRecommendedAction = "resume" | "abort-orphans" | "cleanup-stale" | "paused-corrupt" | "start-fresh";
+export type OrphanRecommendedAction =
+	| "resume"
+	| "abort-orphans"
+	| "cleanup-stale"
+	| "paused-corrupt"
+	| "start-fresh";
 
 /**
  * Result of orphan detection analysis.
@@ -1597,8 +1727,8 @@ export function parseOrchSessionNames(stdout: string, prefix: string): string[]
 
 	return stdout
 		.split("\n")
-		.map(line => line.trim())
-		.filter(name => name.length > 0 && name.startsWith(filterPrefix))
+		.map((line) => line.trim())
+		.filter((name) => name.length > 0 && name.startsWith(filterPrefix))
 		.sort();
 }
 
@@ -1687,8 +1817,8 @@ export function analyzeOrchestratorStartupState(
 
 	if (stateStatus === "valid" && loadedState) {
 		// Check if all tasks completed (all have .DONE files)
-		const allTaskIds = loadedState.tasks.map(t => t.taskId);
-		const allDone = allTaskIds.length > 0 && allTaskIds.every(id => doneTaskIds.has(id));
+		const allTaskIds = loadedState.tasks.map((t) => t.taskId);
+		const allDone = allTaskIds.length > 0 && allTaskIds.every((id) => doneTaskIds.has(id));
 
 		if (allDone) {
 			return {
@@ -1704,7 +1834,7 @@ export function analyzeOrchestratorStartupState(
 		}
 
 		// Not all tasks done — batch was interrupted (crashed orchestrator)
-		const completedCount = allTaskIds.filter(id => doneTaskIds.has(id)).length;
+		const completedCount = allTaskIds.filter((id) => doneTaskIds.has(id)).length;
 
 		// Only phases that resumeOrchBatch can actually handle should get "resume".
 		// "failed" / "stopped" / "idle" / "planning" are non-resumable — if nothing
@@ -1734,10 +1864,10 @@ export function analyzeOrchestratorStartupState(
 			recommendedAction: isResumable ? "resume" : "cleanup-stale",
 			userMessage: isResumable
 				? `🔄 Found interrupted batch ${loadedState.batchId} (${loadedState.phase}).\n` +
-				  `   ${completedCount}/${allTaskIds.length} task(s) completed.\n` +
-				  `   Use /orch-resume to continue, or /orch-abort to clean up.`
+					`   ${completedCount}/${allTaskIds.length} task(s) completed.\n` +
+					`   Use /orch-resume to continue, or /orch-abort to clean up.`
 				: `🧹 Found non-resumable batch state (${loadedState.batchId}, phase=${loadedState.phase}).\n` +
-				  `   ${completedCount}/${allTaskIds.length} task(s) completed. Cleaning up state file.`,
+					`   ${completedCount}/${allTaskIds.length} task(s) completed. Cleaning up state file.`,
 		};
 	}
 
@@ -1823,7 +1953,6 @@ export function detectOrphanSessions(prefix: string, repoRoot: string): OrphanDe
 	);
 }
 
-
 // ── Batch History ────────────────────────────────────────────────────
 
 /** Path to the batch history file. */
@@ -1858,7 +1987,7 @@ export function saveBatchHistory(repoRoot: string, summary: BatchHistorySummary)
 		const history = loadBatchHistory(repoRoot);
 		// Upsert by batchId so resumed batches replace their earlier partial entry
 		// instead of creating duplicates.
-		const nextHistory = history.filter(entry => entry.batchId !== summary.batchId);
+		const nextHistory = history.filter((entry) => entry.batchId !== summary.batchId);
 		// Prepend newest first
 		nextHistory.unshift(summary);
 		// Trim to max
@@ -1884,13 +2013,21 @@ export function saveBatchHistory(repoRoot: string, summary: BatchHistorySummary)
  *
  * @since TP-179
  */
-export function updateBatchHistoryIntegration(repoRoot: string, batchId: string, integratedAt: number): void {
+export function updateBatchHistoryIntegration(
+	repoRoot: string,
+	batchId: string,
+	integratedAt: number,
+): void {
 	const filePath = batchHistoryPath(repoRoot);
 	try {
 		const history = loadBatchHistory(repoRoot);
-		const entry = history.find(e => e.batchId === batchId);
+		const entry = history.find((e) => e.batchId === batchId);
 		if (!entry) {
-			execLog("batch", "history", `no history entry found for batchId=${batchId}, skipping integratedAt update`);
+			execLog(
+				"batch",
+				"history",
+				`no history entry found for batchId=${batchId}, skipping integratedAt update`,
+			);
 			return;
 		}
 		entry.integratedAt = integratedAt;
@@ -1905,7 +2042,6 @@ export function updateBatchHistoryIntegration(repoRoot: string, batchId: string,
 	}
 }
 
-
 // ── Tier 0 Supervisor Event Logging (TP-039 Step 2) ─────────────────
 
 /**
@@ -1986,7 +2122,10 @@ export function buildTier0EventBase(
 	pattern: Tier0RecoveryPattern | "merge_timeout",
 	attempt: number,
 	maxAttempts: number,
-): Pick<Tier0Event, "timestamp" | "type" | "batchId" | "waveIndex" | "pattern" | "attempt" | "maxAttempts"> {
+): Pick<
+	Tier0Event,
+	"timestamp" | "type" | "batchId" | "waveIndex" | "pattern" | "attempt" | "maxAttempts"
+> {
 	return {
 		timestamp: new Date().toISOString(),
 		type,
@@ -2028,7 +2167,6 @@ export function emitTier0Event(stateRoot: string, event: Tier0Event): void {
 	}
 }
 
-
 // ── Engine Event Logging (TP-040) ───────────────────────────────────
 
 /**
@@ -2085,7 +2223,6 @@ export function emitEngineEvent(
 	}
 }
 
-
 // ── TP-187 (#539): Batch-Meta Runtime Artifact ─────────────────────
 //
 // Small JSON file written at batch-start to `.pi/runtime/<batchId>/batch-meta.json`.
@@ -2129,10 +2266,7 @@ function batchMetaPath(stateRoot: string, batchId: string): string {
  *
  * @since TP-187 (#539)
  */
-export function saveBatchMetaRuntimeArtifact(
-	stateRoot: string,
-	artifact: BatchMetaArtifact,
-): void {
+export function saveBatchMetaRuntimeArtifact(stateRoot: string, artifact: BatchMetaArtifact): void {
 	try {
 		const path = batchMetaPath(stateRoot, artifact.batchId);
 		mkdirSync(dirname(path), { recursive: true });
@@ -2144,7 +2278,11 @@ export function saveBatchMetaRuntimeArtifact(
 			tasks: artifact.wavePlan.reduce((sum, w) => sum + w.length, 0),
 		});
 	} catch (err) {
-		execLog("state", artifact.batchId, `batch-meta write failed: ${err instanceof Error ? err.message : String(err)}`);
+		execLog(
+			"state",
+			artifact.batchId,
+			`batch-meta write failed: ${err instanceof Error ? err.message : String(err)}`,
+		);
 	}
 }
 
@@ -2184,7 +2322,6 @@ export function loadBatchMetaRuntimeArtifact(
 	}
 }
 
-
 // ── TP-187 (#539): Reconstruct PersistedBatchState from runtime artifacts ──
 
 /**
@@ -2195,8 +2332,19 @@ export function loadBatchMetaRuntimeArtifact(
  *
  * @since TP-187 (#539)
  */
+// TP-195: `error?: undefined` on the success branch makes this a well-formed
+// discriminated union under `strict: false`. Without it, `if (!result.ok)`
+// does not narrow `error` because non-strict narrowing requires every
+// member of the union to share the discriminating fields. Runtime semantics
+// unchanged — the success branch never carries an error.
 export type ReconstructResult =
-	| { ok: true; state: PersistedBatchState; batchId: string; selectionNote: string }
+	| {
+			ok: true;
+			state: PersistedBatchState;
+			batchId: string;
+			selectionNote: string;
+			error?: undefined;
+	  }
 	| { ok: false; error: string };
 
 /**
@@ -2296,7 +2444,9 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 			failures.push(`${cand.batchId}: no worker manifests`);
 			continue;
 		}
-		const workerManifestsWithWorktree = manifests.filter(m => typeof m.cwd === "string" && m.cwd.length > 0 && existsSync(m.cwd));
+		const workerManifestsWithWorktree = manifests.filter(
+			(m) => typeof m.cwd === "string" && m.cwd.length > 0 && existsSync(m.cwd),
+		);
 		if (workerManifestsWithWorktree.length === 0) {
 			failures.push(`${cand.batchId}: worktree paths from manifests no longer exist on disk`);
 			continue;
@@ -2322,16 +2472,19 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 			if (distinctRepoIds.size > 1) {
 				failures.push(
 					`${cand.batchId}: multi-repo batch detected (${distinctRepoIds.size} distinct repoIds: ` +
-					`${[...distinctRepoIds].slice(0, 4).join(", ")}` +
-					`${distinctRepoIds.size > 4 ? ", ..." : ""}); reconstruction would lose segment ` +
-					`expansion state and is refused. Restore .pi/batch-state.json from backup or start a new batch.`
+						`${[...distinctRepoIds].slice(0, 4).join(", ")}` +
+						`${distinctRepoIds.size > 4 ? ", ..." : ""}); reconstruction would lose segment ` +
+						`expansion state and is refused. Restore .pi/batch-state.json from backup or start a new batch.`,
 				);
 				continue;
 			}
 		}
 
 		// Build per-lane aggregation from worker manifests.
-		const laneMap = new Map<number, { laneNumber: number; agentId: string; worktreePath: string; repoId: string; taskIds: string[] }>();
+		const laneMap = new Map<
+			number,
+			{ laneNumber: number; agentId: string; worktreePath: string; repoId: string; taskIds: string[] }
+		>();
 		for (const m of workerManifestsWithWorktree) {
 			if (typeof m.laneNumber !== "number") continue;
 			const lane = laneMap.get(m.laneNumber) ?? {
@@ -2373,9 +2526,12 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 		for (const taskId of knownTaskIds) {
 			const m = manifestByTaskId.get(taskId);
 			const lane = m ? laneMap.get(m.laneNumber) : undefined;
+			// TP-195: dropped `taskName: taskId` — not on `PersistedTaskRecord`
+			// schema; no consumer reads `.taskName` from persisted records
+			// (only from `ParsedTask`). Was being added via untyped property
+			// bag cast that the Step 0 typecheck inventory flagged.
 			const taskRecord: PersistedTaskRecord = {
 				taskId,
-				taskName: taskId,
 				taskFolder: m?.packet?.taskFolder ?? "",
 				status: "pending",
 				sessionName: m?.agentId ?? "",
@@ -2386,15 +2542,20 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 				doneFileFound: false,
 			};
 			if (m?.repoId) taskRecord.repoId = m.repoId;
-			if (m?.packet?.packetRepoId) (taskRecord as Record<string, unknown>).packetRepoId = m.packet.packetRepoId;
-			if (m?.packet?.packetTaskPath) (taskRecord as Record<string, unknown>).packetTaskPath = m.packet.packetTaskPath;
+			// TP-195: dropped dead reads of `m.packet.packetRepoId` /
+			// `.packetTaskPath`. `m.packet` is `PacketPaths` which has only
+			// `promptPath`/`statusPath`/`donePath`/`reviewsDir`/`taskFolder`
+			// — the `packetRepoId`/`packetTaskPath` fields exist on
+			// `PersistedTaskRecord` and `ParsedTask`, not on `PacketPaths`,
+			// so these reads always returned undefined and the if-branches
+			// never fired. Removed under the no-behavior-change guarantee.
 			tasks.push(taskRecord);
 		}
 
 		// Build lane records.
 		const lanes: PersistedLaneRecord[] = Array.from(laneMap.values())
 			.sort((a, b) => a.laneNumber - b.laneNumber)
-			.map(l => {
+			.map((l) => {
 				const sessionId = l.agentId.replace(/-(worker|reviewer)$/, "");
 				const rec: PersistedLaneRecord = {
 					laneId: `lane-${l.laneNumber}`,
@@ -2426,7 +2587,7 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 			failedTasks: 0,
 			skippedTasks: 0,
 			blockedTasks: 0,
-			wavePlan: meta.wavePlan.map(wave => [...wave]),
+			wavePlan: meta.wavePlan.map((wave) => [...wave]),
 			lanes,
 			tasks,
 			mergeResults: [],
@@ -2443,14 +2604,17 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 			const json = JSON.stringify(reconstructed);
 			validatePersistedState(JSON.parse(json));
 		} catch (err) {
-			failures.push(`${cand.batchId}: reconstructed state failed validation: ${err instanceof Error ? err.message : String(err)}`);
+			failures.push(
+				`${cand.batchId}: reconstructed state failed validation: ${err instanceof Error ? err.message : String(err)}`,
+			);
 			continue;
 		}
 
 		const totalCandidates = candidates.length;
-		const selectionNote = totalCandidates === 1
-			? `single batch in .pi/runtime/`
-			: `selected from ${totalCandidates} candidate(s) by mtime newest-first (skipped ${idx} earlier candidate(s))`;
+		const selectionNote =
+			totalCandidates === 1
+				? `single batch in .pi/runtime/`
+				: `selected from ${totalCandidates} candidate(s) by mtime newest-first (skipped ${idx} earlier candidate(s))`;
 		return { ok: true, state: reconstructed, batchId: meta.batchId, selectionNote };
 	}
 
@@ -2459,4 +2623,3 @@ export function reconstructBatchStateFromRuntime(stateRoot: string): Reconstruct
 		error: `no reconstructable batch found in .pi/runtime/ (${failures.length} candidate(s) inspected: ${failures.slice(0, 3).join("; ")}${failures.length > 3 ? "; ..." : ""})`,
 	};
 }
-