taskplane 0.22.1 → 0.22.2

package/extensions/taskplane/engine.ts

@@ -1510,6 +1510,9 @@ export async function executeOrchBatch(
 						failedLane: mixedOutcomeLanes[0].laneNumber,
 						failureReason,
 					};
+					// Update the already-pushed references so persisted state reflects "partial"
+					allMergeResults[allMergeResults.length - 1] = mergeResult;
+					batchState.mergeResults[batchState.mergeResults.length - 1] = mergeResult;
 				}
 
 				// Emit overall merge result notification
@@ -1567,6 +1570,10 @@ export async function executeOrchBatch(
 						`Automatic partial-branch merge is disabled to avoid dropping succeeded commits.`,
 					totalDurationMs: 0,
 				};
+				// Keep mergeResults in sync even when no mergeable lane exists.
+				// Downstream retry/update paths assume the current wave has an entry.
+				allMergeResults.push(mergeResult);
+				batchState.mergeResults.push(mergeResult);
 				onNotify(
 					ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane, mergeResult.failureReason || "unknown"),
 					"error",

package/extensions/taskplane/extension.ts

@@ -15,16 +15,16 @@ import { ORCH_MESSAGES, computeIntegrateCleanupResult } from "./messages.ts";
 import type { IntegrateCleanupRepoFindings } from "./messages.ts";
 import { computeWaveAssignments } from "./waves.ts";
 import { createOrchWidget, formatDependencyGraph, formatWavePlan } from "./formatting.ts";
-import { deleteBatchState, loadBatchState, detectOrphanSessions, parseOrchSessionNames } from "./persistence.ts";
+import { deleteBatchState, loadBatchState, saveBatchState, detectOrphanSessions, parseOrchSessionNames } from "./persistence.ts";
 import { deleteStaleBranches, listWorktrees, resolveWorktreeBasePath, formatPreflightResults, runPreflight } from "./worktree.ts";
-import { executeLane } from "./execution.ts";
+import { computeTransitiveDependents, executeLane } from "./execution.ts";
 import { executeOrchBatch } from "./engine.ts";
 import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
 import { formatOrchSessions, listOrchSessions } from "./sessions.ts";
 import { getCurrentBranch, runGit } from "./git.ts";
 import { hasConfigFiles, resolveConfigRoot, loadOrchestratorConfig, loadSupervisorConfig, loadTaskRunnerConfig } from "./config.ts";
 import { resolveOperatorId } from "./naming.ts";
-import { resumeOrchBatch } from "./resume.ts";
+import { reconstructAllocatedLanes, resumeOrchBatch } from "./resume.ts";
 import { buildExecutionContext } from "./workspace.ts";
 import { openSettingsTui } from "./settings-tui.ts";
 import { loadProjectConfig } from "./config-loader.ts";
