pi-crew 0.1.10 → 0.1.12

package/README.md

@@ -32,7 +32,7 @@ Current highlights:
 - detached async/background runner
 - stale async PID detection
 - active run summary and async completion notifications in Pi sessions
-- safe scaffold execution by default; real child Pi workers are opt-in
+- real child Pi worker execution by default, with explicit scaffold/dry-run opt-out
 - child Pi JSON output parsing for final text, usage, and event counts
 - retryable model fallback attempts per task
 - aggregate usage totals in status/summary
@@ -89,19 +89,21 @@ npm run ci
 
 ## Runtime safety model
 
-By default, `run` uses safe scaffold mode. It creates run state, task prompts, events, and placeholder result artifacts without launching child Pi workers.
+By default, `run` launches each crew task as a separate child Pi process. This matches the subagent model from `pi-subagents`: the parent session orchestrates while worker sessions execute independently and stream durable output back to run state.
 
-Real child Pi workers only run when explicitly enabled by either:
+Use scaffold/dry-run mode only when you explicitly want prompts/artifacts without launching workers:
 
-```bash
-PI_TEAMS_EXECUTE_WORKERS=1 pi
+```json
+{
+  "runtime": { "mode": "scaffold" }
+}
 ```
 
-or config:
+or disable workers globally:
 
 ```json
 {
-  "executeWorkers": true
+  "executeWorkers": false
 }
 ```
 
@@ -143,7 +145,7 @@ Supported config:
 ```json
 {
   "asyncByDefault": false,
-  "executeWorkers": false,
+  "executeWorkers": true,
   "notifierIntervalMs": 5000,
   "requireCleanWorktreeLeader": true,
   "autonomous": {
@@ -163,6 +165,11 @@ Supported config:
     "maxRunMinutes": 60,
     "maxRetriesPerTask": 1,
     "heartbeatStaleMs": 60000
+  },
+  "ui": {
+    "widgetPlacement": "aboveEditor",
+    "widgetMaxLines": 8,
+    "powerbar": true
   }
 }
 ```
@@ -619,7 +626,8 @@ Optional child Pi smoke check is explicit only:
 ## Environment variables
 
 ```text
-PI_TEAMS_EXECUTE_WORKERS=1       enable real child Pi worker execution
+PI_CREW_EXECUTE_WORKERS=0       disable child workers and use scaffold/dry-run mode
+PI_TEAMS_EXECUTE_WORKERS=0      legacy disable flag
 PI_TEAMS_MOCK_CHILD_PI=success   test/mock child worker success
 PI_TEAMS_MOCK_CHILD_PI=json-success
 PI_TEAMS_MOCK_CHILD_PI=retryable-failure

package/docs/architecture.md

@@ -32,8 +32,8 @@ Implemented now:
 - durable run manifests and task files
 - workflow validation
 - foreground workflow scheduler
-- safe scaffold task execution
-- optional real child Pi execution via `PI_TEAMS_EXECUTE_WORKERS=1`
+- child Pi task execution by default
+- explicit scaffold/dry-run task execution via `runtime.mode=scaffold` or `executeWorkers=false`
 - safety-first create/update/delete for agents, teams, and workflows
 - backups for update/delete mutations
 - dry-run support for management mutations

package/docs/usage.md

@@ -19,7 +19,7 @@ Supported fields:
 ```json
 {
   "asyncByDefault": false,
-  "executeWorkers": false,
+  "executeWorkers": true,
   "notifierIntervalMs": 5000,
   "requireCleanWorktreeLeader": true,
   "autonomous": {
@@ -28,6 +28,11 @@ Supported fields:
     "injectPolicy": true,
     "preferAsyncForLongTasks": false,
     "allowWorktreeSuggestion": true
+  },
+  "ui": {
+    "widgetPlacement": "aboveEditor",
+    "widgetMaxLines": 8,
+    "powerbar": true
   }
 }
 ```
