taskplane 0.25.6 → 0.25.8

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,47 @@ 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.
+  // Snapshots are the PRIMARY source for merge telemetry — merge agents don't
+  // write to .pi/telemetry/*.jsonl (the JSONL path is for lane workers only).
+  // Inject snapshot data when no JSONL-backed entry exists for this session.
+  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 JSONL-backed telemetry entry.
+    // Merge agents don't emit to .pi/telemetry/, so existing will always be
+    // absent unless something else wrote to it — in that case defer to it.
+    const existing = telemetry[key];
+    if (!existing) {
+      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 +1179,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 } : {}),
 			},
 		};