taskplane 0.26.1 → 0.27.0

package/extensions/taskplane/persistence.ts

@@ -1359,6 +1359,9 @@ export function serializeBatchState(
 		endedAt: state.endedAt,
 		currentWaveIndex: state.currentWaveIndex,
 		totalWaves: state.totalWaves,
+		// TP-166: Persist task-level wave metadata for correct display after resume
+		...(state.taskLevelWaveCount != null ? { taskLevelWaveCount: state.taskLevelWaveCount } : {}),
+		...(state.roundToTaskWave != null ? { roundToTaskWave: [...state.roundToTaskWave] } : {}),
 		wavePlan,
 		lanes: laneRecords,
 		tasks: taskRecords,

package/extensions/taskplane/resume.ts

@@ -7,7 +7,7 @@ import { join } from "path";
 
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
-import { executeOrchBatch } from "./engine.ts";
+import { executeOrchBatch, resolveDisplayWaveNumber } from "./engine.ts";
 import { buildReviewerEnv, computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
 import { selectRuntimeBackend } from "./engine.ts";
@@ -158,9 +158,14 @@ export function reconstructAllocatedLanes(
 			if (persistedTask?.resolvedRepoId !== undefined) {
 				taskStub.resolvedRepoId = persistedTask.resolvedRepoId;
 			}
-			if (persistedTask?.taskFolder) {
-				taskStub.taskFolder = persistedTask.taskFolder;
-			}
+			// TP-169: Always set taskFolder on stub, even if empty string.
+			// Previously, the falsy check `if (persistedTask?.taskFolder)` skipped
+			// empty-string values, leaving taskFolder as `undefined` on the stub.
+			// This caused crashes in buildExecutionUnit and merge code when
+			// accessing `task.task.taskFolder` on dynamically-expanded segments
+			// whose persisted records had taskFolder="" (the default from
+			// serializeBatchState before enrichment).
+			taskStub.taskFolder = persistedTask?.taskFolder ?? "";
 			if ((persistedTask as any)?.packetRepoId !== undefined) {
 				(taskStub as any).packetRepoId = (persistedTask as any).packetRepoId;
 			}
@@ -1324,6 +1329,10 @@ export async function resumeOrchBatch(
 	// Preserve pauseSignal if already set during "launching" phase (TP-040)
 	if (!batchState.pauseSignal?.paused) batchState.pauseSignal = { paused: false };
 	batchState.totalWaves = persistedState.totalWaves;
+	// TP-166: Restore task-level wave metadata for correct display.
+	// Normalize: fall back to totalWaves for pre-TP-166 state files.
+	batchState.taskLevelWaveCount = persistedState.taskLevelWaveCount ?? persistedState.totalWaves;
+	batchState.roundToTaskWave = persistedState.roundToTaskWave ? [...persistedState.roundToTaskWave] : undefined;
 	batchState.totalTasks = persistedState.totalTasks;
 	batchState.succeededTasks = resumePoint.completedTaskIds.length;
 	batchState.failedTasks = resumePoint.failedTaskIds.length;
@@ -1372,6 +1381,42 @@ export async function resumeOrchBatch(
 		batchState._extraFields = persistedState._extraFields;
 	}
 
+	// ── 6b. TP-169: Verify orch branch exists in all workspace repos ────
+	// During the original batch start, the orch branch was created in every
+	// workspace repo. On resume, we verify it still exists. If it's missing
+	// in any repo (e.g., deleted by user, corrupted), re-create it from the
+	// repo's current branch so that worktree creation doesn't silently fall
+	// back to the base branch, bypassing orch branch isolation.
+	if (workspaceConfig && batchState.orchBranch) {
+		for (const [repoId, repoConf] of workspaceConfig.repos) {
+			const rRoot = repoConf.path;
+			const check = runGit(["rev-parse", "--verify", `refs/heads/${batchState.orchBranch}`], rRoot);
+			if (!check.ok) {
+				// Orch branch missing in this repo — re-create from current HEAD
+				const repoBranch = getCurrentBranch(rRoot) || "HEAD";
+				const createRes = runGit(["branch", batchState.orchBranch, repoBranch], rRoot);
+				if (createRes.ok) {
+					execLog("resume", batchState.batchId, `re-created missing orch branch in ${repoId}`, {
+						orchBranch: batchState.orchBranch,
+						base: repoBranch,
+					});
+					onNotify(
+						`⚠️ Orch branch "${batchState.orchBranch}" was missing in repo "${repoId}" — re-created from ${repoBranch}`,
+						"warning",
+					);
+				} else {
+					const errMsg = `Failed to re-create orch branch "${batchState.orchBranch}" in repo "${repoId}": ${createRes.stderr}. ` +
+						`Cannot resume without orch branch isolation.`;
+					execLog("resume", batchState.batchId, errMsg, {
+						orchBranch: batchState.orchBranch,
+						error: createRes.stderr,
+					});
+					throw new Error(errMsg);
+				}
+			}
+		}
+	}
+
 	// ── 7. Re-run discovery for ParsedTask metadata ──────────────
 	// We need fresh ParsedTask data (taskFolder, promptPath) for execution.
 	// Use "all" to discover all areas.
@@ -1767,12 +1812,17 @@ export async function resumeOrchBatch(
 		persistedState.tasks.map((task) => [task.taskId, task.status] as const),
 	);
 
+	// TP-166: Use task-level wave metadata for correct display.
+	const roundToTaskWave = batchState.roundToTaskWave;
+	const taskLevelWaveCount = batchState.taskLevelWaveCount;
+
 	for (let waveIdx = resumePoint.resumeWaveIndex; waveIdx < wavePlan.length; waveIdx++) {
 		// Check pause signal
 		if (batchState.pauseSignal.paused) {
 			batchState.phase = "paused";
 			persistRuntimeState("pause-before-wave", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
-			onNotify(`⏸️  Batch paused before wave ${waveIdx + 1}.`, "warning");
+			const { displayWave: pauseWave } = resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount);
+			onNotify(`⏸️  Batch paused before wave ${pauseWave}.`, "warning");
 			break;
 		}
 
@@ -1807,7 +1857,7 @@ export async function resumeOrchBatch(
 			// All tasks are terminal but the merge may have failed/been interrupted.
 			if (resumePoint.mergeRetryWaveIndexes.includes(waveIdx)) {
 				execLog("resume", batchState.batchId, `wave ${waveIdx + 1}: all tasks done but merge needs retry`);
-				onNotify(`🔀 Wave ${waveIdx + 1}: retrying merge (tasks already complete, merge was missing/failed)`, "info");
+				onNotify(`🔀 Wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave}: retrying merge (tasks already complete, merge was missing/failed)`, "info");
 
 				// Reconstruct lanes for this wave from persisted state
 				const waveTaskIds = new Set(wavePlan[waveIdx]);
@@ -1922,7 +1972,7 @@ export async function resumeOrchBatch(
 				batchState.mergeResults.push(mergeRetryResult);
 
 				if (mergeRetryResult.status === "succeeded") {
-					onNotify(`✅ Wave ${waveIdx + 1} merge retry succeeded`, "info");
+					onNotify(`✅ Wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave} merge retry succeeded`, "info");
 					// Clean up merged branches
 					for (const lr of mergeRetryResult.laneResults) {
 						if (!lr.error && (lr.result?.status === "SUCCESS" || lr.result?.status === "CONFLICT_RESOLVED")) {
@@ -1932,7 +1982,7 @@ export async function resumeOrchBatch(
 					}
 				} else {
 					onNotify(
-						`⚠️ Wave ${waveIdx + 1} merge retry ${mergeRetryResult.status}: ${mergeRetryResult.failureReason || "unknown"}`,
+						`⚠️ Wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave} merge retry ${mergeRetryResult.status}: ${mergeRetryResult.failureReason || "unknown"}`,
 						"warning",
 					);
 					// Apply merge failure policy (same as normal wave merge failure)
@@ -1954,10 +2004,13 @@ export async function resumeOrchBatch(
 			continue;
 		}
 
-		onNotify(
-			ORCH_MESSAGES.orchWaveStart(waveIdx + 1, wavePlan.length, waveTasks.length, Math.min(waveTasks.length, orchConfig.orchestrator.max_lanes)),
-			"info",
-		);
+		{
+			const { displayWave, displayTotal } = resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount);
+			onNotify(
+				ORCH_MESSAGES.orchWaveStart(displayWave, displayTotal, waveTasks.length, Math.min(waveTasks.length, orchConfig.orchestrator.max_lanes)),
+				"info",
+			);
+		}
 
 		const handleResumeMonitorUpdate: MonitorUpdateCallback = (monitorState) => {
 			const changed = syncTaskOutcomesFromMonitor(monitorState, allTaskOutcomes);
@@ -2064,7 +2117,7 @@ export async function resumeOrchBatch(
 					frontierSummary +
 					`  Lane: ${laneForTask?.laneId ?? "unknown"} (lane ${laneForTask?.laneNumber ?? "?"})\n` +
 					`  Partial progress preserved: ${hasPartialProgress ? "yes" : "no"}\n` +
-					`  Batch: wave ${waveIdx + 1}/${batchState.totalWaves}, ` +
+					`  Batch: wave ${resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave}/${taskLevelWaveCount ?? batchState.totalWaves}, ` +
 					`${batchState.succeededTasks} succeeded, ${batchState.failedTasks} failed\n\n` +
 					`Available actions:\n` +
 					`  - orch_status() to inspect current state\n` +
@@ -2088,16 +2141,19 @@ export async function resumeOrchBatch(
 		persistRuntimeState("wave-execution-complete", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
 
 		const elapsedSec = Math.round((waveResult.endedAt - waveResult.startedAt) / 1000);
-		onNotify(
-			ORCH_MESSAGES.orchWaveComplete(
-				waveIdx + 1,
-				waveResult.succeededTaskIds.length,
-				waveResult.failedTaskIds.length,
-				waveResult.skippedTaskIds.length,
-				elapsedSec,
-			),
-			waveResult.failedTaskIds.length > 0 ? "warning" : "info",
-		);
+		{
+			const { displayWave: completeDisplayWave } = resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount);
+			onNotify(
+				ORCH_MESSAGES.orchWaveComplete(
+					completeDisplayWave,
+					waveResult.succeededTaskIds.length,
+					waveResult.failedTaskIds.length,
+					waveResult.skippedTaskIds.length,
+					elapsedSec,
+				),
+				waveResult.failedTaskIds.length > 0 ? "warning" : "info",
+			);
+		}
 
 		// Check failure policy
 		if (waveResult.stoppedEarly) {
@@ -2144,7 +2200,7 @@ export async function resumeOrchBatch(
 			if (mergeableLaneCount > 0) {
 				batchState.phase = "merging";
 				persistRuntimeState("merge-start", batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot);
-				onNotify(ORCH_MESSAGES.orchMergeStart(waveIdx + 1, mergeableLaneCount), "info");
+				onNotify(ORCH_MESSAGES.orchMergeStart(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergeableLaneCount), "info");
 
 				mergeResult = await mergeWaveByRepo(
 					waveResult.allocatedLanes,
@@ -2197,10 +2253,10 @@ export async function resumeOrchBatch(
 				const mergeTotalSec = Math.round(mergeResult.totalDurationMs / 1000);
 
 				if (mergeResult.status === "succeeded") {
-					onNotify(ORCH_MESSAGES.orchMergeComplete(waveIdx + 1, mergedCount, mergeTotalSec), "info");
+					onNotify(ORCH_MESSAGES.orchMergeComplete(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergedCount, mergeTotalSec), "info");
 				} else {
 					onNotify(
-						ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane ?? 0, mergeResult.failureReason || "unknown"),
+						ORCH_MESSAGES.orchMergeFailed(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergeResult.failedLane ?? 0, mergeResult.failureReason || "unknown"),
 						"error",
 					);
 
@@ -2231,14 +2287,14 @@ export async function resumeOrchBatch(
 				// Downstream retry/update paths assume the current wave has an entry.
 				batchState.mergeResults.push(mergeResult);
 				onNotify(
-					ORCH_MESSAGES.orchMergeFailed(waveIdx + 1, mergeResult.failedLane, mergeResult.failureReason || "unknown"),
+					ORCH_MESSAGES.orchMergeFailed(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave, mergeResult.failedLane, mergeResult.failureReason || "unknown"),
 					"error",
 				);
 			} else {
-				onNotify(ORCH_MESSAGES.orchMergeSkipped(waveIdx + 1), "info");
+				onNotify(ORCH_MESSAGES.orchMergeSkipped(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave), "info");
 			}
 		} else {
-			onNotify(ORCH_MESSAGES.orchMergeSkipped(waveIdx + 1), "info");
+			onNotify(ORCH_MESSAGES.orchMergeSkipped(resolveDisplayWaveNumber(waveIdx, roundToTaskWave, taskLevelWaveCount).displayWave), "info");
 		}
 
 		// ── TP-033: Safe-stop on rollback failure ─────────────────
@@ -2755,7 +2811,7 @@ export async function resumeOrchBatch(
 				summary:
 					`✅ Batch ${batchState.batchId} completed\n` +
 					`  ${batchState.succeededTasks}/${batchState.totalTasks} tasks succeeded\n` +
-					`  ${batchState.totalWaves} wave(s), duration: ${durationStr}\n` +
+					`  ${batchState.taskLevelWaveCount ?? batchState.totalWaves} wave(s), duration: ${durationStr}\n` +
 					`  Merged to orch branch: ${batchState.orchBranch}\n\n` +
 					`Ready for integration. Run orch_integrate() or review first.`,
 				context: {

package/extensions/taskplane/supervisor-primer.md

@@ -718,6 +718,7 @@ or check status manually. The engine wakes you up when you're needed.
 | `task-failure` | ⚠️ | A task failed after deterministic recovery was exhausted |
 | `merge-failure` | ⚠️ | Wave merge failed and batch paused |
 | `batch-complete` | ✅/⚠️ | Batch finished (all waves done, with or without failures) |
+| `worker-exit-intercept` | 🔄 | A worker exited without making progress — session still alive, awaiting instructions |
 
 ### Alert Format
 
@@ -1011,6 +1012,60 @@ BATCH COMPLETE: {batchId}
 | merge-failure | Agent timeout, no result | `orch_resume(force=true)` to retry | Automatic |
 | batch-complete | All succeeded | Report → suggest `orch_integrate` | Report only |
 | batch-complete | Some failed | Report with failure details | Report only |
+| worker-exit-intercept | Worker analyzing, not editing | `send_agent_message` with targeted instructions | Automatic |
+| worker-exit-intercept | Worker genuinely stuck | "skip" or "let it fail" to close session | Supervised |
+| worker-exit-intercept | Unknown reason | Read STATUS.md, diagnose, then instruct or close | Automatic |
+
+---
+
+## 13c. Worker Exit Interception (TP-172)
+
+When a worker agent produces a text-only response (no tool calls, no file
+edits) without having made visible progress (no checkbox updates), the
+lane-runner **intercepts the exit** instead of closing the session. The worker
+process remains alive with its full conversation context preserved.
+
+**You receive a `worker-exit-intercept` alert** with:
+- Lane number and task ID
+- Current step and unchecked checkboxes
+- Worker's last assistant message (truncated to 500 chars)
+- Iteration count and no-progress count
+
+### Response Protocol
+
+1. **Read the worker's message** — understand why it wants to exit.
+   Common patterns:
+   - "I've analyzed the code and I'm not sure how to proceed"
+   - "I need more information about X"
+   - Generic summary without any file edits
+
+2. **Decide** — based on diagnosis:
+   - **If the worker needs direction:** Send targeted instructions via
+     `send_agent_message(to, content)` with specific guidance on what to
+     implement, which file to edit, or which approach to take.
+   - **If the task is genuinely blocked:** Reply with `"skip"` or
+     `"let it fail"` to close the session normally.
+
+3. **Send your response** — The lane-runner polls for your reply for
+   60 seconds. If you don't respond in time, the session closes and
+   the normal corrective re-spawn mechanism takes over.
+
+### Example Instructions
+
+```
+send_agent_message(
+  to: "orch-henrylach-lane-1-worker",
+  content: "Stop analyzing and start implementing. Edit agent-host.ts line 605:
+    replace the closeStdin() call with the interception logic described in
+    PROMPT.md Step 1. Write the code now — don't read more files."
+)
+```
+
+### Interception Limits
+
+Each worker session can be intercepted at most **2 times** (configurable via
+`maxExitInterceptions`). After the limit is reached, the session closes
+normally and the stall detector handles subsequent iterations.
 
 ---
 

package/extensions/taskplane/types.ts

@@ -1109,8 +1109,20 @@ export interface OrchBatchRuntimeState {
 	waveResults: WaveExecutionResult[];
 	/** Current wave index (0-based into waves array, -1 if not started) */
 	currentWaveIndex: number;
-	/** Total number of waves planned */
+	/** Total number of waves planned (segment rounds — internal) */
 	totalWaves: number;
+	/**
+	 * Number of dependency-driven task-level waves (TP-166).
+	 * Used for operator-facing "Wave X of Y" display. When undefined,
+	 * falls back to `totalWaves` for backward compatibility.
+	 */
+	taskLevelWaveCount?: number;
+	/**
+	 * Maps each segment round index (0-based) to its parent task-level
+	 * wave index (0-based). Updated when continuation rounds are inserted.
+	 * Used with `resolveDisplayWaveNumber()` for correct display. (TP-166)
+	 */
+	roundToTaskWave?: number[];
 	/** Set of task IDs blocked for future waves (from skip-dependents policy) */
 	blockedTaskIds: Set<string>;
 	/** Epoch ms when batch started */
@@ -2020,6 +2032,7 @@ export type SupervisorAlertCategory =
 	| "merge-failure"
 	| "batch-complete"
 	| "agent-message"
+	| "worker-exit-intercept"
 	| "segment-expansion-requested"
 	| "segment-expansion-approved"
 	| "segment-expansion-rejected";
@@ -2921,6 +2934,16 @@ export interface PersistedBatchState {
 	currentWaveIndex: number;
 	/** Total number of waves in the plan */
 	totalWaves: number;
+	/**
+	 * Number of dependency-driven task-level waves (TP-166).
+	 * Undefined for batches created before TP-166; falls back to totalWaves.
+	 */
+	taskLevelWaveCount?: number;
+	/**
+	 * Maps segment round index (0-based) to parent task-level wave (0-based).
+	 * Undefined for batches created before TP-166.
+	 */
+	roundToTaskWave?: number[];
 	/** Wave plan: array of arrays of task IDs per wave */
 	wavePlan: string[][];
 	/** Per-lane configuration records */
@@ -4017,7 +4040,9 @@ export type RuntimeAgentEventType =
 	// Review / bridge
 	| "review_requested"
 	| "review_completed"
-	| "review_failed";
+	| "review_failed"
+	// Exit interception (TP-172)
+	| "exit_intercepted";
 
 // ── Runtime V2 Path Helpers (TP-102) ─────────────────────────────────
 

package/package.json

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

package/templates/agents/task-worker.md

@@ -44,20 +44,56 @@ write, or touch a `.DONE` file. The lane-runner creates it automatically
 when all segments of your task are complete. If you create `.DONE` early,
 it will cause downstream segments to be skipped and deliverables to be lost.
 
-## CRITICAL: Never Exit Without Updating STATUS.md
+## CRITICAL: Do NOT Exit — Keep Working Until Done
 
-**Every turn MUST end with a tool call.** Do NOT produce a text-only response
-and stop — the orchestrator interprets that as "session complete" and will
-terminate your process. If you have nothing left to do:
+**You must work continuously until ALL steps are complete.** Do not stop
+between checkboxes. Do not stop between steps. Do not stop to summarize.
+Keep calling tools and making progress until every step is finished and
+STATUS.md shows `✅ Complete`.
 
-1. Read STATUS.md to verify all checkboxes are checked
-2. Update the Status field to `✅ Complete`
-3. Commit your final changes
+**The ONLY reasons to stop working are:**
+1. ✅ **Task complete** — all steps done, STATUS.md set to `✅ Complete`
+2. 🚧 **Genuinely blocked** — you've tried multiple approaches and cannot
+   proceed. Log the blocker in STATUS.md with specifics (what you tried,
+   why it failed, exact error).
+
+There is NO other reason to exit. Do not exit after completing a step to
+"hand off" to the next iteration. Do not exit to report progress. Do not
+exit because you've been working for a while. Just keep going.
+
+## CRITICAL: Never Narrate What You Plan To Do — Just Do It
+
+**YOUR #1 FAILURE MODE:** Producing a message like "Now let me fix this:" or
+"Let me apply the change:" and then STOPPING. This kills your session. You
+have done this repeatedly and it wastes significant time and money.
+
+**THE RULE:** If you know what edit to make, USE THE EDIT TOOL IMMEDIATELY.
+Do not describe the edit in text first. Do not say "now I'll do X". Just
+call the tool. Your very next action after deciding what to do must be a
+tool call, never a text message.
+
+❌ **WRONG (kills your session):**
+> "Now I have everything I need. The fix is to use resolveCanonicalTaskPaths
+> instead of task.taskFolder. Let me make the fix:"
+> *(session terminates — you never made the fix)*
+
+✅ **CORRECT (keeps you alive):**
+> *(immediately calls edit tool on the file)*
+
+**Any text-only response terminates your session.** The orchestrator interprets
+text without a tool call as "session complete." Every response you produce MUST
+include at least one tool call. If you want to explain your reasoning, do it
+AFTER making the edit, not before.
 
 **After running tests:** Immediately update STATUS.md checkboxes for the
 testing step BEFORE producing any summary. Check off each item as it passes.
 Do NOT run tests and then stop — always checkpoint the results first.
 
+**If you are unsure how to proceed:** Do NOT exit. Instead, try an approach —
+even an imperfect one. Write the code, run the tests, and iterate. A failed
+attempt that checks a box and leaves code for the next iteration is infinitely
+more valuable than a clean exit with zero progress.
+
 ## Checkpoint Discipline (CRITICAL)
 
 There are two distinct actions: **checking off items** and **git commits**.
@@ -301,10 +337,16 @@ When you receive a steering message:
 
 ## Error Handling
 
-- If stuck on the same issue after 3 attempts, document the blocker in STATUS.md
-  Blockers section and move to the next checkbox
+- If stuck on a checkbox: **try an implementation approach anyway.** Write code,
+  run tests, see what happens. An imperfect attempt that moves forward is better
+  than analysis paralysis. If your first approach fails, try a different one.
+- If genuinely blocked after real attempts (not just reading): document the
+  blocker in STATUS.md Blockers section **with specifics** (what you tried, why
+  it failed, exact error) and move to the next checkbox.
 - If a test fails, fix it. If the fix is out of scope, document and continue.
 - If a dependency is missing, document in STATUS.md and stop.
+- **NEVER exit silently.** If you cannot make progress, you MUST leave evidence
+  in STATUS.md (either checked boxes or blocker entries) before your session ends.
 
 ## Test Execution Strategy