@@ -970,6 +970,7 @@ export function startBatchInWorker(
 				wkData.workspaceRoot,
 				wkData.agentRoot,
 				wkData.force ?? false,
+				onSupervisorAlert ?? null,
 			)
 			: () => executeOrchBatch(
 				wkData.args ?? "",
@@ -982,6 +983,8 @@ export function startBatchInWorker(
 				wsConfig,
 				wkData.workspaceRoot,
 				wkData.agentRoot,
+				null, // onEngineEvent
+				onSupervisorAlert ?? null,
 			);
 		startBatchAsync(fallbackFn, batchState, ctx, updateWidget, onTerminal);
 		return null;
@@ -2330,6 +2333,449 @@ export default function (pi: ExtensionAPI) {
 		return messages.join("\n");
 	}
 
+	// ── TP-077: Supervisor Recovery Tools ────────────────────────────
+
+	/**
+	 * Core logic for orch_retry_task. Resets a failed task to pending for re-execution.
+	 *
+	 * Modifies persisted batch state on disk and updates in-memory state.
+	 * The engine picks up the state change on its next poll cycle.
+	 */
+	function doOrchRetryTask(taskId: string, ctx: ExtensionContext): string {
+		// TP-077 R001-1: Reject while engine is actively running (no IPC retry path)
+		const activePhases = new Set(["launching", "executing", "merging", "planning"]);
+		if (activePhases.has(orchBatchState.phase)) {
+			return `❌ Cannot retry task while batch is ${orchBatchState.phase}. Pause or wait for the current operation to finish first.`;
+		}
+
+		const stateRoot = execCtx?.workspaceRoot ?? execCtx?.repoRoot ?? ctx.cwd;
+
+		// Load persisted state
+		let state: PersistedBatchState | null = null;
+		try {
+			state = loadBatchState(stateRoot);
+		} catch (err) {
+			return `❌ Failed to load batch state: ${err instanceof Error ? err.message : String(err)}`;
+		}
+
+		if (!state) {
+			return "❌ No batch state found. There is no active or recent batch to modify.";
+		}
+
+		// Find the task
+		const taskRecord = state.tasks.find(t => t.taskId === taskId);
+		if (!taskRecord) {
+			const knownIds = state.tasks.map(t => t.taskId).join(", ");
+			return `❌ Task "${taskId}" not found in batch ${state.batchId}.\nKnown tasks: ${knownIds || "(none)"}`;
+		}
+
+		// Validate: only failed or stalled tasks can be retried
+		if (taskRecord.status !== "failed" && taskRecord.status !== "stalled") {
+			return `❌ Cannot retry task "${taskId}" — current status is "${taskRecord.status}". Only failed or stalled tasks can be retried.`;
+		}
+
+		const prevStatus = taskRecord.status;
+
+		// Reset task to pending
+		taskRecord.status = "pending";
+		taskRecord.exitReason = "";
+		taskRecord.doneFileFound = false;
+		taskRecord.startedAt = null;
+		taskRecord.endedAt = null;
+		taskRecord.exitDiagnostic = undefined;
+		taskRecord.partialProgressCommits = undefined;
+		taskRecord.partialProgressBranch = undefined;
+
+		// Adjust counters: only decrement failedTasks if the task was in a failure state
+		if (prevStatus === "failed" || prevStatus === "stalled") {
+			state.failedTasks = Math.max(0, state.failedTasks - 1);
+		}
+
+		// Recompute blocked dependents — the retried task is no longer a failure,
+		// so tasks that were blocked solely by it should be unblocked.
+		const remainingFailures = new Set<string>();
+		for (const t of state.tasks) {
+			if (t.status === "failed" || t.status === "stalled") {
+				remainingFailures.add(t.taskId);
+			}
+		}
+		if (orchBatchState.dependencyGraph && orchBatchState.batchId === state.batchId) {
+			const newBlocked = computeTransitiveDependents(remainingFailures, orchBatchState.dependencyGraph);
+			state.blockedTaskIds = [...newBlocked].sort();
+			state.blockedTasks = newBlocked.size;
+		} else if (remainingFailures.size === 0) {
+			state.blockedTaskIds = [];
+			state.blockedTasks = 0;
+		}
+
+		// TP-077 R001-3: Phase transition — terminal "failed" → "stopped" (resumable with force)
+		// "stopped" and "paused" are kept as-is (already resumable).
+		if (state.phase === "failed") {
+			state.phase = "stopped";
+		}
+
+		// Update timestamp
+		state.updatedAt = Date.now();
+
+		// Persist
+		try {
+			saveBatchState(JSON.stringify(state, null, 2), stateRoot);
+		} catch (err) {
+			return `❌ Failed to persist state after retry: ${err instanceof Error ? err.message : String(err)}`;
+		}
+
+		// Sync in-memory state if batch IDs match
+		if (orchBatchState.batchId === state.batchId) {
+			orchBatchState.failedTasks = state.failedTasks;
+			orchBatchState.blockedTasks = state.blockedTasks;
+			orchBatchState.blockedTaskIds = new Set(state.blockedTaskIds);
+			if (state.phase === "stopped" && orchBatchState.phase === "failed") {
+				orchBatchState.phase = "stopped";
+			}
+		}
+
+		updateOrchWidget();
+
+		const resumeHint = state.phase === "stopped"
+			? "Use orch_resume(force=true) to re-execute the batch."
+			: "Use orch_resume() to re-execute the batch.";
+		return `✅ Task "${taskId}" reset to pending for re-execution.\n` +
+			`   Previous status: ${prevStatus}\n` +
+			`   Batch phase: ${state.phase} | Failed: ${state.failedTasks}/${state.totalTasks}\n` +
+			`   ${resumeHint}`;
+	}
+
+	/**
+	 * Core logic for orch_skip_task. Marks a task as skipped and unblocks dependents.
+	 *
+	 * Modifies persisted batch state on disk and updates in-memory state.
+	 * The engine picks up the state change on its next poll cycle.
+	 */
+	function doOrchSkipTask(taskId: string, ctx: ExtensionContext): string {
+		// TP-077 R001-1: Reject while engine is actively running (no IPC skip path)
+		const activePhases = new Set(["launching", "executing", "merging", "planning"]);
+		if (activePhases.has(orchBatchState.phase)) {
+			return `❌ Cannot skip task while batch is ${orchBatchState.phase}. Pause or wait for the current operation to finish first.`;
+		}
+
+		const stateRoot = execCtx?.workspaceRoot ?? execCtx?.repoRoot ?? ctx.cwd;
+
+		// Load persisted state
+		let state: PersistedBatchState | null = null;
+		try {
+			state = loadBatchState(stateRoot);
+		} catch (err) {
+			return `❌ Failed to load batch state: ${err instanceof Error ? err.message : String(err)}`;
+		}
+
+		if (!state) {
+			return "❌ No batch state found. There is no active or recent batch to modify.";
+		}
+
+		// Find the task
+		const taskRecord = state.tasks.find(t => t.taskId === taskId);
+		if (!taskRecord) {
+			const knownIds = state.tasks.map(t => t.taskId).join(", ");
+			return `❌ Task "${taskId}" not found in batch ${state.batchId}.\nKnown tasks: ${knownIds || "(none)"}`;
+		}
+
+		// Validate: only failed, stalled, or pending tasks can be skipped
+		if (taskRecord.status !== "failed" && taskRecord.status !== "stalled" && taskRecord.status !== "pending") {
+			return `❌ Cannot skip task "${taskId}" — current status is "${taskRecord.status}". Only failed, stalled, or pending tasks can be skipped.`;
+		}
+
+		const prevStatus = taskRecord.status;
+		const wasFailed = prevStatus === "failed" || prevStatus === "stalled";
+
+		// Mark as skipped
+		taskRecord.status = "skipped";
+		taskRecord.exitReason = "Skipped by supervisor";
+		taskRecord.endedAt = Date.now();
+
+		// Adjust counters
+		state.skippedTasks = (state.skippedTasks ?? 0) + 1;
+		if (wasFailed) {
+			state.failedTasks = Math.max(0, state.failedTasks - 1);
+		}
+
+		// Unblock dependents: recompute which tasks should remain blocked.
+		// After skipping this task, collect the set of remaining failures to
+		// recompute transitive blocked set from the dependency graph.
+		const prevBlocked = new Set(state.blockedTaskIds ?? []);
+		const unblockedTasks: string[] = [];
+
+		const remainingFailures = new Set<string>();
+		for (const t of state.tasks) {
+			if ((t.status === "failed" || t.status === "stalled") && t.taskId !== taskId) {
+				remainingFailures.add(t.taskId);
+			}
+		}
+
+		// Use in-memory dependency graph if available (batch IDs must match)
+		if (orchBatchState.dependencyGraph && orchBatchState.batchId === state.batchId) {
+			const newBlocked = computeTransitiveDependents(remainingFailures, orchBatchState.dependencyGraph);
+
+			// Find tasks that were blocked but are now unblocked
+			for (const id of prevBlocked) {
+				if (!newBlocked.has(id)) {
+					unblockedTasks.push(id);
+				}
+			}
+
+			state.blockedTaskIds = [...newBlocked].sort();
+			state.blockedTasks = newBlocked.size;
+		} else {
+			// No dependency graph available — conservatively remove the skipped
+			// task from blocked list and let the engine re-evaluate on resume.
+			prevBlocked.delete(taskId);
+			state.blockedTaskIds = [...prevBlocked];
+			state.blockedTasks = prevBlocked.size;
+		}
+
+		// TP-077 R001-3: Phase transition — "failed" → "stopped" (resumable with force)
+		if (state.phase === "failed") {
+			state.phase = "stopped";
+		}
+
+		// Update timestamp
+		state.updatedAt = Date.now();
+
+		// Persist
+		try {
+			saveBatchState(JSON.stringify(state, null, 2), stateRoot);
+		} catch (err) {
+			return `❌ Failed to persist state after skip: ${err instanceof Error ? err.message : String(err)}`;
+		}
+
+		// Sync in-memory state if batch IDs match
+		if (orchBatchState.batchId === state.batchId) {
+			orchBatchState.failedTasks = state.failedTasks;
+			orchBatchState.skippedTasks = state.skippedTasks;
+			orchBatchState.blockedTasks = state.blockedTasks;
+			orchBatchState.blockedTaskIds = new Set(state.blockedTaskIds);
+			if (state.phase === "stopped" && orchBatchState.phase === "failed") {
+				orchBatchState.phase = "stopped";
+			}
+		}
+
+		updateOrchWidget();
+
+		const lines = [
+			`✅ Task "${taskId}" marked as skipped.`,
+			`   Previous status: ${prevStatus}`,
+			`   Batch phase: ${state.phase} | Failed: ${state.failedTasks}, Skipped: ${state.skippedTasks}, Blocked: ${state.blockedTasks} / ${state.totalTasks} total`,
+		];
+
+		if (unblockedTasks.length > 0) {
+			lines.push(`   Unblocked tasks: ${unblockedTasks.join(", ")}`);
+		}
+
+		lines.push("   The engine will re-evaluate dependent tasks on next resume cycle.");
+
+		return lines.join("\n");
+	}
+
+	// ── TP-078: Force Merge Tool ─────────────────────────────────────
+
+	/**
+	 * Core logic for orch_force_merge. Unblocks mixed-outcome merge failures by
+	 * skipping failed tasks, clearing the failed merge entry, and pausing so
+	 * resume re-attempts the real merge.
+	 *
+	 * This is the supervisor's escape hatch when a wave merge was rejected because
+	 * some lanes had both succeeded and failed tasks (mixed-outcome). The tool:
+	 * 1. Validates the batch is paused/stopped/failed and the wave merge status is "partial"
+	 * 2. Verifies the partial failure is specifically the mixed-outcome rejection
+	 * 3. If skipFailed=true, marks failed/stalled tasks in the wave as "skipped"
+	 * 4. Clears the failed merge entry and sets phase to "paused"
+	 * 5. `orch_resume()` re-runs the merge using real git merge logic
+	 */
+	function doOrchForceMerge(waveIndex: number | undefined, skipFailed: boolean, ctx: ExtensionContext): string {
+		// Reject while engine is actively running
+		const activePhases = new Set(["launching", "executing", "merging", "planning"]);
+		if (activePhases.has(orchBatchState.phase)) {
+			return `❌ Cannot force merge while batch is ${orchBatchState.phase}. Pause or wait for the current operation to finish first.`;
+		}
+
+		const stateRoot = execCtx?.workspaceRoot ?? execCtx?.repoRoot ?? ctx.cwd;
+
+		// Load persisted state
+		let state: PersistedBatchState | null = null;
+		try {
+			state = loadBatchState(stateRoot);
+		} catch (err) {
+			return `❌ Failed to load batch state: ${err instanceof Error ? err.message : String(err)}`;
+		}
+
+		if (!state) {
+			return "❌ No batch state found. There is no active or recent batch to modify.";
+		}
+
+		// Force-merge is a recovery action for non-running failed/paused batches.
+		const resumablePhases = new Set(["paused", "stopped", "failed"]);
+		if (!resumablePhases.has(state.phase)) {
+			return `❌ Cannot force merge when batch phase is "${state.phase}". ` +
+				`Force merge is only valid for paused/stopped/failed batches.`;
+		}
+
+		// Determine target wave index (0-based). Default to currentWaveIndex.
+		const targetWave = waveIndex ?? state.currentWaveIndex;
+
+		// Validate wave index
+		if (targetWave < 0 || targetWave >= state.totalWaves) {
+			return `❌ Invalid wave index ${targetWave}. Batch has ${state.totalWaves} wave(s) (0-based: 0..${state.totalWaves - 1}).`;
+		}
+
+		// Find the merge result for the target wave
+		// Walk in reverse to find the latest entry for this wave
+		let mergeResultIdx = -1;
+		for (let i = state.mergeResults.length - 1; i >= 0; i--) {
+			if (state.mergeResults[i].waveIndex === targetWave) {
+				mergeResultIdx = i;
+				break;
+			}
+		}
+
+		// Validate: there must be a merge failure (partial or failed) for this wave
+		if (mergeResultIdx === -1) {
+			return `❌ No merge result found for wave ${targetWave}. Force merge is only needed when a merge failed or was rejected due to mixed-outcome lanes.`;
+		}
+
+		const mergeEntry = state.mergeResults[mergeResultIdx];
+		if (mergeEntry.status === "succeeded") {
+			return `✅ Wave ${targetWave} merge already succeeded. No force merge needed.`;
+		}
+
+		// Only allow force merge for mixed-outcome failures (partial status).
+		// Other failures (conflicts, build failures, repo divergence) need different resolution.
+		if (mergeEntry.status !== "partial") {
+			return `❌ Wave ${targetWave} merge failed with status "${mergeEntry.status}": ${mergeEntry.failureReason || "unknown reason"}.\n` +
+				`Force merge only applies to mixed-outcome lanes (partial). This failure needs manual resolution.`;
+		}
+
+		const failureReason = mergeEntry.failureReason || "";
+		const failureReasonLower = failureReason.toLowerCase();
+		const isMixedOutcomePartial =
+			failureReasonLower.includes("both succeeded and failed tasks") ||
+			failureReasonLower.includes("mixed-outcome") ||
+			failureReasonLower.includes("automatic partial-branch merge is disabled");
+		if (!isMixedOutcomePartial) {
+			return `❌ Wave ${targetWave} has partial merge status, but the failure reason does not match mixed-outcome lanes.\n` +
+				`Reason: ${failureReason || "unknown"}\n` +
+				`Force merge is only valid for the mixed-outcome lane guard. Resolve this merge failure manually.`;
+		}
+
+		// Collect tasks in the target wave
+		const waveTasks = state.wavePlan[targetWave] ?? [];
+		const failedInWave: string[] = [];
+		const succeededInWave: string[] = [];
+
+		for (const taskId of waveTasks) {
+			const task = state.tasks.find(t => t.taskId === taskId);
+			if (!task) continue;
+			if (task.status === "failed" || task.status === "stalled") {
+				failedInWave.push(taskId);
+			} else if (task.status === "succeeded") {
+				succeededInWave.push(taskId);
+			}
+		}
+
+		if (succeededInWave.length === 0) {
+			return `❌ No succeeded tasks in wave ${targetWave}. Force merge requires at least one succeeded task whose commits can be merged.`;
+		}
+
+		// If skipFailed is true, mark failed/stalled tasks as skipped
+		const skippedTasks: string[] = [];
+		if (skipFailed && failedInWave.length > 0) {
+			for (const taskId of failedInWave) {
+				const task = state.tasks.find(t => t.taskId === taskId);
+				if (!task) continue;
+				const prevStatus = task.status;
+				task.status = "skipped";
+				task.exitReason = "Skipped by orch_force_merge";
+				task.endedAt = Date.now();
+				skippedTasks.push(taskId);
+
+				// Adjust counters
+				if (prevStatus === "failed" || prevStatus === "stalled") {
+					state.failedTasks = Math.max(0, state.failedTasks - 1);
+				}
+				state.skippedTasks = (state.skippedTasks ?? 0) + 1;
+			}
+
+			// Recompute blocked tasks if dependency graph is available
+			const remainingFailures = new Set<string>();
+			for (const t of state.tasks) {
+				if ((t.status === "failed" || t.status === "stalled")) {
+					remainingFailures.add(t.taskId);
+				}
+			}
+
+			if (orchBatchState.dependencyGraph && orchBatchState.batchId === state.batchId) {
+				const newBlocked = computeTransitiveDependents(remainingFailures, orchBatchState.dependencyGraph);
+				state.blockedTaskIds = [...newBlocked].sort();
+				state.blockedTasks = newBlocked.size;
+			} else if (remainingFailures.size === 0) {
+				// No remaining failures — clear all blocked state
+				state.blockedTaskIds = [];
+				state.blockedTasks = 0;
+			}
+		} else if (!skipFailed && failedInWave.length > 0) {
+			return `❌ Wave ${targetWave} has ${failedInWave.length} failed task(s): ${failedInWave.join(", ")}.\n` +
+				`Use skipFailed=true to skip them, or use orch_skip_task to skip them individually first.`;
+		}
+
+		// Clear the failed merge result so resume will re-attempt the merge.
+		// With failed tasks now skipped, the merge should succeed (no mixed outcomes).
+		state.mergeResults.splice(mergeResultIdx, 1);
+
+		// Phase transition to "paused" so orch_resume will re-run the merge phase.
+		// "paused" is the standard resumable state (not "stopped" which needs force).
+		state.phase = "paused";
+
+		// Clear merge-related errors
+		state.errors = state.errors.filter(e => !e.includes("mixed") && !e.includes("merge") && !e.includes("Merge"));
+		state.lastError = null;
+
+		// Update timestamp
+		state.updatedAt = Date.now();
+
+		// Persist
+		try {
+			saveBatchState(JSON.stringify(state, null, 2), stateRoot);
+		} catch (err) {
+			return `❌ Failed to persist state after force merge: ${err instanceof Error ? err.message : String(err)}`;
+		}
+
+		// Sync in-memory state if batch IDs match
+		if (orchBatchState.batchId === state.batchId) {
+			orchBatchState.failedTasks = state.failedTasks;
+			orchBatchState.skippedTasks = state.skippedTasks ?? 0;
+			orchBatchState.blockedTasks = state.blockedTasks;
+			orchBatchState.blockedTaskIds = new Set(state.blockedTaskIds);
+			orchBatchState.phase = "paused";
+		}
+
+		updateOrchWidget();
+
+		const lines = [
+			`✅ Force merge prepared for wave ${targetWave}.`,
+			`   Failed merge result cleared — resume will re-attempt the merge.`,
+			`   Succeeded tasks: ${succeededInWave.join(", ")}`,
+		];
+
+		if (skippedTasks.length > 0) {
+			lines.push(`   Skipped tasks (were failed): ${skippedTasks.join(", ")}`);
+		}
+
+		lines.push(`   Batch phase: paused | Failed: ${state.failedTasks}, Skipped: ${state.skippedTasks ?? 0} / ${state.totalTasks} total`);
+
+		const resumeHint = "Use orch_resume() to re-run the merge with failed tasks skipped.";
+		lines.push(`   ${resumeHint}`);
+
+		return lines.join("\n");
+	}
+
 	/**
 	 * Core logic for orch-integrate. Returns a result message string.
 	 * On error, returns an object with error flag.
@@ -3080,6 +3526,111 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
+	// ── TP-077: Supervisor Recovery Tools ────────────────────────────
+
+	pi.registerTool({
+		name: "orch_retry_task",
+		label: "Retry Failed Task",
+		description:
+			"Retry a specific failed task. Resets the task to pending status so it will " +
+			"be re-executed on the next resume cycle. Only works for tasks with 'failed' status.",
+		promptSnippet: "orch_retry_task(taskId) — retry a specific failed task",
+		promptGuidelines: [
+			"Call orch_retry_task to reset a failed task for re-execution.",
+			"The task must have 'failed' status — running, succeeded, or pending tasks cannot be retried.",
+			"After retrying, use orch_resume(force=true) to re-execute the batch if it's paused.",
+			"Use this when a task failed due to a transient issue (context pressure, API error) that may succeed on retry.",
+		],
+		parameters: Type.Object({
+			taskId: Type.String({
+				description: "Task ID to retry (e.g., 'TP-003')",
+			}),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			try {
+				const result = doOrchRetryTask(params.taskId, ctx);
+				return { content: [{ type: "text" as const, text: result }], details: undefined };
+			} catch (err) {
+				return {
+					content: [{ type: "text" as const, text: `Error retrying task: ${err instanceof Error ? err.message : String(err)}` }],
+					details: undefined,
+				};
+			}
+		},
+	});
+
+	pi.registerTool({
+		name: "orch_skip_task",
+		label: "Skip Task",
+		description:
+			"Skip a failed or pending task and unblock its dependents. " +
+			"The task is marked as 'skipped' and will not be executed. " +
+			"Dependent tasks are unblocked for execution.",
+		promptSnippet: "orch_skip_task(taskId) — skip a task and unblock dependents",
+		promptGuidelines: [
+			"Call orch_skip_task to skip a task and unblock any tasks that depend on it.",
+			"The task must have 'failed' or 'pending' status — running or succeeded tasks cannot be skipped.",
+			"Use this when a task cannot succeed and you want to continue the batch without it.",
+			"Skipping a task removes it from the blocker set, potentially unblocking downstream tasks.",
+			"The engine re-evaluates dependencies on the next resume cycle.",
+		],
+		parameters: Type.Object({
+			taskId: Type.String({
+				description: "Task ID to skip (e.g., 'TP-003')",
+			}),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			try {
+				const result = doOrchSkipTask(params.taskId, ctx);
+				return { content: [{ type: "text" as const, text: result }], details: undefined };
+			} catch (err) {
+				return {
+					content: [{ type: "text" as const, text: `Error skipping task: ${err instanceof Error ? err.message : String(err)}` }],
+					details: undefined,
+				};
+			}
+		},
+	});
+
+	// ── TP-078: Force Merge Tool ─────────────────────────────────────
+
+	pi.registerTool({
+		name: "orch_force_merge",
+		label: "Force Merge Wave",
+		description:
+			"Force merge a wave that was rejected due to mixed-outcome lanes (succeeded and failed tasks " +
+			"on the same lane). Updates the merge result to 'succeeded' so the batch can continue. " +
+			"Optionally skips failed tasks in the wave.",
+		promptSnippet: "orch_force_merge(waveIndex?, skipFailed?) — force merge a wave with mixed results",
+		promptGuidelines: [
+			"Call orch_force_merge when a wave merge was rejected because lanes had both succeeded and failed tasks.",
+			"The batch must be paused, stopped, or failed with a 'partial' merge result for the target wave.",
+			"Set skipFailed=true to automatically skip all failed tasks in the wave (recommended).",
+			"If skipFailed is false and failed tasks exist, you must skip them individually with orch_skip_task first.",
+			"After force merging, use orch_resume(force=true) to continue the batch.",
+			"waveIndex is 0-based. Omit it to target the current wave.",
+		],
+		parameters: Type.Object({
+			waveIndex: Type.Optional(Type.Number({
+				description: "0-based wave index to force merge. Defaults to the current wave.",
+			})),
+			skipFailed: Type.Optional(Type.Boolean({
+				description: "If true, automatically skip all failed tasks in the wave before merging. Defaults to false.",
+			})),
+		}),
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			try {
+				const result = doOrchForceMerge(params.waveIndex, params.skipFailed ?? false, ctx);
+				return { content: [{ type: "text" as const, text: result }], details: undefined };
+			} catch (err) {
+				return {
+					content: [{ type: "text" as const, text: `Error force merging: ${err instanceof Error ? err.message : String(err)}` }],
+					details: undefined,
+				};
+			}
+		},
+	});
+
 	// ── Settings TUI ─────────────────────────────────────────────────
 
 	pi.registerCommand("taskplane-settings", {

package/extensions/taskplane/merge.ts

@@ -1202,6 +1202,7 @@ export async function mergeWave(
 	testingCommands?: Record<string, string>,
 	repoId?: string,
 	healthMonitor?: MergeHealthMonitor | null,
+	forceMixedOutcome?: boolean,
 ): Promise<MergeWaveResult> {
 	const startTime = Date.now();
 	const tmuxPrefix = config.orchestrator.tmux_prefix;
@@ -1221,6 +1222,10 @@ export async function mergeWave(
 	//
 	// This allows succeeded+skipped lanes (e.g., stop-wave skip of remaining tasks)
 	// to merge their committed work, while excluding mixed succeeded+failed lanes.
+	//
+	// TP-078: When forceMixedOutcome is true, lanes with both succeeded and
+	// failed/stalled tasks are also considered mergeable. This allows the
+	// orch_force_merge tool to merge succeeded commits from mixed-outcome lanes.
 	const mergeableLanes = completedLanes.filter(lane => {
 		const outcome = laneOutcomeByNumber.get(lane.laneNumber);
 		if (!outcome) return false;
@@ -1230,6 +1235,11 @@ export async function mergeWave(
 			t => t.status === "failed" || t.status === "stalled",
 		);
 
+		if (forceMixedOutcome) {
+			// In force mode, merge any lane with at least one succeeded task
+			return hasSucceeded;
+		}
+
 		return hasSucceeded && !hasHardFailure;
 	});
 
@@ -2127,6 +2137,7 @@ export async function mergeWaveByRepo(
 	agentRoot?: string,
 	testingCommands?: Record<string, string>,
 	healthMonitor?: MergeHealthMonitor | null,
+	forceMixedOutcome?: boolean,
 ): Promise<MergeWaveResult> {
 	const startTime = Date.now();
 
@@ -2137,6 +2148,7 @@ export async function mergeWaveByRepo(
 	}
 
 	// Filter to mergeable lanes (same criteria as mergeWave).
+	// TP-078: When forceMixedOutcome is true, lanes with mixed outcomes are also included.
 	const mergeableLanes = completedLanes.filter(lane => {
 		const outcome = laneOutcomeByNumber.get(lane.laneNumber);
 		if (!outcome) return false;
@@ -2144,6 +2156,7 @@ export async function mergeWaveByRepo(
 		const hasHardFailure = outcome.tasks.some(
 			t => t.status === "failed" || t.status === "stalled",
 		);
+		if (forceMixedOutcome) return hasSucceeded;
 		return hasSucceeded && !hasHardFailure;
 	});
 
@@ -2184,6 +2197,7 @@ export async function mergeWaveByRepo(
 			testingCommands,
 			undefined, // repoId
 			healthMonitor,
+			forceMixedOutcome,
 		);
 		// Attach empty repoResults for consistent shape
 		return { ...result, repoResults: [] };
@@ -2241,6 +2255,7 @@ export async function mergeWaveByRepo(
 			testingCommands,
 			group.repoId,
 			healthMonitor,
+			forceMixedOutcome,
 		);
 
 		// Accumulate lane results

package/extensions/taskplane/resume.ts

@@ -1377,6 +1377,9 @@ export async function resumeOrchBatch(
 	// For waves where some tasks are already done, we filter them out.
 
 	let preserveWorktreesForResume = false;
+	const persistedStatusByTaskId = new Map(
+		persistedState.tasks.map((task) => [task.taskId, task.status] as const),
+	);
 
 	for (let waveIdx = resumePoint.resumeWaveIndex; waveIdx < persistedState.wavePlan.length; waveIdx++) {
 		// Check pause signal
@@ -1390,10 +1393,12 @@ export async function resumeOrchBatch(
 		batchState.currentWaveIndex = waveIdx;
 		persistRuntimeState("wave-index-change", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
 
-		// Get wave tasks, filtering out completed/failed/blocked ones.
+		// 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(
 			taskId => !completedTaskSet.has(taskId) &&
 				!failedTaskSet.has(taskId) &&
+				persistedStatusByTaskId.get(taskId) !== "skipped" &&
 				!batchState.blockedTaskIds.has(taskId),
 		);
 
@@ -1425,26 +1430,71 @@ export async function resumeOrchBatch(
 				);
 				const mergeRetryLanes = reconstructAllocatedLanes(waveLaneRecords, persistedState.tasks);
 
-				// Build synthetic WaveExecutionResult with succeeded tasks
+				// Build synthetic WaveExecutionResult from persisted terminal task states.
+				// 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(
 					taskId => completedTaskSet.has(taskId),
 				);
-				const syntheticLaneResults: LaneExecutionResult[] = mergeRetryLanes.map(lane => ({
-					laneNumber: lane.laneNumber,
-					laneId: lane.laneId,
-					tasks: lane.tasks.map(t => ({
-						taskId: t.taskId,
-						status: (completedTaskSet.has(t.taskId) ? "succeeded" : "failed") as LaneTaskStatus,
+				const skippedTaskIds = persistedState.wavePlan[waveIdx].filter(
+					taskId => persistedStatusByTaskId.get(taskId) === "skipped",
+				);
+				const failedTaskIds = persistedState.wavePlan[waveIdx].filter(
+					taskId => {
+						const status = persistedStatusByTaskId.get(taskId);
+						return status === "failed" || status === "stalled";
+					},
+				);
+
+				const syntheticLaneResults: LaneExecutionResult[] = mergeRetryLanes.map((lane) => {
+					const laneTasks = lane.tasks.map((t) => {
+						const persistedStatus = persistedStatusByTaskId.get(t.taskId);
+						let status: LaneTaskStatus;
+						if (completedTaskSet.has(t.taskId) || persistedStatus === "succeeded") {
+							status = "succeeded";
+						} else if (persistedStatus === "skipped") {
+							status = "skipped";
+						} else if (persistedStatus === "failed") {
+							status = "failed";
+						} else if (persistedStatus === "stalled") {
+							status = "stalled";
+						} else {
+							status = "failed";
+						}
+
+						return {
+							taskId: t.taskId,
+							status,
+							startTime: Date.now(),
+							endTime: Date.now(),
+							exitReason:
+								status === "succeeded" ? "Task completed (merge retry)"
+									: status === "skipped" ? "Task skipped (merge retry)"
+									: status === "stalled" ? "Task stalled (merge retry)"
+									: "Task failed (merge retry)",
+							sessionName: lane.tmuxSessionName,
+							doneFileFound: status === "succeeded",
+						};
+					});
+
+					const laneHasHardFailure = laneTasks.some(
+						(t) => t.status === "failed" || t.status === "stalled",
+					);
+					const laneHasSucceeded = laneTasks.some((t) => t.status === "succeeded");
+					const overallStatus = laneHasHardFailure
+						? (laneHasSucceeded ? "partial" : "failed")
+						: "succeeded";
+
+					return {
+						laneNumber: lane.laneNumber,
+						laneId: lane.laneId,
+						tasks: laneTasks,
+						overallStatus,
 						startTime: Date.now(),
 						endTime: Date.now(),
-						exitReason: completedTaskSet.has(t.taskId) ? "Task completed (merge retry)" : "Task failed (merge retry)",
-						sessionName: lane.tmuxSessionName,
-						doneFileFound: completedTaskSet.has(t.taskId),
-					})),
-					overallStatus: lane.tasks.every(t => completedTaskSet.has(t.taskId)) ? "succeeded" as const : "partial" as const,
-					startTime: Date.now(),
-					endTime: Date.now(),
-				}));
+					};
+				});
 
 				const syntheticWaveResult: WaveExecutionResult = {
 					waveIndex: waveIdx + 1,
@@ -1453,8 +1503,8 @@ export async function resumeOrchBatch(
 					laneResults: syntheticLaneResults,
 					policyApplied: orchConfig.failure.on_task_failure,
 					stoppedEarly: false,
-					failedTaskIds: [],
-					skippedTaskIds: [],
+					failedTaskIds,
+					skippedTaskIds,
 					succeededTaskIds,
 					blockedTaskIds: [],
 					laneCount: mergeRetryLanes.length,
@@ -1713,6 +1763,8 @@ export async function resumeOrchBatch(
 						`Lane(s) ${mixedIds} contain both succeeded and failed tasks. ` +
 						`Automatic partial-branch merge is disabled to avoid dropping succeeded commits.`;
 					mergeResult = { ...mergeResult, status: "partial", failedLane: mixedOutcomeLanes[0].laneNumber, failureReason };
+					// Update the already-pushed reference so persisted state reflects "partial"
+					batchState.mergeResults[batchState.mergeResults.length - 1] = mergeResult;
 				}
 
 				// TP-032 R006-3: Exclude verification_new_failure lanes from success count
@@ -1752,6 +1804,9 @@ export async function resumeOrchBatch(
 						`Automatic partial-branch merge is disabled to avoid dropping succeeded commits.`,
 					totalDurationMs: 0,
 				};
+				// Keep mergeResults in sync even when no mergeable lane exists.
+				// Downstream retry/update paths assume the current wave has an entry.
+				batchState.mergeResults.push(mergeResult);
 				onNotify(
 					ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane, mergeResult.failureReason || "unknown"),
 					"error",

package/extensions/taskplane/supervisor-primer.md

@@ -739,8 +739,8 @@ When you receive an alert, follow this sequence:
 ### Autonomy Rules for Alert Response
 
 - **Do NOT ask the operator for permission** on routine recovery actions:
-  - Retrying a failed task (`orch_resume(force=true)`)
-  - Skipping dependents of a failed task
+  - Retrying a failed task (`orch_retry_task(taskId)` then `orch_resume(force=true)`)
+  - Skipping a failed task and its dependents (`orch_skip_task(taskId)` then `orch_resume(force=true)`)
   - Reading logs and batch state for diagnosis
   
 - **DO escalate to the operator** for genuinely ambiguous situations:
@@ -758,6 +758,17 @@ You have these orchestrator tools available:
 - `orch_abort(hard?)` — Abort the batch
 - `orch_integrate(mode?, force?)` — Integrate completed batch
 - `orch_start(target)` — Start a new batch
+- `orch_retry_task(taskId)` — Reset a failed/stalled task to pending for re-execution
+- `orch_skip_task(taskId)` — Skip a task and unblock its dependents
+- `orch_force_merge(waveIndex?, skipFailed?)` — Force merge a wave with mixed results (skips failed tasks if skipFailed=true)
+
+**Recovery workflow:**
+1. Diagnose with `orch_status()` and reading logs
+2. Decide: retry (`orch_retry_task`), skip (`orch_skip_task`), or force merge (`orch_force_merge`)
+3. Resume: `orch_resume(force=true)` to continue the batch
+
+**Note:** `orch_retry_task`, `orch_skip_task`, and `orch_force_merge` require the batch to be paused/stopped first.
+If the batch is actively running, call `orch_pause()` first.
 
 Plus general tools: `read`, `write`, `edit`, `bash`, `grep`, `find`, `ls`
 for inspecting files, running git commands, and editing batch state.
@@ -771,6 +782,220 @@ typically requires `orch_resume(force=true)` after checking batch state.
 
 ---
 
+## 13b. Recovery Playbooks (TP-078)
+
+When you receive an alert, follow the playbook for that alert category.
+Each playbook is a **decision tree** — follow the branches based on what
+you observe. Do not skip steps; each observation narrows the diagnosis.
+
+### Playbook A: Task Failure
+
+**Trigger:** `task-failure` alert — a task failed after the engine exhausted
+deterministic recovery (retries, context resets).
+
+```
+TASK FAILED: {taskId}
+│
+├─ 1. Read STATUS.md from the task's worktree
+│     Path: .worktrees/{opId}-{batchId}/lane-{N}/{taskFolder}/STATUS.md
+│
+├─ 2. Check: Did the worker complete all steps?
+│     Look at STATUS.md "Current Step" and checkbox completion
+│     │
+│     ├─ YES (all steps checked, .DONE missing — race condition)
+│     │   → orch_retry_task(taskId)
+│     │   → orch_resume(force=true)
+│     │   → Report: "Task {taskId} appears to have completed but .DONE was
+│     │     not created (likely race condition). Retrying."
+│     │
+│     └─ NO (incomplete steps — genuine failure)
+│         │
+│         ├─ 3. Check exit reason in batch state or STATUS.md
+│         │     Read `.pi/batch-state.json` → tasks[].exitReason
+│         │     │
+│         │     ├─ Context pressure / API error / timeout
+│         │     │   → Transient failure. orch_retry_task(taskId)
+│         │     │   → orch_resume(force=true)
+│         │     │   → Report: "Task {taskId} failed due to {reason}. Retrying."
+│         │     │
+│         │     ├─ Test failure / compile error / logic error
+│         │     │   │
+│         │     │   ├─ 4. Is this the first failure of this task?
+│         │     │   │     Check: has it been retried before?
+│         │     │   │     (Look for exitDiagnostic or retry count in state)
+│         │     │   │     │
+│         │     │   │     ├─ FIRST FAILURE
+│         │     │   │     │   → orch_retry_task(taskId)
+│         │     │   │     │   → orch_resume(force=true)
+│         │     │   │     │   → Report: "Retrying {taskId} — first failure,
+│         │     │   │     │     may succeed with fresh context."
+│         │     │   │     │
+│         │     │   │     ├─ SECOND FAILURE (same error pattern)
+│         │     │   │     │   → orch_retry_task(taskId)
+│         │     │   │     │   → orch_resume(force=true)
+│         │     │   │     │   → Report: "Retrying {taskId} — second attempt.
+│         │     │   │     │     Will escalate if it fails again."
+│         │     │   │     │
+│         │     │   │     └─ THIRD+ FAILURE
+│         │     │   │         → ESCALATE to operator
+│         │     │   │         → Report: "Task {taskId} has failed {N} times.
+│         │     │   │           Error: {exitReason}. Recommend skipping or
+│         │     │   │           manual intervention."
+│         │     │   │         → If autonomous mode: orch_skip_task(taskId)
+│         │     │   │           then orch_resume(force=true)
+│         │     │   │
+│         │     │   └─ (unknown error type)
+│         │     │       → ESCALATE to operator
+│         │     │       → Report: "Task {taskId} failed with unexpected error.
+│         │     │         Recommend investigation before retrying."
+│         │     │
+│         │     └─ No exit reason recorded
+│         │         → orch_retry_task(taskId)
+│         │         → orch_resume(force=true)
+│         │         → Report: "Task {taskId} failed without exit reason
+│         │           (session may have died). Retrying."
+│         │
+│         └─ (STATUS.md not accessible — worktree cleaned up)
+│             → orch_retry_task(taskId)
+│             → orch_resume(force=true)
+│             → Report: "Task {taskId} failed, worktree unavailable.
+│               Retrying with fresh worktree."
+```
+
+### Playbook B: Merge Failure
+
+**Trigger:** `merge-failure` alert — wave merge failed and the batch paused.
+Common cause: mixed-outcome lanes (succeeded + failed tasks on the same lane).
+
+```
+MERGE FAILED: wave {waveIndex}
+│
+├─ 1. Check merge result in batch state
+│     Read `.pi/batch-state.json` → mergeResults[]
+│     Find the entry for the failed wave
+│     │
+│     ├─ Status: "partial" (mixed-outcome lanes)
+│     │   │
+│     │   ├─ 2. Identify failed tasks in the wave
+│     │   │     Read wavePlan[waveIndex] → task IDs
+│     │   │     Check each task's status in tasks[]
+│     │   │
+│     │   ├─ 3. For each failed task, decide: retry or skip?
+│     │   │     │
+│     │   │     ├─ Task has partial progress (commits ahead of base)
+│     │   │     │   → May be worth retrying
+│     │   │     │   → orch_retry_task(taskId) for each
+│     │   │     │   → orch_resume(force=true)
+│     │   │     │
+│     │   │     └─ Task genuinely cannot succeed / already retried
+│     │   │         → Skip it and force merge
+│     │   │         → orch_force_merge(waveIndex, skipFailed=true)
+│     │   │         → orch_resume(force=true)
+│     │   │         → Report: "Force merged wave {N}. Skipped tasks:
+│     │   │           {list}. Succeeded tasks merged: {list}."
+│     │   │
+│     │   └─ 4. SHORTCUT (when diagnosis is clear)
+│     │       If all failed tasks are genuinely failed (not race conditions):
+│     │       → orch_force_merge(waveIndex, skipFailed=true)
+│     │       → orch_resume(force=true)
+│     │       This is the most common recovery path.
+│     │
+│     ├─ Status: "failed" (merge agent failure)
+│     │   │
+│     │   ├─ 2. Check merge result JSON files
+│     │   │     ls .pi/merge-result-w{N}-lane{K}-*.json
+│     │   │     │
+│     │   │     ├─ Result file shows CONFLICT_UNRESOLVED
+│     │   │     │   → ESCALATE to operator
+│     │   │     │   → Report: "Merge conflicts in wave {N} that the merge
+│     │   │     │     agent couldn't resolve. Manual resolution needed."
+│     │   │     │   → Provide conflict file list
+│     │   │     │
+│     │   │     ├─ Result file shows BUILD_FAILURE
+│     │   │     │   → Tests failed after merge. May indicate conflicting changes.
+│     │   │     │   → ESCALATE to operator
+│     │   │     │   → Report: "Tests failed after merging wave {N}.
+│     │   │     │     Changes may be incompatible."
+│     │   │     │
+│     │   │     ├─ No result file (merge agent timed out/died)
+│     │   │     │   → Check if lane branch was actually merged:
+│     │   │     │     git log orch/{orchBranch}..task/{laneBranch}
+│     │   │     │   → If empty (merged): update batch state manually
+│     │   │     │   → If not merged: orch_resume(force=true) to retry
+│     │   │     │
+│     │   │     └─ Result file shows SUCCESS
+│     │   │         → Merge succeeded but engine didn't pick it up
+│     │   │         → Update mergeResults in batch state to "succeeded"
+│     │   │         → orch_resume(force=true)
+│     │   │
+│     │   └─ 3. If all else fails
+│     │       → ESCALATE to operator with full diagnostic
+│     │
+│     └─ (No merge result entry)
+│         → Wave tasks completed but merge was never attempted
+│         → orch_resume(force=true) to trigger merge
+│         → Report: "Merge for wave {N} was not attempted. Resuming."
+```
+
+### Playbook C: Batch Complete
+
+**Trigger:** `batch-complete` alert — all waves finished (with or without failures).
+
+```
+BATCH COMPLETE: {batchId}
+│
+├─ 1. Read batch state summary
+│     Check: succeededTasks, failedTasks, skippedTasks, totalTasks
+│     │
+│     ├─ ALL SUCCEEDED (failedTasks=0, skippedTasks=0)
+│     │   → Report: "✅ Batch complete! All {N} tasks succeeded across
+│     │     {W} waves. Ready to integrate."
+│     │   → Suggest: orch_integrate() to bring changes to working branch
+│     │
+│     ├─ SOME FAILED (failedTasks > 0)
+│     │   │
+│     │   ├─ 2. List failed tasks with reasons
+│     │   │     For each failed task:
+│     │   │       - Task ID and title (from PROMPT.md header)
+│     │   │       - Exit reason (from batch state)
+│     │   │       - Wave and lane info
+│     │   │
+│     │   ├─ 3. Report with context
+│     │   │   → "⚠️ Batch complete with {F} failure(s) out of {N} tasks.
+│     │   │      Succeeded: {S}, Skipped: {K}, Failed: {F}
+│     │   │      Failed tasks: {list with reasons}
+│     │   │      The succeeded work is ready to integrate."
+│     │   │
+│     │   └─ 4. Suggest next steps
+│     │       → "You can integrate the succeeded work now with orch_integrate()
+│     │         and handle the failed tasks separately."
+│     │       → If tasks have partial progress: "Some failed tasks have
+│     │         partial commits that could be preserved."
+│     │
+│     └─ SOME SKIPPED (skippedTasks > 0, failedTasks = 0)
+│         → Report: "✅ Batch complete. {S} succeeded, {K} skipped.
+│           Skipped tasks: {list}. Ready to integrate."
+│         → Suggest: orch_integrate()
+```
+
+### Quick Reference: Recovery Action Matrix
+
+| Alert | Diagnosis | Action | Autonomy |
+|-------|-----------|--------|----------|
+| task-failure | Race condition (.DONE missing) | `orch_retry_task` → `orch_resume` | Automatic |
+| task-failure | Transient error (API, context) | `orch_retry_task` → `orch_resume` | Automatic |
+| task-failure | Genuine error, 1st-2nd attempt | `orch_retry_task` → `orch_resume` | Automatic |
+| task-failure | Genuine error, 3rd+ attempt | Escalate (or `orch_skip_task` in autonomous) | Supervised: escalate |
+| task-failure | Unknown error | Escalate | Always escalate |
+| merge-failure | Mixed-outcome lanes | `orch_force_merge(skipFailed=true)` → `orch_resume` | Automatic |
+| merge-failure | Unresolved conflicts | Escalate | Always escalate |
+| merge-failure | Build failure after merge | Escalate | Always escalate |
+| merge-failure | Agent timeout, no result | `orch_resume(force=true)` to retry | Automatic |
+| batch-complete | All succeeded | Report → suggest `orch_integrate` | Report only |
+| batch-complete | Some failed | Report with failure details | Report only |
+
+---
+
 ## 14. Your Startup Checklist
 
 When you activate at the start of a batch:

package/package.json

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