pi-crew 0.1.7 → 0.1.9

package/src/runtime/sidechain-output.ts

@@ -0,0 +1,28 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface SidechainEntry {
+	isSidechain: true;
+	agentId: string;
+	type: string;
+	message: unknown;
+	timestamp: string;
+	cwd: string;
+}
+
+export function writeSidechainEntry(filePath: string, entry: Omit<SidechainEntry, "isSidechain" | "timestamp">): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.appendFileSync(filePath, `${JSON.stringify({ isSidechain: true, timestamp: new Date().toISOString(), ...entry })}\n`, "utf-8");
+}
+
+export function sidechainOutputPath(stateRoot: string, taskId: string): string {
+	return path.join(stateRoot, "agents", taskId, "sidechain.output.jsonl");
+}
+
+export function eventToSidechainType(event: unknown): string | undefined {
+	if (!event || typeof event !== "object" || Array.isArray(event)) return undefined;
+	const type = (event as { type?: unknown }).type;
+	if (type === "message_start" || type === "message_update" || type === "message_end") return "message";
+	if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") return "tool";
+	return typeof type === "string" ? type : undefined;
+}

package/src/runtime/task-runner.ts

@@ -1,6 +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 { CrewLimitsConfig, CrewRuntimeConfig } 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";
@@ -8,7 +8,7 @@ import { saveRunManifest, saveRunTasks } from "../state/state-store.ts";
 import { createTaskClaim } from "../state/task-claims.ts";
 import { createWorkerHeartbeat, touchWorkerHeartbeat } from "./worker-heartbeat.ts";
 import type { WorkflowStep } from "../workflows/workflow-config.ts";
-import { captureWorktreeDiff, prepareTaskWorkspace } from "../worktree/worktree-manager.ts";
+import { captureWorktreeDiff, captureWorktreeDiffStat, prepareTaskWorkspace } from "../worktree/worktree-manager.ts";
 import { buildModelCandidates, formatModelAttemptNote, isRetryableModelFailure, type ModelAttemptSummary } from "./model-fallback.ts";
 import { parsePiJsonOutput, type ParsedPiJsonOutput } from "./pi-json-output.ts";
 import { runChildPi } from "./child-pi.ts";
@@ -19,7 +19,9 @@ import { permissionForRole } from "./role-permission.ts";
 import { collectDependencyOutputContext, renderDependencyOutputContext, writeTaskInputsArtifact, writeTaskSharedOutput } from "./task-output-context.ts";
 import { appendCrewAgentEvent, appendCrewAgentOutput, emptyCrewAgentProgress, recordFromTask, upsertCrewAgent } from "./crew-agent-records.ts";
 import { parseSessionUsage } from "./session-usage.ts";
-import type { CrewAgentProgress } from "./crew-agent-runtime.ts";
+import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { buildMemoryBlock } from "./agent-memory.ts";
+import { runLiveSessionTask } from "./live-session-runtime.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -29,6 +31,11 @@ export interface TaskRunnerInput {
 	agent: AgentConfig;
 	signal?: AbortSignal;
 	executeWorkers: boolean;
+	runtimeKind?: CrewRuntimeKind;
+	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
 	limits?: CrewLimitsConfig;
 	dependencyContextText?: string;
 }
@@ -57,7 +64,8 @@ function coordinationBridgeInstructions(task: TeamTaskState): string {
 	].join("\n");
 }
 
