pi-crew 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",
@@ -68,6 +68,7 @@
     "@mariozechner/pi-tui": "*"
   },
   "dependencies": {
+    "jiti": "^2.6.1",
     "typebox": "^1.1.24"
   },
   "devDependencies": {

package/schema.json

@@ -54,6 +54,30 @@
         "maxTasksPerRun": { "type": "integer", "minimum": 1 },
         "heartbeatStaleMs": { "type": "integer", "minimum": 1 }
       }
+    },
+    "runtime": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Crew runtime selection and live-agent behavior knobs.",
+      "properties": {
+        "mode": { "type": "string", "enum": ["auto", "scaffold", "child-process", "live-session"] },
+        "preferLiveSession": { "type": "boolean" },
+        "allowChildProcessFallback": { "type": "boolean" },
+        "maxTurns": { "type": "integer", "minimum": 1 },
+        "graceTurns": { "type": "integer", "minimum": 1 },
+        "inheritContext": { "type": "boolean" },
+        "promptMode": { "type": "string", "enum": ["replace", "append"] },
+        "groupJoin": { "type": "string", "enum": ["off", "group", "smart"] }
+      }
+    },
+    "control": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Agent control-plane settings for attention/stale activity detection.",
+      "properties": {
+        "enabled": { "type": "boolean" },
+        "needsAttentionAfterMs": { "type": "integer", "minimum": 1 }
+      }
     }
   }
 }

package/src/agents/agent-config.ts

@@ -24,4 +24,6 @@ export interface AgentConfig {
 	inheritProjectContext?: boolean;
 	inheritSkills?: boolean;
 	routing?: RoutingMetadata;
+	disabled?: boolean;
+	override?: { source: "config"; path: string };
 }

package/src/agents/discover-agents.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig, ResourceSource } from "./agent-config.ts";
+import { loadConfig } from "../config/config.ts";
 import { parseCsv, parseFrontmatter } from "../utils/frontmatter.ts";
 import { packageRoot, projectPiRoot, userPiRoot } from "../utils/paths.ts";
 
@@ -40,6 +41,7 @@ function parseAgentFile(filePath: string, source: ResourceSource): AgentConfig |
 			systemPromptMode: frontmatter.systemPromptMode === "append" ? "append" : "replace",
 			inheritProjectContext: frontmatter.inheritProjectContext === "true",
 			inheritSkills: frontmatter.inheritSkills === "true",
