taskplane 0.23.12 → 0.23.14

package/extensions/taskplane/engine.ts

@@ -64,6 +64,61 @@ function emitTier0Escalation(
 	});
 }
 
+/** Zero-token sentinel used for task/wave/batch aggregation. */
+const ZERO_TOKENS: TokenCounts = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
+
+/** Map embedded outcome telemetry to the batch-history TokenCounts shape. */
+export function taskTokensFromOutcomeTelemetry(outcome: LaneTaskOutcome): TokenCounts {
+	const telemetry = outcome.telemetry;
+	if (!telemetry) return { ...ZERO_TOKENS };
+	return {
+		input: telemetry.inputTokens,
+		output: telemetry.outputTokens,
+		cacheRead: telemetry.cacheReadTokens,
+		cacheWrite: telemetry.cacheWriteTokens,
+		costUsd: telemetry.costUsd,
+	};
+}
+
+/**
+ * Resolve per-task token counts for batch history.
+ *
+ * Priority:
+ * 1) Embedded `LaneTaskOutcome.telemetry` (authoritative Runtime V2 path)
+ * 2) V2 lane snapshot fallback by numeric laneNumber (legacy outcomes)
+ * 3) Legacy lane-state sidecar keys by sessionName prefix
+ * 4) Zero tokens
+ */
+export function resolveBatchHistoryTaskTokens(
+	outcome: LaneTaskOutcome,
+	laneNumber: number,
+	v2LaneTokensByNumber: Map<number, TokenCounts>,
+	legacyLaneTokensByKey: Map<string, TokenCounts>,
+): TokenCounts {
+	// Skipped tasks did not run an agent process.
+	if (outcome.status === "skipped") return { ...ZERO_TOKENS };
+
+	if (outcome.telemetry) {
+		return taskTokensFromOutcomeTelemetry(outcome);
+	}
+
+	if (laneNumber > 0) {
+		const v2 = v2LaneTokensByNumber.get(laneNumber);
+		if (v2) return v2;
+	}
+
+	const bySession = legacyLaneTokensByKey.get(outcome.sessionName)
+		|| legacyLaneTokensByKey.get(outcome.sessionName?.replace(/-(?:worker|reviewer)$/, ""));
+	if (bySession) return bySession;
+
+	if (laneNumber > 0) {
+		const byLaneKey = legacyLaneTokensByKey.get(`lane-${laneNumber}`);
+		if (byLaneKey) return byLaneKey;
+	}
+
+	return { ...ZERO_TOKENS };
+}
+
 /**
  * Attempt automatic retry for failed tasks with retryable exit classifications.
  *
@@ -2253,11 +2308,13 @@ export async function executeOrchBatch(
 
 	// ── Save batch history (before cleanup deletes sidecar files) ────
 	try {
-		// Read token data from sidecar files or V2 lane snapshots
+		// Read fallback token data from V2 lane snapshots and legacy sidecars.
+		// Primary source for Runtime V2 is now `LaneTaskOutcome.telemetry`.
 		const piDir = join(stateRoot, ".pi");
-		const laneTokens = new Map<string, TokenCounts>();
+		const v2LaneTokensByNumber = new Map<number, TokenCounts>();
+		const legacyLaneTokensByKey = new Map<string, TokenCounts>();
 
-		// TP-115: Try V2 lane snapshots first (authoritative for Runtime V2)
+		// V2 snapshot fallback (used only when outcome.telemetry is absent).
 		try {
 			const lanesDir = join(piDir, "runtime", batchState.batchId, "lanes");
 			if (existsSync(lanesDir)) {
@@ -2265,11 +2322,11 @@ export async function executeOrchBatch(
 				for (const f of files) {
 					try {
 						const snap = JSON.parse(readFileSync(join(lanesDir, f), "utf-8"));
+						const laneNumber = typeof snap.laneNumber === "number" ? snap.laneNumber : 0;
+						if (laneNumber <= 0) continue;
 						const w = snap.worker || {};
 						const r = snap.reviewer || {};
-						// Key by lane number for reliable per-task lookup (TP-115)
-						const key = `lane-${snap.laneNumber}`;
-						laneTokens.set(key, {
+						v2LaneTokensByNumber.set(laneNumber, {
 							input: (w.inputTokens || 0) + (r.inputTokens || 0),
 							output: (w.outputTokens || 0) + (r.outputTokens || 0),
 							cacheRead: (w.cacheReadTokens || 0) + (r.cacheReadTokens || 0),
@@ -2281,50 +2338,50 @@ export async function executeOrchBatch(
 			}
 		} catch { /* runtime dir may not exist */ }
 