-function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState): string {
+function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: TeamTaskState, agent?: AgentConfig): string {
+	const memoryBlock = agent?.memory ? buildMemoryBlock(agent.name, agent.memory, task.cwd, Boolean(agent.tools?.some((tool) => tool === "write" || tool === "edit"))) : "";
 	return [
 		"# pi-crew Worker Runtime Context",
 		`Run ID: ${manifest.runId}`,
@@ -88,6 +96,7 @@ function renderTaskPrompt(manifest: TeamRunManifest, step: WorkflowStep, task: T
 		task.taskPacket ? renderTaskPacket(task.taskPacket) : "",
 		"",
 		(inputDependencyContext(task) || ""),
+		memoryBlock,
 		"Task:",
 		step.task.replaceAll("{goal}", manifest.goal),
 	].join("\n");
@@ -227,12 +236,13 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		...(dependencyContextText ? { dependencyContextText } : {}),
 	} as TeamTaskState;
 	let tasks = updateTask(input.tasks, task);
+	const runtimeKind = input.runtimeKind ?? (input.executeWorkers ? "child-process" : "scaffold");
 	saveRunTasks(manifest, tasks);
-	upsertCrewAgent(manifest, recordFromTask(manifest, task, input.executeWorkers ? "child-process" : "scaffold"));
-	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
+	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
+	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, runtime: runtimeKind, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
 	const permissionMode = permissionForRole(task.role);
 
-	const prompt = renderTaskPrompt(manifest, input.step, task);
+	const prompt = renderTaskPrompt(manifest, input.step, task, input.agent);
 	const promptArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "prompt",
 		relativePath: `prompts/${task.id}.md`,
@@ -248,7 +258,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	let modelAttempts: ModelAttemptSummary[] | undefined;
 	let parsedOutput: ParsedPiJsonOutput | undefined;
 
-	let startupEvidence = createStartupEvidence({ command: input.executeWorkers ? "pi" : "safe-scaffold", startedAt: new Date(task.startedAt ?? new Date().toISOString()), finishedAt: new Date(), promptSentAt: new Date(task.startedAt ?? new Date().toISOString()), promptAccepted: true, exitCode: 0 });
+	let startupEvidence = createStartupEvidence({ command: runtimeKind === "child-process" ? "pi" : runtimeKind === "live-session" ? "live-session" : "safe-scaffold", startedAt: new Date(task.startedAt ?? new Date().toISOString()), finishedAt: new Date(), promptSentAt: new Date(task.startedAt ?? new Date().toISOString()), promptAccepted: true, exitCode: 0 });
 	const inputsArtifact = writeTaskInputsArtifact(manifest, task, dependencyContext);
 	const coordinationArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
@@ -256,7 +266,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${coordinationBridgeInstructions(task)}\n`,
 		producer: task.id,
 	});
-	if (input.executeWorkers) {
+	if (runtimeKind === "child-process") {
 		const candidates = buildModelCandidates(input.step.model ?? input.agent.model, input.agent.fallbackModels, undefined);
 		const attemptModels = candidates.length > 0 ? candidates : [input.step.model ?? input.agent.model];
 		const logs: string[] = [];
@@ -326,6 +336,55 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				producer: task.id,
 			});
 		}
+	} else if (runtimeKind === "live-session") {
+		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
+		const attemptStartedAt = new Date();
+		const liveResult = await runLiveSessionTask({
+			manifest,
+			task,
+			step: input.step,
+			agent: input.agent,
+			prompt,
+			signal: input.signal,
+			transcriptPath,
+			runtimeConfig: input.runtimeConfig,
+			parentContext: input.parentContext,
+			parentModel: input.parentModel,
+			modelRegistry: input.modelRegistry,
+			onOutput: (text) => appendCrewAgentOutput(manifest, task.id, text),
+			onEvent: (event) => {
+				appendCrewAgentEvent(manifest, task.id, event);
+				task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
+				tasks = updateTask(tasks, task);
+				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { event } });
+			},
+		});
+		startupEvidence = createStartupEvidence({ command: "live-session", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: liveResult.exitCode === 0 && !liveResult.error, stderr: liveResult.stderr, error: liveResult.error, exitCode: liveResult.exitCode });
+		exitCode = liveResult.exitCode;
+		error = liveResult.error || (liveResult.exitCode && liveResult.exitCode !== 0 ? liveResult.stderr || `Live session exited with ${liveResult.exitCode}` : undefined);
+		parsedOutput = { finalText: liveResult.stdout, textEvents: liveResult.stdout ? [liveResult.stdout] : [], jsonEvents: liveResult.jsonEvents, usage: liveResult.usage };
+		if (liveResult.usage) task = { ...task, usage: liveResult.usage, agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage) };
+		resultArtifact = writeArtifact(manifest.artifactsRoot, {
+			kind: "result",
+			relativePath: `results/${task.id}.txt`,
+			content: liveResult.stdout || liveResult.stderr || "(no output)",
+			producer: task.id,
+		});
+		logArtifact = writeArtifact(manifest.artifactsRoot, {
+			kind: "log",
+			relativePath: `logs/${task.id}.log`,
+			content: [`runtime=live-session`, `finalExitCode=${exitCode ?? "null"}`, `jsonEvents=${liveResult.jsonEvents}`, liveResult.usage ? `usage=${JSON.stringify(liveResult.usage)}` : "", "", "STDOUT:", liveResult.stdout, "", "STDERR:", liveResult.stderr].join("\n"),
+			producer: task.id,
+		});
+		if (fs.existsSync(transcriptPath)) {
+			transcriptArtifact = writeArtifact(manifest.artifactsRoot, {
+				kind: "log",
+				relativePath: `transcripts/${task.id}.jsonl`,
+				content: fs.readFileSync(transcriptPath, "utf-8"),
+				producer: task.id,
+			});
+		}
 	} else {
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",
@@ -346,6 +405,12 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: captureWorktreeDiff(workspace.worktreePath),
 		producer: task.id,
 	}) : undefined;
+	const diffStatArtifact = workspace.worktreePath ? writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.diff-stat.json`,
+		content: `${JSON.stringify({ ...captureWorktreeDiffStat(workspace.worktreePath), syntheticPaths: workspace.syntheticPaths ?? [], nodeModulesLinked: workspace.nodeModulesLinked ?? false }, null, 2)}\n`,
+		producer: task.id,
+	}) : undefined;
 
 	task = {
 		...task,
@@ -357,7 +422,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		jsonEvents: parsedOutput?.jsonEvents,
 		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."),
+		verification: createVerificationEvidence(taskPacket.verification, !error, error ? `Task failed: ${error}` : runtimeKind === "scaffold" ? "Safe scaffold mode; verification commands were not executed." : `${runtimeKind} worker finished without reporting a verification failure.`),
 		promptArtifact,
 		resultArtifact,
 		claim: undefined,
@@ -391,10 +456,10 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${JSON.stringify({ role: task.role, permissionMode }, null, 2)}\n`,
 		producer: task.id,
 	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : [])] };
+	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
 	saveRunManifest(manifest);
 	saveRunTasks(manifest, tasks);
-	upsertCrewAgent(manifest, recordFromTask(manifest, task, input.executeWorkers ? "child-process" : "scaffold"));
+	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
 	appendEvent(manifest.eventsPath, { type: error ? "task.failed" : "task.completed", runId: manifest.runId, taskId: task.id, message: error });
 	return { manifest, tasks };
 }

package/src/runtime/team-runner.ts

@@ -27,6 +27,9 @@ export interface ExecuteTeamRunInput {
 	limits?: CrewLimitsConfig;
 	runtime?: CrewRuntimeCapabilities;
 	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
 	signal?: AbortSignal;
 }
 
@@ -174,7 +177,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, limits: input.limits });
+			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, 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/ui/crew-widget.ts

@@ -0,0 +1,113 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { listRuns } from "../extension/run-index.ts";
+import { isActiveRunStatus } from "../runtime/process-status.ts";
+import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const TOOL_LABELS: Record<string, string> = {
+	read: "reading",
+	bash: "running command",
+	edit: "editing",
+	write: "writing",
+	grep: "searching",
+	find: "finding files",
+	ls: "listing",
+};
+
+export interface CrewWidgetState {
+	frame: number;
+	interval?: ReturnType<typeof setInterval>;
+}
+
+function elapsed(iso: string | undefined, now = Date.now()): string | undefined {
+	if (!iso) return undefined;
+	const ms = Math.max(0, now - new Date(iso).getTime());
+	if (!Number.isFinite(ms)) return undefined;
+	if (ms < 1000) return "now";
+	if (ms < 60_000) return `${Math.floor(ms / 1000)}s`;
+	if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m`;
+	return `${Math.floor(ms / 3_600_000)}h`;
+}
+
+function glyph(status: string, runningGlyph: string): string {
+	if (status === "running") return runningGlyph;
+	if (status === "queued") return "◦";
+	if (status === "completed") return "✓";
+	if (status === "failed") return "✗";
+	if (status === "cancelled" || status === "stopped") return "■";
+	return "·";
+}
+
+function agentActivity(agent: CrewAgentRecord): string {
+	if (agent.progress?.currentTool) return `${TOOL_LABELS[agent.progress.currentTool] ?? agent.progress.currentTool}…`;
+	const recent = agent.progress?.recentOutput?.at(-1);
+	if (recent) return recent.replace(/\s+/g, " ").trim();
+	if (agent.progress?.activityState === "needs_attention") return "needs attention";
+	if (agent.status === "queued") return "queued…";
+	if (agent.status === "running") return "thinking…";
+	if (agent.status === "failed") return agent.error ?? "failed";
+	return "done";
+}
+
+function agentStats(agent: CrewAgentRecord): string {
+	const parts: string[] = [];
+	if (agent.toolUses) parts.push(`${agent.toolUses} tools`);
+	if (agent.progress?.tokens) parts.push(`${agent.progress.tokens} tok`);
+	if (agent.progress?.turns) parts.push(`⟳${agent.progress.turns}`);
+	const age = elapsed(agent.completedAt ?? agent.startedAt);
+	if (age) parts.push(agent.completedAt ? age : `${age} ago`);
+	return parts.join(" · ");
+}
+
+function runStep(run: TeamRunManifest, agents: CrewAgentRecord[]): string {
+	const running = agents.find((agent) => agent.status === "running");
+	if (running) return running.taskId;
+	const queued = agents.find((agent) => agent.status === "queued");
+	if (queued) return queued.taskId;
+	return run.status;
+}
+
+export function buildCrewWidgetLines(cwd: string, frame = 0, maxLines = 8): string[] {
+	const runs = listRuns(cwd).slice(0, 20);
+	const activeRuns = runs.filter((run) => isActiveRunStatus(run.status));
+	const recentRuns = runs.filter((run) => !isActiveRunStatus(run.status)).slice(0, 3);
+	const shownRuns = [...activeRuns, ...recentRuns];
+	if (!shownRuns.length) return [];
+	const runningGlyph = SPINNER[frame % SPINNER.length] ?? "⠋";
+	const lines: string[] = [];
+	const activeCount = activeRuns.length;
+	lines.push(`${activeCount ? "●" : "○"} pi-crew · active=${activeCount} recent=${recentRuns.length} · /team-dashboard`);
+	for (const run of shownRuns) {
+		let agents: CrewAgentRecord[] = [];
+		try { agents = readCrewAgents(run); } catch { agents = []; }
+		const counts = new Map<string, number>();
+		for (const agent of agents) counts.set(agent.status, (counts.get(agent.status) ?? 0) + 1);
+		const countText = [...counts.entries()].map(([status, count]) => `${status}:${count}`).join(" ") || run.status;
+		lines.push(`${glyph(run.status, runningGlyph)} ${run.runId.slice(-8)} ${run.team}/${run.workflow ?? "none"} · ${runStep(run, agents)} · ${countText}`);
+		for (const agent of agents.filter((item) => item.status === "running" || item.status === "queued").slice(0, 2)) {
+			const stats = agentStats(agent);
+			lines.push(`  ${glyph(agent.status, runningGlyph)} ${agent.taskId} ${agent.role}→${agent.agent} · ${agentActivity(agent)}${stats ? ` · ${stats}` : ""}`);
+		}
+		if (lines.length >= maxLines) break;
+	}
+	return lines.slice(0, maxLines);
+}
+
+export function updateCrewWidget(ctx: Pick<ExtensionContext, "cwd" | "hasUI" | "ui">, state: CrewWidgetState): void {
+	if (!ctx.hasUI) return;
+	state.frame += 1;
+	const lines = buildCrewWidgetLines(ctx.cwd, state.frame);
+	ctx.ui.setStatus("pi-crew", lines.length ? lines[0] : undefined);
+	ctx.ui.setWidget("pi-crew", lines.length ? lines : undefined, { placement: "aboveEditor" });
+}
+
+export function stopCrewWidget(ctx: Pick<ExtensionContext, "hasUI" | "ui"> | undefined, state: CrewWidgetState): void {
+	if (state.interval) clearInterval(state.interval);
+	state.interval = undefined;
+	if (ctx?.hasUI) {
+		ctx.ui.setStatus("pi-crew", undefined);
+		ctx.ui.setWidget("pi-crew", undefined, { placement: "aboveEditor" });
+	}
+}

