taskplane 0.22.18 → 0.23.0

package/dashboard/server.cjs

@@ -352,6 +352,167 @@ function tailJsonlFile(filePath) {
  * @param {object|null} batchState - The batch state from batch-state.json
  * @returns {object} Map of tmuxPrefix → accumulated telemetry
  */
+
+// ── Runtime V2 Data Loaders (TP-107) ─────────────────────────────
+
+/**
+ * Load the Runtime V2 process registry for the current batch.
+ * Returns null if no registry exists (legacy batch).
+ */
+function loadRuntimeRegistry(batchId) {
+  if (!batchId) return null;
+  const registryPath = path.join(REPO_ROOT, ".pi", "runtime", batchId, "registry.json");
+  try {
+    if (!fs.existsSync(registryPath)) return null;
+    return JSON.parse(fs.readFileSync(registryPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Load Runtime V2 lane snapshots for the current batch.
+ * Returns a map of laneNumber → snapshot data.
+ */
+function loadRuntimeLaneSnapshots(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("lane-") && f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(lanesDir, file), "utf-8"));
+        if (data.laneNumber != null) snapshots[data.laneNumber] = 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.
+ */
+function loadRuntimeAgentEvents(batchId, agentId, maxEvents) {
+  if (!batchId || !agentId) return [];
+  maxEvents = maxEvents || 200;
+  const eventsPath = path.join(REPO_ROOT, ".pi", "runtime", batchId, "agents", agentId, "events.jsonl");
+  try {
+    if (!fs.existsSync(eventsPath)) return [];
+    const raw = fs.readFileSync(eventsPath, "utf-8");
+    const lines = raw.split("\n").filter(l => l.trim());
+    const events = [];
+    const start = Math.max(0, lines.length - maxEvents);
+    for (let i = start; i < lines.length; i++) {
+      try { events.push(JSON.parse(lines[i])); } catch { continue; }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Load mailbox message activity for the current batch.
+ *
+ * TP-093 hardening: event-authoritative model.
+ * Primary source: .pi/mailbox/{batchId}/events.jsonl (audit event stream).
+ * Fallback: directory scans (inbox/ack/outbox/outbox/processed) for
+ * compatibility when events.jsonl is absent.
+ *
+ * Includes:
+ * - Consumed replies (outbox/processed/) so they don't disappear after ack
+ * - Per-recipient broadcast delivery state from ack markers
+ * - Rate-limited events in the timeline
+ */
+function loadMailboxData(batchId) {
+  if (!batchId) return { messages: [], agentIds: [], auditEvents: [] };
+  const mbRoot = path.join(REPO_ROOT, ".pi", "mailbox", batchId);
+  if (!fs.existsSync(mbRoot)) return { messages: [], agentIds: [], auditEvents: [] };
+
+  // ── Primary: events.jsonl audit trail ──
+  const auditEvents = loadMailboxAuditEvents(mbRoot);
+
+  // ── Fallback: directory scan ──
+  const messages = [];
+  const agentIds = [];
+
+  try {
+    const dirs = fs.readdirSync(mbRoot, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+
+    for (const agentDir of dirs) {
+      if (agentDir === "_broadcast") continue;
+      agentIds.push(agentDir);
+
+      // Scan inbox (pending), ack (delivered), outbox (active replies), outbox/processed (consumed replies)
+      for (const subdir of ["inbox", "ack", "outbox", "outbox/processed"]) {
+        const dir = path.join(mbRoot, agentDir, subdir);
+        if (!fs.existsSync(dir)) continue;
+        try {
+          const files = fs.readdirSync(dir).filter(f => f.endsWith(".msg.json"));
+          for (const file of files) {
+            try {
+              const msg = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+              let status;
+              if (subdir === "inbox") status = "pending";
+              else if (subdir === "ack") status = "delivered";
+              else if (subdir === "outbox") status = "reply";
+              else status = "reply-acked"; // outbox/processed
+              const isBroadcast = msg.to === "_broadcast";
+              messages.push({ ...msg, _status: status, _agentDir: agentDir, _isBroadcast: isBroadcast });
+            } catch { continue; }
+          }
+        } catch { continue; }
+      }
+    }
+
+    // _broadcast: per-recipient delivery state
+    const broadcastInbox = path.join(mbRoot, "_broadcast", "inbox");
+    const broadcastAck = path.join(mbRoot, "_broadcast", "ack");
+    for (const [dir, status] of [[broadcastInbox, "pending"], [broadcastAck, "delivered"]]) {
+      if (!fs.existsSync(dir)) continue;
+      try {
+        const files = fs.readdirSync(dir).filter(f => f.endsWith(".msg.json"));
+        for (const file of files) {
+          try {
+            const msg = JSON.parse(fs.readFileSync(path.join(dir, file), "utf-8"));
+            messages.push({ ...msg, _status: status, _agentDir: "_broadcast", _isBroadcast: true });
+          } catch { continue; }
+        }
+      } catch { continue; }
+    }
+  } catch { /* mailbox dir issues */ }
+
+  messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+  return { messages, agentIds, auditEvents };
+}
+
+/**
+ * Load mailbox audit events from events.jsonl.
+ * Returns events sorted by timestamp. Includes: message_sent, message_delivered,
+ * message_replied, message_escalated, message_rate_limited.
+ */
+function loadMailboxAuditEvents(mbRoot) {
+  const eventsPath = path.join(mbRoot, "events.jsonl");
+  if (!fs.existsSync(eventsPath)) return [];
+  try {
+    const raw = fs.readFileSync(eventsPath, "utf-8");
+    const events = [];
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try { events.push(JSON.parse(line)); } catch { continue; }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────
 function loadTelemetryData(batchState) {
   const telemetryDir = path.join(REPO_ROOT, ".pi", "telemetry");
   const result = {};
@@ -849,11 +1010,20 @@ function buildDashboardState() {
     return { ...task, statusData };
   });
 
+  // TP-107: Load Runtime V2 data when available
+  const runtimeRegistry = loadRuntimeRegistry(state.batchId);
+  const runtimeLaneSnapshots = loadRuntimeLaneSnapshots(state.batchId);
+  const mailboxData = loadMailboxData(state.batchId);
+
   return {
     laneStates,
     telemetry,
     batchTotalCost,
     supervisor,
+    // Runtime V2 data (null/empty for legacy batches)
+    runtimeRegistry,
+    runtimeLaneSnapshots,
+    mailbox: mailboxData,
     batch: {
       batchId: state.batchId,
       phase: state.phase,
@@ -1220,6 +1390,35 @@ function createServer() {
     } else if (pathname.startsWith("/api/conversation/") && req.method === "GET") {
       const prefix = pathname.slice("/api/conversation/".length);
       serveConversation(req, res, prefix);
+    } else if (pathname.startsWith("/api/agent-events/") && req.method === "GET") {
+      // TP-107: Serve Runtime V2 agent events (hardened)
+      const agentId = decodeURIComponent(pathname.slice("/api/agent-events/".length));
+      // Strict validation: same pattern as /api/conversation/:prefix
+      if (!/^[\w-]+$/.test(agentId)) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Invalid agent ID");
+        return;
+      }
+      const batchState = loadBatchState();
+      // Path containment: verify resolved path stays inside runtime dir
+      if (batchState?.batchId) {
+        const runtimeBase = path.join(REPO_ROOT, ".pi", "runtime", batchState.batchId, "agents");
+        const resolvedAgent = path.resolve(runtimeBase, agentId);
+        if (!resolvedAgent.startsWith(path.resolve(runtimeBase))) {
+          res.writeHead(403, { "Content-Type": "text/plain" });
+          res.end("Forbidden");
+          return;
+        }
+      }
+      // Optional: ?sinceTs= to return only events after a timestamp
+      const reqUrl = new URL(req.url, "http://localhost");
+      const sinceTs = parseInt(reqUrl.searchParams.get("sinceTs") || "0", 10);
+      let events = loadRuntimeAgentEvents(batchState?.batchId, agentId, 300);
+      if (sinceTs > 0) {
+        events = events.filter(e => (e.ts || 0) > sinceTs);
+      }
+      res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+      res.end(JSON.stringify(events));
     } else if (pathname === "/api/state" && req.method === "GET") {
       const state = buildDashboardState();
       res.writeHead(200, {

package/extensions/task-runner.ts

@@ -38,6 +38,28 @@ import {
 } from "./taskplane/types.ts";
 import { classifyExit } from "./taskplane/diagnostics.ts";
 import type { TaskExitDiagnostic, ExitSummary } from "./taskplane/diagnostics.ts";
+import {
+	parsePromptMd as coreParsePromptMd,
+	parseStatusMd as coreParseStatusMd,
+	generateStatusMd as coreGenerateStatusMd,
+	updateStatusField as coreUpdateStatusField,
+	updateStepStatus as coreUpdateStepStatus,
+	appendTableRow as coreAppendTableRow,
+	logExecution as coreLogExecution,
+	logReview as coreLogReview,
+	sanitizeSteeringContent as coreSanitizeSteeringContent,
+	isStepComplete as coreIsStepComplete,
+	isLowRiskStep as coreIsLowRiskStep,
+	extractVerdict as coreExtractVerdict,
+	getHeadCommitSha as coreGetHeadCommitSha,
+	findStepBoundaryCommit as coreFindStepBoundaryCommit,
+	resolveStandards as coreResolveStandards,
+	generateReviewRequest as coreGenerateReviewRequest,
+	displayName as coreDisplayName,
+	type StepInfo,
+	type CoreParsedTask,
+	type ParsedStatus,
+} from "./taskplane/task-executor-core.ts";
 import {
 	generateQualityGatePrompt,
 	generateFeedbackMd,
@@ -782,194 +804,38 @@ function loadAgentDef(cwd: string, name: string): { systemPrompt: string; tools:
 // ── PROMPT.md Parser ─────────────────────────────────────────────────
 
 function parsePromptMd(content: string, promptPath: string): ParsedTask {
-	const text = content.replace(/\r\n/g, "\n");
-	const taskFolder = dirname(resolve(promptPath));
-
-	// Task ID and name
-	let taskId = "", taskName = "";
-	const titleMatch = text.match(/^#\s+(?:Task:\s*)?(\S+-\d+)\s*[-–:]\s*(.+)/m);
-	if (titleMatch) { taskId = titleMatch[1]; taskName = titleMatch[2].trim(); }
-	else { taskId = basename(taskFolder); taskName = taskId; }
-
-	// Review level
-	let reviewLevel = 0;
-	const rlMatch = text.match(/##\s+Review Level[:\s]*(\d)/);
-	if (rlMatch) reviewLevel = parseInt(rlMatch[1]);
-
-	// Size
-	let size = "M";
-	const sizeMatch = text.match(/\*\*Size:\*\*\s*(\w+)/);
-	if (sizeMatch) size = sizeMatch[1];
-
-	// Steps
-	const steps: StepInfo[] = [];
-	const stepRegex = /###\s+Step\s+(\d+):\s*(.+)/g;
-	const positions: { number: number; name: string; start: number }[] = [];
-	let m;
-	while ((m = stepRegex.exec(text)) !== null) {
-		positions.push({ number: parseInt(m[1]), name: m[2].trim(), start: m.index });
-	}
-	for (let i = 0; i < positions.length; i++) {
-		const section = text.slice(positions[i].start, i + 1 < positions.length ? positions[i + 1].start : text.length);
-		const checkboxes: { text: string; checked: boolean }[] = [];
-		const cbRegex = /^\s*-\s*\[([ xX])\]\s*(.*)/gm;
-		let cb;
-		while ((cb = cbRegex.exec(section)) !== null) {
-			checkboxes.push({ text: cb[2].trim(), checked: cb[1].toLowerCase() === "x" });
-		}
-		steps.push({
-			number: positions[i].number, name: positions[i].name,
-			status: "not-started", checkboxes,
-			totalChecked: checkboxes.filter(c => c.checked).length,
-			totalItems: checkboxes.length,
-		});
-	}
-
-	// Context docs
-	const contextDocs: string[] = [];
-	const ctxMatch = text.match(/##\s+Context to Read First\s*\n+([\s\S]*?)(?=\n##\s|$)/);
-	if (ctxMatch) {
-		const pathRegex = /`([^\s`]+\.(?:md|yaml|json|go|ts|js))`/g;
-		let pm;
-		while ((pm = pathRegex.exec(ctxMatch[1])) !== null) contextDocs.push(pm[1]);
-	}
-
-	return { taskId, taskName, reviewLevel, size, steps, contextDocs, taskFolder, promptPath };
+	const core = coreParsePromptMd(content, promptPath);
+	return { ...core };
 }
 
 // ── STATUS.md Parser ─────────────────────────────────────────────────
 
 function parseStatusMd(content: string): { steps: StepInfo[]; reviewCounter: number; iteration: number } {
-	const text = content.replace(/\r\n/g, "\n");
-	const steps: StepInfo[] = [];
-	let currentStep: StepInfo | null = null;
-	let reviewCounter = 0, iteration = 0;
-
-	for (const line of text.split("\n")) {
-		const rcMatch = line.match(/\*\*Review Counter:\*\*\s*(\d+)/);
-		if (rcMatch) reviewCounter = parseInt(rcMatch[1]);
-		const itMatch = line.match(/\*\*Iteration:\*\*\s*(\d+)/);
-		if (itMatch) iteration = parseInt(itMatch[1]);
-
-		const stepMatch = line.match(/^###\s+Step\s+(\d+):\s*(.+)/);
-		if (stepMatch) {
-			if (currentStep) {
-				currentStep.totalChecked = currentStep.checkboxes.filter(c => c.checked).length;
-				currentStep.totalItems = currentStep.checkboxes.length;
-				steps.push(currentStep);
-			}
-			currentStep = { number: parseInt(stepMatch[1]), name: stepMatch[2].trim(), status: "not-started", checkboxes: [], totalChecked: 0, totalItems: 0 };
-			continue;
-		}
-		if (currentStep) {
-			const ss = line.match(/\*\*Status:\*\*\s*(.*)/);
-			if (ss) {
-				const s = ss[1];
-				if (s.includes("✅") || s.toLowerCase().includes("complete")) currentStep.status = "complete";
-				else if (s.includes("🟨") || s.toLowerCase().includes("progress")) currentStep.status = "in-progress";
-			}
-			const cb = line.match(/^\s*-\s*\[([ xX])\]\s*(.*)/);
-			if (cb) currentStep.checkboxes.push({ text: cb[2].trim(), checked: cb[1].toLowerCase() === "x" });
-		}
-	}
-	if (currentStep) {
-		currentStep.totalChecked = currentStep.checkboxes.filter(c => c.checked).length;
-		currentStep.totalItems = currentStep.checkboxes.length;
-		steps.push(currentStep);
-	}
-	return { steps, reviewCounter, iteration };
+	return coreParseStatusMd(content);
 }
 
 // ── STATUS.md Generator ──────────────────────────────────────────────
 
 function generateStatusMd(task: ParsedTask): string {
-	const now = new Date().toISOString().slice(0, 10);
-	const lines: string[] = [
-		`# ${task.taskId}: ${task.taskName} — Status`, "",
-		`**Current Step:** Not Started`,
-		`**Status:** 🔵 Ready for Execution`,
-		`**Last Updated:** ${now}`,
-		`**Review Level:** ${task.reviewLevel}`,
-		`**Review Counter:** 0`,
-		`**Iteration:** 0`,
-		`**Size:** ${task.size}`, "", "---", "",
-	];
-	for (const step of task.steps) {
-		lines.push(`### Step ${step.number}: ${step.name}`, `**Status:** ⬜ Not Started`, "");
-		for (const cb of step.checkboxes) lines.push(`- [ ] ${cb.text}`);
-		lines.push("", "---", "");
-	}
-	lines.push(
-		"## Reviews", "", "| # | Type | Step | Verdict | File |", "|---|------|------|---------|------|", "", "---", "",
-		"## Discoveries", "", "| Discovery | Disposition | Location |", "|-----------|-------------|----------|", "", "---", "",
-		"## Execution Log", "", "| Timestamp | Action | Outcome |", "|-----------|--------|---------|",
-		`| ${now} | Task staged | STATUS.md auto-generated by task-runner |`, "", "---", "",
-		"## Blockers", "", "*None*", "", "---", "", "## Notes", "", "*Reserved for execution notes*",
-	);
-	return lines.join("\n");
+	return coreGenerateStatusMd(task);
 }
 
 // ── STATUS.md Updaters ───────────────────────────────────────────────
 
 function updateStatusField(statusPath: string, field: string, value: string): void {
-	let content = readFileSync(statusPath, "utf-8").replace(/\r\n/g, "\n");
-	const pattern = new RegExp(`(\\*\\*${field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:\\*\\*\\s*)(.+)`);
-	if (pattern.test(content)) {
-		content = content.replace(pattern, `$1${value}`);
-	} else {
-		// Append after last ** field
-		content = content.replace(/(\*\*[^*]+:\*\*\s*.+\n)/, `$1**${field}:** ${value}\n`);
-	}
-	writeFileSync(statusPath, content);
+	coreUpdateStatusField(statusPath, field, value);
 }
 
 function updateStepStatus(statusPath: string, stepNum: number, status: "not-started" | "in-progress" | "complete"): void {
-	let content = readFileSync(statusPath, "utf-8").replace(/\r\n/g, "\n");
-	const emoji = status === "complete" ? "✅ Complete" : status === "in-progress" ? "🟨 In Progress" : "⬜ Not Started";
-	const lines = content.split("\n");
-	let inTarget = false;
-	for (let i = 0; i < lines.length; i++) {
-		const sm = lines[i].match(/^###\s+Step\s+(\d+):/);
-		if (sm) inTarget = parseInt(sm[1]) === stepNum;
-		if (inTarget && lines[i].match(/^\*\*Status:\*\*/)) {
-			lines[i] = `**Status:** ${emoji}`;
-			break;
-		}
-	}
-	writeFileSync(statusPath, lines.join("\n"));
+	coreUpdateStepStatus(statusPath, stepNum, status);
 }
 
 function appendTableRow(statusPath: string, sectionName: string, row: string): void {
-	let content = readFileSync(statusPath, "utf-8").replace(/\r\n/g, "\n");
-	const lines = content.split("\n");
-	let insertIdx = -1, inSection = false, lastTableRow = -1;
-	for (let i = 0; i < lines.length; i++) {
-		if (lines[i].match(new RegExp(`^##\\s+${sectionName}`))) {
-			inSection = true;
-			continue;
-		}
-		if (inSection) {
-			// End of section — hit another ## heading or ---
-			if (lines[i].match(/^##\s/) || lines[i].trim() === "---") {
-				insertIdx = lastTableRow >= 0 ? lastTableRow + 1 : i;
-				break;
-			}
-			// Track last table data row (skip header separator |---|)
-			if (lines[i].startsWith("|") && !lines[i].match(/^\|[\s-|]+\|$/)) {
-				lastTableRow = i;
-			}
-		}
-	}
-	if (insertIdx === -1) {
-		insertIdx = lastTableRow >= 0 ? lastTableRow + 1 : lines.length;
-	}
-	lines.splice(insertIdx, 0, row);
-	writeFileSync(statusPath, lines.join("\n"));
+	coreAppendTableRow(statusPath, sectionName, row);
 }
 
 function logExecution(statusPath: string, action: string, outcome: string): void {
-	const ts = new Date().toISOString().slice(0, 16).replace("T", " ");
-	appendTableRow(statusPath, "Execution Log", `| ${ts} | ${action} | ${outcome} |`);
+	coreLogExecution(statusPath, action, outcome);
 }
 
 /**
@@ -977,13 +843,11 @@ function logExecution(statusPath: string, action: string, outcome: string): void
  * Collapses newlines to " / ", escapes pipe characters, and truncates to 200 chars.
  */
 function sanitizeSteeringContent(content: string): string {
-	let s = content.replace(/\r?\n/g, " / ").replace(/\|/g, "\\|");
-	if (s.length > 200) s = s.slice(0, 197) + "...";
-	return s;
+	return coreSanitizeSteeringContent(content);
 }
 
 function logReview(statusPath: string, num: string, type: string, stepNum: number, verdict: string, file: string): void {
-	appendTableRow(statusPath, "Reviews", `| ${num} | ${type} | Step ${stepNum} | ${verdict} | ${file} |`);
+	coreLogReview(statusPath, num, type, stepNum, verdict, file);
 }
 
 // ── Project Context Builder ──────────────────────────────────────────
@@ -1020,15 +884,7 @@ function buildProjectContext(config: TaskConfig, taskFolder: string): string {
  * can diff against the correct range instead of just uncommitted changes.
  */
 function getHeadCommitSha(): string {
-	try {
-		const result = spawnSync("git", ["rev-parse", "--short", "HEAD"], {
-			encoding: "utf-8",
-			timeout: 5000,
-		});
-		return result.status === 0 ? (result.stdout || "").trim() : "";
-	} catch {
-		return "";
-	}
+	return coreGetHeadCommitSha();
 }
 
 /**
@@ -1038,18 +894,7 @@ function getHeadCommitSha(): string {
  * Returns the commit SHA if found, or empty string.
  */
 function findStepBoundaryCommit(stepNumber: number, taskId: string, since?: string): string {
-	try {
-		// Search git log for the step completion commit
-		const args = ["log", "--oneline", "--grep", `complete Step ${stepNumber}`, "--grep", taskId, "--all-match", "-1", "--format=%H"];
-		if (since) args.push(`${since}..HEAD`);
-		const result = spawnSync("git", args, {
-			encoding: "utf-8",
-			timeout: 5000,
-		});
-		return result.status === 0 ? (result.stdout || "").trim() : "";
-	} catch {
-		return "";
-	}
+	return coreFindStepBoundaryCommit(stepNumber, taskId, since);
 }
 
 // ── Standards Resolution ─────────────────────────────────────────────
@@ -1065,24 +910,7 @@ function findStepBoundaryCommit(stepNumber: number, taskId: string, since?: stri
  * different review standards than Go backend service tasks.
  */
 function resolveStandards(config: TaskConfig, taskFolder: string): { docs: string[]; rules: string[] } {
-	const normalizedFolder = taskFolder.replace(/\\/g, "/");
-
-	// Find which area this task belongs to
-	for (const [areaName, areaCfg] of Object.entries(config.task_areas)) {
-		const areaPath = areaCfg.path.replace(/\\/g, "/");
-		if (normalizedFolder.includes(areaPath)) {
-			const override = config.standards_overrides[areaName];
-			if (override) {
-				return {
-					docs: override.docs ?? config.standards.docs,
-					rules: override.rules ?? config.standards.rules,
-				};
-			}
-			break; // Area found but no override — use global
-		}
-	}
-
-	return { docs: config.standards.docs, rules: config.standards.rules };
+	return coreResolveStandards(config.standards, config.standards_overrides, config.task_areas, taskFolder);
 }
 
 // ── Review Request Generator ─────────────────────────────────────────
@@ -1092,84 +920,12 @@ function generateReviewRequest(
 	task: ParsedTask, config: TaskConfig, outputPath: string,
 	stepBaselineCommit?: string,
 ): string {
-	const resolved = resolveStandards(config, task.taskFolder);
-	const standardsDocs = resolved.docs.map(d => `   - ${d}`).join("\n");
-	const standardsRules = resolved.rules.map(r => `- ${r}`).join("\n");
-
-	if (type === "plan") {
-		return [
-			`# Review Request: Plan Review`, "",
-			`You are reviewing an implementation plan for a ${config.project.name} task.`,
-			`You have full tool access — use \`read\` to examine files and \`bash\` to run commands.`, "",
-			`## Task Context`, "",
-			`- **Task PROMPT:** ${task.promptPath}`,
-			`- **Task STATUS:** ${join(task.taskFolder, "STATUS.md")}`,
-			`- **Step being planned:** Step ${stepNum}: ${stepName}`, "",
-			`## Instructions`, "",
-			`1. Read the PROMPT.md for full requirements`,
-			`2. Read STATUS.md for progress so far`,
-			`3. Check relevant source files for existing patterns:`,
-			standardsDocs, "",
-			`## Project Standards`, "", standardsRules, "",
-			`## Output`, "",
-			`Write your review to: \`${outputPath}\``,
-		].join("\n");
-	} else {
-		// For code reviews, provide the baseline commit so the reviewer can
-		// diff the full step's changes — not just uncommitted changes.
-		// Workers commit via checkpoints, so `git diff` alone sees nothing.
-		const diffCmd = stepBaselineCommit
-			? `git diff ${stepBaselineCommit}..HEAD --name-only`
-			: `git diff --name-only`;
-		const diffFullCmd = stepBaselineCommit
-			? `git diff ${stepBaselineCommit}..HEAD`
-			: `git diff`;
-
-		return [
-			`# Review Request: Code Review`, "",
-			`You are reviewing code changes for a ${config.project.name} task.`,
-			`You have full tool access — use \`read\` to examine files and \`bash\` to run commands.`, "",
-			`## Task Context`, "",
-			`- **Task PROMPT:** ${task.promptPath}`,
-			`- **Task STATUS:** ${join(task.taskFolder, "STATUS.md")}`,
-			`- **Step reviewed:** Step ${stepNum}: ${stepName}`,
-			...(stepBaselineCommit ? [`- **Step baseline commit:** ${stepBaselineCommit}`] : []),
-			"",
-			`## Instructions`, "",
-			`1. Run \`${diffCmd}\` to see files changed in this step`,
-			`   Then \`${diffFullCmd}\` for the full diff`,
-			`   **Important:** The worker commits code via checkpoints, so plain \`git diff\` may show nothing.`,
-			`   Always use the baseline commit range above to see all step changes.`,
-			`2. Read changed files in full for context`,
-			`3. Check neighboring files for pattern consistency`,
-			`4. Check standards:`,
-			standardsDocs, "",
-			`## Project Standards`, "", standardsRules, "",
-			`## Output`, "",
-			`Write your review to: \`${outputPath}\``,
-		].join("\n");
-	}
+	const standards = resolveStandards(config, task.taskFolder);
+	return coreGenerateReviewRequest(type, stepNum, stepName, task.promptPath, task.taskFolder, config.project.name, standards, outputPath, stepBaselineCommit);
 }
 
 function extractVerdict(reviewContent: string): string {
-	// Primary: standard format "### Verdict: APPROVE|REVISE|RETHINK"
-	const match = reviewContent.match(/###?\s*Verdict[:\s]*(APPROVE|REVISE|RETHINK)/i);
-	if (match) return match[1].toUpperCase();
-
-	// TP-068: Tolerate non-standard verdict formats from models that don't
-	// follow the exact template (e.g., "Changes requested", "Needs revision").
-	const lower = reviewContent.toLowerCase();
-	if (/\b(request\s+changes?|changes?\s+requested|needs?\s+revision|please\s+revise|must\s+revise)\b/.test(lower)) {
-		return "REVISE";
-	}
-	if (/\b(looks?\s+good|no\s+issues?\s+found|approved?)\b/.test(lower)) {
-		return "APPROVE";
-	}
-	if (/\b(fundamentally\s+wrong|rethink|reconsider\s+the\s+approach)\b/.test(lower)) {
-		return "RETHINK";
-	}
-
-	return "UNKNOWN";
+	return coreExtractVerdict(reviewContent);
 }
 
 /**
@@ -1756,9 +1512,7 @@ export type { BuildExitDiagnosticInput };
  * @returns true if the step should skip plan and code reviews
  */
 export function isLowRiskStep(stepNumber: number, totalSteps: number): boolean {
-	if (totalSteps <= 0) return false;
-	const lastStepIndex = totalSteps - 1;
-	return stepNumber === 0 || stepNumber === lastStepIndex;
+	return coreIsLowRiskStep(stepNumber, totalSteps);
 }
 
 // ── TMUX Agent Spawner ───────────────────────────────────────────────
@@ -2255,7 +2009,7 @@ export const _cleanupOrphanProcesses = cleanupOrphanProcesses;
 // ── Display Helpers ──────────────────────────────────────────────────
 
 function displayName(name: string): string {
-	return name.split("-").map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+	return coreDisplayName(name);
 }
 
 // ── Extension ────────────────────────────────────────────────────────

package/extensions/taskplane/abort.ts

@@ -7,6 +7,7 @@ import { execSync } from "child_process";
 import { join } from "path";
 
 import { execLog, resolveCanonicalTaskPaths, tmuxHasSession, tmuxKillSession } from "./execution.ts";
+import { killMergeAgentV2, killAllMergeAgentsV2 } from "./merge.ts";
 import { deleteBatchState, parseOrchSessionNames, persistRuntimeState } from "./persistence.ts";
 import type { AbortActionStep, AbortErrorCode, AbortLaneResult, AbortMode, AbortResult, AbortTargetSession, AllocatedLane, OrchBatchRuntimeState, PersistedBatchState, PersistedLaneRecord } from "./types.ts";
 
@@ -267,6 +268,8 @@ export function killOrchSessions(
 		// Best-effort child cleanup even if not explicitly targeted.
 		tmuxKillSession(`${name}-worker`);
 		tmuxKillSession(`${name}-reviewer`);
+		// TP-108: Also kill V2 merge agents (no-op if not V2)
+		killMergeAgentV2(name);
 
 		const killed = tmuxKillSession(name);
 		results.push({
@@ -332,7 +335,14 @@ export async function executeAbort(
 		execLog("abort", batchState.batchId, `Failed to persist state during abort: ${err instanceof Error ? err.message : String(err)}`);
 	}
 
-	// Step 3: List all orch sessions
+	// TP-108: Kill all V2 merge agents (process-owned, not TMUX)
+	// This catches V2 merge agents that have no TMUX session.
+	const v2MergeKilled = killAllMergeAgentsV2();
+	if (v2MergeKilled > 0) {
+		execLog("abort", batchState.batchId, `killed ${v2MergeKilled} V2 merge agent(s)`);
+	}
+
+	// Step 3: List all orch sessions (TMUX — legacy + fallback)
 	let allSessionNames: string[];
 	try {
 		allSessionNames = parseOrchSessionNames(