taskplane 0.28.8 → 0.29.1

package/extensions/taskplane/lane-runner.ts

@@ -53,6 +53,7 @@ import {
 	sessionInboxDir,
 	ackOutboxMessage,
 	appendMailboxAuditEvent,
+	drainAgentOutbox,
 } from "./mailbox.ts";
 
 import {
@@ -245,6 +246,14 @@ export interface LaneRunnerConfig {
 	killPercent: number;
 	/** Optional callback for surfacing runtime mailbox replies/escalations to supervisor */
 	onSupervisorAlert?: SupervisorAlertCallback;
+	/**
+	 * Optional callback fired when the lane reaches a terminal state (no-progress
+	 * kill or hard-fail). The supervisor process uses this to suppress any
+	 * subsequent zombie alerts queued for the now-dead lane.
+	 *
+	 * @since TP-187 (#538)
+	 */
+	onLaneTerminated?: (info: import("./types.ts").LaneTerminatedInfo) => void;
 }
 
 /**
@@ -656,8 +665,41 @@ export async function executeTaskV2(
 						}
 					} catch { /* If we can't read STATUS.md, proceed with escalation */ }
 
-					// No visible progress — compose escalation message
-					const truncatedMsg = assistantMessage.slice(0, 500);
+					// No visible progress — compose escalation message.
+					// TP-187 (#540): when the worker exits silently, fall back to the most
+					// recent `assistant_message` event in events.jsonl so the supervisor
+					// has SOMETHING to act on instead of `Worker said: ""`.
+					let workerSaid = (assistantMessage ?? "").trim();
+					let workerSaidSource: "current-turn" | "events-jsonl-fallback" | "empty-sentinel" = "current-turn";
+					if (!workerSaid) {
+						workerSaidSource = "empty-sentinel";
+						try {
+							const raw = readFileSync(eventsPath, "utf-8");
+							const lines = raw.split("\n");
+							// Walk backward to find the most recent assistant_message with non-empty text.
+							for (let i = lines.length - 1; i >= 0; i--) {
+								const line = lines[i].trim();
+								if (!line) continue;
+								try {
+									const evt = JSON.parse(line) as Record<string, unknown>;
+									if (evt.type === "assistant_message") {
+										const payload = evt.payload as Record<string, unknown> | undefined;
+										const text = typeof payload?.text === "string" ? payload.text.trim() : "";
+										if (text) {
+											workerSaid = text;
+											workerSaidSource = "events-jsonl-fallback";
+											break;
+										}
+									}
+								} catch { /* skip malformed line */ }
+							}
+						} catch { /* events.jsonl unreadable; sentinel will be used */ }
+					}
+					if (!workerSaid) {
+						workerSaid = "(no assistant message captured — worker exited without producing visible output)";
+						workerSaidSource = "empty-sentinel";
+					}
+					const truncatedMsg = workerSaid.slice(0, 500);
 					const uncheckedItems: string[] = [];
 					try {
 						const statusContent = readFileSync(statusPath, "utf-8");
@@ -693,7 +735,12 @@ export async function executeTaskV2(
 								`  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` +
+								`  Worker said: "${truncatedMsg}"` +
+								(workerSaidSource === "events-jsonl-fallback"
+									? `   (fallback: most-recent assistant_message from events.jsonl)\n`
+									: workerSaidSource === "empty-sentinel"
+										? `   (no assistant message captured this iteration)\n`
+										: "\n") +
 								`\nSend a steering message to ${workerAgentId} with targeted instructions,` +
 								` or reply "skip" / "let it fail" to close the session.`,
 							context: {
@@ -978,6 +1025,30 @@ export async function executeTaskV2(
 					`Iteration ${totalIterations}: 0 new checkboxes (${noProgressCount}/${config.noProgressLimit} stall limit)`);
 				if (noProgressCount >= config.noProgressLimit) {
 					logExecution(statusPath, "Task blocked", `No progress after ${noProgressCount} iterations`);
+					// TP-187 (#538): synchronous outbox drain at lane-termination decision
+					// point. Purges any pending escalations/replies/segment-expansions the
+					// worker emitted just before termination so they are not later re-
+					// discovered and re-forwarded as zombie supervisor alerts.
+					try {
+						const drained = drainAgentOutbox(config.stateRoot, config.batchId, workerAgentId);
+						if (drained > 0) {
+							logExecution(statusPath, "Outbox drained",
+								`No-progress kill: drained ${drained} pending outbox entr${drained === 1 ? "y" : "ies"} for ${workerAgentId}`);
+						}
+					} catch { /* best effort — do not block termination */ }
+					// TP-187 (#538): notify the supervisor process so it can suppress any
+					// further alerts queued for this lane (zombie-alert filter).
+					if (config.onLaneTerminated) {
+						try {
+							config.onLaneTerminated({
+								laneNumber: config.laneNumber,
+								agentId: workerAgentId,
+								batchId: config.batchId,
+								terminatedAt: Date.now(),
+								reason: "no-progress-kill",
+							});
+						} catch { /* best effort */ }
+					}
 					return makeResult(taskId, segmentId, workerAgentId, "failed", startTime,
 						`No progress after ${noProgressCount} iterations`, false, totalIterations, cumulativeCostUsd, cumulativeTokens, config, statusPath, reviewerStatePath, lastTelemetry, snapshotSegmentCtx);
 				}

package/extensions/taskplane/mailbox.ts

@@ -538,6 +538,89 @@ export function ackOutboxMessage(
 	}
 }
 
+/**
+ * Drain (purge to processed/) all pending outbox messages for an agent.
+ *
+ * Used at lane-termination decision points to ensure stale escalations or
+ * replies that the worker emitted just before termination don't get later
+ * re-discovered and re-forwarded as zombie supervisor alerts. The drain
+ * mirrors {@link ackOutboxMessage} — each pending `*.msg.json` file is
+ * moved to `outbox/processed/` so it remains in the durable history (for
+ * `read_agent_replies`) but is no longer pending.
+ *
+ * Best-effort: any per-file failure is logged but does not abort the drain.
+ * Returns the number of messages successfully drained.
+ *
+ * Also drains any non-message pending files in the outbox (e.g.,
+ * `segment-expansion-*.json` requests) by renaming them to a `.drained`
+ * sibling so the engine's discovery scans don't re-pick them up.
+ *
+ * @since TP-187 (#538)
+ */
+export function drainAgentOutbox(
+	stateRoot: string,
+	batchId: string,
+	agentId: string,
+): number {
+	const outboxDir = sessionOutboxDir(stateRoot, batchId, agentId);
+	if (!existsSync(outboxDir)) return 0;
+
+	let entries: string[] = [];
+	try {
+		entries = readdirSync(outboxDir);
+	} catch (err) {
+		process.stderr.write(
+			`[mailbox] WARNING: drainAgentOutbox failed to read ${outboxDir}: ${err instanceof Error ? err.message : String(err)}\n`,
+		);
+		return 0;
+	}
+
+	let drained = 0;
+	const processedDir = join(outboxDir, "processed");
+	let processedDirEnsured = false;
+
+	for (const entry of entries) {
+		// Skip the processed/ subdirectory itself and any in-flight temp writes.
+		if (entry === "processed" || entry.endsWith(".tmp")) continue;
+
+		const srcPath = join(outboxDir, entry);
+
+		if (entry.endsWith(".msg.json")) {
+			if (!processedDirEnsured) {
+				try { mkdirSync(processedDir, { recursive: true }); } catch { /* fall through to rename error handling */ }
+				processedDirEnsured = true;
+			}
+			const dstPath = join(processedDir, entry);
+			try {
+				renameSync(srcPath, dstPath);
+				drained++;
+			} catch (err: unknown) {
+				const code = (err as NodeJS.ErrnoException).code;
+				if (code === "ENOENT") continue; // already gone — race-safe
+				process.stderr.write(
+					`[mailbox] WARNING: drainAgentOutbox failed to rename ${entry}: ${err instanceof Error ? err.message : String(err)}\n`,
+				);
+			}
+			continue;
+		}
+
+		// Non-message pending files (e.g., segment-expansion-*.json). Rename in
+		// place to a `.drained` suffix so engine.ts discovery scans skip them.
+		try {
+			renameSync(srcPath, `${srcPath}.drained`);
+			drained++;
+		} catch (err: unknown) {
+			const code = (err as NodeJS.ErrnoException).code;
+			if (code === "ENOENT") continue;
+			process.stderr.write(
+				`[mailbox] WARNING: drainAgentOutbox failed to mark ${entry} drained: ${err instanceof Error ? err.message : String(err)}\n`,
+			);
+		}
+	}
+
+	return drained;
+}
+
 /**
  * Discover all agent IDs that have mailbox directories for a batch.
  * Returns directory names under .pi/mailbox/{batchId}/ excluding _broadcast.

package/extensions/taskplane/messages.ts

@@ -104,6 +104,25 @@ export const ORCH_MESSAGES = {
 	resumeNoState: () =>
 		`❌ No batch to resume. No batch-state.json file found.\n` +
 		`   Use /orch <areas|all> to start a new batch.`,
+
+	/**
+	 * TP-187 (#539): Successful reconstruction from .pi/runtime/<batchId>/
+	 * runtime artifacts during force-resume after `orch_abort()`.
+	 */
+	resumeReconstructed: (batchId: string, selectionNote: string) =>
+		`🔨 Reconstructed batch ${batchId} from .pi/runtime/ artifacts (${selectionNote}).\n` +
+		`   Force-resume will proceed with a fresh wave-zero pass; the existing\n` +
+		`   reconciliation logic will re-detect succeeded tasks via .DONE markers.`,
+
+	/**
+	 * TP-187 (#539): Fail-loud message when force-resume can't reconstruct
+	 * after `orch_abort()` because required runtime artifacts are missing.
+	 */
+	resumeNoStateAfterAbort: (missingArtifact: string, batchId: string | null) =>
+		`❌ Cannot resume after abort: ${missingArtifact}.\n` +
+		(batchId ? `   Last known batch: ${batchId}.\n` : "") +
+		`   To start fresh from the preserved worktree state, run\n` +
+		`   \`orch_start <PROMPT.md>\` (or \`/orch <areas|all>\`).`,
 	resumeInvalidState: (error: string) =>
 		`❌ Cannot resume: batch state file is invalid.\n` +
 		`   Error: ${error}\n` +

package/extensions/taskplane/path-resolver.ts

@@ -86,15 +86,38 @@ export function getNpmGlobalRoot(): string {
 	return _npmGlobalRoot;
 }
 
+/**
+ * Pi CLI npm package scopes that taskplane resolves at runtime, ordered with
+ * the canonical (current) scope FIRST and legacy scopes after for backward
+ * compatibility. Issue #560: the Pi coding agent was renamed from
+ * `@mariozechner/pi-coding-agent` to `@earendil-works/pi-coding-agent` in
+ * Pi v0.74.0. Pi's own extension loader bundles BOTH scope aliases at runtime
+ * for in-process module imports, but spawn-side path resolution (this file)
+ * has to look on disk under whichever scope was actually installed.
+ *
+ * Order matters: the new scope is preferred so a system that has BOTH
+ * installed (e.g., during a transition window) picks up the current Pi.
+ */
+const PI_PACKAGE_SCOPES = ["@earendil-works", "@mariozechner"] as const;
+
 /**
  * Resolve the absolute path to the Pi coding agent CLI entrypoint (`cli.js`).
  *
- * The Pi CLI is installed as `@mariozechner/pi-coding-agent`. On Windows, invoking
- * `pi` directly executes a `.CMD` shim that cannot be spawned with `shell: false`.
- * This function locates the underlying `dist/cli.js` so callers can spawn it with
- * `node` directly, without a shell intermediary.
+ * The Pi CLI is installed under one of two npm scopes:
+ *   - `@earendil-works/pi-coding-agent` (current, as of Pi v0.74.0)
+ *   - `@mariozechner/pi-coding-agent` (legacy)
  *
- * Resolution order:
+ * On Windows, invoking `pi` directly executes a `.CMD` shim that cannot be
+ * spawned with `shell: false`. This function locates the underlying
+ * `dist/cli.js` so callers can spawn it with `node` directly, without a shell
+ * intermediary.
+ *
+ * Resolution order: the cross product of base directories × package scopes,
+ * with each base directory tried for the new scope before any base directory
+ * is tried for the legacy scope. (Equivalently: scope is the inner loop, base
+ * is the outer loop.)
+ *
+ * Base directories (outer loop):
  *   1. `npm root -g` result (dynamic — covers all setups: nvm, Homebrew, volta, etc.)
  *   2. `%APPDATA%\npm\node_modules\...` (Windows, APPDATA env var)
  *   3. `%USERPROFILE%\AppData\Roaming\npm\node_modules\...` (Windows, HOME-relative)
@@ -102,40 +125,53 @@ export function getNpmGlobalRoot(): string {
  *   5. `/usr/local/lib/node_modules/...` (macOS system Node, Linux)
  *   6. `/opt/homebrew/lib/node_modules/...` (macOS Homebrew)
  *
- * @returns Absolute path to `@mariozechner/pi-coding-agent/dist/cli.js`
- * @throws  {Error} If the CLI entrypoint cannot be found in any known location.
- *          The error message includes the `npm root -g` value for diagnosis.
+ * Scopes per base (inner loop):
+ *   a. `@earendil-works/pi-coding-agent/dist/cli.js`
+ *   b. `@mariozechner/pi-coding-agent/dist/cli.js`
+ *
+ * @returns Absolute path to a Pi CLI `dist/cli.js` (under whichever scope was found).
+ * @throws  {Error} If the CLI entrypoint cannot be found under any base × scope
+ *          combination. The error message includes the `npm root -g` value
+ *          AND lists both scopes searched, for operator diagnosis.
  */
 export function resolvePiCliPath(): string {
-	const relPath = join("@mariozechner", "pi-coding-agent", "dist", "cli.js");
-	const candidates: string[] = [];
+	const bases: string[] = [];
 
 	// 1. Dynamic: npm root -g (covers nvm, Homebrew, volta, custom npm prefix, etc.)
 	const npmRoot = getNpmGlobalRoot();
-	if (npmRoot) candidates.push(join(npmRoot, relPath));
+	if (npmRoot) bases.push(npmRoot);
 
 	// 2-3. Static Windows fallbacks
 	const home = process.env.HOME || process.env.USERPROFILE || "";
 	if (process.env.APPDATA) {
-		candidates.push(join(process.env.APPDATA, "npm", "node_modules", relPath));
+		bases.push(join(process.env.APPDATA, "npm", "node_modules"));
 	}
 	if (home) {
-		candidates.push(join(home, "AppData", "Roaming", "npm", "node_modules", relPath));
+		bases.push(join(home, "AppData", "Roaming", "npm", "node_modules"));
 		// 4. macOS/Linux custom global prefix
-		candidates.push(join(home, ".npm-global", "lib", "node_modules", relPath));
+		bases.push(join(home, ".npm-global", "lib", "node_modules"));
 	}
 	// 5. macOS system Node / Linux
-	candidates.push(join("/usr", "local", "lib", "node_modules", relPath));
+	bases.push(join("/usr", "local", "lib", "node_modules"));
 	// 6. macOS Homebrew
-	candidates.push(join("/opt", "homebrew", "lib", "node_modules", relPath));
+	bases.push(join("/opt", "homebrew", "lib", "node_modules"));
 
-	for (const candidate of candidates) {
-		if (existsSync(candidate)) return candidate;
+	// Cross product: scope is the inner loop so a single base directory is
+	// fully exhausted (new scope, then legacy scope) before falling back to
+	// the next base. This matches operator intuition ("check the most likely
+	// install location for either scope first").
+	for (const base of bases) {
+		for (const scope of PI_PACKAGE_SCOPES) {
+			const candidate = join(base, scope, "pi-coding-agent", "dist", "cli.js");
+			if (existsSync(candidate)) return candidate;
+		}
 	}
 
 	throw new Error(
-		"Cannot find Pi CLI entrypoint (@mariozechner/pi-coding-agent/dist/cli.js). " +
-		"Ensure the pi coding agent is installed globally via 'npm install -g @mariozechner/pi-coding-agent'. " +
+		"Cannot find Pi CLI entrypoint (pi-coding-agent/dist/cli.js) under any known npm scope " +
+		`(${PI_PACKAGE_SCOPES.join(" or ")}). ` +
+		"Install via 'npm install -g @earendil-works/pi-coding-agent' " +
+		"(or, for legacy installs, 'npm install -g @mariozechner/pi-coding-agent'). " +
 		`npm root -g returned: ${npmRoot || "(empty — npm may not be on PATH)"}`,
 	);
 }
@@ -189,12 +225,15 @@ export function resolveTaskplanePackageFile(repoRoot: string, relPath: string):
 	candidates.push(join("/opt", "homebrew", "lib", "node_modules", "taskplane", relPath));
 
 	// 8. Peer of pi's package (look adjacent to pi's CLI entrypoint).
-	// pi is at: <npmRoot>/@mariozechner/pi-coding-agent/dist/cli.js
-	// so piPkgDir = <npmRoot>/@mariozechner/pi-coding-agent  (resolve up 2 levels from cli.js)
-	// then go up TWO more levels to reach <npmRoot>, then into taskplane/
+	// pi is at: <npmRoot>/<scope>/pi-coding-agent/dist/cli.js (where <scope> is
+	//   @earendil-works (current) or @mariozechner (legacy)).
+	// so piPkgDir = <npmRoot>/<scope>/pi-coding-agent (resolve up 2 levels from cli.js).
+	// Then go up TWO more levels to reach <npmRoot>, then into taskplane/.
+	// This works regardless of which scope Pi is installed under because we
+	// only walk up the directory tree — we never name the scope explicitly.
 	try {
 		const piPath = process.argv[1] || "";
-		const piPkgDir = resolve(piPath, "..", ".."); // <npmRoot>/@mariozechner/pi-coding-agent
+		const piPkgDir = resolve(piPath, "..", ".."); // <npmRoot>/<scope>/pi-coding-agent
 		const npmRootFromPi = resolve(piPkgDir, "..", ".."); // <npmRoot>
 		candidates.push(join(npmRootFromPi, "taskplane", relPath));
 	} catch { /* ignore — process.argv[1] may be undefined in test contexts */ }