-
-		// Legacy fallback: lane-state-*.json sidecars (only if V2 found nothing)
-		if (laneTokens.size === 0) {
-			try {
-				const files = readdirSync(piDir).filter(f => f.startsWith("lane-state-") && f.endsWith(".json"));
-				for (const f of files) {
-					try {
-						const raw = readFileSync(join(piDir, f), "utf-8").trim();
-						if (!raw) continue;
-						const data = JSON.parse(raw);
-						if (data.prefix) {
-							laneTokens.set(data.prefix, {
-								input: data.workerInputTokens || 0,
-								output: data.workerOutputTokens || 0,
-								cacheRead: data.workerCacheReadTokens || 0,
-								cacheWrite: data.workerCacheWriteTokens || 0,
-								costUsd: data.workerCostUsd || 0,
-							});
-						}
-					} catch { /* skip invalid files */ }
-				}
-			} catch { /* .pi dir may not exist */ }
-		}
+		// Legacy fallback: lane-state-*.json sidecars (pre-V2).
+		try {
+			const files = readdirSync(piDir).filter(f => f.startsWith("lane-state-") && f.endsWith(".json"));
+			for (const f of files) {
+				try {
+					const raw = readFileSync(join(piDir, f), "utf-8").trim();
+					if (!raw) continue;
+					const data = JSON.parse(raw);
+					if (data.prefix) {
+						legacyLaneTokensByKey.set(data.prefix, {
+							input: data.workerInputTokens || 0,
+							output: data.workerOutputTokens || 0,
+							cacheRead: data.workerCacheReadTokens || 0,
+							cacheWrite: data.workerCacheWriteTokens || 0,
+							costUsd: data.workerCostUsd || 0,
+						});
+					}
+				} catch { /* skip invalid files */ }
+			}
+		} catch { /* .pi dir may not exist */ }
 
 		// Build per-task summaries from allTaskOutcomes + wave plan
 		const taskSummaries: BatchTaskSummary[] = allTaskOutcomes.map((to) => {
 			// Find which wave and lane this task ran in
-			let wave = 0, lane = 0;
+			let wave = 0;
 			for (let wi = 0; wi < wavePlan.length; wi++) {
 				if (wavePlan[wi].includes(to.taskId)) { wave = wi + 1; break; }
 			}
-			// Match lane via tmux session name
-			const laneMatch = to.sessionName?.match(/lane-(\d+)/);
-			if (laneMatch) lane = parseInt(laneMatch[1]);
+			const lane = to.laneNumber
+				?? (() => {
+					const laneMatch = to.sessionName?.match(/lane-(\d+)/);
+					return laneMatch ? parseInt(laneMatch[1], 10) : 0;
+				})();
 
 			// Compute duration from start/end times
 			const durationMs = (to.startTime && to.endTime) ? (to.endTime - to.startTime) : 0;
 
-			// Get tokens for this lane (cumulative — shared across tasks in same lane)
-			// TP-115: Try lane number key first (V2), then sessionName variants (legacy).
-			const tokens = laneTokens.get(`lane-${lane}`)
-				|| laneTokens.get(to.sessionName)
-				|| laneTokens.get(to.sessionName?.replace(/-(?:worker|reviewer)$/, ""))
-				|| { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 };
+			// TP-116: Resolve tokens from outcome telemetry first; only fallback for legacy outcomes.
+			const tokens = resolveBatchHistoryTaskTokens(
+				to,
+				lane,
+				v2LaneTokensByNumber,
+				legacyLaneTokensByKey,
+			);
 
 			return {
 				taskId: to.taskId,

package/extensions/taskplane/execution.ts

@@ -1369,6 +1369,7 @@ export async function executeLane(
 				exitReason: reason,
 				sessionName: lane.tmuxSessionName,
 				doneFileFound: false,
+				laneNumber: lane.laneNumber,
 			});
 			continue;
 		}
@@ -1399,6 +1400,7 @@ export async function executeLane(
 				exitReason: pollResult.exitReason,
 				sessionName: lane.tmuxSessionName,
 				doneFileFound: pollResult.doneFileFound,
+				laneNumber: lane.laneNumber,
 			};
 
 			// After task succeeds, commit any uncommitted artifacts (.DONE, final
@@ -1446,6 +1448,7 @@ export async function executeLane(
 				exitReason: errMsg,
 				sessionName: lane.tmuxSessionName,
 				doneFileFound: false,
+				laneNumber: lane.laneNumber,
 			};
 
 			shouldSkipRemaining = true;
@@ -2577,6 +2580,7 @@ export async function executeWave(
 					exitReason: `Lane promise rejected: ${errMsg}`,
 					sessionName: lanes[idx].tmuxSessionName,
 					doneFileFound: false,
+					laneNumber: lanes[idx].laneNumber,
 				})),
 				overallStatus: "failed" as const,
 				startTime: startedAt,
