taskplane 0.24.30 → 0.25.0

package/extensions/taskplane/settings-tui.ts

@@ -98,34 +98,36 @@ export const SECTIONS: SectionDef[] = [
 			{ configPath: "orchestrator.orchestrator.worktreeLocation", label: "Worktree Location", control: "toggle", layer: "L1", fieldType: "enum", values: ["sibling", "subdirectory"], description: "Where lane worktree directories are created" },
 			{ configPath: "orchestrator.orchestrator.worktreePrefix", label: "Worktree Prefix", control: "input", layer: "L1", fieldType: "string", description: "Prefix for worktree directory names" },
 			{ configPath: "orchestrator.orchestrator.batchIdFormat", label: "Batch ID Format", control: "toggle", layer: "L1", fieldType: "enum", values: ["timestamp", "sequential"], description: "Batch ID format for logs/branch naming" },
-			// spawn_mode removed from Orchestrator section — Runtime V2 is subprocess-only.
-			// The user-facing spawn mode setting is under Worker (controls /task behavior).
 			{ configPath: "orchestrator.orchestrator.sessionPrefix", label: "Session Prefix", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "sessionPrefix", description: "Prefix for orchestrator session names" },
 			{ configPath: "orchestrator.orchestrator.operatorId", label: "Operator ID", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "operatorId", description: "Operator identifier (empty = auto-detect)" },
 			{ configPath: "orchestrator.orchestrator.integration", label: "Integration", control: "picker", layer: "L1", fieldType: "enum", values: ["manual", "supervised", "auto"], description: "How completed batches are integrated. manual = user runs /orch-integrate. supervised = supervisor proposes plan, asks confirmation. auto = supervisor executes without asking." },
 		],
 	},
 	{
-		name: "Dependencies",
+		name: "Agent: Supervisor",
 		fields: [
-			{ configPath: "orchestrator.dependencies.source", label: "Dep Source", control: "toggle", layer: "L1", fieldType: "enum", values: ["prompt", "agent"], description: "Dependency extraction source" },
-			{ configPath: "orchestrator.dependencies.cache", label: "Dep Cache", control: "toggle", layer: "L1", fieldType: "boolean", values: ["true", "false"], description: "Cache dependency analysis results" },
+			{ configPath: "orchestrator.supervisor.model", label: "Supervisor Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "supervisorModel", description: "Supervisor model (inherit = use session model)" },
+			{ configPath: "orchestrator.supervisor.autonomy", label: "Autonomy Level", control: "picker", layer: "L1", fieldType: "enum", values: ["interactive", "supervised", "autonomous"], description: "Recovery action confirmation behavior" },
 		],
 	},
 	{
-		name: "Assignment",
+		name: "Agent: Worker",
 		fields: [
-			{ configPath: "orchestrator.assignment.strategy", label: "Strategy", control: "toggle", layer: "L1", fieldType: "enum", values: ["affinity-first", "round-robin", "load-balanced"], description: "Lane assignment strategy" },
+			{ configPath: "taskRunner.worker.model", label: "Worker Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "workerModel", description: "Worker model (inherit = use session model)" },
+			{ configPath: "taskRunner.worker.tools", label: "Worker Tools", control: "input", layer: "L1", fieldType: "string", description: "Worker tool allowlist" },
+			{ configPath: "taskRunner.worker.thinking", label: "Worker Thinking", control: "picker", layer: "L1", fieldType: "string", description: "Worker thinking mode" },
 		],
 	},
 	{
-		name: "Pre-Warm",
+		name: "Agent: Reviewer",
 		fields: [
-			{ configPath: "orchestrator.preWarm.autoDetect", label: "Auto-Detect", control: "toggle", layer: "L1", fieldType: "boolean", values: ["true", "false"], description: "Enable automatic pre-warm command detection" },
+			{ configPath: "taskRunner.reviewer.model", label: "Reviewer Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "reviewerModel", description: "Reviewer model (inherit = use session model)" },
+			{ configPath: "taskRunner.reviewer.tools", label: "Reviewer Tools", control: "input", layer: "L1", fieldType: "string", description: "Reviewer tool allowlist" },
+			{ configPath: "taskRunner.reviewer.thinking", label: "Reviewer Thinking", control: "picker", layer: "L1", fieldType: "string", description: "Reviewer thinking mode" },
 		],
 	},
 	{
-		name: "Merge",
+		name: "Agent: Merge",
 		fields: [
 			{ configPath: "orchestrator.merge.model", label: "Merge Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "mergeModel", description: "Merge-agent model (inherit = use session model)" },
 			{ configPath: "orchestrator.merge.tools", label: "Merge Tools", control: "input", layer: "L1", fieldType: "string", description: "Merge-agent tool allowlist" },
@@ -134,6 +136,18 @@ export const SECTIONS: SectionDef[] = [
 			{ configPath: "orchestrator.merge.timeoutMinutes", label: "Merge Timeout (minutes)", control: "input", layer: "L1", fieldType: "number", description: "Max time for merge agent to complete. Increase for large batches (default: 10)" },
 		],
 	},
+	{
+		name: "Context Limits",
+		fields: [
+			{ configPath: "taskRunner.context.workerContextWindow", label: "Context Window", control: "input", layer: "L1", fieldType: "number", description: "Worker context window size" },
+			{ configPath: "taskRunner.context.warnPercent", label: "Warn %", control: "input", layer: "L1", fieldType: "number", description: "Context utilization warn threshold (%)" },
+			{ configPath: "taskRunner.context.killPercent", label: "Kill %", control: "input", layer: "L1", fieldType: "number", description: "Context utilization hard-stop threshold (%)" },
+			{ configPath: "taskRunner.context.maxWorkerIterations", label: "Max Iterations", control: "input", layer: "L1", fieldType: "number", description: "Max worker iterations per step" },
+			{ configPath: "taskRunner.context.maxReviewCycles", label: "Max Review Cycles", control: "input", layer: "L1", fieldType: "number", description: "Max revise loops per review stage" },
+			{ configPath: "taskRunner.context.noProgressLimit", label: "No Progress Limit", control: "input", layer: "L1", fieldType: "number", description: "Max no-progress iterations before failure" },
+			{ configPath: "taskRunner.context.maxWorkerMinutes", label: "Max Worker Min (ctx)", control: "input", layer: "L1", fieldType: "number", optional: true, description: "Per-worker wall-clock cap (minutes, empty = no cap)" },
+		],
+	},
 	{
 		name: "Failure Policy",
 		fields: [
@@ -145,46 +159,28 @@ export const SECTIONS: SectionDef[] = [
 		],
 	},
 	{
-		name: "Monitoring",
-		fields: [
-			{ configPath: "orchestrator.monitoring.pollInterval", label: "Poll Interval (sec)", control: "input", layer: "L1", fieldType: "number", description: "Poll interval for lane/task monitoring (seconds)" },
-		],
-	},
-	{
-		name: "Supervisor",
+		name: "Dependencies",
 		fields: [
-			{ configPath: "orchestrator.supervisor.model", label: "Supervisor Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "supervisorModel", description: "Supervisor model (inherit = use session model)" },
-			{ configPath: "orchestrator.supervisor.autonomy", label: "Autonomy Level", control: "picker", layer: "L1", fieldType: "enum", values: ["interactive", "supervised", "autonomous"], description: "Recovery action confirmation behavior" },
+			{ configPath: "orchestrator.dependencies.source", label: "Dep Source", control: "toggle", layer: "L1", fieldType: "enum", values: ["prompt", "agent"], description: "Dependency extraction source" },
+			{ configPath: "orchestrator.dependencies.cache", label: "Dep Cache", control: "toggle", layer: "L1", fieldType: "boolean", values: ["true", "false"], description: "Cache dependency analysis results" },
 		],
 	},
 	{
-		name: "Worker",
+		name: "Assignment",
 		fields: [
-			{ configPath: "taskRunner.worker.model", label: "Worker Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "workerModel", description: "Worker model (inherit = use session model)" },
-			{ configPath: "taskRunner.worker.tools", label: "Worker Tools", control: "input", layer: "L1", fieldType: "string", description: "Worker tool allowlist" },
-			{ configPath: "taskRunner.worker.thinking", label: "Worker Thinking", control: "picker", layer: "L1", fieldType: "string", description: "Worker thinking mode" },
-			// spawnMode removed — /task is deprecated, Runtime V2 is subprocess-only.
-			// { configPath: "taskRunner.worker.spawnMode" ... } was here.
+			{ configPath: "orchestrator.assignment.strategy", label: "Strategy", control: "toggle", layer: "L1", fieldType: "enum", values: ["affinity-first", "round-robin", "load-balanced"], description: "Lane assignment strategy" },
 		],
 	},
 	{
-		name: "Reviewer",
+		name: "Pre-Warm",
 		fields: [
-			{ configPath: "taskRunner.reviewer.model", label: "Reviewer Model", control: "input", layer: "L1+L2", fieldType: "string", prefsKey: "reviewerModel", description: "Reviewer model (inherit = use session model)" },
-			{ configPath: "taskRunner.reviewer.tools", label: "Reviewer Tools", control: "input", layer: "L1", fieldType: "string", description: "Reviewer tool allowlist" },
-			{ configPath: "taskRunner.reviewer.thinking", label: "Reviewer Thinking", control: "picker", layer: "L1", fieldType: "string", description: "Reviewer thinking mode" },
+			{ configPath: "orchestrator.preWarm.autoDetect", label: "Auto-Detect", control: "toggle", layer: "L1", fieldType: "boolean", values: ["true", "false"], description: "Enable automatic pre-warm command detection" },
 		],
 	},
 	{
-		name: "Context Limits",
+		name: "Monitoring",
 		fields: [
-			{ configPath: "taskRunner.context.workerContextWindow", label: "Context Window", control: "input", layer: "L1", fieldType: "number", description: "Worker context window size" },
-			{ configPath: "taskRunner.context.warnPercent", label: "Warn %", control: "input", layer: "L1", fieldType: "number", description: "Context utilization warn threshold (%)" },
-			{ configPath: "taskRunner.context.killPercent", label: "Kill %", control: "input", layer: "L1", fieldType: "number", description: "Context utilization hard-stop threshold (%)" },
-			{ configPath: "taskRunner.context.maxWorkerIterations", label: "Max Iterations", control: "input", layer: "L1", fieldType: "number", description: "Max worker iterations per step" },
-			{ configPath: "taskRunner.context.maxReviewCycles", label: "Max Review Cycles", control: "input", layer: "L1", fieldType: "number", description: "Max revise loops per review stage" },
-			{ configPath: "taskRunner.context.noProgressLimit", label: "No Progress Limit", control: "input", layer: "L1", fieldType: "number", description: "Max no-progress iterations before failure" },
-			{ configPath: "taskRunner.context.maxWorkerMinutes", label: "Max Worker Min (ctx)", control: "input", layer: "L1", fieldType: "number", optional: true, description: "Per-worker wall-clock cap (minutes, empty = no cap)" },
+			{ configPath: "orchestrator.monitoring.pollInterval", label: "Poll Interval (sec)", control: "input", layer: "L1", fieldType: "number", description: "Poll interval for lane/task monitoring (seconds)" },
 		],
 	},
 	{
@@ -1166,9 +1162,10 @@ export async function openSettingsTui(
 	ctx: ExtensionContext,
 	configRoot: string,
 	pointerConfigRoot?: string,
+	onConfigChanged?: () => void,
 ): Promise<void> {
 	// Load current config state — refreshed each time we return to the top level
-	await showSectionSelectorLoop(ctx, configRoot, pointerConfigRoot);
+	await showSectionSelectorLoop(ctx, configRoot, pointerConfigRoot, onConfigChanged);
 }
 
 /**
@@ -1200,6 +1197,7 @@ async function showSectionSelectorLoop(
 	ctx: ExtensionContext,
 	configRoot: string,
 	pointerConfigRoot?: string,
+	onConfigChanged?: () => void,
 ): Promise<void> {
 	while (true) {
 		const state = loadConfigState(configRoot, pointerConfigRoot);
@@ -1257,7 +1255,7 @@ async function showSectionSelectorLoop(
 		if (section.readOnly) {
 			await showAdvancedSection(ctx, state.mergedConfig);
 		} else {
-			await showSectionSettingsLoop(ctx, section, configRoot, pointerConfigRoot);
+			await showSectionSettingsLoop(ctx, section, configRoot, pointerConfigRoot, onConfigChanged);
 		}
 	}
 }
@@ -1339,6 +1337,7 @@ async function showSectionSettingsLoop(
 	section: SectionDef,
 	configRoot: string,
 	pointerConfigRoot?: string,
+	onConfigChanged?: () => void,
 ): Promise<void> {
 	while (true) {
 		const state = loadConfigState(configRoot, pointerConfigRoot);
@@ -1438,9 +1437,13 @@ async function showSectionSettingsLoop(
 			} else {
 				writeGlobalPreference(toGlobalPreferencePath(field), typedValue);
 			}
+			// Notify caller to reload in-memory config from disk
+			if (onConfigChanged) {
+				try { onConfigChanged(); } catch { /* non-fatal */ }
+			}
+
 			ctx.ui.notify(
-				`✅ ${field.label} updated.\n` +
-				`ℹ Restart session to apply changes.`,
+				`✅ ${field.label} updated.`,
 				"info",
 			);
 
@@ -1494,9 +1497,38 @@ async function showSectionSettingsOnce(
 			description: field.description,
 		};
 
-		// Toggle fields get values array for cycling
+		// Toggle fields: use cycling for 2 values (boolean-like), submenu for 3+
 		if (field.control === "toggle" && field.values) {
-			item.values = field.values.map((v) => `${v}  ${sourceBadge}`);
+			if (field.values.length <= 2) {
+				item.values = field.values.map((v) => `${v}  ${sourceBadge}`);
+			} else {
+				// 3+ values: use a submenu so the user can pick any option,
+				// not just cycle to the next one and immediately commit.
+				item.submenu = (_currentValue: string, done: (selected?: string) => void) => {
+					const selectItems: SelectItem[] = field.values!.map((v) => ({
+						value: `${v}  ${sourceBadge}`,
+						label: v,
+					}));
+					// Return SelectList directly — Container doesn't forward
+					// handleInput to children, which would freeze the TUI.
+					const list = new SelectList(
+						selectItems,
+						Math.min(selectItems.length + 1, 10),
+						{
+							selectedPrefix: (t: string) => `\x1b[36m${t}\x1b[0m`,
+							selectedText: (t: string) => `\x1b[36m${t}\x1b[0m`,
+							description: (t: string) => `\x1b[2m${t}\x1b[0m`,
+							scrollInfo: (t: string) => `\x1b[2m${t}\x1b[0m`,
+							noMatch: (t: string) => `\x1b[33m${t}\x1b[0m`,
+						},
+					);
+					const currentIdx = field.values!.indexOf(displayValue);
+					if (currentIdx >= 0) list.setSelectedIndex(currentIdx);
+					list.onSelect = (selected) => done(selected.value);
+					list.onCancel = () => done();
+					return list;
+				};
+			}
 		}
 
 		// Input fields: use a single-value cycling pattern instead of a submenu.
@@ -1649,15 +1681,16 @@ function truncateLine(text: string, width: number): string {
  */
 const SECTION_CONFIG_PREFIXES: Record<string, string[]> = {
 	"Orchestrator": ["orchestrator.orchestrator"],
+	"Agent: Supervisor": ["orchestrator.supervisor"],
+	"Agent: Worker": ["taskRunner.worker"],
+	"Agent: Reviewer": ["taskRunner.reviewer"],
+	"Agent: Merge": ["orchestrator.merge"],
+	"Context Limits": ["taskRunner.context"],
+	"Failure Policy": ["orchestrator.failure"],
 	"Dependencies": ["orchestrator.dependencies"],
 	"Assignment": ["orchestrator.assignment"],
 	"Pre-Warm": ["orchestrator.preWarm"],
-	"Merge": ["orchestrator.merge"],
-	"Failure Policy": ["orchestrator.failure"],
 	"Monitoring": ["orchestrator.monitoring"],
-	"Worker": ["taskRunner.worker"],
-	"Reviewer": ["taskRunner.reviewer"],
-	"Context Limits": ["taskRunner.context"],
 };
 
 /**

package/extensions/taskplane/supervisor.ts

@@ -397,19 +397,52 @@ export interface IntegrationPlan {
 	failedTasks: number;
 }
 
+/**
+ * Check whether the git repository has any remotes configured.
+ *
+ * Used by integration planning to determine if PR mode is possible.
+ * A repo without remotes cannot create pull requests.
+ *
+ * @param cwd - Working directory with the git repo
+ * @returns true if at least one remote is configured
+ *
+ * @since TP-149
+ */
+export function hasGitRemotes(cwd: string): boolean {
+	try {
+		const result = execFileSync("git", ["remote"], {
+			encoding: "utf-8",
+			timeout: 5_000,
+			cwd,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		return result.trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+
 /**
  * Build an integration plan based on the batch state and branch status.
  *
- * Mode selection logic:
- * 1. If base branch is protected → PR mode (can't push directly)
- * 2. If branches have diverged → merge mode (ff not possible)
- * 3. Otherwise → ff mode (cleanest)
+ * Mode selection logic (TP-149):
+ * 1. Check if remotes exist (determines if PR mode is possible)
+ * 2. If base branch is confirmed protected AND remotes exist → PR mode
+ * 3. Try fast-forward first (cleanest, most common)
+ * 4. If FF not possible (diverged) → merge mode
+ *
+ * PR mode is only selected when protection is **confirmed** (not "unknown").
+ * When protection status is indeterminate (gh unavailable, auth issues),
+ * the plan prefers FF → merge over PR, since PR may also fail in that state.
+ * Repos without remotes skip protection checks and PR mode entirely.
  *
  * @param batchState - Runtime batch state (orchBranch, baseBranch, counts)
  * @param cwd - Working directory with the git repo
+ * @param protectionOverride - Injectable protection status for testing
  * @returns Integration plan, or null if integration is not possible
  *
  * @since TP-043
+ * @modified TP-149 — Reordered to FF → merge → PR; check remotes first
  */
 export function buildIntegrationPlan(
 	batchState: OrchBatchRuntimeState,
@@ -428,39 +461,21 @@ export function buildIntegrationPlan(
 	const baseBranch = batchState.baseBranch;
 	const batchId = batchState.batchId;
 
-	// Step 1: Check branch protection (injectable for testing)
-	const protection = protectionOverride ?? detectBranchProtection(baseBranch, cwd);
+	// Step 1: Check for remotes — determines if PR mode is even possible (TP-149)
+	const remotes = hasGitRemotes(cwd);
 
-	if (protection === "protected") {
-		return {
-			mode: "pr",
-			orchBranch,
-			baseBranch,
-			batchId,
-			branchProtection: protection,
-			rationale: `Base branch \`${baseBranch}\` is protected — creating a pull request for review.`,
-			succeededTasks: batchState.succeededTasks,
-			failedTasks: batchState.failedTasks,
-		};
-	}
+	// Step 2: Determine protection status
+	// - Override: use as-is (test injection path)
+	// - Remotes exist: detect via gh API
+	// - No remotes: treat as unprotected (can't create PRs anyway)
+	const protection = protectionOverride
+		?? (remotes ? detectBranchProtection(baseBranch, cwd) : "unprotected");
 
-	if (protection === "unknown") {
-		// Safe fallback: when protection status can't be determined
-		// (gh CLI unavailable, no remote, etc.), default to PR mode
-		// to avoid accidentally pushing to a protected branch.
-		return {
-			mode: "pr",
-			orchBranch,
-			baseBranch,
-			batchId,
-			branchProtection: protection,
-			rationale: `Could not detect branch protection for \`${baseBranch}\` — defaulting to PR mode for safety.`,
-			succeededTasks: batchState.succeededTasks,
-			failedTasks: batchState.failedTasks,
-		};
-	}
+	// Step 3: Always try FF first, then merge, then PR (TP-149).
+	// Protected branches may still allow FF/merge via API tokens.
+	// PR is the last resort when direct merge is blocked.
 
-	// Step 2: Check ff-ability (is baseBranch ancestor of orchBranch?)
+	// Step 3a: Try fast-forward first (cleanest, most common)
 	try {
 		execFileSync("git", ["merge-base", "--is-ancestor", baseBranch, orchBranch], {
 			encoding: "utf-8",
@@ -480,7 +495,20 @@ export function buildIntegrationPlan(
 			failedTasks: batchState.failedTasks,
 		};
 	} catch {
-		// Branches have diverged — need merge commit
+		// Branches have diverged — need merge commit or PR
+		// Step 3c: If protected AND remotes exist, prefer PR (merge may be blocked by push protection)
+		if (protection === "protected" && remotes) {
+			return {
+				mode: "pr",
+				orchBranch,
+				baseBranch,
+				batchId,
+				branchProtection: protection,
+				rationale: `Branches diverged and \`${baseBranch}\` is protected — creating a pull request.`,
+				succeededTasks: batchState.succeededTasks,
+				failedTasks: batchState.failedTasks,
+			};
+		}
 		return {
 			mode: "merge",
 			orchBranch,
@@ -923,7 +951,7 @@ export function triggerSupervisorIntegration(
 				}],
 				display: "Integration plan ready — awaiting operator confirmation",
 			},
-			{ triggerTurn: true, deliverAs: "nextTurn" },
+			{ triggerTurn: true },
 		);
 
 		// TP-043 R004: Defer summary until after integration completes (or operator declines).
@@ -2806,7 +2834,11 @@ export async function activateSupervisor(
 				],
 				display: `Supervisor activated — ${routingContext.routingState}`,
 			},
-			{ triggerTurn: true, deliverAs: "nextTurn" },
+			// triggerTurn starts an LLM turn immediately when the agent is idle.
+			// Do NOT use deliverAs:"nextTurn" — that queues the message for a
+			// future turn instead of starting one, causing the terminal to hang
+			// until the user sends input.
+			{ triggerTurn: true },
 		);
 		return;
 	}
@@ -2858,7 +2890,9 @@ export async function activateSupervisor(
 			],
 			display: "Supervisor activated" + (batchState.batchId ? ` for batch ${batchState.batchId}` : ""),
 		},
-		{ triggerTurn: true, deliverAs: "nextTurn" },
+		// triggerTurn starts an LLM turn immediately when the agent is idle.
+		// Do NOT use deliverAs:"nextTurn" here — see routing path comment.
+		{ triggerTurn: true },
 	);
 }
 
@@ -3004,7 +3038,7 @@ export async function transitionToRoutingMode(
 			}],
 			display: `Supervisor — ${routingContext.routingState}`,
 		},
-		{ triggerTurn: true, deliverAs: "nextTurn" },
+		{ triggerTurn: true },
 	);
 }
 
@@ -4213,7 +4247,7 @@ export function startEventTailer(
 				content: [{ type: "text", text }],
 				display: text.replace(/\*\*/g, "").substring(0, 80),
 			},
-			{ triggerTurn: true, deliverAs: "nextTurn" },
+			{ triggerTurn: true },
 		);
 	};
 

package/extensions/taskplane/types.ts

@@ -3202,7 +3202,7 @@ export interface TokenCounts {
 export interface BatchTaskSummary {
 	taskId: string;
 	taskName: string;
-	status: "succeeded" | "failed" | "skipped" | "blocked" | "stalled";
+	status: "succeeded" | "failed" | "skipped" | "blocked" | "stalled" | "pending";
 	wave: number;      // 1-based
 	lane: number;      // 1-based
 	durationMs: number;

package/extensions/taskplane/waves.ts

@@ -575,12 +575,20 @@ export function resolveBaseBranch(
 	if (batchBaseBranch.startsWith("orch/") && repoId) {
 		try {
 			const check = runGit(["rev-parse", "--verify", `refs/heads/${batchBaseBranch}`], repoRoot);
-			console.error(`[resolveBaseBranch] repoId=${repoId} batchBaseBranch=${batchBaseBranch} repoRoot=${repoRoot} check.ok=${check.ok}`);
 			if (check.ok) {
 				return batchBaseBranch;
 			}
+			// TP-146: Orch branch exists as batch base but not in this repo.
+			// This means worktrees will branch from the repo's current HEAD
+			// instead of the orch branch, bypassing batch isolation.
+			console.error(
+				`[taskplane] resolveBaseBranch WARNING: orch branch "${batchBaseBranch}" not found in repo "${repoId}" at ${repoRoot} — falling back to repo HEAD. ` +
+				`This bypasses orch branch isolation. Ensure the orch branch was created in all workspace repos.`,
+			);
 		} catch (err) {
-			console.error(`[resolveBaseBranch] repoId=${repoId} batchBaseBranch=${batchBaseBranch} THREW: ${err}`);
+			console.error(
+				`[taskplane] resolveBaseBranch WARNING: orch branch check failed for repo "${repoId}" at ${repoRoot}: ${err}`,
+			);
 		}
 	}
 
@@ -963,6 +971,97 @@ export function assignTasksToLanes(
 }
 
 
+// ── Global Lane Cap (TP-148) ─────────────────────────────────────────
+
+/**
+ * Enforce a global lane cap across all repo groups.
+ *
+ * In workspace mode, each repo independently allocates up to `maxLanes`.
+ * This function reduces the total across all repos to fit within the
+ * global `maxLanes` budget by consolidating lanes in repos with the
+ * most headroom (most lanes relative to their minimum of 1).
+ *
+ * Algorithm:
+ *   1. If total lanes ≤ maxLanes, no-op.
+ *   2. Group lanes by repo, sort repos by lane count descending.
+ *   3. Iteratively remove the last lane from the repo with the most
+ *      lanes, redistributing its tasks to the lightest remaining lane
+ *      in that repo.
+ *   4. Stop when total ≤ maxLanes or all repos are at 1 lane.
+ *   5. Renumber global lanes sequentially.
+ *
+ * Mutates `entries` in place: removes excess entries and renumbers.
+ *
+ * @param entries  - Global lane entries from per-repo allocation
+ * @param maxLanes - Global maximum lane count
+ */
+export function enforceGlobalLaneCap(
+	entries: Array<{
+		globalLane: number;
+		localLane: number;
+		repoId: string | undefined;
+		assignments: LaneAssignment[];
+	}>,
+	maxLanes: number,
+): void {
+	if (entries.length <= maxLanes) return;
+
+	// Group entries by repoId
+	const byRepo = new Map<string, typeof entries>();
+	for (const entry of entries) {
+		const key = entry.repoId ?? "";
+		const group = byRepo.get(key) || [];
+		group.push(entry);
+		byRepo.set(key, group);
+	}
+
+	let excess = entries.length - maxLanes;
+
+	while (excess > 0) {
+		// Find the repo with the most lanes (ties broken by key for determinism)
+		let bestKey = "";
+		let bestCount = 0;
+		for (const [key, group] of byRepo) {
+			if (group.length > bestCount || (group.length === bestCount && key < bestKey)) {
+				bestKey = key;
+				bestCount = group.length;
+			}
+		}
+
+		// All repos at 1 lane — can't reduce further
+		if (bestCount <= 1) break;
+
+		// Remove the last lane from this repo and redistribute its tasks
+		const group = byRepo.get(bestKey)!;
+		const removed = group.pop()!;
+		// Merge into the first lane of the same repo (deterministic target)
+		group[0].assignments.push(...removed.assignments);
+		excess--;
+	}
+
+	// Warn if cap could not be fully enforced (more repos than maxLanes)
+	const finalTotal = [...byRepo.values()].reduce((sum, g) => sum + g.length, 0);
+	if (finalTotal > maxLanes) {
+		console.error(
+			`[taskplane] warning: global maxLanes=${maxLanes} could not be enforced — ` +
+			`${byRepo.size} repos each need at least 1 lane (total: ${finalTotal}). ` +
+			`Increase maxLanes to at least ${byRepo.size} to avoid this.`,
+		);
+	}
+
+	// Rebuild entries array with sequential global lane numbers
+	entries.length = 0;
+	let globalLane = 1;
+	for (const key of [...byRepo.keys()].sort()) {
+		const group = byRepo.get(key)!;
+		for (const entry of group) {
+			entry.globalLane = globalLane++;
+			entries.push(entry);
+		}
+	}
+}
+
+
 /**
  * Result of `allocateLanes()`.
  *
@@ -1188,6 +1287,13 @@ export function allocateLanes(
 		globalLaneOffset += sortedLocalLanes.length;
 	}
 
+	// ── Stage 2b: Enforce global lane cap (TP-148) ─────────────────
+	// In workspace mode, each repo group independently allocates up to
+	// maxLanes. If total lanes across all repos exceeds the global
+	// maxLanes limit, reduce lanes in repos with the most headroom.
+	// Preserves at least 1 lane per repo with tasks.
+	enforceGlobalLaneCap(globalLaneEntries, config.orchestrator.max_lanes);
+
 	const laneCount = globalLaneEntries.length;
 
 	if (laneCount === 0) {