+			disabled: frontmatter.disabled === "true" || frontmatter.enabled === "false",
 			routing: triggers || useWhen || avoidWhen || cost || category ? { triggers, useWhen, avoidWhen, cost, category } : undefined,
 		};
 	} catch {
@@ -56,18 +58,40 @@ function readAgentDir(dir: string, source: ResourceSource): AgentConfig[] {
 		.sort((a, b) => a.name.localeCompare(b.name));
 }
 
+function applyAgentOverrides(agents: AgentConfig[], cwd: string): AgentConfig[] {
+	const loaded = loadConfig(cwd);
+	const config = loaded.config.agents;
+	const overrides = config?.overrides ?? {};
+	return agents
+		.filter((agent) => !(config?.disableBuiltins && agent.source === "builtin"))
+		.map((agent) => {
+			const overrideEntry = Object.entries(overrides).find(([name]) => name.toLowerCase() === agent.name.toLowerCase());
+			if (!overrideEntry) return agent;
+			const [, override] = overrideEntry;
+			return {
+				...agent,
+				disabled: override.disabled ?? agent.disabled,
+				model: override.model === false ? undefined : override.model ?? agent.model,
+				fallbackModels: override.fallbackModels === false ? undefined : override.fallbackModels ?? agent.fallbackModels,
+				thinking: override.thinking === false ? undefined : override.thinking ?? agent.thinking,
+				tools: override.tools === false ? undefined : override.tools ?? agent.tools,
+				override: { source: "config", path: loaded.path },
+			};
+		});
+}
+
 export function discoverAgents(cwd: string): AgentDiscoveryResult {
 	return {
-		builtin: readAgentDir(path.join(packageRoot(), "agents"), "builtin"),
-		user: readAgentDir(path.join(userPiRoot(), "agents"), "user"),
-		project: readAgentDir(path.join(projectPiRoot(cwd), "agents"), "project"),
+		builtin: applyAgentOverrides(readAgentDir(path.join(packageRoot(), "agents"), "builtin"), cwd),
+		user: applyAgentOverrides(readAgentDir(path.join(userPiRoot(), "agents"), "user"), cwd),
+		project: applyAgentOverrides(readAgentDir(path.join(projectPiRoot(cwd), "agents"), "project"), cwd),
 	};
 }
 
 export function allAgents(discovery: AgentDiscoveryResult): AgentConfig[] {
 	const byName = new Map<string, AgentConfig>();
 	for (const agent of [...discovery.builtin, ...discovery.user, ...discovery.project]) {
-		byName.set(agent.name, agent);
+		byName.set(agent.name.toLowerCase(), agent);
 	}
-	return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+	return [...byName.values()].filter((agent) => !agent.disabled).sort((a, b) => a.name.localeCompare(b.name));
 }

package/src/config/config.ts

@@ -23,6 +23,37 @@ export interface CrewLimitsConfig {
 	heartbeatStaleMs?: number;
 }
 
+export type CrewRuntimeMode = "auto" | "scaffold" | "child-process" | "live-session";
+
+export interface CrewRuntimeConfig {
+	mode?: CrewRuntimeMode;
+	preferLiveSession?: boolean;
+	allowChildProcessFallback?: boolean;
+	maxTurns?: number;
+	graceTurns?: number;
+	inheritContext?: boolean;
+	promptMode?: "replace" | "append";
+	groupJoin?: "off" | "group" | "smart";
+}
+
+export interface CrewControlConfig {
+	enabled?: boolean;
+	needsAttentionAfterMs?: number;
+}
+
+export interface AgentOverrideConfig {
+	disabled?: boolean;
+	model?: string | false;
+	fallbackModels?: string[] | false;
+	thinking?: string | false;
+	tools?: string[] | false;
+}
+
+export interface CrewAgentsConfig {
+	disableBuiltins?: boolean;
+	overrides?: Record<string, AgentOverrideConfig>;
+}
+
 export interface PiTeamsConfig {
 	asyncByDefault?: boolean;
 	executeWorkers?: boolean;
@@ -30,6 +61,9 @@ export interface PiTeamsConfig {
 	requireCleanWorktreeLeader?: boolean;
 	autonomous?: PiTeamsAutonomousConfig;
 	limits?: CrewLimitsConfig;
+	runtime?: CrewRuntimeConfig;
+	control?: CrewControlConfig;
+	agents?: CrewAgentsConfig;
 }
 
 export interface LoadedPiTeamsConfig {
@@ -77,6 +111,29 @@ function mergeConfig(base: PiTeamsConfig, override: PiTeamsConfig): PiTeamsConfi
 			...withoutUndefined((override.limits ?? {}) as Record<string, unknown>),
 		};
 	}
+	if (base.runtime || override.runtime) {
+		merged.runtime = {
+			...(base.runtime ?? {}),
+			...withoutUndefined((override.runtime ?? {}) as Record<string, unknown>),
+		};
+	}
+	if (base.control || override.control) {
+		merged.control = {
+			...(base.control ?? {}),
+			...withoutUndefined((override.control ?? {}) as Record<string, unknown>),
+		};
+	}
+	if (base.agents || override.agents) {
+		merged.agents = {
+			...(base.agents ?? {}),
+			...withoutUndefined((override.agents ?? {}) as Record<string, unknown>),
+			overrides: {
+				...(base.agents?.overrides ?? {}),
+				...(override.agents?.overrides ?? {}),
+			},
+		};
+	}
+	if (merged.agents?.overrides && Object.keys(merged.agents.overrides).length === 0) delete merged.agents.overrides;
 	return merged;
 }
 
