taskplane 0.7.2 → 0.8.0

package/dashboard/public/app.js

@@ -17,9 +17,11 @@ function formatDuration(ms) {
   return `${m}m ${String(s).padStart(2, "0")}s`;
 }
 
-function relativeTime(epochMs) {
-  if (!epochMs) return "";
-  const diff = Date.now() - epochMs;
+function relativeTime(epochOrIso) {
+  if (!epochOrIso) return "";
+  const ts = typeof epochOrIso === "string" ? new Date(epochOrIso).getTime() : epochOrIso;
+  if (isNaN(ts)) return "";
+  const diff = Date.now() - ts;
   if (diff < 60000) return `${Math.floor(diff / 1000)}s ago`;
   if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
   return `${Math.floor(diff / 3600000)}h ago`;
@@ -711,17 +713,16 @@ function renderNoBatch() {
   if ($mergePanel) $mergePanel.style.display = "none";
   if ($errorsPanel) $errorsPanel.style.display = "none";
 
-  // Try to show the latest history entry
-  if (historyList.length > 0 && !viewingHistoryId) {
-    viewHistoryEntry(historyList[0].batchId);
-    $historySelect.value = historyList[0].batchId;
-  } else if (historyList.length === 0) {
-    // No history yet — show placeholder in the history panel
+  // Show a placeholder while history loads. loadHistoryList() (called in
+  // render() just before this) is async — the fresh list may not be
+  // available yet. The loadHistoryList callback will replace this with
+  // the actual latest entry once it resolves.
+  if (!viewingHistoryId) {
     $historyBody.innerHTML = `
       <div class="no-batch">
         <div class="no-batch-icon">⏳</div>
-        <div class="no-batch-title">No batch running</div>
-        <div class="no-batch-hint">.pi/batch-state.json not found<br>Start an orchestrator batch to see the dashboard.</div>
+        <div class="no-batch-title">Batch complete</div>
+        <div class="no-batch-hint">Loading history…</div>
       </div>`;
     $historyPanel.style.display = "";
   }
@@ -1405,10 +1406,22 @@ function loadHistoryList() {
     .then(list => {
       historyList = list || [];
       renderHistoryDropdown();
-      // If no live batch and no history shown yet, auto-select latest
-      if (noBatchRendered && !viewingHistoryId && historyList.length > 0) {
+      // Auto-select the latest history entry when no live batch is running.
+      // Always update the view here — renderNoBatch() shows a placeholder
+      // while this async fetch completes, so we need to replace it with
+      // the actual latest entry. This fixes #20 where the stale cached
+      // historyList caused the previous batch to be shown.
+      if (noBatchRendered && historyList.length > 0) {
         viewHistoryEntry(historyList[0].batchId);
         $historySelect.value = historyList[0].batchId;
+      } else if (noBatchRendered && historyList.length === 0) {
+        $historyBody.innerHTML = `
+          <div class="no-batch">
+            <div class="no-batch-icon">⏳</div>
+            <div class="no-batch-title">No batch running</div>
+            <div class="no-batch-hint">.pi/batch-state.json not found<br>Start an orchestrator batch to see the dashboard.</div>
+          </div>`;
+        $historyPanel.style.display = "";
       }
     })
     .catch(() => {});

package/extensions/task-runner.ts

@@ -164,7 +164,7 @@ const DEFAULT_CONFIG: TaskConfig = {
 	worker: { model: "", tools: "read,write,edit,bash,grep,find,ls", thinking: "off" },
 	reviewer: { model: "openai/gpt-5.3-codex", tools: "read,bash,grep,find,ls", thinking: "on" },
 	context: {
-		worker_context_window: 200000, warn_percent: 70, kill_percent: 85,
+		worker_context_window: 0, warn_percent: 85, kill_percent: 95,
 		max_worker_iterations: 20, max_review_cycles: 2, no_progress_limit: 3,
 	},
 	quality_gate: {
@@ -309,6 +309,46 @@ function getMaxWorkerMinutes(config: TaskConfig): number {
 	return 30;
 }
 
+// ── Context Window Resolution ─────────────────────────────────────────
+
+/** Default fallback context window when neither config nor model provides a value. */
+const FALLBACK_CONTEXT_WINDOW = 200_000;
+
+/**
+ * Resolve the effective context window size for worker spawning.
+ *
+ * Resolution order (first non-zero value wins):
+ *   1. Explicit user config (worker_context_window > 0 in config)
+ *   2. Auto-detect from pi model registry (ctx.model.contextWindow)
+ *   3. Fallback to 200K tokens
+ *
+ * A config value of 0 signals "auto-detect" — the default when no explicit
+ * value is configured. This allows pi's model registry to provide the real
+ * context window for the active model.
+ *
+ * @returns Object with `contextWindow` (resolved size) and `source` (diagnostic label)
+ */
+function resolveContextWindow(
+	config: TaskConfig,
+	ctx: ExtensionContext,
+): { contextWindow: number; source: string } {
+	// 1. Explicit user config — non-zero means the user set it deliberately
+	const configVal = config.context.worker_context_window;
+	if (configVal > 0) {
+		return { contextWindow: configVal, source: "explicit config" };
+	}
+
+	// 2. Auto-detect from pi model registry
+	const modelWindow = ctx.model?.contextWindow;
+	if (modelWindow && modelWindow > 0) {
+		const modelId = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "unknown";
+		return { contextWindow: modelWindow, source: `auto-detected from ${modelId}` };
+	}
+
+	// 3. Fallback
+	return { contextWindow: FALLBACK_CONTEXT_WINDOW, source: `fallback ${FALLBACK_CONTEXT_WINDOW}` };
+}
+
 // ── Orchestrator Sidecar Files ────────────────────────────────────────
 
 /**
@@ -876,6 +916,27 @@ function getHeadCommitSha(): string {
 	}
 }
 
+/**
+ * Find the git commit SHA where a specific step was completed.
+ * Workers commit at step boundaries with messages like:
+ *   feat(TP-048): complete Step N — description
+ * Returns the commit SHA if found, or empty string.
+ */
+function findStepBoundaryCommit(stepNumber: number, taskId: string, since?: string): string {
+	try {
+		// Search git log for the step completion commit
+		const args = ["log", "--oneline", "--grep", `complete Step ${stepNumber}`, "--grep", taskId, "--all-match", "-1", "--format=%H"];
+		if (since) args.push(`${since}..HEAD`);
+		const result = spawnSync("git", args, {
+			encoding: "utf-8",
+			timeout: 5000,
+		});
+		return result.status === 0 ? (result.stdout || "").trim() : "";
+	} catch {
+		return "";
+	}
+}
+
 // ── Standards Resolution ─────────────────────────────────────────────
 
 /**
@@ -1296,6 +1357,8 @@ function tailSidecarJsonl(filePath: string, tailState: SidecarTailState): Sideca
 export const _tailSidecarJsonl = tailSidecarJsonl;
 export const _createSidecarTailState = createSidecarTailState;
 export const _getSidecarDir = getSidecarDir;
+export const _resolveContextWindow = resolveContextWindow;
+export const _FALLBACK_CONTEXT_WINDOW = FALLBACK_CONTEXT_WINDOW;
 export type { SidecarTailState, SidecarTelemetryDelta };
 
 // ── Exit Summary & Diagnostic ────────────────────────────────────────
@@ -1907,29 +1970,266 @@ export default function (pi: ExtensionAPI) {
 		updateStatusField(statusPath, "Last Updated", new Date().toISOString().slice(0, 10));
 		logExecution(statusPath, "Task started", "Extension-driven execution");
 
-		// Find first incomplete step
-		const status = parseStatusMd(readFileSync(statusPath, "utf-8"));
-		let startStep = 0;
-		for (const s of status.steps) {
-			if (s.status === "complete") startStep = s.number + 1;
-			else break;
+		// ── Per-task worker loop ─────────────────────────────────────
+		// Spawn one worker per iteration; each worker handles ALL remaining
+		// steps.  Reviews run after the worker exits, per newly-completed step.
+		// If context limit is hit mid-task, the next iteration picks up from
+		// the first incomplete step via STATUS.md — same recovery mechanism.
+
+		// Collect baseline commits per step (for code review diffs).
+		// Baselines are updated at step boundaries so each code review
+		// sees only that step's changes, not cumulative diffs.
+		const stepBaselineCommits = new Map<number, string>();
+
+		// Track steps that received a REVISE verdict and need rework.
+		// This prevents the checkbox-count heuristic from re-completing them
+		// before the worker has had a chance to address reviewer feedback.
+		const needsRework = new Set<number>();
+
+		// Track which steps have already received a plan review so we don't
+		// re-run plan review on rework cycles (only code review reruns).
+		const planReviewedSteps = new Set<number>();
+
+		// Mark all incomplete steps as in-progress and capture the baseline
+		// commit for the first one. Reviews are transition-based: they run
+		// when a step newly completes after the worker exits, not up-front.
+		{
+			const currentStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
+			for (const step of task.steps) {
+				const ss = currentStatus.steps.find(s => s.number === step.number);
+				if (ss?.status === "complete") continue;
+
+				// Mark step as in-progress and log its start
+				updateStepStatus(statusPath, step.number, "in-progress");
+				logExecution(statusPath, `Step ${step.number} started`, step.name);
+
+				// Capture baseline commit for the FIRST incomplete step only.
+				// Later steps get their baselines when the prior step completes
+				// (see the newlyCompleted handler in the iteration loop).
+				// This prevents cross-step diff bleeding in code reviews.
+				if (!stepBaselineCommits.size) {
+					stepBaselineCommits.set(step.number, getHeadCommitSha());
+				}
+			}
 		}
 
-		for (let i = 0; i < task.steps.length; i++) {
-			const step = task.steps[i];
-			if (step.number < startStep) continue;
+		// Helper: determine if a parsed step is complete.
+		// A step in needsRework (set after REVISE) is never complete, even if
+		// all checkboxes are checked — the worker must address the feedback first.
+		function isStepComplete(ss: StepInfo | undefined): boolean {
+			if (!ss) return false;
+			if (needsRework.has(ss.number)) return false;
+			if (ss.status === "complete") return true;
+			// Fallback: infer from checkboxes (covers "in-progress" and "not-started")
+			return ss.totalChecked === ss.totalItems && ss.totalItems > 0;
+		}
+
+		let noProgressCount = 0;
+		for (let iter = 0; iter < config.context.max_worker_iterations; iter++) {
 			if (state.phase === "paused") {
-				logExecution(statusPath, "Paused", `User paused at Step ${step.number}`);
-				ctx.ui.notify(`Task paused at Step ${step.number}`, "info");
+				logExecution(statusPath, "Paused", `User paused at iteration ${iter + 1}`);
+				ctx.ui.notify(`Task paused at iteration ${iter + 1}`, "info");
 				return;
 			}
 
-			state.currentStep = step.number;
+			// Determine remaining (incomplete) steps
+			const currentStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
+			const remainingSteps: StepInfo[] = [];
+			for (const step of task.steps) {
+				const ss = currentStatus.steps.find(s => s.number === step.number);
+				if (!isStepComplete(ss)) remainingSteps.push(step);
+			}
+
+			if (remainingSteps.length === 0) break; // All steps done
+
+			state.currentStep = remainingSteps[0].number;
+			updateStatusField(statusPath, "Current Step", `Step ${remainingSteps[0].number}: ${remainingSteps[0].name}`);
+			state.workerIteration = iter + 1;
+			state.totalIterations++;
+			updateStatusField(statusPath, "Iteration", `${state.totalIterations}`);
 			updateWidgets();
 
-			await executeStep(step, ctx);
+			// Count total checked checkboxes across all steps BEFORE worker runs
+			const prevTotalChecked = currentStatus.steps.reduce((sum, s) => sum + s.totalChecked, 0);
+
+			// Track which steps are complete before the worker runs
+			const completedBefore = new Set<number>();
+			for (const ss of currentStatus.steps) {
+				if (isStepComplete(ss)) completedBefore.add(ss.number);
+			}
+
+			// Ensure the first remaining step has a baseline. On subsequent
+			// iterations (after context-limit recovery), the first remaining step
+			// may not have a baseline yet if it wasn't the first step originally.
+			if (remainingSteps.length > 0 && !stepBaselineCommits.has(remainingSteps[0].number)) {
+				stepBaselineCommits.set(remainingSteps[0].number, getHeadCommitSha());
+			}
+
+			await runWorker(remainingSteps, ctx);
+
+			if (state.phase === "error") return;
 
-			if (state.phase === "error" || state.phase === "paused") return;
+			// ── Post-worker: determine which steps were newly completed ──
+			const afterStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
+			const afterTotalChecked = afterStatus.steps.reduce((sum, s) => sum + s.totalChecked, 0);
+
+			// Progress tracking: compare total checked across ALL steps
+			const progressDelta = afterTotalChecked - prevTotalChecked;
+			if (progressDelta <= 0) {
+				noProgressCount++;
+				logExecution(statusPath, "No progress", `Iteration ${iter + 1}: 0 new checkboxes (${noProgressCount}/${config.context.no_progress_limit} stall limit)`);
+				ctx.ui.notify(`⚠️ No progress in iteration ${iter + 1} (${noProgressCount}/${config.context.no_progress_limit})`, "warning");
+				if (noProgressCount >= config.context.no_progress_limit) {
+					logExecution(statusPath, "Task blocked", `No progress after ${noProgressCount} iterations`);
+					ctx.ui.notify(`⚠️ Task blocked — no progress after ${noProgressCount} iterations`, "error");
+					state.phase = "error";
+					return;
+				}
+			} else {
+				noProgressCount = 0;
+			}
+
+			// Find newly completed steps.
+			// For steps in needsRework, the worker must have addressed the
+			// reviewer feedback — we detect this by checking if STATUS.md was
+			// updated (the worker adds/checks revision items). We temporarily
+			// remove the step from needsRework to let isStepComplete() evaluate
+			// the checkbox state, then re-add if it's still not complete.
+			const newlyCompleted: StepInfo[] = [];
+			for (const step of task.steps) {
+				if (completedBefore.has(step.number)) continue;
+				const ss = afterStatus.steps.find(s => s.number === step.number);
+				if (needsRework.has(step.number)) {
+					// For rework steps, check if the worker set status to "complete"
+					// or if the step now has all checkboxes checked (worker addressed feedback)
+					if (ss?.status === "complete" ||
+						(ss && ss.totalChecked === ss.totalItems && ss.totalItems > 0)) {
+						needsRework.delete(step.number);
+						updateStepStatus(statusPath, step.number, "complete");
+						logExecution(statusPath, `Step ${step.number} complete`, `${step.name} (rework)`);
+						newlyCompleted.push(step);
+					}
+				} else if (isStepComplete(ss)) {
+					updateStepStatus(statusPath, step.number, "complete");
+					logExecution(statusPath, `Step ${step.number} complete`, step.name);
+					newlyCompleted.push(step);
+				}
+			}
+
+			// Update baselines for subsequent steps using step boundary commits.
+			// When the worker completes multiple steps in one iteration, each step's
+			// commit becomes the baseline for the next step's code review.
+			if (newlyCompleted.length > 1) {
+				for (let i = 0; i < newlyCompleted.length; i++) {
+					const completedStep = newlyCompleted[i];
+					const boundaryCommit = findStepBoundaryCommit(
+						completedStep.number, task.taskId,
+						stepBaselineCommits.get(completedStep.number)
+					);
+					if (boundaryCommit && i + 1 < newlyCompleted.length) {
+						// Use this step's completion commit as the next step's baseline
+						stepBaselineCommits.set(newlyCompleted[i + 1].number, boundaryCommit);
+					}
+				}
+			}
+
+			// Log iteration summary with progress delta and completed steps
+			const completedNames = newlyCompleted.map(s => `Step ${s.number}`).join(", ");
+			if (newlyCompleted.length > 0) {
+				logExecution(statusPath, `Iteration ${iter + 1} summary`, `+${progressDelta} checkboxes, completed: ${completedNames}`);
+				ctx.ui.notify(`Iteration ${iter + 1}: completed ${completedNames} (+${progressDelta} checkboxes)`, "info");
+			} else if (progressDelta > 0) {
+				logExecution(statusPath, `Iteration ${iter + 1} summary`, `+${progressDelta} checkboxes, no steps fully completed`);
+				ctx.ui.notify(`Iteration ${iter + 1}: +${progressDelta} checkboxes (no steps fully completed)`, "info");
+			}
+
+			// ── Run reviews for newly completed steps (transition-based) ──
+			// Plan reviews run once per step (first completion); code reviews
+			// run on every completion (including rework). Both respect review
+			// level and low-risk skip logic.
+			// Gate on phase !== "error" so reviews still run when paused
+			// (pause is honored after reviews, before next iteration).
+			if (state.phase !== "error") {
+				for (const step of newlyCompleted) {
+					const lowRisk = isLowRiskStep(step.number, task.steps.length);
+
+					// ── Plan review (level ≥ 1, first completion only) ──
+					if (task.reviewLevel >= 1 && !planReviewedSteps.has(step.number)) {
+						if (lowRisk) {
+							const label = step.number === 0 ? "Preflight" : "final step";
+							logExecution(statusPath, `Skip plan review`, `Step ${step.number} (${label}) — low-risk`);
+							ctx.ui.notify(`⏭️ Skipping plan review for Step ${step.number} (${label})`, "info");
+						} else {
+							const verdict = await doReview("plan", step, ctx);
+							if (verdict === "RETHINK") {
+								ctx.ui.notify(`Reviewer: RETHINK on Step ${step.number} plan. Proceeding with caution.`, "warning");
+							}
+						}
+						planReviewedSteps.add(step.number);
+					}
+
+					// ── Code review (level ≥ 2) ──
+					if (task.reviewLevel >= 2) {
+						if (lowRisk) {
+							const label = step.number === 0 ? "Preflight" : "final step";
+							logExecution(statusPath, `Skip code review`, `Step ${step.number} (${label}) — low-risk`);
+							ctx.ui.notify(`⏭️ Skipping code review for Step ${step.number} (${label})`, "info");
+						} else {
+							const baseline = stepBaselineCommits.get(step.number);
+							const verdict = await doReview("code", step, ctx, baseline);
+							if (verdict === "REVISE") {
+								ctx.ui.notify(`Reviewer: REVISE on Step ${step.number}. Will rework in next iteration.`, "warning");
+								// Mark step as needing rework — undo the "complete" status.
+								// needsRework ensures isStepComplete() won't re-complete this
+								// step based on checkbox counts alone; the worker must address
+								// the reviewer feedback first, which will update STATUS.md and
+								// clear the rework flag when the step is newly completed again.
+								needsRework.add(step.number);
+								updateStepStatus(statusPath, step.number, "in-progress");
+								// Update baseline so the next code review for this step
+								// diffs only the rework changes, not the original step work
+								stepBaselineCommits.set(step.number, getHeadCommitSha());
+							}
+						}
+					}
+				}
+			}
+
+			// Update local cache
+			const refreshed = parseStatusMd(readFileSync(statusPath, "utf-8"));
+			for (const s of refreshed.steps) state.stepStatuses.set(s.number, s);
+			updateWidgets();
+
+			// Check if all steps are now complete
+			const allComplete = task.steps.every(step => {
+				const ss = refreshed.steps.find(s => s.number === step.number);
+				return isStepComplete(ss);
+			});
+			if (allComplete) break;
+		}
+
+		// ── Post-loop safety check: ensure all steps are actually complete ──
+		// If the iteration cap was hit without completing all steps, fail explicitly
+		// rather than falling through to quality gate / .DONE creation.
+		if (state.phase === "running") {
+			const finalStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
+			const allStepsComplete = task.steps.every(step => {
+				const ss = finalStatus.steps.find(s => s.number === step.number);
+				return isStepComplete(ss);
+			});
+			if (!allStepsComplete) {
+				const incomplete = task.steps
+					.filter(step => {
+						const ss = finalStatus.steps.find(s => s.number === step.number);
+						return !isStepComplete(ss);
+					})
+					.map(s => `Step ${s.number}`)
+					.join(", ");
+				logExecution(statusPath, "Task incomplete", `Max iterations (${config.context.max_worker_iterations}) reached with incomplete steps: ${incomplete}`);
+				ctx.ui.notify(`⚠️ Task incomplete — max iterations reached. Incomplete: ${incomplete}`, "error");
+				state.phase = "error";
+				return;
+			}
 		}
 
 		// All steps done — run quality gate if enabled, then create .DONE
@@ -2079,111 +2379,9 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.notify(`✅ Task ${task.taskId} complete!`, "success");
 	}
 
-	async function executeStep(step: StepInfo, ctx: ExtensionContext): Promise<void> {
-		if (!state.task || !state.config) return;
-
-		const task = state.task;
-		const config = state.config;
-		const statusPath = join(task.taskFolder, "STATUS.md");
-
-		// Capture git HEAD before the step starts so code reviewers can
-		// diff the full step's changes (workers commit via checkpoints).
-		const stepBaselineCommit = getHeadCommitSha();
-
-		updateStepStatus(statusPath, step.number, "in-progress");
-		updateStatusField(statusPath, "Current Step", `Step ${step.number}: ${step.name}`);
-		logExecution(statusPath, `Step ${step.number} started`, step.name);
-		updateWidgets();
-
-		// Skip reviews for low-risk steps (Step 0 / Preflight and final step / Delivery)
-		const _isLowRiskStep = isLowRiskStep(step.number, task.steps.length);
-
-		// Plan review (level ≥ 1)
-		if (task.reviewLevel >= 1) {
-			if (_isLowRiskStep) {
-				const label = step.number === 0 ? "Preflight" : "final step";
-				logExecution(statusPath, `Skip plan review`, `Step ${step.number} (${label}) — low-risk`);
-				ctx.ui.notify(`⏭️ Skipping plan review for Step ${step.number} (${label})`, "info");
-			} else {
-				const verdict = await doReview("plan", step, ctx, stepBaselineCommit);
-				if (verdict === "RETHINK") {
-					ctx.ui.notify(`Reviewer: RETHINK on Step ${step.number} plan. Proceeding with caution.`, "warning");
-				}
-			}
-		}
-
-		// Worker loop
-		let noProgressCount = 0;
-		for (let iter = 0; iter < config.context.max_worker_iterations; iter++) {
-			if (state.phase === "paused") return;
-
-			// Re-read STATUS.md
-			const currentStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
-			const stepStatus = currentStatus.steps.find(s => s.number === step.number);
-			if (stepStatus?.status === "complete" || (stepStatus && stepStatus.totalChecked === stepStatus.totalItems && stepStatus.totalItems > 0)) {
-				updateStepStatus(statusPath, step.number, "complete");
-				break;
-			}
-
-			const prevChecked = stepStatus?.totalChecked || 0;
-			state.workerIteration = iter + 1;
-			state.totalIterations++;
-			updateStatusField(statusPath, "Iteration", `${state.totalIterations}`);
-			updateWidgets();
-
-			await runWorker(step, ctx);
-
-			// Check progress
-			const afterStatus = parseStatusMd(readFileSync(statusPath, "utf-8"));
-			const afterStep = afterStatus.steps.find(s => s.number === step.number);
-			const afterChecked = afterStep?.totalChecked || 0;
-
-			if (afterChecked <= prevChecked) {
-				noProgressCount++;
-				if (noProgressCount >= config.context.no_progress_limit) {
-					logExecution(statusPath, `Step ${step.number} blocked`, `No progress after ${noProgressCount} iterations`);
-					ctx.ui.notify(`⚠️ Step ${step.number} blocked — no progress after ${noProgressCount} iterations`, "error");
-					state.phase = "error";
-					return;
-				}
-			} else {
-				noProgressCount = 0;
-			}
-
-			if (afterStep?.status === "complete" || (afterStep && afterStep.totalChecked === afterStep.totalItems && afterStep.totalItems > 0)) {
-				updateStepStatus(statusPath, step.number, "complete");
-				break;
-			}
-		}
-
-		// Code review (level ≥ 2)
-		if (task.reviewLevel >= 2 && state.phase === "running") {
-			if (_isLowRiskStep) {
-				const label = step.number === 0 ? "Preflight" : "final step";
-				logExecution(statusPath, `Skip code review`, `Step ${step.number} (${label}) — low-risk`);
-				ctx.ui.notify(`⏭️ Skipping code review for Step ${step.number} (${label})`, "info");
-			} else {
-				const verdict = await doReview("code", step, ctx, stepBaselineCommit);
-				if (verdict === "REVISE") {
-					ctx.ui.notify(`Reviewer: REVISE on Step ${step.number}. Running worker to fix...`, "warning");
-					await runWorker(step, ctx); // One more pass to address issues
-				}
-			}
-		}
-
-		if (state.phase === "running") {
-			updateStepStatus(statusPath, step.number, "complete");
-			logExecution(statusPath, `Step ${step.number} complete`, step.name);
-			// Update local cache
-			const refreshed = parseStatusMd(readFileSync(statusPath, "utf-8"));
-			for (const s of refreshed.steps) state.stepStatuses.set(s.number, s);
-			updateWidgets();
-		}
-	}
-
 	// ── Worker ───────────────────────────────────────────────────────
 
-	async function runWorker(step: StepInfo, ctx: ExtensionContext): Promise<void> {
+	async function runWorker(remainingSteps: StepInfo[], ctx: ExtensionContext): Promise<void> {
 		if (!state.task || !state.config) return;
 
 		const task = state.task;
@@ -2228,8 +2426,16 @@ export default function (pi: ExtensionAPI) {
 			  "Just create the .DONE file in the task folder when complete."
 			: "";
 
+		// Build step listing for the worker prompt — show ALL steps with status
+		const remainingSet = new Set(remainingSteps.map(s => s.number));
+		const stepListing = task.steps.map(s =>
+			remainingSet.has(s.number)
+				? `  - Step ${s.number}: ${s.name}`
+				: `  - Step ${s.number}: ${s.name}  [already complete — skip]`
+		).join("\n");
+
 		const prompt = [
-			`Execute Step ${step.number}: ${step.name}`,
+			`Execute all remaining steps for task ${task.taskId}.`,
 			``,
 			`Task: ${task.taskId} — ${task.taskName}`,
 			`Task folder: ${task.taskFolder}/`,
@@ -2238,7 +2444,17 @@ export default function (pi: ExtensionAPI) {
 			``,
 			`This is iteration ${state.totalIterations}.`,
 			`Read STATUS.md FIRST to find where you left off.`,
-			`Work ONLY on Step ${step.number}. Do not proceed to other steps.`,
+			``,
+			`Steps:`,
+			stepListing,
+			``,
+			`Work through these steps in order. For each step:`,
+			`1. Read STATUS.md to find unchecked items for that step`,
+			`2. Complete all items for the step`,
+			`3. Update STATUS.md step status to "complete"`,
+			`4. Commit your changes: feat(${task.taskId}): complete Step N — description`,
+			`5. Check for wrap-up signal files before starting the next step`,
+			`6. Proceed to the next incomplete step`,
 			``,
 			`Wrap-up signal files: ${wrapUpFile} (primary), ${legacyWrapUpFile} (legacy)`,
 			`Check for either file after each checkpoint. If one exists, stop.`,
@@ -2273,15 +2489,18 @@ export default function (pi: ExtensionAPI) {
 		// Exit summary path — set only in tmux mode (rpc-wrapper produces this file).
 		let exitSummaryPath: string | null = null;
 
+		// Resolve context window: explicit config → model registry → 200K fallback
+		const { contextWindow, source: contextWindowSource } = resolveContextWindow(config, ctx);
+		const warnPct = config.context.warn_percent;
+		const killPct = config.context.kill_percent;
+		console.error(`[task-runner] worker context window: ${contextWindow} (${contextWindowSource})`);
+
 		if (spawnMode === "tmux") {
 			// ── TMUX mode ────────────────────────────────────────
 			// Sidecar JSONL provides telemetry parity: tokens, cost, context%,
 			// tool calls, and retry events — same signals as subprocess mode.
 			// Kill via wall-clock timeout (context-% wrap-up also available via sidecar).
 			const sessionName = `${getTmuxPrefix()}-worker`;
-			const contextWindow = config.context.worker_context_window;
-			const warnPct = config.context.warn_percent;
-			const killPct = config.context.kill_percent;
 
 			const spawned = spawnAgentTmux({
 				sessionName,
@@ -2373,9 +2592,9 @@ export default function (pi: ExtensionAPI) {
 				thinking: config.worker.thinking || "off",
 				systemPrompt,
 				prompt,
-				contextWindow: config.context.worker_context_window,
-				warnPct: config.context.warn_percent,
-				killPct: config.context.kill_percent,
+				contextWindow,
+				warnPct,
+				killPct,
 				wrapUpFile,
 				onToolCall: (toolName, args) => {
 					state.workerToolCount++;
@@ -2405,7 +2624,7 @@ export default function (pi: ExtensionAPI) {
 				},
 				onContextPct: (pct) => {
 					state.workerContextPct = pct;
-					if (pct >= config.context.warn_percent) {
+					if (pct >= warnPct) {
 						writeWrapUpSignal(`Wrap up (context ${Math.round(pct)}%)`);
 					}
 					updateWidgets();

package/extensions/taskplane/config-loader.ts

@@ -760,7 +760,7 @@ export function toOrchestratorConfig(config: TaskplaneConfig): import("./types.t
 			tools: o.merge.tools,
 			verify: [...o.merge.verify],
 			order: o.merge.order,
-			timeout_minutes: o.merge.timeoutMinutes ?? 10,
+			timeout_minutes: o.merge.timeoutMinutes ?? 90,
 		},
 		failure: {
 			on_task_failure: o.failure.onTaskFailure,

package/extensions/taskplane/config-schema.ts

@@ -125,7 +125,9 @@ export interface ReviewerConfig {
 
 /** Context/resource limits for task execution */
 export interface ContextConfig {
-	/** Context window size used for worker context pressure tracking */
+	/** Context window size used for worker context pressure tracking.
+	 *  Set to 0 (default) for auto-detection from the pi model registry.
+	 *  When 0, the task-runner resolves at runtime: ctx.model.contextWindow → 200K fallback. */
 	workerContextWindow: number;
 	/** Warn threshold for context utilization (percent) */
 	warnPercent: number;
@@ -494,9 +496,9 @@ export const DEFAULT_TASK_RUNNER_SECTION: TaskRunnerSection = {
 	worker: { model: "", tools: "read,write,edit,bash,grep,find,ls", thinking: "off" },
 	reviewer: { model: "openai/gpt-5.3-codex", tools: "read,bash,grep,find,ls", thinking: "on" },
 	context: {
-		workerContextWindow: 200000,
-		warnPercent: 70,
-		killPercent: 85,
+		workerContextWindow: 0,
+		warnPercent: 85,
+		killPercent: 95,
 		maxWorkerIterations: 20,
 		maxReviewCycles: 2,
 		noProgressLimit: 3,
@@ -545,7 +547,7 @@ export const DEFAULT_ORCHESTRATOR_SECTION: OrchestratorSection = {
 		tools: "read,write,edit,bash,grep,find,ls",
 		verify: [],
 		order: "fewest-files-first",
-		timeoutMinutes: 10,
+		timeoutMinutes: 90,
 	},
 	failure: {
 		onTaskFailure: "skip-dependents",

package/extensions/taskplane/extension.ts

@@ -43,6 +43,7 @@ import {
 } from "./index.ts";
 import { buildExecutionContext } from "./workspace.ts";
 import { openSettingsTui } from "./settings-tui.ts";
+import { loadProjectConfig } from "./config-loader.ts";
 import {
 	activateSupervisor,
 	deactivateSupervisor,
@@ -767,10 +768,11 @@ export function validateModelAvailability(
 	runnerConfig: TaskRunnerConfig,
 	supervisorConfig: SupervisorConfig,
 	ctx: ExtensionContext,
+	agentModels?: { workerModel?: string; reviewerModel?: string },
 ): ModelCheckResult[] {
 	const entries: ModelCheckEntry[] = [
-		{ role: "Worker", modelStr: runnerConfig.worker?.model ?? "" },
-		{ role: "Reviewer", modelStr: runnerConfig.reviewer?.model ?? "" },
+		{ 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 ?? "" },
 	];
@@ -1401,7 +1403,18 @@ export default function (pi: ExtensionAPI) {
 			// 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);
+			// 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) {

package/extensions/taskplane/merge.ts

@@ -449,7 +449,7 @@ export async 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

package/extensions/taskplane/supervisor.ts

@@ -2028,7 +2028,38 @@ When the conversation reaches the config generation phase, create ALL of these
 - \`.gitignore\` entries — add Taskplane working file patterns if not already present
 
 Use conservative creation: check if each file exists before writing. If files
-already exist (partial setup), read and merge rather than overwrite.`;
+already exist (partial setup), read and merge rather than overwrite.
+
+### CRITICAL: Task Area Registration
+
+**Every task folder MUST be registered in \`.pi/taskplane-config.json\` under
+\`taskRunner.taskAreas\`.** Without registration, \`/orch all\` will fail with
+"no task areas configured" — even if the folders and tasks physically exist.
+
+When creating a task folder (e.g., \`taskplane-tasks/\`):
+1. Create the folder and its \`CONTEXT.md\`
+2. Register it in \`.pi/taskplane-config.json\`:
+   \`\`\`json
+   {
+     "taskRunner": {
+       "taskAreas": {
+         "general": {
+           "path": "taskplane-tasks",
+           "prefix": "TP",
+           "context": "taskplane-tasks/CONTEXT.md"
+         }
+       }
+     }
+   }
+   \`\`\`
+3. **Verify** by reading the config back to confirm the area is registered
+
+When creating tasks inside an area, check that the area is registered first.
+If it's not (e.g., operator created the folder manually), register it before
+proceeding.
+
+This also applies when creating tasks later in the conversation — always verify
+the task area is registered in the config before offering to run \`/orch all\`.`;
 			break;
 
 		case "pending-tasks":
@@ -2068,7 +2099,14 @@ Follow the primer's **"Script 6: Batch Planning"** section
 5. **Offer a health check** (Script 7) if the operator prefers to assess
    project state rather than create tasks
 6. **Graceful fallback**: If \`gh\` CLI is unavailable, skip GitHub checks and
-   mention it to the operator — continue with CONTEXT.md and TODO scanning`;
+   mention it to the operator — continue with CONTEXT.md and TODO scanning
+
+### Important: Task Area Verification
+
+Before creating any tasks, verify that the target task area folder is registered
+in \`.pi/taskplane-config.json\` under \`taskRunner.taskAreas\`. If it's missing
+(e.g., the folder exists but was never registered), register it first. Without
+registration, \`/orch all\` will fail with "no task areas configured."`;
 			break;
 
 		case "completed-batch":
@@ -3045,11 +3083,16 @@ export function startHeartbeat(
 			return;
 		}
 
-		// Update heartbeat
+		// Update heartbeat (and refresh batchId if it was initially unknown)
 		try {
 			const lock = readLockfile(stateRoot);
 			if (lock && lock.sessionId === sessionId) {
 				lock.heartbeat = new Date().toISOString();
+				// TP-130: batchId may have been "(initializing)" at lock creation
+				// because the batch hadn't started yet. Refresh from live state ref.
+				if (state.batchStateRef?.batchId && lock.batchId !== state.batchStateRef.batchId) {
+					lock.batchId = state.batchStateRef.batchId;
+				}
 				writeLockfile(stateRoot, lock);
 			}
 		} catch {

package/extensions/taskplane/types.ts

@@ -182,7 +182,7 @@ export const DEFAULT_ORCHESTRATOR_CONFIG: OrchestratorConfig = {
 		tools: "read,write,edit,bash,grep,find,ls",
 		verify: [],
 		order: "fewest-files-first",
-		timeout_minutes: 10,
+		timeout_minutes: 90,
 	},
 	failure: {
 		on_task_failure: "skip-dependents",
@@ -1225,7 +1225,7 @@ export class MergeError extends Error {
  * is generous and covers verification (go build) on large codebases.
  */
 /** Default merge agent timeout. Use config.merge.timeout_minutes to override. */
-export const MERGE_TIMEOUT_MS = 10 * 60 * 1000;
+export const MERGE_TIMEOUT_MS = 90 * 60 * 1000;
 
 /**
  * Polling interval for merge result file (ms).

package/package.json

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

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

@@ -13,8 +13,9 @@ name: task-worker
 
   The base prompt (maintained by taskplane) handles:
   - STATUS.md-first workflow and checkpoint discipline
-  - Fresh-context loop behavior and iteration rules
-  - Git commit conventions and .DONE file creation
+  - Multi-step execution (worker handles all remaining steps per invocation)
+  - Iteration recovery (context limit → next invocation resumes from STATUS.md)
+  - Git commit conventions (per-step commits) and .DONE file creation
   - Review response handling
 
   Add project-specific rules below. Common examples:

package/templates/agents/task-worker.md

@@ -1,21 +1,25 @@
 ---
 name: task-worker
-description: Autonomous task execution agent — works on individual steps with checkpoint discipline
+description: Autonomous task execution agent — works through remaining 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
-ONLY memory.
+You are a task execution agent. You may be invoked multiple times across
+iterations — each invocation starts with ZERO memory of prior ones.
+STATUS.md on disk is your ONLY memory.
+
+Your prompt tells you which steps remain. Work through them **in order**,
+completing each step before moving to the next.
 
 ## Resume Algorithm (MANDATORY — Do This First)
 
 1. Read STATUS.md completely
-2. Find the step you have been assigned (specified in your prompt)
+2. Find the **first incomplete step** listed in your prompt
 3. **Hydrate if needed** (see STATUS.md Hydration below)
 4. Within that step, find the **first unchecked checkbox** (`- [ ]`)
 5. Resume from there — do NOT redo checked items (`- [x]`)
-6. If all items in your assigned step are checked, report completion
+6. When a step's items are all checked, proceed to the next incomplete step
+7. If all steps are complete, report completion
 
 ## Checkpoint Discipline (CRITICAL)
 
@@ -68,9 +72,9 @@ dozens of micro-commits that nobody reads.
 
 STATUS.md is the worker's memory, not git. Checking off items in STATUS.md
 ensures the next worker iteration knows where to resume. Git commits preserve
-file changes at meaningful milestones. Per-checkbox commits waste tool calls
-on git housekeeping without adding recovery value — the files are already on
-disk in the worktree.
+file changes at meaningful milestones — one per completed step. Per-checkbox
+commits waste tool calls on git housekeeping without adding recovery value —
+the files are already on disk in the worktree.
 
 ## STATUS.md Hydration (MANDATORY)
 
@@ -94,7 +98,7 @@ instead of solving the problem.
 
 Before implementing anything, assess whether the step needs expansion:
 
-1. **Read the PROMPT.md step details** for your assigned step
+1. **Read the PROMPT.md step details** for the step you're entering
 2. **Look for `⚠️ Hydrate` markers** — these signal the task creator expected
    you to expand based on runtime discoveries
 3. **If expansion is needed**, add checkboxes for **distinct outcomes** you've
@@ -149,9 +153,9 @@ When a reviewer returns REVISE with specific feedback items:
 
 ## Scope Rules
 
-- Work ONLY on the step assigned in your prompt
-- Do NOT proceed to other steps
-- Do NOT expand task scope
+- Work through all remaining steps listed in your prompt, **in order**
+- Do NOT skip ahead — complete each step before starting the next
+- Do NOT expand task scope beyond what the steps require
 - If you discover something out of scope, note it in STATUS.md Discoveries table
 
 ## Self-Documentation

package/templates/config/task-orchestrator.yaml

@@ -77,7 +77,7 @@ merge:
   order: "fewest-files-first"
 
   # Merge agent timeout in minutes. Increase for large batches with many files.
-  timeout_minutes: 10
+  timeout_minutes: 90
 
 # ── Failure Handling ──────────────────────────────────────────────────
 

package/templates/config/task-runner.yaml

@@ -57,9 +57,9 @@ reviewer:
   thinking: "off"
 
 context:
-  worker_context_window: 200000
-  warn_percent: 70
-  kill_percent: 85
+  # worker_context_window: 200000  # 0 or omit = auto-detect from model registry; set explicitly to override
+  warn_percent: 85
+  kill_percent: 95
   max_worker_iterations: 20
   max_review_cycles: 2
   no_progress_limit: 3