taskplane 0.24.21 → 0.24.23

package/extensions/taskplane/execution.ts

@@ -1541,6 +1541,7 @@ export async function executeWave(
 	workspaceConfig?: WorkspaceConfig | null,
 	runtimeBackend?: RuntimeBackend,
 	onSupervisorAlert?: SupervisorAlertCallback,
+	supervisorAutonomy: "interactive" | "supervised" | "autonomous" = "autonomous",
 ): Promise<WaveExecutionResult> {
 	const startedAt = Date.now();
 	const policy = config.failure.on_task_failure;
@@ -1642,7 +1643,10 @@ export async function executeWave(
 	}
 
 	const lanePromises = lanes.map(lane =>
-		executeLaneV2(lane, config, repoRoot, wavePauseSignal, wsRoot, isWsMode, { ORCH_BATCH_ID: batchId }, onSupervisorAlert),
+		executeLaneV2(lane, config, repoRoot, wavePauseSignal, wsRoot, isWsMode, {
+			ORCH_BATCH_ID: batchId,
+			TASKPLANE_SUPERVISOR_AUTONOMY: supervisorAutonomy,
+		}, onSupervisorAlert),
 	);
 
 	// Start monitoring as a sibling async loop
@@ -2235,6 +2239,12 @@ export async function executeLaneV2(
 		// Build execution unit
 		const unit = buildExecutionUnit(lane, task, repoRoot, isWorkspaceMode);
 
+		const rawAutonomy = String(extraEnvVars?.TASKPLANE_SUPERVISOR_AUTONOMY ?? "autonomous").toLowerCase();
+		const supervisorAutonomy: LaneRunnerConfig["supervisorAutonomy"] =
+			(rawAutonomy === "interactive" || rawAutonomy === "supervised" || rawAutonomy === "autonomous")
+				? rawAutonomy as LaneRunnerConfig["supervisorAutonomy"]
+				: "autonomous";
+
 		const laneRunnerConfig: LaneRunnerConfig = {
 			batchId,
 			agentIdPrefix,
@@ -2247,6 +2257,7 @@ export async function executeLaneV2(
 			workerTools: "read,write,edit,bash,grep,find,ls",
 			workerThinking: "",
 			workerSystemPrompt,
+			supervisorAutonomy,
 			projectName: config.project?.name || "project",
 			maxIterations: 20,
 			noProgressLimit: 3,

package/extensions/taskplane/extension.ts

@@ -1032,6 +1032,7 @@ export function startBatchInWorker(
 				wkData.agentRoot,
 				wkData.force ?? false,
 				onSupervisorAlert ?? null,
+				wkData.supervisorAutonomy ?? "autonomous",
 			)
 			: () => executeOrchBatch(
 				wkData.args ?? "",
@@ -1046,6 +1047,7 @@ export function startBatchInWorker(
 				wkData.agentRoot,
 				null, // onEngineEvent
 				onSupervisorAlert ?? null,
+				wkData.supervisorAutonomy ?? "autonomous",
 			);
 		startBatchAsync(fallbackFn, batchState, ctx, updateWidget, onTerminal);
 		return null;
@@ -2052,6 +2054,7 @@ export default function (pi: ExtensionAPI) {
 					: null,
 				workspaceRoot: execCtx!.workspaceRoot,
 				agentRoot: execCtx!.pointer?.agentRoot,
+				supervisorAutonomy: supervisorConfig.autonomy,
 			},
 			orchBatchState,
 			ctx,
@@ -2396,6 +2399,7 @@ export default function (pi: ExtensionAPI) {
 				workspaceRoot: execCtx!.workspaceRoot,
 				agentRoot: execCtx!.pointer?.agentRoot,
 				force,
+				supervisorAutonomy: supervisorConfig.autonomy,
 			},
 			orchBatchState,
 			ctx,

package/extensions/taskplane/lane-runner.ts

@@ -92,6 +92,8 @@ export interface LaneRunnerConfig {
 	workerThinking: string;
 	/** Worker system prompt */
 	workerSystemPrompt: string;
+	/** Supervisor autonomy level for bridge-tool guards. */
+	supervisorAutonomy?: "interactive" | "supervised" | "autonomous";
 	/** Project name (for review request context) */
 	projectName?: string;
 	/** Max worker iterations before giving up */
@@ -312,6 +314,9 @@ export async function executeTaskV2(
 				TASKPLANE_REVIEWS_DIR: unit.packet.reviewsDir,
 				TASKPLANE_REVIEWER_STATE_PATH: reviewerStatePath,
 				TASKPLANE_PROJECT_NAME: config.projectName || "project",
+				TASKPLANE_TASK_ID: taskId,
+				TASKPLANE_ACTIVE_SEGMENT_ID: segmentId ?? "",
+				TASKPLANE_SUPERVISOR_AUTONOMY: config.supervisorAutonomy || "autonomous",
 				ORCH_BATCH_ID: config.batchId,
 			},
 		};

package/extensions/taskplane/merge.ts

@@ -611,7 +611,7 @@ export async function spawnMergeAgentV2(
 		packet: null,
 		env: {
 			ORCH_BATCH_ID: bid,
-			// Isolate merge agent from operator's user preferences to prevent
+			// Isolate merge agent from operator's global preferences to prevent
 			// verification test contamination (e.g., stale reviewerModel pref
 			// overriding schema defaults in deep-equal assertions).
 			PI_CODING_AGENT_DIR: join(sidecarRoot, "runtime", bid, "merge-agent-env"),
@@ -1849,6 +1849,12 @@ export async function mergeWave(
 
 		for (const lane of orderedLanes) {
 			for (const allocTask of lane.tasks) {
+				if (!allocTask.task.taskFolder?.trim()) {
+					execLog("merge", `W${waveIndex}`, `skipping task with missing taskFolder (possibly dynamically expanded)`, {
+						taskId: allocTask.taskId,
+					});
+					continue;
+				}
 				const absFolder = resolve(allocTask.task.taskFolder);
 				const relFolder = relative(resolvedRepoRoot, absFolder).replace(/\\/g, "/");
 

package/extensions/taskplane/persistence.ts

@@ -1139,6 +1139,18 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 				);
 			}
 		}
+		if (s.expandedFrom !== undefined && typeof s.expandedFrom !== "string") {
+			throw new StateFileError(
+				"STATE_SCHEMA_INVALID",
+				`segments[${i}].expandedFrom is not a string when present (got ${typeof s.expandedFrom})`,
+			);
+		}
+		if (s.expansionRequestId !== undefined && typeof s.expansionRequestId !== "string") {
+			throw new StateFileError(
+				"STATE_SCHEMA_INVALID",
+				`segments[${i}].expansionRequestId is not a string when present (got ${typeof s.expansionRequestId})`,
+			);
+		}
 		// Optional exitDiagnostic
 		if (s.exitDiagnostic !== undefined) {
 			if (!s.exitDiagnostic || typeof s.exitDiagnostic !== "object" || Array.isArray(s.exitDiagnostic)) {

package/extensions/taskplane/resume.ts

@@ -641,6 +641,84 @@ export function getMergeStatusForWave(
 	return null;
 }
 
+/**
+ * Expand persisted wave plan with continuation rounds required by segment counts.
+ *
+ * Groups missing rounds by the original last-occurrence wave so resumed execution
+ * preserves multi-task round concurrency semantics (`[A,B]`, then `[A]`, etc.).
+ */
+export function buildResumeRuntimeWavePlan(persistedState: PersistedBatchState): string[][] {
+	const baseWavePlan = persistedState.wavePlan.map((wave) => [...wave]);
+	const runtimeWavePlan = [...baseWavePlan];
+	const segmentCountByTaskId = new Map<string, number>();
+	for (const task of persistedState.tasks) {
+		if (Array.isArray(task.segmentIds) && task.segmentIds.length > 0) {
+			segmentCountByTaskId.set(task.taskId, task.segmentIds.length);
+		}
+	}
+
+	const scheduledCountByTaskId = new Map<string, number>();
+	const lastWaveIndexByTaskId = new Map<string, number>();
+	for (let waveIdx = 0; waveIdx < baseWavePlan.length; waveIdx++) {
+		for (const taskId of baseWavePlan[waveIdx]) {
+			scheduledCountByTaskId.set(taskId, (scheduledCountByTaskId.get(taskId) ?? 0) + 1);
+			lastWaveIndexByTaskId.set(taskId, waveIdx);
+		}
+	}
+
+	const missingByLastWaveIndex = new Map<number, Map<string, number>>();
+	for (const [taskId, segmentCount] of segmentCountByTaskId.entries()) {
+		const scheduledCount = scheduledCountByTaskId.get(taskId) ?? 0;
+		if (segmentCount <= scheduledCount) continue;
+		const lastWaveIndex = lastWaveIndexByTaskId.get(taskId) ?? -1;
+		if (!missingByLastWaveIndex.has(lastWaveIndex)) {
+			missingByLastWaveIndex.set(lastWaveIndex, new Map<string, number>());
+		}
+		missingByLastWaveIndex.get(lastWaveIndex)!.set(taskId, segmentCount - scheduledCount);
+	}
+
+	let offset = 0;
+	for (let baseWaveIdx = 0; baseWaveIdx < baseWavePlan.length; baseWaveIdx++) {
+		const missingForWave = missingByLastWaveIndex.get(baseWaveIdx);
+		if (!missingForWave || missingForWave.size === 0) continue;
+		const rounds: string[][] = [];
+		const remaining = new Map(missingForWave);
+		while ([...remaining.values()].some((count) => count > 0)) {
+			const roundTaskIds = [...remaining.entries()]
+				.filter(([, count]) => count > 0)
+				.map(([taskId]) => taskId)
+				.sort((a, b) => a.localeCompare(b));
+			if (roundTaskIds.length === 0) break;
+			rounds.push(roundTaskIds);
+			for (const taskId of roundTaskIds) {
+				remaining.set(taskId, (remaining.get(taskId) ?? 0) - 1);
+			}
+		}
+		if (rounds.length > 0) {
+			runtimeWavePlan.splice(baseWaveIdx + 1 + offset, 0, ...rounds);
+			offset += rounds.length;
+		}
+	}
+
+	const dangling = missingByLastWaveIndex.get(-1);
+	if (dangling && dangling.size > 0) {
+		const remaining = new Map(dangling);
+		while ([...remaining.values()].some((count) => count > 0)) {
+			const roundTaskIds = [...remaining.entries()]
+				.filter(([, count]) => count > 0)
+				.map(([taskId]) => taskId)
+				.sort((a, b) => a.localeCompare(b));
+			if (roundTaskIds.length === 0) break;
+			runtimeWavePlan.push(roundTaskIds);
+			for (const taskId of roundTaskIds) {
+				remaining.set(taskId, (remaining.get(taskId) ?? 0) - 1);
+			}
+		}
+	}
+
+	return runtimeWavePlan;
+}
+
 /**
  * Compute the resume point from reconciled task states and wave plan.
  *
@@ -662,6 +740,7 @@ export function getMergeStatusForWave(
 export function computeResumePoint(
 	persistedState: PersistedBatchState,
 	reconciledTasks: ReconciledTaskState[],
+	wavePlan: string[][] = persistedState.wavePlan,
 ): ResumePoint {
 	// Build lookup: taskId → reconciled state
 	const reconciledMap = new Map<string, ReconciledTaskState>();
@@ -684,8 +763,8 @@ export function computeResumePoint(
 	}
 	const waveSegmentIdByTaskOccurrence = new Map<string, string>();
 	const occurrenceByTaskId = new Map<string, number>();
-	for (let waveIdx = 0; waveIdx < persistedState.wavePlan.length; waveIdx++) {
-		for (const taskId of persistedState.wavePlan[waveIdx]) {
+	for (let waveIdx = 0; waveIdx < wavePlan.length; waveIdx++) {
+		for (const taskId of wavePlan[waveIdx]) {
 			const segmentIds = segmentIdsByTaskId.get(taskId);
 			if (!segmentIds || segmentIds.length === 0) continue;
 			const occurrence = occurrenceByTaskId.get(taskId) ?? 0;
@@ -737,11 +816,11 @@ export function computeResumePoint(
 	// Find resume wave: first wave with any non-completed tasks OR missing/failed merge.
 	// TP-037 (Bug #102): A wave where all tasks are terminal but the merge
 	// hasn't succeeded is flagged for merge retry, not skipped.
-	let resumeWaveIndex = persistedState.wavePlan.length; // default: past end = all done
+	let resumeWaveIndex = wavePlan.length; // default: past end = all done
 	const mergeRetryWaveIndexes: number[] = [];
 
-	for (let i = 0; i < persistedState.wavePlan.length; i++) {
-		const waveTasks = persistedState.wavePlan[i];
+	for (let i = 0; i < wavePlan.length; i++) {
+		const waveTasks = wavePlan[i];
 		const allDone = waveTasks.every((taskId) => {
 			const waveSegmentId = waveSegmentIdByTaskOccurrence.get(`${i}:${taskId}`);
 			if (waveSegmentId && segmentStatusBySegmentId.has(waveSegmentId)) {
@@ -769,7 +848,7 @@ export function computeResumePoint(
 		if (!allDone) {
 			// Only set resumeWaveIndex if not already set by a merge retry
 			// (merge retry at an earlier wave takes precedence)
-			if (resumeWaveIndex === persistedState.wavePlan.length) {
+			if (resumeWaveIndex === wavePlan.length) {
 				resumeWaveIndex = i;
 			}
 			break;
@@ -795,7 +874,7 @@ export function computeResumePoint(
 			if (mergeStatus !== "succeeded") {
 				// Merge missing or failed — flag for retry, don't skip past this wave
 				mergeRetryWaveIndexes.push(i);
-				if (resumeWaveIndex === persistedState.wavePlan.length) {
+				if (resumeWaveIndex === wavePlan.length) {
 					// This is the first wave needing attention — set resume point here
 					resumeWaveIndex = i;
 				}
@@ -805,8 +884,8 @@ export function computeResumePoint(
 
 	// Determine pending tasks: tasks in resume wave and later that need execution
 	const actualPendingTaskIds: string[] = [];
-	for (let i = resumeWaveIndex; i < persistedState.wavePlan.length; i++) {
-		for (const taskId of persistedState.wavePlan[i]) {
+	for (let i = resumeWaveIndex; i < wavePlan.length; i++) {
+		for (const taskId of wavePlan[i]) {
 			const waveSegmentId = waveSegmentIdByTaskOccurrence.get(`${i}:${taskId}`);
 			if (waveSegmentId && segmentStatusBySegmentId.has(waveSegmentId)) {
 				const segmentStatus = segmentStatusBySegmentId.get(waveSegmentId)!;
@@ -985,6 +1064,7 @@ export async function resumeOrchBatch(
 	agentRoot?: string,
 	force: boolean = false,
 	onSupervisorAlert?: import("./types.ts").SupervisorAlertCallback | null,
+	supervisorAutonomy: "interactive" | "supervised" | "autonomous" = "autonomous",
 ): Promise<void> {
 	const repoRoot = cwd;
 	// State files (.pi/batch-state.json, lane-state, etc.) belong in the workspace root,
@@ -1103,11 +1183,12 @@ export async function resumeOrchBatch(
 		});
 	}
 
+	const runtimeWavePlan = buildResumeRuntimeWavePlan(persistedState);
 	// TP-108/112: Runtime V2 backend selection for resumed batches.
 	// MUST be computed before any backend-aware branch (section 3+).
 	const resumeBackend: RuntimeBackend = selectRuntimeBackend(
 		"all",
-		persistedState.wavePlan,
+		runtimeWavePlan,
 		workspaceConfig,
 	).backend;
 	execLog("resume", batchState.batchId, `runtime backend for resumed execution: ${resumeBackend}`);
@@ -1176,7 +1257,7 @@ export async function resumeOrchBatch(
 	}
 
 	// ── 5. Compute resume point ──────────────────────────────────
-	const resumePoint = computeResumePoint(persistedState, reconciledTasks);
+	const resumePoint = computeResumePoint(persistedState, reconciledTasks, runtimeWavePlan);
 	const completedTaskSet = new Set(resumePoint.completedTaskIds);
 	const failedTaskSet = new Set(resumePoint.failedTaskIds);
 	const reconnectTaskSet = new Set(resumePoint.reconnectTaskIds);
@@ -1263,8 +1344,8 @@ export async function resumeOrchBatch(
 	// entered, so they were never counted in blockedTasks.
 	if (persistedBlockedTaskIds.size > 0) {
 		let uncountedBlocked = 0;
-		for (let wi = resumePoint.resumeWaveIndex; wi < persistedState.wavePlan.length; wi++) {
-			for (const taskId of persistedState.wavePlan[wi]) {
+		for (let wi = resumePoint.resumeWaveIndex; wi < runtimeWavePlan.length; wi++) {
+			for (const taskId of runtimeWavePlan[wi]) {
 				if (persistedBlockedTaskIds.has(taskId)) {
 					uncountedBlocked++;
 				}
@@ -1284,6 +1365,8 @@ export async function resumeOrchBatch(
 	// v3: Carry forward resilience and diagnostics from persisted state
 	batchState.resilience = persistedState.resilience;
 	batchState.diagnostics = persistedState.diagnostics;
+	// v4: Carry forward segment records (including dynamically expanded segments)
+	batchState.segments = [...(persistedState.segments ?? [])];
 	// Carry forward unknown fields for roundtrip preservation
 	if (persistedState._extraFields) {
 		batchState._extraFields = persistedState._extraFields;
@@ -1303,6 +1386,28 @@ export async function resumeOrchBatch(
 	const depGraph = buildDependencyGraph(discovery.pending, discovery.completed);
 	batchState.dependencyGraph = depGraph;
 
+	// Rehydrate discovered tasks with persisted segment metadata.
+	// Dynamically expanded segments may reference tasks that have segment-level
+	// fields (segmentIds, activeSegmentId, packetRepoId, packetTaskPath) set
+	// during the prior run. Merge these back into discovered ParsedTask records
+	// so execution can resume with correct segment context.
+	for (const persistedTask of persistedState.tasks) {
+		const parsed = discovery.pending.get(persistedTask.taskId);
+		if (!parsed) continue;
+		if (persistedTask.segmentIds?.length) {
+			parsed.segmentIds = persistedTask.segmentIds;
+		}
+		if (persistedTask.activeSegmentId !== undefined) {
+			parsed.activeSegmentId = persistedTask.activeSegmentId;
+		}
+		if (persistedTask.packetRepoId) {
+			parsed.packetRepoId = persistedTask.packetRepoId;
+		}
+		if (persistedTask.packetTaskPath) {
+			parsed.packetTaskPath = persistedTask.packetTaskPath;
+		}
+	}
+
 
 	// ── 8. Handle alive sessions (reconnect) ─────────────────────
 	// For tasks with alive sessions, we need to wait for them to complete.
@@ -1578,7 +1683,11 @@ export async function resumeOrchBatch(
 
 	// ── 9. Persist state after reconciliation ────────────────────
 	// Track state for persistence
-	const wavePlan = persistedState.wavePlan;
+	const wavePlan = runtimeWavePlan;
+	persistedState.wavePlan = wavePlan;
+	if (batchState.totalWaves < wavePlan.length) {
+		batchState.totalWaves = wavePlan.length;
+	}
 	const allTaskOutcomes: LaneTaskOutcome[] = [];
 
 	// Initialize latestAllocatedLanes from persisted lane records so that
@@ -1658,7 +1767,7 @@ export async function resumeOrchBatch(
 		persistedState.tasks.map((task) => [task.taskId, task.status] as const),
 	);
 
-	for (let waveIdx = resumePoint.resumeWaveIndex; waveIdx < persistedState.wavePlan.length; waveIdx++) {
+	for (let waveIdx = resumePoint.resumeWaveIndex; waveIdx < wavePlan.length; waveIdx++) {
 		// Check pause signal
 		if (batchState.pauseSignal.paused) {
 			batchState.phase = "paused";
@@ -1672,7 +1781,7 @@ export async function resumeOrchBatch(
 
 		// Get wave tasks, filtering out completed/failed/skipped/blocked ones.
 		// Persisted "skipped" tasks are terminal and must never be re-executed.
-		let waveTasks = persistedState.wavePlan[waveIdx].filter(
+		let waveTasks = wavePlan[waveIdx].filter(
 			taskId => !completedTaskSet.has(taskId) &&
 				!failedTaskSet.has(taskId) &&
 				persistedStatusByTaskId.get(taskId) !== "skipped" &&
@@ -1685,7 +1794,7 @@ export async function resumeOrchBatch(
 		// Count only newly blocked tasks (not already persisted) to avoid double-counting.
 		// persistedState.blockedTaskIds were already counted in persistedState.blockedTasks
 		// which initialized batchState.blockedTasks.
-		const blockedInWave = persistedState.wavePlan[waveIdx].filter(
+		const blockedInWave = wavePlan[waveIdx].filter(
 			taskId => batchState.blockedTaskIds.has(taskId) &&
 				!persistedBlockedTaskIds.has(taskId),
 		);
@@ -1701,7 +1810,7 @@ export async function resumeOrchBatch(
 				onNotify(`🔀 Wave ${waveIdx + 1}: retrying merge (tasks already complete, merge was missing/failed)`, "info");
 
 				// Reconstruct lanes for this wave from persisted state
-				const waveTaskIds = new Set(persistedState.wavePlan[waveIdx]);
+				const waveTaskIds = new Set(wavePlan[waveIdx]);
 				const waveLaneRecords = persistedState.lanes.filter(
 					lane => lane.taskIds.some(tid => waveTaskIds.has(tid)),
 				);
@@ -1711,13 +1820,13 @@ export async function resumeOrchBatch(
 				// Crucial for orch_force_merge: tasks intentionally marked "skipped" must
 				// remain skipped here (not failed), otherwise mixed-outcome detection would
 				// trigger again and block the forced merge recovery path.
-				const succeededTaskIds = persistedState.wavePlan[waveIdx].filter(
+				const succeededTaskIds = wavePlan[waveIdx].filter(
 					taskId => completedTaskSet.has(taskId),
 				);
-				const skippedTaskIds = persistedState.wavePlan[waveIdx].filter(
+				const skippedTaskIds = wavePlan[waveIdx].filter(
 					taskId => persistedStatusByTaskId.get(taskId) === "skipped",
 				);
-				const failedTaskIds = persistedState.wavePlan[waveIdx].filter(
+				const failedTaskIds = wavePlan[waveIdx].filter(
 					taskId => {
 						const status = persistedStatusByTaskId.get(taskId);
 						return status === "failed" || status === "stalled";
@@ -1846,7 +1955,7 @@ export async function resumeOrchBatch(
 		}
 
 		onNotify(
-			ORCH_MESSAGES.orchWaveStart(waveIdx + 1, persistedState.wavePlan.length, waveTasks.length, Math.min(waveTasks.length, orchConfig.orchestrator.max_lanes)),
+			ORCH_MESSAGES.orchWaveStart(waveIdx + 1, wavePlan.length, waveTasks.length, Math.min(waveTasks.length, orchConfig.orchestrator.max_lanes)),
 			"info",
 		);
 
@@ -1884,6 +1993,7 @@ export async function resumeOrchBatch(
 			workspaceConfig,
 			resumeBackend,
 			emitAlert,
+			supervisorAutonomy,
 		);
 
 		batchState.waveResults.push(waveResult);