taskplane 0.25.6 → 0.25.7

package/dashboard/public/app.js

@@ -79,7 +79,7 @@ function mergeV2LaneSnapshot(legacyLs, v2snap) {
   if (w) {
     // Map V2 agent status to legacy dashboard status strings
     if (w.status) {
-      const statusMap = { running: 'running', spawning: 'running', exited: 'done', crashed: 'error', killed: 'error', timed_out: 'error', wrapping_up: 'running' };
+      const statusMap = { running: 'running', spawning: 'running', exited: 'done', crashed: 'error', killed: 'done', timed_out: 'error', wrapping_up: 'running' };
       base.workerStatus = statusMap[w.status] || w.status;
     }
     if (w.elapsedMs != null) base.workerElapsed = w.elapsedMs;
@@ -1062,9 +1062,15 @@ function renderAgentsPanel(registry) {
   let html = '<div class="agents-grid">';
 
   for (const agent of agents) {
+    const isCrash = ['crashed', 'timed_out'].includes(agent.status);
     const isTerminal = ['exited', 'crashed', 'timed_out', 'killed'].includes(agent.status);
-    const statusClass = isTerminal ? 'agent-terminal' : 'agent-live';
-    const icon = isTerminal ? '\u{1F534}' : '\u{1F7E2}';
+    const statusClass = isTerminal ? (isCrash ? 'agent-terminal agent-crashed' : 'agent-terminal') : 'agent-live';
+    const icon = isCrash ? '\u{1F534}' : (isTerminal ? '\u26AA' : '\u{1F7E2}');
+    // Display label: exited and killed both show as 'shutdown' — the mechanism is an
+    // implementation detail. Only crashed/timed_out warrant a different label.
+    const displayStatus = (agent.status === 'exited' || agent.status === 'killed') ? 'shutdown'
+      : agent.status === 'timed_out' ? 'timed out'
+      : agent.status;
     const elapsed = agent.startedAt ? Math.round((Date.now() - agent.startedAt) / 1000) : 0;
     const elapsedStr = elapsed > 0 ? formatDuration(elapsed * 1000) : '';
 
@@ -1074,7 +1080,7 @@ function renderAgentsPanel(registry) {
     html += `<span class="agent-badge">${escapeHtml(agent.role)}</span>`;
     if (agent.laneNumber != null) html += `<span class="agent-badge">lane ${agent.laneNumber}</span>`;
     if (agent.taskId) html += `<span class="agent-badge">${escapeHtml(agent.taskId)}</span>`;
-    html += `<span class="agent-badge agent-status-${agent.status}">${escapeHtml(agent.status)}</span>`;
+    html += `<span class="agent-badge agent-status-${agent.status}">${escapeHtml(displayStatus)}</span>`;
     if (elapsedStr && !isTerminal) html += `<span class="agent-badge">${elapsedStr}</span>`;
     html += `</div>`;
     html += `</div>`;

package/dashboard/public/style.css

@@ -817,8 +817,9 @@ body {
 .worker-last-tool {
   color: var(--text-muted);
   max-width: 600px;
-  overflow: hidden;
-  text-overflow: ellipsis;
+  overflow-wrap: break-word;
+  word-break: break-all;
+  white-space: normal;
 }
 
 /* ─── Reviewer Sub-Row ─────────────────────────────────────────────── */
@@ -1774,10 +1775,10 @@ body {
 }
 .agent-status-running { color: var(--green); }
 .agent-status-spawning { color: var(--yellow); }
-.agent-status-exited { color: var(--text-faint); }
+.agent-status-exited { color: var(--text-faint); }   /* displayed as 'shutdown' */
+.agent-status-killed { color: var(--text-faint); }   /* displayed as 'shutdown' */
 .agent-status-crashed { color: var(--red); }
-.agent-status-killed { color: var(--red); }
-.agent-status-timed_out { color: var(--yellow); }
+.agent-status-timed_out { color: var(--red); }
 
 /* TP-107: Messages Panel */
 .messages-list {

package/dashboard/server.cjs

@@ -194,9 +194,21 @@ function parseStatusMd(taskFolder) {
 }
 
 function getActiveSessions() {
-  // Runtime V2 no longer relies on external terminal multiplexers for liveness.
-  // Dashboard session data is driven by runtime registry + persisted state.
-  return [];
+  // Runtime V2: return active merger session names from the runtime registry
+  // so the dashboard merge pane can display live telemetry for running agents.
+  // Terminal statuses indicate the agent is no longer alive.
+  const TERMINAL_STATUSES = new Set(["exited", "killed", "crashed", "timed_out"]);
+  try {
+    const state = loadBatchState();
+    if (!state || !state.batchId) return [];
+    const registry = loadRuntimeRegistry(state.batchId);
+    if (!registry || !registry.agents) return [];
+    return Object.values(registry.agents)
+      .filter(a => a.role === "merger" && !TERMINAL_STATUSES.has(a.status))
+      .map(a => a.agentId);
+  } catch {
+    return [];
+  }
 }
 
 function checkDoneFile(taskFolder) {
@@ -406,6 +418,33 @@ function loadRuntimeLaneSnapshots(batchId) {
   return snapshots;
 }
 
+/**
+ * Load Runtime V2 merge agent snapshots for the current batch.
+ *
+ * Reads all `merge-N.json` files from `.pi/runtime/{batchId}/lanes/`.
+ * Returns a map of mergeNumber (string) → snapshot data.
+ *
+ * Follows the same pattern as {@link loadRuntimeLaneSnapshots}.
+ *
+ * @since TP-164
+ */
+function loadRuntimeMergeSnapshots(batchId) {
+  if (!batchId) return {};
+  const lanesDir = path.join(REPO_ROOT, ".pi", "runtime", batchId, "lanes");
+  const snapshots = {};
+  try {
+    if (!fs.existsSync(lanesDir)) return snapshots;
+    const files = fs.readdirSync(lanesDir).filter(f => f.startsWith("merge-") && f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(lanesDir, file), "utf-8"));
+        if (data.mergeNumber != null) snapshots[data.mergeNumber] = data;
+      } catch { continue; }
+    }
+  } catch { /* dir missing */ }
+  return snapshots;
+}
+
 /**
  * Load Runtime V2 agent events for a specific agent.
  * Returns the last N events from the agent's events.jsonl.
@@ -1077,6 +1116,46 @@ function buildDashboardState() {
   const runtimeLaneSnapshots = loadRuntimeLaneSnapshots(state.batchId);
   const mailboxData = loadMailboxData(state.batchId);
 
+  // TP-164: Load merge agent snapshots for live dashboard telemetry.
+  const runtimeMergeSnapshots = loadRuntimeMergeSnapshots(state.batchId);
+
+  // TP-164: Inject merge snapshot telemetry into the telemetry map so
+  // `telemetry[sessionName]` resolves for the merge pane.
+  // Only inject when a JSONL-backed entry is absent or stale — the snapshot
+  // provides real-time tool-call / cost / context data even before the
+  // JSONL accumulator has accumulated enough events.
+  for (const snap of Object.values(runtimeMergeSnapshots)) {
+    const key = snap.sessionName;
+    if (!key) continue;
+    const agent = snap.agent;
+    if (!agent) continue;
+    // Only inject if there is no existing telemetry entry, or if the snapshot
+    // is more recent than the latest accumulator update.
+    const existing = telemetry[key];
+    if (!existing || (snap.updatedAt && snap.updatedAt > (existing._updatedAt || 0))) {
+      telemetry[key] = {
+        inputTokens: agent.inputTokens || 0,
+        outputTokens: agent.outputTokens || 0,
+        cacheReadTokens: agent.cacheReadTokens || 0,
+        cacheWriteTokens: agent.cacheWriteTokens || 0,
+        cost: agent.costUsd || 0,
+        toolCalls: agent.toolCalls || 0,
+        lastTool: agent.lastTool || "",
+        currentTool: snap.status === "running" ? (agent.lastTool || "") : "",
+        contextPct: agent.contextPct || 0,
+        // startedAt is not in the snapshot; compute from elapsed if possible.
+        startedAt: agent.elapsedMs > 0 ? snap.updatedAt - agent.elapsedMs : snap.updatedAt,
+        retries: 0,
+        retryActive: false,
+        lastRetryError: "",
+        compactions: 0,
+        latestTotalTokens: (agent.inputTokens || 0) + (agent.outputTokens || 0),
+        _updatedAt: snap.updatedAt,
+        _source: "merge-snapshot",
+      };
+    }
+  }
+
   // TP-115: Synthesize laneStates from V2 snapshots so the dashboard
   // pipeline works without legacy lane-state-*.json sidecar files.
   // V2 snapshots are authoritative when present.
@@ -1099,6 +1178,8 @@ function buildDashboardState() {
     // Runtime V2 data (null/empty for legacy batches)
     runtimeRegistry,
     runtimeLaneSnapshots,
+    // TP-164: Merge agent snapshots for live dashboard telemetry.
+    runtimeMergeSnapshots,
     mailbox: mailboxData,
     batch: {
       batchId: state.batchId,

package/extensions/taskplane/agent-bridge-extension.ts

@@ -429,12 +429,22 @@ export default function (pi: ExtensionAPI) {
 		// Pre-clean stale reviewer state from prior interrupted review
 		removeReviewerState(taskFolder);
 		return new Promise((resolve) => {
+			// Read reviewer config from env vars set by lane-runner from runnerConfig.reviewer.
+			// Empty string means inherit from session default (no flag passed to pi CLI).
+			const reviewerModel = process.env.TASKPLANE_REVIEWER_MODEL || "";
+			const reviewerThinking = process.env.TASKPLANE_REVIEWER_THINKING || "";
+			// Fall back to the schema default reviewer tool list (read-only + bash/grep).
+			// Must match config-schema.ts reviewer.tools default to avoid capability expansion.
+			const reviewerTools = process.env.TASKPLANE_REVIEWER_TOOLS || "read,bash,grep,find,ls";
+
 			const cliPath = resolvePiCliPath();
 			const args = [
 				cliPath, "--mode", "rpc", "--no-session", "--no-extensions", "--no-skills",
-				"--tools", "read,write,edit,bash,grep,find,ls",
+				"--tools", reviewerTools,
 				"--system-prompt", systemPrompt,
 			];
+			if (reviewerModel) args.push("--model", reviewerModel);
+			if (reviewerThinking) args.push("--thinking", reviewerThinking);
 			const proc = nodeSpawn(process.execPath, args, {
 				shell: false,
 				cwd,

package/extensions/taskplane/agent-host.ts

@@ -561,8 +561,8 @@ export function spawnAgent(
 					case "tool_execution_start": {
 						toolCalls++;
 						const toolName = event.toolName || "tool";
-						const argPreview = typeof event.args === "string" ? event.args.slice(0, 80) :
-							(event.args && typeof Object.values(event.args)[0] === "string" ? String(Object.values(event.args)[0]).slice(0, 80) : "");
+						const argPreview = typeof event.args === "string" ? event.args.slice(0, 300) :
+							(event.args && typeof Object.values(event.args)[0] === "string" ? String(Object.values(event.args)[0]).slice(0, 300) : "");
 						lastTool = argPreview ? `${toolName}: ${argPreview}` : toolName;
 						// TP-111: Bounded payload only — no raw args in durable event log
 						const toolPath = event.args?.path ? String(event.args.path).slice(0, 200) : "";

package/extensions/taskplane/config-loader.ts

@@ -1177,6 +1177,11 @@ export function toTaskRunnerConfig(config: TaskplaneConfig): import("./types.ts"
 		reference_docs: { ...config.taskRunner.referenceDocs },
 		...(hasTestingCommands ? { testing_commands: { ...testingCommands } } : {}),
 		model_fallback: config.taskRunner.modelFallback ?? "inherit",
+		reviewer: {
+			model: config.taskRunner.reviewer.model,
+			thinking: config.taskRunner.reviewer.thinking,
+			tools: config.taskRunner.reviewer.tools,
+		},
 	};
 }
 

package/extensions/taskplane/engine.ts

@@ -6,7 +6,7 @@ import { existsSync, readdirSync, readFileSync, renameSync, unlinkSync } from "f
 import { join, resolve } from "path";
 
 import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
-import { computeTransitiveDependents, execLog, executeLaneV2, executeWave, killV2LaneAgents } from "./execution.ts";
+import { buildReviewerEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, killV2LaneAgents } from "./execution.ts";
 import type { RuntimeBackend } from "./execution.ts";
 import type { MonitorUpdateCallback } from "./execution.ts";
 // classifyExit no longer called directly — Tier 0 uses exitDiagnostic.classification
@@ -1307,7 +1307,7 @@ async function attemptWorkerCrashRetry(
 				retryPauseSignal,
 				wsRoot,
 				isWsMode,
-				{ ORCH_BATCH_ID: batchState.batchId }, // TP-089: ensure mailbox works for retries
+				{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig?.reviewer) }, // TP-089: ensure mailbox works for retries
 			);
 
 			const retryOutcome = retryResult.tasks[0];
@@ -1566,7 +1566,7 @@ async function attemptModelFallbackRetry(
 			// Pass TASKPLANE_MODEL_FALLBACK=1 as extra env var to signal
 			// the task-runner to use the session model instead of configured model.
 			// TP-089: Also include ORCH_BATCH_ID so mailbox steering works for retries.
-			const modelFallbackEnv = { TASKPLANE_MODEL_FALLBACK: "1", ORCH_BATCH_ID: batchState.batchId };
+			const modelFallbackEnv = { TASKPLANE_MODEL_FALLBACK: "1", ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig?.reviewer) };
 			const retryResult = await executeLaneV2(
 				retryLane,
 				orchConfig,
@@ -1706,6 +1706,7 @@ async function attemptStaleWorktreeRecovery(
 	runtimeBackend?: RuntimeBackend,
 	onSupervisorAlert?: SupervisorAlertCallback,
 	supervisorAutonomy: "interactive" | "supervised" | "autonomous" = "autonomous",
+	runnerConfig?: TaskRunnerConfig,
 ): Promise<WaveExecutionResult | null> {
 	// Only attempt recovery for ALLOC_WORKTREE_FAILED
 	if (!waveResult.allocationError || waveResult.allocationError.code !== "ALLOC_WORKTREE_FAILED") {
@@ -1808,6 +1809,11 @@ async function attemptStaleWorktreeRecovery(
 		runtimeBackend,
 		onSupervisorAlert,
 		supervisorAutonomy,
+		{
+			model: runnerConfig?.reviewer?.model || "",
+			thinking: runnerConfig?.reviewer?.thinking || "",
+			tools: runnerConfig?.reviewer?.tools || "",
+		},
 	);
 
 	return retryResult;
@@ -2376,6 +2382,11 @@ export async function executeOrchBatch(
 			selectedBackend,
 			emitAlert,
 			supervisorAutonomy,
+			{
+				model: runnerConfig?.reviewer?.model || "",
+				thinking: runnerConfig?.reviewer?.thinking || "",
+				tools: runnerConfig?.reviewer?.tools || "",
+			},
 		);
 
 		// ── TP-039: Tier 0 — Stale worktree recovery ────────────
@@ -2398,6 +2409,7 @@ export async function executeOrchBatch(
 				selectedBackend,
 				emitAlert,
 				supervisorAutonomy,
+				runnerConfig,
 			);
 			if (retryResult) {
 				const staleRecovered = !retryResult.allocationError;

package/extensions/taskplane/execution.ts

@@ -1411,6 +1411,7 @@ export function ensureTaskFilesCommitted(
 	pending: Map<string, ParsedTask>,
 	repoRoot: string,
 	waveIndex: number,
+	orchBranch?: string,
 ): void {
 	// Collect task folder paths for this wave
 	const foldersToCheck: { taskId: string; relPath: string }[] = [];
@@ -1477,6 +1478,121 @@ export function ensureTaskFilesCommitted(
 		folders: foldersToStage,
 		commit: commitResult.stdout.trim().split("\n")[0],
 	});
+
+	// Fast-forward (or merge) the orch branch to include the staging commit so
+	// that worktrees—which branch from orchBranch—see the new task files and
+	// workers can find their PROMPT.md / STATUS.md without an ENOENT crash.
+	//
+	// The orch branch was created from baseBranch before executeWave runs, so in
+	// wave 1 it is always an ancestor of HEAD and a plain fast-forward applies.
+	// In wave 2+ the orch branch may have advanced due to prior wave merges
+	// (commits from worker worktrees merged back). In that case we create a merge
+	// commit so the task files become visible without rewinding any wave history.
+	//
+	// Failure here is non-fatal: the commit already succeeded; if the ref update
+	// fails the subsequent worktree allocation will produce a clear error.
+	if (orchBranch) {
+		try {
+			const headRes = runGit(["rev-parse", "HEAD"], repoRoot);
+			const orchTipRes = runGit(["rev-parse", `refs/heads/${orchBranch}`], repoRoot);
+
+			if (headRes.ok && orchTipRes.ok) {
+				const newHead = headRes.stdout.trim();
+				const orchTip = orchTipRes.stdout.trim();
+
+				// Check whether the orch branch tip is an ancestor of the new HEAD
+				// (i.e., a fast-forward is safe and sufficient).
+				const ancestorCheck = runGit(
+					["merge-base", "--is-ancestor", orchTip, newHead],
+					repoRoot,
+				);
+
+				if (ancestorCheck.ok) {
+					// FF case: orch branch is behind HEAD — move it forward.
+					// Expected-old-sha semantics guard against concurrent ref moves.
+					const ffResult = runGit(
+						["update-ref", `refs/heads/${orchBranch}`, newHead, orchTip],
+						repoRoot,
+					);
+					if (ffResult.ok) {
+						execLog("wave", `W${waveIndex}`, `fast-forwarded orch branch to include staging commit`, {
+							orchBranch,
+							from: orchTip.slice(0, 8),
+							to: newHead.slice(0, 8),
+						});
+					} else {
+						execLog("wave", `W${waveIndex}`, `warning: failed to fast-forward orch branch (non-fatal)`, {
+							orchBranch,
+							error: ffResult.stderr,
+						});
+					}
+				} else {
+					// Non-FF case: orch branch has advanced due to prior wave merges.
+					// Create a merge commit so the new task files become visible in
+					// worktrees without discarding any accumulated wave history.
+					// Requires git ≥ 2.38 for `merge-tree --write-tree`.
+					const mergeTreeRes = runGit(
+						["merge-tree", "--write-tree", orchTip, newHead],
+						repoRoot,
+					);
+					if (mergeTreeRes.ok) {
+						// First line of stdout is the merged tree SHA.
+						// git merge-tree --write-tree exits 0 on clean merge, non-zero on conflicts.
+						// Since it exited 0, the tree should be conflict-free, but validate
+						// the SHA looks like a valid 40-hex OID before using it.
+						const mergedTree = mergeTreeRes.stdout.trim().split("\n")[0];
+						if (!/^[0-9a-f]{40}$/i.test(mergedTree)) {
+							execLog("wave", `W${waveIndex}`, `warning: merge-tree returned unexpected output (non-fatal)`, {
+								orchBranch,
+								output: mergedTree.slice(0, 60),
+							});
+						} else {
+							const mergeCommitMsg = `merge: include staged task files for wave ${waveIndex} into orch branch`;
+							const commitTreeRes = runGit(
+								["commit-tree", mergedTree, "-p", orchTip, "-p", newHead, "-m", mergeCommitMsg],
+								repoRoot,
+							);
+							if (commitTreeRes.ok) {
+								const mergeCommitSha = commitTreeRes.stdout.trim();
+								const refUpdateRes = runGit(
+									["update-ref", `refs/heads/${orchBranch}`, mergeCommitSha, orchTip],
+									repoRoot,
+								);
+								if (refUpdateRes.ok) {
+									execLog("wave", `W${waveIndex}`, `merged staging commit into orch branch (non-FF wave)`, {
+										orchBranch,
+										orchTip: orchTip.slice(0, 8),
+										newHead: newHead.slice(0, 8),
+										mergeCommit: mergeCommitSha.slice(0, 8),
+									});
+								} else {
+									execLog("wave", `W${waveIndex}`, `warning: failed to update orch branch ref after merge-tree (non-fatal)`, {
+										orchBranch,
+										error: refUpdateRes.stderr,
+									});
+								}
+							} else {
+								execLog("wave", `W${waveIndex}`, `warning: failed to create merge commit for orch branch (non-fatal)`, {
+									orchBranch,
+									error: commitTreeRes.stderr,
+								});
+							}
+						} // end valid tree SHA
+					} else {
+						execLog("wave", `W${waveIndex}`, `warning: failed to compute merge-tree for orch branch (non-fatal; requires git ≥ 2.38)`, {
+							orchBranch,
+							error: mergeTreeRes.stderr,
+						});
+					}
+				}
+			}
+		} catch (refErr: unknown) {
+			execLog("wave", `W${waveIndex}`, `warning: orch branch ref update threw unexpectedly (non-fatal)`, {
+				orchBranch,
+				error: refErr instanceof Error ? refErr.message : String(refErr),
+			});
+		}
+	}
 }
 
 // ── Wave Execution Core ──────────────────────────────────────────────
@@ -1515,7 +1631,7 @@ export function ensureTaskFilesCommitted(
  * @param batchId           - Batch ID for naming
  * @param pauseSignal       - Shared pause signal (mutated by stop-wave policy)
  * @param dependencyGraph   - Dependency graph for computing transitive dependents
- * @param baseBranch        - Branch to base worktrees on (captured at batch start)
+ * @param orchBranch        - Orch branch to base worktrees on (and to update after staging commits)
  * @param onMonitorUpdate   - Optional callback for dashboard updates during monitoring
  * @param onLanesAllocated  - Optional callback fired after lane allocation succeeds
  * @param workspaceConfig   - Workspace configuration for repo routing (null/undefined = repo mode)
@@ -1540,13 +1656,14 @@ export async function executeWave(
 	batchId: string,
 	pauseSignal: { paused: boolean },
 	dependencyGraph: DependencyGraph,
-	baseBranch: string,
+	orchBranch: string,
 	onMonitorUpdate?: MonitorUpdateCallback,
 	onLanesAllocated?: (lanes: AllocatedLane[]) => void,
 	workspaceConfig?: WorkspaceConfig | null,
 	runtimeBackend?: RuntimeBackend,
 	onSupervisorAlert?: SupervisorAlertCallback,
 	supervisorAutonomy: "interactive" | "supervised" | "autonomous" = "autonomous",
+	reviewerConfig?: { model?: string; thinking?: string; tools?: string },
 ): Promise<WaveExecutionResult> {
 	const startedAt = Date.now();
 	const policy = config.failure.on_task_failure;
@@ -1561,8 +1678,10 @@ export async function executeWave(
 	// Task folders may contain untracked files (PROMPT.md, STATUS.md) that
 	// won't appear in worktrees unless committed. Stage and commit them now,
 	// before worktree creation, so workers can find their TASK_AUTOSTART paths.
+	// Pass orchBranch so the staging commit is reflected in the orch branch
+	// before worktrees are allocated from it.
 	try {
-		ensureTaskFilesCommitted(waveTasks, pending, repoRoot, waveIndex);
+		ensureTaskFilesCommitted(waveTasks, pending, repoRoot, waveIndex, orchBranch);
 	} catch (err: unknown) {
 		const errMsg = err instanceof Error ? err.message : String(err);
 		execLog("wave", `W${waveIndex}`, `task file commit failed: ${errMsg}`);
@@ -1586,7 +1705,7 @@ export async function executeWave(
 	}
 
 	// ── Stage 1: Allocate lanes ──────────────────────────────────
-	const allocResult = allocateLanes(waveTasks, pending, config, repoRoot, batchId, baseBranch, workspaceConfig);
+	const allocResult = allocateLanes(waveTasks, pending, config, repoRoot, batchId, orchBranch, workspaceConfig);
 
 	if (!allocResult.success) {
 		const errMsg = allocResult.error?.message || "Unknown allocation failure";
@@ -1651,6 +1770,7 @@ export async function executeWave(
 		executeLaneV2(lane, config, repoRoot, wavePauseSignal, wsRoot, isWsMode, {
 			ORCH_BATCH_ID: batchId,
 			TASKPLANE_SUPERVISOR_AUTONOMY: supervisorAutonomy,
+			...buildReviewerEnv(reviewerConfig),
 		}, onSupervisorAlert),
 	);
 
@@ -2162,6 +2282,27 @@ import { executeTaskV2, type LaneRunnerConfig, type LaneRunnerTaskResult } from
  *
  * @since TP-105
  */
+
+/**
+ * Build reviewer env vars from a TaskRunnerConfig or reviewer config object.
+ * Used to ensure reviewer config is consistently passed to executeLaneV2
+ * across all call sites (initial waves, resume, retries).
+ *
+ * Returns only the keys that have non-empty values, so that empty/inherit
+ * config does not override inherited env vars from the parent process.
+ *
+ * @since TP-160
+ */
+export function buildReviewerEnv(
+	reviewerConfig?: { model?: string; thinking?: string; tools?: string } | null,
+): Record<string, string> {
+	const env: Record<string, string> = {};
+	if (reviewerConfig?.model) env.TASKPLANE_REVIEWER_MODEL = reviewerConfig.model;
+	if (reviewerConfig?.thinking) env.TASKPLANE_REVIEWER_THINKING = reviewerConfig.thinking;
+	if (reviewerConfig?.tools) env.TASKPLANE_REVIEWER_TOOLS = reviewerConfig.tools;
+	return env;
+}
+
 export async function executeLaneV2(
 	lane: AllocatedLane,
 	config: OrchestratorConfig,
@@ -2247,6 +2388,9 @@ export async function executeLaneV2(
 			workerTools: "read,write,edit,bash,grep,find,ls",
 			workerThinking: "",
 			workerSystemPrompt,
+			reviewerModel: extraEnvVars?.TASKPLANE_REVIEWER_MODEL || "",
+			reviewerThinking: extraEnvVars?.TASKPLANE_REVIEWER_THINKING || "",
+			reviewerTools: extraEnvVars?.TASKPLANE_REVIEWER_TOOLS || "",
 			supervisorAutonomy,
 			projectName: config.project?.name || "project",
 			maxIterations: 20,

package/extensions/taskplane/lane-runner.ts

@@ -92,6 +92,22 @@ export interface LaneRunnerConfig {
 	workerThinking: string;
 	/** Worker system prompt */
 	workerSystemPrompt: string;
+	/**
+	 * Reviewer model (empty string = inherit session default).
+	 * Set from TASKPLANE_REVIEWER_MODEL env var, sourced from runnerConfig.reviewer.model.
+	 * @since TP-160
+	 */
+	reviewerModel: string;
+	/**
+	 * Reviewer thinking mode (empty string = inherit).
+	 * @since TP-160
+	 */
+	reviewerThinking: string;
+	/**
+	 * Reviewer tool allowlist (comma-separated).
+	 * @since TP-160
+	 */
+	reviewerTools: string;
 	/** Supervisor autonomy level for bridge-tool guards. */
 	supervisorAutonomy?: "interactive" | "supervised" | "autonomous";
 	/** Project name (for review request context) */
@@ -331,6 +347,9 @@ export async function executeTaskV2(
 				TASKPLANE_ACTIVE_SEGMENT_ID: segmentId ?? "",
 				TASKPLANE_SUPERVISOR_AUTONOMY: config.supervisorAutonomy || "autonomous",
 				ORCH_BATCH_ID: config.batchId,
+				...(config.reviewerModel ? { TASKPLANE_REVIEWER_MODEL: config.reviewerModel } : {}),
+				...(config.reviewerThinking ? { TASKPLANE_REVIEWER_THINKING: config.reviewerThinking } : {}),
+				...(config.reviewerTools ? { TASKPLANE_REVIEWER_TOOLS: config.reviewerTools } : {}),
 			},
 		};
 

package/extensions/taskplane/merge.ts

@@ -10,9 +10,9 @@ import { join, dirname, resolve, relative } from "path";
 import { execLog, isV2AgentAlive, setV2LivenessRegistryCache } 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, 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";
+import type { AllocatedLane, LaneExecutionResult, MergeLaneResult, MergeResult, MergeResultStatus, MergeWaveResult, OrchestratorConfig, RepoMergeOutcome, TaskRunnerConfig, TransactionRecord, TransactionStatus, VerificationBaselineResult, WaveExecutionResult, WorkspaceConfig, MergeHealthStatus, MergeHealthEventType, MergeSessionSnapshot, MergeSessionHealthState, EngineEvent, OrchBatchPhase, RuntimeMergeSnapshot, RuntimeAgentTelemetrySnapshot } from "./types.ts";
 import { resolveBaseBranch, resolveRepoRoot } from "./waves.ts";
-import { readManifest, writeManifest, buildRegistrySnapshot, writeRegistrySnapshot, readRegistrySnapshot } from "./process-registry.ts";
+import { readManifest, writeManifest, buildRegistrySnapshot, writeRegistrySnapshot, readRegistrySnapshot, writeMergeSnapshot } from "./process-registry.ts";
 import { generateMergeWorktreePath, sleepAsync, sleepSync } from "./worktree.ts";
 import { getCurrentBranch, runGit } from "./git.ts";
 import { ORCH_MESSAGES } from "./messages.ts";
@@ -20,7 +20,7 @@ import { emitEngineEvent } from "./persistence.ts";
 import { loadOrchestratorConfig } from "./config.ts";
 import { captureBaseline, diffFingerprints, runVerificationCommands, parseTestOutput, deduplicateFingerprints } from "./verification.ts";
 import { spawnAgent } from "./agent-host.ts";
-import type { AgentHostOptions, AgentHostResult } from "./agent-host.ts";
+import type { AgentHostOptions, AgentHostResult, AgentTelemetryCallback } from "./agent-host.ts";
 import type { RuntimeBackend } from "./execution.ts";
 import type { VerificationBaseline, FingerprintDiff, TestFingerprint } from "./verification.ts";
 
@@ -614,14 +614,69 @@ export async function spawnMergeAgentV2(
 		},
 	};
 
-	const { promise, kill } = spawnAgent(opts);
+	// Derive the 1-indexed merge number from the session name
+	// (e.g. "orch-henry-merge-1" → 1, "orch-henry-merge-2" → 2).
+	const mergeNumberMatch = sessionName.match(/-merge-(\d+)$/);
+	const mergeNumber = mergeNumberMatch ? parseInt(mergeNumberMatch[1], 10) : 1;
+	const mergeStartedAt = Date.now();
+	const mergeStateRoot = stateRoot ?? repoRoot;
+
+	// Helper: build a RuntimeAgentTelemetrySnapshot from a partial AgentHostResult.
+	const buildAgentSnap = (tel: Partial<AgentHostResult>, status: RuntimeAgentTelemetrySnapshot["status"]): RuntimeAgentTelemetrySnapshot => ({
+		agentId: sessionName,
+		status,
+		elapsedMs: tel.durationMs ?? (Date.now() - mergeStartedAt),
+		toolCalls: tel.toolCalls ?? 0,
+		contextPct: tel.contextUsage?.percent ?? 0,
+		costUsd: tel.costUsd ?? 0,
+		lastTool: tel.lastTool ?? "",
+		inputTokens: tel.inputTokens ?? 0,
+		outputTokens: tel.outputTokens ?? 0,
+		cacheReadTokens: tel.cacheReadTokens ?? 0,
+		cacheWriteTokens: tel.cacheWriteTokens ?? 0,
+	});
+
+	// Telemetry callback: write a merge snapshot on every telemetry update.
+	// Non-fatal — snapshot writes must never interfere with merge execution.
+	const onMergeTelemetry: AgentTelemetryCallback = (tel) => {
+		try {
+			const snap: RuntimeMergeSnapshot = {
+				batchId: bid,
+				mergeNumber,
+				sessionName,
+				waveIndex: 0,
+				status: "running",
+				agent: buildAgentSnap(tel, "running"),
+				updatedAt: Date.now(),
+			};
+			writeMergeSnapshot(mergeStateRoot, bid, mergeNumber, snap);
+		} catch { /* non-fatal */ }
+	};
+
+	const { promise, kill } = spawnAgent(opts, undefined, onMergeTelemetry);
+
+	// Write an initial "running" snapshot immediately so the dashboard row
+	// appears even when the first telemetry event is delayed.
+	try {
+		const initialSnap: RuntimeMergeSnapshot = {
+			batchId: bid,
+			mergeNumber,
+			sessionName,
+			waveIndex: 0,
+			status: "running",
+			agent: buildAgentSnap({}, "running"),
+			updatedAt: Date.now(),
+		};
+		writeMergeSnapshot(mergeStateRoot, bid, mergeNumber, initialSnap);
+	} catch { /* non-fatal */ }
 
 	// Store the kill handle for external cleanup (pause/abort).
 	// The promise runs in background — caller uses waitForMergeResult()
 	// to poll for the result file, same contract as the legacy session path.
-	activeMergeAgents.set(sessionName, { promise, kill, stateRoot: stateRoot ?? repoRoot, batchId: bid });
+	activeMergeAgents.set(sessionName, { promise, kill, stateRoot: mergeStateRoot, batchId: bid });
 
-	// Fire-and-forget: the background promise handles exit logging
+	// Fire-and-forget: the background promise handles exit logging and
+	// writes a terminal snapshot ("complete" or "failed") when the agent exits.
 	promise.then(result => {
 		activeMergeAgents.delete(sessionName);
 		execLog("merge", sessionName, "merge agent exited (V2)", {
@@ -630,9 +685,39 @@ export async function spawnMergeAgentV2(
 			costUsd: result.costUsd,
 			killed: result.killed,
 		});
+		// Write terminal snapshot. Promise resolves for both successful and
+		// failed exits, so derive status from result fields rather than
+		// relying on .catch to handle failures.
+		const terminalStatus: RuntimeMergeSnapshot["status"] =
+			(result.killed || result.exitCode !== 0 || !result.agentEnded) ? "failed" : "complete";
+		try {
+			const snap: RuntimeMergeSnapshot = {
+				batchId: bid,
+				mergeNumber,
+				sessionName,
+				waveIndex: 0,
+				status: terminalStatus,
+				agent: buildAgentSnap(result, terminalStatus === "complete" ? "exited" : "crashed"),
+				updatedAt: Date.now(),
+			};
+			writeMergeSnapshot(mergeStateRoot, bid, mergeNumber, snap);
+		} catch { /* non-fatal */ }
 	}).catch(err => {
 		activeMergeAgents.delete(sessionName);
 		execLog("merge", sessionName, `merge agent error (V2): ${err instanceof Error ? err.message : String(err)}`);
+		// Write a failed terminal snapshot on unexpected rejection.
+		try {
+			const snap: RuntimeMergeSnapshot = {
+				batchId: bid,
+				mergeNumber,
+				sessionName,
+				waveIndex: 0,
+				status: "failed",
+				agent: buildAgentSnap({}, "crashed"),
+				updatedAt: Date.now(),
+			};
+			writeMergeSnapshot(mergeStateRoot, bid, mergeNumber, snap);
+		} catch { /* non-fatal */ }
 	});
 }
 

package/extensions/taskplane/process-registry.ts

@@ -30,12 +30,14 @@ import {
 	runtimeRegistryPath,
 	runtimeAgentEventsPath,
 	runtimeLaneSnapshotPath,
+	runtimeMergeSnapshotPath,
 	validateAgentManifest,
 	type RuntimeAgentId,
 	type RuntimeAgentManifest,
 	type RuntimeAgentRole,
 	type RuntimeAgentStatus,
 	type RuntimeRegistry,
+	type RuntimeMergeSnapshot,
 	type PacketPaths,
 } from "./types.ts";
 
@@ -362,3 +364,53 @@ export function readLaneSnapshot(
 		return null;
 	}
 }
+
+/**
+ * Write a V2 merge agent snapshot to disk (atomic rename).
+ *
+ * Stored in the `lanes/` directory alongside lane snapshots so the dashboard
+ * server picks it up with the same scan that reads lane-N.json files.
+ *
+ * @param stateRoot   - Repository root (where `.pi/` lives)
+ * @param batchId     - Current batch identifier
+ * @param mergeNumber - 1-indexed merge agent number
+ * @param snapshot    - Snapshot data to persist
+ *
+ * @since TP-164
+ */
+export function writeMergeSnapshot(
+	stateRoot: string,
+	batchId: string,
+	mergeNumber: number,
+	snapshot: RuntimeMergeSnapshot,
+): void {
+	const path = runtimeMergeSnapshotPath(stateRoot, batchId, mergeNumber);
+	mkdirSync(dirname(path), { recursive: true });
+	const tmpPath = path + ".tmp";
+	writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+	renameSync(tmpPath, path);
+}
+
+/**
+ * Read a V2 merge agent snapshot from disk.
+ * Returns null if the file does not exist or is unreadable.
+ *
+ * @param stateRoot   - Repository root (where `.pi/` lives)
+ * @param batchId     - Current batch identifier
+ * @param mergeNumber - 1-indexed merge agent number
+ *
+ * @since TP-164
+ */
+export function readMergeSnapshot(
+	stateRoot: string,
+	batchId: string,
+	mergeNumber: number,
+): RuntimeMergeSnapshot | null {
+	try {
+		const p = runtimeMergeSnapshotPath(stateRoot, batchId, mergeNumber);
+		if (!existsSync(p)) return null;
+		return JSON.parse(readFileSync(p, "utf-8")) as RuntimeMergeSnapshot;
+	} catch {
+		return null;
+	}
+}

package/extensions/taskplane/resume.ts

@@ -8,7 +8,7 @@ import { join } from "path";
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
 import { executeOrchBatch } from "./engine.ts";
-import { computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
+import { buildReviewerEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
 import { selectRuntimeBackend } from "./engine.ts";
 import { readRegistrySnapshot, isTerminalStatus, isProcessAlive } from "./process-registry.ts";
@@ -1461,7 +1461,7 @@ export async function resumeOrchBatch(
 				const laneResult = await executeLaneV2(
 					lane, orchConfig, laneRepoRoot, batchState.pauseSignal,
 					workspaceRoot, !!workspaceConfig,
-					{ ORCH_BATCH_ID: batchState.batchId },
+					{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig.reviewer) },
 					emitAlert,
 				);
 				const taskResult = laneResult.tasks.find(t => t.taskId === task.taskId);
@@ -1543,7 +1543,7 @@ export async function resumeOrchBatch(
 				const laneResult = await executeLaneV2(
 					lane, orchConfig, reExecRepoRoot, batchState.pauseSignal,
 					workspaceRoot, !!workspaceConfig,
-					{ ORCH_BATCH_ID: batchState.batchId },
+					{ ORCH_BATCH_ID: batchState.batchId, ...buildReviewerEnv(runnerConfig.reviewer) },
 					emitAlert,
 				);
 				const taskResult = laneResult.tasks.find(t => t.taskId === task.taskId);
@@ -1994,6 +1994,7 @@ export async function resumeOrchBatch(
 			resumeBackend,
 			emitAlert,
 			supervisorAutonomy,
+			runnerConfig.reviewer,
 		);
 
 		batchState.waveResults.push(waveResult);

package/extensions/taskplane/types.ts

@@ -291,6 +291,19 @@ export interface TaskRunnerConfig {
 	 * @since TP-055
 	 */
 	model_fallback?: "inherit" | "fail";
+	/**
+	 * Reviewer agent model/thinking/tools configuration.
+	 * Threaded through to `spawnReviewer()` via env vars.
+	 * @since TP-160
+	 */
+	reviewer?: {
+		/** Model string (empty = inherit session default) */
+		model: string;
+		/** Thinking mode ("on" | "off" | budget string, empty = inherit) */
+		thinking: string;
+		/** Comma-separated tool allowlist */
+		tools: string;
+	};
 }
 
 /** Result of a preflight check */
@@ -4062,6 +4075,50 @@ export function runtimeLaneSnapshotPath(stateRoot: string, batchId: string, lane
 	return `${stateRoot}/.pi/runtime/${batchId}/lanes/lane-${laneNumber}.json`;
 }
 
+/**
+ * Telemetry snapshot for a merge agent.
+ *
+ * Written to `.pi/runtime/{batchId}/lanes/merge-{mergeNumber}.json` alongside
+ * lane snapshots so the dashboard can display live merge-phase telemetry.
+ * Follows the same file-backed pattern as {@link RuntimeLaneSnapshot} but is
+ * simpler — merge agents have no reviewer, progress tracking, or repoId.
+ *
+ * @since TP-164
+ */
+export interface RuntimeMergeSnapshot {
+	/** Batch this merge agent belongs to */
+	batchId: string;
+	/** 1-indexed merge agent number (e.g. 1 for "orch-henry-merge-1") */
+	mergeNumber: number;
+	/** Stable agent session name (e.g. "orch-henry-merge-1") */
+	sessionName: string;
+	/** Wave index this merge agent is processing (0-indexed, 0 when unknown) */
+	waveIndex: number;
+	/** Merge agent lifecycle status */
+	status: "running" | "complete" | "failed";
+	/** Live telemetry snapshot for the merge agent (null when not yet started) */
+	agent: RuntimeAgentTelemetrySnapshot | null;
+	/** Epoch ms when this snapshot was last updated */
+	updatedAt: number;
+}
+
+/**
+ * Resolve the path for a merge agent snapshot file.
+ *
+ * Snapshots are stored alongside lane snapshots in the `lanes/` directory so
+ * the dashboard server's directory scan picks them up automatically.
+ *
+ * @param stateRoot  - Repository root (where `.pi/` lives)
+ * @param batchId    - Current batch identifier
+ * @param mergeNumber - 1-indexed merge agent number
+ * @returns Absolute path to the merge snapshot JSON file
+ *
+ * @since TP-164
+ */
+export function runtimeMergeSnapshotPath(stateRoot: string, batchId: string, mergeNumber: number): string {
+	return `${stateRoot}/.pi/runtime/${batchId}/lanes/merge-${mergeNumber}.json`;
+}
+
 /**
  * Resolve the path for the batch runtime registry.
  *

package/package.json

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