taskplane 0.24.30 → 0.25.0

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-worker.ts

@@ -16,6 +16,7 @@
  * @module orch/engine-worker
  */
 import type {
+	AllocatedLane,
 	EngineEvent,
 	MonitorState,
 	OrchBatchPhase,
@@ -71,6 +72,8 @@ export interface SerializedBatchState {
 	startedAt: number;
 	endedAt: number | null;
 	errors: string[];
+	/** Active lanes for the current wave (synced so /orch-sessions works). */
+	currentLanes: AllocatedLane[];
 }
 
 /**
@@ -164,6 +167,7 @@ function serializeBatchState(state: OrchBatchRuntimeState): SerializedBatchState
 		startedAt: state.startedAt,
 		endedAt: state.endedAt,
 		errors: [...state.errors],
+		currentLanes: state.currentLanes,
 	};
 }
 
@@ -192,6 +196,7 @@ export function applySerializedState(
 	batchState.startedAt = serialized.startedAt;
 	batchState.endedAt = serialized.endedAt;
 	batchState.errors = [...serialized.errors];
+	batchState.currentLanes = serialized.currentLanes ?? [];
 }
 
 // ── Engine main (runs when launched as a forked child process) ───────

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) {
@@ -2612,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);
 							}
@@ -2915,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) {
@@ -3465,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 ────────────
@@ -3811,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);
@@ -3852,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,
@@ -3859,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,
@@ -3983,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/extension.ts

@@ -4720,7 +4720,39 @@ export default function (pi: ExtensionAPI) {
 			if (!requireExecCtx(ctx)) return;
 
 			try {
-				await openSettingsTui(ctx, execCtx!.workspaceRoot, execCtx!.pointer?.configRoot);
+				// Capture the workspace root for reload consistency — use the same
+				// root the settings TUI writes to, not ctx.cwd which may differ.
+				const reloadCwd = execCtx!.workspaceRoot;
+				await openSettingsTui(ctx, execCtx!.workspaceRoot, execCtx!.pointer?.configRoot, () => {
+					// Reload live config from disk so changes take effect immediately
+					// without requiring a session restart.
+					// Build everything into temporaries first, then commit atomically
+					// so a partial failure doesn't leave mixed-generation state.
+					try {
+						const freshCtx = buildExecutionContext(reloadCwd, loadOrchestratorConfig, loadTaskRunnerConfig);
+						let freshSupervisor: SupervisorConfig;
+						try {
+							freshSupervisor = loadSupervisorConfig(
+								freshCtx.repoRoot,
+								freshCtx.pointer?.configRoot,
+							);
+						} catch {
+							freshSupervisor = { ...DEFAULT_SUPERVISOR_CONFIG };
+						}
+						// Atomic commit — all or nothing
+						execCtx = freshCtx;
+						orchConfig = freshCtx.orchestratorConfig;
+						runnerConfig = freshCtx.taskRunnerConfig;
+						supervisorConfig = freshSupervisor;
+					} catch {
+						// Non-fatal — config was saved to disk but live reload failed.
+						// Existing in-memory config is preserved unchanged.
+						ctx.ui.notify(
+							"⚠️ Saved to disk but live reload failed. Restart to apply.",
+							"warn",
+						);
+					}
+				});
 			} catch (err: any) {
 				ctx.ui.notify(`❌ Failed to load settings: ${err.message}`, "error");
 			}

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`);
 	}