@@ -127,25 +184,104 @@ function parseAutonomousConfig(value: unknown): PiTeamsAutonomousConfig | undefi
 	};
 }
 
-function parsePositiveInteger(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+const LIMIT_CEILINGS = {
+	maxConcurrentWorkers: 1024,
+	maxTaskDepth: 100,
+	maxChildrenPerTask: 1000,
+	maxRunMinutes: 1440,
+	maxRetriesPerTask: 100,
+	maxTasksPerRun: 10_000,
+	heartbeatStaleMs: 24 * 60 * 60 * 1000,
+	runtimeMaxTurns: 10_000,
+	runtimeGraceTurns: 1_000,
+} as const;
+
+function parsePositiveInteger(value: unknown, max = Number.MAX_SAFE_INTEGER): number | undefined {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= max ? value : undefined;
 }
 
 function parseLimitsConfig(value: unknown): CrewLimitsConfig | undefined {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
 	const obj = value as Record<string, unknown>;
 	const limits: CrewLimitsConfig = {
-		maxConcurrentWorkers: parsePositiveInteger(obj.maxConcurrentWorkers),
-		maxTaskDepth: parsePositiveInteger(obj.maxTaskDepth),
-		maxChildrenPerTask: parsePositiveInteger(obj.maxChildrenPerTask),
-		maxRunMinutes: parsePositiveInteger(obj.maxRunMinutes),
-		maxRetriesPerTask: parsePositiveInteger(obj.maxRetriesPerTask),
-		maxTasksPerRun: parsePositiveInteger(obj.maxTasksPerRun),
-		heartbeatStaleMs: parsePositiveInteger(obj.heartbeatStaleMs),
+		maxConcurrentWorkers: parsePositiveInteger(obj.maxConcurrentWorkers, LIMIT_CEILINGS.maxConcurrentWorkers),
+		maxTaskDepth: parsePositiveInteger(obj.maxTaskDepth, LIMIT_CEILINGS.maxTaskDepth),
+		maxChildrenPerTask: parsePositiveInteger(obj.maxChildrenPerTask, LIMIT_CEILINGS.maxChildrenPerTask),
+		maxRunMinutes: parsePositiveInteger(obj.maxRunMinutes, LIMIT_CEILINGS.maxRunMinutes),
+		maxRetriesPerTask: parsePositiveInteger(obj.maxRetriesPerTask, LIMIT_CEILINGS.maxRetriesPerTask),
+		maxTasksPerRun: parsePositiveInteger(obj.maxTasksPerRun, LIMIT_CEILINGS.maxTasksPerRun),
+		heartbeatStaleMs: parsePositiveInteger(obj.heartbeatStaleMs, LIMIT_CEILINGS.heartbeatStaleMs),
 	};
 	return Object.values(limits).some((entry) => entry !== undefined) ? limits : undefined;
 }
 
+function parseRuntimeMode(value: unknown): CrewRuntimeMode | undefined {
+	return value === "auto" || value === "scaffold" || value === "child-process" || value === "live-session" ? value : undefined;
+}
+
+function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const obj = value as Record<string, unknown>;
+	const runtime: CrewRuntimeConfig = {
+		mode: parseRuntimeMode(obj.mode),
+		preferLiveSession: typeof obj.preferLiveSession === "boolean" ? obj.preferLiveSession : undefined,
+		allowChildProcessFallback: typeof obj.allowChildProcessFallback === "boolean" ? obj.allowChildProcessFallback : undefined,
+		maxTurns: parsePositiveInteger(obj.maxTurns, LIMIT_CEILINGS.runtimeMaxTurns),
+		graceTurns: parsePositiveInteger(obj.graceTurns, LIMIT_CEILINGS.runtimeGraceTurns),
+		inheritContext: typeof obj.inheritContext === "boolean" ? obj.inheritContext : undefined,
+		promptMode: obj.promptMode === "replace" || obj.promptMode === "append" ? obj.promptMode : undefined,
+		groupJoin: obj.groupJoin === "off" || obj.groupJoin === "group" || obj.groupJoin === "smart" ? obj.groupJoin : undefined,
+	};
+	return Object.values(runtime).some((entry) => entry !== undefined) ? runtime : undefined;
+}
+
+function parseControlConfig(value: unknown): CrewControlConfig | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const obj = value as Record<string, unknown>;
+	const control: CrewControlConfig = {
+		enabled: typeof obj.enabled === "boolean" ? obj.enabled : undefined,
+		needsAttentionAfterMs: parsePositiveInteger(obj.needsAttentionAfterMs),
+	};
+	return Object.values(control).some((entry) => entry !== undefined) ? control : undefined;
+}
+
+function parseStringArrayOrFalse(value: unknown): string[] | false | undefined {
+	if (value === false) return false;
+	if (typeof value === "string") return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+	if (Array.isArray(value)) return value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim());
+	return undefined;
+}
+
+function parseAgentOverride(value: unknown): AgentOverrideConfig | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const obj = value as Record<string, unknown>;
+	const override: AgentOverrideConfig = {
+		disabled: typeof obj.disabled === "boolean" ? obj.disabled : undefined,
+		model: typeof obj.model === "string" || obj.model === false ? obj.model : undefined,
+		fallbackModels: parseStringArrayOrFalse(obj.fallbackModels),
+		thinking: typeof obj.thinking === "string" || obj.thinking === false ? obj.thinking : undefined,
+		tools: parseStringArrayOrFalse(obj.tools),
+	};
+	return Object.values(override).some((entry) => entry !== undefined) ? override : undefined;
+}
+
+function parseAgentsConfig(value: unknown): CrewAgentsConfig | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const obj = value as Record<string, unknown>;
+	const overrides: Record<string, AgentOverrideConfig> = {};
+	if (obj.overrides && typeof obj.overrides === "object" && !Array.isArray(obj.overrides)) {
+		for (const [name, rawOverride] of Object.entries(obj.overrides)) {
+			const parsed = parseAgentOverride(rawOverride);
+			if (parsed) overrides[name] = parsed;
+		}
+	}
+	const agents: CrewAgentsConfig = {
+		disableBuiltins: typeof obj.disableBuiltins === "boolean" ? obj.disableBuiltins : undefined,
+		overrides: Object.keys(overrides).length > 0 ? overrides : undefined,
+	};
+	return Object.values(agents).some((entry) => entry !== undefined) ? agents : undefined;
+}
+
 function parseConfig(raw: unknown): PiTeamsConfig {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
 	const obj = raw as Record<string, unknown>;
@@ -156,6 +292,9 @@ function parseConfig(raw: unknown): PiTeamsConfig {
 		requireCleanWorktreeLeader: typeof obj.requireCleanWorktreeLeader === "boolean" ? obj.requireCleanWorktreeLeader : undefined,
 		autonomous: parseAutonomousConfig(obj.autonomous),
 		limits: parseLimitsConfig(obj.limits),
+		runtime: parseRuntimeConfig(obj.runtime),
+		control: parseControlConfig(obj.control),
+		agents: parseAgentsConfig(obj.agents),
 	};
 }
 