@@ -47,9 +52,9 @@ Then open Pi and run:
 /team-autonomy status
 ```
 
-## Safe run
+## Default run: real worker execution
 
-By default, `pi-crew` does not launch child workers. It creates a durable run, prompts, placeholder results, events, and artifacts.
+By default, `pi-crew` launches each task as a separate child Pi worker process. The parent Pi session orchestrates; workers execute independently and stream output to durable run state.
 
 ```json
 {
@@ -59,16 +64,21 @@ By default, `pi-crew` does not launch child workers. It creates a durable run, p
 }
 ```
 
-## Real worker execution
+## Scaffold / dry run
 
-Start Pi with:
+Use scaffold mode only when you want durable prompts/artifacts without launching child workers.
 
-```bash
-PI_TEAMS_EXECUTE_WORKERS=1 pi
+```json
+{
+  "action": "run",
+  "team": "default",
+  "goal": "Plan only",
+  "config": {
+    "runtime": { "mode": "scaffold" }
+  }
+}
 ```
 
-Then run normally. Each task can spawn a child Pi worker.
-
 ## Async run
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/schema.json

@@ -78,6 +78,16 @@
         "enabled": { "type": "boolean" },
         "needsAttentionAfterMs": { "type": "integer", "minimum": 1 }
       }
+    },
+    "ui": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Pi UI settings for the crew widget, dashboard, and optional powerbar segments.",
+      "properties": {
+        "widgetPlacement": { "type": "string", "enum": ["aboveEditor", "belowEditor"] },
+        "widgetMaxLines": { "type": "integer", "minimum": 1, "maximum": 50 },
+        "powerbar": { "type": "boolean" }
+      }
     }
   }
 }

package/src/config/config.ts

@@ -47,6 +47,12 @@ export interface CrewWorktreeConfig {
 	linkNodeModules?: boolean;
 }
 
+export interface CrewUiConfig {
+	widgetPlacement?: "aboveEditor" | "belowEditor";
+	widgetMaxLines?: number;
+	powerbar?: boolean;
+}
+
 export interface AgentOverrideConfig {
 	disabled?: boolean;
 	model?: string | false;
@@ -71,6 +77,7 @@ export interface PiTeamsConfig {
 	control?: CrewControlConfig;
 	worktree?: CrewWorktreeConfig;
 	agents?: CrewAgentsConfig;
+	ui?: CrewUiConfig;
 }
 
 export interface LoadedPiTeamsConfig {
@@ -136,6 +143,12 @@ function mergeConfig(base: PiTeamsConfig, override: PiTeamsConfig): PiTeamsConfi
 			...withoutUndefined((override.worktree ?? {}) as Record<string, unknown>),
 		};
 	}
+	if (base.ui || override.ui) {
+		merged.ui = {
+			...(base.ui ?? {}),
+			...withoutUndefined((override.ui ?? {}) as Record<string, unknown>),
+		};
+	}
 	if (base.agents || override.agents) {
 		merged.agents = {
 			...(base.agents ?? {}),
@@ -289,6 +302,17 @@ function parseAgentOverride(value: unknown): AgentOverrideConfig | undefined {
 	return Object.values(override).some((entry) => entry !== undefined) ? override : undefined;
 }
 
+function parseUiConfig(value: unknown): CrewUiConfig | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const obj = value as Record<string, unknown>;
+	const ui: CrewUiConfig = {
+		widgetPlacement: obj.widgetPlacement === "aboveEditor" || obj.widgetPlacement === "belowEditor" ? obj.widgetPlacement : undefined,
+		widgetMaxLines: parsePositiveInteger(obj.widgetMaxLines, 50),
+		powerbar: typeof obj.powerbar === "boolean" ? obj.powerbar : undefined,
+	};
+	return Object.values(ui).some((entry) => entry !== undefined) ? ui : undefined;
+}
+
 function parseAgentsConfig(value: unknown): CrewAgentsConfig | undefined {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
 	const obj = value as Record<string, unknown>;
@@ -320,6 +344,7 @@ function parseConfig(raw: unknown): PiTeamsConfig {
 		control: parseControlConfig(obj.control),
 		worktree: parseWorktreeConfig(obj.worktree),
 		agents: parseAgentsConfig(obj.agents),
+		ui: parseUiConfig(obj.ui),
 	};
 }
 

package/src/extension/help.ts

@@ -40,6 +40,6 @@ export function piTeamsHelp(): string {
 		"- /team-validate",
 		"- /team-help",
 		"",
-		"Real child workers are disabled by default. Enable with PI_TEAMS_EXECUTE_WORKERS=1 or config executeWorkers=true.",
+		"Real child workers are enabled by default. Use runtime.mode=scaffold or executeWorkers=false only for dry runs.",
 	].join("\n");
 }

