taskplane 0.9.0 → 0.9.2

package/extensions/task-runner.ts

@@ -174,7 +174,7 @@ const DEFAULT_CONFIG: TaskConfig = {
 	standards_overrides: {},
 	task_areas: {},
 	worker: { model: "", tools: "read,write,edit,bash,grep,find,ls", thinking: "off" },
-	reviewer: { model: "openai/gpt-5.3-codex", tools: "read,bash,grep,find,ls", thinking: "on" },
+	reviewer: { model: "", tools: "read,bash,grep,find,ls", thinking: "on" },
 	context: {
 		worker_context_window: 0, warn_percent: 85, kill_percent: 95,
 		max_worker_iterations: 20, max_review_cycles: 2, no_progress_limit: 3,
@@ -633,56 +633,6 @@ function resolveRpcWrapperPath(): string {
 	);
 }
 
-/**
- * Resolve the path to this extension file (task-runner.ts).
- * Used to pass the extension to worker subprocesses so they have access
- * to the review_step tool in orchestrated mode.
- *
- * Resolution strategy:
- *   1. Derive from -e argument that loaded this extension
- *   2. Package root + extensions/task-runner.ts
- *   3. cwd/extensions/task-runner.ts (development fallback)
- *
- * Returns null if the extension path cannot be found (non-fatal — worker
- * runs without review_step tool).
- */
-function resolveExtensionPath(): string | null {
-	const extRelPath = join("extensions", "task-runner.ts");
-
-	// 1. Derive from the -e argument that loaded this file
-	try {
-		const args = process.argv;
-		for (let i = 0; i < args.length - 1; i++) {
-			if (args[i] === "-e" && args[i + 1]?.includes("task-runner")) {
-				const extPath = resolve(args[i + 1]);
-				if (existsSync(extPath)) return extPath;
-			}
-		}
-	} catch { /* ignore argv parsing errors */ }
-
-	// 2. Package root
-	const root = findPackageRoot();
-	if (root) {
-		const p = join(root, extRelPath);
-		if (existsSync(p)) return p;
-	}
-
-	// 3. Development fallback
-	const devPath = join(process.cwd(), extRelPath);
-	if (existsSync(devPath)) return devPath;
-
-	return null;
-}
-
-/**
- * Detect whether this extension instance is running inside a worker subprocess
- * (set via TASK_RUNNER_WORKER_TOOL_MODE env var). When true, the extension only
- * registers the review_step tool — no commands, widgets, or auto-start.
- */
-function isWorkerToolMode(): boolean {
-	return process.env.TASK_RUNNER_WORKER_TOOL_MODE === "1";
-}
-
 /**
  * Load an agent definition with prompt inheritance.
  *
@@ -2080,6 +2030,7 @@ export default function (pi: ExtensionAPI) {
 				"Call review_step at step boundaries based on the task's Review Level (from STATUS.md header).",
 				"Review Level 0: skip all reviews. Level 1: plan review before implementing. Level 2: plan + code review. Level 3: plan + code + test review.",
 				"Skip reviews for Step 0 (Preflight) and the final documentation/delivery step.",
+				"For code reviews: before starting a step, capture the current HEAD commit with `git rev-parse HEAD` and pass it as the `baseline` parameter. This lets the reviewer see only that step's changes.",
 				"On REVISE: read the review file in .reviews/ for detailed feedback, address the issues, commit fixes, then proceed.",
 				"On RETHINK: reconsider your plan approach, adjust, then implement.",
 				"On UNAVAILABLE: reviewer failed — proceed with caution.",
@@ -2090,9 +2041,14 @@ export default function (pi: ExtensionAPI) {
 					[Type.Literal("plan"), Type.Literal("code")],
 					{ description: 'Review type: "plan" or "code"' },
 				),
+				baseline: Type.Optional(Type.String({
+					description: "Git commit SHA to use as the diff baseline for code reviews. " +
+						"Capture HEAD before starting a step and pass it here so the reviewer " +
+						"sees only that step's changes. If omitted, the reviewer sees the full diff against HEAD.",
+				})),
 			}),
 			async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-				const { step: stepNum, type: reviewType } = params;
+				const { step: stepNum, type: reviewType, baseline } = params;
 
 				if (!state.task || !state.config) {
 					return {
@@ -2123,11 +2079,12 @@ export default function (pi: ExtensionAPI) {
 				const requestPath = join(reviewsDir, `request-R${num}.md`);
 				const outputPath = join(reviewsDir, `R${num}-${reviewType}-step${stepNum}.md`);
 
-				// Find step baseline commit for code reviews
-				let stepBaselineCommit: string | undefined;
-				if (reviewType === "code") {
-					stepBaselineCommit = getHeadCommitSha();
-				}
+				// Resolve step baseline commit for code reviews.
+				// The worker should pass the pre-step HEAD SHA as `baseline` so the
+				// reviewer sees only this step's changes (not cumulative diff).
+				// Falls back to undefined (full diff) if baseline is not provided.
+				const stepBaselineCommit: string | undefined =
+					reviewType === "code" ? (baseline || undefined) : undefined;
 
 				// Find step info for the name
 				const stepInfo = task.steps.find(s => s.number === stepNum);
@@ -2143,7 +2100,7 @@ export default function (pi: ExtensionAPI) {
 				const reviewerDef = loadAgentDef(ctx.cwd, "task-reviewer");
 				const reviewerModel = config.reviewer.model
 					|| reviewerDef?.model
-					|| "openai/gpt-5.3-codex";
+					|| (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "anthropic/claude-sonnet-4-20250514");
 				const reviewerPrompt = reviewerDef?.systemPrompt
 					|| "You are a code reviewer. Read the request and write your review to the specified output file.";
 				const systemPrompt = reviewerPrompt + "\n\n" + buildProjectContext(config, task.taskFolder);
@@ -2947,7 +2904,7 @@ export default function (pi: ExtensionAPI) {
 		writeFileSync(requestPath, request);
 
 		const reviewerDef = loadAgentDef(ctx.cwd, "task-reviewer");
-		const reviewerModel = config.reviewer.model || reviewerDef?.model || "openai/gpt-5.3-codex";
+		const reviewerModel = config.reviewer.model || reviewerDef?.model || (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "anthropic/claude-sonnet-4-20250514");
 		const reviewerPrompt = reviewerDef?.systemPrompt || "You are a code reviewer. Read the request and write your review to the specified output file.";
 		const systemPrompt = reviewerPrompt + "\n\n" + buildProjectContext(config, task.taskFolder);
 
@@ -3086,7 +3043,7 @@ export default function (pi: ExtensionAPI) {
 		const reviewModel = config.quality_gate.review_model
 			|| config.reviewer.model
 			|| reviewerDef?.model
-			|| "openai/gpt-5.3-codex";
+			|| (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "anthropic/claude-sonnet-4-20250514");
 
 		const reviewerPrompt = reviewerDef?.systemPrompt
 			|| "You are a quality gate reviewer. Read the review request and write your JSON verdict to the specified file.";

package/extensions/taskplane/extension.ts

@@ -15,6 +15,7 @@ import {
 	computeWaveAssignments,
 	createOrchWidget,
 	deleteBatchState,
+	deleteStaleBranches,
 	detectOrphanSessions,
 	executeLane,
 	executeOrchBatch,
@@ -407,6 +408,10 @@ export function executeIntegration(
 		}
 
 		if (!result.ok) {
+			// TP-052: Include branch protection hint when merge fails
+			const protectionHint = result.stderr.includes("protected") || result.stderr.includes("permission")
+				? `\n\n  💡 If the branch is protected, use --pr to create a pull request.`
+				: "";
 			return {
 				success: false,
 				integratedLocally: false,
@@ -417,7 +422,8 @@ export function executeIntegration(
 					`${result.stderr}\n\n` +
 					`Try:\n` +
 					`  /orch-integrate --merge    Create a merge commit\n` +
-					`  /orch-integrate --pr       Create a pull request instead`,
+					`  /orch-integrate --pr       Create a pull request instead` +
+					protectionHint,
 			};
 		}
 		// Count commits that were applied
@@ -451,6 +457,10 @@ export function executeIntegration(
 		}
 
 		if (!result.ok) {
+			// TP-052: Include branch protection hint when merge fails
+			const mergeProtectionHint = result.stderr.includes("protected") || result.stderr.includes("permission")
+				? `\n\n  💡 If the branch is protected, use --pr to create a pull request.`
+				: "";
 			return {
 				success: false,
 				integratedLocally: false,
@@ -460,7 +470,8 @@ export function executeIntegration(
 					`❌ Merge failed — there may be conflicts.\n` +
 					`${result.stderr}\n\n` +
 					`Resolve conflicts manually, or try:\n` +
-					`  /orch-integrate --pr       Create a pull request instead`,
+					`  /orch-integrate --pr       Create a pull request instead` +
+					mergeProtectionHint,
 			};
 		}
 		return performCleanup(deps, orchBranch, {
@@ -644,7 +655,7 @@ export function collectRepoCleanupFindings(
 		findings.staleWorktrees = wts.map(wt => wt.path);
 	} catch { /* best effort — git worktree list may fail in unusual states */ }
 