package/src/extension/register.ts

@@ -167,7 +167,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			const config: Record<string, unknown> = { operation };
 			for (const token of tokens.filter((item) => item.includes("="))) {
 				const [key, ...rest] = token.split("=");
-				if (key) config[key] = rest.join("=");
+				if (key) config[key] = parseScalar(rest.join("="));
 			}
 			const result = await handleTeamTool({ action: "api", runId, config }, ctx);
 			await notifyCommandResult(ctx, commandText(result));
@@ -255,7 +255,15 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				if (selection.action === "reload") continue;
 				const result = selection.action === "api"
 					? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-manifest" } }, ctx)
-					: await handleTeamTool({ action: selection.action, runId: selection.runId }, ctx);
+					: selection.action === "agents"
+						? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "agent-dashboard" } }, ctx)
+						: selection.action === "agent-events"
+							? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-events", limit: 50 } }, ctx)
+							: selection.action === "agent-output"
+								? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-output", maxBytes: 32_000 } }, ctx)
+								: selection.action === "agent-transcript"
+									? await handleTeamTool({ action: "api", runId: selection.runId, config: { operation: "read-agent-transcript" } }, ctx)
+									: await handleTeamTool({ action: selection.action, runId: selection.runId }, ctx);
 				await notifyCommandResult(ctx, commandText(result));
 				return;
 			}

