pi-crew 0.9.68 → 0.10.1

package/src/ui/powerbar-publisher.ts

@@ -4,6 +4,7 @@ import { listRecentRuns } from "../extension/run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { listLiveAgents, listLiveAgentsByWorkspace } from "../runtime/live-session/live-agent-manager.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
+import { isPlanApprovalPending } from "../runtime/plan-approval.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
@@ -87,6 +88,10 @@ export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUi
 		id: "pi-crew-steps",
 		label: "pi-crew workflow steps",
 	});
+	safeEmit(events, "powerbar:register-segment", {
+		id: "pi-crew-plan",
+		label: "pi-crew plan approval",
+	});
 }
 
 export function updatePiCrewPowerbar(
@@ -136,11 +141,40 @@ interface ActiveItem {
  * Build the workflow steps segment showing: ✓explore › →plan › ○execute › ○verify
  * with the current/active step highlighted using → arrow.
  */
-function buildStepsPayload(active: ActiveItem[], allTasks: TeamTaskState[]): PowerbarPayloadShape {
+export function buildStepsPayload(active: ActiveItem[], allTasks: TeamTaskState[]): PowerbarPayloadShape {
 	if (!active.length) {
 		return { id: "pi-crew-steps" };
 	}
 	const run = active[0]!.run;
+	// WP-7 (R7): plan-carrying runs show PLAN PHASES instead of workflow steps —
+	// the plan is the actual execution shape (a re-plan revision switches the
+	// segment without waiting for workflow steps that no longer apply).
+	const plans = active[0]!.snapshot?.plans;
+	if (plans && plans.length > 0) {
+		const current = plans[plans.length - 1]!;
+		const itemById = new Map(current.items.map((i) => [i.id, i]));
+		const statusOf = (ids: string[]): "completed" | "running" | "pending" => {
+			const items = ids.map((id) => itemById.get(id)?.status).filter(Boolean) as string[];
+			if (items.length && items.every((s) => s === "done")) return "completed";
+			if (items.some((s) => s === "active")) return "running";
+			return "pending";
+		};
+		const parts = current.phases.map((phase) => {
+			const status = phase.status === "done" ? "completed" : statusOf(phase.itemIds);
+			const icon = status === "completed" ? "✓" : status === "running" ? "→" : "○";
+			const name = phase.title.length > 10 ? `${phase.title.slice(0, 9)}…` : phase.title;
+			return `${icon}${name}`;
+		});
+		if (parts.length) {
+			const hasRunning = parts.some((p) => p.startsWith("→"));
+			const allComplete = parts.every((p) => p.startsWith("✓"));
+			return {
+				id: "pi-crew-steps",
+				text: `P${current.version} ${parts.join(" › ")}`,
+				color: allComplete ? "success" : hasRunning ? "accent" : "dim",
+			};
+		}
+	}
 	const workflowName = run.workflow ?? "default";
 	// Load workflow steps
 	const workflows = allWorkflows(discoverWorkflows(run.cwd));
@@ -206,6 +240,7 @@ class PowerbarPublisher {
 	#lastActiveKey: string | undefined;
 	#lastProgressKey: string | undefined;
 	#lastStepsKey: string | undefined;
+	#lastPlanKey: string | undefined;
 	#latestArgs: PowerbarUpdateArgs | null = null;
 	readonly #coalescer: RenderCoalescer;
 
@@ -279,9 +314,11 @@ class PowerbarPublisher {
 			this.#lastActiveKey = undefined;
 			this.#lastProgressKey = undefined;
 			this.#lastStepsKey = undefined;
+			this.#lastPlanKey = undefined;
 			safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 			safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
 			safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
+			safeEmit(events, "powerbar:update", { id: "pi-crew-plan" });
 			return;
 		}
 		const agents = active.flatMap((item) => item.agents);
@@ -373,6 +410,12 @@ class PowerbarPublisher {
 		} as const;
 		// Build step progress: "explorer > planner > executor > verifier" with current step highlighted
 		const stepsPayload = buildStepsPayload(active, tasks);
+		// WP-3 (H4): plan-approval segment — `plan:pending` while ANY active run is
+		// parked awaiting plan approval, clear payload otherwise. `item.run` is
+		// always the freshest manifest available (snapshot.manifest when cached).
+		const planPayload: PowerbarPayloadShape = active.some((item) => isPlanApprovalPending(item.run))
+			? { id: "pi-crew-plan", text: "plan:pending", color: "warning" }
+			: { id: "pi-crew-plan" };
 		// 1.8: dedup per segment using a key over every visible field. Previously
 		// the dedup string only carried text/suffix/running, so changes to `bar`
 		// (progress %) or `color` could be swallowed and stale UI emitted again
@@ -380,6 +423,7 @@ class PowerbarPublisher {
 		const activeKey = powerbarKey(activePayload);
 		const progressKey = powerbarKey(progressPayload);
 		const stepsKey = powerbarKey(stepsPayload);
+		const planKey = powerbarKey(planPayload);
 		if (activeKey !== this.#lastActiveKey) {
 			this.#lastActiveKey = activeKey;
 			safeEmit(events, "powerbar:update", activePayload);
@@ -392,6 +436,10 @@ class PowerbarPublisher {
 			this.#lastStepsKey = stepsKey;
 			safeEmit(events, "powerbar:update", stepsPayload);
 		}
+		if (planKey !== this.#lastPlanKey) {
+			this.#lastPlanKey = planKey;
+			safeEmit(events, "powerbar:update", planPayload);
+		}
 		// Never call setStatusFallback - crew-widget manages "pi-crew" status with its own widget format
 		// Powerbar only emits events; it does not set status directly
 	}
@@ -431,9 +479,11 @@ class PowerbarPublisher {
 		this.#lastActiveKey = undefined;
 		this.#lastProgressKey = undefined;
 		this.#lastStepsKey = undefined;
+		this.#lastPlanKey = undefined;
 		safeEmit(events, "powerbar:update", { id: "pi-crew-active" });
 		safeEmit(events, "powerbar:update", { id: "pi-crew-progress" });
 		safeEmit(events, "powerbar:update", { id: "pi-crew-steps" });
+		safeEmit(events, "powerbar:update", { id: "pi-crew-plan" });
 	}
 
 	/** Reset dedup state on session lifecycle events. */
@@ -441,6 +491,7 @@ class PowerbarPublisher {
 		this.#lastActiveKey = undefined;
 		this.#lastProgressKey = undefined;
 		this.#lastStepsKey = undefined;
+		this.#lastPlanKey = undefined;
 	}
 
 	dispose(): void {

package/src/ui/run-dashboard.ts

@@ -3,6 +3,7 @@ import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { getLiveAgentContextPercent } from "../runtime/live-session/live-agent-manager.ts";
+import { isPlanApprovalPending } from "../runtime/plan-approval.ts";
 import { isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { aggregateUsage } from "../state/usage.ts";
@@ -16,6 +17,7 @@ import { summarizeTerminalReason } from "./dashboard-panes/cancellation-pane.ts"
 import { renderHealthPane } from "./dashboard-panes/health-pane.ts";
 import { renderMailboxPane } from "./dashboard-panes/mailbox-pane.ts";
 import { renderMetricsPane } from "./dashboard-panes/metrics-pane.ts";
+import { renderPlanPane } from "./dashboard-panes/plan-pane.ts";
 import { renderProgressPane } from "./dashboard-panes/progress-pane.ts";
 import { renderTranscriptPane } from "./dashboard-panes/transcript-pane.ts";
 import { DynamicCrewBorder } from "./dynamic-border.ts";
@@ -75,7 +77,7 @@ export interface RunDashboardOptions {
  * looking at. Resetting to "agents" on every `new RunDashboard(...)` was a
  * UX regression.
  */
-let lastActivePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" = "agents";
+let lastActivePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" | "plan" = "agents";
 
 export type RunDashboardAction =
 	| "status"
@@ -94,6 +96,8 @@ export type RunDashboardAction =
 	| "health-recovery"
 	| "health-kill-stale"
 	| "health-diagnostic-export"
+	| "plan-approve"
+	| "plan-deny"
 	| "notifications-dismiss";
 export interface RunDashboardSelection {
 	runId: string;
@@ -404,7 +408,9 @@ export class RunDashboard implements DashboardComponent {
 	private runScrollOffset = 0;
 	private showFullProgress = false;
 	private showHelp = false;
-	private activePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" = lastActivePane;
+	private activePane: "agents" | "progress" | "mailbox" | "output" | "health" | "metrics" | "plan" = lastActivePane;
+	/** WP-7 (R7): pane-scoped revision-diff toggle (X). */
+	private planDiff = false;
 	private runs: TeamRunManifest[];
 	private readonly done: (selection: RunDashboardSelection | undefined) => void;
 	private readonly theme: CrewTheme;
@@ -638,7 +644,7 @@ export class RunDashboard implements DashboardComponent {
 				lines.push(
 					border("╭", "╮"),
 					row(
-						`${fg("accent", "▐")} ${this.theme.bold("pi-crew")} · ${this.runs.length} runs  ${fg("dim", "1-6 pane · ↑↓ · Enter · ? help · Esc")}`,
+						`${fg("accent", "▐")} ${this.theme.bold("pi-crew")} · ${this.runs.length} runs  ${fg("dim", "1-7 pane · ↑↓ · Enter · ? help · Esc")}`,
 					),
 					sep(),
 				);
@@ -732,7 +738,9 @@ export class RunDashboard implements DashboardComponent {
 															registry: this.options.registry,
 														}),
 													)
-												: safeRenderPane("transcript", () => renderTranscriptPane(snap))
+												: this.activePane === "plan"
+													? safeRenderPane("plan", () => renderPlanPane(snap, { diff: this.planDiff }))
+													: safeRenderPane("transcript", () => renderTranscriptPane(snap))
 							: [...readAgentPreview(r, 4, this.options), ...readProgressPreview(r, 2, this.options.snapshotCache)];
 						const filteredPane = paneLines.filter((l) => l && !l.includes("(none)") && l.trim() !== "");
 						if (filteredPane.length > 0) {
@@ -832,6 +840,19 @@ export class RunDashboard implements DashboardComponent {
 			this.done(selectedRunId ? { runId: selectedRunId, action: "status" } : undefined);
 			return;
 		}
+		// WP-3 (H4-subset): plan approval keys. Deliberately a DEDICATED branch
+		// (not the generic union block below) because plan actions must gate on
+		// the selected run actually being parked on a pending approval — a
+		// stray keystroke on a non-pending run is a silent no-op (dashboard
+		// stays open) instead of closing it via done(undefined).
+		if (action === "plan-approve" || action === "plan-deny") {
+			const run = selectedRunFromGrouped(this.runs, this.selected, this.options.snapshotCache);
+			const manifest = run ? (snapshotFor(run, this.options.snapshotCache)?.manifest ?? run) : undefined;
+			if (run && manifest && isPlanApprovalPending(manifest)) {
+				this.done({ runId: run.runId, action });
+			}
+			return;
+		}
 		if (
 			action === "summary" ||
 			action === "artifacts" ||
@@ -875,7 +896,12 @@ export class RunDashboard implements DashboardComponent {
 		else if (action === "pane-output") this.activePane = "output";
 		else if (action === "pane-health") this.activePane = "health";
 		else if (action === "pane-metrics") this.activePane = "metrics";
-		else if (action === "up") this.selected = Math.max(0, this.selected - 1);
+		else if (action === "pane-plan") this.activePane = "plan";
+		else if (action === "plan-diff") {
+			this.planDiff = !this.planDiff;
+			this.invalidate();
+			return;
+		} else if (action === "up") this.selected = Math.max(0, this.selected - 1);
 		else if (action === "down") {
 			const selectableCount = groupedRuns(this.runs, this.options.snapshotCache).filter((row) => row.run).length;
 			this.selected = Math.min(Math.max(0, selectableCount - 1), this.selected + 1);

package/src/ui/run-snapshot-cache.ts

@@ -1,12 +1,14 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { getCrewEnv } from "../config/env-vars.ts";
 import { agentOutputPath, agentsPath, readCrewAgents, readCrewAgentsAsync } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isActiveRunStatus } from "../runtime/process-status.ts";
 import type { MailboxMessageStatus } from "../state/coordination/mailbox.ts";
 import type { TeamEvent } from "../state/event-log/event-log.ts";
 import { sequencePath } from "../state/event-log/event-log.ts";
+import { loadPlanRecords, planFilePath } from "../state/stores/plan-store.ts";
 import { loadRunManifestById, loadRunManifestByIdAsync } from "../state/stores/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { extractDwfPhaseState } from "./dwf-phase-display.ts";
@@ -25,6 +27,12 @@ export interface RunSnapshotCache extends RunSnapshotCacheBase {
 	preloadAllStale(runIds: string[]): Promise<void>;
 }
 
+/** WP-7 (R7): the plans slice + Plan pane load only when this flag is set —
+ *  flag-off keeps the snapshot build byte-identical (zero extra I/O). */
+export function isPlanUiEnabled(): boolean {
+	return getCrewEnv("PI_CREW_PLAN_UI") === "1";
+}
+
 const DEFAULT_TTL_MS = 1500;
 const DEFAULT_MAX_ENTRIES = 24;
 const DEFAULT_RECENT_EVENTS = 20;
@@ -44,6 +52,8 @@ interface SnapshotStamps {
 	agents: FileStamp;
 	events: FileStamp;
 	mailbox: FileStamp;
+	/** WP-7 (R7): present only when PI_CREW_PLAN_UI=1. */
+	plans?: FileStamp;
 }
 
 interface CacheEntry {
@@ -163,15 +173,10 @@ function safeAgentOutputPath(manifest: TeamRunManifest, agent: CrewAgentRecord):
 	}
 }
 
-function outputStamp(manifest: TeamRunManifest, agents: CrewAgentRecord[]): FileStamp {
-	return combineStamps(agents.map((agent) => stampFile(safeAgentOutputPath(manifest, agent))));
-}
-
-async function outputStampAsync(manifest: TeamRunManifest, agents: CrewAgentRecord[]): Promise<FileStamp> {
-	return combineStamps(await Promise.all(agents.map((agent) => stampFileAsync(safeAgentOutputPath(manifest, agent)))));
-}
-
-function sameStamp(a: FileStamp, b: FileStamp): boolean {
+function sameStamp(a: FileStamp | undefined, b: FileStamp | undefined): boolean {
+	// Optional stamps (WP-7 plans): absent on both sides = unchanged; absent
+	// on one side = the flag flipped — force a rebuild.
+	if (a === undefined || b === undefined) return a === b;
 	return a.mtimeMs === b.mtimeMs && a.size === b.size;
 }
 
@@ -181,19 +186,11 @@ function sameStamps(a: SnapshotStamps, b: SnapshotStamps): boolean {
 		sameStamp(a.tasks, b.tasks) &&
 		sameStamp(a.agents, b.agents) &&
 		sameStamp(a.events, b.events) &&
-		sameStamp(a.mailbox, b.mailbox)
+		sameStamp(a.mailbox, b.mailbox) &&
+		sameStamp(a.plans, b.plans)
 	);
 }
 
-function readTasks(tasksPath: string): TeamTaskState[] {
-	try {
-		const parsed = JSON.parse(fs.readFileSync(tasksPath, "utf-8")) as unknown;
-		return Array.isArray(parsed) ? (parsed as TeamTaskState[]) : [];
-	} catch {
-		throw new Error(`Failed to parse tasks at ${tasksPath}`);
-	}
-}
-
 /** Tail-read JSONL lines from a file, returning parsed objects (limited). */
 function tailJsonlLines<T>(filePath: string, limit: number, parse: (line: string) => T | undefined): T[] {
 	if (limit <= 0) return [];
@@ -711,6 +708,21 @@ function computeSliceSignatures(input: Omit<RunUiSnapshot, "signature" | "fetche
 				event.data?.reason,
 			]),
 		),
+		...(input.plans
+			? {
+					// WP-7 (R7): plan writes (revision append / approval flip / item
+					// linkage) must invalidate the Plan pane. Plans live outside the
+					// stamped files' content — the slice hashes the records directly.
+					plans: hash(
+						input.plans.map((record) => [
+							record.version,
+							record.approval?.status,
+							record.items.map((item) => [item.id, item.status, item.taskIds]),
+							record.phases.map((p) => [p.id, p.status]),
+						]),
+					),
+				}
+			: {}),
 	};
 }
 
@@ -723,7 +735,21 @@ function signatureFor(
 		const digest = createHash("sha256");
 		digest.update(
 			JSON.stringify({
-				run: [input.manifest.runId, input.manifest.status, input.manifest.updatedAt, input.manifest.artifacts.length],
+				// WP-3 (H4): planApproval.status is a RUN-level field surfaced by the
+				// widget badge / progress banner / powerbar segment — pending→approved
+				// must flip the signature so per-run render caches (run-dashboard keys
+				// on snapshot.signature) invalidate. `undefined` serializes as null,
+				// keeping the array shape stable for older manifests without the field.
+				run: [
+					input.manifest.runId,
+					input.manifest.status,
+					input.manifest.updatedAt,
+					input.manifest.artifacts.length,
+					input.manifest.planApproval?.status,
+					// T2/R4 (ADR-4 §2): a re-plan (revision switch) or record-side
+					// approval flip must invalidate per-run render caches too.
+					input.manifest.plan?.version ?? null,
+				],
 				tasks: sliceSignatures.tasks,
 				agents: sliceSignatures.agents,
 				progress: input.progress,
@@ -731,6 +757,7 @@ function signatureFor(
 				mailbox: input.mailbox,
 				groupJoins: input.groupJoins,
 				events: sliceSignatures.events,
+				...(sliceSignatures.plans ? { plans: sliceSignatures.plans } : {}),
 				cancellationReason: input.cancellationReason,
 				dwfPhaseState: input.dwfPhaseState,
 				output: input.recentOutputLines,
@@ -744,16 +771,8 @@ function signatureFor(
 	}
 }
 
-/**
- * 1.6 / 1.7 — compute one short hash per logical slice of the snapshot so
- * dashboard panes / widget can short-circuit when their slice hasn't moved.
- * The slice contents must mirror what `signatureFor` packs into each branch.
- */
-function sliceSignaturesFor(sliceSignatures: SliceSignatures): SliceSignatures {
-	return sliceSignatures;
-}
-
 function stampsFor(manifest: TeamRunManifest, _agents: CrewAgentRecord[]): SnapshotStamps {
+	// WP-7: optional plans stamp — one extra statSync, flag-gated.
 	// 1.4: use events sequence file instead of stat-ing the events log directly.
 	// 1.5: drop per-agent output.log stamping; rely on event-bus invalidation
 	// (`crew.subagent.*` and stream events) and on agents.json mtime which
@@ -765,6 +784,7 @@ function stampsFor(manifest: TeamRunManifest, _agents: CrewAgentRecord[]): Snaps
 		agents: stampFile(agentsPath(manifest)),
 		events: eventsStamp(manifest.eventsPath),
 		mailbox: mailboxStamp(manifest),
+		...(isPlanUiEnabled() ? { plans: stampFile(planFilePath(manifest)) } : {}),
 	};
 }
 
@@ -834,7 +854,12 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		let tasks: TeamTaskState[];
 		let agents: CrewAgentRecord[];
 		try {
-			tasks = readTasks(loaded.manifest.tasksPath);
+			// R10-4 (docs/refactor-plan.review.md §ROUND 10): sync/async parity.
+			// loadRunManifestById already returns tasks validated against the
+			// current tasks.json (mtime+size+generation check in state-store),
+			// so the old readTasks() re-read only doubled tasks.json I/O per
+			// sync rebuild. buildAsync() has always used loaded.tasks.
+			tasks = loaded.tasks;
 			agents = readCrewAgents(loaded.manifest);
 		} catch {
 			if (previous) return previous;
@@ -857,6 +882,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			dwfPhaseState: extractDwfPhaseState(recentEvents),
 			recentEvents,
 			recentOutputLines: recentOutputLines(loaded.manifest, agents, recentOutputLimit),
+			...(isPlanUiEnabled() ? { plans: loadPlanRecords(loaded.manifest) } : {}),
 		};
 		const stamps = stampsFor(loaded.manifest, agents);
 		const sliceSignatures = computeSliceSignatures(base);
@@ -915,6 +941,7 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			dwfPhaseState: extractDwfPhaseState(recentEvents),
 			recentEvents,
 			recentOutputLines: recentOutput,
+			...(isPlanUiEnabled() ? { plans: loadPlanRecords(loaded.manifest) } : {}),
 		};
 		const stamps = await stampsForAsync(loaded.manifest, agents);
 		const sliceSignatures = computeSliceSignatures(base);

package/src/ui/snapshot-types.ts

@@ -1,6 +1,6 @@
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import type { TeamEvent } from "../state/event-log/event-log.ts";
-import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import type { PlanRecord, TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import type { DwfPhaseState } from "./dwf-phase-display.ts";
 
 export interface RunUiProgress {
@@ -64,6 +64,8 @@ export interface RunUiSnapshot {
 		mailbox: string;
 		progress: string;
 		events: string;
+		/** WP-7 (R7): present only when the plans slice is loaded (flag on). */
+		plans?: string;
 	};
 	manifest: TeamRunManifest;
 	tasks: TeamTaskState[];
@@ -76,6 +78,9 @@ export interface RunUiSnapshot {
 	cancellationReason?: string;
 	/** DWF phase state derived from `recentEvents`. Null/absent for non-DWF runs. */
 	dwfPhaseState?: DwfPhaseState | null;
+	/** WP-7 (R7): plan records for the Plan pane — populated ONLY when
+	 *  PI_CREW_PLAN_UI=1 (flag-off → field absent, zero extra I/O). */
+	plans?: PlanRecord[];
 	recentEvents: TeamEvent[];
 	recentOutputLines: string[];
 }

package/src/ui/widget/widget-renderer.ts

@@ -5,6 +5,7 @@
  */
 
 import { listLiveAgents } from "../../runtime/live-session/live-agent-manager.ts";
+import { isPlanApprovalStatePending } from "../../runtime/plan-approval.ts";
 import { isFinishedRunStatus } from "../../runtime/process-status.ts";
 import { truncate } from "../../utils/visual.ts";
 import { Box, Text } from "../layout-primitives.ts";
@@ -73,7 +74,14 @@ export function buildWidgetLines(
 			return Number.isFinite(age) && age < maxAgeMs;
 		});
 		const completed = agents.filter((a) => a.status === "completed").length;
-		const runGlyph = iconForStatus(run.status, { runningGlyph });
+		// WP-3 (H4): while a run is parked awaiting plan approval, the spinner
+		// glyph is replaced by a `⚠ plan:<last-8 runId>` badge. Plain-unicode ⚠
+		// (the same glyph needs_attention already uses) stays legible in no-color
+		// mode and is colorized by the shared colorizeStatusGlyphs pass. In-place
+		// glyph swap only — no extra line, so the MAX_AGENTS_DISPLAY / maxLines
+		// budget and the truncate(width) rule are untouched.
+		const planPending = isPlanApprovalStatePending(run.planApproval);
+		const runGlyph = planPending ? `⚠ plan:${run.runId.slice(-8)}` : iconForStatus(run.status, { runningGlyph });
 		const isTerminal = isFinishedRunStatus(run.status);
 		// Run progress line. v1–v3 flickered on snapshot.tasks state, v4 was
 		// too minimal (`0/1 agents` only), v5 duplicated the worker activity

package/src/utils/file-coalescer.ts

@@ -63,10 +63,6 @@ function evictOldestCacheEntry(): void {
 	if (oldestKey !== undefined) readCache.delete(oldestKey);
 }
 
-export function clearReadCache(): void {
-	readCache.clear();
-}
-
 export function readJsonFileCoalesced<T>(filePath: string, ttlMs: number, read: () => T): T {
 	const now = Date.now();
 	const stat = (() => {

package/src/utils/fs-errno.ts

@@ -0,0 +1,66 @@
+/**
+ * Fatal-filesystem errno classification (bug-026 sub-issue B).
+ *
+ * During the 2026-08-15 disk-full window, workers died with generic
+ * "unresponsive"/ETIMEDOUT diagnostics — the ENOSPC errno only surfaced
+ * inside stderr-tail strings embedded in the E007 ChildTimeout message
+ * (`errors.ts` childTimeout appends "Stderr tail: ..."), never as a raw
+ * errno object in the parent process. The classifier therefore matches BOTH
+ * shapes:
+ *  - (a) `err.code` (NodeJS.ErrnoException) case-insensitively, and
+ *  - (b) the error's message text — or any plain string, e.g. a stderr tail.
+ *
+ * Deliberately NOT placed in state/atomic-write.ts: that module has
+ * process.on side effects at module load and imports worker-atomic-writer,
+ * and it already throws raw errno errors — classification belongs at catch
+ * sites. This module is dependency-free so state/types.ts (type-only) and
+ * the team-tool run/doctor surfaces can import it cheaply.
+ */
+
+export type FatalFsCause = "enospc" | "edquot" | "emfile" | "enfile";
+
+const FATAL_FS_CODES: ReadonlySet<string> = new Set(["enospc", "edquot", "emfile", "enfile"]);
+
+/** Message-text fallback: catches errno codes embedded in stderr tails /
+ *  synthesized error messages where no structured `.code` exists. */
+const FATAL_FS_TEXT = /\b(ENOSPC|EDQUOT|EMFILE|ENFILE)\b/;
+
+function classifyCode(code: unknown): FatalFsCause | undefined {
+	if (typeof code !== "string") return undefined;
+	const normalized = code.toLowerCase();
+	return FATAL_FS_CODES.has(normalized) ? (normalized as FatalFsCause) : undefined;
+}
+
+function classifyText(text: unknown): FatalFsCause | undefined {
+	if (typeof text !== "string") return undefined;
+	const match = FATAL_FS_TEXT.exec(text);
+	return match ? (match[1]?.toLowerCase() as FatalFsCause) : undefined;
+}
+
+/**
+ * Classify an unknown error (or a raw string, e.g. a child stderr tail) as a
+ * fatal filesystem cause. Returns undefined for non-fs errors. Pure and total:
+ * never throws on non-object inputs.
+ */
+export function classifyFatalFsError(err: unknown): FatalFsCause | undefined {
+	if (typeof err === "string") return classifyText(err);
+	if (err === null || err === undefined) return undefined;
+	const code = classifyCode((err as NodeJS.ErrnoException).code);
+	if (code) return code;
+	return classifyText((err as { message?: unknown }).message);
+}
+
+/**
+ * Combined classification for a finished attempt (bug-026 sub-issue B):
+ * the assembled attempt error first — a structured errno or a message that
+ * embeds one (E007 stderr tails) — then the child's stderr tail. Extracted
+ * as a pure seam so the child-executor hook is directly unit-testable.
+ */
+export function failureCauseForAttempt(error: string | undefined, stderr: string | undefined): FatalFsCause | undefined {
+	return classifyFatalFsError(error) ?? classifyFatalFsError(stderr);
+}
+
+/** Human label for a fatal fs cause. */
+export function fsFailureLabel(cause: FatalFsCause): string {
+	return cause === "enospc" || cause === "edquot" ? "disk full" : "too many open files";
+}

package/src/utils/fs-watch.ts

@@ -10,7 +10,7 @@ import * as fs from "node:fs";
  * caused a permanent interactive-session busy-loop. The bounded
  * {@link RunWatcherRegistry} (one non-recursive watcher per ACTIVE run) now
  * replaces them. Only the two primitives below survive — they are still used by
- * manifest-cache, result-watcher, and run-watcher-registry.
+ * manifest-cache and run-watcher-registry.
  */
 
 export function closeWatcher(watcher: FSWatcher | null | undefined): void {

package/src/utils/internal-error.ts

@@ -1,7 +1,9 @@
+import { getCrewEnv } from "../config/env-vars.ts";
+
 export function logInternalError(scope: string, error: unknown, details?: string, severity?: "error" | "warn" | "debug"): void {
 	// "error" and "warn" always emit; "debug" (default) is gated behind PI_TEAMS_DEBUG
 	if (!severity || severity === "debug") {
-		if (!process.env.PI_TEAMS_DEBUG) return;
+		if (!getCrewEnv("PI_TEAMS_DEBUG")) return;
 	}
 	const message =
 		error instanceof Error ? error.message : typeof error === "object" && error !== null ? JSON.stringify(error) : String(error);

package/src/utils/paths.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { getCrewEnv } from "../config/env-vars.ts";
 
 // NEW-P1/NEW-P2 (perf): packageRoot() and userPiRoot() are invariant for a
 // process lifetime but each call did statSync/readFileSync/lstatSync (10-15+
@@ -55,7 +56,7 @@ export function userPiRoot(): string {
 	// "undefined/.pi/agent" relative to cwd and silently create a junk "undefined/"
 	// tree. Treat the literal "undefined" (and empty) as unset and fall back to
 	// os.homedir().
-	const rawHome = (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim();
+	const rawHome = getCrewEnv("PI_CREW_HOME")?.trim();
 	const home = rawHome && rawHome !== "undefined" ? rawHome : os.homedir();
 	// NEW-P2: memoize but KEY ON HOME. Tests (withIsolatedHome / isolateHome)
 	// change PI_TEAMS_HOME mid-process; an unkeyed cache would leak the first
@@ -203,8 +204,15 @@ export function findRepoRoot(cwd: string): string | undefined {
 function computeRepoRoot(start: string): string | undefined {
 	let current = start;
 	const root = path.parse(current).root;
-	const home = path.resolve(os.homedir());
-	const tempRoot = path.resolve(os.tmpdir());
+	// Canonicalize the boundaries to match the walk chain: findRepoRoot
+	// resolves the start dir via realpathSync, so every step of the walk is a
+	// canonical path. Comparing against the LEXICAL home/tmpdir lets symlinked
+	// temp dirs (macOS: /var -> /private/var, TMPDIR=/var/folders/.../T) never
+	// match, so the walk escapes the sandbox and can latch onto an unrelated
+	// ancestor marker (seen live: GH macOS runners have one) — state then
+	// resolves to a repo root far outside the temp tree (bug-029).
+	const home = canonicalizePath(path.resolve(os.homedir()));
+	const tempRoot = canonicalizePath(path.resolve(os.tmpdir()));
 	while (current !== root) {
 		// Stop walking before checking markers at home or temp root
 		if (current === home || current === tempRoot) return undefined;

package/src/utils/task-name-generator.ts

@@ -295,7 +295,7 @@ function capitalize(s: string): string {
 	return s.charAt(0).toUpperCase() + s.slice(1);
 }
 
-let usedNames = new Set<string>();
+const usedNames = new Set<string>();
 
 /**
  * Generate a unique two-word identifier (e.g., "SwiftFalcon").
@@ -328,10 +328,3 @@ export function generateTaskName(): string {
 	usedNames.clear();
 	return generateTaskName();
 }
-
-/**
- * Reset name generator state (for testing).
- */
-export function resetTaskNames(): void {
-	usedNames = new Set<string>();
-}