pi-crew 0.1.17 → 0.1.19

package/src/runtime/child-pi.ts

@@ -9,6 +9,9 @@ const POST_EXIT_STDIO_GUARD_MS = 3000;
 const FINAL_DRAIN_MS = 5000;
 const HARD_KILL_MS = 3000;
 const MAX_CAPTURE_BYTES = 256 * 1024;
+const MAX_ASSISTANT_TEXT_CHARS = 8192;
+const MAX_TOOL_RESULT_CHARS = 1024;
+const MAX_TOOL_INPUT_CHARS = 2048;
 const MAX_COMPACT_CONTENT_CHARS = 4096;
 const activeChildProcesses = new Map<number, ChildProcess>();
 
@@ -87,9 +90,9 @@ function compactValue(value: unknown): unknown {
 function compactContentPart(part: unknown): unknown | undefined {
 	const record = asRecord(part);
 	if (!record) return undefined;
-	if (record.type === "text") return { type: "text", text: typeof record.text === "string" ? compactString(record.text) : "" };
-	if (record.type === "toolCall") return { type: "toolCall", name: record.name, input: compactValue(record.input) };
-	if (record.type === "toolResult") return { type: "toolResult", name: record.name, content: compactValue(record.content) };
+	if (record.type === "text") return { type: "text", text: typeof record.text === "string" ? compactString(record.text, MAX_ASSISTANT_TEXT_CHARS) : "" };
+	if (record.type === "toolCall") return { type: "toolCall", name: record.name, input: compactValue(typeof record.input === "string" ? compactString(record.input, MAX_TOOL_INPUT_CHARS) : record.input) };
+	if (record.type === "toolResult") return { type: "toolResult", name: record.name, content: compactValue(typeof record.content === "string" ? compactString(record.content, MAX_TOOL_RESULT_CHARS) : record.content) };
 	return undefined;
 }
 
@@ -102,6 +105,7 @@ function compactChildPiEvent(event: unknown): unknown | undefined {
 	}
 	if (record.type === "tool_result_end" || record.type === "message_end" || record.type === "message") {
 		const message = asRecord(record.message);
+		if (message?.role === "user" || message?.role === "system") return undefined;
 		const content = Array.isArray(message?.content) ? message.content.map(compactContentPart).filter((part) => part !== undefined) : undefined;
 		return {
 			type: record.type,

package/src/runtime/concurrency.ts

@@ -0,0 +1,42 @@
+export interface ResolveBatchConcurrencyInput {
+	workflowName: string;
+	teamMaxConcurrency?: number;
+	limitMaxConcurrentWorkers?: number;
+	readyCount: number;
+	workspaceMode?: "single" | "worktree";
+	readyRoles?: string[];
+}
+
+export interface BatchConcurrencyDecision {
+	maxConcurrent: number;
+	selectedCount: number;
+	defaultConcurrency: number;
+	reason: string;
+}
+
+export function defaultWorkflowConcurrency(workflowName: string): number {
+	if (workflowName === "parallel-research") return 4;
+	if (workflowName === "research") return 2;
+	if (workflowName === "implementation" || workflowName === "review" || workflowName === "default") return 2;
+	return 1;
+}
+
+function positiveInteger(value: number | undefined): number | undefined {
+	if (value === undefined || !Number.isFinite(value)) return undefined;
+	return Math.max(1, Math.trunc(value));
+}
+
+export function resolveBatchConcurrency(input: ResolveBatchConcurrencyInput): BatchConcurrencyDecision {
+	const defaultConcurrency = defaultWorkflowConcurrency(input.workflowName);
+	const limitMax = positiveInteger(input.limitMaxConcurrentWorkers);
+	const teamMax = positiveInteger(input.teamMaxConcurrency);
+	const requested = limitMax ?? teamMax ?? defaultConcurrency;
+	const source = limitMax !== undefined ? "limit" : teamMax !== undefined ? "team" : "workflow";
+	const readyCount = Math.max(0, Math.trunc(input.readyCount));
+	return {
+		maxConcurrent: requested,
+		selectedCount: readyCount === 0 ? 0 : Math.min(readyCount, requested),
+		defaultConcurrency,
+		reason: `${source}:${requested};ready:${readyCount}`,
+	};
+}

package/src/runtime/progress-event-coalescer.ts

@@ -0,0 +1,43 @@
+export interface ProgressEventSummary {
+	eventType: string;
+	currentTool?: string;
+	toolCount?: number;
+	tokens?: number;
+	turns?: number;
+	activityState?: string;
+	lastActivityAt?: string;
+}
+
+export interface ProgressEventCoalesceDecision {
+	shouldAppend: boolean;
+	reason: string;
+}
+
+export interface ProgressEventCoalesceInput {
+	previous?: ProgressEventSummary;
+	next: ProgressEventSummary;
+	nowMs: number;
+	lastAppendMs?: number;
+	minIntervalMs: number;
+	force?: boolean;
+	tokenThreshold?: number;
+}
+
+const DEFAULT_TOKEN_THRESHOLD = 256;
+
+function numericIncrease(previous: number | undefined, next: number | undefined): number {
+	return next !== undefined && previous !== undefined ? next - previous : next !== undefined ? next : 0;
+}
+
+export function shouldAppendProgressEventUpdate(input: ProgressEventCoalesceInput): ProgressEventCoalesceDecision {
+	if (input.force) return { shouldAppend: true, reason: "force" };
+	if (!input.previous) return { shouldAppend: true, reason: "first" };
+	if (input.previous.activityState !== input.next.activityState) return { shouldAppend: true, reason: "activity_changed" };
+	if (input.previous.currentTool !== input.next.currentTool) return { shouldAppend: true, reason: "tool_changed" };
+	if (numericIncrease(input.previous.toolCount, input.next.toolCount) > 0) return { shouldAppend: true, reason: "tool_count_increased" };
+	if (numericIncrease(input.previous.turns, input.next.turns) > 0) return { shouldAppend: true, reason: "turns_increased" };
+	const tokenIncrease = numericIncrease(input.previous.tokens, input.next.tokens);
+	if (tokenIncrease >= (input.tokenThreshold ?? DEFAULT_TOKEN_THRESHOLD)) return { shouldAppend: true, reason: "tokens_increased" };
+	if (input.lastAppendMs === undefined || input.nowMs - input.lastAppendMs >= input.minIntervalMs) return { shouldAppend: true, reason: "interval" };
+	return { shouldAppend: false, reason: "coalesced" };
+}

package/src/runtime/subagent-manager.ts

@@ -0,0 +1,202 @@
+import { loadRunManifestById } from "../state/state-store.ts";
+import type { PiTeamsToolResult } from "../extension/tool-result.ts";
+
+export type SubagentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "error" | "stopped";
+
+export interface SubagentSpawnOptions {
+	cwd: string;
+	type: string;
+	description: string;
+	prompt: string;
+	background: boolean;
+	model?: string;
+	maxTurns?: number;
+}
+
+export interface SubagentRecord {
+	id: string;
+	runId?: string;
+	type: string;
+	description: string;
+	prompt: string;
+	status: SubagentStatus;
+	startedAt: number;
+	completedAt?: number;
+	result?: string;
+	error?: string;
+	resultConsumed?: boolean;
+	model?: string;
+	background: boolean;
+	promise?: Promise<void>;
+}
+
+type SpawnRunner = (options: SubagentSpawnOptions, signal?: AbortSignal) => Promise<PiTeamsToolResult>;
+type Notify = (record: SubagentRecord) => void;
+
+interface QueuedSpawn {
+	record: SubagentRecord;
+	options: SubagentSpawnOptions;
+	runner: SpawnRunner;
+	signal?: AbortSignal;
+}
+
+const TERMINAL_RUN_STATUS = new Set(["completed", "failed", "cancelled", "blocked"]);
+
+function resultText(result: PiTeamsToolResult): string {
+	return result.content?.map((item) => item.type === "text" ? item.text : "").filter(Boolean).join("\n") ?? "";
+}
+
+function detailsRunId(result: PiTeamsToolResult): string | undefined {
+	const details = result.details as { runId?: unknown } | undefined;
+	return typeof details?.runId === "string" ? details.runId : undefined;
+}
+
+export class SubagentManager {
+	private readonly records = new Map<string, SubagentRecord>();
+	private queue: QueuedSpawn[] = [];
+	private runningBackground = 0;
+	private counter = 0;
+	private maxConcurrent: number;
+	private readonly onComplete?: Notify;
+	private readonly pollIntervalMs: number;
+
+	constructor(maxConcurrent = 4, onComplete?: Notify, pollIntervalMs = 1000) {
+		this.maxConcurrent = maxConcurrent;
+		this.onComplete = onComplete;
+		this.pollIntervalMs = pollIntervalMs;
+	}
+
+	spawn(options: SubagentSpawnOptions, runner: SpawnRunner, signal?: AbortSignal): SubagentRecord {
+		const record: SubagentRecord = {
+			id: `agent_${Date.now().toString(36)}_${(++this.counter).toString(36)}`,
+			type: options.type,
+			description: options.description,
+			prompt: options.prompt,
+			status: options.background && this.runningBackground >= this.maxConcurrent ? "queued" : "running",
+			startedAt: Date.now(),
+			model: options.model,
+			background: options.background,
+		};
+		this.records.set(record.id, record);
+		if (record.status === "queued") {
+			this.queue.push({ record, options, runner, signal });
+			return record;
+		}
+		this.start(record, options, runner, signal);
+		return record;
+	}
+
+	getRecord(id: string): SubagentRecord | undefined {
+		return this.records.get(id);
+	}
+
+	listAgents(): SubagentRecord[] {
+		return [...this.records.values()].sort((a, b) => b.startedAt - a.startedAt);
+	}
+
+	abort(id: string): boolean {
+		const record = this.records.get(id);
+		if (!record) return false;
+		if (record.status === "queued") {
+			this.queue = this.queue.filter((entry) => entry.record.id !== id);
+			record.status = "stopped";
+			record.completedAt = Date.now();
+			return true;
+		}
+		if (record.status !== "running") return false;
+		record.status = "stopped";
+		record.completedAt = Date.now();
+		return true;
+	}
+
+	abortAll(): number {
+		let count = 0;
+		for (const entry of this.queue) {
+			entry.record.status = "stopped";
+			entry.record.completedAt = Date.now();
+			count++;
+		}
+		this.queue = [];
+		for (const record of this.records.values()) {
+			if (record.status === "running") {
+				record.status = "stopped";
+				record.completedAt = Date.now();
+				count++;
+			}
+		}
+		return count;
+	}
+
+	async waitForAll(): Promise<void> {
+		while (true) {
+			this.drainQueue();
+			const pending = this.listAgents().filter((record) => record.status === "running" || record.status === "queued").map((record) => record.promise).filter((promise): promise is Promise<void> => Boolean(promise));
+			if (!pending.length) break;
+			await Promise.allSettled(pending);
+		}
+	}
+
+	async waitForRecord(id: string): Promise<SubagentRecord | undefined> {
+		while (true) {
+			const record = this.records.get(id);
+			if (!record) return undefined;
+			if (record.status !== "running" && record.status !== "queued") return record;
+			if (record.promise) await record.promise;
+			else await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+	}
+
+	setMaxConcurrent(value: number): void {
+		this.maxConcurrent = Math.max(1, Math.floor(value));
+		this.drainQueue();
+	}
+
+	private start(record: SubagentRecord, options: SubagentSpawnOptions, runner: SpawnRunner, signal?: AbortSignal): void {
+		if (options.background) this.runningBackground++;
+		record.status = "running";
+		record.startedAt = Date.now();
+		record.promise = (async () => {
+			try {
+				const result = await runner(options, signal);
+				record.runId = detailsRunId(result);
+				record.result = resultText(result);
+				if (result.isError) {
+					record.status = "error";
+					record.error = record.result;
+					return;
+				}
+				if (record.runId) await this.pollRunToTerminal(options.cwd, record);
+				else record.status = "completed";
+			} catch (error) {
+				record.status = "error";
+				record.error = error instanceof Error ? error.message : String(error);
+			} finally {
+				if (options.background) this.runningBackground = Math.max(0, this.runningBackground - 1);
+				record.completedAt = record.completedAt ?? Date.now();
+				this.onComplete?.(record);
+				this.drainQueue();
+			}
+		})();
+	}
+
+	private drainQueue(): void {
+		while (this.queue.length > 0 && this.runningBackground < this.maxConcurrent) {
+			const next = this.queue.shift();
+			if (!next || next.record.status !== "queued") continue;
+			this.start(next.record, next.options, next.runner, next.signal);
+		}
+	}
+
+	private async pollRunToTerminal(cwd: string, record: SubagentRecord): Promise<void> {
+		while (record.runId && record.status === "running") {
+			const loaded = loadRunManifestById(cwd, record.runId);
+			if (loaded && TERMINAL_RUN_STATUS.has(loaded.manifest.status)) {
+				record.status = loaded.manifest.status === "completed" ? "completed" : loaded.manifest.status === "cancelled" ? "cancelled" : "failed";
+				record.error = record.status === "completed" ? undefined : loaded.manifest.summary;
+				record.completedAt = Date.now();
+				return;
+			}
+			await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+		}
+	}
+}

package/src/runtime/task-display.ts

@@ -0,0 +1,38 @@
+import type { TeamTaskState } from "../state/types.ts";
+import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { recordFromTask } from "./crew-agent-records.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+
+export function shouldMaterializeAgent(task: TeamTaskState): boolean {
+	return task.status !== "queued" && task.status !== "skipped";
+}
+
+export function recordsForMaterializedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[], runtime: CrewRuntimeKind): CrewAgentRecord[] {
+	return tasks.filter(shouldMaterializeAgent).map((task) => recordFromTask(manifest, task, runtime));
+}
+
+export function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
+	const map = new Map<string, TeamTaskState>();
+	for (const task of tasks) {
+		map.set(task.id, task);
+		if (task.stepId) map.set(task.stepId, task);
+	}
+	return map;
+}
+
+export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): string | undefined {
+	if (task.status !== "queued") return undefined;
+	const byId = taskById(tasks);
+	const waiting = task.dependsOn.map((id) => byId.get(id)?.id ?? id).filter((id) => byId.get(id)?.status !== "completed");
+	if (waiting.length === 0) return "ready";
+	return `waiting for ${waiting.join(", ")}`;
+}
+
+export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
+	if (tasks.length === 0) return ["- (none)"];
+	return tasks.map((task) => {
+		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
+		const wait = waitingReason(task, tasks);
+		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
+	});
+}

