pi-crew 0.1.37 → 0.1.39

package/src/state/jsonl-writer.ts

@@ -1,77 +1,77 @@
-import * as fs from "node:fs";
-
-export interface DrainableSource {
-	pause(): void;
-	resume(): void;
-}
-
-export interface JsonlWriteStream {
-	write(chunk: string): boolean;
-	once(event: "drain", listener: () => void): JsonlWriteStream;
-	end(callback?: () => void): void;
-}
-
-const DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
-
-export interface JsonlWriterDeps {
-	createWriteStream?: (filePath: string) => JsonlWriteStream;
-	maxBytes?: number;
-}
-
-export interface JsonlWriter {
-	writeLine(line: string): void;
-	close(): Promise<void>;
-}
-
-export function createJsonlWriter(filePath: string | undefined, source: DrainableSource, deps: JsonlWriterDeps = {}): JsonlWriter {
-	if (!filePath) {
-		return {
-			writeLine() {},
-			async close() {},
-		};
-	}
-
-	const createWriteStream = deps.createWriteStream ?? ((targetPath: string) => fs.createWriteStream(targetPath, { flags: "a" }));
-	let stream: JsonlWriteStream | undefined;
-	try {
-		stream = createWriteStream(filePath);
-	} catch {
-		return {
-			writeLine() {},
-			async close() {},
-		};
-	}
-
-	let backpressured = false;
-	let closed = false;
-	let bytesWritten = 0;
-	const maxBytes = deps.maxBytes ?? DEFAULT_MAX_JSONL_BYTES;
-
-	return {
-		writeLine(line: string) {
-			if (!stream || closed || !line.trim()) return;
-			const chunk = `${line}\n`;
-			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
-			if (bytesWritten + chunkBytes > maxBytes) return;
-			try {
-				const ok = stream.write(chunk);
-				bytesWritten += chunkBytes;
-				if (!ok && !backpressured) {
-					backpressured = true;
-					source.pause();
-					stream.once("drain", () => {
-						backpressured = false;
-						if (!closed) source.resume();
-					});
-				}
-			} catch {}
-		},
-		async close() {
-			if (!stream || closed) return;
-			closed = true;
-			const current = stream;
-			stream = undefined;
-			await new Promise<void>((resolve) => current.end(() => resolve()));
-		},
-	};
-}
+import * as fs from "node:fs";
+
+export interface DrainableSource {
+	pause(): void;
+	resume(): void;
+}
+
+export interface JsonlWriteStream {
+	write(chunk: string): boolean;
+	once(event: "drain", listener: () => void): JsonlWriteStream;
+	end(callback?: () => void): void;
+}
+
+const DEFAULT_MAX_JSONL_BYTES = 50 * 1024 * 1024;
+
+export interface JsonlWriterDeps {
+	createWriteStream?: (filePath: string) => JsonlWriteStream;
+	maxBytes?: number;
+}
+
+export interface JsonlWriter {
+	writeLine(line: string): void;
+	close(): Promise<void>;
+}
+
+export function createJsonlWriter(filePath: string | undefined, source: DrainableSource, deps: JsonlWriterDeps = {}): JsonlWriter {
+	if (!filePath) {
+		return {
+			writeLine() {},
+			async close() {},
+		};
+	}
+
+	const createWriteStream = deps.createWriteStream ?? ((targetPath: string) => fs.createWriteStream(targetPath, { flags: "a" }));
+	let stream: JsonlWriteStream | undefined;
+	try {
+		stream = createWriteStream(filePath);
+	} catch {
+		return {
+			writeLine() {},
+			async close() {},
+		};
+	}
+
+	let backpressured = false;
+	let closed = false;
+	let bytesWritten = 0;
+	const maxBytes = deps.maxBytes ?? DEFAULT_MAX_JSONL_BYTES;
+
+	return {
+		writeLine(line: string) {
+			if (!stream || closed || !line.trim()) return;
+			const chunk = `${line}\n`;
+			const chunkBytes = Buffer.byteLength(chunk, "utf-8");
+			if (bytesWritten + chunkBytes > maxBytes) return;
+			try {
+				const ok = stream.write(chunk);
+				bytesWritten += chunkBytes;
+				if (!ok && !backpressured) {
+					backpressured = true;
+					source.pause();
+					stream.once("drain", () => {
+						backpressured = false;
+						if (!closed) source.resume();
+					});
+				}
+			} catch {}
+		},
+		async close() {
+			if (!stream || closed) return;
+			closed = true;
+			const current = stream;
+			stream = undefined;
+			await new Promise<void>((resolve) => current.end(() => resolve()));
+		},
+	};
+}