package/src/extension/register.ts

@@ -11,9 +11,11 @@ import { listRuns } from "./run-index.ts";
 import { RunDashboard, type RunDashboardSelection } from "../ui/run-dashboard.ts";
 import { registerPiCrewRpc, type PiCrewRpcHandle } from "./cross-extension-rpc.ts";
 import { stopCrewWidget, updateCrewWidget, type CrewWidgetState } from "../ui/crew-widget.ts";
+import { clearPiCrewPowerbar, registerPiCrewPowerbarSegments, updatePiCrewPowerbar } from "../ui/powerbar-publisher.ts";
 import { DurableTextViewer, DurableTranscriptViewer } from "../ui/transcript-viewer.ts";
 import { loadRunManifestById } from "../state/state-store.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import { terminateActiveChildPiProcesses } from "../runtime/child-pi.ts";
 
 function parseRunArgs(args: string): TeamToolParamsValue {
 	const tokens = args.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
@@ -102,6 +104,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let currentCtx: ExtensionContext | undefined;
 	let rpcHandle: PiCrewRpcHandle | undefined;
 	const widgetState: CrewWidgetState = { frame: 0 };
+	const foregroundControllers = new Set<AbortController>();
 	registerAutonomousPolicy(pi);
 	rpcHandle = registerPiCrewRpc((pi as unknown as { events?: Parameters<typeof registerPiCrewRpc>[0] }).events, () => currentCtx);
 
@@ -109,14 +112,24 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		currentCtx = ctx;
 		notifyActiveRuns(ctx);
 		const loadedConfig = loadConfig(ctx.cwd);
+		registerPiCrewPowerbarSegments(pi.events, loadedConfig.config.ui);
 		startAsyncRunNotifier(ctx, notifierState, loadedConfig.config.notifierIntervalMs ?? 5000);
-		updateCrewWidget(ctx, widgetState);
-		widgetState.interval = setInterval(() => { if (currentCtx) updateCrewWidget(currentCtx, widgetState); }, 1000);
+		updateCrewWidget(ctx, widgetState, loadedConfig.config.ui);
+		updatePiCrewPowerbar(pi.events, ctx.cwd, loadedConfig.config.ui);
+		widgetState.interval = setInterval(() => {
+			if (!currentCtx) return;
+			const config = loadConfig(currentCtx.cwd).config.ui;
+			updateCrewWidget(currentCtx, widgetState, config);
+			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config);
+		}, 1000);
 		widgetState.interval.unref?.();
 	});
 	pi.on("session_shutdown", () => {
+		for (const controller of foregroundControllers) controller.abort();
+		terminateActiveChildPiProcesses();
 		stopAsyncRunNotifier(notifierState);
-		stopCrewWidget(currentCtx, widgetState);
+		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
+		clearPiCrewPowerbar(pi.events);
 		currentCtx = undefined;
 		rpcHandle?.unsubscribe();
 		rpcHandle = undefined;
@@ -128,10 +141,21 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		description: "Coordinate Pi teams. Use proactively for complex multi-file work, planning, implementation, tests, reviews, security audits, research, async/background runs, and worktree-isolated execution. Use action='recommend' when unsure which team/workflow to choose. Destructive actions require explicit user confirmation.",
 		promptSnippet: "Use the team tool proactively for coordinated multi-agent work. If unsure, call { action: 'recommend', goal } first, then run or plan with the suggested team/workflow.",
 		parameters: TeamToolParams as never,
-		async execute(_id, params, _signal, _onUpdate, ctx) {
-			const output = await handleTeamTool(params as TeamToolParamsValue, ctx);
-			updateCrewWidget(ctx, widgetState);
-			return output;
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const controller = new AbortController();
+			foregroundControllers.add(controller);
+			const abort = (): void => controller.abort();
+			signal?.addEventListener("abort", abort, { once: true });
+			try {
+				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal });
+				const config = loadConfig(ctx.cwd).config.ui;
+				updateCrewWidget(ctx, widgetState, config);
+				updatePiCrewPowerbar(pi.events, ctx.cwd, config);
+				return output;
+			} finally {
+				signal?.removeEventListener("abort", abort);
+				foregroundControllers.delete(controller);
+			}
 		},
 	};
 