package/src/ui/run-dashboard.ts

@@ -2,6 +2,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";
+import { isActiveRunStatus } from "../runtime/process-status.ts";
 
 interface DashboardComponent {
 	invalidate(): void;
@@ -68,6 +69,16 @@ function readProgressPreview(run: TeamRunManifest, maxLines = 5): string[] {
 	}
 }
 
+function formatAge(iso: string | undefined): string | undefined {
+	if (!iso) return undefined;
+	const ms = Math.max(0, Date.now() - new Date(iso).getTime());
+	if (!Number.isFinite(ms)) return undefined;
+	if (ms < 1000) return "now";
+	if (ms < 60_000) return `${Math.floor(ms / 1000)}s`;
+	if (ms < 3_600_000) return `${Math.floor(ms / 60_000)}m`;
+	return `${Math.floor(ms / 3_600_000)}h`;
+}
+
 function agentPreviewLine(agent: CrewAgentRecord): string {
 	const stats = [
 		agent.progress?.activityState,
@@ -76,6 +87,7 @@ function agentPreviewLine(agent: CrewAgentRecord): string {
 		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,
+		agent.startedAt ? `age=${formatAge(agent.completedAt ?? agent.startedAt)}` : 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}` : ""}`;
@@ -92,6 +104,29 @@ function readAgentPreview(run: TeamRunManifest, maxLines = 5): string[] {
 	}
 }
 
+function runLabel(run: TeamRunManifest, selected: boolean): string {
+	let agents: CrewAgentRecord[] = [];
+	try { agents = readCrewAgents(run); } catch { agents = []; }
+	const running = agents.find((agent) => agent.status === "running");
+	const queued = agents.find((agent) => agent.status === "queued");
+	const step = running ? `step ${running.taskId}` : queued ? `queued ${queued.taskId}` : `agents ${agents.length}`;
+	const marker = selected ? "›" : " ";
+	return `${marker} ${statusIcon(run.status)} ${run.runId.slice(-8)} ${run.status} | ${run.team}/${run.workflow ?? "none"} | ${step} | ${run.goal}`;
+}
+
+function groupedRuns(runs: TeamRunManifest[]): Array<{ label: string; run?: TeamRunManifest }> {
+	const active = runs.filter((run) => isActiveRunStatus(run.status));
+	const recent = runs.filter((run) => !isActiveRunStatus(run.status));
+	const rows: Array<{ label: string; run?: TeamRunManifest }> = [];
+	if (active.length) rows.push({ label: "Active" }, ...active.map((run) => ({ label: run.runId, run })));
+	if (recent.length) rows.push({ label: "Recent" }, ...recent.map((run) => ({ label: run.runId, run })));
+	return rows;
+}
+
+function selectedRunFromGrouped(runs: TeamRunManifest[], selected: number): TeamRunManifest | undefined {
+	return groupedRuns(runs).filter((row) => row.run)[selected]?.run;
+}
+
 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);