package/src/state/mailbox.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { TeamRunManifest } from "./types.ts";
+import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 
 export type MailboxDirection = "inbox" | "outbox";
 export type MailboxMessageStatus = "queued" | "delivered" | "acknowledged";
@@ -43,33 +44,78 @@ function mailboxDir(manifest: TeamRunManifest): string {
 	return path.join(manifest.stateRoot, "mailbox");
 }
 
-function taskMailboxDir(manifest: TeamRunManifest, taskId: string): string {
-	return path.join(mailboxDir(manifest), "tasks", taskId);
+function safeMailboxDir(manifest: TeamRunManifest, create = false): string {
+	const dir = mailboxDir(manifest);
+	if (create) fs.mkdirSync(dir, { recursive: true });
+	if (!fs.existsSync(dir)) return dir;
+	if (fs.lstatSync(dir).isSymbolicLink()) throw new Error(`Invalid mailbox directory: ${dir}`);
+	return resolveRealContainedPath(manifest.stateRoot, "mailbox");
 }
 
-function mailboxPath(manifest: TeamRunManifest, direction: MailboxDirection, taskId?: string): string {
-	return taskId ? path.join(taskMailboxDir(manifest, taskId), `${direction}.jsonl`) : path.join(mailboxDir(manifest), `${direction}.jsonl`);
+function safeTaskId(taskId: string): string {
+	if (!/^[\w.-]+$/.test(taskId) || taskId.includes("..") || path.isAbsolute(taskId)) throw new Error(`Invalid mailbox task id: ${taskId}`);
+	return taskId;
 }
 
-function deliveryPath(manifest: TeamRunManifest): string {
-	return path.join(mailboxDir(manifest), "delivery.json");
+function safeMailboxTasksRoot(manifest: TeamRunManifest, create = false): string {
+	const root = path.join(safeMailboxDir(manifest, create), "tasks");
+	if (create) fs.mkdirSync(root, { recursive: true });
+	if (!fs.existsSync(root)) return root;
+	if (fs.lstatSync(root).isSymbolicLink()) throw new Error(`Invalid mailbox tasks directory: ${root}`);
+	return resolveRealContainedPath(safeMailboxDir(manifest), "tasks");
+}
+
+function taskMailboxDir(manifest: TeamRunManifest, taskId: string, create = false): string {
+	const tasksRoot = safeMailboxTasksRoot(manifest, create);
+	const normalizedTaskId = safeTaskId(taskId);
+	const resolved = path.resolve(tasksRoot, normalizedTaskId);
+	const relative = path.relative(tasksRoot, resolved);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Invalid mailbox task id: ${taskId}`);
+	if (create) fs.mkdirSync(resolved, { recursive: true });
+	if (!fs.existsSync(resolved)) return resolved;
+	if (fs.lstatSync(resolved).isSymbolicLink()) throw new Error(`Invalid mailbox task directory: ${resolved}`);
+	return resolveRealContainedPath(tasksRoot, normalizedTaskId);
+}
+
+function mailboxPath(manifest: TeamRunManifest, direction: MailboxDirection, taskId?: string, create = false): string {
+	return taskId ? path.join(taskMailboxDir(manifest, taskId, create), `${direction}.jsonl`) : path.join(safeMailboxDir(manifest, create), `${direction}.jsonl`);
+}
+
+function deliveryPath(manifest: TeamRunManifest, create = false): string {
+	return path.join(safeMailboxDir(manifest, create), "delivery.json");
+}
+
+function safeMailboxFile(filePath: string, parentDir: string): string {
+	if (!fs.existsSync(filePath)) return filePath;
+	if (fs.lstatSync(filePath).isSymbolicLink()) throw new Error(`Invalid mailbox file: ${filePath}`);
+	return resolveRealContainedPath(parentDir, path.basename(filePath));
+}
+
+function mailboxFile(manifest: TeamRunManifest, direction: MailboxDirection, taskId?: string, create = false): string {
+	const parent = taskId ? taskMailboxDir(manifest, taskId, create) : safeMailboxDir(manifest, create);
+	return safeMailboxFile(path.join(parent, `${direction}.jsonl`), parent);
+}
+
+function deliveryFile(manifest: TeamRunManifest, create = false): string {
+	const parent = safeMailboxDir(manifest, create);
+	return safeMailboxFile(path.join(parent, "delivery.json"), parent);
 }
 
 function ensureRunMailbox(manifest: TeamRunManifest): void {
-	fs.mkdirSync(mailboxDir(manifest), { recursive: true });
+	safeMailboxDir(manifest, true);
 	for (const direction of ["inbox", "outbox"] as const) {
-		const filePath = mailboxPath(manifest, direction);
+		const filePath = mailboxFile(manifest, direction, undefined, true);
 		if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, "", "utf-8");
 	}
-	const delivery = deliveryPath(manifest);
+	const delivery = deliveryFile(manifest, true);
 	if (!fs.existsSync(delivery)) fs.writeFileSync(delivery, `${JSON.stringify({ messages: {}, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf-8");
 }
 
 function ensureTaskMailbox(manifest: TeamRunManifest, taskId: string): void {
 	ensureRunMailbox(manifest);
-	fs.mkdirSync(taskMailboxDir(manifest, taskId), { recursive: true });
+	taskMailboxDir(manifest, taskId, true);
 	for (const direction of ["inbox", "outbox"] as const) {
-		const filePath = mailboxPath(manifest, direction, taskId);
+		const filePath = mailboxFile(manifest, direction, taskId, true);
 		if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, "", "utf-8");
 	}
 }
@@ -112,25 +158,24 @@ function safeReadMailboxFile(filePath: string, direction: MailboxDirection): Mai
 
 export function readMailbox(manifest: TeamRunManifest, direction?: MailboxDirection, taskId?: string): MailboxMessage[] {
 	const directions = direction ? [direction] : ["inbox", "outbox"] as const;
-	return directions.flatMap((item) => safeReadMailboxFile(mailboxPath(manifest, item, taskId), item)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+	return directions.flatMap((item) => safeReadMailboxFile(mailboxFile(manifest, item, taskId), item)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 
 function readAllInboxMessages(manifest: TeamRunManifest): MailboxMessage[] {
-	const messages = [...safeReadMailboxFile(mailboxPath(manifest, "inbox"), "inbox")];
-	const tasksDir = path.join(mailboxDir(manifest), "tasks");
+	const messages = [...safeReadMailboxFile(mailboxFile(manifest, "inbox"), "inbox")];
+	const tasksDir = safeMailboxTasksRoot(manifest);
 	if (fs.existsSync(tasksDir)) {
 		for (const entry of fs.readdirSync(tasksDir, { withFileTypes: true })) {
 			if (!entry.isDirectory()) continue;
-			messages.push(...safeReadMailboxFile(mailboxPath(manifest, "inbox", entry.name), "inbox"));
+			messages.push(...safeReadMailboxFile(mailboxFile(manifest, "inbox", entry.name), "inbox"));
 		}
 	}
 	return messages.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 
 export function readDeliveryState(manifest: TeamRunManifest): MailboxDeliveryState {
-	ensureRunMailbox(manifest);
 	try {
-		const raw = JSON.parse(fs.readFileSync(deliveryPath(manifest), "utf-8")) as unknown;
+		const raw = JSON.parse(fs.readFileSync(deliveryFile(manifest), "utf-8")) as unknown;
 		if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("Invalid delivery state.");
 		const obj = raw as Record<string, unknown>;
 		const messages: Record<string, MailboxMessageStatus> = {};
@@ -145,7 +190,7 @@ export function readDeliveryState(manifest: TeamRunManifest): MailboxDeliverySta
 
 function writeDeliveryState(manifest: TeamRunManifest, state: MailboxDeliveryState): void {
 	ensureRunMailbox(manifest);
-	fs.writeFileSync(deliveryPath(manifest), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+	fs.writeFileSync(deliveryFile(manifest, true), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
 }
 
 export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<MailboxMessage, "id" | "runId" | "createdAt" | "status"> & { id?: string; status?: MailboxMessageStatus }): MailboxMessage {
@@ -163,7 +208,7 @@ export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<Ma
 		status: message.status ?? "queued",
 		taskId: message.taskId,
 	};
-	fs.appendFileSync(mailboxPath(manifest, complete.direction, complete.taskId), `${JSON.stringify(complete)}\n`, "utf-8");
+	fs.appendFileSync(mailboxFile(manifest, complete.direction, complete.taskId), `${JSON.stringify(complete)}\n`, "utf-8");
 	const delivery = readDeliveryState(manifest);
 	delivery.messages[complete.id] = complete.status;
 	delivery.updatedAt = createdAt;
@@ -196,7 +241,7 @@ export function validateMailbox(manifest: TeamRunManifest, options: { repair?: b
 	const issues: MailboxValidationIssue[] = [];
 	const repaired: string[] = [];
 	for (const direction of ["inbox", "outbox"] as const) {
-		const filePath = mailboxPath(manifest, direction);
+		const filePath = mailboxFile(manifest, direction);
 		const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/).filter(Boolean);
 		const validLines: string[] = [];
 		for (const line of lines) {
@@ -217,12 +262,12 @@ export function validateMailbox(manifest: TeamRunManifest, options: { repair?: b
 	}
 	const delivery = readDeliveryState(manifest);
 	const allMessages = readMailbox(manifest);
-	for (const message of allMessages) if (!delivery.messages[message.id]) issues.push({ level: "warning", path: deliveryPath(manifest), message: `Missing delivery entry for ${message.id}.` });
+	for (const message of allMessages) if (!delivery.messages[message.id]) issues.push({ level: "warning", path: deliveryFile(manifest), message: `Missing delivery entry for ${message.id}.` });
 	if (options.repair) {
 		for (const message of allMessages) delivery.messages[message.id] ??= message.status;
 		delivery.updatedAt = new Date().toISOString();
 		writeDeliveryState(manifest, delivery);
-		repaired.push(deliveryPath(manifest));
+		repaired.push(deliveryFile(manifest));
 	}
 	return { issues, repaired };
 }

package/src/state/state-store.ts

@@ -7,6 +7,7 @@ import { appendEvent } from "./event-log.ts";
 import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
 import { createRunId, createTaskId } from "../utils/ids.ts";
 import { findRepoRoot, projectCrewRoot, userCrewRoot } from "../utils/paths.ts";
+import { assertSafePathId, resolveContainedRelativePath, resolveRealContainedPath } from "../utils/safe-paths.ts";
 import type { TeamConfig } from "../teams/team-config.ts";
 import type { WorkflowConfig } from "../workflows/workflow-config.ts";
 
@@ -53,14 +54,40 @@ function scopeBaseRoot(cwd: string): string {
 }
 
 function resolveRunStateRoot(cwd: string, runId: string): string | undefined {
-	const scopedPath = path.join(scopeBaseRoot(cwd), DEFAULT_PATHS.state.runsSubdir, runId);
-	return fs.existsSync(scopedPath) ? scopedPath : undefined;
+	assertSafePathId("runId", runId);
+	const runsRoot = path.join(scopeBaseRoot(cwd), DEFAULT_PATHS.state.runsSubdir);
+	const scopedPath = resolveContainedRelativePath(runsRoot, runId, "runId");
+	if (!fs.existsSync(scopedPath)) return undefined;
+	try {
+		if (fs.lstatSync(scopedPath).isSymbolicLink()) return undefined;
+		resolveRealContainedPath(runsRoot, runId);
+	} catch {
+		return undefined;
+	}
+	return scopedPath;
+}
+
+function validateRunManifestPaths(cwd: string, runId: string, manifest: TeamRunManifest, stateRoot: string, tasksPath: string): boolean {
+	if (manifest.runId !== runId || manifest.stateRoot !== stateRoot || manifest.tasksPath !== tasksPath || manifest.eventsPath !== path.join(stateRoot, "events.jsonl")) return false;
+	const artifactsParent = path.join(scopeBaseRoot(cwd), DEFAULT_PATHS.state.artifactsSubdir);
+	const expectedArtifactsRoot = resolveContainedRelativePath(artifactsParent, runId, "runId");
+	if (manifest.artifactsRoot !== expectedArtifactsRoot) return false;
+	if (fs.existsSync(expectedArtifactsRoot)) {
+		try {
+			if (fs.lstatSync(expectedArtifactsRoot).isSymbolicLink()) return false;
+			resolveRealContainedPath(artifactsParent, runId);
+		} catch {
+			return false;
+		}
+	}
+	return true;
 }
 
 export function createRunPaths(cwd: string, runId = createRunId()): RunPaths {
+	assertSafePathId("runId", runId);
 	const baseRoot = scopeBaseRoot(cwd);
-	const stateRoot = path.join(baseRoot, DEFAULT_PATHS.state.runsSubdir, runId);
-	const artifactsRoot = path.join(baseRoot, DEFAULT_PATHS.state.artifactsSubdir, runId);
+	const stateRoot = resolveContainedRelativePath(path.join(baseRoot, DEFAULT_PATHS.state.runsSubdir), runId, "runId");
+	const artifactsRoot = resolveContainedRelativePath(path.join(baseRoot, DEFAULT_PATHS.state.artifactsSubdir), runId, "runId");
 	return {
 		runId,
 		stateRoot,
@@ -222,11 +249,15 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 		&& cached.tasksMtimeMs === tasksMtimeMs
 		&& cached.tasksSize === (tasksStat?.size ?? 0)
 	) {
+		if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
+			manifestCache.delete(stateRoot);
+			return undefined;
+		}
 		return { manifest: cached.manifest, tasks: cached.tasks };
 	}
 
 	const manifest = readJsonFile<TeamRunManifest>(manifestPath);
-	if (!manifest) return undefined;
+	if (!manifest || !validateRunManifestPaths(cwd, runId, manifest, stateRoot, tasksPath)) return undefined;
 	const tasks = readJsonFile<TeamTaskState[]>(tasksPath) ?? [];
 	setManifestCache(stateRoot, {
 		manifest,

package/src/state/task-claims.ts

@@ -1,42 +1,42 @@
-import { randomUUID } from "node:crypto";
-import type { TeamTaskState } from "./types.ts";
-
-export interface TaskClaimState {
-	owner: string;
-	token: string;
-	leasedUntil: string;
-}
-
-export function createTaskClaim(owner: string, leaseMs = 5 * 60_000, now = new Date()): TaskClaimState {
-	return { owner, token: randomUUID(), leasedUntil: new Date(now.getTime() + leaseMs).toISOString() };
-}
-
-export function isTaskClaimExpired(claim: TaskClaimState | undefined, now = new Date()): boolean {
-	if (!claim) return false;
-	return Date.parse(claim.leasedUntil) <= now.getTime();
-}
-
-export function canUseTaskClaim(task: Pick<TeamTaskState, "claim">, owner: string, token: string, now = new Date()): boolean {
-	return task.claim?.owner === owner && task.claim.token === token && !isTaskClaimExpired(task.claim, now);
-}
-
-export function claimTask<T extends TeamTaskState>(task: T, owner: string, leaseMs?: number, now = new Date()): T {
-	if (task.claim && !isTaskClaimExpired(task.claim, now)) {
-		throw new Error(`Task '${task.id}' is already claimed by '${task.claim.owner}'.`);
-	}
-	return { ...task, claim: createTaskClaim(owner, leaseMs, now) };
-}
-
-export function releaseTaskClaim<T extends TeamTaskState>(task: T, owner: string, token: string, now = new Date()): T {
-	if (!canUseTaskClaim(task, owner, token, now)) {
-		throw new Error(`Task '${task.id}' claim is not held by '${owner}' or has expired.`);
-	}
-	return { ...task, claim: undefined };
-}
-
-export function transitionClaimedTaskStatus<T extends TeamTaskState>(task: T, owner: string, token: string, status: T["status"], now = new Date()): T {
-	if (!canUseTaskClaim(task, owner, token, now)) {
-		throw new Error(`Task '${task.id}' claim is not held by '${owner}' or has expired.`);
-	}
-	return { ...task, status };
-}
+import { randomUUID } from "node:crypto";
+import type { TeamTaskState } from "./types.ts";
+
+export interface TaskClaimState {
+	owner: string;
+	token: string;
+	leasedUntil: string;
+}
+
+export function createTaskClaim(owner: string, leaseMs = 5 * 60_000, now = new Date()): TaskClaimState {
+	return { owner, token: randomUUID(), leasedUntil: new Date(now.getTime() + leaseMs).toISOString() };
+}
+
+export function isTaskClaimExpired(claim: TaskClaimState | undefined, now = new Date()): boolean {
+	if (!claim) return false;
+	return Date.parse(claim.leasedUntil) <= now.getTime();
+}
+
+export function canUseTaskClaim(task: Pick<TeamTaskState, "claim">, owner: string, token: string, now = new Date()): boolean {
+	return task.claim?.owner === owner && task.claim.token === token && !isTaskClaimExpired(task.claim, now);
+}
+
+export function claimTask<T extends TeamTaskState>(task: T, owner: string, leaseMs?: number, now = new Date()): T {
+	if (task.claim && !isTaskClaimExpired(task.claim, now)) {
+		throw new Error(`Task '${task.id}' is already claimed by '${task.claim.owner}'.`);
+	}
+	return { ...task, claim: createTaskClaim(owner, leaseMs, now) };
+}
+
+export function releaseTaskClaim<T extends TeamTaskState>(task: T, owner: string, token: string, now = new Date()): T {
+	if (!canUseTaskClaim(task, owner, token, now)) {
+		throw new Error(`Task '${task.id}' claim is not held by '${owner}' or has expired.`);
+	}
+	return { ...task, claim: undefined };
+}
+
+export function transitionClaimedTaskStatus<T extends TeamTaskState>(task: T, owner: string, token: string, status: T["status"], now = new Date()): T {
+	if (!canUseTaskClaim(task, owner, token, now)) {
+		throw new Error(`Task '${task.id}' claim is not held by '${owner}' or has expired.`);
+	}
+	return { ...task, status };
+}

package/src/state/usage.ts

@@ -1,29 +1,29 @@
-import type { TeamTaskState, UsageState } from "./types.ts";
-
-export function aggregateUsage(tasks: TeamTaskState[]): UsageState | undefined {
-	const total: UsageState = {};
-	let found = false;
-	for (const task of tasks) {
-		if (!task.usage) continue;
-		found = true;
-		total.input = (total.input ?? 0) + (task.usage.input ?? 0);
-		total.output = (total.output ?? 0) + (task.usage.output ?? 0);
-		total.cacheRead = (total.cacheRead ?? 0) + (task.usage.cacheRead ?? 0);
-		total.cacheWrite = (total.cacheWrite ?? 0) + (task.usage.cacheWrite ?? 0);
-		total.cost = (total.cost ?? 0) + (task.usage.cost ?? 0);
-		total.turns = (total.turns ?? 0) + (task.usage.turns ?? 0);
-	}
-	return found ? total : undefined;
-}
-
-export function formatUsage(usage: UsageState | undefined): string {
-	if (!usage) return "(none)";
-	const parts: string[] = [];
-	if (usage.input !== undefined) parts.push(`input=${usage.input}`);
-	if (usage.output !== undefined) parts.push(`output=${usage.output}`);
-	if (usage.cacheRead !== undefined) parts.push(`cacheRead=${usage.cacheRead}`);
-	if (usage.cacheWrite !== undefined) parts.push(`cacheWrite=${usage.cacheWrite}`);
-	if (usage.cost !== undefined) parts.push(`cost=${usage.cost.toFixed(6)}`);
-	if (usage.turns !== undefined) parts.push(`turns=${usage.turns}`);
-	return parts.join(", ") || "(none)";
-}
+import type { TeamTaskState, UsageState } from "./types.ts";
+
+export function aggregateUsage(tasks: TeamTaskState[]): UsageState | undefined {
+	const total: UsageState = {};
+	let found = false;
+	for (const task of tasks) {
+		if (!task.usage) continue;
+		found = true;
+		total.input = (total.input ?? 0) + (task.usage.input ?? 0);
+		total.output = (total.output ?? 0) + (task.usage.output ?? 0);
+		total.cacheRead = (total.cacheRead ?? 0) + (task.usage.cacheRead ?? 0);
+		total.cacheWrite = (total.cacheWrite ?? 0) + (task.usage.cacheWrite ?? 0);
+		total.cost = (total.cost ?? 0) + (task.usage.cost ?? 0);
+		total.turns = (total.turns ?? 0) + (task.usage.turns ?? 0);
+	}
+	return found ? total : undefined;
+}
+
+export function formatUsage(usage: UsageState | undefined): string {
+	if (!usage) return "(none)";
+	const parts: string[] = [];
+	if (usage.input !== undefined) parts.push(`input=${usage.input}`);
+	if (usage.output !== undefined) parts.push(`output=${usage.output}`);
+	if (usage.cacheRead !== undefined) parts.push(`cacheRead=${usage.cacheRead}`);
+	if (usage.cacheWrite !== undefined) parts.push(`cacheWrite=${usage.cacheWrite}`);
+	if (usage.cost !== undefined) parts.push(`cost=${usage.cost.toFixed(6)}`);
+	if (usage.turns !== undefined) parts.push(`turns=${usage.turns}`);
+	return parts.join(", ") || "(none)";
+}

package/src/subagents/async-entry.ts

@@ -1 +1 @@
-export * from "../runtime/async-runner.ts";
+export * from "../runtime/async-runner.ts";

package/src/subagents/index.ts

@@ -1,3 +1,3 @@
-export * from "./spawn.ts";
-export * from "./manager.ts";
-export * from "./async-entry.ts";
+export * from "./spawn.ts";
+export * from "./manager.ts";
+export * from "./async-entry.ts";

package/src/subagents/live/control.ts

@@ -1 +1 @@
-export * from "../../runtime/live-agent-control.ts";
+export * from "../../runtime/live-agent-control.ts";

package/src/subagents/live/manager.ts

@@ -1 +1 @@
-export * from "../../runtime/live-agent-manager.ts";
+export * from "../../runtime/live-agent-manager.ts";

package/src/subagents/live/realtime.ts

@@ -1 +1 @@
-export * from "../../runtime/live-control-realtime.ts";
+export * from "../../runtime/live-control-realtime.ts";

package/src/subagents/live/session-runtime.ts

@@ -1 +1 @@
-export * from "../../runtime/live-session-runtime.ts";
+export * from "../../runtime/live-session-runtime.ts";

package/src/subagents/manager.ts

@@ -1 +1 @@
-export * from "../runtime/subagent-manager.ts";
+export * from "../runtime/subagent-manager.ts";

package/src/subagents/spawn.ts

@@ -1 +1 @@
-export * from "../runtime/child-pi.ts";
+export * from "../runtime/child-pi.ts";

package/src/teams/discover-teams.ts

@@ -12,19 +12,41 @@ export interface TeamDiscoveryResult {
 	project: TeamConfig[];
 }
 
+function parseRoleSkills(value: string | undefined): string[] | false | undefined {
+	if (!value) return undefined;
+	if (value === "false") return false;
+	const skills = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+	return skills.length ? skills : undefined;
+}
+
 function parseRoleLine(line: string): TeamRole | undefined {
 	const trimmed = line.trim();
 	if (!trimmed.startsWith("-")) return undefined;
 	const value = trimmed.slice(1).trim();
 	if (!value) return undefined;
-	const [namePart, restPart] = value.split(":", 2);
-	const name = namePart?.trim();
+	const separator = value.indexOf(":");
+	const namePart = separator >= 0 ? value.slice(0, separator) : value;
+	const restPart = separator >= 0 ? value.slice(separator + 1) : "";
+	const name = namePart.trim();
 	if (!name) return undefined;
-	const agentMatch = restPart?.match(/agent\s*=\s*([\w-]+)/);
+	const metadata: Record<string, string> = {};
+	let descriptionSource = restPart.replace(/\bskills\s*=\s*([\w-]+(?:\s*,\s*[\w-]+)*)/g, (_match, raw: string) => {
+		metadata.skills = raw.replace(/\s*,\s*/g, ",").trim();
+		return "";
+	});
+	descriptionSource = descriptionSource.replace(/\b(agent|model|maxConcurrency)\s*=\s*(\S+)/g, (_match, key: string, raw: string) => {
+		metadata[key] = raw.trim();
+		return "";
+	});
+	const description = descriptionSource.replace(/\s+/g, " ").trim() || undefined;
+	const maxConcurrency = metadata.maxConcurrency ? Number.parseInt(metadata.maxConcurrency, 10) : undefined;
 	return {
 		name,
-		agent: agentMatch?.[1] ?? name,
-		description: restPart?.replace(/agent\s*=\s*[\w-]+/, "").trim() || undefined,
+		agent: metadata.agent ?? name,
+		description,
+		model: metadata.model,
+		skills: parseRoleSkills(metadata.skills),
+		maxConcurrency: maxConcurrency && maxConcurrency > 0 ? maxConcurrency : undefined,
 	};
 }