taskplane 0.19.0 → 0.20.0

package/extensions/taskplane/merge.ts

@@ -3,10 +3,11 @@
  * @module orch/merge
  */
 import { readFileSync, writeFileSync, existsSync, unlinkSync, copyFileSync, mkdirSync, rmSync } from "fs";
+import { readFile as fsReadFile } from "fs/promises";
 import { execSync, spawnSync } from "child_process";
 import { join, dirname, resolve, relative } from "path";
 
-import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, generateTelemetryPaths, resolveRpcWrapperPath, resolveTelemOpId, tmuxHasSession, tmuxKillSession, toTmuxPath } from "./execution.ts";
+import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, generateTelemetryPaths, resolveRpcWrapperPath, resolveTelemOpId, tmuxHasSession, tmuxHasSessionAsync, tmuxKillSession, tmuxKillSessionAsync, tmuxAsync, toTmuxPath } from "./execution.ts";
 import { resolveOperatorId } from "./naming.ts";
 import { MERGE_POLL_INTERVAL_MS, MERGE_RESULT_GRACE_MS, MERGE_RESULT_READ_RETRIES, MERGE_RESULT_READ_RETRY_DELAY_MS, MERGE_SPAWN_RETRY_MAX, MERGE_TIMEOUT_MAX_RETRIES, MERGE_TIMEOUT_MS, MERGE_HEALTH_POLL_INTERVAL_MS, MERGE_HEALTH_WARNING_THRESHOLD_MS, MERGE_HEALTH_STUCK_THRESHOLD_MS, MERGE_HEALTH_CAPTURE_LINES, MergeError, VALID_MERGE_STATUSES, buildEngineEventBase } from "./types.ts";
 import type { AllocatedLane, LaneExecutionResult, MergeLaneResult, MergeResult, MergeResultStatus, MergeWaveResult, OrchestratorConfig, RepoMergeOutcome, TaskRunnerConfig, TransactionRecord, TransactionStatus, VerificationBaselineResult, WaveExecutionResult, WorkspaceConfig, MergeHealthStatus, MergeHealthEventType, MergeSessionSnapshot, MergeSessionHealthState, EngineEvent, OrchBatchPhase } from "./types.ts";
@@ -250,6 +251,186 @@ export function parseMergeResult(resultPath: string): MergeResult {
 	);
 }
 
