pi-crew 0.10.2 → 0.10.3

package/src/extension/team-tool/doctor.ts

@@ -6,13 +6,18 @@ import { loadConfig } from "../../config/config.ts";
 import { DEFAULT_PATHS } from "../../config/defaults.ts";
 import { type DriftReport, detectDrift, formatDriftReport } from "../../config/drift-detector.ts";
 import { buildConfiguredModelRouting, resolveModelFallbackPolicy } from "../../runtime/model/model-fallback.ts";
+import { getPiTempBase } from "../../runtime/model/pi-args.ts";
 import { getRuntimeWarmupStatus } from "../../runtime/model/runtime-warmup.ts";
 import { currentSessionModel, sessionModelSnapshot } from "../../runtime/model/session-model.ts";
 import { getPiSpawnCommand } from "../../runtime/pi-spawn.ts";
-import { formatZombieReport, scanZombieSubagents } from "../../runtime/process/zombie-scanner.ts";
+import { formatZombieReport, scanZombieSubagents, type ZombieScanResult } from "../../runtime/process/zombie-scanner.ts";
+import { launchScriptRegistry, sweepLaunchScripts, sweepOrphanLaunchScriptFiles } from "../../runtime/surface/launch-script.ts";
+import { surfaceProviderForCleanup } from "../../runtime/surface/resolve-surface.ts";
+import type { SurfaceProvider } from "../../runtime/surface/surface-provider.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { TeamToolParams } from "../../schema/team-tool-schema.ts";
-import { atomicWriteFile } from "../../state/atomic-write.ts";
+import { atomicWriteFile, atomicWriteJson } from "../../state/atomic-write.ts";
+import { TEAM_TERMINAL_RUN_STATUSES } from "../../state/contracts.ts";
 import { allTeams, discoverTeams } from "../../teams/discover-teams.ts";
 import { type FatalFsCause, fsFailureLabel } from "../../utils/fs-errno.ts";
 import { projectCrewRoot, userCrewRoot } from "../../utils/paths.ts";
@@ -514,13 +519,356 @@ export function buildTeamDoctorReport(input: TeamDoctorReportInput): TeamDoctorR
 	};
 }
 
