taskplane 0.25.8 → 0.27.0

package/extensions/taskplane/formatting.ts

@@ -367,22 +367,71 @@ export function buildDashboardViewModel(
 	// Build lane cards from monitor state (if available) or current lanes
 	const laneCards: OrchLaneCardData[] = [];
 
-	if (monitorState && monitorState.lanes.length > 0) {
+	// TP-170: Detect stale monitor data from prior waves.
+	// When wave N+1 starts, batchState.currentLanes is updated to wave N+1's
+	// lanes, but monitorState may still hold wave N's data until the first
+	// poll of wave N+1's monitor. Detect this mismatch by checking whether
+	// the monitor's lane numbers match the current allocation.
+	const monitorIsFresh = monitorState && monitorState.lanes.length > 0 && (
+		// If no current allocation, monitor data is the best we have
+		// (covers terminal phases like completed/failed/stopped)
+		batchState.currentLanes.length === 0 ||
+		// If allocated lanes exist, verify monitor lanes match them
+		monitorState.lanes.some(ml =>
+			batchState.currentLanes.some(cl => cl.laneNumber === ml.laneNumber),
+		)
+	);
+
+	// TP-170: Build a laneNumber → AllocatedLane index for identity reconciliation.
+	// In workspace mode, the monitor’s sessionName (e.g., "orch-henry-api-lane-1")
+	// may differ from the V2 registry agentId ("orch-henry-lane-3-worker").
+	// Cross-referencing with the current allocation ensures the displayed session
+	// name matches the authoritative laneSessionId for the current wave.
+	const allocatedByLaneNumber = new Map<number, { laneSessionId: string; laneId: string }>();
+	for (const cl of batchState.currentLanes) {
+		allocatedByLaneNumber.set(cl.laneNumber, { laneSessionId: cl.laneSessionId, laneId: cl.laneId });
+	}
+
+	if (monitorIsFresh && monitorState) {
 		// Sort lanes by laneNumber (deterministic)
 		const sortedLanes = [...monitorState.lanes].sort((a, b) => a.laneNumber - b.laneNumber);
 
 		for (const lane of sortedLanes) {
 			const snap = lane.currentTaskSnapshot;
+			const alloc = allocatedByLaneNumber.get(lane.laneNumber);
+
+			// TP-170: Reconcile task-level vs lane-level sessionAlive.
+			// resolveTaskMonitorState may derive sessionAlive from the lane
+			// snapshot file (snap.status === "running") while the lane-level
+			// sessionAlive comes from isV2AgentAlive (PID check). When the
+			// task snapshot says "running" but the lane session is confirmed
+			// dead, the task is effectively failed — not still running.
 			let status: OrchLaneCardData["status"] = "idle";
-			if (lane.failedTasks.length > 0) status = "failed";
-			else if (snap?.status === "stalled") status = "stalled";
-			else if (snap?.status === "running") status = "running";
-			else if (lane.completedTasks.length > 0 && lane.remainingTasks.length === 0 && !lane.currentTaskId) status = "succeeded";
+			if (lane.failedTasks.length > 0) {
+				status = "failed";
+			} else if (snap?.status === "stalled") {
+				status = "stalled";
+			} else if (snap?.status === "running") {
+				// TP-170: TOCTOU guard — if lane session is dead but task snapshot
+				// still says "running", treat as failed instead of showing
+				// "session dead" in the card. This prevents the false positive
+				// where the lane snapshot file lags behind the PID liveness check.
+				status = lane.sessionAlive ? "running" : "failed";
+			} else if (
+				lane.completedTasks.length > 0 &&
+				lane.remainingTasks.length === 0 &&
+				!lane.currentTaskId
+			) {
+				status = "succeeded";
+			}
 
 			laneCards.push({
 				laneNumber: lane.laneNumber,
-				laneId: lane.laneId,
-				sessionName: lane.sessionName,
+				laneId: alloc?.laneId || lane.laneId,
+				// TP-170: Prefer the allocation’s laneSessionId (current-wave authority)
+				// over the monitor’s sessionName which may use a stale or workspace-local
+				// name that doesn’t match the V2 registry.
+				sessionName: alloc?.laneSessionId || lane.sessionName,
 				sessionAlive: lane.sessionAlive,
 				currentTaskId: lane.currentTaskId,
 				currentStepName: snap?.currentStepName || null,
@@ -395,7 +444,9 @@ export function buildDashboardViewModel(
 			});
 		}
 	} else if (batchState.currentLanes.length > 0) {
-		// No monitor data yet — show lanes from allocation
+		// No fresh monitor data — show lanes from allocation.
+		// This covers both initial startup (monitor hasn't polled yet)
+		// and wave transitions (monitor data is stale from prior wave).
 		const sortedLanes = [...batchState.currentLanes].sort((a, b) => a.laneNumber - b.laneNumber);
 		for (const lane of sortedLanes) {
 			laneCards.push({
@@ -495,7 +546,11 @@ export function renderLaneCard(card: OrchLaneCardData, colWidth: number, theme:
 	if (card.currentStepName) {
 		stepInfo = trunc(card.currentStepName, w - 2);
 	} else if (card.currentTaskId && card.totalItems === 0) {
-		stepInfo = "waiting for data...";
+		// TP-170: Distinguish startup-grace (no STATUS.md yet) from
+		// genuine stale data. During startup, the lane is alive but
+		// hasn’t written STATUS.md yet — show "starting..." instead of
+		// the misleading "waiting for data..." which implies a problem.
+		stepInfo = card.sessionAlive ? "starting..." : "no status data";
 	} else if (!card.currentTaskId && card.status !== "idle") {
 		stepInfo = `${card.completedTasks}/${card.totalLaneTasks} tasks`;
 	}
@@ -512,8 +567,12 @@ export function renderLaneCard(card: OrchLaneCardData, colWidth: number, theme:
 		extraInfo = `${card.totalChecked}/${card.totalItems} ✓`;
 		extraColor = card.totalChecked === card.totalItems ? "success" : "muted";
 	} else if (!card.sessionAlive && card.status === "running") {
-		extraInfo = "session dead";
-		extraColor = "error";
+		// TP-170: With the TOCTOU guard in buildDashboardViewModel, a lane
+		// with a dead session and task snapshot "running" now gets status
+		// "failed" instead. This branch guards any remaining edge cases
+		// (e.g., allocation-fallback lane assumed alive but actually dead).
+		extraInfo = "session ended";
+		extraColor = "warning";
 	}
 	const extraStr = theme.fg(extraColor, trunc(extraInfo, w));
 	const extraVis = Math.min(extraInfo.length, w);

package/extensions/taskplane/git.ts

@@ -54,3 +54,37 @@ export function runGit(
 	}
 }
 
+/**
+ * Run a git command with custom environment variables.
+ *
+ * Used by TP-169 to create commits on the orch branch without
+ * modifying HEAD, via GIT_INDEX_FILE for alternate index manipulation.
+ *
+ * @param args  - Git command arguments
+ * @param cwd   - Working directory
+ * @param env   - Additional environment variables to set
+ */
+export function runGitWithEnv(
+	args: string[],
+	cwd: string,
+	env: Record<string, string>,
+): { ok: boolean; stdout: string; stderr: string } {
+	try {
+		const stdout = execFileSync("git", args, {
+			encoding: "utf-8",
+			timeout: 30_000,
+			cwd,
+			stdio: ["pipe", "pipe", "pipe"],
+			env: { ...process.env, ...env },
+		}).trim();
+		return { ok: true, stdout, stderr: "" };
+	} catch (err: unknown) {
+		const e = err as { stdout?: string; stderr?: string; message?: string };
+		return {
+			ok: false,
+			stdout: (e.stdout ?? "").toString().trim(),
+			stderr: (e.stderr ?? e.message ?? "unknown error").toString().trim(),
+		};
+	}
+}
+

package/extensions/taskplane/lane-runner.ts

@@ -15,8 +15,9 @@
  * @since TP-105
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync } from "fs";
 import { join, dirname, resolve, basename } from "path";
+import { execSync } from "child_process";
 import { fileURLToPath } from "url";
 
 import {
@@ -40,6 +41,9 @@ import {
 
 import {
 	readOutbox,
+	readInbox,
+	ackMessage,
+	sessionInboxDir,
 	ackOutboxMessage,
 	appendMailboxAuditEvent,
 } from "./mailbox.ts";
@@ -299,6 +303,21 @@ export async function executeTaskV2(
 				`Completed (do not redo): ${completedSteps.map(s => `Step ${s.number}: ${s.name}`).join(", ") || "(none)"}`,
 				`Remaining (focus here): ${remainingSteps.map(s => `Step ${s.number}: ${s.name}`).join(", ")}`,
 			);
+
+			// If the worker exited without checking any boxes, add a corrective directive
+			if (noProgressCount > 0) {
+				promptLines.push(
+					``,
+					`🚨 CRITICAL: You have exited ${noProgressCount} time(s) without completing work.`,
+					`Your previous exit was premature. You said something like "Now let me fix this"`,
+					`and then STOPPED instead of actually making the edit.`,
+					``,
+					`DO NOT DO THIS AGAIN. When you know what to edit, call the edit tool IMMEDIATELY.`,
+					`Do not produce a text message describing what you plan to do. Just do it.`,
+					`Work continuously through ALL remaining checkboxes until the task is DONE.`,
+					`Do not exit between checkboxes or steps.`,
+				);
+			}
 		}
 
 		// ── Spawn worker ────────────────────────────────────────────
@@ -351,6 +370,135 @@ export async function executeTaskV2(
 				...(config.reviewerThinking ? { TASKPLANE_REVIEWER_THINKING: config.reviewerThinking } : {}),
 				...(config.reviewerTools ? { TASKPLANE_REVIEWER_TOOLS: config.reviewerTools } : {}),
 			},
+			// TP-172: Exit interception callback — escalate to supervisor when worker
+			// exits without making visible progress (no checkboxes, no blocker logged).
+			onPrematureExit: config.onSupervisorAlert
+				? async (assistantMessage: string): Promise<string | null> => {
+					// Check if the worker made visible progress during this turn:
+					// 1. Checkbox progress (more items checked)
+					// 2. Blocker logged (non-empty Blockers section)
+					try {
+						const statusContent = readFileSync(statusPath, "utf-8");
+						const midStatus = parseStatusMd(statusContent);
+						const midTotalChecked = midStatus.steps.reduce((sum, s) => sum + s.totalChecked, 0);
+						if (midTotalChecked > prevTotalChecked) {
+							// Worker checked off checkboxes — let it exit normally
+							return null;
+						}
+						// Check for blocker entries: extract Blockers section and see if non-empty
+						const blockerMatch = statusContent.match(/## Blockers\s*\n([\s\S]*?)(?:\n---|-$)/i);
+						if (blockerMatch) {
+							const blockerContent = blockerMatch[1].trim();
+							// If blockers section has real content (not just "*None*" or empty)
+							if (blockerContent && blockerContent !== "*None*") {
+								// Worker logged a blocker — let it exit normally
+								return null;
+							}
+						}
+					} catch { /* If we can't read STATUS.md, proceed with escalation */ }
+
+					// No visible progress — compose escalation message
+					const truncatedMsg = assistantMessage.slice(0, 500);
+					const uncheckedItems: string[] = [];
+					try {
+						const statusContent = readFileSync(statusPath, "utf-8");
+						const uncheckedMatches = statusContent.match(/^- \[ \] .+$/gm);
+						if (uncheckedMatches) {
+							for (const item of uncheckedMatches.slice(0, 5)) {
+								uncheckedItems.push(item.replace(/^- \[ \] /, "").trim());
+							}
+						}
+					} catch { /* best effort */ }
+
+					const currentStepInfo = remainingSteps.length > 0
+						? `Step ${remainingSteps[0].number}: ${remainingSteps[0].name}`
+						: "Unknown";
+
+					// Fire supervisor alert
+					try {
+						config.onSupervisorAlert!({
+							category: "worker-exit-intercept",
+							summary:
+								`🔄 Worker on lane ${config.laneNumber} wants to exit with no progress.\n` +
+								`  Task: ${taskId}\n` +
+								`  Current step: ${currentStepInfo}\n` +
+								`  Iteration: ${totalIterations}, No-progress count: ${noProgressCount + 1}\n` +
+								`  Unchecked items: ${uncheckedItems.length > 0 ? uncheckedItems.join("; ") : "(none found)"}\n` +
+								`  Worker said: "${truncatedMsg}"\n` +
+								`\nSend a steering message to ${workerAgentId} with targeted instructions,` +
+								` or reply "skip" / "let it fail" to close the session.`,
+							context: {
+								taskId,
+								laneId: `lane-${config.laneNumber}`,
+								laneNumber: config.laneNumber,
+								agentId: workerAgentId,
+								exitReason: `worker_exit_no_progress: ${truncatedMsg.slice(0, 200)}`,
+							},
+						});
+					} catch { /* best effort — don't block on alert failure */ }
+
+					// Poll worker mailbox inbox for supervisor reply (60s timeout)
+					const SUPERVISOR_REPLY_TIMEOUT_MS = 60_000;
+					const POLL_INTERVAL_MS = 2_000;
+					const escalationTimestamp = Date.now();
+					const inboxDir = sessionInboxDir(config.stateRoot, config.batchId, workerAgentId);
+
+					const supervisorReply = await new Promise<string | null>((resolve) => {
+						const deadline = Date.now() + SUPERVISOR_REPLY_TIMEOUT_MS;
+						const poll = () => {
+							if (Date.now() >= deadline) {
+								resolve(null); // Timeout — fall back to corrective re-spawn
+								return;
+							}
+							try {
+								const messages = readInbox(inboxDir, config.batchId);
+								// Only accept messages newer than escalation timestamp
+								for (const { filename, message } of messages) {
+									if (message.timestamp >= escalationTimestamp && message.from === "supervisor") {
+										// Consume the message
+										const ackDir = join(dirname(inboxDir), "ack");
+										try { ackMessage(inboxDir, filename); } catch { /* best effort */ }
+										resolve(message.content);
+										return;
+									}
+								}
+							} catch { /* inbox not ready yet */ }
+							setTimeout(poll, POLL_INTERVAL_MS);
+						};
+						poll();
+					});
+
+					if (!supervisorReply) {
+						// Timeout — let the session close, corrective re-spawn will handle it
+						logExecution(statusPath, "Exit intercept timeout",
+							`Supervisor did not respond within ${SUPERVISOR_REPLY_TIMEOUT_MS / 1000}s — closing session`);
+						return null;
+					}
+
+					// Interpret supervisor reply: close directives vs instructional content
+					const normalizedReply = supervisorReply.trim().toLowerCase();
+					const CLOSE_DIRECTIVES = ["skip", "let it fail", "close", "abort", "stop"];
+					// Only short messages (< 30 chars) can be close directives.
+					// Longer messages are always instructions even if they start with "stop".
+					const isShortEnoughForDirective = normalizedReply.length < 30;
+					if (isShortEnoughForDirective && CLOSE_DIRECTIVES.some(d =>
+						normalizedReply === d ||
+						normalizedReply.startsWith(d + ":") ||
+						normalizedReply.startsWith(d + " ") ||
+						normalizedReply.startsWith(d + ".") ||
+						normalizedReply.startsWith(d + " -")
+					)) {
+						logExecution(statusPath, "Exit intercept close",
+							`Supervisor directed session close: "${supervisorReply.slice(0, 100)}"`);
+						return null;
+					}
+
+					// Instructional reply — return as new prompt for the worker
+					logExecution(statusPath, "Exit intercept reprompt",
+						`Supervisor provided instructions (${supervisorReply.length} chars) — reprompting worker`);
+					return supervisorReply;
+				}
+				: undefined,
 		};
 
 		// Context pressure: write wrap-up signal before kill
@@ -510,13 +658,39 @@ export async function executeTaskV2(
 		const progressDelta = afterTotalChecked - prevTotalChecked;
 
 		if (progressDelta <= 0) {
-			noProgressCount++;
-			logExecution(statusPath, "No progress",
-				`Iteration ${totalIterations}: 0 new checkboxes (${noProgressCount}/${config.noProgressLimit} stall limit)`);
-			if (noProgressCount >= config.noProgressLimit) {
-				logExecution(statusPath, "Task blocked", `No progress after ${noProgressCount} iterations`);
-				return makeResult(taskId, segmentId, workerAgentId, "failed", startTime,
-					`No progress after ${noProgressCount} iterations`, false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
+			// Check for soft progress: uncommitted changes in the worktree
+			// indicate the worker is actively editing code even if no checkbox
+			// was checked yet. This avoids false stall detection on complex
+			// steps where analysis + editing spans multiple tool calls.
+			let hasSoftProgress = false;
+			try {
+				const diffOutput = execSync("git diff --stat HEAD", {
+					cwd: unit.worktreePath,
+					timeout: 5000,
+					encoding: "utf-8",
+					stdio: ["pipe", "pipe", "pipe"],
+				}).trim();
+				// Only count source file changes as soft progress, not just STATUS.md
+				const changedFiles = diffOutput.split("\n").filter(l => l.includes("|"));
+				const sourceChanges = changedFiles.filter(l => !l.includes("STATUS.md") && !l.includes(".steering"));
+				hasSoftProgress = sourceChanges.length > 0;
+			} catch { /* git not available or timeout — treat as no soft progress */ }
+
+			if (hasSoftProgress) {
+				// Worker has uncommitted code changes — don't count toward stall.
+				// Reset the counter since the worker is actively editing.
+				logExecution(statusPath, "Soft progress",
+					`Iteration ${totalIterations}: 0 new checkboxes but uncommitted source changes detected — not counting as stall`);
+				noProgressCount = 0;
+			} else {
+				noProgressCount++;
+				logExecution(statusPath, "No progress",
+					`Iteration ${totalIterations}: 0 new checkboxes (${noProgressCount}/${config.noProgressLimit} stall limit)`);
+				if (noProgressCount >= config.noProgressLimit) {
+					logExecution(statusPath, "Task blocked", `No progress after ${noProgressCount} iterations`);
+					return makeResult(taskId, segmentId, workerAgentId, "failed", startTime,
+						`No progress after ${noProgressCount} iterations`, false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
+				}
 			}
 		} else {
 			noProgressCount = 0;
@@ -569,7 +743,15 @@ export async function executeTaskV2(
 		&& unit.task.segmentIds.length > 1
 		&& unit.task.segmentIds[unit.task.segmentIds.length - 1] !== segmentId;
 
-	if (isNonFinalSegment) {
+	// TP-165: Check for pending expansion requests in the worker's outbox.
+	// If the worker filed expansion requests, more segments may be added by the
+	// engine at the segment boundary — .DONE must not be created even if this
+	// appears to be the final segment based on the static segmentIds list.
+	const hasPendingExpansionRequests = segmentId != null && hasPendingExpansionRequestFiles(
+		config.stateRoot, config.batchId, workerAgentId,
+	);
+
+	if (isNonFinalSegment || hasPendingExpansionRequests) {
 		// Segment succeeded but more segments remain — suppress .DONE and "✅ Complete" status.
 		// The engine will advance the frontier and dispatch the next segment.
 		// Also delete any .DONE the worker may have created directly (workers have
@@ -588,8 +770,11 @@ export async function executeTaskV2(
 			logExecution(statusPath, "Segment complete",
 				`Segment ${segmentId} succeeded (not final — .DONE suppressed)`);
 		}
+		const suppressionReason = isNonFinalSegment
+			? "non-final"
+			: "pending expansion requests";
 		return makeResult(taskId, segmentId, workerAgentId, "succeeded", startTime,
-			"Segment completed (non-final — .DONE suppressed)", false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
+			`Segment completed (${suppressionReason} — .DONE suppressed)`, false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry);
 	}
 
 	// Create .DONE if not already present (final segment or single-segment/whole-task execution)
@@ -605,6 +790,30 @@ export async function executeTaskV2(
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
+/**
+ * TP-165: Check if the worker's outbox contains pending segment expansion requests.
+ *
+ * Pending expansion request files match `segment-expansion-*.json` (not renamed
+ * to `.processed`, `.rejected`, etc.). If any exist, the engine will process them
+ * at the segment boundary — and may add more segments to the task.
+ *
+ * @returns true if at least one pending expansion request file exists
+ */
+export function hasPendingExpansionRequestFiles(
+	stateRoot: string,
+	batchId: string,
+	agentId: string,
+): boolean {
+	const outboxDir = join(stateRoot, ".pi", "mailbox", batchId, agentId, "outbox");
+	if (!existsSync(outboxDir)) return false;
+	try {
+		const entries = readdirSync(outboxDir);
+		return entries.some((entry) => /^segment-expansion-.+\.json$/.test(entry));
+	} catch {
+		return false;
+	}
+}
+
 export function mapLaneTaskStatusToTerminalSnapshotStatus(
 	status: LaneTaskStatus,
 ): "idle" | "complete" | "failed" {