@@ -2779,6 +2783,7 @@ export async function executeWithStopAll(
 					exitReason: `Lane aborted: ${errMsg}`,
 					sessionName: lanes[idx].tmuxSessionName,
 					doneFileFound: false,
+					laneNumber: lanes[idx].laneNumber,
 				})),
 				overallStatus: "failed",
 				startTime: Date.now(),
@@ -2933,6 +2938,83 @@ export function buildAgentIdFromLane(
  *
  * @since TP-102
  */
+/**
+ * Parse an agent .md file: extract frontmatter and body.
+ * Returns null if file doesn't exist or is malformed.
+ * @since TP-117
+ */
+function parseAgentFile(filePath: string): { fm: Record<string, string>; body: string } | null {
+	try {
+		if (!existsSync(filePath)) return null;
+		const raw = readFileSync(filePath, "utf-8");
+		const fmEnd = raw.indexOf("---", 4);
+		if (fmEnd < 0) return { fm: {}, body: raw.trim() };
+		const fmBlock = raw.slice(4, fmEnd).trim();
+		const fm: Record<string, string> = {};
+		for (const line of fmBlock.split("\n")) {
+			const m = line.match(/^([\w-]+)\s*:\s*(.+)/);
+			if (m) fm[m[1]] = m[2].trim();
+		}
+		return { fm, body: raw.slice(fmEnd + 3).trim() };
+	} catch { return null; }
+}
+
+/**
+ * Load the base agent prompt from the taskplane package's templates/ directory.
+ * Resolves the package root via well-known npm global paths.
+ * @since TP-117
+ */
+function loadBaseAgentPrompt(agentName: string): string {
+	const relPath = join("node_modules", "taskplane", "templates", "agents", `${agentName}.md`);
+	const candidates: string[] = [];
+
+	// Global npm paths
+	const home = process.env.HOME || process.env.USERPROFILE || "";
+	if (process.env.APPDATA) candidates.push(join(process.env.APPDATA, "npm", relPath));
+	if (home) {
+		candidates.push(join(home, "AppData", "Roaming", "npm", relPath));
+		candidates.push(join(home, ".npm-global", "lib", relPath));
+	}
+	candidates.push(join("/usr", "local", "lib", relPath));
+	candidates.push(join("/opt", "homebrew", "lib", relPath));
+
+	// Dynamic: npm root -g
+	try {
+		const result = spawnSync("npm", ["root", "-g"], { encoding: "utf-8", timeout: 5000, shell: true });
+		if (result.stdout?.trim()) {
+			candidates.push(join(result.stdout.trim(), "taskplane", "templates", "agents", `${agentName}.md`));
+		}
+	} catch { /* ignore */ }
+
+	for (const p of candidates) {
+		const def = parseAgentFile(p);
+		if (def?.body) return def.body;
+	}
+	return "";
+}
+
+/**
+ * Load local project agent prompt from .pi/agents/ or agents/ directory.
+ * Supports standalone mode (local replaces base entirely).
+ * @since TP-117
+ */
+function loadLocalAgentPrompt(stateRoot: string, agentName: string): string {
+	const paths = [
+		join(stateRoot, ".pi", "agents", `${agentName}.md`),
+		join(stateRoot, "agents", `${agentName}.md`),
+	];
+	for (const p of paths) {
+		const def = parseAgentFile(p);
+		if (def) {
+			// standalone: true → use local as-is (body only, replaces base)
+			if (def.fm.standalone === "true") return def.body;
+			// Otherwise return body as project-specific guidance to append
+			if (def.body) return def.body;
+		}
+	}
+	return "";
+}
+
 export function resolveRuntimeStateRoot(
 	repoRoot: string,
 	workspaceRoot?: string,
@@ -2982,16 +3064,20 @@ export async function executeLaneV2(
 	const opId = resolveOperatorId(config);
 	const agentIdPrefix = `${tmuxPrefix}-${opId}`;
 
-	// Load worker agent definition for system prompt
+	// Load worker agent definition: compose base template + local project guidance.
+	// The base template (templates/agents/task-worker.md) contains critical behavioral
+	// rules: checkpoint discipline, STATUS.md resume algorithm, review_step instructions.
+	// The local file (.pi/agents/task-worker.md) adds project-specific guidance.
 	let workerSystemPrompt = "You are a task execution agent. Read STATUS.md first, find unchecked items, work on them, checkpoint after each.";
 	try {
-		const agentPath = join(stateRoot, ".pi", "agents", "task-worker.md");
-		if (existsSync(agentPath)) {
-			const raw = readFileSync(agentPath, "utf-8");
-			const fmEnd = raw.indexOf("---", 4);
-			if (fmEnd > 0) {
-				workerSystemPrompt = raw.slice(fmEnd + 3).trim();
-			}
+		const basePrompt = loadBaseAgentPrompt("task-worker");
+		const localPrompt = loadLocalAgentPrompt(stateRoot, "task-worker");
+		if (basePrompt && localPrompt) {
+			workerSystemPrompt = basePrompt + "\n\n---\n\n## Project-Specific Guidance\n\n" + localPrompt;
+		} else if (basePrompt) {
+			workerSystemPrompt = basePrompt;
+		} else if (localPrompt) {
+			workerSystemPrompt = localPrompt;
 		}
 	} catch { /* use default */ }
 
@@ -3011,6 +3097,7 @@ export async function executeLaneV2(
 				exitReason: reason,
 				sessionName: buildRuntimeAgentId(agentIdPrefix, lane.laneNumber, "worker"),
 				doneFileFound: false,
+				laneNumber: lane.laneNumber,
 			});
 			continue;
 		}
@@ -3040,7 +3127,10 @@ export async function executeLaneV2(
 
 		try {
 			const result = await executeTaskV2(unit, laneRunnerConfig, pauseSignal);
-			outcomes.push(result.outcome);
+			outcomes.push({
+				...result.outcome,
+				laneNumber: result.outcome.laneNumber ?? lane.laneNumber,
+			});
 
 			// Commit artifacts after success (same as legacy path)
 			if (result.outcome.status === "succeeded") {
@@ -3066,6 +3156,7 @@ export async function executeLaneV2(
 				exitReason: `Runtime V2 execution error: ${errMsg}`,
 				sessionName: buildRuntimeAgentId(agentIdPrefix, lane.laneNumber, "worker"),
 				doneFileFound: false,
+				laneNumber: lane.laneNumber,
 			});
 			shouldSkipRemaining = true;
 		}

package/extensions/taskplane/lane-runner.ts

@@ -496,6 +496,18 @@ function makeResult(
 	statusPath?: string,
 	finalTelemetry?: Partial<AgentHostResult>,
 ): LaneRunnerTaskResult {
+	const telemetry = status === "skipped"
+		? undefined
+		: {
+			inputTokens: finalTelemetry?.inputTokens ?? 0,
+			outputTokens: finalTelemetry?.outputTokens ?? 0,
+			cacheReadTokens: finalTelemetry?.cacheReadTokens ?? 0,
+			cacheWriteTokens: finalTelemetry?.cacheWriteTokens ?? 0,
+			costUsd: finalTelemetry?.costUsd ?? 0,
+			toolCalls: finalTelemetry?.toolCalls ?? 0,
+			durationMs: finalTelemetry?.durationMs ?? 0,
+		};
+
 	const result: LaneRunnerTaskResult = {
 		outcome: {
 			taskId,
@@ -505,6 +517,8 @@ function makeResult(
 			exitReason,
 			sessionName,
 			doneFileFound,
+			laneNumber: config?.laneNumber,
+			telemetry,
 		},
 		iterations,
 		costUsd,

package/extensions/taskplane/persistence.ts

@@ -50,6 +50,21 @@ export function hasTaskDoneMarker(taskFolder: string): boolean {
 	return false;
 }
 
+/**
+ * Compare optional embedded outcome telemetry.
+ */
+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;
+}
+
 /**
  * Upsert a task outcome in-place. Returns true if changed.
  */
@@ -61,19 +76,27 @@ export function upsertTaskOutcome(outcomes: LaneTaskOutcome[], next: LaneTaskOut
 	}
 
 	const prev = outcomes[idx];
+	const mergedNext: LaneTaskOutcome = {
+		...next,
+		laneNumber: next.laneNumber ?? prev.laneNumber,
+		telemetry: next.telemetry ?? prev.telemetry,
+	};
+
 	const changed =
-		prev.status !== next.status ||
-		prev.startTime !== next.startTime ||
-		prev.endTime !== next.endTime ||
-		prev.exitReason !== next.exitReason ||
-		prev.sessionName !== next.sessionName ||
-		prev.doneFileFound !== next.doneFileFound ||
-		prev.partialProgressCommits !== next.partialProgressCommits ||
-		prev.partialProgressBranch !== next.partialProgressBranch ||
-		prev.exitDiagnostic !== next.exitDiagnostic;
+		prev.status !== mergedNext.status ||
+		prev.startTime !== mergedNext.startTime ||
+		prev.endTime !== mergedNext.endTime ||
+		prev.exitReason !== mergedNext.exitReason ||
+		prev.sessionName !== mergedNext.sessionName ||
+		prev.doneFileFound !== mergedNext.doneFileFound ||
+		prev.laneNumber !== mergedNext.laneNumber ||
+		!sameOutcomeTelemetry(prev.telemetry, mergedNext.telemetry) ||
+		prev.partialProgressCommits !== mergedNext.partialProgressCommits ||
+		prev.partialProgressBranch !== mergedNext.partialProgressBranch ||
+		prev.exitDiagnostic !== mergedNext.exitDiagnostic;
 
 	if (changed) {
-		outcomes[idx] = next;
+		outcomes[idx] = mergedNext;
 	}
 	return changed;
 }
@@ -130,6 +153,7 @@ export function seedPendingOutcomesForAllocatedLanes(
 				exitReason: "Pending execution",
 				sessionName: lane.tmuxSessionName,
 				doneFileFound: false,
+				laneNumber: lane.laneNumber,
 			}) || changed;
 		}
 	}
@@ -163,6 +187,8 @@ export function syncTaskOutcomesFromMonitor(
 				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,
@@ -182,6 +208,8 @@ export function syncTaskOutcomesFromMonitor(
 				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,
@@ -199,6 +227,8 @@ export function syncTaskOutcomesFromMonitor(
 				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,
@@ -233,6 +263,8 @@ export function syncTaskOutcomesFromMonitor(
 				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,
@@ -1164,7 +1196,7 @@ export function serializeBatchState(
 
 			const record: PersistedTaskRecord = {
 				taskId,
-				laneNumber: lane?.laneNumber ?? 0,
+				laneNumber: lane?.laneNumber ?? outcome?.laneNumber ?? 0,
 				sessionName: outcome?.sessionName || lane?.tmuxSessionName || "",
 				status: outcome?.status ?? "pending",
 				taskFolder: "", // Enriched by caller from discovery

package/extensions/taskplane/resume.ts

@@ -1356,6 +1356,7 @@ export async function resumeOrchBatch(
 					exitReason: "Re-executed task completed successfully",
 					sessionName: lane.tmuxSessionName,
 					doneFileFound: true,
+					laneNumber: lane.laneNumber,
 				})),
 				overallStatus: "succeeded" as const,
 				startTime: Date.now(),
@@ -1474,6 +1475,7 @@ export async function resumeOrchBatch(
 				: persistedTask?.exitReason ?? "",
 			sessionName: persistedTask?.sessionName ?? "",
 			doneFileFound: status === "succeeded" ? true : task.doneFileFound,
+			laneNumber: persistedTask?.laneNumber,
 			// Carry forward partial progress from persisted state (TP-028)
 			partialProgressCommits: persistedTask?.partialProgressCommits,
 			partialProgressBranch: persistedTask?.partialProgressBranch,
@@ -1604,6 +1606,7 @@ export async function resumeOrchBatch(
 									: "Task failed (merge retry)",
 							sessionName: lane.tmuxSessionName,
 							doneFileFound: status === "succeeded",
+							laneNumber: lane.laneNumber,
 						};
 					});
 

package/extensions/taskplane/types.ts

@@ -649,6 +649,30 @@ export interface AllocatedLane {
  */
 export type LaneTaskStatus = "pending" | "running" | "succeeded" | "failed" | "stalled" | "skipped";
 
+/**
+ * Embedded telemetry attached to a lane task outcome.
+ *
+ * Populated by Runtime V2 lane-runner at emission time so downstream
+ * consumers (batch history, diagnostics) can read authoritative usage
+ * without reconstructing task↔lane joins from snapshot keys.
+ */
+export interface LaneTaskOutcomeTelemetry {
+	/** Total input tokens for this task outcome. */
+	inputTokens: number;
+	/** Total output tokens for this task outcome. */
+	outputTokens: number;
+	/** Total cache-read tokens for this task outcome. */
+	cacheReadTokens: number;
+	/** Total cache-write tokens for this task outcome. */
+	cacheWriteTokens: number;
+	/** Cumulative cost in USD for this task outcome. */
+	costUsd: number;
+	/** Number of tool calls made while producing this outcome. */
+	toolCalls: number;
+	/** End-to-end duration in milliseconds for this outcome. */
+	durationMs: number;
+}
+
 /**
  * Outcome of a single task execution within a lane.
  *
@@ -670,6 +694,19 @@ export interface LaneTaskOutcome {
 	sessionName: string;
 	/** Whether .DONE file was found */
 	doneFileFound: boolean;
+	/**
+	 * Lane number that produced this task outcome (1-indexed).
+	 *
+	 * Optional for backward compatibility with pre-TP-116 persisted state.
+	 */
+	laneNumber?: number;
+	/**
+	 * Embedded task-level telemetry (authoritative for Runtime V2).
+	 *
+	 * Optional for backward compatibility and non-agent outcomes
+	 * (for example skipped tasks).
+	 */
+	telemetry?: LaneTaskOutcomeTelemetry;
 	/**
 	 * Number of commits preserved as partial progress for a failed task.
 	 * 0 when no partial progress was saved (succeeded tasks, no commits, etc.).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskplane",
-  "version": "0.23.12",
+  "version": "0.23.14",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",