+/**
+ * Async version of parseMergeResult — reads and validates a merge result
+ * JSON file without blocking the event loop.
+ *
+ * Uses `fs/promises.readFile` instead of `readFileSync` and `sleepAsync`
+ * instead of `sleepSync` for retry delays. Validation semantics and error
+ * codes are identical to the sync version.
+ *
+ * @param resultPath - Path to the merge result JSON file
+ * @returns Promise resolving to a validated MergeResult
+ * @throws MergeError on missing/invalid/unparseable result
+ *
+ * @since TP-070
+ */
+export async function parseMergeResultAsync(resultPath: string): Promise<MergeResult> {
+	if (!existsSync(resultPath)) {
+		throw new MergeError(
+			"MERGE_RESULT_INVALID",
+			`Merge result file not found: ${resultPath}`,
+		);
+	}
+
+	const pickString = (obj: Record<string, unknown>, ...keys: string[]): string | null => {
+		for (const key of keys) {
+			const value = obj[key];
+			if (typeof value === "string" && value.trim().length > 0) {
+				return value;
+			}
+		}
+		return null;
+	};
+
+	const hasFlatVerification = (obj: Record<string, unknown>): boolean =>
+		typeof obj.verification_passed === "boolean"
+		|| Array.isArray(obj.verification_commands)
+		|| typeof obj.verification_output === "string"
+		|| typeof obj.verification_exit_code === "number";
+
+	const normalizeVerification = (obj: Record<string, unknown>): MergeResult["verification"] | null => {
+		const nested = (obj.verification && typeof obj.verification === "object")
+			? obj.verification as Record<string, unknown>
+			: null;
+
+		if (!nested && !hasFlatVerification(obj)) {
+			return null;
+		}
+
+		const passedFromBool =
+			(nested && typeof nested.passed === "boolean" ? nested.passed : undefined)
+			?? (nested && typeof nested.all_passed === "boolean" ? nested.all_passed : undefined)
+			?? (typeof obj.verification_passed === "boolean" ? obj.verification_passed : undefined);
+
+		const exitCode =
+			(nested && typeof nested.exitCode === "number" ? nested.exitCode : undefined)
+			?? (nested && typeof nested.exit_code === "number" ? nested.exit_code : undefined)
+			?? (typeof obj.verification_exit_code === "number" ? obj.verification_exit_code : undefined);
+
+		const passed = typeof passedFromBool === "boolean"
+			? passedFromBool
+			: (typeof exitCode === "number" ? exitCode === 0 : false);
+
+		const ran = (nested && typeof nested.ran === "boolean")
+			? nested.ran
+			: (
+				typeof passedFromBool === "boolean"
+				|| typeof exitCode === "number"
+				|| (nested && typeof nested.command === "string")
+				|| (nested && typeof nested.summary === "string")
+				|| typeof obj.verification_output === "string"
+				|| Array.isArray(obj.verification_commands)
+			);
+
+		const output = (
+			(nested && typeof nested.output === "string" ? nested.output : undefined)
+			?? (nested && typeof nested.summary === "string" ? nested.summary : undefined)
+			?? (nested && typeof nested.notes === "string" ? nested.notes : undefined)
+			?? (typeof obj.verification_output === "string" ? obj.verification_output : "")
+		).slice(0, 2000);
+
+		return { ran, passed, output };
+	};
+
+	// Retry-read loop for partially-written files — async version
+	let lastParseError = "";
+	for (let attempt = 1; attempt <= MERGE_RESULT_READ_RETRIES; attempt++) {
+		try {
+			const raw = (await fsReadFile(resultPath, "utf-8")).trim();
+			if (!raw) {
+				lastParseError = "File is empty";
+				if (attempt < MERGE_RESULT_READ_RETRIES) {
+					await sleepAsync(MERGE_RESULT_READ_RETRY_DELAY_MS);
+					continue;
+				}
+				throw new MergeError(
+					"MERGE_RESULT_INVALID",
+					`Merge result file is empty after ${MERGE_RESULT_READ_RETRIES} attempts: ${resultPath}`,
+				);
+			}
+
+			const parsed = JSON.parse(raw) as Record<string, unknown>;
+
+			// Validate required fields
+			if (typeof parsed.status !== "string") {
+				throw new MergeError(
+					"MERGE_RESULT_MISSING_FIELDS",
+					`Merge result missing required field "status": ${resultPath}`,
+				);
+			}
+
+			const sourceBranch = pickString(parsed, "source_branch", "sourceBranch", "source");
+			if (!sourceBranch) {
+				throw new MergeError(
+					"MERGE_RESULT_MISSING_FIELDS",
+					`Merge result missing required field "source_branch" (accepted aliases: sourceBranch, source): ${resultPath}`,
+				);
+			}
+
+			const verification = normalizeVerification(parsed);
+			if (!verification) {
+				throw new MergeError(
+					"MERGE_RESULT_MISSING_FIELDS",
+					`Merge result missing required field "verification": ${resultPath}`,
+				);
+			}
+
+			// Normalize status to uppercase
+			parsed.status = String(parsed.status).toUpperCase();
+
+			if (!VALID_MERGE_STATUSES.has(parsed.status)) {
+				execLog("merge", "parse", `unknown merge status "${parsed.status}" — treating as BUILD_FAILURE`, {
+					resultPath,
+				});
+				parsed.status = "BUILD_FAILURE";
+			}
+
+			const targetBranch = pickString(parsed, "target_branch", "targetBranch", "target") ?? "";
+			const mergeCommit = pickString(parsed, "merge_commit", "mergeCommit") ?? "";
+			const conflicts = Array.isArray(parsed.conflicts)
+				? parsed.conflicts
+					.filter((c): c is { file: string; type: string; resolved: boolean; resolution?: string } => (
+						typeof c === "object"
+						&& c !== null
+						&& typeof (c as { file?: unknown }).file === "string"
+						&& typeof (c as { type?: unknown }).type === "string"
+						&& typeof (c as { resolved?: unknown }).resolved === "boolean"
+					))
+					.map(c => ({
+						file: c.file,
+						type: c.type,
+						resolved: c.resolved,
+						...(typeof c.resolution === "string" ? { resolution: c.resolution } : {}),
+					}))
+				: [];
+
+			return {
+				status: parsed.status as MergeResultStatus,
+				source_branch: sourceBranch,
+				target_branch: targetBranch,
+				merge_commit: mergeCommit,
+				conflicts,
+				verification,
+			};
+		} catch (err: unknown) {
+			if (err instanceof MergeError) throw err;
+
+			lastParseError = err instanceof Error ? err.message : String(err);
+			if (attempt < MERGE_RESULT_READ_RETRIES) {
+				await sleepAsync(MERGE_RESULT_READ_RETRY_DELAY_MS);
+				continue;
+			}
+		}
+	}
+
+	throw new MergeError(
+		"MERGE_RESULT_INVALID",
+		`Failed to parse merge result JSON after ${MERGE_RESULT_READ_RETRIES} attempts. ` +
+		`Last error: ${lastParseError}. File: ${resultPath}`,
+	);
+}
+
 /**
  * Determine merge order for completed lanes.
  *
@@ -580,7 +761,7 @@ export async function waitForMergeResult(
 			// just pushed past the timeout. Accept successful results without killing.
 			if (existsSync(resultPath)) {
 				try {
-					const lateResult = parseMergeResult(resultPath);
+					const lateResult = await parseMergeResultAsync(resultPath);
 					if (SUCCESSFUL_MERGE_STATUSES.has(lateResult.status)) {
 						execLog("merge", sessionName, "merge agent slow but succeeded — accepting result at timeout", {
 							status: lateResult.status,
@@ -588,8 +769,8 @@ export async function waitForMergeResult(
 							timeoutMs,
 						});
 						// Clean up session (agent may still be running post-write)
-						if (tmuxHasSession(sessionName)) {
-							tmuxKillSession(sessionName);
+						if (await tmuxHasSessionAsync(sessionName)) {
+							await tmuxKillSessionAsync(sessionName);
 						}
 						return lateResult;
 					}
@@ -608,7 +789,7 @@ export async function waitForMergeResult(
 				elapsed,
 				timeoutMs,
 			});
-			tmuxKillSession(sessionName);
+			await tmuxKillSessionAsync(sessionName);
 
 			throw new MergeError(
 				"MERGE_TIMEOUT",
@@ -621,25 +802,25 @@ export async function waitForMergeResult(
 		// Check if result file exists
 		if (existsSync(resultPath)) {
 			try {
-				const result = parseMergeResult(resultPath);
+				const result = await parseMergeResultAsync(resultPath);
 				execLog("merge", sessionName, "merge result received", {
 					status: result.status,
 					elapsed,
 				});
 				// Kill session if still alive (agent should exit, but ensure cleanup)
-				if (tmuxHasSession(sessionName)) {
-					tmuxKillSession(sessionName);
+				if (await tmuxHasSessionAsync(sessionName)) {
+					await tmuxKillSessionAsync(sessionName);
 				}
 				return result;
 			} catch (err: unknown) {
 				// File exists but invalid — might be partially written.
-				// parseMergeResult already retries, so if it throws, it's final.
+				// parseMergeResultAsync already retries, so if it throws, it's final.
 				if (err instanceof MergeError && err.code === "MERGE_RESULT_INVALID") {
 					// Wait a bit and try once more (file might still be in flight)
 					await sleepAsync(MERGE_RESULT_READ_RETRY_DELAY_MS);
 					if (existsSync(resultPath)) {
 						try {
-							return parseMergeResult(resultPath);
+							return await parseMergeResultAsync(resultPath);
 						} catch {
 							// Give up on this file
 						}
@@ -649,8 +830,8 @@ export async function waitForMergeResult(
 			}
 		}
 
-		// Check session liveness
-		const sessionAlive = tmuxHasSession(sessionName);
+		// Check session liveness — async to avoid blocking
+		const sessionAlive = await tmuxHasSessionAsync(sessionName);
 
 		if (!sessionAlive) {
 			if (sessionDiedAt === null) {
@@ -664,7 +845,7 @@ export async function waitForMergeResult(
 				// One final check
 				if (existsSync(resultPath)) {
 					try {
-						return parseMergeResult(resultPath);
+						return await parseMergeResultAsync(resultPath);
 					} catch {
 						// Fall through to session died error
 					}
@@ -2310,6 +2491,38 @@ export function captureMergePaneOutput(
 	}
 }
 
+/**
+ * Async version of captureMergePaneOutput — captures pane output
+ * without blocking the event loop.
+ *
+ * @param sessionName - TMUX session name
+ * @param lines - Number of lines to capture from the bottom
+ * @returns Promise resolving to captured text, or null on failure
+ *
+ * @since TP-070
+ */
+export async function captureMergePaneOutputAsync(
+	sessionName: string,
+	lines: number = MERGE_HEALTH_CAPTURE_LINES,
+): Promise<string | null> {
+	try {
+		const result = await tmuxAsync([
+			"capture-pane",
+			"-t", sessionName,
+			"-p",
+			"-S", `-${lines}`,
+		], 5_000);
+
+		if (result.status !== 0) {
+			return null;
+		}
+
+		return result.stdout || null;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * Classify the health of a merge session based on session liveness
  * and pane output activity.
@@ -2458,6 +2671,9 @@ export class MergeHealthMonitor {
 		this._resultPaths.delete(sessionName);
 	}
 
+	/** Overlap guard for async poll (TP-070) */
+	private _polling = false;
+
 	/**
 	 * Start the health monitoring polling loop.
 	 */
@@ -2470,8 +2686,14 @@ export class MergeHealthMonitor {
 			pollIntervalMs: this.pollIntervalMs,
 		});
 
-		this.pollTimer = setInterval(() => {
-			this.poll();
+		this.pollTimer = setInterval(async () => {
+			if (this._polling) return; // Overlap guard (TP-070)
+			this._polling = true;
+			try {
+				await this.poll();
+			} finally {
+				this._polling = false;
+			}
 		}, this.pollIntervalMs);
 	}
 
@@ -2499,18 +2721,19 @@ export class MergeHealthMonitor {
 	 * Run a single poll cycle across all monitored sessions.
 	 *
 	 * Exposed as public for testing — normally called by the interval timer.
+	 * Async (TP-070) — uses non-blocking tmux calls to avoid event loop stalls.
 	 */
-	poll(): void {
+	async poll(): Promise<void> {
 		const now = Date.now();
 
 		for (const [sessionName, state] of this.sessions) {
-			const sessionAlive = tmuxHasSession(sessionName);
+			const sessionAlive = await tmuxHasSessionAsync(sessionName);
 			const resultPath = this._resultPaths.get(sessionName) ?? "";
 			const hasResultFile = resultPath ? existsSync(resultPath) : false;
 
-			// Capture pane output for activity detection
+			// Capture pane output for activity detection — async to avoid blocking
 			const currentOutput = sessionAlive
-				? captureMergePaneOutput(sessionName)
+				? await captureMergePaneOutputAsync(sessionName)
 				: null;
 
 			// Classify health

package/extensions/taskplane/supervisor-primer.md

@@ -38,7 +38,7 @@ guardrails) is injected at runtime.
 ```
 You (supervisor) ← operator talks to you
 │
-├── Engine (deterministic TypeScript code)
+├── Engine (deterministic TypeScript code, runs in worker_thread)
 │   ├── Discovers tasks, builds dependency DAG
 │   ├── Computes waves (topological sort)
 │   ├── Assigns tasks to lanes (parallel execution slots)

package/extensions/taskplane/supervisor.ts

@@ -29,6 +29,7 @@
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, renameSync, statSync, openSync, readSync, closeSync, appendFileSync } from "fs";
+import { stat as fsStat, open as fsOpen, readFile as fsReadFile, writeFile as fsWriteFile, rename as fsRename } from "fs/promises";
 import { execFileSync } from "child_process";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { Model, Api } from "@mariozechner/pi-ai";
@@ -2587,7 +2588,7 @@ export interface SupervisorRoutingContext {
 /**
  * Activate the supervisor agent in the current pi session.
  *
- * This is called after `startBatchAsync()` in the `/orch` command handler,
+ * This is called after `startBatchInWorker()` in the `/orch` command handler,
  * or directly by the `/orch` no-args routing logic (TP-042).
  *
  * It:
@@ -2705,7 +2706,9 @@ export async function activateSupervisor(
 	// Initializes byte offset to current file size so we skip stale events.
 	// Idempotent — safe even if called from takeover paths that may have
 	// started a tailer previously (stopEventTailer is called in deactivate).
-	startEventTailer(pi, state.eventTailer, state);
+	startEventTailer(pi, state.eventTailer, state, (key, text) => {
+		try { ctx.ui.setStatus(key, text); } catch { /* non-fatal */ }
+	});
 
 	// Send activation message to trigger the supervisor's first turn.
 	// The content is generic — specific counts may not be available yet
@@ -3071,6 +3074,62 @@ export function writeLockfile(stateRoot: string, lock: SupervisorLockfile): void
 	renameSync(tmpPath, finalPath);
 }
 
+/**
+ * Async version of readLockfile — reads lockfile without blocking the event loop.
+ *
+ * @param stateRoot - Root path for .pi/ state directory
+ * @returns Parsed lockfile or null
+ *
+ * @since TP-070
+ */
+export async function readLockfileAsync(stateRoot: string): Promise<SupervisorLockfile | null> {
+	const path = lockfilePath(stateRoot);
+
+	try {
+		const raw = await fsReadFile(path, "utf-8");
+		const parsed = JSON.parse(raw) as Record<string, unknown>;
+
+		if (
+			typeof parsed.pid !== "number" ||
+			typeof parsed.sessionId !== "string" ||
+			typeof parsed.batchId !== "string" ||
+			typeof parsed.startedAt !== "string" ||
+			typeof parsed.heartbeat !== "string"
+		) {
+			return null;
+		}
+
+		return parsed as unknown as SupervisorLockfile;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Async version of writeLockfile — writes lockfile without blocking the event loop.
+ *
+ * Creates the `.pi/supervisor/` directory if it doesn't exist.
+ * Uses temp+rename for atomicity.
+ *
+ * @param stateRoot - Root path for .pi/ state directory
+ * @param lock - Lockfile data to write
+ *
+ * @since TP-070
+ */
+export async function writeLockfileAsync(stateRoot: string, lock: SupervisorLockfile): Promise<void> {
+	const dir = join(stateRoot, ".pi", "supervisor");
+	if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+	}
+
+	const finalPath = lockfilePath(stateRoot);
+	const tmpPath = finalPath + ".tmp";
+	const json = JSON.stringify(lock, null, 2) + "\n";
+
+	await fsWriteFile(tmpPath, json, "utf-8");
+	await fsRename(tmpPath, finalPath);
+}
+
 /**
  * Remove the supervisor lockfile.
  *
@@ -3301,47 +3360,55 @@ export function startHeartbeat(
 	pi: ExtensionAPI,
 ): ReturnType<typeof setInterval> {
 	const sessionId = state.lockSessionId;
+	let heartbeatInProgress = false; // Overlap guard (TP-070)
 
-	const timer = setInterval(() => {
+	const timer = setInterval(async () => {
 		if (!state.active) {
 			clearInterval(timer);
 			return;
 		}
 
-		// Read current lockfile to detect force takeover
-		const currentLock = readLockfile(stateRoot);
-		if (currentLock && currentLock.sessionId !== sessionId) {
-			// Another session has taken over — yield gracefully
-			clearInterval(timer);
-			pi.sendMessage(
-				{
-					customType: "supervisor-yield",
-					content: [{
-						type: "text",
-						text: "⚡ Another session has taken over supervisor duties. Yielding.",
-					}],
-					display: "Supervisor yielded to another session",
-				},
-				{ triggerTurn: false },
-			);
-			deactivateSupervisor(pi, state);
-			return;
-		}
+		if (heartbeatInProgress) return; // Overlap guard (TP-070)
+		heartbeatInProgress = true;
 
-		// Update heartbeat (and refresh batchId if it was initially unknown)
 		try {
-			const lock = readLockfile(stateRoot);
-			if (lock && lock.sessionId === sessionId) {
-				lock.heartbeat = new Date().toISOString();
-				// TP-130: batchId may have been "(initializing)" at lock creation
-				// because the batch hadn't started yet. Refresh from live state ref.
-				if (state.batchStateRef?.batchId && lock.batchId !== state.batchStateRef.batchId) {
-					lock.batchId = state.batchStateRef.batchId;
+			// Read current lockfile to detect force takeover — async (TP-070)
+			const currentLock = await readLockfileAsync(stateRoot);
+			if (currentLock && currentLock.sessionId !== sessionId) {
+				// Another session has taken over — yield gracefully
+				clearInterval(timer);
+				pi.sendMessage(
+					{
+						customType: "supervisor-yield",
+						content: [{
+							type: "text",
+							text: "⚡ Another session has taken over supervisor duties. Yielding.",
+						}],
+						display: "Supervisor yielded to another session",
+					},
+					{ triggerTurn: false },
+				);
+				deactivateSupervisor(pi, state);
+				return;
+			}
+
+			// Update heartbeat (and refresh batchId if it was initially unknown)
+			try {
+				const lock = await readLockfileAsync(stateRoot);
+				if (lock && lock.sessionId === sessionId) {
+					lock.heartbeat = new Date().toISOString();
+					// TP-130: batchId may have been "(initializing)" at lock creation
+					// because the batch hadn't started yet. Refresh from live state ref.
+					if (state.batchStateRef?.batchId && lock.batchId !== state.batchStateRef.batchId) {
+						lock.batchId = state.batchStateRef.batchId;
+					}
+					await writeLockfileAsync(stateRoot, lock);
 				}
-				writeLockfile(stateRoot, lock);
+			} catch {
+				// Best-effort heartbeat — don't crash the supervisor
 			}
-		} catch {
-			// Best-effort heartbeat — don't crash the supervisor
+		} finally {
+			heartbeatInProgress = false;
 		}
 	}, HEARTBEAT_INTERVAL_MS);
 
@@ -3602,6 +3669,39 @@ export function readNewBytes(eventsPath: string, byteOffset: number): [string, n
 	return [buffer.toString("utf-8"), fileSize];
 }
 
+/**
+ * Async version of readNewBytes — reads new bytes without blocking the event loop.
+ *
+ * Uses `fs/promises` for non-blocking stat and read operations.
+ *
+ * @param eventsPath - Full path to events.jsonl
+ * @param byteOffset - Start reading from this byte offset
+ * @returns [newData, newByteOffset]
+ *
+ * @since TP-070
+ */
+export async function readNewBytesAsync(eventsPath: string, byteOffset: number): Promise<[string, number]> {
+	try {
+		const stats = await fsStat(eventsPath);
+		const fileSize = stats.size;
+		if (fileSize <= byteOffset) return ["", byteOffset];
+
+		const bytesToRead = fileSize - byteOffset;
+		const buffer = Buffer.alloc(bytesToRead);
+
+		const fh = await fsOpen(eventsPath, "r");
+		try {
+			await fh.read(buffer, 0, bytesToRead, byteOffset);
+		} finally {
+			await fh.close();
+		}
+
+		return [buffer.toString("utf-8"), fileSize];
+	} catch {
+		return ["", byteOffset];
+	}
+}
+
 /**
  * Parse JSONL lines from raw data, handling partial lines.
  *
@@ -3940,6 +4040,8 @@ export function startEventTailer(
 	pi: ExtensionAPI,
 	tailer: EventTailerState,
 	supervisorState: SupervisorState,
+	/** Optional callback to update footer status immediately (bypasses sendMessage queue). @since TP-068/214 */
+	setStatus?: (key: string, text: string) => void,
 ): void {
 	if (tailer.running) return; // Idempotent guard (R005-2)
 
@@ -3967,6 +4069,15 @@ export function startEventTailer(
 	// Notification callback — sends as a supervisor event message
 	const notify = (text: string) => {
 		if (!supervisorState.active) return; // Guard: don't notify after deactivation
+
+		// TP-068/214: Update footer status immediately for visibility.
+		// setStatus renders in the TUI footer without waiting for user input,
+		// unlike sendMessage which queues until next turn.
+		if (setStatus) {
+			const statusText = text.replace(/\*\*/g, "").replace(/\n.*/s, "").substring(0, 120);
+			setStatus("supervisor", `🔀 ${statusText}`);
+		}
+
 		pi.sendMessage(
 			{
 				customType: "supervisor-event",
@@ -3978,27 +4089,35 @@ export function startEventTailer(
 	};
 
 	// ── TP-043: Integration is triggered by triggerSupervisorIntegration() ──
-	// called from the onTerminal callback in startBatchAsync (extension.ts),
+	// called from the onTerminal callback in startBatchInWorker (extension.ts),
 	// gated on phase === "completed" (R002-1). For auto mode, integration is
 	// executed programmatically via the executor callback (R002-2). The event
 	// tailer does NOT duplicate the integration trigger — batch_complete events
 	// are handled via the normal notification path (formatEventNotification).
 
-	// ── Poll timer ───────────────────────────────────────────────
-	tailer.pollTimer = setInterval(() => {
+	// ── Poll timer (async, TP-070) ───────────────────────────────
+	let tailerPollInProgress = false; // Overlap guard (TP-070)
+	tailer.pollTimer = setInterval(async () => {
 		if (!supervisorState.active || !tailer.running) {
 			stopEventTailer(tailer);
 			return;
 		}
 
-		const [newData, newOffset] = readNewBytes(eventsPath, tailer.byteOffset);
-		if (!newData) return; // No new data
+		if (tailerPollInProgress) return; // Overlap guard (TP-070)
+		tailerPollInProgress = true;
 
-		tailer.byteOffset = newOffset;
-		const [events, remaining] = parseJsonlLines(newData, tailer.partialLine);
-		tailer.partialLine = remaining;
+		try {
+			const [newData, newOffset] = await readNewBytesAsync(eventsPath, tailer.byteOffset);
+			if (!newData) return; // No new data
 
-		processEvents(events, tailer, autonomy, notify);
+			tailer.byteOffset = newOffset;
+			const [events, remaining] = parseJsonlLines(newData, tailer.partialLine);
+			tailer.partialLine = remaining;
+
+			processEvents(events, tailer, autonomy, notify);
+		} finally {
+			tailerPollInProgress = false;
+		}
 	}, EVENT_POLL_INTERVAL_MS);
 
 	// ── Digest flush timer ───────────────────────────────────────

package/package.json

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