package/src/runtime/task-runner.ts

@@ -22,6 +22,7 @@ import { parseSessionUsage } from "./session-usage.ts";
 import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
 import { buildMemoryBlock } from "./agent-memory.ts";
 import { runLiveSessionTask } from "./live-session-runtime.ts";
+import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "./progress-event-coalescer.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -201,7 +202,7 @@ function cleanResultText(text: string | undefined): string | undefined {
 	return trimmed;
 }
 
-function progressEventSummary(task: TeamTaskState, event: unknown): Record<string, unknown> {
+function progressEventSummary(task: TeamTaskState, event: unknown): ProgressEventSummary {
 	const type = asRecord(event)?.type;
 	return {
 		eventType: typeof type === "string" ? type : "event",
@@ -306,14 +307,18 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
 		let lastAgentRecordPersistedAt = 0;
 		let lastRunProgressPersistedAt = 0;
+		let lastRunProgressSummary: ProgressEventSummary | undefined;
 		const persistChildProgress = (event: unknown, force = false): void => {
 			const now = Date.now();
 			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
 				upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
 				lastAgentRecordPersistedAt = now;
 			}
-			if (force || shouldFlushProgressEvent(event) || now - lastRunProgressPersistedAt >= 1000) {
-				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: progressEventSummary(task, event) });
+			const summary = progressEventSummary(task, event);
+			const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
+			if (decision.shouldAppend) {
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
+				lastRunProgressSummary = summary;
 				lastRunProgressPersistedAt = now;
 			}
 		};
@@ -389,14 +394,18 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
 		let lastAgentRecordPersistedAt = 0;
 		let lastRunProgressPersistedAt = 0;
+		let lastRunProgressSummary: ProgressEventSummary | undefined;
 		const persistLiveProgress = (event: unknown, force = false): void => {
 			const now = Date.now();
 			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
 				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
 				lastAgentRecordPersistedAt = now;
 			}
-			if (force || shouldFlushProgressEvent(event) || now - lastRunProgressPersistedAt >= 1000) {
-				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: progressEventSummary(task, event) });
+			const summary = progressEventSummary(task, event);
+			const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
+			if (decision.shouldAppend) {
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
+				lastRunProgressSummary = summary;
 				lastRunProgressPersistedAt = now;
 			}
 		};