taskplane 0.1.18 → 0.2.1

package/dashboard/public/app.js

@@ -137,6 +137,13 @@ const $historySelect  = $("history-select");
 const $historyPanel   = $("history-panel");
 const $historyBody    = $("history-body");
 
+// ─── Repo Filter State ──────────────────────────────────────────────────────
+
+const $repoFilter = $("repo-filter");
+let selectedRepo = "";       // "" means "All repos"
+let knownRepos = [];         // sorted list of known repo IDs
+let repoFilterVisible = false;
+
 // ─── History State ──────────────────────────────────────────────────────────
 
 let historyList = [];  // compact batch summaries
@@ -147,6 +154,97 @@ let viewingHistoryId = null; // batchId if viewing history, null if live
 let viewerMode = null;   // "conversation" | "status-md" | null
 let viewerTarget = null; // session name (conversation) or taskId (status-md)
 
+// ─── Repo Helpers ───────────────────────────────────────────────────────────
+
+/**
+ * Build a sorted, deduplicated list of repo IDs from the batch payload.
+ * Returns empty array when mode !== "workspace" or when fewer than 2 repos.
+ */
+function buildRepoSet(batch) {
+  if (!batch || batch.mode !== "workspace") return [];
+
+  const repos = new Set();
+  for (const lane of (batch.lanes || [])) {
+    if (lane.repoId) repos.add(lane.repoId);
+  }
+  for (const task of (batch.tasks || [])) {
+    const rid = task.resolvedRepoId || task.repoId;
+    if (rid) repos.add(rid);
+  }
+  for (const mr of (batch.mergeResults || [])) {
+    for (const rr of (mr.repoResults || [])) {
+      if (rr.repoId) repos.add(rr.repoId);
+    }
+  }
+  const sorted = Array.from(repos).sort();
+  return sorted.length >= 2 ? sorted : [];
+}
+
+/**
+ * Update the repo filter dropdown options and visibility.
+ * Resets selection to "All repos" if the previously selected repo disappeared.
+ */
+function updateRepoFilter(repos) {
+  knownRepos = repos;
+  const shouldShow = repos.length >= 2;
+
+  if (shouldShow !== repoFilterVisible) {
+    $repoFilter.style.display = shouldShow ? "" : "none";
+    repoFilterVisible = shouldShow;
+  }
+
+  if (!shouldShow) {
+    selectedRepo = "";
+    return;
+  }
+
+  // If selected repo disappeared, reset to "All"
+  if (selectedRepo && !repos.includes(selectedRepo)) {
+    selectedRepo = "";
+  }
+
+  // Rebuild options only if repo set changed
+  const currentOpts = Array.from($repoFilter.options).slice(1).map(o => o.value);
+  const changed = currentOpts.length !== repos.length || currentOpts.some((v, i) => v !== repos[i]);
+  if (changed) {
+    // Preserve selection
+    const prev = selectedRepo;
+    $repoFilter.innerHTML = '<option value="">All repos</option>';
+    for (const r of repos) {
+      const opt = document.createElement("option");
+      opt.value = r;
+      opt.textContent = r;
+      $repoFilter.appendChild(opt);
+    }
+    $repoFilter.value = prev;
+  }
+}
+
+/** Get the effective repo ID for a task (prefer resolvedRepoId, fallback repoId). */
+function taskRepoId(task) {
+  return task.resolvedRepoId || task.repoId || undefined;
+}
+
+/** Render a repo badge span. Returns "" if repoId is falsy or repos not active. */
+function repoBadgeHtml(repoId, extraClass) {
+  if (!repoId || knownRepos.length < 2) return "";
+  return `<span class="repo-badge ${extraClass || ""}" title="Repo: ${escapeHtml(repoId)}">${escapeHtml(repoId)}</span>`;
+}
+
+// Repo filter change handler
+$repoFilter.addEventListener("change", (e) => {
+  selectedRepo = e.target.value;
+  // Re-render with current data
+  if (currentData) {
+    const batch = currentData.batch;
+    const tmux = currentData.tmuxSessions || [];
+    if (batch) {
+      renderLanesTasks(batch, tmux);
+      renderMergeAgents(batch, tmux);
+    }
+  }
+});
+
 // ─── Render: Header ─────────────────────────────────────────────────────────
 
 function renderHeader(batch) {
@@ -288,9 +386,18 @@ function renderLanesTasks(batch, tmuxSessions) {
   const tasks = batch.tasks || [];
   const tmuxSet = new Set(tmuxSessions || []);
   const laneStates = currentData?.laneStates || {};
+  const showRepos = knownRepos.length >= 2;
   let html = "";
 
   for (const lane of batch.lanes) {
+    // Repo filtering: if a repo is selected, skip lanes that don't match
+    if (selectedRepo && showRepos) {
+      const laneTasks = (lane.taskIds || []).map(tid => tasks.find(t => t.taskId === tid)).filter(Boolean);
+      const laneMatchesRepo = (lane.repoId === selectedRepo) ||
+        laneTasks.some(t => (taskRepoId(t) || lane.repoId) === selectedRepo);
+      if (!laneMatchesRepo) continue;
+    }
+
     const alive = tmuxSet.has(lane.tmuxSessionName);
     const tmuxCmd = `tmux attach -t ${lane.tmuxSessionName}`;
 
@@ -301,6 +408,9 @@ function renderLanesTasks(batch, tmuxSessions) {
     html += `  <div class="lane-meta">`;
     html += `    <span class="lane-session">${escapeHtml(lane.tmuxSessionName || "—")}</span>`;
     html += `    <span class="lane-branch">${escapeHtml(lane.branch || "—")}</span>`;
+    if (showRepos && lane.repoId) {
+      html += `    ${repoBadgeHtml(lane.repoId, "repo-badge-lane")}`;
+    }
     html += `  </div>`;
     html += `  <div class="lane-right">`;
     html += `    <span class="tmux-dot ${alive ? "alive" : "dead"}" title="${alive ? "tmux alive" : "tmux dead"}"></span>`;
@@ -326,6 +436,10 @@ function renderLanesTasks(batch, tmuxSessions) {
     const ls = laneStates[lane.tmuxSessionName] || null;
 
     for (const task of laneTasks) {
+      // Repo filtering at task level
+      const tRepo = taskRepoId(task) || lane.repoId;
+      if (selectedRepo && showRepos && tRepo !== selectedRepo) continue;
+
       const sd = task.statusData;
       const dur = task.startedAt
         ? formatDuration((task.endedAt || Date.now()) - task.startedAt)
@@ -402,7 +516,7 @@ function renderLanesTasks(batch, tmuxSessions) {
         <div class="task-row">
           <span class="task-icon"><span class="status-dot ${task.status}"></span></span>
           <span class="task-actions">${eyeHtml}</span>
-          <span class="task-id status-${task.status}">${escapeHtml(task.taskId)}</span>
+          <span class="task-id status-${task.status}">${escapeHtml(task.taskId)}${showRepos ? repoBadgeHtml(tRepo, "repo-badge-task") : ""}</span>
           <span><span class="status-badge status-${task.status}"><span class="status-dot ${task.status}"></span> ${task.status}</span></span>
           <span class="task-duration">${dur}</span>
           <span>${progressHtml}</span>
@@ -421,6 +535,7 @@ function renderLanesTasks(batch, tmuxSessions) {
 function renderMergeAgents(batch, tmuxSessions) {
   const mergeResults = batch?.mergeResults || [];
   const tmuxSet = new Set(tmuxSessions || []);
+  const showRepos = knownRepos.length >= 2;
 
   // Check for active merge sessions (convention: orch-merge-*)
   const mergeSessions = (tmuxSessions || []).filter(s => s.startsWith("orch-merge"));
@@ -436,6 +551,14 @@ function renderMergeAgents(batch, tmuxSessions) {
 
   // Show merge results
   for (const mr of mergeResults) {
+    // Repo filtering: if a repo is selected and this merge has repoResults,
+    // check if the selected repo is among them
+    const repoResults = mr.repoResults || [];
+    if (selectedRepo && showRepos && repoResults.length >= 2) {
+      const hasSelectedRepo = repoResults.some(rr => rr.repoId === selectedRepo);
+      if (!hasSelectedRepo) continue;
+    }
+
     const statusCls = mr.status === "succeeded" ? "status-succeeded"
       : mr.status === "partial" ? "status-stalled"
       : "status-failed";
@@ -458,6 +581,29 @@ function renderMergeAgents(batch, tmuxSessions) {
     html += `</td>`;
     html += `<td style="font-size:0.8rem;color:var(--text-muted);">${mr.failureReason ? escapeHtml(mr.failureReason) : "—"}</td>`;
     html += `</tr>`;
+
+    // Per-repo sub-rows: only when repoResults has 2+ entries (workspace mode)
+    if (showRepos && repoResults.length >= 2) {
+      const displayRepos = selectedRepo
+        ? repoResults.filter(rr => rr.repoId === selectedRepo)
+        : repoResults;
+
+      for (const rr of displayRepos) {
+        const rrStatusCls = rr.status === "succeeded" ? "status-succeeded"
+          : rr.status === "partial" ? "status-stalled"
+          : "status-failed";
+        const rrLanes = (rr.laneNumbers || []).map(n => `L${n}`).join(", ") || "—";
+        const rrDetail = rr.failureReason ? escapeHtml(rr.failureReason) : "—";
+
+        html += `<tr class="merge-repo-row">`;
+        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 style="font-size:0.75rem;color:var(--text-faint);">${rrDetail}</td>`;
+        html += `</tr>`;
+      }
+    }
   }
 
   // Show active merge sessions not yet in results
@@ -504,6 +650,9 @@ function renderNoBatch() {
   if (noBatchRendered) return;
   noBatchRendered = true;
 
+  // Hide repo filter when no batch
+  updateRepoFilter([]);
+
   // Hide live panels, show history panel
   const $lanesPanel = document.getElementById("lanes-tasks-panel");
   const $mergePanel = document.getElementById("merge-panel");
@@ -570,6 +719,11 @@ function render(data) {
 
   renderHeader(batch);
   renderSummary(batch);
+
+  // Update repo filter based on current batch data
+  const repos = buildRepoSet(batch);
+  updateRepoFilter(repos);
+
   renderLanesTasks(batch, tmux);
   renderMergeAgents(batch, tmux);
   renderErrors(batch);

package/dashboard/public/index.html

@@ -18,6 +18,9 @@
       <select class="history-select" id="history-select" title="View past batch runs">
         <option value="">History ▾</option>
       </select>
+      <select class="repo-filter-select" id="repo-filter" title="Filter by repository" style="display:none;">
+        <option value="">All repos</option>
+      </select>
       <div class="header-meta">
         <span id="last-update">—</span>
         <span class="connection-dot disconnected" id="conn-dot" title="SSE connection"></span>

package/dashboard/public/style.css

@@ -712,22 +712,26 @@ body {
   background: none;
   border: none;
   cursor: pointer;
-  font-size: 0.75rem;
-  padding: 2px;
+  font-size: 0.85rem;
+  padding: 3px 5px;
   border-radius: var(--radius-sm);
-  opacity: 0.6;
-  transition: opacity 0.2s, background 0.2s;
+  opacity: 1;
+  transition: opacity 0.2s, background 0.2s, color 0.2s, box-shadow 0.2s;
   line-height: 1;
+  color: var(--text-muted);
 }
 
 .viewer-eye-btn:hover {
   opacity: 1;
-  background: rgba(88,166,255,0.15);
+  background: rgba(88,166,255,0.18);
+  color: var(--accent);
 }
 
 .viewer-eye-btn.active {
   opacity: 1;
-  background: rgba(88,166,255,0.15);
+  background: rgba(88,166,255,0.25);
+  color: var(--accent);
+  box-shadow: 0 0 0 1px var(--accent-dim);
 }
 
 .tmux-view-btn.active {
@@ -940,6 +944,69 @@ body {
   .progress-bar-bg { width: 160px; }
 }
 
+/* ─── Repo Filter & Badges ─────────────────────────────────────────────── */
+
+.repo-filter-select {
+  background: var(--bg-surface);
+  border: 1px solid var(--border);
+  color: var(--text-muted);
+  font-family: var(--font-mono);
+  font-size: 0.8rem;
+  padding: 3px 8px;
+  border-radius: 8px;
+  cursor: pointer;
+  max-width: 220px;
+}
+.repo-filter-select:hover {
+  border-color: var(--accent);
+  color: var(--text);
+}
+.repo-filter-select:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+.repo-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-family: var(--font-mono);
+  font-size: 0.68rem;
+  font-weight: 500;
+  padding: 1px 7px;
+  border-radius: 8px;
+  background: rgba(188,140,255,0.12);
+  color: var(--magenta);
+  white-space: nowrap;
+  max-width: 140px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.repo-badge-lane {
+  margin-left: 8px;
+}
+
+.repo-badge-task {
+  margin-left: 4px;
+}
+
+/* Merge repo sub-rows */
+.merge-repo-row td {
+  padding: 4px 12px 4px 28px !important;
+  font-size: 0.78rem !important;
+  color: var(--text-muted);
+  border-bottom: 1px solid var(--border-subtle);
+}
+
+.merge-repo-row td:first-child {
+  padding-left: 28px !important;
+}
+
+.merge-repo-row:last-child td {
+  border-bottom: none;
+}
+
 /* ─── Scrollbar ────────────────────────────────────────────────────────── */
 
 ::-webkit-scrollbar { width: 6px; }

package/dashboard/server.cjs

@@ -191,11 +191,16 @@ function buildDashboardState() {
       currentWaveIndex: state.currentWaveIndex || 0,
       totalWaves: state.totalWaves || (state.wavePlan ? state.wavePlan.length : 0),
       wavePlan: state.wavePlan || [],
+      // Lanes already include repoId (string|undefined) from PersistedLaneRecord (v2).
       lanes: state.lanes || [],
+      // Tasks already include repoId, resolvedRepoId (string|undefined) from PersistedTaskRecord (v2).
       tasks,
       mergeResults: state.mergeResults || [],
       errors: state.errors || [],
       lastError: state.lastError || null,
+      // Workspace mode: "repo" (default/v1) or "workspace" (v2 multi-repo).
+      // Additive field — absent in v1 state files, frontend must default to "repo".
+      mode: state.mode || "repo",
     },
     tmuxSessions,
     timestamp: Date.now(),

package/extensions/taskplane/abort.ts

@@ -8,7 +8,7 @@ import { join } from "path";
 
 import { execLog, resolveCanonicalTaskPaths, tmuxHasSession, tmuxKillSession } from "./execution.ts";
 import { deleteBatchState, parseOrchSessionNames, persistRuntimeState } from "./persistence.ts";
-import type { AbortActionStep, AbortErrorCode, AbortLaneResult, AbortMode, AbortResult, AbortTargetSession, AllocatedLane, OrchBatchRuntimeState, PersistedBatchState } from "./types.ts";
+import type { AbortActionStep, AbortErrorCode, AbortLaneResult, AbortMode, AbortResult, AbortTargetSession, AllocatedLane, OrchBatchRuntimeState, PersistedBatchState, PersistedLaneRecord } from "./types.ts";
 
 // ── Abort Pure Functions ─────────────────────────────────────────────
 
@@ -35,20 +35,41 @@ export function selectAbortTargetSessions(
 	prefix: string = "orch",
 ): AbortTargetSession[] {
 	// Filter to only lane and merge sessions for the exact orchestrator prefix.
+	// Handles both repo-mode (`<prefix>-lane-<N>`) and workspace-mode
+	// (`<prefix>-<repoId>-lane-<N>`) session name formats.
 	const targetNames = allSessionNames.filter(name => {
 		const prefixWithDash = `${prefix}-`;
 		if (!name.startsWith(prefixWithDash)) return false;
 		const suffix = name.slice(prefixWithDash.length);
-		return suffix.startsWith("lane-") || suffix.startsWith("merge-");
+		// Repo mode: suffix starts with "lane-" or "merge-"
+		if (suffix.startsWith("lane-") || suffix.startsWith("merge-")) return true;
+		// Workspace mode: suffix is "<repoId>-lane-<N>" — contains "-lane-"
+		// Match any suffix that contains "-lane-" or "-merge-" followed by a number
+		if (/\-lane-\d/.test(suffix) || /\-merge-\d/.test(suffix)) return true;
+		return false;
 	});
 
+	// Build lookup from persisted lane records for workspace-aware laneId resolution.
+	// Keyed by tmuxSessionName for direct session-to-lane mapping.
+	const persistedLaneLookup = new Map<string, PersistedLaneRecord>();
+	if (persistedState?.lanes) {
+		for (const lane of persistedState.lanes) {
+			persistedLaneLookup.set(lane.tmuxSessionName, lane);
+		}
+	}
+
 	// Build lookup from persisted state task records
 	const persistedLookup = new Map<string, { laneId: string; taskId: string; taskFolder: string }>();
 	if (persistedState) {
 		for (const task of persistedState.tasks) {
 			if (task.sessionName) {
+				// Source laneId from persisted lane records (workspace-aware)
+				// rather than reconstructing as `lane-${laneNumber}` which
+				// drops the repo dimension in workspace mode.
+				const laneRecord = persistedLaneLookup.get(task.sessionName);
+				const laneId = laneRecord?.laneId ?? `lane-${task.laneNumber}`;
 				persistedLookup.set(task.sessionName, {
-					laneId: `lane-${task.laneNumber}`,
+					laneId,
 					taskId: task.taskId,
 					taskFolder: task.taskFolder,
 				});

package/extensions/taskplane/discovery.ts

@@ -886,8 +886,32 @@ export function resolveTaskRouting(
 ): DiscoveryError[] {
 	const errors: DiscoveryError[] = [];
 	const validRepoIds = workspaceConfig.repos;
+	const strictMode = workspaceConfig.routing.strict === true;
 
 	for (const task of discovery.pending.values()) {
+		// ── Strict mode enforcement ──────────────────────────────
+		// When strict routing is enabled, every task MUST declare an
+		// explicit execution target in PROMPT.md. Area-level and
+		// workspace-default fallbacks are NOT used for resolution.
+		if (strictMode && !task.promptRepoId) {
+			errors.push({
+				code: "TASK_ROUTING_STRICT",
+				message:
+					`Task ${task.taskId} has no explicit execution target, but strict routing is enabled ` +
+					`(routing.strict: true in workspace config). ` +
+					`Add an execution target to the task's PROMPT.md:\n` +
+					`\n` +
+					`  ## Execution Target\n` +
+					`\n` +
+					`  Repo: <repo-id>\n` +
+					`\n` +
+					`Available repos: ${[...validRepoIds.keys()].join(", ")}`,
+				taskId: task.taskId,
+				taskPath: task.promptPath,
+			});
+			continue;
+		}
+
 		// Precedence 1: prompt-declared repo
 		let resolvedId = task.promptRepoId;
 		let source = "prompt";

package/extensions/taskplane/engine.ts

@@ -9,13 +9,14 @@ import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
 import { execLog, executeWave, tmuxKillSession } from "./execution.ts";
 import type { MonitorUpdateCallback } from "./execution.ts";
 import { getCurrentBranch, runGit } from "./git.ts";
-import { mergeWave } from "./merge.ts";
-import { ORCH_MESSAGES } from "./messages.ts";
+import { mergeWaveByRepo } from "./merge.ts";
+import { computeMergeFailurePolicy, formatRepoMergeSummary, ORCH_MESSAGES } from "./messages.ts";
+import { resolveOperatorId } from "./naming.ts";
 import { deleteBatchState, loadBatchHistory, persistRuntimeState, saveBatchHistory, seedPendingOutcomesForAllocatedLanes, syncTaskOutcomesFromMonitor, upsertTaskOutcome } from "./persistence.ts";
 import { listOrchSessions } from "./sessions.ts";
 import { FATAL_DISCOVERY_CODES, generateBatchId } from "./types.ts";
 import type { AllocatedLane, BatchHistorySummary, BatchTaskSummary, BatchWaveSummary, DiscoveryResult, LaneExecutionResult, LaneTaskOutcome, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, TaskRunnerConfig, TokenCounts, WorkspaceConfig } from "./types.ts";
-import { buildDependencyGraph, computeWaves, validateGraph } from "./waves.ts";
+import { buildDependencyGraph, computeWaves, resolveRepoRoot, validateGraph } from "./waves.ts";
 import { deleteBranchBestEffort, forceCleanupWorktree, formatPreflightResults, listWorktrees, removeAllWorktrees, removeWorktree, runPreflight, safeResetWorktree, sleepSync } from "./worktree.ts";
 
 // ── /orch Execution Engine ───────────────────────────────────────────
@@ -52,6 +53,7 @@ export async function executeOrchBatch(
 	batchState.startedAt = Date.now();
 	batchState.pauseSignal = { paused: false };
 	batchState.mergeResults = [];
+	batchState.mode = workspaceConfig ? "workspace" : "repo";
 
 	// Capture the current branch as the base for worktrees and merge target
 	const detectedBranch = getCurrentBranch(repoRoot);
@@ -83,7 +85,7 @@ export async function executeOrchBatch(
 	execLog("batch", batchState.batchId, "starting batch planning");
 
 	// Preflight
-	const preflight = runPreflight(orchConfig);
+	const preflight = runPreflight(orchConfig, repoRoot);
 	onNotify(formatPreflightResults(preflight), preflight.passed ? "info" : "error");
 	if (!preflight.passed) {
 		batchState.phase = "failed";
@@ -118,6 +120,17 @@ export async function executeOrchBatch(
 				"info",
 			);
 		}
+		const hasStrictErrors = fatalErrors.some(
+			(e) => e.code === "TASK_ROUTING_STRICT",
+		);
+		if (hasStrictErrors) {
+			onNotify(
+				"💡 Strict routing is enabled (routing.strict: true). Every task must declare an explicit execution target.\n" +
+				"   Add a `## Execution Target` section with `Repo: <id>` to each task's PROMPT.md.\n" +
+				"   To disable strict routing, set `routing.strict: false` in workspace config.",
+				"info",
+			);
+		}
 		return;
 	}
 
@@ -241,6 +254,7 @@ export async function executeOrchBatch(
 					persistRuntimeState("wave-lanes-allocated", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, repoRoot);
 				}
 			},
+			workspaceConfig,
 		);
 
 		batchState.waveResults.push(waveResult);
@@ -332,7 +346,7 @@ export async function executeOrchBatch(
 				persistRuntimeState("merge-start", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, repoRoot);
 				onNotify(ORCH_MESSAGES.orchMergeStart(waveIdx + 1, mergeableLaneCount), "info");
 
-				mergeResult = mergeWave(
+				mergeResult = mergeWaveByRepo(
 					waveResult.allocatedLanes,
 					waveResult,
 					waveIdx + 1,
@@ -340,6 +354,7 @@ export async function executeOrchBatch(
 					repoRoot,
 					batchState.batchId,
 					batchState.baseBranch,
+					workspaceConfig,
 				);
 				allMergeResults.push(mergeResult);
 				batchState.mergeResults.push(mergeResult);
@@ -392,6 +407,14 @@ export async function executeOrchBatch(
 						ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane ?? 0, mergeResult.failureReason || "unknown"),
 						"error",
 					);
+
+					// Emit repo-divergence summary when partial is caused by cross-repo outcome differences
+					if (mergeResult.status === "partial") {
+						const repoSummary = formatRepoMergeSummary(mergeResult);
+						if (repoSummary) {
+							onNotify(repoSummary, "warning");
+						}
+					}
 				}
 
 				// Restore phase to executing (may be overridden below by failure handling)
@@ -424,58 +447,20 @@ export async function executeOrchBatch(
 		}
 
 		// ── Handle merge failure ─────────────────────────────────
-		// Apply config.failure.on_merge_failure policy
+		// Apply config.failure.on_merge_failure policy via shared helper
+		// for guaranteed parity with resume.ts (TP-005 Step 2).
 		if (mergeResult && (mergeResult.status === "failed" || mergeResult.status === "partial")) {
-			const mergeFailurePolicy = orchConfig.failure.on_merge_failure;
-			let failedLaneIds = mergeResult.laneResults
-				.filter(r => r.result?.status === "CONFLICT_UNRESOLVED" || r.result?.status === "BUILD_FAILURE" || r.error)
-				.map(r => `lane-${r.laneNumber}`)
-				.join(", ");
-			if (!failedLaneIds && mergeResult.failedLane !== null) {
-				failedLaneIds = `lane-${mergeResult.failedLane}`;
-			}
+			const policyResult = computeMergeFailurePolicy(mergeResult, waveIdx, orchConfig);
 
-			execLog("batch", batchState.batchId, `merge failure — applying ${mergeFailurePolicy} policy`, {
-				failedLane: mergeResult.failedLane ?? 0,
-				failedLaneIds,
-				reason: mergeResult.failureReason?.slice(0, 200) || "unknown",
-			});
+			execLog("batch", batchState.batchId, `merge failure — applying ${policyResult.policy} policy`, policyResult.logDetails);
 
-			if (mergeFailurePolicy === "pause") {
-				batchState.phase = "paused";
-				batchState.errors.push(
-					`Merge failed at wave ${waveIdx + 1}: ${mergeResult.failureReason || "unknown"}. ` +
-					`Batch paused. Resolve conflicts and use /orch-resume to continue.`,
-				);
-				// ── TS-009: Persist BEFORE cleanup decision (pause) ──
-				persistRuntimeState("merge-failure-pause", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, repoRoot);
-				onNotify(
-					`⏸️  Batch paused due to merge failure at wave ${waveIdx + 1} (${failedLaneIds}). ` +
-					`Reason: ${mergeResult.failureReason?.slice(0, 200) || "unknown"}. ` +
-					`Resolve conflicts and resume (TS-009).`,
-					"error",
-				);
-				// DO NOT cleanup/reset worktrees — preserve state for debugging/resume
-				preserveWorktreesForResume = true;
-				break;
-			} else {
-				// abort policy
-				batchState.phase = "stopped";
-				batchState.errors.push(
-					`Merge failed at wave ${waveIdx + 1}: ${mergeResult.failureReason || "unknown"}. ` +
-					`Batch aborted by on_merge_failure policy.`,
-				);
-				// ── TS-009: Persist BEFORE cleanup decision (abort) ──
-				persistRuntimeState("merge-failure-abort", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, repoRoot);
-				onNotify(
-					`⛔ Batch aborted due to merge failure at wave ${waveIdx + 1} (${failedLaneIds}). ` +
-					`Reason: ${mergeResult.failureReason?.slice(0, 200) || "unknown"}.`,
-					"error",
-				);
-				// DO NOT cleanup/reset worktrees — preserve state for debugging
-				preserveWorktreesForResume = true;
-				break;
-			}
+			batchState.phase = policyResult.targetPhase;
+			batchState.errors.push(policyResult.errorMessage);
+			persistRuntimeState(policyResult.persistTrigger, batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, repoRoot);
+			onNotify(policyResult.notifyMessage, policyResult.notifyLevel);
+			// DO NOT cleanup/reset worktrees — preserve state for debugging/resume
+			preserveWorktreesForResume = true;
+			break;
 		}
 
 		// NOTE: Merged branch cleanup is deferred to Phase 3, AFTER worktree
@@ -485,7 +470,8 @@ export async function executeOrchBatch(
 		// Only reset if merge succeeded AND there are more waves
 		if (waveIdx < rawWaves.length - 1 && !batchState.pauseSignal.paused) {
 			const prefix = orchConfig.orchestrator.worktree_prefix;
-			const existingWorktrees = listWorktrees(prefix, repoRoot);
+			const resetOpId = resolveOperatorId(orchConfig);
+			const existingWorktrees = listWorktrees(prefix, repoRoot, resetOpId);
 
 			if (existingWorktrees.length > 0) {
 				onNotify(
@@ -678,8 +664,9 @@ export async function executeOrchBatch(
 
 		// Clean up worktrees — pass base branch to protect unmerged work
 		const targetBranch = batchState.baseBranch;
+		const cleanupOpId = resolveOperatorId(orchConfig);
 		execLog("batch", batchState.batchId, "cleaning up worktrees");
-		const removeResult = removeAllWorktrees(prefix, repoRoot, targetBranch);
+		const removeResult = removeAllWorktrees(prefix, repoRoot, cleanupOpId, targetBranch);
 
 		// Log preserved branches
 		for (const p of removeResult.preserved) {
@@ -704,23 +691,32 @@ export async function executeOrchBatch(
 		// ── Post-worktree-removal: Clean up merged branches ──────
 		// This MUST run after worktree removal because git branch -D
 		// fails if any worktree still has the branch checked out.
+		// In workspace mode, each lane's branch lives in its owning repo,
+		// so we resolve the correct repo root per lane using repoId.
 		for (const mergeResult of allMergeResults) {
 			if (mergeResult.status === "succeeded" || mergeResult.status === "partial") {
 				for (const lr of mergeResult.laneResults) {
 					if (lr.result?.status === "SUCCESS" || lr.result?.status === "CONFLICT_RESOLVED") {
+						const laneRepoRoot = resolveRepoRoot(lr.repoId, repoRoot, workspaceConfig);
 						const ancestorCheck = runGit(
-							["merge-base", "--is-ancestor", lr.sourceBranch, targetBranch],
-							repoRoot,
+							["merge-base", "--is-ancestor", lr.sourceBranch, lr.targetBranch],
+							laneRepoRoot,
 						);
 						if (ancestorCheck.ok) {
-							const deleted = deleteBranchBestEffort(lr.sourceBranch, repoRoot);
+							const deleted = deleteBranchBestEffort(lr.sourceBranch, laneRepoRoot);
 							if (deleted) {
-								execLog("batch", batchState.batchId, `deleted merged branch ${lr.sourceBranch}`);
+								execLog("batch", batchState.batchId, `deleted merged branch ${lr.sourceBranch}`, {
+									repoId: lr.repoId ?? "(default)",
+								});
 							} else {
-								execLog("batch", batchState.batchId, `warning: failed to delete merged branch ${lr.sourceBranch} — retained for manual cleanup`);
+								execLog("batch", batchState.batchId, `warning: failed to delete merged branch ${lr.sourceBranch} — retained for manual cleanup`, {
+									repoId: lr.repoId ?? "(default)",
+								});
 							}
 						} else {
-							execLog("batch", batchState.batchId, `warning: branch ${lr.sourceBranch} not fully merged into ${targetBranch} — retained`);
+							execLog("batch", batchState.batchId, `warning: branch ${lr.sourceBranch} not fully merged into ${lr.targetBranch} — retained`, {
+								repoId: lr.repoId ?? "(default)",
+							});
 						}
 					}
 				}