@@ -323,7 +347,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			for (;;) {
 				const runs = listRuns(ctx.cwd).slice(0, 50);
-				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, _theme, _keybindings, done) => new RunDashboard(runs, done), {
+				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme), {
 					overlay: true,
 					overlayOptions: { width: "90%", maxHeight: "80%", anchor: "center" },
 				});

package/src/extension/run-maintenance.ts

@@ -12,7 +12,7 @@ function isFinished(run: TeamRunManifest): boolean {
 }
 
 export function pruneFinishedRuns(cwd: string, keep: number): PruneRunsResult {
-	const finished = listRuns(cwd).filter(isFinished).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	const finished = listRuns(cwd).filter((run) => run.cwd === cwd && isFinished(run)).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
 	const kept = finished.slice(0, keep).map((run) => run.runId);
 	const removed: string[] = [];
 	for (const run of finished.slice(keep)) {

package/src/extension/team-tool.ts

@@ -56,6 +56,7 @@ type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext
 	modelRegistry?: unknown;
 	sessionManager?: { getBranch?: () => unknown[] };
 	events?: { emit?: (event: string, data: unknown) => void };
+	signal?: AbortSignal;
 };
 
 function result(text: string, details: TeamToolDetails, isError = false): PiTeamsToolResult {
@@ -306,7 +307,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const runtime = await resolveCrewRuntime(effectiveRunConfig(loadedConfig.config, params.config));
 	const executeWorkers = runtime.kind === "child-process";
 	const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
-	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry });
+	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, signal: ctx.signal });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,
@@ -318,10 +319,10 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		"",
 		`Runtime: ${runtime.kind}${runtime.fallback ? ` (fallback from ${runtime.requestedMode})` : ""}${runtime.reason ? ` - ${runtime.reason}` : ""}`,
 		runtime.kind === "child-process"
-			? "Child Pi worker execution was enabled."
+			? "Child Pi worker execution is enabled by default; each task is launched as a separate Pi process. Set runtime.mode=scaffold or executeWorkers=false only for dry runs."
 			: runtime.kind === "live-session"
 				? "Experimental live-session worker execution was enabled."
-				: "Safe scaffold mode: child Pi workers were not launched. Set PI_CREW_EXECUTE_WORKERS=1, PI_TEAMS_EXECUTE_WORKERS=1, or runtime.mode=child-process to enable real worker execution.",
+				: "Safe scaffold mode: child Pi workers were not launched because runtime.mode=scaffold or executeWorkers=false was configured.",
 	].join("\n");
 	return result(text, { action: "run", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 }
@@ -429,7 +430,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
 		const executeWorkers = runtime.kind === "child-process";
-		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry });
+		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, signal: ctx.signal });
 		return result([`Resumed run ${executed.manifest.runId}.`, `Status: ${executed.manifest.status}`, `Tasks: ${executed.tasks.length}`, `Artifacts: ${executed.manifest.artifactsRoot}`].join("\n"), { action: "resume", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 	});
 }
