taskplane 0.7.0 → 0.7.2

package/dashboard/public/app.js

@@ -308,9 +308,17 @@ function renderSummary(batch) {
   let batchChecked = 0, batchTotal = 0;
   const waveStats = wavePlan.map((taskIds, waveIdx) => {
     let wChecked = 0, wTotal = 0;
+    let allSucceeded = taskIds.length > 0;
     for (const tid of taskIds) {
       const t = taskMap.get(tid);
-      if (t && t.statusData) {
+      if (!t || t.status !== "succeeded") allSucceeded = false;
+      if (t && t.status === "succeeded" && t.statusData) {
+        // Succeeded task with statusData: count as fully done even if
+        // STATUS.md checkboxes weren't all ticked before .DONE was created
+        const total = t.statusData.total || 1;
+        wChecked += total;
+        wTotal += total;
+      } else if (t && t.statusData) {
         wChecked += t.statusData.checked || 0;
         wTotal += t.statusData.total || 0;
       } else if (t && t.status === "succeeded") {
@@ -322,7 +330,7 @@ function renderSummary(batch) {
     }
     batchChecked += wChecked;
     batchTotal += wTotal;
-    return { waveIdx, taskIds, checked: wChecked, total: wTotal };
+    return { waveIdx, taskIds, checked: wChecked, total: wTotal, allSucceeded };
   });
 
   const overallPct = batchTotal > 0 ? Math.round((batchChecked / batchTotal) * 100) : 0;
@@ -333,15 +341,19 @@ function renderSummary(batch) {
   for (const ws of waveStats) {
     const segWidthPct = batchTotal > 0 ? (ws.total / batchTotal) * 100 : (100 / waveStats.length);
     const fillPct = ws.total > 0 ? (ws.checked / ws.total) * 100 : 0;
-    const isDone = ws.checked === ws.total && ws.total > 0;
-    const isCurrent = ws.waveIdx === currentWaveIdx && batch.phase === "executing";
+    const checkboxDone = ws.checked === ws.total && ws.total > 0;
+    const pastWave = ws.waveIdx < currentWaveIdx;
+    const batchDone = batch.phase === "completed" || batch.phase === "merging";
+    const isDone = checkboxDone || pastWave || batchDone || ws.allSucceeded;
+    const isCurrent = ws.waveIdx === currentWaveIdx && (batch.phase === "executing" || batch.phase === "merging");
     const isFuture = ws.waveIdx > currentWaveIdx && batch.phase === "executing";
 
     const fillClass = isDone ? "pct-hi" : fillPct > 50 ? "pct-mid" : fillPct > 0 ? "pct-low" : "pct-0";
+    const fillWidth = isDone ? 100 : fillPct;
     const segClass = isCurrent ? "wave-seg-current" : isFuture ? "wave-seg-future" : "";
 
     barHtml += `<div class="wave-seg ${segClass}" style="width:${segWidthPct.toFixed(1)}%" title="W${ws.waveIdx + 1}: ${ws.checked}/${ws.total} checkboxes (${ws.taskIds.join(', ')})">`;
-    barHtml += `  <div class="wave-seg-fill ${fillClass}" style="width:${fillPct.toFixed(1)}%"></div>`;
+    barHtml += `  <div class="wave-seg-fill ${fillClass}" style="width:${fillWidth.toFixed(1)}%"></div>`;
     barHtml += `  <span class="wave-seg-label">W${ws.waveIdx + 1}</span>`;
     barHtml += `</div>`;
   }

package/extensions/taskplane/config.ts

@@ -12,7 +12,7 @@
  */
 
 import { loadProjectConfig, toOrchestratorConfig, toTaskRunnerConfig, hasConfigFiles } from "./config-loader.ts";
-export { hasConfigFiles } from "./config-loader.ts";
+export { hasConfigFiles, resolveConfigRoot } from "./config-loader.ts";
 import type { OrchestratorConfig, TaskRunnerConfig } from "./types.ts";
 import type { SupervisorConfig } from "./supervisor.ts";
 import { DEFAULT_SUPERVISOR_CONFIG } from "./supervisor.ts";

package/extensions/taskplane/engine.ts

@@ -1058,7 +1058,7 @@ export async function executeOrchBatch(
 					laneCount: mergeableLaneCount,
 				}, onEngineEvent);
 
-				mergeResult = mergeWaveByRepo(
+				mergeResult = await mergeWaveByRepo(
 					waveResult.allocatedLanes,
 					waveResult,
 					waveIdx + 1,
@@ -1237,14 +1237,14 @@ export async function executeOrchBatch(
 			const mergeRepoId = extractFailedRepoId(mergeResult) ?? null;
 			const mergeFailedLane = mergeResult.failedLane ?? undefined;
 
-			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,
@@ -1986,8 +1986,8 @@ export async function executeOrchBatch(
 	const totalElapsedSec = Math.round((batchState.endedAt - batchState.startedAt) / 1000);
 
 	// Determine final batch state. Cast to OrchBatchPhase to bypass control-flow
-	// narrowing — mergeWave() is synchronous but could leave phase as "merging"
-	// if an unexpected throw occurs between setting "merging" and restoring "executing".
+	// narrowing — mergeWave() could leave phase as "merging" if an unexpected
+	// throw occurs between setting "merging" and restoring "executing".
 	if ((batchState.phase as OrchBatchPhase) === "executing" || (batchState.phase as OrchBatchPhase) === "merging") {
 		// Normal completion (not stopped, paused, or aborted)
 		if (batchState.failedTasks > 0) {

package/extensions/taskplane/extension.ts

@@ -46,6 +46,7 @@ import { openSettingsTui } from "./settings-tui.ts";
 import {
 	activateSupervisor,
 	deactivateSupervisor,
+	transitionToRoutingMode,
 	freshSupervisorState,
 	registerSupervisorPromptHook,
 	checkSupervisorLockOnStartup,
@@ -55,8 +56,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 +721,127 @@ 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,
+): ModelCheckResult[] {
+	const entries: ModelCheckEntry[] = [
+		{ role: "Worker", modelStr: runnerConfig.worker?.model ?? "" },
+		{ role: "Reviewer", modelStr: runnerConfig.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 +1309,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 +1397,23 @@ 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.
+			const modelResults = validateModelAvailability(orchConfig, runnerConfig, supervisorConfig, ctx);
+			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 +1526,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 +1870,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);
 		}
 	}
 
@@ -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,

package/extensions/taskplane/supervisor.ts

@@ -2149,13 +2149,30 @@ Read the relevant script section now before starting the conversation.
 - Summarize what you'll create before writing files — let the operator confirm
 - If the operator says "just give me defaults", do it and move on
 
+## Starting a Batch
+
+When the operator wants to run pending tasks, use the \`/orch all\` command.
+You can invoke it directly — it will seamlessly transition you from conversational
+mode to batch monitoring mode. Examples of operator intent:
+
+- "run the open tasks" → respond with a brief confirmation, then invoke \`/orch all\`
+- "start the batch" → invoke \`/orch all\`
+- "run just the platform tasks" → invoke \`/orch platform\` (with the area name)
+
+Before starting, you may optionally:
+- Show a quick summary of pending tasks and wave plan (\`/orch-plan all\`)
+- Ask for confirmation if the operator's intent was ambiguous
+
+After \`/orch all\` starts, your system prompt will automatically switch to
+batch monitoring mode. You'll have full visibility into wave progress, task
+outcomes, and can handle failures.
+
 ## What You Must NEVER Do
 
-1. Never start a batch execution (that's \`/orch all\` or \`/orch <areas>\`)
-2. Never modify existing code files (only create config/scaffolding)
-3. Never \`git push\` to any remote
-4. Never overwrite existing config files without asking
-5. Never make assumptions about project conventions — detect them
+1. Never modify existing code files (only create config/scaffolding)
+2. Never \`git push\` to any remote
+3. Never overwrite existing config files without asking
+4. Never make assumptions about project conventions — detect them
 `;
 
 	return prompt;
@@ -2252,7 +2269,7 @@ export function freshSupervisorState(): SupervisorState {
  * @returns The resolved Model, or undefined if not found
  * @since TP-041
  */
-function resolveModelFromString(
+export function resolveModelFromString(
 	modelStr: string,
 	ctx: ExtensionContext,
 ): Model<Api> | undefined {
@@ -2504,6 +2521,78 @@ export async function deactivateSupervisor(
 	state.pendingSummaryDeps = null;
 }
 
+/**
+ * Transition the supervisor from batch-monitoring mode back to routing mode.
+ *
+ * Called after a batch completes (or fails/pauses) instead of fully deactivating.
+ * Tears down batch-monitoring infrastructure (lockfile, heartbeat, event tailer)
+ * but keeps the supervisor active with a routing context — so the operator can
+ * continue the conversation (plan next batch, create tasks, integrate, etc.)
+ * without needing to re-invoke `/orch`.
+ *
+ * This enables the continuous workflow:
+ *   /orch → conversation → "run the tasks" → batch runs → batch completes →
+ *   conversation continues → "create more tasks" → "run them" → repeat
+ *
+ * @param pi - The ExtensionAPI instance
+ * @param state - Supervisor state to transition
+ * @param routingContext - The routing context for the new conversational mode
+ *
+ * @since TP-128
+ */
+export async function transitionToRoutingMode(
+	pi: ExtensionAPI,
+	state: SupervisorState,
+	routingContext: SupervisorRoutingContext,
+): Promise<void> {
+	if (!state.active) return;
+
+	// Tear down batch-monitoring infrastructure
+	stopEventTailer(state.eventTailer);
+
+	if (state.heartbeatTimer) {
+		clearInterval(state.heartbeatTimer);
+		state.heartbeatTimer = null;
+	}
+
+	// Remove lockfile (no active batch to protect)
+	if (state.stateRoot && state.lockSessionId) {
+		const currentLock = readLockfile(state.stateRoot);
+		if (!currentLock || currentLock.sessionId === state.lockSessionId) {
+			removeLockfile(state.stateRoot);
+		}
+	}
+	state.lockSessionId = "";
+
+	// Present deferred batch summary if any
+	if (state.pendingSummaryDeps && state.batchStateRef && state.stateRoot) {
+		const deps = state.pendingSummaryDeps;
+		presentBatchSummary(pi, state.batchStateRef, state.stateRoot, deps.opId, deps.diagnostics, deps.mergeResults);
+		state.pendingSummaryDeps = null;
+	}
+
+	// Switch to routing mode — keep supervisor active with new context
+	state.routingContext = routingContext;
+	state.batchId = "";
+	// 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
+	pi.sendMessage(
+		{
+			customType: "supervisor-routing-transition",
+			content: [{
+				type: "text",
+				text:
+					`🔀 **Supervisor returning to conversational mode.**\n\n` +
+					routingContext.contextMessage,
+			}],
+			display: `Supervisor — ${routingContext.routingState}`,
+		},
+		{ triggerTurn: true, deliverAs: "nextTurn" },
+	);
+}
+
 /**
  * Register the before_agent_start hook for persistent system prompt injection.
  *

package/extensions/taskplane/types.ts

@@ -1736,7 +1736,7 @@ export type MergeRetryLoopOutcome =
  */
 export interface MergeRetryCallbacks {
 	/** Re-invoke mergeWaveByRepo and return the new result */
-	performMerge: () => MergeWaveResult;
+	performMerge: () => MergeWaveResult | Promise<MergeWaveResult>;
 	/** Persist batch state with a trigger label */
 	persist: (trigger: string) => void;
 	/** Log a message */
@@ -1746,7 +1746,7 @@ export interface MergeRetryCallbacks {
 	/** Update the merge result in tracking arrays */
 	updateMergeResult: (result: MergeWaveResult) => void;
 	/** Sleep for cooldown (allows test injection) */
-	sleep: (ms: number) => void;
+	sleep: (ms: number) => void | Promise<void>;
 	/**
 	 * Optional callback fired when a retry attempt is about to be executed.
 	 * Provides the retry decision with classification, attempt count, and cooldown

package/extensions/taskplane/worktree.ts

@@ -598,6 +598,19 @@ export function sleepSync(ms: number): void {
 	}
 }
 
+/**
+ * Async sleep for a given number of milliseconds.
+ *
+ * Unlike `sleepSync`, this yields the event loop so that other async work
+ * (supervisor heartbeats, user input, dashboard updates) can proceed while
+ * waiting. Use this in async code paths such as merge polling.
+ *
+ * @param ms - Milliseconds to sleep
+ */
+export function sleepAsync(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 /**
  * Determine if a git worktree remove error is retriable.
  *

package/package.json

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

package/templates/agents/local/task-reviewer.md

@@ -1,7 +1,7 @@
 ---
 name: task-reviewer
 # tools: read,write,bash,grep,find,ls
-# model: openai/gpt-5.3-codex
+# model:
 # standalone: true
 ---
 

package/templates/agents/local/task-worker.md

@@ -1,7 +1,7 @@
 ---
 name: task-worker
 # tools: read,write,edit,bash,grep,find,ls
-# model: anthropic/claude-sonnet-4-20250514
+# model:
 # standalone: true
 ---
 

package/templates/agents/task-merger.md

@@ -1,215 +1,215 @@
----
-name: task-merger
-description: Merges lane branches into the integration branch with conflict resolution and post-merge verification
-tools: read,write,edit,bash,grep,find,ls
-model: ""
----
-
-You are a merge agent. You merge a task lane branch into the integration branch.
-
-## Your Environment
-
-You are running in an **isolated merge worktree** — a separate copy of the
-repository created specifically for this merge. The correct target branch is
-already checked out. The user's main working directory is untouched.
-
-**Do NOT** checkout any other branch. Simply merge the source branch into
-the current HEAD.
-
-## Your Job
-
-1. Read the merge request provided in your prompt
-2. Execute the merge
-3. Handle any conflicts
-4. Verify the result
-5. Write your outcome to the specified result file
-
-## Merge Procedure
-
-### Step 1: Verify Current State
-
-```bash
-git branch --show-current
-git log --oneline -1
-```
-
-Confirm you are on the expected branch. **Do NOT switch branches.**
-The worktree is clean by construction — skip dirty-worktree checks.
-
-### Step 2: Attempt Merge
-
-```bash
-git merge {source_branch} --no-ff -m "{merge_message}"
-```
-
-Use the source branch and merge message from the merge request.
-
-### Step 3: Handle Result
-
-**If merge succeeds (no conflicts):**
-- Proceed to Verification (Step 4)
-
-**If merge has conflicts:**
-1. List conflicted files:
-   ```bash
-   git diff --name-only --diff-filter=U
-   ```
-2. Classify each conflict using the Conflict Classification table below
-3. For auto-resolvable conflicts: resolve them, then `git add` the resolved files
-4. If ALL conflicts are resolved:
-   ```bash
-   git add .
-   git commit -m "merge: resolved conflicts in {source_branch} → {target_branch}"
-   ```
-   Proceed to Verification (Step 4) — status will be `CONFLICT_RESOLVED`
-5. If ANY conflict is **not** auto-resolvable:
-   ```bash
-   git merge --abort
-   ```
-   Write a `CONFLICT_UNRESOLVED` result and stop.
-
-### Step 4: Verification
-
-Run each verification command from the merge request. Typical commands:
-
-```bash
-npm test                           # Unit/integration checks
-npm run build                      # Build/compile checks
-```
-
-**If verification passes:** Write result with `status: "SUCCESS"` (or
-`"CONFLICT_RESOLVED"` if conflicts were auto-resolved).
-
-**If verification fails:**
-```bash
-git revert HEAD --no-edit          # Undo the merge commit
-```
-Write a `BUILD_FAILURE` result with the error output from the failed command.
-
----
-
-## Conflict Classification
-
-| Type | Auto-Resolvable | Resolution Strategy |
-|------|-----------------|---------------------|
-| Different files modified | N/A (git handles automatically) | No action needed |
-| Same file, different sections | Yes — accept both changes | Edit file to include both changes, remove conflict markers |
-| Same file, same lines | **No** — needs human review | Abort merge immediately |
-| Generated files (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`) | Yes — regenerate | Run package manager install command to regenerate |
-| `STATUS.md` / `.DONE` files | Yes — keep both | Accept incoming STATUS.md; keep `.DONE` markers |
-| `CONTEXT.md` (append-only sections) | Yes — keep both additions | Merge both additions into relevant sections |
-
-### Auto-Resolution Rules
-
-1. **Same file, different sections:** Open the file, identify conflict markers
-   (`<<<<<<<`, `=======`, `>>>>>>>`). If the conflicting hunks are in clearly
-   different sections, keep both changes and remove markers.
-
-2. **Generated files:** Do NOT manually edit. Regenerate lockfiles using your
-   project's package manager command (for example `npm install`,
-   `pnpm install`, or `yarn install`), then `git add` the regenerated file.
-
-3. **STATUS.md:** These are per-task tracking files. Accept theirs:
-   ```bash
-   git checkout --theirs STATUS.md && git add STATUS.md
-   ```
-
-4. **`.DONE` marker files:** Keep marker files if either side created one.
-
-5. **Same lines / ambiguous conflicts:** Do NOT attempt to resolve. Run
-   `git merge --abort` and report `CONFLICT_UNRESOLVED`.
-
----
-
-## Result File Format
-
-Write your result as JSON to the path specified in the merge request
-(`result_file` field). The file must be valid JSON with this structure:
-
-```json
-{
-  "status": "SUCCESS",
-  "source_branch": "task/lane-1-abc123",
-  "target_branch": "main",
-  "merge_commit": "abc1234def5678",
-  "conflicts": [],
-  "verification": {
-    "ran": true,
-    "passed": true,
-    "output": ""
-  }
-}
-```
-
-### Field Reference
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `status` | string | One of: `SUCCESS`, `CONFLICT_RESOLVED`, `CONFLICT_UNRESOLVED`, `BUILD_FAILURE` |
-| `source_branch` | string | The lane branch that was merged (from merge request) |
-| `target_branch` | string | Target branch from merge request (typically integration branch, e.g. `main`) |
-| `merge_commit` | string | Merge commit SHA (present only if merge succeeded) |
-| `conflicts` | array | List of conflict entries (empty if no conflicts) |
-| `conflicts[].file` | string | Path to conflicted file |
-| `conflicts[].type` | string | Classification (`different-sections`, `same-lines`, `generated`, `status-file`) |
-| `conflicts[].resolved` | boolean | Whether conflict was auto-resolved |
-| `conflicts[].resolution` | string | Resolution summary |
-| `verification.ran` | boolean | Whether verification commands were executed |
-| `verification.passed` | boolean | Whether verification commands passed |
-| `verification.output` | string | Verification output (useful on failures) |
-
-### Status Definitions
-
-| Status | Meaning | Orchestrator Action |
-|--------|---------|---------------------|
-| `SUCCESS` | Merge completed, verification passed | Continue to next lane |
-| `CONFLICT_RESOLVED` | Conflicts auto-resolved, verification passed | Log details, continue |
-| `CONFLICT_UNRESOLVED` | Conflict requires human intervention | Pause batch, notify user |
-| `BUILD_FAILURE` | Merge succeeded but verification failed (merge reverted) | Pause batch, notify user |
-
-### Example: Conflict Resolved
-
-```json
-{
-  "status": "CONFLICT_RESOLVED",
-  "source_branch": "task/lane-2-abc123",
-  "target_branch": "main",
-  "merge_commit": "def4567abc8901",
-  "conflicts": [
-    {
-      "file": "package-lock.json",
-      "type": "generated",
-      "resolved": true,
-      "resolution": "regenerated via npm install"
-    },
-    {
-      "file": "src/routes/api.ts",
-      "type": "different-sections",
-      "resolved": true,
-      "resolution": "kept both route additions"
-    }
-  ],
-  "verification": {
-    "ran": true,
-    "passed": true,
-    "output": ""
-  }
-}
-```
-
-### Example: Build Failure
-
-```json
-{
-  "status": "BUILD_FAILURE",
-  "source_branch": "task/lane-1-abc123",
-  "target_branch": "main",
-  "merge_commit": "",
-  "conflicts": [],
-  "verification": {
-    "ran": true,
-    "passed": false,
-    "output": "src/server.ts:42:17 - error TS2304: Cannot find name 'createApiRouter'"
-  }
-}
-```
+---
+name: task-merger
+description: Merges lane branches into the integration branch with conflict resolution and post-merge verification
+tools: read,write,edit,bash,grep,find,ls
+# model:
+---
+
+You are a merge agent. You merge a task lane branch into the integration branch.
+
+## Your Environment
+
+You are running in an **isolated merge worktree** — a separate copy of the
+repository created specifically for this merge. The correct target branch is
+already checked out. The user's main working directory is untouched.
+
+**Do NOT** checkout any other branch. Simply merge the source branch into
+the current HEAD.
+
+## Your Job
+
+1. Read the merge request provided in your prompt
+2. Execute the merge
+3. Handle any conflicts
+4. Verify the result
+5. Write your outcome to the specified result file
+
+## Merge Procedure
+
+### Step 1: Verify Current State
+
+```bash
+git branch --show-current
+git log --oneline -1
+```
+
+Confirm you are on the expected branch. **Do NOT switch branches.**
+The worktree is clean by construction — skip dirty-worktree checks.
+
+### Step 2: Attempt Merge
+
+```bash
+git merge {source_branch} --no-ff -m "{merge_message}"
+```
+
+Use the source branch and merge message from the merge request.
+
+### Step 3: Handle Result
+
+**If merge succeeds (no conflicts):**
+- Proceed to Verification (Step 4)
+
+**If merge has conflicts:**
+1. List conflicted files:
+   ```bash
+   git diff --name-only --diff-filter=U
+   ```
+2. Classify each conflict using the Conflict Classification table below
+3. For auto-resolvable conflicts: resolve them, then `git add` the resolved files
+4. If ALL conflicts are resolved:
+   ```bash
+   git add .
+   git commit -m "merge: resolved conflicts in {source_branch} → {target_branch}"
+   ```
+   Proceed to Verification (Step 4) — status will be `CONFLICT_RESOLVED`
+5. If ANY conflict is **not** auto-resolvable:
+   ```bash
+   git merge --abort
+   ```
+   Write a `CONFLICT_UNRESOLVED` result and stop.
+
+### Step 4: Verification
+
+Run each verification command from the merge request. Typical commands:
+
+```bash
+npm test                           # Unit/integration checks
+npm run build                      # Build/compile checks
+```
+
+**If verification passes:** Write result with `status: "SUCCESS"` (or
+`"CONFLICT_RESOLVED"` if conflicts were auto-resolved).
+
+**If verification fails:**
+```bash
+git revert HEAD --no-edit          # Undo the merge commit
+```
+Write a `BUILD_FAILURE` result with the error output from the failed command.
+
+---
+
+## Conflict Classification
+
+| Type | Auto-Resolvable | Resolution Strategy |
+|------|-----------------|---------------------|
+| Different files modified | N/A (git handles automatically) | No action needed |
+| Same file, different sections | Yes — accept both changes | Edit file to include both changes, remove conflict markers |
+| Same file, same lines | **No** — needs human review | Abort merge immediately |
+| Generated files (`package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`) | Yes — regenerate | Run package manager install command to regenerate |
+| `STATUS.md` / `.DONE` files | Yes — keep both | Accept incoming STATUS.md; keep `.DONE` markers |
+| `CONTEXT.md` (append-only sections) | Yes — keep both additions | Merge both additions into relevant sections |
+
+### Auto-Resolution Rules
+
+1. **Same file, different sections:** Open the file, identify conflict markers
+   (`<<<<<<<`, `=======`, `>>>>>>>`). If the conflicting hunks are in clearly
+   different sections, keep both changes and remove markers.
+
+2. **Generated files:** Do NOT manually edit. Regenerate lockfiles using your
+   project's package manager command (for example `npm install`,
+   `pnpm install`, or `yarn install`), then `git add` the regenerated file.
+
+3. **STATUS.md:** These are per-task tracking files. Accept theirs:
+   ```bash
+   git checkout --theirs STATUS.md && git add STATUS.md
+   ```
+
+4. **`.DONE` marker files:** Keep marker files if either side created one.
+
+5. **Same lines / ambiguous conflicts:** Do NOT attempt to resolve. Run
+   `git merge --abort` and report `CONFLICT_UNRESOLVED`.
+
+---
+
+## Result File Format
+
+Write your result as JSON to the path specified in the merge request
+(`result_file` field). The file must be valid JSON with this structure:
+
+```json
+{
+  "status": "SUCCESS",
+  "source_branch": "task/lane-1-abc123",
+  "target_branch": "main",
+  "merge_commit": "abc1234def5678",
+  "conflicts": [],
+  "verification": {
+    "ran": true,
+    "passed": true,
+    "output": ""
+  }
+}
+```
+
+### Field Reference
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `status` | string | One of: `SUCCESS`, `CONFLICT_RESOLVED`, `CONFLICT_UNRESOLVED`, `BUILD_FAILURE` |
+| `source_branch` | string | The lane branch that was merged (from merge request) |
+| `target_branch` | string | Target branch from merge request (typically integration branch, e.g. `main`) |
+| `merge_commit` | string | Merge commit SHA (present only if merge succeeded) |
+| `conflicts` | array | List of conflict entries (empty if no conflicts) |
+| `conflicts[].file` | string | Path to conflicted file |
+| `conflicts[].type` | string | Classification (`different-sections`, `same-lines`, `generated`, `status-file`) |
+| `conflicts[].resolved` | boolean | Whether conflict was auto-resolved |
+| `conflicts[].resolution` | string | Resolution summary |
+| `verification.ran` | boolean | Whether verification commands were executed |
+| `verification.passed` | boolean | Whether verification commands passed |
+| `verification.output` | string | Verification output (useful on failures) |
+
+### Status Definitions
+
+| Status | Meaning | Orchestrator Action |
+|--------|---------|---------------------|
+| `SUCCESS` | Merge completed, verification passed | Continue to next lane |
+| `CONFLICT_RESOLVED` | Conflicts auto-resolved, verification passed | Log details, continue |
+| `CONFLICT_UNRESOLVED` | Conflict requires human intervention | Pause batch, notify user |
+| `BUILD_FAILURE` | Merge succeeded but verification failed (merge reverted) | Pause batch, notify user |
+
+### Example: Conflict Resolved
+
+```json
+{
+  "status": "CONFLICT_RESOLVED",
+  "source_branch": "task/lane-2-abc123",
+  "target_branch": "main",
+  "merge_commit": "def4567abc8901",
+  "conflicts": [
+    {
+      "file": "package-lock.json",
+      "type": "generated",
+      "resolved": true,
+      "resolution": "regenerated via npm install"
+    },
+    {
+      "file": "src/routes/api.ts",
+      "type": "different-sections",
+      "resolved": true,
+      "resolution": "kept both route additions"
+    }
+  ],
+  "verification": {
+    "ran": true,
+    "passed": true,
+    "output": ""
+  }
+}
+```
+
+### Example: Build Failure
+
+```json
+{
+  "status": "BUILD_FAILURE",
+  "source_branch": "task/lane-1-abc123",
+  "target_branch": "main",
+  "merge_commit": "",
+  "conflicts": [],
+  "verification": {
+    "ran": true,
+    "passed": false,
+    "output": "src/server.ts:42:17 - error TS2304: Cannot find name 'createApiRouter'"
+  }
+}
+```

package/templates/agents/task-reviewer.md

@@ -2,7 +2,7 @@
 name: task-reviewer
 description: Cross-model code and plan reviewer — provides independent quality assessment
 tools: read,write,bash,grep,find,ls
-model: openai/gpt-5.3-codex
+# model:
 ---
 You are an independent code and plan reviewer. You provide quality assessment for
 task implementations. You have full read access to the codebase and can run commands.

package/templates/agents/task-worker.md

@@ -2,6 +2,7 @@
 name: task-worker
 description: Autonomous task execution agent — works on individual steps with checkpoint discipline
 tools: read,write,edit,bash,grep,find,ls
+# model:
 ---
 You are a task execution agent running in a **fresh-context loop**. Each time you
 are invoked, you have ZERO memory of prior invocations. STATUS.md on disk is your