taskplane 0.24.29 → 0.24.31

package/dashboard/public/app.js

@@ -455,6 +455,27 @@ function renderSummary(batch) {
   const wavePlan = batch.wavePlan || [tasks.map(t => t.taskId)]; // fallback: single wave
   const currentWaveIdx = batch.currentWaveIndex || 0;
 
+  // TP-148: Build wave segment context — for each task appearing in multiple waves,
+  // determine which segment corresponds to each wave appearance.
+  const taskWaveAppearance = new Map(); // taskId → count of appearances so far
+  const waveSegmentLabels = wavePlan.map((taskIds) => {
+    const labels = new Map(); // taskId → label string
+    for (const tid of taskIds) {
+      const task = taskMap.get(tid);
+      const segmentIds = task?.segmentIds;
+      if (!segmentIds || segmentIds.length <= 1) continue;
+      const count = (taskWaveAppearance.get(tid) || 0);
+      taskWaveAppearance.set(tid, count + 1);
+      const segId = segmentIds[count];
+      if (segId) {
+        const parsed = parseSegmentId(segId);
+        const repo = parsed ? parsed.repoId : "";
+        labels.set(tid, `${tid} (segment ${count + 1}/${segmentIds.length}: ${repo})`);
+      }
+    }
+    return labels;
+  });
+
   // Compute per-wave and overall checkbox totals
   let batchChecked = 0, batchTotal = 0;
   const waveStats = wavePlan.map((taskIds, waveIdx) => {
@@ -503,7 +524,10 @@ function renderSummary(batch) {
     const fillWidth = isDone ? 100 : fillPct;
     const segClass = isCurrent ? "wave-seg-current" : isFuture ? "wave-seg-future" : "";
 
-    barHtml += `<div class="wave-seg ${segClass}" style="width:${segWidthPct.toFixed(1)}%" title="W${ws.waveIdx + 1}: ${ws.checked}/${ws.total} checkboxes (${ws.taskIds.join(', ')})">`;
+    // TP-148: Use segment-aware labels in tooltip when available
+    const segLabels = waveSegmentLabels[ws.waveIdx] || new Map();
+    const tooltipTasks = ws.taskIds.map(tid => segLabels.get(tid) || tid).join(', ');
+    barHtml += `<div class="wave-seg ${segClass}" style="width:${segWidthPct.toFixed(1)}%" title="W${ws.waveIdx + 1}: ${ws.checked}/${ws.total} checkboxes (${tooltipTasks})">`;
     barHtml += `  <div class="wave-seg-fill ${fillClass}" style="width:${fillWidth.toFixed(1)}%"></div>`;
     barHtml += `  <span class="wave-seg-label">W${ws.waveIdx + 1}</span>`;
     barHtml += `</div>`;
@@ -1144,7 +1168,7 @@ function renderMailboxAuditEvent(evt) {
   } else {
     // Unknown event type — render generically
     direction = evt.from ? `${escapeHtml(evt.from)}` : '';
-    preview = JSON.stringify(evt).slice(0, 120);
+    preview = JSON.stringify(evt);
   }
 
   return `<div class="message-row">`
@@ -1175,7 +1199,7 @@ function renderMailboxDirMessage(msg) {
   else if (msg._status === 'reply-acked') statusBadge = '<span class="msg-badge msg-delivered">reply (acked)</span>';
   else statusBadge = '';
   const typeBadge = `<span class="msg-badge msg-type">${escapeHtml(msg.type || '')}</span>`;
-  const preview = (msg.content || '').slice(0, 120);
+  const preview = msg.content || '';
   const broadcastTag = msg._isBroadcast ? ' <span class="msg-badge msg-type">broadcast</span>' : '';
 
   return `<div class="message-row">`

package/dashboard/public/style.css

@@ -1787,9 +1787,9 @@ body {
 }
 .message-row {
   display: flex;
-  align-items: center;
+  align-items: flex-start;
   gap: 8px;
-  padding: 4px 8px;
+  padding: 6px 8px;
   font-size: 0.8rem;
   border-radius: 4px;
   background: var(--bg-secondary);
@@ -1826,9 +1826,8 @@ body {
 }
 .msg-preview {
   color: var(--text-primary);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  white-space: pre-wrap;
+  word-break: break-word;
   flex: 1;
 }
 .msg-rate-limited {

package/dashboard/server.cjs

@@ -1118,6 +1118,9 @@ function buildDashboardState() {
       // 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",
+      // TP-148: Segment records for wave display context (v4+).
+      // Each record has taskId, segmentId, repoId, status.
+      segments: state.segments || [],
     },
     sessions,
     tmuxSessions: sessions, // Legacy compatibility field for older dashboard clients

package/extensions/taskplane/engine.ts

@@ -22,7 +22,7 @@ import { readRegistrySnapshot, isTerminalStatus, isProcessAlive as registryIsPro
 import { buildBatchProgressSnapshot, buildEngineEventBase, buildSegmentId, buildSupervisorSegmentFrontierSnapshot, defaultResilienceState, FATAL_DISCOVERY_CODES, generateBatchId, TIER0_RETRYABLE_CLASSIFICATIONS, TIER0_RETRY_BUDGETS, tier0ScopeKey, tier0WaveScopeKey } from "./types.ts";
 import type { AllocatedLane, AllocatedTask, BatchHistorySummary, BatchTaskSummary, BatchWaveSummary, DiscoveryResult, EngineEventCallback, EscalationContext, LaneExecutionResult, LaneTaskOutcome, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, ParsedTask, PersistedSegmentRecord, SegmentExpansionRequest, SupervisorAlert, SupervisorAlertCallback, TaskRunnerConfig, TaskSegmentPlan, TaskSegmentPlanMap, TaskSegmentNode, Tier0EscalationPattern, Tier0RecoveryPattern, TokenCounts, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
 import { buildDependencyGraph, computeWaveAssignments, resolveBaseBranch, resolveRepoRoot, validateGraph } from "./waves.ts";
-import { deleteBranchBestEffort, forceCleanupWorktree, formatPreflightResults, listWorktrees, preserveFailedLaneProgress, removeAllWorktrees, removeWorktree, runPreflight, safeResetWorktree, sleepSync } from "./worktree.ts";
+import { deleteBranchBestEffort, forceCleanupWorktree, formatPreflightResults, listWorktrees, preserveFailedLaneProgress, preserveSkippedLaneProgress, removeAllWorktrees, removeWorktree, runPreflight, safeResetWorktree, sleepSync } from "./worktree.ts";
 import { runPreflightCleanup, formatPreflightCleanup } from "./cleanup.ts";
 
 // ── Tier 0: Automatic Recovery Helpers (TP-039) ─────────────────────
@@ -346,9 +346,28 @@ export function validateSegmentExpansionRequestAtBoundary(
 	if (requestedRepoSet.size !== request.requestedRepoIds.length) {
 		return "duplicate repoIds in requestedRepoIds";
 	}
+
+	// TP-145: Build a set of known repo IDs that edge endpoints may reference.
+	// This includes all requestedRepoIds plus the anchor segment's repo and
+	// any already-completed segments' repos. Workers commonly reference the
+	// anchor repo in edges (e.g., { from: "shared-libs", to: "web-client" })
+	// which is valid — the dependency is implicit for after-current placement.
+	const knownEdgeRepoIds = new Set(requestedRepoSet);
+	const orderedSegments = segmentState.orderedSegments ?? [];
+	const anchorSegment = orderedSegments.find((seg) => seg.segmentId === segmentId);
+	if (anchorSegment) {
+		knownEdgeRepoIds.add(anchorSegment.repoId);
+	}
+	for (const seg of orderedSegments) {
+		const status = segmentState.statusBySegmentId?.get(seg.segmentId);
+		if (status === "succeeded" || status === "failed" || status === "skipped") {
+			knownEdgeRepoIds.add(seg.repoId);
+		}
+	}
+
 	for (const edge of request.edges) {
-		if (!requestedRepoSet.has(edge.from) || !requestedRepoSet.has(edge.to)) {
-			return "edge references a repo outside requestedRepoIds";
+		if (!knownEdgeRepoIds.has(edge.from) || !knownEdgeRepoIds.has(edge.to)) {
+			return "edge references a repo outside requestedRepoIds and known segments";
 		}
 	}
 
@@ -2289,10 +2308,29 @@ export async function executeOrchBatch(
 				ORCH_MESSAGES.orchWaveStart(waveIdx + 1, runtimeSegmentRounds.length, waveTasks.length, lanes.length),
 				"info",
 			);
+			// TP-148: Build per-task segment context for the wave_start event
+			const waveSegmentContext: Array<{ taskId: string; segmentIndex: number; totalSegments: number; repoId: string; segmentId: string }> = [];
+			for (const taskId of waveTasks) {
+				const segState = segmentStateByTask.get(taskId);
+				if (segState && segState.orderedSegments.length > 1) {
+					const idx = segState.nextSegmentIndex;
+					const seg = segState.orderedSegments[idx];
+					if (seg) {
+						waveSegmentContext.push({
+							taskId,
+							segmentIndex: idx + 1,
+							totalSegments: segState.orderedSegments.length,
+							repoId: seg.repoId,
+							segmentId: seg.segmentId,
+						});
+					}
+				}
+			}
 			emitEvent(stateRoot, {
 				...buildEngineEventBase("wave_start", batchState.batchId, waveIdx, batchState.phase),
 				taskIds: waveTasks,
 				laneCount: lanes.length,
+				...(waveSegmentContext.length > 0 ? { segmentContext: waveSegmentContext } : {}),
 			}, onEngineEvent);
 			// TP-029: Track repos from newly allocated lanes for cleanup coverage
 			for (const lane of lanes) {
@@ -2521,10 +2559,12 @@ export async function executeOrchBatch(
 			const segmentState = segmentStateByTask.get(taskId);
 			if (!task || !segmentState) continue;
 
-			const activeSegmentId = task.activeSegmentId;
+			// Use the completing segment ID from the task outcome, not task.activeSegmentId
+			// which may already be null (advanced by pre-wave loop for next wave).
+			const outcome = allTaskOutcomes.find((candidate) => candidate.taskId === taskId);
+			const activeSegmentId = outcome?.segmentId ?? task.activeSegmentId;
 			if (activeSegmentId) {
 				segmentState.statusBySegmentId.set(activeSegmentId, "succeeded");
-				const outcome = allTaskOutcomes.find((candidate) => candidate.taskId === taskId);
 				upsertTerminalSegmentRecord(batchState, task, segmentState, activeSegmentId, "succeeded", outcome, laneByTaskId.get(taskId));
 
 				const workerAgentId = resolveTaskWorkerAgentId(taskId, allTaskOutcomes, laneByTaskId);
@@ -2610,6 +2650,26 @@ export async function executeOrchBatch(
 								batchState.orchBranch,
 							);
 							const recordedRequestId = recordProcessedSegmentExpansionRequestId(batchState, requestId, "succeeded");
+
+							// TP-145 hardening: if .DONE was prematurely created by the
+							// completing segment (because it was the last segment at that
+							// time), remove it now. The task is no longer complete — new
+							// segments have been added and must execute first.
+							// Only delete if segments were actually inserted (avoid
+							// reopening a completed task on no-op mutations).
+							const doneDir = task.packetTaskPath || task.taskFolder;
+							if (doneDir && mutation.insertedSegmentIds.length > 0) {
+								const donePath = join(doneDir, ".DONE");
+								if (existsSync(donePath)) {
+									try {
+										unlinkSync(donePath);
+										execLog("batch", batchState.batchId, "removed premature .DONE after segment expansion", {
+											taskId, donePath, requestId,
+										});
+									} catch { /* non-fatal */ }
+								}
+							}
+
 							if (persistedInsertedSegments || recordedRequestId || mutation.insertedSegmentIds.length > 0) {
 								persistRuntimeState("segment-expansion-approved", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discoveryRef, stateRoot);
 							}
@@ -2672,11 +2732,11 @@ export async function executeOrchBatch(
 			const task = discovery.pending.get(taskId);
 			const segmentState = segmentStateByTask.get(taskId);
 			if (!task || !segmentState) continue;
-			const activeSegmentId = task.activeSegmentId;
+			const failOutcome = allTaskOutcomes.find((candidate) => candidate.taskId === taskId);
+			const activeSegmentId = failOutcome?.segmentId ?? task.activeSegmentId;
 			if (activeSegmentId) {
 				segmentState.statusBySegmentId.set(activeSegmentId, "failed");
-				const outcome = allTaskOutcomes.find((candidate) => candidate.taskId === taskId);
-				upsertTerminalSegmentRecord(batchState, task, segmentState, activeSegmentId, "failed", outcome, laneByTaskId.get(taskId));
+				upsertTerminalSegmentRecord(batchState, task, segmentState, activeSegmentId, "failed", failOutcome, laneByTaskId.get(taskId));
 
 				const workerAgentId = resolveTaskWorkerAgentId(taskId, allTaskOutcomes, laneByTaskId);
 				if (workerAgentId) {
@@ -2913,13 +2973,16 @@ export async function executeOrchBatch(
 		// files (especially for level-0 / fast tasks). Check each merge-candidate
 		// lane worktree and auto-commit any remaining changes so they're included
 		// in the merge. Skips lanes with only failed/stalled tasks (no merge).
+		// TP-147: Also auto-commit skipped-task lanes so partial progress
+		// (STATUS.md updates, partial code) is preserved on their branch.
 		for (const lane of waveResult.allocatedLanes) {
 			if (!lane.worktreePath || !existsSync(lane.worktreePath)) continue;
-			// Only check lanes that have at least one succeeded task (merge candidates)
 			const laneOutcome = laneOutcomeByNumber.get(lane.laneNumber);
 			if (!laneOutcome) continue;
 			const hasSucceeded = laneOutcome.tasks.some(t => t.status === "succeeded");
-			if (!hasSucceeded) continue;
+			const hasSkipped = laneOutcome.tasks.some(t => t.status === "skipped");
+			// Auto-commit merge candidates (succeeded) and skipped-task lanes
+			if (!hasSucceeded && !hasSkipped) continue;
 			try {
 				const addResult = runGit(["add", "-A"], lane.worktreePath);
 				if (!addResult.ok) {
@@ -3463,6 +3526,34 @@ export async function executeOrchBatch(
 			}
 			// TP-028: Stamp task outcomes with partial progress data for persistence
 			applyPartialProgressToOutcomes(ppResult, allTaskOutcomes);
+
+			// TP-147: Also preserve skipped task branches before inter-wave reset
+			const skippedPpResult = preserveSkippedLaneProgress(
+				latestAllocatedLanes,
+				allTaskOutcomes,
+				ppOpId,
+				batchState.batchId,
+				(repoId) => {
+					const perRepoRoot = resolveRepoRoot(repoId, repoRoot, workspaceConfig);
+					let targetBranch = batchState.orchBranch;
+					if (repoId && perRepoRoot !== repoRoot) {
+						try {
+							targetBranch = resolveBaseBranch(repoId, perRepoRoot, batchState.orchBranch, workspaceConfig);
+						} catch { /* fall back to orchBranch */ }
+					}
+					return { repoRoot: perRepoRoot, targetBranch };
+				},
+			);
+			// Merge unsafe branches from skipped tasks into the main set
+			for (const branch of skippedPpResult.unsafeBranches) {
+				ppUnsafeBranches.add(branch);
+			}
+			if (skippedPpResult.results.some(r => r.saved)) {
+				execLog("batch", batchState.batchId,
+					`preserved partial progress for ${skippedPpResult.results.filter(r => r.saved).length} skipped task(s) before inter-wave reset`);
+			}
+			// Stamp skipped task outcomes with partial progress data
+			applyPartialProgressToOutcomes(skippedPpResult, allTaskOutcomes);
 		}
 
 		// ── Post-merge: Reset worktrees for next wave ────────────
@@ -3809,6 +3900,30 @@ export async function executeOrchBatch(
 			};
 		});
 
+		// TP-147: Ensure ALL tasks from the wave plan are represented in history.
+		// Tasks that never got allocated (blocked by upstream failures, never started)
+		// won't have entries in allTaskOutcomes. Add them with appropriate status.
+		const coveredTaskIds = new Set(taskSummaries.map(t => t.taskId));
+		for (let wi = 0; wi < wavePlan.length; wi++) {
+			for (const taskId of wavePlan[wi]) {
+				if (coveredTaskIds.has(taskId)) continue;
+				// Determine the appropriate status for uncovered tasks
+				const isBlocked = batchState.blockedTaskIds.has(taskId);
+				const status: BatchTaskSummary["status"] = isBlocked ? "blocked" : "pending";
+				taskSummaries.push({
+					taskId,
+					taskName: taskId,
+					status,
+					wave: wi + 1,
+					lane: 0,
+					durationMs: 0,
+					tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, costUsd: 0 },
+					exitReason: isBlocked ? "Blocked by upstream failure" : null,
+				});
+				coveredTaskIds.add(taskId);
+			}
+		}
+
 		// Build per-wave summaries
 		const waveSummaries: BatchWaveSummary[] = wavePlan.map((taskIds, wi) => {
 			const waveTasks = taskSummaries.filter(t => t.wave === wi + 1);
@@ -3850,6 +3965,16 @@ export async function executeOrchBatch(
 					? "completed"
 					: "aborted";
 
+		// TP-147: Ensure totalTasks matches actual task array length.
+		// Use taskSummaries.length as authoritative (includes gap-filled tasks)
+		// and log a warning if it diverges from batchState.totalTasks.
+		const actualTotalTasks = taskSummaries.length;
+		if (actualTotalTasks !== batchState.totalTasks) {
+			execLog("batch", batchState.batchId,
+				`WARNING: totalTasks mismatch — batchState.totalTasks=${batchState.totalTasks}, ` +
+				`taskSummaries.length=${actualTotalTasks}. Using taskSummaries.length for history.`);
+		}
+
 		const summary: BatchHistorySummary = {
 			batchId: batchState.batchId,
 			status: historyStatus,
@@ -3857,7 +3982,7 @@ export async function executeOrchBatch(
 			endedAt: Date.now(),
 			durationMs: Date.now() - batchState.startedAt,
 			totalWaves: wavePlan.length,
-			totalTasks: batchState.totalTasks,
+			totalTasks: actualTotalTasks,
 			succeededTasks: batchState.succeededTasks,
 			failedTasks: batchState.failedTasks,
 			skippedTasks: batchState.skippedTasks,
@@ -3981,6 +4106,37 @@ export async function executeOrchBatch(
 			}
 			// TP-028: Stamp task outcomes with partial progress data for persistence
 			applyPartialProgressToOutcomes(ppResult, allTaskOutcomes);
+
+			// TP-147: Also preserve skipped task branches before terminal cleanup
+			const skippedPpResult = preserveSkippedLaneProgress(
+				latestAllocatedLanes,
+				allTaskOutcomes,
+				ppOpId,
+				batchState.batchId,
+				(repoId) => {
+					const perRepoRoot = resolveRepoRoot(repoId, repoRoot, workspaceConfig);
+					let targetBranch = batchState.orchBranch;
+					if (repoId && perRepoRoot !== repoRoot) {
+						try {
+							targetBranch = resolveBaseBranch(repoId, perRepoRoot, batchState.orchBranch, workspaceConfig);
+						} catch { /* fall back to orchBranch */ }
+					}
+					return { repoRoot: perRepoRoot, targetBranch };
+				},
+			);
+			if (skippedPpResult.results.some(r => r.saved)) {
+				execLog("batch", batchState.batchId,
+					`preserved partial progress for ${skippedPpResult.results.filter(r => r.saved).length} skipped task(s) before terminal cleanup`);
+			}
+			for (const r of skippedPpResult.results) {
+				if (!r.saved && (r.commitCount > 0 || r.error)) {
+					execLog("batch", batchState.batchId,
+						`WARNING: Failed to preserve partial progress for skipped task ${r.taskId} ` +
+						`(${r.commitCount} commit(s) may become unreachable after cleanup)`,
+						{ taskId: r.taskId, commitCount: r.commitCount, error: r.error ?? "unknown" });
+				}
+			}
+			applyPartialProgressToOutcomes(skippedPpResult, allTaskOutcomes);
 		}
 
 		// TP-029: Clean up worktrees across ALL encountered repos (not just primary).

package/extensions/taskplane/execution.ts

@@ -164,7 +164,7 @@ export function execLog(
  * @returns true if agent is alive
  * @since TP-112
  */
-export function isV2AgentAlive(agentIdOrSessionName: string, _runtimeBackend?: RuntimeBackend): boolean {
+export function isV2AgentAlive(agentIdOrSessionName: string, _runtimeBackend?: RuntimeBackend, laneNumber?: number): boolean {
 	// Read the registry from the global state root.
 	// Since this is a pure liveness check, we scan for matching agentId
 	// patterns: direct match, or lane-session + "-worker" suffix.
@@ -176,6 +176,18 @@ export function isV2AgentAlive(agentIdOrSessionName: string, _runtimeBackend?: R
 	// Try worker suffix (monitor uses lane session name, registry uses agentId)
 	const workerManifest = agents[`${agentIdOrSessionName}-worker`];
 	if (workerManifest && !isTerminalStatus(workerManifest.status) && isProcessAlive(workerManifest.pid)) return true;
+	// TP-148: In workspace mode, laneSessionId includes repoId and uses a local
+	// lane number (e.g., "orch-henry-api-lane-1") while the V2 registry uses
+	// global lane numbers without repoId (e.g., "orch-henry-lane-3-worker").
+	// Fall back to scanning the registry by global lane number when provided.
+	if (laneNumber != null) {
+		for (const agent of Object.values(agents)) {
+			if (agent.laneNumber === laneNumber && agent.role === "worker" &&
+				!isTerminalStatus(agent.status) && isProcessAlive(agent.pid)) {
+				return true;
+			}
+		}
+	}
 	return false;
 }
 
@@ -201,7 +213,7 @@ export function setV2LivenessRegistryCache(registry: import("./process-registry.
  */
 export function killV2LaneAgents(
 	sessionName: string,
-	options?: { stateRoot?: string; batchId?: string; logContext?: string },
+	options?: { stateRoot?: string; batchId?: string; logContext?: string; laneNumber?: number },
 ): void {
 	const registry = _v2LivenessRegistryCache ?? (
 		options?.stateRoot && options?.batchId
@@ -212,16 +224,32 @@ export function killV2LaneAgents(
 
 	const agents = registry.agents;
 	const logContext = options?.logContext ?? "monitor";
+	const killedPids = new Set<number>();
 	for (const suffix of ["-worker", "-reviewer", ""]) {
 		const key = `${sessionName}${suffix}`;
 		const manifest = agents[key];
-		if (manifest && !isTerminalStatus(manifest.status) && isProcessAlive(manifest.pid)) {
+		if (manifest && !isTerminalStatus(manifest.status) && isProcessAlive(manifest.pid) && !killedPids.has(manifest.pid)) {
 			try {
 				process.kill(manifest.pid, "SIGTERM");
+				killedPids.add(manifest.pid);
 				execLog(logContext, key, `killed V2 agent (PID ${manifest.pid})`);
 			} catch { /* already dead */ }
 		}
 	}
+	// TP-148: Workspace-mode fallback — match by global lane number when
+	// session name lookup misses (repoId/local-vs-global lane mismatch).
+	if (options?.laneNumber != null) {
+		for (const agent of Object.values(agents)) {
+			if (agent.laneNumber === options.laneNumber &&
+				!isTerminalStatus(agent.status) && isProcessAlive(agent.pid) && !killedPids.has(agent.pid)) {
+				try {
+					process.kill(agent.pid, "SIGTERM");
+					killedPids.add(agent.pid);
+					execLog(logContext, agent.agentId, `killed V2 agent by lane number (PID ${agent.pid})`);
+				} catch { /* already dead */ }
+			}
+		}
+	}
 }
 
 // ── Async File/Status Helpers (TP-070) ───────────────────────────────
@@ -877,7 +905,7 @@ export async function resolveTaskMonitorState(
 					// New task, stale snapshot — give the worker startup grace period
 					sessionAlive = true;
 				} else {
-					sessionAlive = isV2AgentAlive(sessionName, runtimeBackend);
+					sessionAlive = isV2AgentAlive(sessionName, runtimeBackend, v2Context?.laneNumber);
 				}
 			} else {
 				sessionAlive = true;
@@ -886,7 +914,7 @@ export async function resolveTaskMonitorState(
 			sessionAlive = snap.status === "running";
 		}
 	} else {
-		sessionAlive = isV2AgentAlive(sessionName, "v2");
+		sessionAlive = isV2AgentAlive(sessionName, "v2", v2Context?.laneNumber);
 	}
 	const doneFileFound = await fileExistsAsync(donePath);
 
@@ -984,7 +1012,7 @@ export async function resolveTaskMonitorState(
 			stallMinutes,
 			backend: runtimeBackend ?? "legacy",
 		});
-		killV2LaneAgents(sessionName);
+		killV2LaneAgents(sessionName, { laneNumber: v2Context?.laneNumber });
 
 		return {
 			taskId,
@@ -1249,7 +1277,8 @@ export async function monitorLanes(
 			}
 
 			// TP-112: Backend-aware lane liveness for snapshot
-			const sessionAlive = isV2AgentAlive(laneSessionIdOf(lane), "v2");
+			// TP-148: Pass global laneNumber for workspace-mode fallback lookup
+			const sessionAlive = isV2AgentAlive(laneSessionIdOf(lane), "v2", lane.laneNumber);
 
 			laneSnapshots.push({
 				laneId: lane.laneId,
@@ -1874,7 +1903,7 @@ export async function executeWithStopAll(
 
 					// Kill ALL lane sessions immediately
 					for (const lane of lanes) {
-						killV2LaneAgents(laneSessionIdOf(lane));
+						killV2LaneAgents(laneSessionIdOf(lane), { laneNumber: lane.laneNumber });
 					}
 				}
 			}
@@ -1888,7 +1917,7 @@ export async function executeWithStopAll(
 				pauseSignal.paused = true;
 				execLog("wave", `W${waveIndex}`, `stop-all triggered by lane error in ${lanes[idx].laneId}: ${errMsg}`);
 				for (const lane of lanes) {
-					killV2LaneAgents(laneSessionIdOf(lane));
+					killV2LaneAgents(laneSessionIdOf(lane), { laneNumber: lane.laneNumber });
 				}
 			}
 

package/extensions/taskplane/lane-runner.ts

@@ -176,6 +176,19 @@ export async function executeTaskV2(
 	updateStatusField(statusPath, "Last Updated", new Date().toISOString().slice(0, 10));
 	logExecution(statusPath, "Task started", "Runtime V2 lane-runner execution");
 
+	// Pre-segment guard: remove any stale .DONE from a prior segment or prior run.
+	// This closes the race window where the monitor sees .DONE before lane-runner
+	// can suppress it at segment end. For non-final segments, .DONE must not exist
+	// at any point during execution.
+	const isNonFinalAtStart = segmentId != null
+		&& Array.isArray(unit.task.segmentIds)
+		&& unit.task.segmentIds.length > 1
+		&& unit.task.segmentIds[unit.task.segmentIds.length - 1] !== segmentId;
+	if (isNonFinalAtStart && existsSync(donePath)) {
+		try { unlinkSync(donePath); } catch { /* best effort */ }
+		logExecution(statusPath, "Segment start", `Removed stale .DONE before non-final segment ${segmentId}`);
+	}
+
 	// ── 2. Iteration loop ───────────────────────────────────────────
 	let noProgressCount = 0;
 	let totalIterations = 0;
@@ -528,7 +541,39 @@ export async function executeTaskV2(
 			false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
 	}
 
-	// Create .DONE if not already present
+	// TP-145: Determine if this is a non-final segment of a multi-segment task.
+	// If more segments remain after this one, suppress .DONE creation so that
+	// the engine can advance the segment frontier and execute subsequent segments.
+	// .DONE must only exist when ALL segments of a multi-segment task are complete.
+	const isNonFinalSegment = segmentId != null
+		&& Array.isArray(unit.task.segmentIds)
+		&& unit.task.segmentIds.length > 1
+		&& unit.task.segmentIds[unit.task.segmentIds.length - 1] !== segmentId;
+
+	if (isNonFinalSegment) {
+		// Segment succeeded but more segments remain — suppress .DONE and "✅ Complete" status.
+		// The engine will advance the frontier and dispatch the next segment.
+		// Also delete any .DONE the worker may have created directly (workers have
+		// write access and sometimes create .DONE on their own, bypassing this gate).
+		if (existsSync(donePath)) {
+			let deleted = false;
+			try { unlinkSync(donePath); deleted = true; } catch { /* best effort */ }
+			if (deleted) {
+				logExecution(statusPath, "Segment complete",
+					`Segment ${segmentId} succeeded (non-final — removed premature worker-created .DONE)`);
+			} else {
+				logExecution(statusPath, "Segment complete",
+					`⚠️ Segment ${segmentId} succeeded but FAILED to remove premature .DONE — downstream segments may be skipped`);
+			}
+		} else {
+			logExecution(statusPath, "Segment complete",
+				`Segment ${segmentId} succeeded (not final — .DONE suppressed)`);
+		}
+		return makeResult(taskId, segmentId, workerAgentId, "succeeded", startTime,
+			"Segment completed (non-final — .DONE suppressed)", false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
+	}
+
+	// Create .DONE if not already present (final segment or single-segment/whole-task execution)
 	if (!existsSync(donePath)) {
 		writeFileSync(donePath, `Completed: ${new Date().toISOString()}\nTask: ${taskId}\n`);
 	}

package/extensions/taskplane/supervisor.ts

@@ -397,19 +397,52 @@ export interface IntegrationPlan {
 	failedTasks: number;
 }
 
+/**
+ * Check whether the git repository has any remotes configured.
+ *
+ * Used by integration planning to determine if PR mode is possible.
+ * A repo without remotes cannot create pull requests.
+ *
+ * @param cwd - Working directory with the git repo
+ * @returns true if at least one remote is configured
+ *
+ * @since TP-149
+ */
+export function hasGitRemotes(cwd: string): boolean {
+	try {
+		const result = execFileSync("git", ["remote"], {
+			encoding: "utf-8",
+			timeout: 5_000,
+			cwd,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		return result.trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+
 /**
  * Build an integration plan based on the batch state and branch status.
  *
- * Mode selection logic:
- * 1. If base branch is protected → PR mode (can't push directly)
- * 2. If branches have diverged → merge mode (ff not possible)
- * 3. Otherwise → ff mode (cleanest)
+ * Mode selection logic (TP-149):
+ * 1. Check if remotes exist (determines if PR mode is possible)
+ * 2. If base branch is confirmed protected AND remotes exist → PR mode
+ * 3. Try fast-forward first (cleanest, most common)
+ * 4. If FF not possible (diverged) → merge mode
+ *
+ * PR mode is only selected when protection is **confirmed** (not "unknown").
+ * When protection status is indeterminate (gh unavailable, auth issues),
+ * the plan prefers FF → merge over PR, since PR may also fail in that state.
+ * Repos without remotes skip protection checks and PR mode entirely.
  *
  * @param batchState - Runtime batch state (orchBranch, baseBranch, counts)
  * @param cwd - Working directory with the git repo
+ * @param protectionOverride - Injectable protection status for testing
  * @returns Integration plan, or null if integration is not possible
  *
  * @since TP-043
+ * @modified TP-149 — Reordered to FF → merge → PR; check remotes first
  */
 export function buildIntegrationPlan(
 	batchState: OrchBatchRuntimeState,
@@ -428,39 +461,21 @@ export function buildIntegrationPlan(
 	const baseBranch = batchState.baseBranch;
 	const batchId = batchState.batchId;
 
-	// Step 1: Check branch protection (injectable for testing)
-	const protection = protectionOverride ?? detectBranchProtection(baseBranch, cwd);
+	// Step 1: Check for remotes — determines if PR mode is even possible (TP-149)
+	const remotes = hasGitRemotes(cwd);
 
-	if (protection === "protected") {
-		return {
-			mode: "pr",
-			orchBranch,
-			baseBranch,
-			batchId,
-			branchProtection: protection,
-			rationale: `Base branch \`${baseBranch}\` is protected — creating a pull request for review.`,
-			succeededTasks: batchState.succeededTasks,
-			failedTasks: batchState.failedTasks,
-		};
-	}
+	// Step 2: Determine protection status
+	// - Override: use as-is (test injection path)
+	// - Remotes exist: detect via gh API
+	// - No remotes: treat as unprotected (can't create PRs anyway)
+	const protection = protectionOverride
+		?? (remotes ? detectBranchProtection(baseBranch, cwd) : "unprotected");
 
-	if (protection === "unknown") {
-		// Safe fallback: when protection status can't be determined
-		// (gh CLI unavailable, no remote, etc.), default to PR mode
-		// to avoid accidentally pushing to a protected branch.
-		return {
-			mode: "pr",
-			orchBranch,
-			baseBranch,
-			batchId,
-			branchProtection: protection,
-			rationale: `Could not detect branch protection for \`${baseBranch}\` — defaulting to PR mode for safety.`,
-			succeededTasks: batchState.succeededTasks,
-			failedTasks: batchState.failedTasks,
-		};
-	}
+	// Step 3: Always try FF first, then merge, then PR (TP-149).
+	// Protected branches may still allow FF/merge via API tokens.
+	// PR is the last resort when direct merge is blocked.
 
-	// Step 2: Check ff-ability (is baseBranch ancestor of orchBranch?)
+	// Step 3a: Try fast-forward first (cleanest, most common)
 	try {
 		execFileSync("git", ["merge-base", "--is-ancestor", baseBranch, orchBranch], {
 			encoding: "utf-8",
@@ -480,7 +495,20 @@ export function buildIntegrationPlan(
 			failedTasks: batchState.failedTasks,
 		};
 	} catch {
-		// Branches have diverged — need merge commit
+		// Branches have diverged — need merge commit or PR
+		// Step 3c: If protected AND remotes exist, prefer PR (merge may be blocked by push protection)
+		if (protection === "protected" && remotes) {
+			return {
+				mode: "pr",
+				orchBranch,
+				baseBranch,
+				batchId,
+				branchProtection: protection,
+				rationale: `Branches diverged and \`${baseBranch}\` is protected — creating a pull request.`,
+				succeededTasks: batchState.succeededTasks,
+				failedTasks: batchState.failedTasks,
+			};
+		}
 		return {
 			mode: "merge",
 			orchBranch,

package/extensions/taskplane/types.ts

@@ -3202,7 +3202,7 @@ export interface TokenCounts {
 export interface BatchTaskSummary {
 	taskId: string;
 	taskName: string;
-	status: "succeeded" | "failed" | "skipped" | "blocked" | "stalled";
+	status: "succeeded" | "failed" | "skipped" | "blocked" | "stalled" | "pending";
 	wave: number;      // 1-based
 	lane: number;      // 1-based
 	durationMs: number;

package/extensions/taskplane/waves.ts

@@ -575,12 +575,20 @@ export function resolveBaseBranch(
 	if (batchBaseBranch.startsWith("orch/") && repoId) {
 		try {
 			const check = runGit(["rev-parse", "--verify", `refs/heads/${batchBaseBranch}`], repoRoot);
-			console.error(`[resolveBaseBranch] repoId=${repoId} batchBaseBranch=${batchBaseBranch} repoRoot=${repoRoot} check.ok=${check.ok}`);
 			if (check.ok) {
 				return batchBaseBranch;
 			}
+			// TP-146: Orch branch exists as batch base but not in this repo.
+			// This means worktrees will branch from the repo's current HEAD
+			// instead of the orch branch, bypassing batch isolation.
+			console.error(
+				`[taskplane] resolveBaseBranch WARNING: orch branch "${batchBaseBranch}" not found in repo "${repoId}" at ${repoRoot} — falling back to repo HEAD. ` +
+				`This bypasses orch branch isolation. Ensure the orch branch was created in all workspace repos.`,
+			);
 		} catch (err) {
-			console.error(`[resolveBaseBranch] repoId=${repoId} batchBaseBranch=${batchBaseBranch} THREW: ${err}`);
+			console.error(
+				`[taskplane] resolveBaseBranch WARNING: orch branch check failed for repo "${repoId}" at ${repoRoot}: ${err}`,
+			);
 		}
 	}
 
@@ -963,6 +971,97 @@ export function assignTasksToLanes(
 }
 
 
+// ── Global Lane Cap (TP-148) ─────────────────────────────────────────
+
+/**
+ * Enforce a global lane cap across all repo groups.
+ *
+ * In workspace mode, each repo independently allocates up to `maxLanes`.
+ * This function reduces the total across all repos to fit within the
+ * global `maxLanes` budget by consolidating lanes in repos with the
+ * most headroom (most lanes relative to their minimum of 1).
+ *
+ * Algorithm:
+ *   1. If total lanes ≤ maxLanes, no-op.
+ *   2. Group lanes by repo, sort repos by lane count descending.
+ *   3. Iteratively remove the last lane from the repo with the most
+ *      lanes, redistributing its tasks to the lightest remaining lane
+ *      in that repo.
+ *   4. Stop when total ≤ maxLanes or all repos are at 1 lane.
+ *   5. Renumber global lanes sequentially.
+ *
+ * Mutates `entries` in place: removes excess entries and renumbers.
+ *
+ * @param entries  - Global lane entries from per-repo allocation
+ * @param maxLanes - Global maximum lane count
+ */
+export function enforceGlobalLaneCap(
+	entries: Array<{
+		globalLane: number;
+		localLane: number;
+		repoId: string | undefined;
+		assignments: LaneAssignment[];
+	}>,
+	maxLanes: number,
+): void {
+	if (entries.length <= maxLanes) return;
+
+	// Group entries by repoId
+	const byRepo = new Map<string, typeof entries>();
+	for (const entry of entries) {
+		const key = entry.repoId ?? "";
+		const group = byRepo.get(key) || [];
+		group.push(entry);
+		byRepo.set(key, group);
+	}
+
+	let excess = entries.length - maxLanes;
+
+	while (excess > 0) {
+		// Find the repo with the most lanes (ties broken by key for determinism)
+		let bestKey = "";
+		let bestCount = 0;
+		for (const [key, group] of byRepo) {
+			if (group.length > bestCount || (group.length === bestCount && key < bestKey)) {
+				bestKey = key;
+				bestCount = group.length;
+			}
+		}
+
+		// All repos at 1 lane — can't reduce further
+		if (bestCount <= 1) break;
+
+		// Remove the last lane from this repo and redistribute its tasks
+		const group = byRepo.get(bestKey)!;
+		const removed = group.pop()!;
+		// Merge into the first lane of the same repo (deterministic target)
+		group[0].assignments.push(...removed.assignments);
+		excess--;
+	}
+
+	// Warn if cap could not be fully enforced (more repos than maxLanes)
+	const finalTotal = [...byRepo.values()].reduce((sum, g) => sum + g.length, 0);
+	if (finalTotal > maxLanes) {
+		console.error(
+			`[taskplane] warning: global maxLanes=${maxLanes} could not be enforced — ` +
+			`${byRepo.size} repos each need at least 1 lane (total: ${finalTotal}). ` +
+			`Increase maxLanes to at least ${byRepo.size} to avoid this.`,
+		);
+	}
+
+	// Rebuild entries array with sequential global lane numbers
+	entries.length = 0;
+	let globalLane = 1;
+	for (const key of [...byRepo.keys()].sort()) {
+		const group = byRepo.get(key)!;
+		for (const entry of group) {
+			entry.globalLane = globalLane++;
+			entries.push(entry);
+		}
+	}
+}
+
+
 /**
  * Result of `allocateLanes()`.
  *
@@ -1188,6 +1287,13 @@ export function allocateLanes(
 		globalLaneOffset += sortedLocalLanes.length;
 	}
 
+	// ── Stage 2b: Enforce global lane cap (TP-148) ─────────────────
+	// In workspace mode, each repo group independently allocates up to
+	// maxLanes. If total lanes across all repos exceeds the global
+	// maxLanes limit, reduce lanes in repos with the most headroom.
+	// Preserves at least 1 lane per repo with tasks.
+	enforceGlobalLaneCap(globalLaneEntries, config.orchestrator.max_lanes);
+
 	const laneCount = globalLaneEntries.length;
 
 	if (laneCount === 0) {

package/extensions/taskplane/worktree.ts

@@ -2266,6 +2266,120 @@ export function preserveFailedLaneProgress(
 }
 
 
+/**
+ * TP-147: Preserve partial progress for all skipped tasks before cleanup/reset.
+ *
+ * Skipped tasks may have worker commits (STATUS.md updates, partial code)
+ * that would be lost when the worktree is cleaned up. This function saves
+ * their lane branches as task-ID-named saved branches, similar to how
+ * preserveFailedLaneProgress works for failed tasks.
+ *
+ * Unlike failed tasks, skipped-task branches are NOT merged (partial work
+ * could break verification). Instead they are preserved for manual recovery.
+ *
+ * @param allocatedLanes - Lanes from the current/last wave
+ * @param taskOutcomes   - All task outcomes accumulated so far
+ * @param opId           - Operator identifier
+ * @param batchId        - Batch ID
+ * @param resolveRepo    - Callback to resolve repo root and target branch per repoId
+ * @returns PreserveFailedLaneProgressResult with per-task results and preserved branch set
+ */
+export function preserveSkippedLaneProgress(
+	allocatedLanes: AllocatedLane[],
+	taskOutcomes: LaneTaskOutcome[],
+	opId: string,
+	batchId: string,
+	resolveRepo: ResolveRepoContext,
+): PreserveFailedLaneProgressResult {
+	const results: SavePartialProgressResult[] = [];
+	const preservedBranches = new Set<string>();
+	const unsafeBranches = new Set<string>();
+
+	// Build a map: taskId → { laneBranch, repoId } from allocated lanes
+	const taskToLane = new Map<string, { branch: string; repoId?: string }>();
+	for (const lane of allocatedLanes) {
+		for (const allocatedTask of lane.tasks) {
+			taskToLane.set(allocatedTask.taskId, {
+				branch: lane.branch,
+				repoId: lane.repoId,
+			});
+		}
+	}
+
+	// Find skipped tasks
+	const skippedTasks = taskOutcomes.filter(
+		(to) => to.status === "skipped",
+	);
+
+	// Track which lane branches we've already processed (a lane may have
+	// multiple tasks; only save once per branch since all commits are shared)
+	const processedBranches = new Set<string>();
+
+	for (const skippedTask of skippedTasks) {
+		const laneInfo = taskToLane.get(skippedTask.taskId);
+		if (!laneInfo) {
+			results.push({
+				saved: false,
+				commitCount: 0,
+				taskId: skippedTask.taskId,
+				error: "Task not found in allocated lanes",
+			});
+			continue;
+		}
+
+		// Skip if we've already processed this branch
+		if (processedBranches.has(laneInfo.branch)) {
+			continue;
+		}
+		processedBranches.add(laneInfo.branch);
+
+		// Resolve repo-specific target branch and repo root
+		const { repoRoot: perRepoRoot, targetBranch } = resolveRepo(laneInfo.repoId);
+
+		const result = savePartialProgress(
+			laneInfo.branch,
+			targetBranch,
+			opId,
+			skippedTask.taskId,
+			batchId,
+			perRepoRoot,
+			laneInfo.repoId,
+		);
+
+		results.push(result);
+
+		if (result.saved) {
+			preservedBranches.add(result.savedBranch!);
+
+			execLog("partial-progress", skippedTask.taskId,
+				`Task ${skippedTask.taskId} was skipped but has ${result.commitCount} commit(s) of partial progress preserved on branch ${result.savedBranch}`,
+				{
+					laneBranch: laneInfo.branch,
+					savedBranch: result.savedBranch,
+					commitCount: result.commitCount,
+					repoId: laneInfo.repoId ?? "(default)",
+				},
+			);
+		} else if (result.commitCount > 0 || result.error) {
+			unsafeBranches.add(laneInfo.branch);
+
+			execLog("partial-progress", skippedTask.taskId,
+				`WARNING: Failed to preserve partial progress for skipped task ${skippedTask.taskId} ` +
+				`(${result.commitCount} commit(s) at risk on branch "${laneInfo.branch}")`,
+				{
+					laneBranch: laneInfo.branch,
+					commitCount: result.commitCount,
+					error: result.error ?? "unknown",
+					repoId: laneInfo.repoId ?? "(default)",
+				},
+			);
+		}
+	}
+
+	return { results, preservedBranches, unsafeBranches };
+}
+
+
 // ── Stale Branch Cleanup (TP-051) ────────────────────────────────────
 
 /**

package/package.json

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

package/templates/agents/supervisor.md

@@ -152,7 +152,7 @@ Use tools **proactively** when the situation calls for it:
 - Operator asks to run tasks or start a batch → call `orch_start(target="all")` (or a specific area)
 - Operator asks "how's it going?" → call `orch_status()` first, then summarize
 - Batch paused due to a failure you diagnosed and fixed → call `orch_resume()`
-- Batch completed successfully → offer to call `orch_integrate(mode="pr")` or the operator's preferred mode
+- Batch completed successfully → offer to call `orch_integrate()` (fast-forward is default and cleanest; use `mode="merge"` if diverged, `mode="pr"` only if remotes exist and branch is protected)
 - Batch is stuck or failing repeatedly → call `orch_status()` to diagnose, then `orch_abort()` if needed
 - Need to investigate before more tasks launch → call `orch_pause()` first
 

package/templates/agents/task-worker.md

@@ -37,6 +37,13 @@ visibility into your progress. If you batch updates, the dashboard shows
 7. If all steps are complete, update STATUS.md **Status** field to `✅ Complete`
    and **Current Step** to the last step name — this is your final action
 
+## CRITICAL: Do NOT Create .DONE Files
+
+**The `.DONE` file is managed by the runtime, not by you.** Never create,
+write, or touch a `.DONE` file. The lane-runner creates it automatically
+when all segments of your task are complete. If you create `.DONE` early,
+it will cause downstream segments to be skipped and deliverables to be lost.
+
 ## CRITICAL: Never Exit Without Updating STATUS.md
 
 **Every turn MUST end with a tool call.** Do NOT produce a text-only response