@@ -508,6 +509,7 @@ function configPatchFromConfig(config: unknown): PiTeamsConfig {
 	const runtime = configRecord(cfg.runtime);
 	const limits = configRecord(cfg.limits);
 	const worktree = configRecord(cfg.worktree);
+	const ui = configRecord(cfg.ui);
 	return {
 		asyncByDefault: typeof cfg.asyncByDefault === "boolean" ? cfg.asyncByDefault : undefined,
 		executeWorkers: typeof cfg.executeWorkers === "boolean" ? cfg.executeWorkers : undefined,
@@ -542,6 +544,11 @@ function configPatchFromConfig(config: unknown): PiTeamsConfig {
 			enabled: typeof control.enabled === "boolean" ? control.enabled : undefined,
 			needsAttentionAfterMs: typeof control.needsAttentionAfterMs === "number" && Number.isInteger(control.needsAttentionAfterMs) && control.needsAttentionAfterMs > 0 ? control.needsAttentionAfterMs : undefined,
 		} : undefined,
+		ui: Object.keys(ui).length > 0 ? {
+			widgetPlacement: ui.widgetPlacement === "aboveEditor" || ui.widgetPlacement === "belowEditor" ? ui.widgetPlacement : undefined,
+			widgetMaxLines: typeof ui.widgetMaxLines === "number" && Number.isInteger(ui.widgetMaxLines) && ui.widgetMaxLines > 0 ? ui.widgetMaxLines : undefined,
+			powerbar: typeof ui.powerbar === "boolean" ? ui.powerbar : undefined,
+		} : undefined,
 	};
 }
 

package/src/runtime/child-pi.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
@@ -8,6 +8,29 @@ import { getPiSpawnCommand } from "./pi-spawn.ts";
 const POST_EXIT_STDIO_GUARD_MS = 3000;
 const FINAL_DRAIN_MS = 5000;
 const HARD_KILL_MS = 3000;
+const activeChildProcesses = new Map<number, ChildProcess>();
+
+function killProcessTree(pid: number | undefined): void {
+	if (!pid || !Number.isInteger(pid) || pid <= 0) return;
+	try {
+		if (process.platform === "win32") {
+			spawn("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+			return;
+		}
+		try { process.kill(-pid, "SIGTERM"); } catch { process.kill(pid, "SIGTERM"); }
+		setTimeout(() => {
+			try { process.kill(-pid, "SIGKILL"); } catch { try { process.kill(pid, "SIGKILL"); } catch {} }
+		}, HARD_KILL_MS).unref?.();
+	} catch {
+		// Ignore shutdown races.
+	}
+}
+
+export function terminateActiveChildPiProcesses(): number {
+	const pids = [...activeChildProcesses.keys()];
+	for (const pid of pids) killProcessTree(pid);
+	return pids.length;
+}
 
 export interface ChildPiRunInput {
 	cwd: string;
@@ -118,7 +141,9 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				cwd: input.cwd,
 				env: { ...process.env, ...built.env },
 				stdio: ["ignore", "pipe", "pipe"],
+				detached: process.platform !== "win32",
 			});
+			if (child.pid) activeChildProcesses.set(child.pid, child);
 			let stdout = "";
 			let stderr = "";
 			let settled = false;
@@ -167,6 +192,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			};
 
 			const abort = (): void => {
+				killProcessTree(child.pid);
 				try {
 					child.kill(process.platform === "win32" ? undefined : "SIGTERM");
 				} catch {
@@ -187,6 +213,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				settle({ exitCode: null, stdout, stderr, error: error.message });
 			});
 			child.on("exit", () => {
+				if (child.pid) activeChildProcesses.delete(child.pid);
 				childExited = true;
 				clearFinalDrainTimers();
 				postExitGuard = setTimeout(() => {
@@ -196,6 +223,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				postExitGuard.unref?.();
 			});
 			child.on("close", (exitCode) => {
+				if (child.pid) activeChildProcesses.delete(child.pid);
 				settle({ exitCode, stdout, stderr, ...(forcedFinalDrain && !stderr.trim() ? { error: `Child Pi did not exit within ${finalDrainMs}ms after final assistant message; termination was requested.` } : {}) });
 			});
 		});