package/src/extension/team-tool.ts

@@ -21,7 +21,7 @@ import { getPiSpawnCommand } from "../runtime/pi-spawn.ts";
 import { executeTeamRun } from "../runtime/team-runner.ts";
 import { spawnBackgroundTeamRun } from "../runtime/async-runner.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../runtime/process-status.ts";
-import { appendEvent, readEvents } from "../state/event-log.ts";
+import { appendEvent, readEvents, readEventsCursor } from "../state/event-log.ts";
 import { cleanupRunWorktrees } from "../worktree/cleanup.ts";
 import { piTeamsHelp } from "./help.ts";
 import { initializeProject } from "./project-init.ts";
@@ -35,6 +35,12 @@ import { formatValidationReport, validateResources } from "./validate-resources.
 import { formatRecommendation, recommendTeam } from "./team-recommendation.ts";
 import { toolResult, type PiTeamsToolResult } from "./tool-result.ts";
 import { touchWorkerHeartbeat } from "../runtime/worker-heartbeat.ts";
+import { agentEventsPath, agentOutputPath, readCrewAgentEvents, readCrewAgentEventsCursor, readCrewAgentStatus, readCrewAgents } from "../runtime/crew-agent-records.ts";
+import { resolveCrewRuntime } from "../runtime/runtime-resolver.ts";
+import { probeLiveSessionRuntime } from "../runtime/live-session-runtime.ts";
+import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../runtime/agent-control.ts";
+import { buildAgentDashboard, readAgentOutput } from "../runtime/agent-observability.ts";
+import { readForegroundControlStatus, writeForegroundInterruptRequest } from "../runtime/foreground-control.ts";
 
 export interface TeamToolDetails {
 	action: string;
@@ -255,8 +261,9 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
 	}
 
-	const executeWorkers = loadedConfig.config.executeWorkers === true || process.env.PI_TEAMS_EXECUTE_WORKERS === "1";
-	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits });
+	const runtime = await resolveCrewRuntime(loadedConfig.config);
+	const executeWorkers = runtime.kind === "child-process";
+	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,
@@ -266,9 +273,10 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		`State: ${executed.manifest.stateRoot}`,
 		`Artifacts: ${executed.manifest.artifactsRoot}`,
 		"",
+		`Runtime: ${runtime.kind}${runtime.fallback ? ` (fallback from ${runtime.requestedMode})` : ""}${runtime.reason ? ` - ${runtime.reason}` : ""}`,
 		executeWorkers
-			? "Child Pi worker execution was enabled with PI_TEAMS_EXECUTE_WORKERS=1."
-			: "Safe scaffold mode: child Pi workers were not launched. Set PI_TEAMS_EXECUTE_WORKERS=1 to enable real worker execution.",
+			? "Child Pi worker execution was enabled."
+			: "Safe scaffold mode: child Pi workers were not launched. Set PI_TEAMS_EXECUTE_WORKERS=1 or runtime.mode=child-process to enable real worker execution.",
 	].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");
 }