-export function handleDoctor(ctx: TeamContext, params: TeamToolParamsValue = {}): PiTeamsToolResult {
-	// Sub-focus: zombie sub-agent scan. READ-ONLY — never kills. Returns a table of
-	// orphaned pi-crew sub-agents identified by the authoritative PI_CREW_KIND=subagent
-	// marker. The user's main session never carries that marker, so it can never appear.
+// ── T12: orphan surface-pane cleanup (doctor focus=zombies) ─────────────────
+//
+// Three orphan sources:
+//  1. zombie scan — a sub-agent whose crew parent died while carrying
+//     PI_CREW_SURFACE/PI_CREW_SURFACE_PANE: the pane outlived its host.
+//  2. terminal-run manifests — a finished run whose manifest.surface.panes
+//     still has entries (host died before releaseSurfacePane). Those panes
+//     hold the live-pane cap hostage for the rest of the run (T11 residual);
+//     doctor is the sweep that finally releases them.
+//  3. terminal-run manifests' surface.tabs (tab-layout Task 6) — a finished
+//     run whose tabs entry still carries tab ids: the host died before
+//     closeTabForRun ran in its finally block. Doctor closes each tab BY ID
+//     (its own process never owned the provider's tabKey map) and clears the
+//     manifest entry only once the mux confirmed every tab id resolved.
+//
+// Closing is gated on provider.detect() — if the mux is unavailable the panes
+// are listed without any close attempt (fail-open list-only, never close blind).
+
+/** How many most-recent run manifests to scan for orphan panes. */
+const ORPHAN_RUN_SCAN_LIMIT = 10;
+
+export interface OrphanSurfacePane {
+	paneId: string;
+	kind: "tmux" | "herdr";
+	/** Provenance line for the human, e.g. `zombie-scan pid 4242`. */
+	source: string;
+}
+
+/**
+ * Tab-layout Task 6: một entry `surface.tabs[tabKey]` còn tabIds trên manifest
+ * của run TERMINAL — ứng viên orphan, phải liveness-check từng tabId qua mux
+ * (closeTabById) trước khi đóng (doctor chạy ở process khác host đã spawn nên
+ * map nội bộ tabKey của provider trống ở đây — KHÔNG dùng closeTab(tabKey)).
+ */
+export interface OrphanSurfaceTab {
+	runId: string;
+	tabKey: string;
+	/** Mọi tab/window id của entry (run dài vượt MAX_PANES_PER_TAB có nhiều). */
+	tabIds: string[];
+	kind: "tmux" | "herdr";
+	manifestPath: string;
+}
+
+export interface DoctorSurfaceCleanupDeps {
+	/** Provider per kind — injectable so tests never touch a real mux. */
+	providers?: Partial<Record<"tmux" | "herdr", SurfaceProvider>>;
+	/** Clock (ms epoch) for the script TTL sweep — default Date.now. */
+	now?: () => number;
+	/** Launch-script temp base (default getPiTempBase()). */
+	tempBase?: string;
+	/** Max recent run manifests scanned — 0 skips the manifest source. */
+	runScanLimit?: number;
+}
+
+export interface DoctorSurfaceCleanupResult {
+	orphans: OrphanSurfacePane[];
+	/** Pane ids successfully closed via provider.closeSurface. */
+	closed: string[];
+	/** Pane ids the mux no longer knows — nothing to close, not a failure. */
+	gone: string[];
+	failures: { paneId: string; error: string }[];
+	/** Tabs của terminal runs còn tabIds trên manifest (tab-layout Task 6). */
+	orphanTabs: OrphanSurfaceTab[];
+	/** Tab ids closed directly by id via provider.closeTabById. */
+	tabsClosed: string[];
+	/** Tab ids the mux no longer knows — liveness confirmed dead, not a failure. */
+	tabsGone: string[];
+	tabFailures: { tabId: string; error: string }[];
+	/** Launch scripts removed from disk + registry (orphan script sweep, T5). */
+	scriptsSwept: number;
+	/** Why a provider kind was skipped (listed-only). */
+	providerNotes: string[];
+}
+
+/** TERMINAL-run manifest record đọc từ đĩa — nguồn chung cho pane + tab orphans. */
+interface TerminalRunManifestRecord {
+	runId: string;
+	manifestPath: string;
+	manifest: Record<string, unknown>;
+	kind: "tmux" | "herdr";
+}
+
+/** Panes recorded on TERMINAL runs' manifests — the T11 residual leak. */
+function collectTerminalRunOrphanPanes(records: TerminalRunManifestRecord[]): OrphanSurfacePane[] {
+	const orphans: OrphanSurfacePane[] = [];
+	for (const record of records) {
+		const surface = record.manifest.surface as { panes?: unknown } | undefined;
+		if (!surface?.panes || typeof surface.panes !== "object") continue;
+		for (const [taskId, paneId] of Object.entries(surface.panes as Record<string, unknown>)) {
+			if (typeof paneId !== "string" || paneId === "") continue;
+			orphans.push({ paneId, kind: record.kind, source: `run ${record.runId} task ${taskId} (terminal)` });
+		}
+	}
+	return orphans;
+}
+
+/**
+ * Tabs recorded on TERMINAL runs' manifests (tab-layout Task 5/6). Manifest
+ * TRÊN ĐĨA GIỮ tabIds sau run end làm evidence — entry non-empty trên run
+ * terminal nghĩa là host chết trước khi closeTabForRun chạy ở finally. Đây
+ * chỉ là DANH SÁCH ứng viên; doctor liveness-check từng tabId qua mux
+ * (closeTabById) rồi mới close-by-ID idempotent — không bao giờ close mù.
+ */
+function collectTerminalRunOrphanTabs(records: TerminalRunManifestRecord[]): OrphanSurfaceTab[] {
+	const tabs: OrphanSurfaceTab[] = [];
+	for (const record of records) {
+		const surface = record.manifest.surface as { tabs?: unknown } | undefined;
+		if (!surface?.tabs || typeof surface.tabs !== "object") continue;
+		for (const [tabKey, tabIds] of Object.entries(surface.tabs as Record<string, unknown>)) {
+			if (!Array.isArray(tabIds)) continue;
+			const ids = tabIds.filter((id): id is string => typeof id === "string" && id !== "");
+			if (ids.length === 0) continue; // host đã closeTabForRun — không phải orphan
+			tabs.push({ runId: record.runId, tabKey, tabIds: ids, kind: record.kind, manifestPath: record.manifestPath });
+		}
+	}
+	return tabs;
+}
+
+/** TERMINAL-run manifests gần nhất (mới nhất trước) — đọc MỘT lần cho cả pane + tab orphans. */
+function readRecentRunManifests(cwd: string, limit: number): TerminalRunManifestRecord[] {
+	const runsRoot = path.join(projectCrewRoot(cwd), DEFAULT_PATHS.state.runsSubdir);
+	let recentRunIds: string[];
+	try {
+		recentRunIds = fs
+			.readdirSync(runsRoot, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => {
+				let mtimeMs = 0;
+				try {
+					mtimeMs = fs.statSync(path.join(runsRoot, entry.name)).mtimeMs;
+				} catch {
+					/* unreadable run dir — mtime 0 sorts last */
+				}
+				return { runId: entry.name, mtimeMs };
+			})
+			.sort((a, b) => b.mtimeMs - a.mtimeMs)
+			.slice(0, limit)
+			.map((entry) => entry.runId);
+	} catch {
+		return [];
+	}
+	const records: TerminalRunManifestRecord[] = [];
+	for (const runId of recentRunIds) {
+		const manifestPath = path.join(runsRoot, runId, "manifest.json");
+		let manifest: Record<string, unknown>;
+		try {
+			manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		} catch {
+			continue; // unreadable/absent manifest — nothing this run can tell us
+		}
+		if (typeof manifest.status !== "string" || !TEAM_TERMINAL_RUN_STATUSES.has(manifest.status as never)) continue;
+		const kind = (manifest.surface as { provider?: unknown } | undefined)?.provider;
+		if (kind !== "tmux" && kind !== "herdr") continue;
+		records.push({ runId, manifestPath, manifest, kind });
+	}
+	return records;
+}
+
+/**
+ * Collect + close orphan surface panes and sweep orphan launch scripts.
+ * Best-effort throughout: an error on one pane never aborts the rest, and a
+ * provider that fails detect() downgrades that kind to list-only.
+ */
+export async function cleanupOrphanSurfacePanes(input: {
+	cwd: string;
+	scan: ZombieScanResult;
+	deps?: DoctorSurfaceCleanupDeps;
+}): Promise<DoctorSurfaceCleanupResult> {
+	const deps = input.deps ?? {};
+	const now = deps.now ?? Date.now;
+
+	// Orphan launch-script sweep (optional T5): registry covers this process's
+	// scripts, disk glob covers scripts left by a dead host (they carry broker
+	// tokens, so a doctor run is the right moment to purge them).
+	let scriptsSwept = 0;
+	try {
+		scriptsSwept += sweepLaunchScripts(launchScriptRegistry, now());
+		scriptsSwept += sweepOrphanLaunchScriptFiles(deps.tempBase ?? getPiTempBase(), now());
+	} catch {
+		// best-effort — sweeping must never break the pane report
+	}
+
+	const orphans: OrphanSurfacePane[] = [];
+	const seen = new Set<string>();
+	for (const zombie of input.scan.zombies) {
+		if (!zombie.surface || !zombie.surfacePaneId || seen.has(zombie.surfacePaneId)) continue;
+		seen.add(zombie.surfacePaneId);
+		orphans.push({ paneId: zombie.surfacePaneId, kind: zombie.surface, source: `zombie-scan pid ${zombie.pid}` });
+	}
+	const runScanLimit = deps.runScanLimit ?? ORPHAN_RUN_SCAN_LIMIT;
+	// Tab-layout Task 6: terminal runs còn surface.tabs entry non-empty. Đây
+	// chỉ là ứng viên — KHÔNG đóng mù theo "tabs non-empty" (manifest giữ
+	// tabIds sau run end by-design); liveness + close-by-ID từng tabId qua mux.
+	const terminalRunManifests = runScanLimit > 0 ? readRecentRunManifests(input.cwd, runScanLimit) : [];
+	if (terminalRunManifests.length > 0) {
+		for (const orphan of collectTerminalRunOrphanPanes(terminalRunManifests)) {
+			if (seen.has(orphan.paneId)) continue;
+			seen.add(orphan.paneId);
+			orphans.push(orphan);
+		}
+	}
+	const orphanTabs = collectTerminalRunOrphanTabs(terminalRunManifests);
+
+	const providerNotes: string[] = [];
+	const providers = new Map<"tmux" | "herdr", SurfaceProvider>();
+	for (const kind of [...new Set([...orphans.map((orphan) => orphan.kind), ...orphanTabs.map((tab) => tab.kind)])]) {
+		const provider = deps.providers?.[kind] ?? surfaceProviderForCleanup(kind);
+		if (!provider) {
+			providerNotes.push(`${kind}: provider unavailable — panes listed only`);
+			continue;
+		}
+		try {
+			const detection = provider.detect();
+			if (!detection.ok) {
+				providerNotes.push(`${kind}: ${detection.reason ?? "not detected"} — panes listed only`);
+				continue;
+			}
+		} catch (error) {
+			providerNotes.push(`${kind}: detect threw (${error instanceof Error ? error.message : String(error)}) — panes listed only`);
+			continue;
+		}
+		providers.set(kind, provider);
+	}
+
+	const closed: string[] = [];
+	const gone: string[] = [];
+	const failures: { paneId: string; error: string }[] = [];
+	for (const orphan of orphans) {
+		const provider = providers.get(orphan.kind);
+		if (!provider) continue; // list-only — note already recorded per kind
+		try {
+			const handle = provider.attach(orphan.paneId);
+			if (!handle) {
+				gone.push(orphan.paneId);
+				continue;
+			}
+			// Attach của herdr là optimistic (interface sync không round-trip
+			// socket được) — xác minh pane còn sống trước khi đóng. tmux attach
+			// đã xác minh sync nhưng readScreen thêm một lần vẫn vô hại.
+			try {
+				await provider.readScreen(handle, 1);
+			} catch {
+				gone.push(orphan.paneId);
+				continue;
+			}
+			await provider.closeSurface(handle, { force: true });
+			closed.push(orphan.paneId);
+		} catch (error) {
+			failures.push({ paneId: orphan.paneId, error: error instanceof Error ? error.message : String(error) });
+		}
+	}
+
+	// Tab-layout Task 6: đóng tab orphan theo tabId TRỰC TIẾP. Doctor chạy ở
+	// process khác host đã spawn nên map nội bộ tabKey của provider.closeTab
+	// TRỐNG ở đây — bắt buộc đường closeTabById theo id trên manifest. Entry
+	// manifest chỉ được clear (giữ key rỗng, cùng shape closeTabForRun) khi
+	// MỌI tabId đã được mux xác nhận (closed/gone); còn failure thì giữ
+	// nguyên để lần doctor sau thử lại (close-by-ID idempotent nên an toàn).
+	const tabsClosed: string[] = [];
+	const tabsGone: string[] = [];
+	const tabFailures: { tabId: string; error: string }[] = [];
+	const tabCloseUnsupported = new Set<string>();
+	for (const orphan of orphanTabs) {
+		const provider = providers.get(orphan.kind);
+		if (!provider) continue; // list-only — note already recorded per kind
+		if (typeof provider.closeTabById !== "function") {
+			if (!tabCloseUnsupported.has(orphan.kind)) {
+				tabCloseUnsupported.add(orphan.kind);
+				providerNotes.push(`${orphan.kind}: closeTabById unavailable — run tabs listed only`);
+			}
+			continue;
+		}
+		let allResolved = true;
+		for (const tabId of orphan.tabIds) {
+			try {
+				const outcome = await provider.closeTabById(tabId);
+				if (outcome === "gone") tabsGone.push(tabId);
+				else tabsClosed.push(tabId);
+			} catch (error) {
+				allResolved = false;
+				tabFailures.push({ tabId, error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+		if (!allResolved) continue; // giữ nguyên entry manifest — evidence cho lần thử sau
+		try {
+			const manifest = JSON.parse(fs.readFileSync(orphan.manifestPath, "utf-8")) as {
+				surface?: { tabs?: Record<string, unknown> };
+			};
+			if (Array.isArray(manifest.surface?.tabs?.[orphan.tabKey])) {
+				manifest.surface.tabs[orphan.tabKey] = [];
+				atomicWriteJson(orphan.manifestPath, manifest);
+			}
+		} catch (error) {
+			tabFailures.push({
+				tabId: orphan.tabIds[0] ?? orphan.tabKey,
+				error: `manifest persist failed: ${error instanceof Error ? error.message : String(error)}`,
+			});
+		}
+	}
+
+	return { orphans, closed, gone, failures, orphanTabs, tabsClosed, tabsGone, tabFailures, scriptsSwept, providerNotes };
+}
+
+export function formatOrphanPaneReport(cleanup: DoctorSurfaceCleanupResult): string {
+	const lines: string[] = [];
+	lines.push("## Orphan surface-pane cleanup");
+	lines.push("");
+	if (cleanup.orphans.length === 0) {
+		lines.push("No orphan surface panes found (zombie scan + terminal-run manifests).");
+	} else {
+		lines.push(`Orphan panes (${cleanup.orphans.length}):`);
+		for (const orphan of cleanup.orphans) {
+			lines.push(`  - ${orphan.kind} pane ${orphan.paneId} — ${orphan.source}`);
+		}
+		lines.push("");
+	}
+	if (cleanup.closed.length > 0) lines.push(`Closed: ${cleanup.closed.join(", ")}`);
+	if (cleanup.gone.length > 0) lines.push(`Already gone (mux no longer tracks them): ${cleanup.gone.join(", ")}`);
+	if (cleanup.failures.length > 0) {
+		lines.push(`Close failures (${cleanup.failures.length}):`);
+		for (const failure of cleanup.failures) lines.push(`  - ${failure.paneId}: ${failure.error}`);
+	}
+	if (cleanup.orphanTabs.length > 0) {
+		lines.push("");
+		lines.push(`Orphan run tabs (${cleanup.orphanTabs.length}) — terminal runs whose surface.tabs still carry tab ids:`);
+		for (const tab of cleanup.orphanTabs) {
+			lines.push(`  - ${tab.kind} tab ${tab.tabIds.join(", ")} — run ${tab.runId} tabKey ${tab.tabKey} (terminal)`);
+		}
+	}
+	if (cleanup.tabsClosed.length > 0) lines.push(`Tabs closed by id: ${cleanup.tabsClosed.join(", ")}`);
+	if (cleanup.tabsGone.length > 0) lines.push(`Tabs already gone (mux no longer tracks them): ${cleanup.tabsGone.join(", ")}`);
+	if (cleanup.tabFailures.length > 0) {
+		lines.push(`Tab close failures (${cleanup.tabFailures.length}):`);
+		for (const failure of cleanup.tabFailures) lines.push(`  - ${failure.tabId}: ${failure.error}`);
+	}
+	for (const note of cleanup.providerNotes) lines.push(`Note: ${note}`);
+	lines.push(`Orphan launch scripts swept: ${cleanup.scriptsSwept}`);
+	return lines.join("\n");
+}
+
+export async function handleDoctor(ctx: TeamContext, params: TeamToolParamsValue = {}): Promise<PiTeamsToolResult> {
+	// Sub-focus: zombie sub-agent scan + orphan surface-pane cleanup (T12). The
+	// process scan itself stays READ-ONLY — never kills a process. The pane
+	// cleanup only closes multiplexer panes (zombie workers' panes + terminal
+	// runs' leaked panes) through the provider, gated on detect(). The user's
+	// main session never carries PI_CREW_KIND, so it can never appear here.
 	if (params.focus === "zombies") {
 		const scan = scanZombieSubagents();
-		const text = formatZombieReport(scan);
+		const cleanup = await cleanupOrphanSurfacePanes({ cwd: ctx.cwd, scan });
+		const text = `${formatZombieReport(scan)}\n\n${formatOrphanPaneReport(cleanup)}`;
 		return result(
 			text,
 			{
@@ -530,6 +878,15 @@ export function handleDoctor(ctx: TeamContext, params: TeamToolParamsValue = {})
 					zombies: scan.zombies.length,
 					live: scan.live.length,
 					errors: scan.errors.length,
+					orphanPanes: cleanup.orphans.length,
+					panesClosed: cleanup.closed.length,
+					panesGone: cleanup.gone.length,
+					paneCloseFailures: cleanup.failures.length,
+					orphanTabs: cleanup.orphanTabs.length,
+					tabsClosed: cleanup.tabsClosed.length,
+					tabsGone: cleanup.tabsGone.length,
+					tabCloseFailures: cleanup.tabFailures.length,
+					scriptsSwept: cleanup.scriptsSwept,
 				},
 			},
 			false,

package/src/extension/team-tool/handle-settings.ts

@@ -18,6 +18,12 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"runtime.promptMode": "replace",
 	"runtime.completionMutationGuard": "warn",
 	"runtime.isolationPolicy": undefined,
+	// Mux-surface policy (spec v0.7 §8.2.2): auto-detect tmux/herdr; A1 shows
+	// panes to nobody until visibleAgents opts roles in (["*"] at A2 GA).
+	"runtime.surface.mode": "auto",
+	"runtime.surface.visibleAgents": [],
+	// Inter-pi broker (Phase 0): default-on after ADR-0 "asked then flipped true".
+	"broker.enabled": true,
 	"limits.maxConcurrentWorkers": 1024,
 	"limits.maxTaskDepth": 100,
 	"limits.maxRunMinutes": 1440,
@@ -152,6 +158,16 @@ const KNOWN_KEYS = new Set([
 	"runtime.completionMutationGuard",
 	"runtime.effectivenessGuard",
 	"runtime.isolationPolicy",
+	// Mux-surface policy (spec v0.7 §8.2.1)
+	"runtime.surface.mode",
+	"runtime.surface.visibleAgents",
+	// governed nesting (ADR-5 §10; default-on since D8 — user config may close)
+	"nesting.enabled",
+	"nesting.maxSlots",
+	"nesting.maxDepth",
+	// inter-pi broker (Phase 0) — wait.* gate + master switch
+	"broker.enabled",
+	"broker.waitMethodsEnabled",
 	// limits
 	"limits.maxConcurrentWorkers",
 	"limits.allowUnboundedConcurrency",
@@ -487,6 +503,9 @@ export function handleSettings(params: { config?: Record<string, unknown> }, ctx
 					"autonomous.injectPolicy",
 					"agents.overrides",
 					"agents.disableBuiltins",
+					// Privilege-raising (spawns grandchildren) — schema marks it
+					// sensitive; project config is sanitized (ADR-5 §12 posture).
+					"nesting.enabled",
 				];
 				if (sensitiveKeys.some((k) => key === k || key.startsWith(k + "."))) {
 					warning +=

package/src/extension/team-tool/inspect.ts

@@ -1,5 +1,5 @@
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { readEvents } from "../../state/event-log/event-log.ts";
+import { readEventsCursor } from "../../state/event-log/event-log.ts";
 import { loadRunManifestById } from "../../state/stores/state-store.ts";
 import { aggregateUsage, formatCostReport, formatUsage } from "../../state/usage.ts";
 import { locateRunCwd } from "../team-tool.ts";
@@ -20,9 +20,17 @@ export function handleEvents(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	if (!runCwd) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "events", status: "error" }, true);
 	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "events", status: "error" }, true);
-	const events = readEvents(loaded.manifest.eventsPath);
+	// PERF (2026-08-24): `readEvents` parses full history (every archive + the
+	// whole live file) and exposes no limit option, and the events action params
+	// carry no full-history flag — so read the bounded cursor tail (4 MB /
+	// 5000-event cap) and display the last 500 events by default.
+	const cursor = readEventsCursor(loaded.manifest.eventsPath);
+	const events = cursor.events.slice(-500);
 	const lines = [
 		`Events for ${loaded.manifest.runId}:`,
+		// Truncation indicator: `total` is the cursor's event count before the
+		// display slice — surface it whenever the slice dropped events.
+		...(cursor.total > events.length ? [`(showing last ${events.length} of ${cursor.total} events)`] : []),
 		...(events.length
 			? events.map(
 					(event) =>

package/src/extension/team-tool/status.ts

@@ -149,6 +149,13 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	const counts = new Map<string, number>();
 	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
 	const phaseProgress = computePhaseProgress(tasks);
+	// PERF (2026-08-24): intentionally NOT passing `limit` here — readEventsCursor's
+	// limit is a HEAD cap (oldest-first slice for streaming pagination), not a tail
+	// window, so it would hide recent events from the ack-timeout dedupe below and
+	// re-append duplicate ack_timeout events on every poll. The manifest carries no
+	// last-seq anchor for a sinceSeq-based tail either. The reader is already bounded
+	// internally (4 MB / 5000-event tail), and the downstream filters
+	// (ackTimeoutRequestIds, attentionByTask) intentionally operate on that recent window.
 	const { events: allEvents } = readEventsCursor(manifest.eventsPath);
 	const events = allEvents.slice(-8);
 	// P1-8: pre-build the ack-timeout requestId set once (was O(events × messages)

package/src/extension/team-tool.ts

@@ -19,7 +19,7 @@ import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
-import { listRuns } from "./run-index.ts";
+import { listRecentRuns } from "./run-index.ts";
 import type { PiTeamsToolResult } from "./tool-result.ts";
 
 type ExecuteTeamRunFn = typeof _executeTeamRunFn;
@@ -124,7 +124,10 @@ export function handleList(params: TeamToolParamsValue, ctx: TeamContext): PiTea
 		);
 	}
 	if (!resource) {
-		const runs = listRuns(ctx.cwd).slice(0, 10);
+		// PERF (2026-08-24): listRecentRuns caps at source — collectRuns slices the
+		// run-directory listing before reading manifests, instead of parsing every
+		// manifest in scope and discarding all but 10.
+		const runs = listRecentRuns(ctx.cwd, 10);
 		blocks.push(
 			"",
 			"Recent runs:",
@@ -627,7 +630,37 @@ export function handleInvalidate(params: TeamToolParamsValue, ctx: TeamContext):
 const MAX_SCAN_ENTRIES = 1000;
 const SKIP_SCAN_DIRS = new Set(["node_modules", ".git", ".npm", ".cache", ".local", "proc", "sys", "dev", "Library", "Applications"]);
 
+// PERF (2026-08-24): a stale/typo'd runId from a looping LLM caller paid the
+// full 1000-entry directory sweep on EVERY attempt. Resolution results (hits
+// AND misses) are cached briefly; TTL bounds staleness for runs created in a
+// sibling cwd after a cached miss.
+const runCwdCache = new Map<string, { cwd: string | undefined; expiresAt: number }>();
+const RUN_CWD_TTL_MS = 30_000;
+const RUN_CWD_CACHE_MAX = 128;
 export function locateRunCwd(runId: string, baseCwd: string): string | undefined {
+	const key = `${baseCwd}\0${runId}`;
+	const cached = runCwdCache.get(key);
+	if (cached && cached.expiresAt > Date.now()) return cached.cwd;
+	const cwd = locateRunCwdUncached(runId, baseCwd); // original body, renamed
+	if (runCwdCache.size >= RUN_CWD_CACHE_MAX) {
+		const oldest = runCwdCache.keys().next().value;
+		if (oldest !== undefined) runCwdCache.delete(oldest);
+	}
+	runCwdCache.set(key, { cwd, expiresAt: Date.now() + RUN_CWD_TTL_MS });
+	return cwd;
+}
+
+/**
+ * Locate the CWD where a run's state is stored.
+ * Tries ctx.cwd first, then scans immediate child directories for .crew/state/runs/<runId>.
+ *
+ * Defensive bounds (prevent hang on large dirs like /tmp in CI):
+ * - Skips entries that are well-known system/ephemeral dirs (e.g. .npm, node_modules, .git)
+ * - Caps the scan at MAX_SCAN_ENTRIES to avoid pathological scans
+ * - Skips hidden entries (starting with `.`) unless they look like run directories
+ *   (e.g. .crew, .pi, .tmp-crew-runs)
+ */
+export function locateRunCwdUncached(runId: string, baseCwd: string): string | undefined {
 	// Fast path: run is in the current CWD
 	if (loadRunManifestById(baseCwd, runId)) {
 		return baseCwd;

package/src/hooks/registry.ts

@@ -42,6 +42,65 @@ export function getHooks(name: HookName): HookDefinition[] {
 	return registry.get(name) ?? [];
 }
 
+// PERF (2026-08-24): constant sanitizer state hoisted to module scope — it was
+// rebuilt (12 normalize+toLowerCase + Set + 3 closures) on EVERY hook execution.
+const POLLUTED_KEYS = new Set(
+	[
+		"__proto__",
+		"constructor",
+		"prototype",
+		"hasOwnProperty",
+		"toString",
+		"valueOf",
+		"isPrototypeOf",
+		"propertyIsEnumerable",
+		"__defineGetter__",
+		"__defineSetter__",
+		"__lookupGetter__",
+		"__lookupSetter__",
+	].map((k) => k.toLowerCase().normalize("NFKC")),
+);
+function sanitizeMergeData(data: Record<string, unknown>): Record<string, unknown> {
+	const clean: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(data)) {
+		if (!POLLUTED_KEYS.has(k.toLowerCase().normalize("NFKC"))) {
+			if (v !== null && typeof v === "object") {
+				if (Array.isArray(v)) {
+					// Sanitize array elements that are objects
+					clean[k] = v.map((item) =>
+						item !== null && typeof item === "object" && !Array.isArray(item)
+							? sanitizeMergeData(item as Record<string, unknown>)
+							: item,
+					);
+				} else {
+					clean[k] = sanitizeMergeData(v as Record<string, unknown>);
+				}
+			} else {
+				clean[k] = v;
+			}
+		}
+	}
+	return clean;
+}
+// Sanitize ctx by stripping dangerous property names before passing to handlers.
+// Hook authors must NOT set these keys directly on ctx: [...POLLUTED_KEYS]
+// This sanitization runs at the start of executeHook to prevent prototype pollution attacks.
+function sanitizeContext(ctx: HookContext): HookContext {
+	for (const key of Object.keys(ctx)) {
+		if (POLLUTED_KEYS.has(key.toLowerCase().normalize("NFKC"))) {
+			delete ctx[key];
+		}
+	}
+	return ctx;
+}
+function sanitizeErrorMessage(message: string): string {
+	// Remove file paths, environment variable references, and other potentially sensitive data
+	return message
+		.replace(/\/[^:\s]+/g, "[path]")
+		.replace(/\b[A-Z_0-9]+\s*=/g, "[env]")
+		.replace(/\b\d+\.\d+\.\d+\.\d+\b/g, "[ip]");
+}
+
 export async function executeHook(name: HookName, ctx: HookContext): Promise<HookExecutionReport> {
 	const hooks = getHooks(name);
 	if (hooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
@@ -62,62 +121,6 @@ export async function executeHook(name: HookName, ctx: HookContext): Promise<Hoo
 		return ctx.includeGlobalHooks !== false;
 	});
 	if (scopedHooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
-	const POLLUTED_KEYS = new Set(
-		[
-			"__proto__",
-			"constructor",
-			"prototype",
-			"hasOwnProperty",
-			"toString",
-			"valueOf",
-			"isPrototypeOf",
-			"propertyIsEnumerable",
-			"__defineGetter__",
-			"__defineSetter__",
-			"__lookupGetter__",
-			"__lookupSetter__",
-		].map((k) => k.toLowerCase().normalize("NFKC")),
-	);
-	function sanitizeMergeData(data: Record<string, unknown>): Record<string, unknown> {
-		const clean: Record<string, unknown> = {};
-		for (const [k, v] of Object.entries(data)) {
-			if (!POLLUTED_KEYS.has(k.toLowerCase().normalize("NFKC"))) {
-				if (v !== null && typeof v === "object") {
-					if (Array.isArray(v)) {
-						// Sanitize array elements that are objects
-						clean[k] = v.map((item) =>
-							item !== null && typeof item === "object" && !Array.isArray(item)
-								? sanitizeMergeData(item as Record<string, unknown>)
-								: item,
-						);
-					} else {
-						clean[k] = sanitizeMergeData(v as Record<string, unknown>);
-					}
-				} else {
-					clean[k] = v;
-				}
-			}
-		}
-		return clean;
-	}
-	// Sanitize ctx by stripping dangerous property names before passing to handlers.
-	// Hook authors must NOT set these keys directly on ctx: [...POLLUTED_KEYS]
-	// This sanitization runs at the start of executeHook to prevent prototype pollution attacks.
-	function sanitizeContext(ctx: HookContext): HookContext {
-		for (const key of Object.keys(ctx)) {
-			if (POLLUTED_KEYS.has(key.toLowerCase().normalize("NFKC"))) {
-				delete ctx[key];
-			}
-		}
-		return ctx;
-	}
-	function sanitizeErrorMessage(message: string): string {
-		// Remove file paths, environment variable references, and other potentially sensitive data
-		return message
-			.replace(/\/[^:\s]+/g, "[path]")
-			.replace(/\b[A-Z_0-9]+\s*=/g, "[env]")
-			.replace(/\b\d+\.\d+\.\d+\.\d+\b/g, "[ip]");
-	}
 	const start = Date.now();
 	const diagnostics: string[] = [];
 	let capturedModifications: Record<string, unknown> | undefined;