package/src/runtime/process-status.ts

@@ -38,6 +38,13 @@ export function isLikelyOrphanedActiveRun(run: TeamRunManifest, agents: CrewAgen
 	return agents.every((agent) => agent.status === "queued" && !agent.completedAt && !agent.progress);
 }
 
+function hasDurableActiveAgentEvidence(agent: CrewAgentRecord): boolean {
+	if (agent.status !== "running" && agent.status !== "queued") return false;
+	return Boolean(agent.statusPath || agent.eventsPath || agent.outputPath || agent.progress || agent.toolUses || agent.jsonEvents);
+}
+
 export function isDisplayActiveRun(run: TeamRunManifest, agents: CrewAgentRecord[] = [], now = Date.now()): boolean {
-	return isActiveRunStatus(run.status) && !isLikelyOrphanedActiveRun(run, agents, now);
+	if (!isActiveRunStatus(run.status) || isLikelyOrphanedActiveRun(run, agents, now)) return false;
+	if (agents.length === 0) return true;
+	return agents.some(hasDurableActiveAgentEvidence);
 }

package/src/runtime/runtime-resolver.ts

@@ -48,22 +48,21 @@ export async function isLiveSessionRuntimeAvailable(timeoutMs = 1500, env: NodeJ
 
 export async function resolveCrewRuntime(config: PiTeamsConfig, env: NodeJS.ProcessEnv = process.env): Promise<CrewRuntimeCapabilities> {
 	const requestedMode = config.runtime?.mode ?? "auto";
-	const executeWorkers = config.executeWorkers === true || env.PI_CREW_EXECUTE_WORKERS === "1" || env.PI_TEAMS_EXECUTE_WORKERS === "1";
+	const workersDisabled = config.executeWorkers === false || env.PI_CREW_EXECUTE_WORKERS === "0" || env.PI_TEAMS_EXECUTE_WORKERS === "0";
 	if (requestedMode === "scaffold") return scaffoldCaps(requestedMode);
-	if (requestedMode === "child-process") return childCaps(requestedMode, executeWorkers ? undefined : "child-process requested but executeWorkers is not enabled; caller should refuse or fall back explicitly.");
+	if (workersDisabled) return scaffoldCaps(requestedMode, "Child worker execution disabled by config/env. Set runtime.mode=scaffold or executeWorkers=false only for dry runs.");
+	if (requestedMode === "child-process") return childCaps(requestedMode);
 	if (requestedMode === "live-session" || (requestedMode === "auto" && config.runtime?.preferLiveSession === true)) {
 		const live = await isLiveSessionRuntimeAvailable(1500, env);
 		if (live.available) return liveCaps(requestedMode);
 		if (requestedMode === "live-session" && config.runtime?.allowChildProcessFallback === false) return { ...scaffoldCaps(requestedMode), available: false, reason: live.reason };
-		if (executeWorkers) return { ...childCaps(requestedMode), fallback: "child-process", reason: live.reason };
-		return { ...scaffoldCaps(requestedMode), fallback: "scaffold", reason: live.reason };
+		return { ...childCaps(requestedMode), fallback: "child-process", reason: live.reason };
 	}
-	if (executeWorkers) return childCaps(requestedMode);
-	return scaffoldCaps(requestedMode);
+	return childCaps(requestedMode);
 }
 
-function scaffoldCaps(requestedMode: CrewRuntimeMode): CrewRuntimeCapabilities {
-	return { kind: "scaffold", requestedMode, available: true, steer: false, resume: false, liveToolActivity: false, transcript: false };
+function scaffoldCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {
+	return { kind: "scaffold", requestedMode, available: true, steer: false, resume: false, liveToolActivity: false, transcript: false, ...(reason ? { reason } : {}) };
 }
 
 function childCaps(requestedMode: CrewRuntimeMode, reason?: string): CrewRuntimeCapabilities {