taskplane 0.9.1 → 0.9.2

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.1",
+  "version": "0.9.2",
   "description": "AI agent orchestration for pi — parallel task execution with checkpoint discipline",
   "keywords": [
     "pi-package",