@@ -291,6 +299,8 @@ 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 events = readEvents(manifest.eventsPath).slice(-8);
+	const controlConfig = resolveCrewControlConfig(loadConfig(ctx.cwd).config);
+	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
 	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
 	const totalUsage = aggregateUsage(tasks);
 	const lines = [
@@ -308,6 +318,8 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		"Tasks:",
 		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
 		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
+		"Agents:",
+		...(crewAgents.length ? crewAgents.map((agent) => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`) : ["- (none)"]),
 		"Policy decisions:",
 		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
 		`Total usage: ${formatUsage(totalUsage)}`,
@@ -370,8 +382,9 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		saveRunTasks(loaded.manifest, resetTasks);
 		appendEvent(loaded.manifest.eventsPath, { type: "run.resume_requested", runId: loaded.manifest.runId });
 		const loadedConfig = loadConfig(ctx.cwd);
-		const executeWorkers = loadedConfig.config.executeWorkers === true || process.env.PI_TEAMS_EXECUTE_WORKERS === "1";
-		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits });
+		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 });
 		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");
 	});
 }
@@ -446,12 +459,17 @@ function autonomousPatchFromConfig(config: unknown): PiTeamsAutonomousConfig {
 
 function configPatchFromConfig(config: unknown): PiTeamsConfig {
 	const cfg = configRecord(config);
+	const control = configRecord(cfg.control);
 	return {
 		asyncByDefault: typeof cfg.asyncByDefault === "boolean" ? cfg.asyncByDefault : undefined,
 		executeWorkers: typeof cfg.executeWorkers === "boolean" ? cfg.executeWorkers : undefined,
 		notifierIntervalMs: typeof cfg.notifierIntervalMs === "number" && Number.isFinite(cfg.notifierIntervalMs) ? cfg.notifierIntervalMs : undefined,
 		requireCleanWorktreeLeader: typeof cfg.requireCleanWorktreeLeader === "boolean" ? cfg.requireCleanWorktreeLeader : undefined,
 		autonomous: typeof cfg.autonomous === "object" && cfg.autonomous !== null && !Array.isArray(cfg.autonomous) ? autonomousPatchFromConfig(cfg.autonomous) : undefined,
+		control: Object.keys(control).length > 0 ? {
+			enabled: typeof control.enabled === "boolean" ? control.enabled : undefined,
+			needsAttentionAfterMs: typeof control.needsAttentionAfterMs === "number" && Number.isInteger(control.needsAttentionAfterMs) && control.needsAttentionAfterMs > 0 ? control.needsAttentionAfterMs : undefined,
+		} : undefined,
 	};
 }
 
@@ -540,7 +558,7 @@ export function handleCleanup(params: TeamToolParamsValue, ctx: TeamContext): Pi
 	return result(lines.join("\n"), { action: "cleanup", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 }
 
-export function handleApi(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	if (!params.runId) return result("API requires runId.", { action: "api", status: "error" }, true);
 	const loaded = loadRunManifestById(ctx.cwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
@@ -559,7 +577,92 @@ export function handleApi(params: TeamToolParamsValue, ctx: TeamContext): PiTeam
 		return result(JSON.stringify(task, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
 	}
 	if (operation === "read-events") {
-		return result(JSON.stringify(readEvents(loaded.manifest.eventsPath), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+		const sinceSeq = typeof cfg.sinceSeq === "number" ? cfg.sinceSeq : undefined;
+		const limit = typeof cfg.limit === "number" ? cfg.limit : undefined;
+		const payload = sinceSeq !== undefined || limit !== undefined
+			? readEventsCursor(loaded.manifest.eventsPath, { sinceSeq, limit })
+			: { events: readEvents(loaded.manifest.eventsPath), nextSeq: undefined, total: undefined };
+		return result(JSON.stringify(payload, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "runtime-capabilities") {
+		const loadedConfig = loadConfig(ctx.cwd);
+		return result(JSON.stringify(await resolveCrewRuntime(loadedConfig.config), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "probe-live-session") {
+		return result(JSON.stringify(await probeLiveSessionRuntime(), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "list-agents") {
+		return result(JSON.stringify(readCrewAgents(loaded.manifest), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "get-agent-result") {
+		const agentId = typeof cfg.agentId === "string" ? cfg.agentId : undefined;
+		const agent = readCrewAgents(loaded.manifest).find((item) => item.id === agentId || item.taskId === agentId);
+		if (!agent) return result("API get-agent-result requires config.agentId matching an agent id or task id.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		const task = loaded.tasks.find((item) => item.id === agent.taskId);
+		const text = task?.resultArtifact && fs.existsSync(task.resultArtifact.path) ? fs.readFileSync(task.resultArtifact.path, "utf-8") : JSON.stringify(agent, null, 2);
+		return result(text, { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "read-agent-status") {
+		const agentId = typeof cfg.agentId === "string" ? cfg.agentId : undefined;
+		const agent = agentId ? readCrewAgents(loaded.manifest).find((item) => item.id === agentId || item.taskId === agentId) : undefined;
+		const status = agent ? readCrewAgentStatus(loaded.manifest, agent.taskId) ?? agent : undefined;
+		if (!status) return result("API read-agent-status requires config.agentId matching an agent id or task id.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		return result(JSON.stringify(status, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "read-agent-events") {
+		const agentId = typeof cfg.agentId === "string" ? cfg.agentId : undefined;
+		const agents = readCrewAgents(loaded.manifest);
+		const agent = agentId ? agents.find((item) => item.id === agentId || item.taskId === agentId) : agents[0];
+		if (!agent) return result("API read-agent-events requires config.agentId matching an agent id or task id, or at least one agent in the run.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		const sinceSeq = typeof cfg.sinceSeq === "number" ? cfg.sinceSeq : undefined;
+		const limit = typeof cfg.limit === "number" ? cfg.limit : undefined;
+		const payload = sinceSeq !== undefined || limit !== undefined
+			? readCrewAgentEventsCursor(loaded.manifest, agent.taskId, { sinceSeq, limit })
+			: { path: agentEventsPath(loaded.manifest, agent.taskId), events: readCrewAgentEvents(loaded.manifest, agent.taskId) };
+		return result(JSON.stringify(payload, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "read-agent-transcript") {
+		const agentId = typeof cfg.agentId === "string" ? cfg.agentId : undefined;
+		const agents = readCrewAgents(loaded.manifest);
+		const agent = agentId ? agents.find((item) => item.id === agentId || item.taskId === agentId) : agents[0];
+		if (!agent) return result("API read-agent-transcript requires config.agentId matching an agent id or task id, or at least one agent in the run.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		const transcriptPath = agent.transcriptPath && fs.existsSync(agent.transcriptPath) ? agent.transcriptPath : agentOutputPath(loaded.manifest, agent.taskId);
+		const text = fs.existsSync(transcriptPath) ? fs.readFileSync(transcriptPath, "utf-8") : "";
+		return result(text || `(no transcript at ${transcriptPath})`, { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "read-agent-output") {
+		const agentId = typeof cfg.agentId === "string" ? cfg.agentId : undefined;
+		const agents = readCrewAgents(loaded.manifest);
+		const agent = agentId ? agents.find((item) => item.id === agentId || item.taskId === agentId) : agents[0];
+		if (!agent) return result("API read-agent-output requires config.agentId matching an agent id or task id, or at least one agent in the run.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		const maxBytes = typeof cfg.maxBytes === "number" ? cfg.maxBytes : undefined;
+		return result(JSON.stringify(readAgentOutput(loaded.manifest, agent.taskId, maxBytes), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "agent-dashboard") {
+		return result(buildAgentDashboard(loaded.manifest).text, { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "foreground-status") {
+		return result(JSON.stringify(readForegroundControlStatus(loaded.manifest, loaded.tasks), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "foreground-interrupt") {
+		const reason = typeof cfg.reason === "string" && cfg.reason.trim() ? cfg.reason.trim() : undefined;
+		return result(JSON.stringify(writeForegroundInterruptRequest(loaded.manifest, reason), null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "nudge-agent") {
+		const agentId = typeof cfg.agentId === "string" ? cfg.agentId : undefined;
+		const agent = readCrewAgents(loaded.manifest).find((item) => item.id === agentId || item.taskId === agentId);
+		if (!agent) return result("API nudge-agent requires config.agentId matching an agent id or task id.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		const messageText = typeof cfg.message === "string" && cfg.message.trim() ? cfg.message.trim() : "Please report your current status, blocker, or smallest next step.";
+		const message = appendMailboxMessage(loaded.manifest, { direction: "inbox", from: "leader", to: agent.taskId, taskId: agent.taskId, body: messageText });
+		appendEvent(loaded.manifest.eventsPath, { type: "agent.nudged", runId: loaded.manifest.runId, taskId: agent.taskId, message: messageText, data: { agentId: agent.id, mailboxMessageId: message.id } });
+		return result(JSON.stringify({ agentId: agent.id, mailboxMessage: message }, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	}
+	if (operation === "steer-agent" || operation === "stop-agent" || operation === "resume-agent" || operation === "interrupt-agent") {
+		const runtime = await resolveCrewRuntime(loadConfig(ctx.cwd).config);
+		if (!runtime.steer && operation === "steer-agent") return result(`Runtime '${runtime.kind}' does not support live steering. Use nudge-agent for mailbox-based child-process coordination.`, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		if (!runtime.resume && operation === "resume-agent") return result(`Runtime '${runtime.kind}' does not support live resume.`, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		if (operation === "interrupt-agent" && runtime.kind !== "live-session") return result(`Runtime '${runtime.kind}' does not expose per-agent interrupt yet. Use nudge-agent or cancel the run.`, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		return result(`Operation '${operation}' is reserved for live-session runtime and is not active for this run yet.`, { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 	}
 	if (operation === "read-mailbox") {
 		const direction = cfg.direction === "inbox" || cfg.direction === "outbox" ? cfg.direction as MailboxDirection : undefined;
@@ -762,7 +865,7 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 		}
 		case "doctor": return handleDoctor(ctx, params);
 		case "cleanup": return handleCleanup(params, ctx);
-		case "api": return handleApi(params, ctx);
+		case "api": return await handleApi(params, ctx);
 		case "events": return handleEvents(params, ctx);
 		case "artifacts": return handleArtifacts(params, ctx);
 		case "worktrees": return handleWorktrees(params, ctx);

package/src/prompt/prompt-runtime.ts

@@ -2,6 +2,8 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";
+export const PI_CREW_INHERIT_PROJECT_CONTEXT_ENV = "PI_CREW_INHERIT_PROJECT_CONTEXT";
+export const PI_CREW_INHERIT_SKILLS_ENV = "PI_CREW_INHERIT_SKILLS";
 
 const PROJECT_CONTEXT_HEADER = "\n\n# Project Context\n\nProject-specific instructions and guidelines:\n\n";
 const SKILLS_HEADER = "\n\nThe following skills provide specialized instructions for specific tasks.";
@@ -13,6 +15,14 @@ function readBooleanEnv(name: string): boolean | undefined {
 	return value !== "0";
 }
 
+function readBooleanEnvAny(...names: string[]): boolean | undefined {
+	for (const name of names) {
+		const value = readBooleanEnv(name);
+		if (value !== undefined) return value;
+	}
+	return undefined;
+}
+
 function findSectionEnd(prompt: string, startIndex: number, nextHeaders: string[]): number {
 	let endIndex = prompt.length;
 	for (const header of nextHeaders) {
@@ -45,8 +55,8 @@ export function rewriteTeamWorkerPrompt(prompt: string, options: { inheritProjec
 
 export default function registerPiTeamsPromptRuntime(pi: ExtensionAPI): void {
 	pi.on("before_agent_start", (event) => {
-		const inheritProjectContext = readBooleanEnv(PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV);
-		const inheritSkills = readBooleanEnv(PI_TEAMS_INHERIT_SKILLS_ENV);
+		const inheritProjectContext = readBooleanEnvAny(PI_CREW_INHERIT_PROJECT_CONTEXT_ENV, PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV);
+		const inheritSkills = readBooleanEnvAny(PI_CREW_INHERIT_SKILLS_ENV, PI_TEAMS_INHERIT_SKILLS_ENV);
 		if (inheritProjectContext === undefined && inheritSkills === undefined) return;
 		const rewritten = rewriteTeamWorkerPrompt(event.systemPrompt, {
 			inheritProjectContext: inheritProjectContext ?? true,