taskplane 0.22.5 → 0.22.7

package/extensions/task-runner.ts

@@ -2148,6 +2148,9 @@ export default function (pi: ExtensionAPI) {
 
 	// ── review_step Tool (orchestrated mode only) ───────────────────
 
+	/** Per-step code review cycle counter. Reset when reviewer is killed after APPROVE. */
+	const stepCodeReviewCounts = new Map<number, number>();
+
 	/**
 	 * Reset reviewer telemetry fields on state to idle/zero.
 	 * Called after a review completes to clear dashboard metrics.
@@ -2291,6 +2294,30 @@ export default function (pi: ExtensionAPI) {
 				const reviewsDir = join(task.taskFolder, ".reviews");
 				if (!existsSync(reviewsDir)) mkdirSync(reviewsDir, { recursive: true });
 
+				// Per-step code review cycle limit
+				if (reviewType === "code") {
+					const codeCount = (stepCodeReviewCounts.get(stepNum) || 0) + 1;
+					stepCodeReviewCounts.set(stepNum, codeCount);
+					const maxCycles = config.context.max_review_cycles || 2;
+					if (codeCount > maxCycles) {
+						logExecution(statusPath, `Skip code review`,
+							`Step ${stepNum} code review cycle limit reached (${codeCount}/${maxCycles}) — auto-approving`);
+						// Kill reviewer to free context for next step
+						if (state.persistentReviewerKill) {
+							try { state.persistentReviewerKill(); } catch {}
+						}
+						state.persistentReviewerSession = null;
+						state.persistentReviewerKill = null;
+						state.persistentReviewerSignalNum = 0;
+						state.reviewerRespawnCount = 0;
+						stepCodeReviewCounts.delete(stepNum);
+						return {
+							content: [{ type: "text" as const, text: `APPROVE — Code review cycle limit reached (${maxCycles}). Auto-approved to prevent context exhaustion.` }],
+							details: undefined,
+						};
+					}
+				}
+
 				// Low-risk step check (safety net — worker template also skips)
 				if (isLowRiskStep(stepNum, task.steps.length)) {
 					const label = stepNum === 0 ? "Preflight" : "final step";
@@ -2551,11 +2578,29 @@ export default function (pi: ExtensionAPI) {
 					updateWidgets();
 
 					// Extract verdict and build result
-					const { resultText } = processReviewVerdict(
+					const { resultText, verdict } = processReviewVerdict(
 						reviewContent, statusPath, num, reviewType, stepNum, state.reviewCounter,
 					);
 
-					// Set reviewer to idle (NOT clear — persistent session stays alive)
+					// After code review APPROVE: kill the persistent reviewer to free context.
+					// The reviewer persists through plan+code for one step, and through
+					// REVISE→fix→re-review cycles (it knows what it asked to be fixed).
+					// Only kill on APPROVE — a REVISE means the worker needs to fix and
+					// re-submit, and the same reviewer should evaluate the follow-up.
+					if (reviewType === "code" && (verdict === "APPROVE" || verdict === "UNAVAILABLE")) {
+						console.error(`[task-runner] code review ${verdict} for step ${stepNum} — killing reviewer for fresh context on next step`);
+						logExecution(statusPath, `Reviewer R${num}`,
+							`code review ${verdict} — killing persistent reviewer (step ${stepNum} cycle done)`);
+						if (state.persistentReviewerKill) {
+							try { state.persistentReviewerKill(); } catch {}
+						}
+						state.persistentReviewerSession = null;
+						state.persistentReviewerKill = null;
+						state.persistentReviewerSignalNum = 0;
+						state.reviewerRespawnCount = 0;
+						stepCodeReviewCounts.delete(stepNum);
+					}
+
 					state.reviewerStatus = "idle";
 					state.reviewerType = "";
 					state.reviewerStep = 0;
@@ -2643,6 +2688,9 @@ export default function (pi: ExtensionAPI) {
 							fallbackContent, statusPath, num, reviewType, stepNum, state.reviewCounter, "fallback",
 						);
 
+						// Reset respawn counter on successful fallback review
+						state.reviewerRespawnCount = 0;
+
 						clearReviewerState();
 						writeLaneState(state);
 						updateWidgets();

package/package.json

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

package/templates/agents/task-worker.md

@@ -289,33 +289,35 @@ checkpoints protect against regressions even when intermediate steps use targete
 2. The merge agent (before merging to the orchestrator branch)
 3. CI (before merging to main)
 
-## File Reading Strategy (Context Budget)
+## File Reading Strategy (Context Budget) — CRITICAL
 
-Your context window is finite. Reading large files whole wastes budget and risks
-triggering the context-pressure safety net (85% → wrap-up, 95% → kill).
-Use targeted reads instead:
+Your context window is finite. **Reading large files without offset/limit is the
+#1 cause of context exhaustion** — one full read of a 3000-line file consumes
+~5% of a 1M context window. Three such reads = 15% gone before you've done
+anything.
+
+### HARD RULES
+
+1. **NEVER read a file > 500 lines without offset/limit.** Always grep first.
+2. **NEVER read the same file twice in full.** Re-read only the changed region.
+3. **ALWAYS check file size before reading:** `wc -l <file>` or `ls -la <file>`
 
 ### Pattern: grep-first, read-with-offset
 
-1. **Locate** the relevant section with `grep` or `find`:
-   ```
-   grep -n "function buildPrompt" extensions/task-runner.ts
-   ```
-2. **Read** just that region with `offset` and `limit`:
-   ```
-   read extensions/task-runner.ts (offset: 1773, limit: 50)
-   ```
-3. **Edit** surgically with exact `oldText → newText`
+1. **Check size:** `wc -l extensions/task-runner.ts` → 4100 lines (DO NOT read fully)
+2. **Locate** the relevant section: `grep -n "function buildPrompt" extensions/task-runner.ts`
+3. **Read** just that region: `read extensions/task-runner.ts (offset: 1773, limit: 50)`
+4. **Edit** surgically with exact `oldText → newText`
 
 ### When to read a full file
 
 - Files under ~500 lines — read the whole thing, it's fine
-- Config files, test files, templates — usually small enough to read fully
+- Config files, small test files, templates — usually small enough
 - New files you're creating — read after writing to verify
 
 ### When NOT to read a full file
 
-- Source files over ~1000 lines — grep first, read the relevant region
+- Source files over ~500 lines — grep first, read with offset/limit
 - Generated files, lock files, large data files — almost never need full reads
 - Files you've already read this session — re-read only the changed region