taskplane 0.7.1 → 0.8.0

package/extensions/taskplane/extension.ts

@@ -43,9 +43,11 @@ import {
 } from "./index.ts";
 import { buildExecutionContext } from "./workspace.ts";
 import { openSettingsTui } from "./settings-tui.ts";
+import { loadProjectConfig } from "./config-loader.ts";
 import {
 	activateSupervisor,
 	deactivateSupervisor,
+	transitionToRoutingMode,
 	freshSupervisorState,
 	registerSupervisorPromptHook,
 	checkSupervisorLockOnStartup,
@@ -55,8 +57,9 @@ import {
 	DEFAULT_SUPERVISOR_CONFIG,
 	triggerSupervisorIntegration,
 	presentBatchSummary,
+	resolveModelFromString,
 } from "./supervisor.ts";
-import type { SupervisorConfig, IntegrationExecutor, CiDeps, SummaryDeps } from "./supervisor.ts";
+import type { SupervisorConfig, SupervisorRoutingContext, IntegrationExecutor, CiDeps, SummaryDeps } from "./supervisor.ts";
 import type {
 	AbortMode,
 	ExecutionContext,
@@ -719,6 +722,128 @@ export function collectRepoCleanupFindings(
  * This prevents unhandled promise rejections from crashing the session
  * or leaving batch state inconsistent.
  */
+
+// ── Model Availability Pre-Flight ───────────────────────────────────
+
+/**
+ * A single model configuration to validate.
+ */
+interface ModelCheckEntry {
+	/** Role label for display (e.g., "Worker", "Reviewer") */
+	role: string;
+	/** Model string from config (empty = inherit session model) */
+	modelStr: string;
+}
+
+/**
+ * Result of a single model availability check.
+ */
+export interface ModelCheckResult {
+	role: string;
+	modelStr: string;
+	status: "inherit" | "found" | "not-found";
+	resolvedName?: string;
+}
+
+/**
+ * Validate that all configured agent models are available in the model registry.
+ *
+ * Checks worker, reviewer, merger, and supervisor model settings. Models set to
+ * empty string ("") or not configured inherit the session model and are always valid.
+ *
+ * Does NOT validate API keys (that would require side-effectful setModel calls).
+ * This catches the most common misconfiguration: specifying a model that isn't
+ * registered in pi (wrong name, missing provider, etc.).
+ *
+ * @param orchConfig - Orchestrator configuration
+ * @param runnerConfig - Task runner configuration
+ * @param supervisorConfig - Supervisor configuration
+ * @param ctx - Extension context with model registry
+ * @returns Array of check results (one per role)
+ *
+ * @since v0.7.2
+ */
+export function validateModelAvailability(
+	orchConfig: OrchestratorConfig,
+	runnerConfig: TaskRunnerConfig,
+	supervisorConfig: SupervisorConfig,
+	ctx: ExtensionContext,
+	agentModels?: { workerModel?: string; reviewerModel?: string },
+): ModelCheckResult[] {
+	const entries: ModelCheckEntry[] = [
+		{ role: "Worker", modelStr: agentModels?.workerModel ?? (runnerConfig as any).worker?.model ?? "" },
+		{ role: "Reviewer", modelStr: agentModels?.reviewerModel ?? (runnerConfig as any).reviewer?.model ?? "" },
+		{ role: "Merger", modelStr: orchConfig.merge?.model ?? "" },
+		{ role: "Supervisor", modelStr: supervisorConfig.model ?? "" },
+	];
+
+	const sessionModel = ctx.model;
+	const results: ModelCheckResult[] = [];
+
+	for (const entry of entries) {
+		if (!entry.modelStr) {
+			// Empty = inherit session model
+			results.push({
+				role: entry.role,
+				modelStr: "(inherit)",
+				status: "inherit",
+				resolvedName: sessionModel
+					? `${(sessionModel as any).provider ?? ""}/${sessionModel.id}`.replace(/^\//, "")
+					: "session default",
+			});
+			continue;
+		}
+
+		const resolved = resolveModelFromString(entry.modelStr, ctx);
+		if (resolved) {
+			results.push({
+				role: entry.role,
+				modelStr: entry.modelStr,
+				status: "found",
+				resolvedName: `${(resolved as any).provider ?? ""}/${resolved.id}`.replace(/^\//, ""),
+			});
+		} else {
+			results.push({
+				role: entry.role,
+				modelStr: entry.modelStr,
+				status: "not-found",
+			});
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Format model validation results for display.
+ *
+ * @param results - Model check results from validateModelAvailability
+ * @returns Formatted string for ctx.ui.notify
+ */
+export function formatModelValidation(results: ModelCheckResult[]): string {
+	const lines: string[] = ["Model Configuration:"];
+	let hasFailure = false;
+
+	for (const r of results) {
+		if (r.status === "inherit") {
+			lines.push(`  ✅ ${r.role.padEnd(12)} inherit → ${r.resolvedName}`);
+		} else if (r.status === "found") {
+			lines.push(`  ✅ ${r.role.padEnd(12)} ${r.modelStr} → ${r.resolvedName}`);
+		} else {
+			lines.push(`  ❌ ${r.role.padEnd(12)} ${r.modelStr} — NOT FOUND in model registry`);
+			hasFailure = true;
+		}
+	}
+
+	if (hasFailure) {
+		lines.push("");
+		lines.push("  Fix: update the model in .pi/taskplane-config.json or /taskplane-settings,");
+		lines.push("  or remove the override to inherit the session model.");
+	}
+
+	return lines.join("\n");
+}
+
 export function startBatchAsync(
 	engineFn: () => Promise<void>,
 	batchState: import("./types.ts").OrchBatchRuntimeState,
@@ -1186,6 +1311,15 @@ export default function (pi: ExtensionAPI) {
 
 			if (!requireExecCtx(ctx)) return;
 
+			// ── TP-128: Transition from routing-mode supervisor to batch execution ──
+			// If the supervisor is active in routing mode (conversational, no batch),
+			// deactivate it so the batch can start fresh with monitoring-mode supervisor.
+			// This enables the workflow: /orch → conversation → "run the tasks" → /orch all
+			// without the operator needing to know about internal mode distinctions.
+			if (supervisorState.active && supervisorState.routingContext) {
+				await deactivateSupervisor(pi, supervisorState);
+			}
+
 			// Prevent concurrent batch execution (merging is an active state)
 			if (orchBatchState.phase !== "idle" && orchBatchState.phase !== "completed" && orchBatchState.phase !== "failed" && orchBatchState.phase !== "stopped") {
 				ctx.ui.notify(
@@ -1265,6 +1399,34 @@ export default function (pi: ExtensionAPI) {
 					break;
 			}
 
+			// ── Model availability pre-flight ────────────────────────
+			// Validate that all configured agent models are resolvable in
+			// the model registry before starting. Catches misconfigured
+			// model names early instead of failing hours into a batch.
+			// Note: runnerConfig (TaskRunnerConfig) is a stripped type without
+			// worker/reviewer model fields. Load the full unified config to
+			// get the actual agent model strings (including user preferences).
+			let agentModels: { workerModel?: string; reviewerModel?: string } | undefined;
+			try {
+				const fullConfig = loadProjectConfig(execCtx!.repoRoot);
+				agentModels = {
+					workerModel: fullConfig.taskRunner.worker.model || "",
+					reviewerModel: fullConfig.taskRunner.reviewer.model || "",
+				};
+			} catch { /* fall through — validateModelAvailability handles empty strings */ }
+			const modelResults = validateModelAvailability(orchConfig, runnerConfig, supervisorConfig, ctx, agentModels);
+			const modelFailures = modelResults.filter(r => r.status === "not-found");
+			ctx.ui.notify(formatModelValidation(modelResults), modelFailures.length > 0 ? "error" : "info");
+			if (modelFailures.length > 0) {
+				ctx.ui.notify(
+					`❌ Cannot start batch — ${modelFailures.length} model(s) not found: ` +
+					modelFailures.map(f => `${f.role} (${f.modelStr})`).join(", ") +
+					`.\n\nFix the model configuration and try again.`,
+					"error",
+				);
+				return;
+			}
+
 			// Reset batch state for new execution
 			orchBatchState = freshOrchBatchState();
 			latestMonitorState = null;
@@ -1377,9 +1539,33 @@ export default function (pi: ExtensionAPI) {
 							{ triggerTurn: false },
 						);
 					}
-					// TP-043: Generate summary before deactivation (manual mode or non-completed)
+					// TP-043: Generate summary before transition
 					presentBatchSummary(pi, orchBatchState, execCtx!.workspaceRoot, opId, orchBatchState.diagnostics, sDeps.mergeResults);
-					deactivateSupervisor(pi, supervisorState);
+					// TP-128: Transition to routing mode instead of deactivating.
+					// The operator can continue the conversation (integrate, plan
+					// next batch, create tasks) without re-invoking /orch.
+					const postBatchContext: SupervisorRoutingContext = orchBatchState.phase === "completed"
+						? {
+							routingState: "completed-batch",
+							contextMessage:
+								`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?\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);
 				},
 			);
 
@@ -1697,9 +1883,25 @@ export default function (pi: ExtensionAPI) {
 							{ triggerTurn: false },
 						);
 					}
-					// TP-043: Generate summary before deactivation
+					// TP-043: Generate summary before transition
 					presentBatchSummary(pi, orchBatchState, execCtx!.workspaceRoot, opId, orchBatchState.diagnostics, sDeps.mergeResults);
-					deactivateSupervisor(pi, supervisorState);
+					// TP-128: Transition to routing mode (same as /orch onTerminal)
+					const postBatchContext: SupervisorRoutingContext = orchBatchState.phase === "completed"
+						? {
+							routingState: "completed-batch",
+							contextMessage:
+								`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?`,
+						}
+						: {
+							routingState: "no-tasks",
+							contextMessage:
+								`Batch **${orchBatchState.batchId}** ended (${orchBatchState.phase}).\n\n` +
+								`What would you like to do next?`,
+						};
+					transitionToRoutingMode(pi, supervisorState, postBatchContext);
 				},
 			);
 

package/extensions/taskplane/merge.ts

@@ -11,7 +11,7 @@ import { resolveOperatorId } from "./naming.ts";
 import { MERGE_POLL_INTERVAL_MS, MERGE_RESULT_GRACE_MS, MERGE_RESULT_READ_RETRIES, MERGE_RESULT_READ_RETRY_DELAY_MS, MERGE_SPAWN_RETRY_MAX, MERGE_TIMEOUT_MAX_RETRIES, MERGE_TIMEOUT_MS, MergeError, VALID_MERGE_STATUSES } from "./types.ts";
 import type { AllocatedLane, LaneExecutionResult, MergeLaneResult, MergeResult, MergeResultStatus, MergeWaveResult, OrchestratorConfig, RepoMergeOutcome, TaskRunnerConfig, TransactionRecord, TransactionStatus, VerificationBaselineResult, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
 import { resolveBaseBranch, resolveRepoRoot } from "./waves.ts";
-import { generateMergeWorktreePath, sleepSync } from "./worktree.ts";
+import { generateMergeWorktreePath, sleepAsync, sleepSync } from "./worktree.ts";
 import { getCurrentBranch, runGit } from "./git.ts";
 import { ORCH_MESSAGES } from "./messages.ts";
 import { loadOrchestratorConfig } from "./config.ts";
@@ -353,7 +353,7 @@ export function buildMergeRequest(
  * @param agentRoot       - Root for agent prompts. When pointer is resolved, this is the config repo's agent dir. Falls back to `<stateRoot>/.pi/agents/` or `<repoRoot>/.pi/agents/`.
  * @throws MergeError if spawn fails after retries
  */
-export function spawnMergeAgent(
+export async function spawnMergeAgent(
 	sessionName: string,
 	repoRoot: string,
 	mergeWorkDir: string,
@@ -361,7 +361,7 @@ export function spawnMergeAgent(
 	config: OrchestratorConfig,
 	stateRoot?: string,
 	agentRoot?: string,
-): void {
+): Promise<void> {
 	execLog("merge", sessionName, "preparing to spawn merge agent", {
 		mergeWorkDir,
 		mergeRequestPath,
@@ -371,7 +371,7 @@ export function spawnMergeAgent(
 	if (tmuxHasSession(sessionName)) {
 		execLog("merge", sessionName, "killing stale merge session");
 		tmuxKillSession(sessionName);
-		sleepSync(500);
+		await sleepAsync(500);
 	}
 
 	// Build the pi command for the merge agent.
@@ -424,7 +424,7 @@ export function spawnMergeAgent(
 		execLog("merge", sessionName, `merge spawn attempt ${attempt} failed: ${lastError}`);
 
 		if (attempt <= MERGE_SPAWN_RETRY_MAX) {
-			sleepSync(attempt * 1000);
+			await sleepAsync(attempt * 1000);
 		}
 	}
 
@@ -449,7 +449,7 @@ export function spawnMergeAgent(
 export function reloadMergeTimeoutMs(configRoot: string, pointerConfigRoot?: string): number {
 	try {
 		const freshConfig = loadOrchestratorConfig(configRoot, pointerConfigRoot);
-		const minutes = freshConfig.merge.timeout_minutes ?? 10;
+		const minutes = freshConfig.merge.timeout_minutes ?? 90;
 		return minutes * 60 * 1000;
 	} catch (err: unknown) {
 		// Config re-read is best-effort — fall back to default on failure
@@ -480,11 +480,11 @@ const SUCCESSFUL_MERGE_STATUSES = new Set<string>(["SUCCESS", "CONFLICT_RESOLVED
  * @returns Validated MergeResult
  * @throws MergeError on timeout, session death, or invalid result
  */
-export function waitForMergeResult(
+export async function waitForMergeResult(
 	resultPath: string,
 	sessionName: string,
 	timeoutMs: number = MERGE_TIMEOUT_MS,
-): MergeResult {
+): Promise<MergeResult> {
 	const startTime = Date.now();
 	let sessionDiedAt: number | null = null;
 
@@ -559,7 +559,7 @@ export function waitForMergeResult(
 				// parseMergeResult already retries, so if it throws, it's final.
 				if (err instanceof MergeError && err.code === "MERGE_RESULT_INVALID") {
 					// Wait a bit and try once more (file might still be in flight)
-					sleepSync(MERGE_RESULT_READ_RETRY_DELAY_MS);
+					await sleepAsync(MERGE_RESULT_READ_RETRY_DELAY_MS);
 					if (existsSync(resultPath)) {
 						try {
 							return parseMergeResult(resultPath);
@@ -605,7 +605,7 @@ export function waitForMergeResult(
 		}
 
 		// Poll interval
-		sleepSync(MERGE_POLL_INTERVAL_MS);
+		await sleepAsync(MERGE_POLL_INTERVAL_MS);
 	}
 }
 
@@ -931,7 +931,7 @@ function runPostMergeVerification(
  * @param baseBranch       - Branch to merge into (captured at batch start)
  * @returns MergeWaveResult with per-lane outcomes
  */
-export function mergeWave(
+export async function mergeWave(
 	completedLanes: AllocatedLane[],
 	waveResult: WaveExecutionResult,
 	waveIndex: number,
@@ -943,7 +943,7 @@ export function mergeWave(
 	agentRoot?: string,
 	testingCommands?: Record<string, string>,
 	repoId?: string,
-): MergeWaveResult {
+): Promise<MergeWaveResult> {
 	const startTime = Date.now();
 	const tmuxPrefix = config.orchestrator.tmux_prefix;
 	const opId = resolveOperatorId(config);
@@ -1008,7 +1008,7 @@ export function mergeWave(
 	forceRemoveMergeWorktree(mergeWorkDir, repoRoot, `W${waveIndex}`);
 	if (existsSync(mergeWorkDir)) {
 		// Force cleanup didn't fully remove — wait and retry once
-		sleepSync(500);
+		await sleepAsync(500);
 		forceRemoveMergeWorktree(mergeWorkDir, repoRoot, `W${waveIndex}`);
 	}
 	try {
@@ -1242,14 +1242,14 @@ export function mergeWave(
 						}
 
 						// Re-spawn merge agent for the retry
-						spawnMergeAgent(sessionName, repoRoot, mergeWorkDir, requestFilePath, config, stateRoot, agentRoot);
+						await spawnMergeAgent(sessionName, repoRoot, mergeWorkDir, requestFilePath, config, stateRoot, agentRoot);
 					} else {
 						// First attempt: spawn merge agent
-						spawnMergeAgent(sessionName, repoRoot, mergeWorkDir, requestFilePath, config, stateRoot, agentRoot);
+						await spawnMergeAgent(sessionName, repoRoot, mergeWorkDir, requestFilePath, config, stateRoot, agentRoot);
 					}
 
 					try {
-						mergeResult = waitForMergeResult(resultFilePath, sessionName, currentTimeoutMs);
+						mergeResult = await waitForMergeResult(resultFilePath, sessionName, currentTimeoutMs);
 						lastTimeoutError = null;
 						break; // Success — exit retry loop
 					} catch (waitErr: unknown) {
@@ -1732,7 +1732,7 @@ export function mergeWave(
 		forceRemoveMergeWorktree(mergeWorkDir, repoRoot, `W${waveIndex}`);
 		try {
 			// Small delay to ensure worktree lock is released
-			sleepSync(500);
+			await sleepAsync(500);
 			spawnSync("git", ["branch", "-D", tempBranch], { cwd: repoRoot });
 		} catch { /* best effort */ }
 	}
@@ -1845,7 +1845,7 @@ export function groupLanesByRepo(
  * @param workspaceConfig  - Workspace configuration (null in repo mode)
  * @returns MergeWaveResult with per-lane and per-repo outcomes
  */
-export function mergeWaveByRepo(
+export async function mergeWaveByRepo(
 	completedLanes: AllocatedLane[],
 	waveResult: WaveExecutionResult,
 	waveIndex: number,
@@ -1857,7 +1857,7 @@ export function mergeWaveByRepo(
 	stateRoot?: string,
 	agentRoot?: string,
 	testingCommands?: Record<string, string>,
-): MergeWaveResult {
+): Promise<MergeWaveResult> {
 	const startTime = Date.now();
 
 	// Build lane outcome lookup for merge eligibility (same logic as mergeWave).
@@ -1901,7 +1901,7 @@ export function mergeWaveByRepo(
 	// In repo mode (single group with repoId=undefined), delegate directly
 	// to mergeWave() for zero-overhead backward compatibility.
 	if (repoGroups.length === 1 && repoGroups[0].repoId === undefined) {
-		const result = mergeWave(
+		const result = await mergeWave(
 			completedLanes,
 			waveResult,
 			waveIndex,
@@ -1956,7 +1956,7 @@ export function mergeWaveByRepo(
 			allocatedLanes: waveResult.allocatedLanes.filter(l => groupLaneNumbers.has(l.laneNumber)),
 		};
 
-		const groupResult = mergeWave(
+		const groupResult = await mergeWave(
 			group.lanes,
 			filteredWaveResult,
 			waveIndex,

package/extensions/taskplane/messages.ts

@@ -698,12 +698,12 @@ export function extractFailedRepoId(mergeResult: MergeWaveResult): string | unde
  * @returns Outcome describing what happened during the retry cycle
  * @since TP-033 R006
  */
-export function applyMergeRetryLoop(
+export async function applyMergeRetryLoop(
 	mergeResult: MergeWaveResult,
 	waveIdx: number,
 	retryCountByScope: Record<string, number>,
 	callbacks: MergeRetryCallbacks,
-): MergeRetryLoopOutcome {
+): Promise<MergeRetryLoopOutcome> {
 	let currentResult = mergeResult;
 
 	// Classify the initial failure
@@ -766,12 +766,12 @@ export function applyMergeRetryLoop(
 		);
 
 		if (lastDecision.cooldownMs > 0) {
-			callbacks.sleep(lastDecision.cooldownMs);
+			await callbacks.sleep(lastDecision.cooldownMs);
 		}
 
 		// Re-invoke merge
 		callbacks.persist("merge-retry-start");
-		currentResult = callbacks.performMerge();
+		currentResult = await callbacks.performMerge();
 		callbacks.updateMergeResult(currentResult);
 		callbacks.persist("merge-retry-complete");
 

package/extensions/taskplane/resume.ts

@@ -1246,7 +1246,7 @@ export async function resumeOrchBatch(
 				allocatedLanes: reExecAllocatedLanes,
 			};
 
-			const reExecMergeResult = mergeWaveByRepo(
+			const reExecMergeResult = await mergeWaveByRepo(
 				reExecAllocatedLanes,
 				syntheticWaveResult,
 				RE_EXEC_WAVE_INDEX,
@@ -1451,7 +1451,7 @@ export async function resumeOrchBatch(
 				batchState.phase = "merging";
 				persistRuntimeState("merge-retry-start", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
 
-				const mergeRetryResult = mergeWaveByRepo(
+				const mergeRetryResult = await mergeWaveByRepo(
 					mergeRetryLanes,
 					syntheticWaveResult,
 					waveIdx + 1,
@@ -1630,7 +1630,7 @@ export async function resumeOrchBatch(
 				persistRuntimeState("merge-start", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
 				onNotify(ORCH_MESSAGES.orchMergeStart(waveIdx + 1, mergeableLaneCount), "info");
 
-				mergeResult = mergeWaveByRepo(
+				mergeResult = await mergeWaveByRepo(
 					waveResult.allocatedLanes,
 					waveResult,
 					waveIdx + 1,
@@ -1762,14 +1762,14 @@ export async function resumeOrchBatch(
 				batchState.resilience = defaultResilienceState();
 			}
 
-			const retryOutcome = applyMergeRetryLoop(
+			const retryOutcome = await applyMergeRetryLoop(
 				mergeResult,
 				waveIdx,
 				batchState.resilience.retryCountByScope,
 				{
-					performMerge: () => {
+					performMerge: async () => {
 						batchState.phase = "merging";
-						return mergeWaveByRepo(
+						return await mergeWaveByRepo(
 							waveResult.allocatedLanes,
 							waveResult,
 							waveIdx + 1,