taskplane 0.8.0 → 0.8.1

package/dashboard/public/app.js

@@ -589,6 +589,7 @@ function renderMergeAgents(batch, tmuxSessions) {
   const mergeResults = batch?.mergeResults || [];
   const tmuxSet = new Set(tmuxSessions || []);
   const showRepos = knownRepos.length >= 2;
+  const telemetry = currentData?.telemetry || {};
 
   // Check for active merge sessions (convention: orch-merge-*)
   const mergeSessions = (tmuxSessions || []).filter(s => s.startsWith("orch-merge"));
@@ -599,7 +600,7 @@ function renderMergeAgents(batch, tmuxSessions) {
   }
 
   let html = '<table class="merge-table"><thead><tr>';
-  html += '<th>Wave</th><th>Status</th><th>Session</th><th>Attach</th><th>Details</th>';
+  html += '<th>Wave</th><th>Status</th><th>Session</th><th>Telemetry</th><th>Attach</th><th>Details</th>';
   html += '</tr></thead><tbody>';
 
   // Show merge results
@@ -620,10 +621,29 @@ function renderMergeAgents(batch, tmuxSessions) {
     const sessionName = `orch-merge-w${mr.waveIndex + 1}`;
     const alive = tmuxSet.has(sessionName);
 
+    // Look for merge telemetry data
+    const mergeTel = telemetry[sessionName] || telemetry[`orch-merge-${mr.waveIndex + 1}`] || null;
+
     html += `<tr>`;
     html += `<td style="font-family:var(--font-mono);">Wave ${mr.waveIndex + 1}</td>`;
     html += `<td><span class="status-badge ${statusCls}">${mr.status}</span></td>`;
     html += `<td style="font-family:var(--font-mono);font-size:0.8rem;">${alive ? escapeHtml(sessionName) : "—"}</td>`;
+    // Telemetry cell
+    html += `<td style="font-size:0.75rem;">`;
+    if (mergeTel) {
+      const totalTok = (mergeTel.inputTokens || 0) + (mergeTel.outputTokens || 0);
+      const cost = mergeTel.cost || 0;
+      if (totalTok > 0 || cost > 0) {
+        html += `<span style="color:var(--text-muted);">${totalTok > 0 ? totalTok.toLocaleString() + " tok" : ""}`;
+        if (cost > 0) html += ` · $${cost.toFixed(4)}`;
+        html += `</span>`;
+      } else {
+        html += '<span style="color:var(--text-faint);">—</span>';
+      }
+    } else {
+      html += '<span style="color:var(--text-faint);">—</span>';
+    }
+    html += `</td>`;
     html += `<td>`;
     if (alive) {
       const cmd = `tmux attach -t ${sessionName}`;
@@ -652,7 +672,8 @@ function renderMergeAgents(batch, tmuxSessions) {
         html += `<td>${repoBadgeHtml(rr.repoId)}</td>`;
         html += `<td><span class="status-badge ${rrStatusCls}">${rr.status}</span></td>`;
         html += `<td style="font-family:var(--font-mono);font-size:0.75rem;color:var(--text-faint);">${rrLanes}</td>`;
-        html += `<td></td>`;
+        html += `<td></td>`; /* telemetry placeholder */
+        html += `<td></td>`; /* attach placeholder */
         html += `<td style="font-size:0.75rem;color:var(--text-faint);">${rrDetail}</td>`;
         html += `</tr>`;
       }
@@ -664,11 +685,28 @@ function renderMergeAgents(batch, tmuxSessions) {
     const alreadyShown = mergeResults.some((mr) => `orch-merge-w${mr.waveIndex + 1}` === sess);
     if (alreadyShown) continue;
 
+    const sessTel = telemetry[sess] || null;
     const cmd = `tmux attach -t ${sess}`;
     html += `<tr>`;
     html += `<td style="font-family:var(--font-mono);">—</td>`;
     html += `<td><span class="status-badge status-running"><span class="status-dot running"></span> merging</span></td>`;
     html += `<td style="font-family:var(--font-mono);font-size:0.8rem;">${escapeHtml(sess)}</td>`;
+    // Telemetry cell for active merge session
+    html += `<td style="font-size:0.75rem;">`;
+    if (sessTel) {
+      const totalTok = (sessTel.inputTokens || 0) + (sessTel.outputTokens || 0);
+      const cost = sessTel.cost || 0;
+      if (totalTok > 0 || cost > 0) {
+        html += `<span style="color:var(--text-muted);">${totalTok > 0 ? totalTok.toLocaleString() + " tok" : ""}`;
+        if (cost > 0) html += ` · $${cost.toFixed(4)}`;
+        html += `</span>`;
+      } else {
+        html += '<span style="color:var(--text-faint);">—</span>';
+      }
+    } else {
+      html += '<span style="color:var(--text-faint);">—</span>';
+    }
+    html += `</td>`;
     html += `<td><span class="tmux-cmd" data-tmux="${escapeHtml(sess)}" onclick="copyTmuxCmd('${escapeHtml(sess)}')" title="Click to copy">${escapeHtml(cmd)}</span></td>`;
     html += `<td>—</td>`;
     html += `</tr>`;

package/dashboard/server.cjs

@@ -239,7 +239,8 @@ const telemetryPrefixFiles = new Map();
 /**
  * Parse a telemetry JSONL filename to extract lane number and role.
  * Pattern: {opId}-{batchId}-{repoId}[-{taskId}][-lane-{N}]-{role}.jsonl
- * Returns { laneNumber: number|null, role: string } or null if unparseable.
+ * Roles: worker, reviewer, merger
+ * Returns { laneNumber: number|null, role: string, mergeNumber: number|null } or null if unparseable.
  */
 function parseTelemetryFilename(filename) {
   // Remove .jsonl extension
@@ -248,13 +249,17 @@ function parseTelemetryFilename(filename) {
   const lastDash = base.lastIndexOf("-");
   if (lastDash < 0) return null;
   const role = base.slice(lastDash + 1);
-  if (role !== "worker" && role !== "reviewer") return null;
+  if (role !== "worker" && role !== "reviewer" && role !== "merger") return null;
 
   // Extract lane number from -lane-{N}- pattern
   const laneMatch = base.match(/-lane-(\d+)-/);
   const laneNumber = laneMatch ? parseInt(laneMatch[1], 10) : null;
 
-  return { laneNumber, role };
+  // Extract merge number from -merge-{N}- pattern (merge agents)
+  const mergeMatch = base.match(/-merge-(\d+)-/);
+  const mergeNumber = mergeMatch ? parseInt(mergeMatch[1], 10) : null;
+
+  return { laneNumber, role, mergeNumber };
 }
 
 /**
@@ -375,7 +380,10 @@ function loadTelemetryData(batchState) {
 
     // Determine the key (tmux prefix)
     let prefix;
-    if (parsed.laneNumber != null && laneToPrefix[parsed.laneNumber]) {
+    if (parsed.role === "merger") {
+      // Merge agent — key by merge session number or generic "merge"
+      prefix = parsed.mergeNumber != null ? `orch-merge-${parsed.mergeNumber}` : "orch-merge";
+    } else if (parsed.laneNumber != null && laneToPrefix[parsed.laneNumber]) {
       prefix = laneToPrefix[parsed.laneNumber];
     } else if (parsed.laneNumber != null) {
       // Lane number found but no batch-state mapping — use heuristic

package/extensions/taskplane/execution.ts

@@ -2,9 +2,10 @@
  * Lane execution, monitoring, wave execution loop
  * @module orch/execution
  */
-import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync } from "fs";
+import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync, writeFileSync } from "fs";
 import { spawnSync } from "child_process";
 import { join, dirname, resolve, relative, delimiter as pathDelimiter } from "path";
+import { tmpdir, userInfo } from "os";
 
 import { DONE_GRACE_MS, EXECUTION_POLL_INTERVAL_MS, ExecutionError, SESSION_SPAWN_RETRY_MAX } from "./types.ts";
 import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
@@ -58,6 +59,108 @@ function resolveTaskRunnerExtensionPath(repoRoot: string): string {
 	return localPath;
 }
 
+// ── RPC Wrapper Path Resolution ──────────────────────────────────────
+
+/**
+ * Find the rpc-wrapper.mjs path for lane sessions.
+ *
+ * Resolution order mirrors resolveTaskRunnerExtensionPath:
+ *   1. Local project: {repoRoot}/bin/rpc-wrapper.mjs (for taskplane dev)
+ *   2. Global npm (Windows): {APPDATA}/npm/node_modules/taskplane/bin/rpc-wrapper.mjs
+ *   3. Global npm (Unix): /usr/local/lib/node_modules/taskplane/bin/rpc-wrapper.mjs
+ *   4. npm peer: resolve from pi's location
+ *
+ * @throws ExecutionError if rpc-wrapper.mjs cannot be found anywhere
+ */
+export function resolveRpcWrapperPath(repoRoot: string): string {
+	const wrapperFile = join("bin", "rpc-wrapper.mjs");
+
+	// 1. Local project (taskplane development)
+	const localPath = join(resolve(repoRoot), wrapperFile);
+	if (existsSync(localPath)) return localPath;
+
+	// 2. Global npm install paths
+	const home = process.env.HOME || process.env.USERPROFILE || "";
+	const candidates: string[] = [];
+	if (process.env.APPDATA) {
+		candidates.push(join(process.env.APPDATA, "npm", "node_modules", "taskplane", wrapperFile));
+	}
+	if (home) {
+		candidates.push(join(home, "AppData", "Roaming", "npm", "node_modules", "taskplane", wrapperFile));
+		candidates.push(join(home, ".npm-global", "lib", "node_modules", "taskplane", wrapperFile));
+	}
+	candidates.push(join("/usr", "local", "lib", "node_modules", "taskplane", wrapperFile));
+
+	// 3. Peer of pi's package
+	try {
+		const piPath = process.argv[1] || "";
+		const piPkgDir = resolve(piPath, "..", "..");
+		candidates.push(join(piPkgDir, "..", "taskplane", wrapperFile));
+	} catch { /* ignore */ }
+
+	for (const candidate of candidates) {
+		if (existsSync(candidate)) return candidate;
+	}
+
+	// Fallback: return the local path (will fail at spawn time with a clear error)
+	return localPath;
+}
+
+// ── Telemetry Path Generation ────────────────────────────────────────
+
+/**
+ * Generate telemetry file paths for a lane session.
+ *
+ * Naming contract from resilience roadmap:
+ *   .pi/telemetry/{opId}-{batchId}-{repoId}[-{taskId}][-lane-{N}]-{role}.{ext}
+ *
+ * @param sessionName  - TMUX session name (e.g., "orch-lane-1")
+ * @param sidecarRoot  - Root dir for sidecar files (e.g., <workspace>/.pi or <repo>/.pi)
+ * @param taskId       - Task identifier (e.g., "TP-049")
+ * @returns { sidecarPath, exitSummaryPath, telemetryDir }
+ */
+export function generateTelemetryPaths(
+	sessionName: string,
+	sidecarRoot: string,
+	taskId?: string,
+): { sidecarPath: string; exitSummaryPath: string; telemetryDir: string } {
+	const telemetryTs = Date.now();
+
+	// Resolve opId: same priority chain as naming.ts resolveOperatorId()
+	let opId = "op";
+	const envOpId = process.env.TASKPLANE_OPERATOR_ID;
+	if (envOpId?.trim()) {
+		opId = envOpId.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+	} else {
+		try {
+			const username = userInfo().username;
+			if (username?.trim()) {
+				opId = username.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+			}
+		} catch { /* userInfo() can throw on some platforms */ }
+	}
+
+	const batchId = String(telemetryTs);
+	const repoId = "default";
+
+	// Extract role from sessionName — lane sessions are "worker" role
+	const role = "worker";
+	const laneMatch = sessionName.match(/lane-(\d+)/);
+	const laneSuffix = laneMatch ? `-lane-${laneMatch[1]}` : "";
+
+	// Include taskId when available
+	const taskIdSegment = taskId
+		? `-${taskId.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30)}`
+		: "";
+	const telemetryBasename = `${opId}-${batchId}-${repoId}${taskIdSegment}${laneSuffix}-${role}`;
+	const telemetryDir = join(sidecarRoot, "telemetry");
+	if (!existsSync(telemetryDir)) mkdirSync(telemetryDir, { recursive: true });
+	const sidecarPath = join(telemetryDir, `${telemetryBasename}.jsonl`);
+	const exitSummaryPath = join(telemetryDir, `${telemetryBasename}-exit.json`);
+
+	return { sidecarPath, exitSummaryPath, telemetryDir };
+}
+
 // ── Execution Helpers ────────────────────────────────────────────────
 
 /**
@@ -231,7 +334,12 @@ export function toTmuxPath(pathValue: string): string {
  *
  * Constructs a properly escaped command that:
  * 1. Sets env vars (TASK_AUTOSTART, TASK_RUNNER_SPAWN_MODE, TASK_RUNNER_TMUX_PREFIX)
- * 2. Runs `pi --no-session -e extensions/task-runner.ts` in the worktree directory
+ * 2. Runs `node rpc-wrapper.mjs` to spawn pi with the task-runner extension,
+ *    producing structured telemetry (sidecar JSONL + exit summary JSON).
+ *
+ * The RPC wrapper spawns pi in RPC mode with the task-runner extension loaded.
+ * The extension's TASK_AUTOSTART env var triggers task execution on init.
+ * A minimal prompt file is created to satisfy the wrapper's --prompt-file requirement.
  *
  * Shell escaping: env var values are single-quoted to prevent expansion.
  * Path args are single-quoted to handle spaces and special characters.
@@ -241,6 +349,8 @@ export function toTmuxPath(pathValue: string): string {
  * @param repoRoot     - Absolute path to main repo (for extension absolute path)
  * @param envVars      - Environment variables to set
  * @param laneLogPath  - Optional path to write lane session stdout/stderr
+ * @param sidecarPath  - Path for RPC telemetry sidecar JSONL file
+ * @param exitSummaryPath - Path for RPC telemetry exit summary JSON file
  * @returns Array of arguments for spawnSync("tmux", args)
  */
 export function buildTmuxSpawnArgs(
@@ -249,6 +359,8 @@ export function buildTmuxSpawnArgs(
 	repoRoot: string,
 	envVars: Record<string, string>,
 	laneLogPath?: string,
+	sidecarPath?: string,
+	exitSummaryPath?: string,
 ): string[] {
 	// Shell-quote a value for safe embedding in a command string.
 	// Wraps in single quotes, escaping any internal single quotes.
@@ -260,18 +372,44 @@ export function buildTmuxSpawnArgs(
 	};
 
 	// Build the command string that runs inside the TMUX session.
-	// Format: ENV_VAR1=value1 ENV_VAR2=value2 pi --no-session -e extensions/task-runner.ts
 	const envParts = Object.entries(envVars)
 		.map(([key, val]) => `${key}=${shellQuote(val)}`)
 		.join(" ");
 
 	const taskRunnerExtPath = resolveTaskRunnerExtensionPath(repoRoot);
-	const basePiCommand = `${envParts} pi --no-session -e ${shellQuote(taskRunnerExtPath)}`;
+
+	let piCommand: string;
+
+	if (sidecarPath && exitSummaryPath) {
+		// ── RPC Wrapper mode: structured telemetry ──────────────
+		// Spawn `node rpc-wrapper.mjs` instead of `pi` directly.
+		// The wrapper runs pi in RPC mode, captures telemetry to
+		// sidecar JSONL, and writes exit summary on process exit.
+		const rpcWrapperPath = resolveRpcWrapperPath(repoRoot);
+
+		// Create a minimal prompt file for the RPC wrapper.
+		// The task-runner extension handles execution via TASK_AUTOSTART;
+		// this prompt satisfies the wrapper's --prompt-file requirement.
+		const promptId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const promptTmpFile = join(tmpdir(), `pi-lane-prompt-${promptId}.txt`);
+		writeFileSync(promptTmpFile, "Execute the task as configured by the task-runner extension.");
+
+		piCommand = [
+			envParts,
+			"node", shellQuote(rpcWrapperPath),
+			"--sidecar-path", shellQuote(sidecarPath),
+			"--exit-summary-path", shellQuote(exitSummaryPath),
+			"--prompt-file", shellQuote(promptTmpFile),
+			"--extensions", shellQuote(taskRunnerExtPath),
+		].filter(Boolean).join(" ");
+	} else {
+		// ── Legacy mode: direct pi spawn (no telemetry) ─────────
+		piCommand = `${envParts} pi --no-session -e ${shellQuote(taskRunnerExtPath)}`;
+	}
 
 	// NOTE: Do not redirect lane output here. Shell redirection has proven
 	// fragile across Windows + tmux environments and can prevent session spawn.
 	// Diagnostics use tmux pane capture + STATUS tail in pollUntilTaskComplete().
-	const piCommand = basePiCommand;
 
 	const tmuxWorktreePath = toTmuxPath(worktreePath);
 	const wrappedCommand = `cd ${shellQuote(tmuxWorktreePath)} && ${piCommand}`;
@@ -550,8 +688,16 @@ export function spawnLaneSession(
 		// Best effort — session can still run without log file setup
 	}
 
-	// Build tmux args
-	const tmuxArgs = buildTmuxSpawnArgs(sessionName, lane.worktreePath, repoRoot, envVars, laneLogRelativePath);
+	// Generate telemetry file paths for RPC wrapper sidecar
+	const sidecarRoot = join(workspaceRoot || repoRoot, ".pi");
+	const telemetry = generateTelemetryPaths(sessionName, sidecarRoot, task.taskId);
+	execLog(laneId, task.taskId, "telemetry paths generated", {
+		sidecar: telemetry.sidecarPath,
+		exitSummary: telemetry.exitSummaryPath,
+	});
+
+	// Build tmux args (with RPC wrapper telemetry)
+	const tmuxArgs = buildTmuxSpawnArgs(sessionName, lane.worktreePath, repoRoot, envVars, laneLogRelativePath, telemetry.sidecarPath, telemetry.exitSummaryPath);
 
 	// Clean up stale session if exists
 	if (tmuxHasSession(sessionName)) {

package/extensions/taskplane/merge.ts

@@ -6,7 +6,7 @@ import { readFileSync, writeFileSync, existsSync, unlinkSync, copyFileSync, mkdi
 import { execSync, spawnSync } from "child_process";
 import { join, dirname, resolve, relative } from "path";
 
-import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, tmuxHasSession, tmuxKillSession, toTmuxPath } from "./execution.ts";
+import { buildLaneEnvVars, buildTmuxSpawnArgs, execLog, generateTelemetryPaths, resolveRpcWrapperPath, tmuxHasSession, tmuxKillSession, 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, MergeError, VALID_MERGE_STATUSES } from "./types.ts";
 import type { AllocatedLane, LaneExecutionResult, MergeLaneResult, MergeResult, MergeResultStatus, MergeWaveResult, OrchestratorConfig, RepoMergeOutcome, TaskRunnerConfig, TransactionRecord, TransactionStatus, VerificationBaselineResult, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
@@ -18,6 +18,58 @@ import { loadOrchestratorConfig } from "./config.ts";
 import { captureBaseline, diffFingerprints, runVerificationCommands, parseTestOutput, deduplicateFingerprints } from "./verification.ts";
 import type { VerificationBaseline, FingerprintDiff, TestFingerprint } from "./verification.ts";
 
+// ── Merge Telemetry Helpers ───────────────────────────────────────────
+
+import { userInfo } from "os";
+
+/**
+ * Generate telemetry file paths for a merge agent session.
+ *
+ * Naming: {opId}-{batchId}-{repoId}[-merge-w{N}-lane-{N}]-merger.{ext}
+ * Role is always "merger" to distinguish from worker/reviewer in the dashboard.
+ *
+ * @param sessionName  - TMUX session name (e.g., "orch-merge-1")
+ * @param sidecarRoot  - Root dir for sidecar files (e.g., <workspace>/.pi)
+ * @returns { sidecarPath, exitSummaryPath }
+ */
+function generateMergeTelemetryPaths(
+	sessionName: string,
+	sidecarRoot: string,
+): { sidecarPath: string; exitSummaryPath: string } {
+	const telemetryTs = Date.now();
+
+	// Resolve opId: same priority chain as execution.ts
+	let opId = "op";
+	const envOpId = process.env.TASKPLANE_OPERATOR_ID;
+	if (envOpId?.trim()) {
+		opId = envOpId.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+	} else {
+		try {
+			const username = userInfo().username;
+			if (username?.trim()) {
+				opId = username.trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 12) || "op";
+			}
+		} catch { /* userInfo() can throw on some platforms */ }
+	}
+
+	const batchId = String(telemetryTs);
+	const repoId = "default";
+
+	// Extract merge-specific info from sessionName (e.g., "orch-merge-1")
+	const mergeMatch = sessionName.match(/merge-(\d+)/);
+	const mergeSuffix = mergeMatch ? `-merge-${mergeMatch[1]}` : "";
+
+	const role = "merger";
+	const telemetryBasename = `${opId}-${batchId}-${repoId}${mergeSuffix}-${role}`;
+	const telemetryDir = join(sidecarRoot, "telemetry");
+	if (!existsSync(telemetryDir)) mkdirSync(telemetryDir, { recursive: true });
+
+	return {
+		sidecarPath: join(telemetryDir, `${telemetryBasename}.jsonl`),
+		exitSummaryPath: join(telemetryDir, `${telemetryBasename}-exit.json`),
+	};
+}
+
 // ── Merge Implementation ─────────────────────────────────────────────
 
 /**
@@ -374,10 +426,10 @@ export async function spawnMergeAgent(
 		await sleepAsync(500);
 	}
 
-	// Build the pi command for the merge agent.
-	// Uses --no-session to prevent interactive session management.
-	// --append-system-prompt loads the merger agent definition.
-	// The merge request file is passed as a prompt via @file syntax.
+	// Build the merge agent command.
+	// Uses rpc-wrapper.mjs to produce structured telemetry (sidecar JSONL + exit summary).
+	// The merger agent definition is loaded via --system-prompt-file.
+	// The merge request is passed as the --prompt-file.
 	const shellQuote = (s: string): string => {
 		if (/[\s"'`$\\!&|;()<>{}#*?~]/.test(s)) {
 			return `'${s.replace(/'/g, "'\\''")}'`;
@@ -385,25 +437,43 @@ export async function spawnMergeAgent(
 		return s;
 	};
 
-	// Build model args if specified
-	const modelArgs = config.merge.model ? `--model ${shellQuote(config.merge.model)}` : "";
+	// Generate telemetry paths for this merge session
+	// Naming: {opId}-{batchId}-{repoId}-merger.jsonl (or with wave/lane info from sessionName)
+	const sidecarRoot = join(stateRoot ?? repoRoot, ".pi");
+	const telemetry = generateMergeTelemetryPaths(sessionName, sidecarRoot);
+	execLog("merge", sessionName, "telemetry paths generated", {
+		sidecar: telemetry.sidecarPath,
+		exitSummary: telemetry.exitSummaryPath,
+	});
+
+	// Resolve paths
+	const rpcWrapperPath = resolveRpcWrapperPath(repoRoot);
+	const systemPromptPath = agentRoot ? join(agentRoot, "task-merger.md") : join(stateRoot ?? repoRoot, ".pi", "agents", "task-merger.md");
+
+	// Build RPC wrapper command
+	const wrapperParts = [
+		"TERM=xterm-256color",
+		"node", shellQuote(rpcWrapperPath),
+		"--sidecar-path", shellQuote(telemetry.sidecarPath),
+		"--exit-summary-path", shellQuote(telemetry.exitSummaryPath),
+		"--prompt-file", shellQuote(mergeRequestPath),
+		"--system-prompt-file", shellQuote(systemPromptPath),
+	];
 
-	// Build tools override if specified
-	const toolsArgs = config.merge.tools ? `--tools ${shellQuote(config.merge.tools)}` : "";
+	// Add model args if specified
+	if (config.merge.model) {
+		wrapperParts.push("--model", shellQuote(config.merge.model));
+	}
+
+	// Add tools override if specified
+	if (config.merge.tools) {
+		wrapperParts.push("--tools", shellQuote(config.merge.tools));
+	}
 
-	const piCommand = [
-		"pi --no-session",
-		modelArgs,
-		toolsArgs,
-		`--append-system-prompt ${shellQuote(agentRoot ? join(agentRoot, "task-merger.md") : join(stateRoot ?? repoRoot, ".pi", "agents", "task-merger.md"))}`,
-		`@${shellQuote(mergeRequestPath)}`,
-	].filter(Boolean).join(" ");
+	const piCommand = wrapperParts.filter(Boolean).join(" ");
 
 	const tmuxMergeDir = toTmuxPath(mergeWorkDir);
-	// Pi's TUI (ink/react) hangs silently with TERM=tmux-256color (tmux default).
-	// Force xterm-256color so pi can render and start execution.
-	// Same fix as buildTmuxSpawnArgs / buildLaneEnvVars.
-	const wrappedCommand = `cd ${shellQuote(tmuxMergeDir)} && TERM=xterm-256color ${piCommand}`;
+	const wrappedCommand = `cd ${shellQuote(tmuxMergeDir)} && ${piCommand}`;
 	const tmuxArgs = [
 		"new-session", "-d",
 		"-s", sessionName,

package/package.json

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