taskplane 0.24.14 → 0.24.16

package/extensions/taskplane/execution.ts

@@ -868,8 +868,17 @@ export async function resolveTaskMonitorState(
 			// to avoid indefinite false "running" if the lane-runner died.
 			const staleMs = snap?.updatedAt ? (now - snap.updatedAt) : 0;
 			if (staleMs > 30_000) {
-				// Snapshot hasn't been updated for 30s+ — check registry as fallback
-				sessionAlive = isV2AgentAlive(sessionName, runtimeBackend);
+				// Snapshot hasn't been updated for 30s+ — check registry as fallback.
+				// But also check if the tracker just started (firstObservedAt within
+				// last 60s) — wave transitions can leave stale snapshots from the
+				// prior wave/task while the new worker is still spawning.
+				const trackerAgeMs = now - tracker.firstObservedAt;
+				if (trackerAgeMs < 60_000) {
+					// New task, stale snapshot — give the worker startup grace period
+					sessionAlive = true;
+				} else {
+					sessionAlive = isV2AgentAlive(sessionName, runtimeBackend);
+				}
 			} else {
 				sessionAlive = true;
 			}
@@ -1620,6 +1629,18 @@ export async function executeWave(
 	}
 	execLog("wave", `W${waveIndex}`, "using Runtime V2 backend (executeLaneV2)");
 
+	// Clear stale lane snapshots from prior waves before launching new workers.
+	// Without this, the monitor reads a snapshot from wave N-1 (different taskId,
+	// staleMs > 30s) and may falsely mark the new task as failed before the
+	// worker has time to write its first snapshot.
+	const snapshotStateRoot = resolveRuntimeStateRoot(repoRoot, wsRoot);
+	for (const lane of lanes) {
+		try {
+			const snapPath = join(snapshotStateRoot, ".pi", "runtime", batchId, "lanes", `lane-${lane.laneNumber}.json`);
+			if (existsSync(snapPath)) unlinkSync(snapPath);
+		} catch { /* best effort */ }
+	}
+
 	const lanePromises = lanes.map(lane =>
 		executeLaneV2(lane, config, repoRoot, wavePauseSignal, wsRoot, isWsMode, { ORCH_BATCH_ID: batchId }, onSupervisorAlert),
 	);

package/extensions/taskplane/extension.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-age
 import { Type } from "@mariozechner/pi-ai";
 
 import { execSync, execFileSync } from "child_process";
-import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync, readFileSync, statSync, createWriteStream } from "fs";
+import { writeFileSync, unlinkSync, mkdirSync, existsSync, readdirSync, readFileSync, statSync, createWriteStream, renameSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { fork, type ChildProcess } from "child_process";
@@ -365,6 +365,49 @@ export interface IntegrationExecDeps {
 	deleteBatchState: () => void;
 }
 
+interface BatchHistorySnapshot {
+	filePath: string;
+	raw: string;
+}
+
+/**
+ * Preserve `.pi/batch-history.json` across integration merges.
+ *
+ * Runtime history is sidecar state, not source-controlled content. In environments
+ * where `.pi/batch-history.json` was previously tracked, merge/checkouts can
+ * replace newer runtime history with stale branch snapshots. This helper snapshots
+ * the file before integration and restores it afterward (best effort).
+ */
+export function withPreservedBatchHistory<T>(stateRoot: string, operation: () => T): T {
+	const historyPath = join(stateRoot, ".pi", "batch-history.json");
+	let snapshot: BatchHistorySnapshot | null = null;
+	try {
+		if (existsSync(historyPath)) {
+			snapshot = {
+				filePath: historyPath,
+				raw: readFileSync(historyPath, "utf-8"),
+			};
+		}
+	} catch {
+		// Best effort only — integration should never fail due to snapshot capture.
+	}
+
+	try {
+		return operation();
+	} finally {
+		if (!snapshot) return;
+		try {
+			const dir = dirname(snapshot.filePath);
+			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+			const tmpPath = snapshot.filePath + ".tmp";
+			writeFileSync(tmpPath, snapshot.raw);
+			renameSync(tmpPath, snapshot.filePath);
+		} catch {
+			// Best effort only — never block integration completion.
+		}
+	}
+}
+
 /**
  * Execute the integration operation for the resolved context.
  *
@@ -1324,10 +1367,13 @@ export function buildIntegrationExecutor(repoRoot: string, opId?: string, stateR
 			},
 		};
 
-		const result = executeIntegration(mode as IntegrateMode, {
-			...context,
-			currentBranch: context.baseBranch,
-		}, deps);
+		const effectiveStateRoot = stateRoot ?? repoRoot;
+		const result = withPreservedBatchHistory(effectiveStateRoot, () =>
+			executeIntegration(mode as IntegrateMode, {
+				...context,
+				currentBranch: context.baseBranch,
+			}, deps),
+		);
 
 		// TP-051: Clean up stale task/* and saved/* branches after successful integration.
 		// This ensures auto-mode integration (supervisor path) gets the same cleanup
@@ -3116,44 +3162,51 @@ export default function (pi: ExtensionAPI) {
 			reposToIntegrate.push({ id: "(default)", root: repoRoot });
 		}
 
-		let totalCommits = 0;
-		let allSucceeded = true;
-		const repoMessages: string[] = [];
-
-		for (const repo of reposToIntegrate) {
-			const preCountResult = runGit(["rev-list", "--count", `HEAD..${resolvedOrchBranch}`], repo.root);
-			const repoCommitsBefore = preCountResult.ok ? parseInt(preCountResult.stdout) || 0 : 0;
-
-			const integrationResult = executeIntegration(parsed.mode, resolution as IntegrationContext, {
-				runGit: (gitArgs: string[]) => runGit(gitArgs, repo.root),
-				runCommand: (cmd: string, cmdArgs: string[]) => {
-					try {
-						const stdout = execFileSync(cmd, cmdArgs, {
-							encoding: "utf-8",
-							timeout: 60_000,
-							cwd: repo.root,
-							stdio: ["pipe", "pipe", "pipe"],
-						}).trim();
-						return { ok: true, stdout, stderr: "" };
-					} catch (err: unknown) {
-						const e = err as { stdout?: string; stderr?: string; message?: string };
-						return {
-							ok: false,
-							stdout: (e.stdout ?? "").toString().trim(),
-							stderr: (e.stderr ?? e.message ?? "unknown error").toString().trim(),
-						};
-					}
-				},
-				deleteBatchState: () => { /* handled once after all repos */ },
-			});
+		const integrationRun = withPreservedBatchHistory(stateRoot, () => {
+			let totalCommits = 0;
+			const repoMessages: string[] = [];
+
+			for (const repo of reposToIntegrate) {
+				const preCountResult = runGit(["rev-list", "--count", `HEAD..${resolvedOrchBranch}`], repo.root);
+				const repoCommitsBefore = preCountResult.ok ? parseInt(preCountResult.stdout) || 0 : 0;
 
-			if (!integrationResult.success) {
-				return { message: `❌ Integration failed in ${repo.id}:\n${integrationResult.error}`, error: true };
+				const integrationResult = executeIntegration(parsed.mode, resolution as IntegrationContext, {
+					runGit: (gitArgs: string[]) => runGit(gitArgs, repo.root),
+					runCommand: (cmd: string, cmdArgs: string[]) => {
+						try {
+							const stdout = execFileSync(cmd, cmdArgs, {
+								encoding: "utf-8",
+								timeout: 60_000,
+								cwd: repo.root,
+								stdio: ["pipe", "pipe", "pipe"],
+							}).trim();
+							return { ok: true, stdout, stderr: "" };
+						} catch (err: unknown) {
+							const e = err as { stdout?: string; stderr?: string; message?: string };
+							return {
+								ok: false,
+								stdout: (e.stdout ?? "").toString().trim(),
+								stderr: (e.stderr ?? e.message ?? "unknown error").toString().trim(),
+							};
+						}
+					},
+					deleteBatchState: () => { /* handled once after all repos */ },
+				});
+
+				if (!integrationResult.success) {
+					return { ok: false as const, error: `❌ Integration failed in ${repo.id}:\n${integrationResult.error}` };
+				}
+
+				totalCommits += repoCommitsBefore;
+				repoMessages.push(`  ${repo.id}: ${integrationResult.message}`);
 			}
 
-			totalCommits += repoCommitsBefore;
-			repoMessages.push(`  ${repo.id}: ${integrationResult.message}`);
+			return { ok: true as const, totalCommits, repoMessages };
+		});
+		if (!integrationRun.ok) {
+			return { message: integrationRun.error, error: true };
 		}
+		const { totalCommits, repoMessages } = integrationRun;
 
 		// Post-integration cleanup & acceptance
 		const allRepos: { id: string; root: string }[] = [];

package/extensions/taskplane/persistence.ts

@@ -1841,18 +1841,21 @@ export function saveBatchHistory(repoRoot: string, summary: BatchHistorySummary)
 	const filePath = batchHistoryPath(repoRoot);
 	try {
 		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);
 		// Prepend newest first
-		history.unshift(summary);
+		nextHistory.unshift(summary);
 		// Trim to max
-		if (history.length > BATCH_HISTORY_MAX_ENTRIES) {
-			history.length = BATCH_HISTORY_MAX_ENTRIES;
+		if (nextHistory.length > BATCH_HISTORY_MAX_ENTRIES) {
+			nextHistory.length = BATCH_HISTORY_MAX_ENTRIES;
 		}
 		const dir = dirname(filePath);
 		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 		const tmpPath = filePath + ".tmp";
-		writeFileSync(tmpPath, JSON.stringify(history, null, 2));
+		writeFileSync(tmpPath, JSON.stringify(nextHistory, null, 2));
 		renameSync(tmpPath, filePath);
-		execLog("batch", "history", `saved batch summary (${history.length} entries)`);
+		execLog("batch", "history", `saved batch summary (${nextHistory.length} entries)`);
 	} catch (err) {
 		execLog("batch", "history", `failed to save batch history: ${err}`);
 	}

package/package.json

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