pi-crew 0.1.6 → 0.1.7

package/package.json

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

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

@@ -41,6 +41,19 @@ export interface CrewControlConfig {
 	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;
@@ -50,6 +63,7 @@ export interface PiTeamsConfig {
 	limits?: CrewLimitsConfig;
 	runtime?: CrewRuntimeConfig;
 	control?: CrewControlConfig;
+	agents?: CrewAgentsConfig;
 }
 
 export interface LoadedPiTeamsConfig {
@@ -109,6 +123,17 @@ function mergeConfig(base: PiTeamsConfig, override: PiTeamsConfig): PiTeamsConfi
 			...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;
 }
 
@@ -159,21 +184,33 @@ 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;
 }
@@ -189,8 +226,8 @@ function parseRuntimeConfig(value: unknown): CrewRuntimeConfig | undefined {
 		mode: parseRuntimeMode(obj.mode),
 		preferLiveSession: typeof obj.preferLiveSession === "boolean" ? obj.preferLiveSession : undefined,
 		allowChildProcessFallback: typeof obj.allowChildProcessFallback === "boolean" ? obj.allowChildProcessFallback : undefined,
-		maxTurns: parsePositiveInteger(obj.maxTurns),
-		graceTurns: parsePositiveInteger(obj.graceTurns),
+		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,
@@ -208,6 +245,43 @@ function parseControlConfig(value: unknown): CrewControlConfig | undefined {
 	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>;
@@ -220,6 +294,7 @@ function parseConfig(raw: unknown): PiTeamsConfig {
 		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,10 +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, readCrewAgentStatus, readCrewAgents } from "../runtime/crew-agent-records.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;
@@ -575,7 +577,12 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		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);
@@ -604,18 +611,43 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 	}
 	if (operation === "read-agent-events") {
 		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 read-agent-events requires config.agentId matching an agent id or task id.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
-		return result(JSON.stringify({ path: agentEventsPath(loaded.manifest, agent.taskId), events: readCrewAgentEvents(loaded.manifest, agent.taskId) }, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+		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 agent = readCrewAgents(loaded.manifest).find((item) => item.id === agentId || item.taskId === agentId);
-		if (!agent) return result("API read-agent-transcript requires config.agentId matching an agent id or task id.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
+		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);

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,

package/src/runtime/agent-observability.ts

@@ -0,0 +1,88 @@
+import * as fs from "node:fs";
+import type { TeamRunManifest } from "../state/types.ts";
+import { agentOutputPath, readCrewAgents } from "./crew-agent-records.ts";
+import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
+
+export interface TextTailResult {
+	path: string;
+	text: string;
+	bytes: number;
+	truncated: boolean;
+}
+
+export function readTextTail(filePath: string, maxBytes = 64_000): TextTailResult {
+	if (!fs.existsSync(filePath)) return { path: filePath, text: "", bytes: 0, truncated: false };
+	const stat = fs.statSync(filePath);
+	const bytesToRead = Math.min(stat.size, Math.max(0, maxBytes));
+	const fd = fs.openSync(filePath, "r");
+	try {
+		const buffer = Buffer.alloc(bytesToRead);
+		fs.readSync(fd, buffer, 0, bytesToRead, stat.size - bytesToRead);
+		return { path: filePath, text: buffer.toString("utf-8"), bytes: stat.size, truncated: stat.size > bytesToRead };
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+
+function activityText(agent: CrewAgentRecord): string {
+	const parts: string[] = [];
+	if (agent.progress?.activityState) parts.push(agent.progress.activityState);
+	if (agent.progress?.currentTool) parts.push(`tool=${agent.progress.currentTool}`);
+	if (agent.toolUses !== undefined) parts.push(`tools=${agent.toolUses}`);
+	if (agent.progress?.tokens !== undefined) parts.push(`tokens=${agent.progress.tokens}`);
+	if (agent.progress?.turns !== undefined) parts.push(`turns=${agent.progress.turns}`);
+	if (agent.progress?.durationMs !== undefined) parts.push(`durationMs=${agent.progress.durationMs}`);
+	if (agent.progress?.failedTool) parts.push(`failedTool=${agent.progress.failedTool}`);
+	if (agent.progress?.recentOutput?.length) parts.push(`last=${agent.progress.recentOutput.at(-1)}`);
+	return parts.join(" ") || "idle";
+}
+
+function statusGlyph(status: CrewAgentRecord["status"]): string {
+	if (status === "completed") return "✓";
+	if (status === "failed") return "✗";
+	if (status === "running") return "▶";
+	if (status === "cancelled" || status === "stopped") return "■";
+	return "·";
+}
+
+function outputWarning(agent: CrewAgentRecord): string {
+	if (agent.status !== "completed") return "";
+	if (!agent.outputPath || !fs.existsSync(agent.outputPath)) return " no-output";
+	try {
+		return fs.statSync(agent.outputPath).size === 0 ? " no-output" : "";
+	} catch {
+		return " no-output";
+	}
+}
+
+function agentLine(agent: CrewAgentRecord): string {
+	return `- ${statusGlyph(agent.status)} ${agent.taskId} [${agent.status}] ${agent.role}->${agent.agent} runtime=${agent.runtime} ${activityText(agent)}${outputWarning(agent)}${agent.error ? ` error=${agent.error}` : ""}`;
+}
+
+export function buildAgentDashboard(manifest: TeamRunManifest): { text: string; groups: Record<string, CrewAgentRecord[]> } {
+	const agents = readCrewAgents(manifest);
+	const groups: Record<string, CrewAgentRecord[]> = {
+		running: agents.filter((agent) => agent.status === "running"),
+		queued: agents.filter((agent) => agent.status === "queued"),
+		recent: agents.filter((agent) => agent.status !== "running" && agent.status !== "queued"),
+	};
+	const lines = [
+		`Crew agents for ${manifest.runId}`,
+		`Run status: ${manifest.status}`,
+		`Counts: running=${groups.running.length}, queued=${groups.queued.length}, recent=${groups.recent.length}`,
+		"",
+		"## Running",
+		...(groups.running.length ? groups.running.map(agentLine) : ["- (none)"]),
+		"",
+		"## Queued",
+		...(groups.queued.length ? groups.queued.map(agentLine) : ["- (none)"]),
+		"",
+		"## Recent",
+		...(groups.recent.length ? groups.recent.slice(-10).map(agentLine) : ["- (none)"]),
+	];
+	return { text: lines.join("\n"), groups };
+}
+
+export function readAgentOutput(manifest: TeamRunManifest, taskId: string, maxBytes?: number): TextTailResult {
+	return readTextTail(agentOutputPath(manifest, taskId), maxBytes);
+}

package/src/runtime/child-pi.ts

@@ -2,10 +2,12 @@ import { spawn } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
-import { buildPiWorkerArgs, cleanupTempDir } from "./pi-args.ts";
+import { buildPiWorkerArgs, checkCrewDepth, cleanupTempDir } from "./pi-args.ts";
 import { getPiSpawnCommand } from "./pi-spawn.ts";
 
 const POST_EXIT_STDIO_GUARD_MS = 3000;
+const FINAL_DRAIN_MS = 5000;
+const HARD_KILL_MS = 3000;
 
 export interface ChildPiRunInput {
 	cwd: string;
@@ -16,6 +18,9 @@ export interface ChildPiRunInput {
 	transcriptPath?: string;
 	onStdoutLine?: (line: string) => void;
 	onJsonEvent?: (event: unknown) => void;
+	maxDepth?: number;
+	finalDrainMs?: number;
+	hardKillMs?: number;
 }
 
 export interface ChildPiRunResult {
@@ -71,7 +76,25 @@ function observeStdoutChunk(input: ChildPiRunInput, text: string): void {
 	observer.flush();
 }
 
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function isFinalAssistantEvent(event: unknown): boolean {
+	const obj = asRecord(event);
+	if (!obj || obj.type !== "message_end") return false;
+	const message = asRecord(obj.message);
+	const role = message?.role;
+	if (role !== undefined && role !== "assistant") return false;
+	const stopReason = typeof message?.stopReason === "string" ? message.stopReason : typeof obj.stopReason === "string" ? obj.stopReason : undefined;
+	if (stopReason !== undefined && stopReason !== "stop") return false;
+	const content = Array.isArray(message?.content) ? message.content : [];
+	return !content.some((part) => asRecord(part)?.type === "toolCall");
+}
+
 export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResult> {
+	const depth = checkCrewDepth(input.maxDepth);
+	if (depth.blocked) return { exitCode: 1, stdout: "", stderr: `pi-crew depth guard blocked child worker: depth ${depth.depth} >= max ${depth.maxDepth}` };
 	const mock = process.env.PI_TEAMS_MOCK_CHILD_PI;
 	if (mock) {
 		if (mock === "success") {
@@ -87,7 +110,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 		if (mock === "retryable-failure") return { exitCode: 1, stdout: "", stderr: "rate limit: mock failure" };
 		return { exitCode: 1, stdout: "", stderr: `mock failure: ${mock}` };
 	}
-	const built = buildPiWorkerArgs({ task: input.task, agent: input.agent, model: input.model, sessionEnabled: false });
+	const built = buildPiWorkerArgs({ task: input.task, agent: input.agent, model: input.model, sessionEnabled: false, maxDepth: input.maxDepth });
 	const spawnSpec = getPiSpawnCommand(built.args);
 	try {
 		return await new Promise<ChildPiRunResult>((resolve) => {
@@ -99,13 +122,44 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			let stdout = "";
 			let stderr = "";
 			let settled = false;
+			let childExited = false;
 			let postExitGuard: NodeJS.Timeout | undefined;
-			const lineObserver = new ChildPiLineObserver(input);
+			let finalDrainTimer: NodeJS.Timeout | undefined;
+			let hardKillTimer: NodeJS.Timeout | undefined;
+			const finalDrainMs = input.finalDrainMs ?? FINAL_DRAIN_MS;
+			const hardKillMs = input.hardKillMs ?? HARD_KILL_MS;
+			let forcedFinalDrain = false;
+			const lineObserver = new ChildPiLineObserver({
+				...input,
+				onJsonEvent: (event) => {
+					input.onJsonEvent?.(event);
+					if (!isFinalAssistantEvent(event) || childExited || settled || finalDrainTimer) return;
+					finalDrainTimer = setTimeout(() => {
+						if (settled || childExited) return;
+						forcedFinalDrain = true;
+						try { child.kill(process.platform === "win32" ? undefined : "SIGTERM"); } catch {}
+						hardKillTimer = setTimeout(() => {
+							if (settled || childExited) return;
+							try { child.kill(process.platform === "win32" ? undefined : "SIGKILL"); } catch {}
+						}, hardKillMs);
+						hardKillTimer.unref?.();
+					}, finalDrainMs);
+					finalDrainTimer.unref?.();
+				},
+			});
+
+			const clearFinalDrainTimers = (): void => {
+				if (finalDrainTimer) clearTimeout(finalDrainTimer);
+				if (hardKillTimer) clearTimeout(hardKillTimer);
+				finalDrainTimer = undefined;
+				hardKillTimer = undefined;
+			};
 
 			const settle = (result: ChildPiRunResult): void => {
 				if (settled) return;
 				settled = true;
 				if (postExitGuard) clearTimeout(postExitGuard);
+				clearFinalDrainTimers();
 				lineObserver.flush();
 				input.signal?.removeEventListener("abort", abort);
 				cleanupTempDir(built.tempDir);
@@ -133,6 +187,8 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				settle({ exitCode: null, stdout, stderr, error: error.message });
 			});
 			child.on("exit", () => {
+				childExited = true;
+				clearFinalDrainTimers();
 				postExitGuard = setTimeout(() => {
 					child.stdout?.destroy();
 					child.stderr?.destroy();
@@ -140,7 +196,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				postExitGuard.unref?.();
 			});
 			child.on("close", (exitCode) => {
-				settle({ exitCode, stdout, stderr });
+				settle({ exitCode, stdout, stderr, ...(forcedFinalDrain && !stderr.trim() ? { error: `Child Pi did not exit within ${finalDrainMs}ms after final assistant message; termination was requested.` } : {}) });
 			});
 		});
 	} finally {

package/src/runtime/crew-agent-records.ts

@@ -52,17 +52,55 @@ export function readCrewAgentStatus(manifest: TeamRunManifest, taskOrAgentId: st
 	return readJsonFile<CrewAgentRecord>(agentStatusPath(manifest, taskId));
 }
 
+function nextAgentEventSeq(filePath: string): number {
+	if (!fs.existsSync(filePath)) return 1;
+	let max = 0;
+	for (const line of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		try {
+			const parsed = JSON.parse(line) as { seq?: unknown };
+			if (typeof parsed.seq === "number" && Number.isFinite(parsed.seq)) max = Math.max(max, parsed.seq);
+			else max += 1;
+		} catch {
+			max += 1;
+		}
+	}
+	return max + 1;
+}
+
 export function appendCrewAgentEvent(manifest: TeamRunManifest, taskId: string, event: unknown): void {
 	fs.mkdirSync(agentStateDir(manifest, taskId), { recursive: true });
-	fs.appendFileSync(agentEventsPath(manifest, taskId), `${JSON.stringify({ time: new Date().toISOString(), event })}\n`, "utf-8");
+	const filePath = agentEventsPath(manifest, taskId);
+	fs.appendFileSync(filePath, `${JSON.stringify({ seq: nextAgentEventSeq(filePath), time: new Date().toISOString(), event })}\n`, "utf-8");
+}
+
+export interface CrewAgentEventCursorOptions {
+	sinceSeq?: number;
+	limit?: number;
 }
 
 export function readCrewAgentEvents(manifest: TeamRunManifest, taskId: string): unknown[] {
+	return readCrewAgentEventsCursor(manifest, taskId).events;
+}
+
+export function readCrewAgentEventsCursor(manifest: TeamRunManifest, taskId: string, options: CrewAgentEventCursorOptions = {}): { path: string; events: unknown[]; nextSeq: number; total: number } {
 	const filePath = agentEventsPath(manifest, taskId);
-	if (!fs.existsSync(filePath)) return [];
-	return fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).map((line) => {
-		try { return JSON.parse(line) as unknown; } catch { return { raw: line }; }
+	if (!fs.existsSync(filePath)) return { path: filePath, events: [], nextSeq: options.sinceSeq ?? 0, total: 0 };
+	const sinceSeq = typeof options.sinceSeq === "number" && Number.isInteger(options.sinceSeq) && options.sinceSeq >= 0 ? options.sinceSeq : 0;
+	const limit = typeof options.limit === "number" && Number.isInteger(options.limit) && options.limit >= 0 ? options.limit : undefined;
+	const parsed = fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean).map((line, index) => {
+		try {
+			const event = JSON.parse(line) as Record<string, unknown>;
+			if (typeof event.seq !== "number") event.seq = index + 1;
+			return event;
+		} catch {
+			return { seq: index + 1, raw: line };
+		}
 	});
+	const filtered = parsed.filter((event) => typeof event.seq === "number" && event.seq > sinceSeq);
+	const events = limit !== undefined ? filtered.slice(0, limit) : filtered;
+	const returnedMaxSeq = events.reduce((max, event) => typeof event.seq === "number" ? Math.max(max, event.seq) : max, sinceSeq);
+	return { path: filePath, events, nextSeq: returnedMaxSeq, total: filtered.length };
 }
 
 export function appendCrewAgentOutput(manifest: TeamRunManifest, taskId: string, text: string): void {

package/src/runtime/crew-agent-runtime.ts

@@ -21,6 +21,7 @@ export interface CrewAgentProgress {
 	durationMs?: number;
 	lastActivityAt?: string;
 	activityState?: "active" | "needs_attention" | "stale";
+	failedTool?: string;
 }
 
 export interface CrewAgentRecord {

package/src/runtime/foreground-control.ts

@@ -0,0 +1,82 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { appendEvent } from "../state/event-log.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { checkProcessLiveness, isActiveRunStatus } from "./process-status.ts";
+import { readCrewAgents } from "./crew-agent-records.ts";
+
+export type ForegroundControlRequestType = "interrupt" | "status";
+
+export interface ForegroundControlStatus {
+	runId: string;
+	status: TeamRunManifest["status"];
+	active: boolean;
+	asyncPid?: number;
+	asyncAlive?: boolean;
+	runningTasks: string[];
+	runningAgents: string[];
+	controlPath: string;
+	lastRequest?: ForegroundControlRequest;
+}
+
+export interface ForegroundControlRequest {
+	id: string;
+	type: ForegroundControlRequestType;
+	createdAt: string;
+	reason: string;
+	acknowledged: boolean;
+}
+
+export function foregroundControlPath(manifest: TeamRunManifest): string {
+	return path.join(manifest.stateRoot, "foreground-control.json");
+}
+
+function readLastRequest(controlPath: string): ForegroundControlRequest | undefined {
+	if (!fs.existsSync(controlPath)) return undefined;
+	try {
+		const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
+		return parsed.requests?.at(-1);
+	} catch {
+		return undefined;
+	}
+}
+
+export function readForegroundControlStatus(manifest: TeamRunManifest, tasks: TeamTaskState[]): ForegroundControlStatus {
+	const controlPath = foregroundControlPath(manifest);
+	const asyncAlive = manifest.async?.pid !== undefined ? checkProcessLiveness(manifest.async.pid).alive : undefined;
+	return {
+		runId: manifest.runId,
+		status: manifest.status,
+		active: isActiveRunStatus(manifest.status),
+		asyncPid: manifest.async?.pid,
+		asyncAlive,
+		runningTasks: tasks.filter((task) => task.status === "running").map((task) => task.id),
+		runningAgents: readCrewAgents(manifest).filter((agent) => agent.status === "running").map((agent) => agent.id),
+		controlPath,
+		lastRequest: readLastRequest(controlPath),
+	};
+}
+
+export function writeForegroundInterruptRequest(manifest: TeamRunManifest, reason = "User requested foreground interrupt."): ForegroundControlRequest {
+	const controlPath = foregroundControlPath(manifest);
+	let requests: ForegroundControlRequest[] = [];
+	if (fs.existsSync(controlPath)) {
+		try {
+			const parsed = JSON.parse(fs.readFileSync(controlPath, "utf-8")) as { requests?: ForegroundControlRequest[] };
+			requests = Array.isArray(parsed.requests) ? parsed.requests : [];
+		} catch {
+			requests = [];
+		}
+	}
+	const request: ForegroundControlRequest = {
+		id: `fg_${Date.now().toString(36)}_${Math.random().toString(16).slice(2, 10)}`,
+		type: "interrupt",
+		createdAt: new Date().toISOString(),
+		reason,
+		acknowledged: false,
+	};
+	fs.mkdirSync(path.dirname(controlPath), { recursive: true });
+	fs.writeFileSync(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}\n`, "utf-8");
+	appendEvent(manifest.eventsPath, { type: "foreground.interrupt_requested", runId: manifest.runId, message: reason, data: { requestId: request.id, controlPath } });
+	return request;
+}

package/src/runtime/pi-args.ts

@@ -7,12 +7,14 @@ import type { AgentConfig } from "../agents/agent-config.ts";
 const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const PROMPT_RUNTIME_EXTENSION_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "prompt", "prompt-runtime.ts");
 const TASK_ARG_LIMIT = 8000;
+const DEFAULT_MAX_CREW_DEPTH = 2;
 
 export interface BuildPiWorkerArgsInput {
 	task: string;
 	agent: AgentConfig;
 	model?: string;
 	sessionEnabled?: boolean;
+	maxDepth?: number;
 }
 
 export interface BuildPiWorkerArgsResult {
@@ -28,6 +30,25 @@ export function applyThinkingSuffix(model: string | undefined, thinking: string
 	return `${model}:${thinking}`;
 }
 
+export function currentCrewDepth(env: NodeJS.ProcessEnv = process.env): number {
+	const raw = env.PI_CREW_DEPTH ?? env.PI_TEAMS_DEPTH ?? "0";
+	const parsed = Number(raw);
+	return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+export function resolveCrewMaxDepth(inputMaxDepth?: number, env: NodeJS.ProcessEnv = process.env): number {
+	const raw = env.PI_CREW_MAX_DEPTH ?? env.PI_TEAMS_MAX_DEPTH;
+	const envDepth = raw !== undefined ? Number(raw) : NaN;
+	if (Number.isInteger(envDepth) && envDepth >= 0) return envDepth;
+	return Number.isInteger(inputMaxDepth) && inputMaxDepth !== undefined && inputMaxDepth >= 0 ? inputMaxDepth : DEFAULT_MAX_CREW_DEPTH;
+}
+
+export function checkCrewDepth(inputMaxDepth?: number, env: NodeJS.ProcessEnv = process.env): { blocked: boolean; depth: number; maxDepth: number } {
+	const depth = currentCrewDepth(env);
+	const maxDepth = resolveCrewMaxDepth(inputMaxDepth, env);
+	return { depth, maxDepth, blocked: depth >= maxDepth };
+}
+
 export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerArgsResult {
 	const args = ["--mode", "json", "-p"];
 	if (input.sessionEnabled === false) args.push("--no-session");
@@ -61,11 +82,19 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		args.push(`Task: ${input.task}`);
 	}
 
+	const parentDepth = currentCrewDepth();
+	const maxDepth = resolveCrewMaxDepth(input.maxDepth);
 	return {
 		args,
 		env: {
+			PI_CREW_INHERIT_PROJECT_CONTEXT: input.agent.inheritProjectContext ? "1" : "0",
+			PI_CREW_INHERIT_SKILLS: input.agent.inheritSkills ? "1" : "0",
+			PI_CREW_DEPTH: String(parentDepth + 1),
+			PI_CREW_MAX_DEPTH: String(maxDepth),
 			PI_TEAMS_INHERIT_PROJECT_CONTEXT: input.agent.inheritProjectContext ? "1" : "0",
 			PI_TEAMS_INHERIT_SKILLS: input.agent.inheritSkills ? "1" : "0",
+			PI_TEAMS_DEPTH: String(parentDepth + 1),
+			PI_TEAMS_MAX_DEPTH: String(maxDepth),
 		},
 		tempDir,
 	};

package/src/runtime/task-runner.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agent-config.ts";
+import type { CrewLimitsConfig } from "../config/config.ts";
 import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
@@ -28,6 +29,7 @@ export interface TaskRunnerInput {
 	agent: AgentConfig;
 	signal?: AbortSignal;
 	executeWorkers: boolean;
+	limits?: CrewLimitsConfig;
 	dependencyContextText?: string;
 }
 
@@ -190,6 +192,9 @@ function applyAgentProgressEvent(progress: CrewAgentProgress, event: unknown, st
 		next.currentToolArgs = undefined;
 		next.currentToolStartedAt = undefined;
 	}
+	if ((obj?.type === "tool_execution_error" || obj?.type === "tool_execution_failed") && next.currentTool) {
+		next.failedTool = next.currentTool;
+	}
 	const usage = eventUsage(event);
 	if (usage) {
 		next.tokens = (usage.input ?? 0) + (usage.output ?? 0);
@@ -269,6 +274,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				model,
 				signal: input.signal,
 				transcriptPath,
+				maxDepth: input.limits?.maxTaskDepth,
 				onStdoutLine: (line) => appendCrewAgentOutput(manifest, task.id, line),
 				onJsonEvent: (event) => {
 					appendCrewAgentEvent(manifest, task.id, event);
@@ -349,7 +355,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		modelAttempts,
 		usage: parsedOutput?.usage,
 		jsonEvents: parsedOutput?.jsonEvents,
-		agentProgress: task.agentProgress,
+		agentProgress: error && task.agentProgress?.currentTool ? { ...task.agentProgress, failedTool: task.agentProgress.currentTool } : task.agentProgress,
 		error,
 		verification: createVerificationEvidence(taskPacket.verification, !error, error ? `Task failed: ${error}` : input.executeWorkers ? "Worker finished without reporting a verification failure." : "Safe scaffold mode; verification commands were not executed."),
 		promptArtifact,

package/src/runtime/team-runner.ts

@@ -174,7 +174,7 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		const results = await Promise.all(readyBatch.map((task) => {
 			const step = findStep(input.workflow, task);
 			const agent = findAgent(input.agents, task);
-			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers });
+			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, limits: input.limits });
 		}));
 		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
 		tasks = mergeTaskUpdates(tasks, results);

package/src/state/event-log.ts

@@ -94,6 +94,25 @@ export function readEvents(eventsPath: string): TeamEvent[] {
 		.map((line) => JSON.parse(line) as TeamEvent);
 }
 
+export interface EventCursorOptions {
+	sinceSeq?: number;
+	limit?: number;
+}
+
+function positiveInteger(value: number | undefined): number | undefined {
+	return value !== undefined && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+
+export function readEventsCursor(eventsPath: string, options: EventCursorOptions = {}): { events: TeamEvent[]; nextSeq: number; total: number } {
+	const sinceSeq = positiveInteger(options.sinceSeq) ?? 0;
+	const limit = positiveInteger(options.limit);
+	const all = readEvents(eventsPath);
+	const filtered = all.filter((event) => (event.metadata?.seq ?? 0) > sinceSeq);
+	const events = limit !== undefined ? filtered.slice(0, limit) : filtered;
+	const returnedMaxSeq = events.reduce((max, event) => Math.max(max, event.metadata?.seq ?? 0), sinceSeq);
+	return { events, nextSeq: returnedMaxSeq, total: filtered.length };
+}
+
 export function dedupeTerminalEvents(events: TeamEvent[]): TeamEvent[] {
 	const seen = new Set<string>();
 	const output: TeamEvent[] = [];

package/src/ui/run-dashboard.ts

@@ -1,5 +1,7 @@
 import * as fs from "node:fs";
 import type { TeamRunManifest } from "../state/types.ts";
+import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 
 interface DashboardComponent {
 	invalidate(): void;
@@ -7,17 +9,43 @@ interface DashboardComponent {
 	handleInput(data: string): void;
 }
 
-export type RunDashboardAction = "status" | "summary" | "artifacts" | "api" | "reload";
+export type RunDashboardAction = "status" | "summary" | "artifacts" | "api" | "events" | "agents" | "agent-events" | "agent-output" | "agent-transcript" | "reload";
 export interface RunDashboardSelection {
 	runId: string;
 	action: RunDashboardAction;
 }
 
+const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+
+function visibleLength(value: string): number {
+	return value.replace(ANSI_PATTERN, "").length;
+}
+
 function truncate(value: string, width: number): string {
 	if (width <= 0) return "";
-	if (value.length <= width) return value;
+	if (visibleLength(value) <= width) return value;
 	if (width <= 1) return "…";
-	return `${value.slice(0, width - 1)}…`;
+	let output = "";
+	let visible = 0;
+	for (let index = 0; index < value.length;) {
+		const slice = value.slice(index);
+		const ansi = slice.match(/^\u001b\[[0-?]*[ -/]*[@-~]/);
+		if (ansi?.[0]) {
+			output += ansi[0];
+			index += ansi[0].length;
+			continue;
+		}
+		const char = value[index]!;
+		if (visible >= width - 1) break;
+		output += char;
+		visible += 1;
+		index += char.length;
+	}
+	return `${output}\u001b[0m…`;
+}
+
+function padVisible(value: string, width: number): string {
+	return `${value}${" ".repeat(Math.max(0, width - visibleLength(value)))}`;
 }
 
 function statusIcon(status: string): string {
@@ -40,6 +68,30 @@ function readProgressPreview(run: TeamRunManifest, maxLines = 5): string[] {
 	}
 }
 
+function agentPreviewLine(agent: CrewAgentRecord): string {
+	const stats = [
+		agent.progress?.activityState,
+		agent.progress?.currentTool ? `tool=${agent.progress.currentTool}` : undefined,
+		agent.toolUses !== undefined ? `${agent.toolUses} tools` : undefined,
+		agent.progress?.tokens !== undefined ? `${agent.progress.tokens} tok` : undefined,
+		agent.progress?.turns !== undefined ? `${agent.progress.turns} turns` : undefined,
+		agent.progress?.failedTool ? `failedTool=${agent.progress.failedTool}` : undefined,
+	].filter((part): part is string => Boolean(part));
+	const recent = agent.progress?.recentOutput?.at(-1);
+	return `Agent: ${statusIcon(agent.status)} ${agent.taskId} ${agent.role}->${agent.agent}${stats.length ? ` · ${stats.join(" · ")}` : ""}${recent ? ` ⎿ ${recent}` : ""}`;
+}
+
+function readAgentPreview(run: TeamRunManifest, maxLines = 5): string[] {
+	try {
+		const agents = readCrewAgents(run);
+		if (!agents.length) return ["Agents: (none)"];
+		return ["Agents:", ...agents.slice(0, maxLines).map(agentPreviewLine), ...(agents.length > maxLines ? [`Agents: +${agents.length - maxLines} more`] : [])];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return [`Agents: failed to read (${message})`];
+	}
+}
+
 function countByStatus(runs: TeamRunManifest[]): string {
 	const counts = new Map<string, number>();
 	for (const run of runs) counts.set(run.status, (counts.get(run.status) ?? 0) + 1);
@@ -64,19 +116,19 @@ export class RunDashboard implements DashboardComponent {
 		const borderWidth = Math.min(innerWidth, Math.max(0, width - 2));
 		const lines = [
 			`╭${"─".repeat(borderWidth)}╮`,
-			`│ ${truncate("pi-crew dashboard", innerWidth - 1).padEnd(innerWidth - 1)}│`,
-			`│ ${truncate("↑/↓/j/k select • r reload • p progress • s/u/a/i actions • q close", innerWidth - 1).padEnd(innerWidth - 1)}│`,
-			`│ ${truncate(`Runs: ${this.runs.length} • ${countByStatus(this.runs)}`, innerWidth - 1).padEnd(innerWidth - 1)}│`,
+			`│ ${padVisible(truncate("pi-crew dashboard", innerWidth - 1), innerWidth - 1)}│`,
+			`│ ${padVisible(truncate("↑/↓/j/k select • r reload • p progress • s/u/a/i actions • d agents • e/v/o viewers • q close", innerWidth - 1), innerWidth - 1)}│`,
+			`│ ${padVisible(truncate(`Runs: ${this.runs.length} • ${countByStatus(this.runs)}`, innerWidth - 1), innerWidth - 1)}│`,
 			`├${"─".repeat(borderWidth)}┤`,
 		];
 		if (this.runs.length === 0) {
-			lines.push(`│ ${truncate("No runs found.", innerWidth - 1).padEnd(innerWidth - 1)}│`);
+			lines.push(`│ ${padVisible(truncate("No runs found.", innerWidth - 1), innerWidth - 1)}│`);
 		} else {
 			for (let i = 0; i < Math.min(this.runs.length, 10); i++) {
 				const run = this.runs[i]!;
 				const marker = i === this.selected ? "›" : " ";
 				const text = `${marker} ${statusIcon(run.status)} ${run.runId} ${run.status} ${run.team}/${run.workflow ?? "none"} ${run.goal}`;
-				lines.push(`│ ${truncate(text, innerWidth - 1).padEnd(innerWidth - 1)}│`);
+				lines.push(`│ ${padVisible(truncate(text, innerWidth - 1), innerWidth - 1)}│`);
 			}
 			const selectedRun = this.runs[this.selected];
 			if (selectedRun) {
@@ -90,8 +142,8 @@ export class RunDashboard implements DashboardComponent {
 					selectedRun.async ? `Async: pid=${selectedRun.async.pid ?? "unknown"} log=${selectedRun.async.logPath}` : "Async: no",
 					`Goal: ${selectedRun.goal}`,
 				];
-				for (const detail of [...details, ...readProgressPreview(selectedRun, this.showFullProgress ? 20 : 5)]) {
-					lines.push(`│ ${truncate(detail, innerWidth - 1).padEnd(innerWidth - 1)}│`);
+				for (const detail of [...details, ...readAgentPreview(selectedRun), ...readProgressPreview(selectedRun, this.showFullProgress ? 20 : 5)]) {
+					lines.push(`│ ${padVisible(truncate(detail, innerWidth - 1), innerWidth - 1)}│`);
 				}
 			}
 		}
@@ -124,6 +176,26 @@ export class RunDashboard implements DashboardComponent {
 			this.done(runId ? { runId, action: "api" } : undefined);
 			return;
 		}
+		if (data === "d") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "agents" } : undefined);
+			return;
+		}
+		if (data === "e") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "agent-events" } : undefined);
+			return;
+		}
+		if (data === "o") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "agent-output" } : undefined);
+			return;
+		}
+		if (data === "v") {
+			const runId = this.runs[this.selected]?.runId;
+			this.done(runId ? { runId, action: "agent-transcript" } : undefined);
+			return;
+		}
 		if (data === "r") {
 			this.done({ runId: this.runs[this.selected]?.runId ?? "", action: "reload" });
 			return;