pi-crew 0.3.6 → 0.3.8

package/src/extension/registration/commands.ts

@@ -221,11 +221,24 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 	] as const) {
 		pi.registerCommand(name, { description, handler: async (args: string, ctx: ExtensionCommandContext) => {
 			const runId = args.trim() || undefined;
-			const result = await handleTeamTool({ action, runId }, teamCommandContext(ctx));
+			const result = await handleTeamTool({ action, runId }, { ...teamCommandContext(ctx), getRunSnapshotCache: deps.getRunSnapshotCache });
 			await notifyCommandResult(ctx, commandText(result));
 		} });
 	}
 
+	pi.registerCommand("team-invalidate", {
+		description: "Invalidate the snapshot cache for a run so the UI refreshes immediately: <runId>",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const runId = args.trim() || undefined;
+			if (!runId) {
+				await notifyCommandResult(ctx, "Usage: /team-invalidate <runId>");
+				return;
+			}
+			const result = await handleTeamTool({ action: "invalidate", runId }, { ...teamCommandContext(ctx), getRunSnapshotCache: deps.getRunSnapshotCache });
+			await notifyCommandResult(ctx, commandText(result));
+		},
+	});
+
 	pi.registerCommand("team-retry", {
 		description: "Retry failed/cancelled pi-crew tasks: <runId> [taskId]",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
@@ -236,7 +249,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 				await notifyCommandResult(ctx, "Usage: /team-retry <runId> [taskId]");
 				return;
 			}
-			const retryResult = await handleTeamTool({ action: "retry", runId, taskId }, teamCommandContext(ctx));
+			const retryResult = await handleTeamTool({ action: "retry", runId, taskId }, { ...teamCommandContext(ctx), getRunSnapshotCache: deps.getRunSnapshotCache });
 			await notifyCommandResult(ctx, commandText(retryResult));
 		},
 	});

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

@@ -81,7 +81,7 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 					const runLabel = resolved.team ?? resolved.agent ?? "direct";
 					pi.setSessionName(`pi-crew: ${runLabel}/${resolved.workflow ?? "default"} — ${resolved.goal.slice(0, 60)}`);
 				}