-	// 2. Lane branches — task/{opId}-lane-*
+	// 2. Lane branches — task/{opId}-lane-* and saved/task/{opId}-lane-*
 	try {
 		const branchResult = runGit(["branch", "--list", `task/${opId}-lane-*`], repoRoot);
 		if (branchResult.ok && branchResult.stdout.trim()) {
@@ -653,6 +664,15 @@ export function collectRepoCleanupFindings(
 				.map(b => b.replace(/^\*?\s+/, "").trim())
 				.filter(Boolean);
 		}
+		// Also detect saved lane branches (preserved refs from worktree removal)
+		const savedBranchResult = runGit(["branch", "--list", `saved/task/${opId}-lane-*`], repoRoot);
+		if (savedBranchResult.ok && savedBranchResult.stdout.trim()) {
+			const savedBranches = savedBranchResult.stdout
+				.split("\n")
+				.map(b => b.replace(/^\*?\s+/, "").trim())
+				.filter(Boolean);
+			findings.staleLaneBranches.push(...savedBranches);
+		}
 	} catch { /* best effort */ }
 
 	// 3. Orch branch — check if the specific orch branch still exists
@@ -899,7 +919,7 @@ export function startBatchAsync(
  *
  * @since TP-043 R002
  */
-export function buildIntegrationExecutor(repoRoot: string): IntegrationExecutor {
+export function buildIntegrationExecutor(repoRoot: string, opId?: string): IntegrationExecutor {
 	return (mode, context) => {
 		// Ensure we're on the base branch before integrating
 		const currentBranch = getCurrentBranch(repoRoot);
@@ -942,10 +962,22 @@ export function buildIntegrationExecutor(repoRoot: string): IntegrationExecutor
 			},
 		};
 
-		return executeIntegration(mode as IntegrateMode, {
+		const result = executeIntegration(mode as IntegrateMode, {
 			...context,
 			currentBranch: context.baseBranch,
 		}, deps);
+
+		// TP-051: Clean up stale task/* and saved/* branches after successful integration.
+		// This ensures auto-mode integration (supervisor path) gets the same cleanup
+		// as the manual /orch-integrate handler.
+		if (result.success && result.integratedLocally && context.batchId && opId) {
+			try {
+				deleteStaleBranches(repoRoot, opId, context.batchId);
+				dropBatchAutostash(repoRoot, context.batchId);
+			} catch { /* best effort — don't fail integration for cleanup errors */ }
+		}
+
+		return result;
 	};
 }
 
@@ -1512,7 +1544,7 @@ export default function (pi: ExtensionAPI) {
 							orchBatchState,
 							mode,
 							repoRoot,
-							buildIntegrationExecutor(repoRoot),
+							buildIntegrationExecutor(repoRoot, opId),
 							buildCiDeps(repoRoot),
 							sDeps,
 						);
@@ -1858,7 +1890,7 @@ export default function (pi: ExtensionAPI) {
 							orchBatchState,
 							mode,
 							execCtx!.repoRoot,
-							buildIntegrationExecutor(execCtx!.repoRoot),
+							buildIntegrationExecutor(execCtx!.repoRoot, opId),
 							buildCiDeps(execCtx!.repoRoot),
 							sDeps,
 						);
@@ -1893,12 +1925,18 @@ export default function (pi: ExtensionAPI) {
 								`Batch **${orchBatchState.batchId}** completed — ` +
 								`${orchBatchState.succeededTasks}/${orchBatchState.totalTasks} tasks succeeded.\n\n` +
 								`The orch branch \`${orchBatchState.orchBranch}\` is ready to integrate.\n` +
-								`Would you like me to integrate it, or would you prefer to review first?`,
+								`Would you like me to integrate it, or would you prefer to review first?\n\n` +
+								`You can also:\n` +
+								`• Run \`/orch-integrate\` (or \`/orch-integrate --pr\`) to integrate\n` +
+								`• Create new tasks for the next batch\n` +
+								`• Run a health check`,
 						}
 						: {
 							routingState: "no-tasks",
 							contextMessage:
 								`Batch **${orchBatchState.batchId}** ended (${orchBatchState.phase}).\n\n` +
+								`${orchBatchState.succeededTasks} succeeded, ${orchBatchState.failedTasks} failed, ` +
+								`${orchBatchState.skippedTasks} skipped.\n\n` +
 								`What would you like to do next?`,
 						};
 					transitionToRoutingMode(pi, supervisorState, postBatchContext);
@@ -2352,7 +2390,26 @@ export default function (pi: ExtensionAPI) {
 				ctx.ui.notify(notice, "info");
 			}
 
-			// ── Step 2: Pre-integration summary ──────────────────────
+			// ── Step 2a: Branch protection pre-check (TP-052) ───────
+			// When using ff or merge mode (direct push), check if the target
+			// branch has protection rules. If protected, warn and suggest --pr.
+			// Graceful degradation: if gh is unavailable, skip the check.
+			if (parsed.mode !== "pr") {
+				const { detectBranchProtection } = await import("./supervisor.ts");
+				const protectionStatus = detectBranchProtection(baseBranch, repoRoot);
+				if (protectionStatus === "protected") {
+					ctx.ui.notify(
+						`⚠️ Branch \`${baseBranch}\` has branch protection rules enabled.\n` +
+						`Direct merges may be blocked by your repository settings.\n\n` +
+						`Recommended: use \`/orch-integrate --pr\` to create a pull request instead.`,
+						"warning",
+					);
+					// Don't block — proceed with the attempt. The merge will fail
+					// gracefully and show a clear error if protection blocks it.
+				}
+			}
+
+			// ── Step 2b: Pre-integration summary ─────────────────────
 			// Count commits ahead
 			const revListResult = runGit(
 				["rev-list", "--count", `${currentBranch}..${orchBranch}`],
@@ -2469,6 +2526,30 @@ export default function (pi: ExtensionAPI) {
 				dropBatchAutostash(repo.root, batchId);
 			}
 
+			// TP-051: Delete stale task/* and saved/task/* branches from all repos.
+			// These accumulate after each batch and clutter `git branch` output.
+			// Deletes both current-batch branches and orphans from previous batches.
+			const branchCleanupLines: string[] = [];
+			for (const repo of allRepos) {
+				const branchCleanup = deleteStaleBranches(repo.root, opId, batchId);
+				const totalDeleted = branchCleanup.deletedTaskBranches.length + branchCleanup.deletedSavedBranches.length;
+				if (totalDeleted > 0 || branchCleanup.failedDeletes.length > 0) {
+					const label = repo.id === "(default)" ? "" : ` (${repo.id})`;
+					if (branchCleanup.deletedTaskBranches.length > 0) {
+						branchCleanupLines.push(`  🗑️ Deleted ${branchCleanup.deletedTaskBranches.length} task branch(es)${label}`);
+					}
+					if (branchCleanup.deletedSavedBranches.length > 0) {
+						branchCleanupLines.push(`  🗑️ Deleted ${branchCleanup.deletedSavedBranches.length} saved branch(es)${label}`);
+					}
+					if (branchCleanup.failedDeletes.length > 0) {
+						branchCleanupLines.push(`  ⚠️ Failed to delete ${branchCleanup.failedDeletes.length} branch(es)${label}: ${branchCleanup.failedDeletes.join(", ")}`);
+					}
+				}
+			}
+			if (branchCleanupLines.length > 0) {
+				ctx.ui.notify("Branch cleanup:\n" + branchCleanupLines.join("\n"), "info");
+			}
+
 			// Run acceptance checks across all workspace repos.
 			// In PR mode, the orch branch is intentionally preserved for the PR,
 			// so we skip orch branch detection to avoid contradictory output.

package/extensions/taskplane/messages.ts

@@ -51,15 +51,18 @@ export const ORCH_MESSAGES = {
 		}
 		if (orchBranch && succeeded > 0) {
 			lines.push("");
-			lines.push(`   ℹ All work is on orch branch: ${orchBranch}`);
-			lines.push(`   Your ${baseBranch || "working"} branch was not modified.`);
+			lines.push("   ┌─────────────────────────────────────────────────┐");
+			lines.push(`   │  Your changes are on branch: ${orchBranch}`);
+			lines.push(`   │  Your ${baseBranch || "working"} branch was not modified.`);
 			if (baseBranch) {
-				lines.push(`   Preview: git log ${baseBranch}..${orchBranch}`);
+				lines.push(`   │  Preview: git log ${baseBranch}..${orchBranch}`);
 			}
-			lines.push("");
-			lines.push("   To apply the changes:");
-			lines.push("   • /orch-integrate           Apply now (fast-forward, recommended)");
-			lines.push("   • /orch-integrate --pr      Push orch branch & open a PR for team review");
+			lines.push("   │");
+			lines.push("   │  👉 To bring changes into your working branch:");
+			lines.push("   │");
+			lines.push("   │    /orch-integrate        — merge directly (recommended)");
+			lines.push("   │    /orch-integrate --pr   — create a pull request");
+			lines.push("   └─────────────────────────────────────────────────┘");
 		}
 		return lines.join("\n");
 	},

package/extensions/taskplane/persistence.ts

@@ -219,10 +219,14 @@ export function syncTaskOutcomesFromMonitor(
 			const mappedStatus = monitorToLane[snap.status];
 			const terminal = mappedStatus === "succeeded" || mappedStatus === "failed" || mappedStatus === "stalled" || mappedStatus === "skipped";
 
+			// TP-051: Use snap.observedAt (Date.now() from monitor poll) instead of
+			// snap.lastHeartbeat (STATUS.md mtime) for task start time. The mtime
+			// reflects when STATUS.md was last edited, which may be long before
+			// actual execution started (e.g., during task staging).
 			changed = upsertTaskOutcome(outcomes, {
 				taskId: lane.currentTaskId,
 				status: mappedStatus,
-				startTime: existing?.startTime ?? snap.lastHeartbeat ?? snap.observedAt,
+				startTime: existing?.startTime ?? snap.observedAt,
 				endTime: terminal ? (existing?.endTime ?? snap.observedAt) : null,
 				exitReason: existing?.exitReason || (mappedStatus === "running" ? "Task in progress" : (snap.stallReason || "Task reached terminal state")),
 				sessionName: existing?.sessionName || lane.sessionName,

package/extensions/taskplane/supervisor.ts

@@ -2615,15 +2615,19 @@ export async function transitionToRoutingMode(
 	// Keep batchStateRef/orchConfigRef/stateRoot — routing prompt may need them
 	// Keep model override — don't switch models mid-conversation
 
-	// Notify the operator that conversational mode is back
+	// TP-052: Send a prominent conversational message that clearly signals
+	// the supervisor is ready for input. Uses triggerTurn to force an LLM
+	// response, which ensures the pi TUI redraws and shows the input prompt.
 	pi.sendMessage(
 		{
 			customType: "supervisor-routing-transition",
 			content: [{
 				type: "text",
 				text:
-					`🔀 **Supervisor returning to conversational mode.**\n\n` +
-					routingContext.contextMessage,
+					`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n` +
+					`🔀 **Ready for your input.**\n\n` +
+					routingContext.contextMessage +
+					`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
 			}],
 			display: `Supervisor — ${routingContext.routingState}`,
 		},

package/extensions/taskplane/worktree.ts

@@ -2323,3 +2323,127 @@ export function preserveFailedLaneProgress(
 	return { results, preservedBranches, unsafeBranches };
 }
 
+
+// ── Stale Branch Cleanup (TP-051) ────────────────────────────────────
+
+/**
+ * Result of stale branch cleanup after integration.
+ */
+export interface StaleBranchCleanupResult {
+	/** task/* branches deleted */
+	deletedTaskBranches: string[];
+	/** saved/task/* branches deleted */
+	deletedSavedBranches: string[];
+	/** Branches that failed to delete (best-effort) */
+	failedDeletes: string[];
+}
+
+/**
+ * Delete stale task/* and saved/* branches after integration.
+ *
+ * After `/orch-integrate` merges or creates a PR, the lane branches
+ * (`task/{opId}-lane-{N}-{batchId}`) and their saved counterparts
+ * are no longer needed. This function cleans them up.
+ *
+ * Cleanup scope:
+ * 1. **Lane branches:** `task/{opId}-lane-*` (any batch from this operator)
+ * 2. **Saved lane branches:** `saved/task/{opId}-lane-*` (preserved lane refs)
+ * 3. **Partial-progress branches:** `saved/{opId}-*` (per-task partial progress refs)
+ *
+ * Targets all branches matching the operator's prefix, not just the current
+ * batch — this also cleans up orphans from previous batches that were never
+ * cleaned.
+ *
+ * All deletions are best-effort — individual failures are logged but don't
+ * prevent other branches from being cleaned.
+ *
+ * @param repoRoot - Repository root directory
+ * @param opId     - Operator identifier (e.g., "henrylach")
+ * @param batchId  - Current batch ID (for logging context)
+ * @returns Cleanup result with lists of deleted and failed branches
+ */
+export function deleteStaleBranches(
+	repoRoot: string,
+	opId: string,
+	batchId: string,
+): StaleBranchCleanupResult {
+	const deletedTaskBranches: string[] = [];
+	const deletedSavedBranches: string[] = [];
+	const failedDeletes: string[] = [];
+
+	// 1. Delete task/{opId}-lane-* branches
+	const taskBranchResult = runGit(["branch", "--list", `task/${opId}-lane-*`], repoRoot);
+	if (taskBranchResult.ok && taskBranchResult.stdout.trim()) {
+		const branches = taskBranchResult.stdout
+			.split("\n")
+			.map(b => b.replace(/^\*?\s+/, "").trim())
+			.filter(Boolean);
+
+		for (const branch of branches) {
+			const deleted = deleteBranchBestEffort(branch, repoRoot);
+			if (deleted) {
+				deletedTaskBranches.push(branch);
+			} else {
+				failedDeletes.push(branch);
+			}
+		}
+	}
+
+	// 2. Delete saved/task/{opId}-lane-* branches (preserved lane refs)
+	const savedTaskResult = runGit(["branch", "--list", `saved/task/${opId}-lane-*`], repoRoot);
+	if (savedTaskResult.ok && savedTaskResult.stdout.trim()) {
+		const branches = savedTaskResult.stdout
+			.split("\n")
+			.map(b => b.replace(/^\*?\s+/, "").trim())
+			.filter(Boolean);
+
+		for (const branch of branches) {
+			const deleted = deleteBranchBestEffort(branch, repoRoot);
+			if (deleted) {
+				deletedSavedBranches.push(branch);
+			} else {
+				failedDeletes.push(branch);
+			}
+		}
+	}
+
+	// 3. Delete saved/{opId}-*-{batchId} branches (partial-progress refs from this batch)
+	// Pattern: saved/{opId}-{taskId}-{batchId} or saved/{opId}-{repoId}-{taskId}-{batchId}
+	// Only deletes branches ending with the current batchId to avoid removing
+	// partial-progress refs from other batches that the operator may still need.
+	const savedProgressResult = runGit(["branch", "--list", `saved/${opId}-*`], repoRoot);
+	if (savedProgressResult.ok && savedProgressResult.stdout.trim()) {
+		const branches = savedProgressResult.stdout
+			.split("\n")
+			.map(b => b.replace(/^\*?\s+/, "").trim())
+			.filter(Boolean);
+
+		const batchSuffix = `-${batchId}`;
+		for (const branch of branches) {
+			// Avoid double-deleting saved/task/* already handled above
+			if (branch.startsWith("saved/task/")) continue;
+			// Only delete partial-progress refs from the current batch
+			if (!branch.endsWith(batchSuffix)) continue;
+			const deleted = deleteBranchBestEffort(branch, repoRoot);
+			if (deleted) {
+				deletedSavedBranches.push(branch);
+			} else {
+				failedDeletes.push(branch);
+			}
+		}
+	}
+
+	const totalDeleted = deletedTaskBranches.length + deletedSavedBranches.length;
+	if (totalDeleted > 0) {
+		execLog("cleanup", "branches", `deleted ${totalDeleted} stale branch(es) for batch ${batchId}`, {
+			taskBranches: deletedTaskBranches.length,
+			savedBranches: deletedSavedBranches.length,
+			failed: failedDeletes.length,
+		});
+	}
+
+	return { deletedTaskBranches, deletedSavedBranches, failedDeletes };
+}
+
+
+

package/package.json

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

package/templates/agents/task-worker.md

@@ -187,11 +187,12 @@ value.
 **Example flow for a Review Level 2 task, Step 3:**
 1. Read Step 3 requirements
 2. Call `review_step(step=3, type="plan")` → get plan feedback
-3. Implement Step 3
-4. Commit changes
-5. Call `review_step(step=3, type="code")` → get code feedback
-6. If REVISE: fix issues, commit again
-7. Move to Step 4
+3. Capture baseline: run `git rev-parse HEAD` and save the SHA
+4. Implement Step 3
+5. Commit changes
+6. Call `review_step(step=3, type="code", baseline="<saved SHA>")` → get code feedback
+7. If REVISE: fix issues, commit again
+8. Move to Step 4
 
 If the `review_step` tool is not available (e.g., non-orchestrated mode), skip
 this protocol entirely — the task-runner handles reviews externally.