@@ -124,13 +159,17 @@ export class RunDashboard implements DashboardComponent {
 		if (this.runs.length === 0) {
 			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(`│ ${padVisible(truncate(text, innerWidth - 1), innerWidth - 1)}│`);
+			const rows = groupedRuns(this.runs).slice(0, 16);
+			const runRows = rows.filter((row) => row.run);
+			for (const row of rows) {
+				if (!row.run) {
+					lines.push(`│ ${padVisible(truncate(row.label, innerWidth - 1), innerWidth - 1)}│`);
+					continue;
+				}
+				const index = runRows.findIndex((candidate) => candidate.run?.runId === row.run?.runId);
+				lines.push(`│ ${padVisible(truncate(runLabel(row.run, index === this.selected), innerWidth - 1), innerWidth - 1)}│`);
 			}
-			const selectedRun = this.runs[this.selected];
+			const selectedRun = selectedRunFromGrouped(this.runs, this.selected);
 			if (selectedRun) {
 				lines.push(`├${"─".repeat(borderWidth)}┤`);
 				const details = [
@@ -157,47 +196,47 @@ export class RunDashboard implements DashboardComponent {
 			return;
 		}
 		if (data === "\r" || data === "\n" || data === "s") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "status" } : undefined);
 			return;
 		}
 		if (data === "u") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "summary" } : undefined);
 			return;
 		}
 		if (data === "a") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "artifacts" } : undefined);
 			return;
 		}
 		if (data === "i") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "api" } : undefined);
 			return;
 		}
 		if (data === "d") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "agents" } : undefined);
 			return;
 		}
 		if (data === "e") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "agent-events" } : undefined);
 			return;
 		}
 		if (data === "o") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(this.runs, this.selected)?.runId;
 			this.done(runId ? { runId, action: "agent-output" } : undefined);
 			return;
 		}
 		if (data === "v") {
-			const runId = this.runs[this.selected]?.runId;
+			const runId = selectedRunFromGrouped(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" });
+			this.done({ runId: selectedRunFromGrouped(this.runs, this.selected)?.runId ?? "", action: "reload" });
 			return;
 		}
 		if (data === "p") {
@@ -209,7 +248,8 @@ export class RunDashboard implements DashboardComponent {
 			return;
 		}
 		if (data === "j" || data === "\u001b[B") {
-			this.selected = Math.min(Math.max(0, this.runs.length - 1), this.selected + 1);
+			const selectableCount = groupedRuns(this.runs).filter((row) => row.run).length;
+			this.selected = Math.min(Math.max(0, selectableCount - 1), this.selected + 1);
 		}
 	}
 }