-				const output = await handleTeamTool(resolved, { ...toolCtx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(toolCtx, runner, runId), abortForegroundRun: deps.abortForegroundRun, onRunStarted: (runId) => { stopProgress.attach(toolCtx.cwd, runId); deps.openLiveSidebar(toolCtx, runId); }, onJsonEvent: deps.onJsonEvent });
+				const output = await handleTeamTool(resolved, { ...toolCtx, signal: controller.signal, metricRegistry: deps.getMetricRegistry?.(), startForegroundRun: (runner, runId) => deps.startForegroundRun(toolCtx, runner, runId), abortForegroundRun: deps.abortForegroundRun, onRunStarted: (runId) => { stopProgress.attach(toolCtx.cwd, runId); deps.openLiveSidebar(toolCtx, runId); }, onJsonEvent: deps.onJsonEvent, getRunSnapshotCache: deps.getRunSnapshotCache });
 				if (resolved.action === "run" && !output.isError && typeof output.details?.runId === "string") {
 					pi.appendEntry("crew:run-started", {
 						runId: output.details.runId,

package/src/extension/session-summary.ts

@@ -1,8 +1,18 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { isDisplayActiveRun } from "../runtime/process-status.ts";
 import { listRuns } from "./run-index.ts";
+import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 
 export function notifyActiveRuns(ctx: ExtensionContext): void {
-	const active = listRuns(ctx.cwd).filter((run) => run.status === "queued" || run.status === "planning" || run.status === "running").slice(0, 5);
+	const active = listRuns(ctx.cwd)
+		.filter((run) => {
+			if (run.status !== "queued" && run.status !== "planning" && run.status !== "running") return false;
+			// Use the same display filter as the widget/powerbar — runs without
+			// real agent evidence (e.g. integration test fixtures) must not appear.
+			const agents = readCrewAgents(run);
+			return isDisplayActiveRun(run, agents);
+		})
+		.slice(0, 5);
 	if (active.length === 0) return;
 	ctx.ui.notify(`pi-crew active runs: ${active.map((run) => `${run.runId} [${run.status}]`).join(", ")}`, "info");
 }

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

@@ -21,6 +21,7 @@ import { liveControlRealtimeMessage, publishLiveControlRealtime } from "../../su
 import { buildCapabilityInventory } from "../../runtime/capability-inventory.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
+import { locateRunCwd } from "../team-tool.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
 
 function globMatch(value: string, pattern: string): boolean {
@@ -83,7 +84,9 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		return result(JSON.stringify(inventory, null, 2), { action: "api", status: "ok" });
 	}
 	if (!params.runId) return result("API requires runId.", { action: "api", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	const runCwd = locateRunCwd(params.runId, ctx.cwd);
+	if (!runCwd) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
+	const loaded = loadRunManifestById(runCwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
 	if (operation === "read-manifest") {
 		return result(JSON.stringify(loaded.manifest, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });

package/src/extension/team-tool/cache-control.ts

@@ -0,0 +1,23 @@
+import { runEventBus } from "../../ui/run-event-bus.ts";
+import type { RunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
+
+export interface CacheControlDeps {
+	getRunSnapshotCache: (cwd: string) => RunSnapshotCache;
+}
+
+/**
+ * Invalidate the run snapshot cache for a specific runId and emit
+ * a runEventBus event so the render scheduler coalescer fires immediately.
+ * Call this after any state mutation that changes task/agent status.
+ */
+export function invalidateSnapshot(
+	runId: string,
+	runCwd: string,
+	deps: CacheControlDeps,
+): void {
+	// 1. Invalidate snapshot cache entry
+	deps.getRunSnapshotCache(runCwd).invalidate(runId);
+
+	// 2. Emit runEventBus event so renderScheduler coalescer fires
+	runEventBus.emit({ runId, type: "run.cache_invalidated" });
+}

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

@@ -10,8 +10,10 @@ import { killProcessPid } from "../../runtime/child-pi.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { executeHook, appendHookEvent } from "../../hooks/registry.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
+import { locateRunCwd } from "../team-tool.ts";
 import { result, type TeamContext } from "./context.ts";
 import { enforceDestructiveIntent, intentFromConfig } from "./intent-policy.ts";
+import { invalidateSnapshot, type CacheControlDeps } from "./cache-control.ts";
 
 export interface AbortOwnedResult {
 	abortedIds: string[];
@@ -35,8 +37,11 @@ export function abortOwned(
 	runId: string,
 	taskIds: string[] | undefined,
 	ctx: TeamContext,
+	force?: boolean,
 ): AbortOwnedResult {
-	const loaded = loadRunManifestById(ctx.cwd, runId);
+	const runCwd = locateRunCwd(runId, ctx.cwd);
+	if (!runCwd) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
+	const loaded = loadRunManifestById(runCwd, runId);
 	if (!loaded) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
 
 	const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
@@ -51,7 +56,7 @@ export function abortOwned(
 			continue;
 		}
 		if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") continue;
-		if (foreignRun) {
+		if (foreignRun && !force) {
 			result.foreignIds.push(id);
 			continue;
 		}
@@ -72,15 +77,17 @@ function cancelReasonFromParams(params: TeamToolParamsValue): CancellationReason
 	return { code: reason.code, message: reason.message };
 }
 
-export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext, deps?: CacheControlDeps): Promise<PiTeamsToolResult> {
 	if (!params.runId) return result("Retry requires runId.", { action: "retry", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	const runCwd = locateRunCwd(params.runId, ctx.cwd);
+	if (!runCwd) return result(`Run '${params.runId}' not found.`, { action: "retry", status: "error" }, true);
+	const loaded = loadRunManifestById(runCwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "retry", status: "error" }, true);
 
-	// Pre-lock ownership check: reject foreign-owned runs
+	// Pre-lock ownership check: reject foreign-owned runs unless force is set
 	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
-	if (foreignRun) {
-		return result(`Run ${loaded.manifest.runId} belongs to another session; not retried.`, { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
+	if (foreignRun && !params.force) {
+		return result(`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`, { action: "retry", status: "error", runId: loaded.manifest.runId }, true);
 	}
 
 	// Execute before_retry hook after ownership confirmed, before mutation lock
@@ -122,6 +129,7 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext)
 			appendEvent(loaded.manifest.eventsPath, { type: "task.retried", runId: loaded.manifest.runId, taskId, message: `Task ${taskId} queued for retry.` });
 		}
 
+		if (deps) invalidateSnapshot(loaded.manifest.runId, runCwd, deps);
 		return result(`Retried ${retriedTaskIds.length} task(s) in run ${loaded.manifest.runId}.`, {
 			action: "retry",
 			status: "ok",
@@ -132,17 +140,19 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext)
 	});
 }
 
-export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext, deps?: CacheControlDeps): Promise<PiTeamsToolResult> {
 	const intentError = enforceDestructiveIntent("cancel", params, ctx.config);
 	if (intentError) return intentError;
 	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	const runCwd = locateRunCwd(params.runId, ctx.cwd);
+	if (!runCwd) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
+	const loaded = loadRunManifestById(runCwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
 
-	// Pre-lock ownership check: reject foreign-owned runs before executing hooks
-	const preCheck = abortOwned(loaded.manifest.runId, undefined, ctx);
-	if (preCheck.abortedIds.length === 0 && preCheck.foreignIds.length > 0) {
-		return result(`Run ${loaded.manifest.runId} belongs to another session; not cancelled.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: preCheck.foreignIds }, true);
+	// Pre-lock ownership check: reject foreign-owned runs unless force is set
+	const preCheck = abortOwned(loaded.manifest.runId, undefined, ctx, params.force);
+	if (preCheck.abortedIds.length === 0 && preCheck.foreignIds.length > 0 && !params.force) {
+		return result(`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: preCheck.foreignIds }, true);
 	}
 
 	// Execute before_cancel hook after ownership confirmed, before mutation lock
@@ -169,9 +179,9 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force) return result(`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 
 		// Classify tasks for foreign-aware cancellation
-		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx);
-		if (abortResult.abortedIds.length === 0 && abortResult.foreignIds.length > 0) {
-			return result(`Run ${loaded.manifest.runId} belongs to another session; not cancelled.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: abortResult.foreignIds }, true);
+		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx, params.force);
+		if (abortResult.abortedIds.length === 0 && abortResult.foreignIds.length > 0 && !params.force) {
+			return result(`Run ${loaded.manifest.runId} belongs to another session. Use force: true to override.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: abortResult.foreignIds }, true);
 		}
 		const cancellableIds = new Set(abortResult.abortedIds);
 		const cancelReason = cancelReasonFromParams(params);
@@ -211,6 +221,7 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 		if (abortResult.foreignIds.length > 0) parts.push(` ${abortResult.foreignIds.length} task(s) belong to another session and were not cancelled: ${abortResult.foreignIds.join(", ")}.`);
 		if (abortResult.missingIds.length > 0) parts.push(` ${abortResult.missingIds.length} task ID(s) not found: ${abortResult.missingIds.join(", ")}.`);
 
+		if (deps) invalidateSnapshot(updated.runId, runCwd, deps);
 		return result(parts.join(""), {
 			action: "cancel",
 			status: "ok",

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

@@ -2,6 +2,7 @@ import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { PiTeamsConfig } from "../../config/config.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import type { TeamToolDetails } from "../team-tool-types.ts";
+import type { RunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 import { toolResult, type PiTeamsToolResult } from "../tool-result.ts";
 
 export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext, "model">> & {
@@ -16,6 +17,7 @@ export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<Extension
 	onRunStarted?: (runId: string) => void;
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 	config?: PiTeamsConfig;
+	getRunSnapshotCache?: (cwd: string) => RunSnapshotCache;
 };
 
 export function withSessionId<T extends Pick<ExtensionContext, "sessionManager">>(ctx: T): T & { sessionId?: string } {

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

@@ -40,6 +40,7 @@ const EFFECTIVE_DEFAULTS: Record<string, unknown> = {
 	"notifierIntervalMs": 5000,
 	"reliability.autoRetry": false,
 	"reliability.autoRecover": false,
+	"reliability.cleanupOrphanedTempDirs": true,
 	"telemetry.enabled": false,
 	"notifications.enabled": false,
 };
@@ -192,6 +193,7 @@ const KNOWN_KEYS = new Set([
 	// reliability
 	"reliability.autoRetry",
 	"reliability.autoRecover",
+	"reliability.cleanupOrphanedTempDirs",
 	"reliability.deadletterThreshold",
 	"reliability.retryPolicy.maxAttempts",
 	"reliability.retryPolicy.backoffMs",