pi-crew 0.1.45 → 0.1.46

package/src/state/active-run-registry.ts

@@ -0,0 +1,165 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DEFAULT_CACHE, DEFAULT_PATHS } from "../config/defaults.ts";
+import type { TeamRunManifest } from "./types.ts";
+import { atomicWriteJson } from "./atomic-write.ts";
+import { userCrewRoot } from "../utils/paths.ts";
+import { isSafePathId } from "../utils/safe-paths.ts";
+
+export interface ActiveRunRegistryEntry {
+	runId: string;
+	cwd: string;
+	stateRoot: string;
+	manifestPath: string;
+	updatedAt: string;
+}
+
+function registryPath(): string {
+	return path.join(userCrewRoot(), DEFAULT_PATHS.state.runsSubdir, "active-run-index.json");
+}
+
+function registryLockPath(): string {
+	return `${registryPath()}.lock`;
+}
+
+function sleepSync(ms: number): void {
+	try {
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+	} catch {
+		const deadline = Date.now() + ms;
+		while (Date.now() < deadline) {
+			// Best-effort fallback for rare runtimes without Atomics.wait.
+		}
+	}
+}
+
+function lockCreatedAt(raw: string): number | undefined {
+	try {
+		const parsed = JSON.parse(raw) as { createdAt?: unknown };
+		if (typeof parsed.createdAt !== "string") return undefined;
+		const time = Date.parse(parsed.createdAt);
+		return Number.isNaN(time) ? undefined : time;
+	} catch {
+		return undefined;
+	}
+}
+
+function removeStaleRegistryLock(lockPath: string, staleMs: number): boolean {
+	try {
+		const stat = fs.statSync(lockPath);
+		const createdAt = lockCreatedAt(fs.readFileSync(lockPath, "utf-8")) ?? stat.mtimeMs;
+		if (Date.now() - createdAt <= staleMs) return false;
+		fs.rmSync(lockPath, { force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function withRegistryLock<T>(fn: () => T): T {
+	const filePath = registryLockPath();
+	const staleMs = 30_000;
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	let attempt = 0;
+	const deadline = Date.now() + staleMs * 2;
+	while (true) {
+		try {
+			const fd = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL, 0o644);
+			try {
+				fs.writeSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
+			} finally {
+				fs.closeSync(fd);
+			}
+			break;
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code !== "EEXIST") throw error;
+			if (!removeStaleRegistryLock(filePath, staleMs) && Date.now() > deadline) throw new Error("Active-run registry is locked by another operation.");
+			sleepSync(Math.min(250, 25 * 2 ** attempt));
+			attempt += 1;
+		}
+	}
+	try {
+		return fn();
+	} finally {
+		try {
+			fs.rmSync(filePath, { force: true });
+		} catch {
+			// Best-effort cleanup.
+		}
+	}
+}
+
+function normalizeEntry(value: unknown): ActiveRunRegistryEntry | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	const runId = typeof record.runId === "string" ? record.runId : undefined;
+	const cwd = typeof record.cwd === "string" ? record.cwd : undefined;
+	const stateRoot = typeof record.stateRoot === "string" ? record.stateRoot : undefined;
+	const manifestPath = typeof record.manifestPath === "string" ? record.manifestPath : undefined;
+	const updatedAt = typeof record.updatedAt === "string" ? record.updatedAt : undefined;
+	if (!runId || !isSafePathId(runId) || !cwd || !stateRoot || !manifestPath || !updatedAt) return undefined;
+	if (path.basename(stateRoot) !== runId) return undefined;
+	if (path.resolve(manifestPath) !== path.resolve(path.join(stateRoot, DEFAULT_PATHS.state.manifestFile))) return undefined;
+	return { runId, cwd, stateRoot, manifestPath, updatedAt };
+}
+
+export function readActiveRunRegistry(maxEntries = DEFAULT_CACHE.manifestMaxEntries): ActiveRunRegistryEntry[] {
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(fs.readFileSync(registryPath(), "utf-8"));
+	} catch {
+		return [];
+	}
+	const entries = Array.isArray(parsed) ? parsed.map(normalizeEntry).filter((entry): entry is ActiveRunRegistryEntry => entry !== undefined) : [];
+	const byId = new Map<string, ActiveRunRegistryEntry>();
+	for (const entry of entries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))) {
+		if (!byId.has(entry.runId)) byId.set(entry.runId, entry);
+	}
+	return [...byId.values()].slice(0, Math.max(0, maxEntries));
+}
+
+function writeEntries(entries: ActiveRunRegistryEntry[]): void {
+	fs.mkdirSync(path.dirname(registryPath()), { recursive: true });
+	atomicWriteJson(registryPath(), entries.slice(0, DEFAULT_CACHE.manifestMaxEntries));
+}
+
+export function registerActiveRun(manifest: TeamRunManifest): void {
+	const entry: ActiveRunRegistryEntry = {
+		runId: manifest.runId,
+		cwd: manifest.cwd,
+		stateRoot: manifest.stateRoot,
+		manifestPath: path.join(manifest.stateRoot, DEFAULT_PATHS.state.manifestFile),
+		updatedAt: manifest.updatedAt,
+	};
+	withRegistryLock(() => {
+		writeEntries([entry, ...readActiveRunRegistry().filter((item) => item.runId !== manifest.runId)]);
+	});
+}
+
+export function unregisterActiveRun(runId: string): void {
+	if (!isSafePathId(runId)) return;
+	withRegistryLock(() => {
+		writeEntries(readActiveRunRegistry().filter((entry) => entry.runId !== runId));
+	});
+}
+
+export function activeRunEntries(): ActiveRunRegistryEntry[] {
+	const entries: ActiveRunRegistryEntry[] = [];
+	for (const entry of readActiveRunRegistry()) {
+		try {
+			if (!fs.existsSync(entry.stateRoot) || !fs.existsSync(entry.manifestPath)) continue;
+			if (fs.lstatSync(entry.stateRoot).isSymbolicLink()) continue;
+			const manifest = JSON.parse(fs.readFileSync(entry.manifestPath, "utf-8")) as { status?: unknown };
+			if (manifest.status !== "queued" && manifest.status !== "planning" && manifest.status !== "running") continue;
+			entries.push(entry);
+		} catch {
+			// Ignore stale entries; callers filter active status from manifests.
+		}
+	}
+	return entries;
+}
+
+export function activeRunRoots(): string[] {
+	return [...new Set(activeRunEntries().map((entry) => path.dirname(entry.stateRoot)))];
+}

package/src/state/contracts.ts

@@ -20,7 +20,7 @@ export const TEAM_RUN_STATUS_TRANSITIONS: Readonly<Record<TeamRunStatus, readonl
 export const TEAM_TASK_STATUS_TRANSITIONS: Readonly<Record<TeamTaskStatus, readonly TeamTaskStatus[]>> = {
 	queued: ["running", "cancelled", "skipped", "failed"],
 	running: ["completed", "failed", "cancelled", "queued", "waiting"],
-	waiting: ["running", "completed", "failed", "cancelled"],
+	waiting: ["running", "queued", "completed", "failed", "cancelled"],
 	completed: ["queued"],
 	failed: ["queued", "cancelled"],
 	cancelled: ["queued"],

package/src/state/mailbox.ts

@@ -6,6 +6,9 @@ import { redactSecrets } from "../utils/redaction.ts";
 
 export type MailboxDirection = "inbox" | "outbox";
 export type MailboxMessageStatus = "queued" | "delivered" | "acknowledged";
+export type MailboxMessageKind = "message" | "steer" | "follow-up" | "response" | "group_join";
+export type MailboxMessagePriority = "urgent" | "normal" | "low";
+export type MailboxDeliveryMode = "interrupt" | "next_turn";
 
 export interface MailboxMessage {
 	id: string;
@@ -16,6 +19,9 @@ export interface MailboxMessage {
 	body: string;
 	createdAt: string;
 	status: MailboxMessageStatus;
+	kind?: MailboxMessageKind;
+	priority?: MailboxMessagePriority;
+	deliveryMode?: MailboxDeliveryMode;
 	taskId?: string;
 	acknowledgedAt?: string;
 	data?: Record<string, unknown>;
@@ -130,12 +136,26 @@ function isStatus(value: unknown): value is MailboxMessageStatus {
 	return value === "queued" || value === "delivered" || value === "acknowledged";
 }
 
+function isKind(value: unknown): value is MailboxMessageKind {
+	return value === "message" || value === "steer" || value === "follow-up" || value === "response" || value === "group_join";
+}
+
+function isPriority(value: unknown): value is MailboxMessagePriority {
+	return value === "urgent" || value === "normal" || value === "low";
+}
+
+function isDeliveryMode(value: unknown): value is MailboxDeliveryMode {
+	return value === "interrupt" || value === "next_turn";
+}
+
 function parseMailboxMessage(raw: unknown, expectedDirection: MailboxDirection): MailboxMessage | undefined {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
 	const obj = raw as Record<string, unknown>;
 	if (typeof obj.id !== "string" || typeof obj.runId !== "string" || !isDirection(obj.direction) || typeof obj.from !== "string" || typeof obj.to !== "string" || typeof obj.body !== "string" || typeof obj.createdAt !== "string" || !isStatus(obj.status)) return undefined;
 	if (obj.direction !== expectedDirection) return undefined;
-	return { id: obj.id, runId: obj.runId, direction: obj.direction, from: obj.from, to: obj.to, body: obj.body, createdAt: obj.createdAt, status: obj.status, taskId: typeof obj.taskId === "string" ? obj.taskId : undefined, acknowledgedAt: typeof obj.acknowledgedAt === "string" ? obj.acknowledgedAt : undefined, data: obj.data && typeof obj.data === "object" && !Array.isArray(obj.data) ? obj.data as Record<string, unknown> : undefined };
+	const data = obj.data && typeof obj.data === "object" && !Array.isArray(obj.data) ? obj.data as Record<string, unknown> : undefined;
+	const dataKind = data?.kind;
+	return { id: obj.id, runId: obj.runId, direction: obj.direction, from: obj.from, to: obj.to, body: obj.body, createdAt: obj.createdAt, status: obj.status, kind: isKind(obj.kind) ? obj.kind : isKind(dataKind) ? dataKind : undefined, priority: isPriority(obj.priority) ? obj.priority : undefined, deliveryMode: isDeliveryMode(obj.deliveryMode) ? obj.deliveryMode : undefined, taskId: typeof obj.taskId === "string" ? obj.taskId : undefined, acknowledgedAt: typeof obj.acknowledgedAt === "string" ? obj.acknowledgedAt : undefined, data };
 }
 
 function readMailboxFile(filePath: string, direction: MailboxDirection): MailboxMessage[] {
@@ -163,18 +183,22 @@ export function readMailbox(manifest: TeamRunManifest, direction?: MailboxDirect
 	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(mailboxFile(manifest, "inbox"), "inbox")];
+function readAllMessages(manifest: TeamRunManifest, direction: MailboxDirection): MailboxMessage[] {
+	const messages = [...safeReadMailboxFile(mailboxFile(manifest, direction), direction)];
 	const tasksDir = safeMailboxTasksRoot(manifest);
 	if (fs.existsSync(tasksDir)) {
 		for (const entry of fs.readdirSync(tasksDir, { withFileTypes: true })) {
 			if (!entry.isDirectory()) continue;
-			messages.push(...safeReadMailboxFile(mailboxFile(manifest, "inbox", entry.name), "inbox"));
+			messages.push(...safeReadMailboxFile(mailboxFile(manifest, direction, entry.name), direction));
 		}
 	}
 	return messages.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 
+function readAllInboxMessages(manifest: TeamRunManifest): MailboxMessage[] {
+	return readAllMessages(manifest, "inbox");
+}
+
 export function readDeliveryState(manifest: TeamRunManifest): MailboxDeliveryState {
 	try {
 		const raw = JSON.parse(fs.readFileSync(deliveryFile(manifest), "utf-8")) as unknown;
@@ -208,6 +232,9 @@ export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<Ma
 		body: message.body,
 		createdAt,
 		status: message.status ?? "queued",
+		kind: message.kind,
+		priority: message.priority,
+		deliveryMode: message.deliveryMode,
 		taskId: message.taskId,
 		data: message.data,
 	};
@@ -219,6 +246,19 @@ export function appendMailboxMessage(manifest: TeamRunManifest, message: Omit<Ma
 	return complete;
 }
 
+export function appendSteeringMessage(manifest: TeamRunManifest, input: { taskId: string; body: string; from?: string; to?: string; priority?: MailboxMessagePriority; status?: MailboxMessageStatus; data?: Record<string, unknown> }): MailboxMessage {
+	return appendMailboxMessage(manifest, { direction: "inbox", from: input.from ?? "leader", to: input.to ?? input.taskId, taskId: input.taskId, body: input.body, kind: "steer", priority: input.priority ?? "urgent", deliveryMode: "interrupt", status: input.status, data: { ...(input.data ?? {}), kind: "steer" } });
+}
+
+export function appendFollowUpMessage(manifest: TeamRunManifest, input: { taskId: string; body: string; from?: string; to?: string; priority?: MailboxMessagePriority; status?: MailboxMessageStatus; data?: Record<string, unknown> }): MailboxMessage {
+	return appendMailboxMessage(manifest, { direction: "inbox", from: input.from ?? "leader", to: input.to ?? input.taskId, taskId: input.taskId, body: input.body, kind: "follow-up", priority: input.priority ?? "normal", deliveryMode: "next_turn", status: input.status, data: { ...(input.data ?? {}), kind: "follow-up" } });
+}
+
+export function listMailboxByKind(manifest: TeamRunManifest, kind: MailboxMessageKind, direction?: MailboxDirection): MailboxMessage[] {
+	const messages = direction ? readAllMessages(manifest, direction) : [...readAllMessages(manifest, "inbox"), ...readAllMessages(manifest, "outbox")].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+	return messages.filter((message) => message.kind === kind || message.data?.kind === kind);
+}
+
 export function findMailboxMessageByRequestId(manifest: TeamRunManifest, requestId: string): MailboxMessage | undefined {
 	return readMailbox(manifest).find((message) => message.data?.requestId === requestId);
 }

package/src/state/state-store.ts

@@ -196,7 +196,12 @@ export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTa
 	invalidateRunCache(manifest.stateRoot);
 }
 
-export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManifest["status"], summary?: string): TeamRunManifest {
+export interface UpdateRunStatusOptions {
+	data?: Record<string, unknown>;
+	metadata?: Parameters<typeof appendEvent>[1]["metadata"];
+}
+
+export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManifest["status"], summary?: string, options: UpdateRunStatusOptions = {}): TeamRunManifest {
 	if (!canTransitionRunStatus(manifest.status, status)) {
 		throw new Error(`Invalid run status transition: ${manifest.status} -> ${status}`);
 	}
@@ -206,11 +211,13 @@ export function updateRunStatus(manifest: TeamRunManifest, status: TeamRunManife
 		type: `run.${status}`,
 		runId: updated.runId,
 		message: summary,
+		...(options.data ? { data: options.data } : {}),
 		metadata: {
 			provenance: "team_runner",
 			sessionIdentity: { title: updated.team, workspace: updated.cwd, purpose: updated.goal },
 			ownership: { owner: updated.team, workflowScope: updated.workflow ?? "manual", watcherAction: "act" },
 			confidence: "high",
+			...options.metadata,
 		},
 	});
 	return updated;

package/src/state/task-claims.ts

@@ -1,44 +1,44 @@
-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;
-	const parsed = Date.parse(claim.leasedUntil);
-	// Corrupt or invalid date strings produce NaN — treat as expired immediately.
-	return Number.isFinite(parsed) ? parsed <= now.getTime() : true;
-}
-
-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;
+	const parsed = Date.parse(claim.leasedUntil);
+	// Corrupt or invalid date strings produce NaN — treat as expired immediately.
+	return Number.isFinite(parsed) ? parsed <= now.getTime() : true;
+}
+
+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/types.ts

@@ -55,8 +55,8 @@ export interface TaskPacket {
 	verification: VerificationContract;
 }
 
-export type PolicyDecisionAction = "retry" | "reassign" | "escalate" | "block" | "notify" | "cleanup" | "closeout";
-export type PolicyDecisionReason = "task_failed" | "worker_stale" | "green_unsatisfied" | "limit_exceeded" | "run_complete" | "mailbox_timeout" | "review_rejected" | "branch_stale" | "scope_mismatch";
+export type PolicyDecisionAction = "retry" | "reassign" | "escalate" | "block" | "notify" | "cleanup" | "closeout" | "fail";
+export type PolicyDecisionReason = "task_failed" | "worker_stale" | "green_unsatisfied" | "limit_exceeded" | "run_complete" | "mailbox_timeout" | "review_rejected" | "branch_stale" | "scope_mismatch" | "ineffective_worker";
 
 export interface PolicyDecision {
 	action: PolicyDecisionAction;
@@ -81,6 +81,39 @@ export interface AsyncRunState {
 	spawnedAt: string;
 }
 
+export interface RuntimeResolutionState {
+	kind: "scaffold" | "child-process" | "live-session";
+	requestedMode: "auto" | "scaffold" | "child-process" | "live-session";
+	safety: "trusted" | "explicit_dry_run" | "blocked";
+	available: boolean;
+	fallback?: "scaffold" | "child-process" | "live-session";
+	reason?: string;
+	resolvedAt: string;
+}
+
+export interface WorkerExitStatus {
+	exitCode: number | null;
+	cancelled: boolean;
+	timedOut: boolean;
+	killed: boolean;
+	signal?: string;
+	cleanupErrors: string[];
+	finalDrainMs: number;
+}
+
+export interface OperationTerminalEvidence {
+	operation: "worker" | "tool" | "model";
+	status: "cancelled" | "failed" | "completed";
+	startedAt?: string;
+	finishedAt: string;
+	attemptId?: string;
+	reason?: {
+		code: string;
+		message: string;
+	};
+	exitStatus?: WorkerExitStatus;
+}
+
 export interface PlanApprovalState {
 	required: boolean;
 	status: "pending" | "approved" | "cancelled";
@@ -125,6 +158,12 @@ export interface TeamRunManifest {
 	planApproval?: PlanApprovalState;
 	/** Pi session that created the run, when available. Used to prevent cross-session destructive actions. */
 	ownerSessionId?: string;
+	/** pi-crew skill override selected when the run was created. false disables injected skill instructions. */
+	skillOverride?: string[] | false;
+	/** Resolved runtime/safety mode used for execution. Optional for backward compatibility with older manifests. */
+	runtimeResolution?: RuntimeResolutionState;
+	/** Effective run config snapshot used by async background workers. Optional for backward compatibility. */
+	runConfig?: unknown;
 	summary?: string;
 	policyDecisions?: PolicyDecision[];
 }
@@ -166,6 +205,7 @@ export interface TaskCheckpointState {
 }
 
 export interface TaskAttemptState {
+	attemptId?: string;
 	startedAt: string;
 	endedAt?: string;
 	error?: string;
@@ -200,6 +240,8 @@ export interface TeamTaskState {
 	heartbeat?: WorkerHeartbeatState;
 	checkpoint?: TaskCheckpointState;
 	attempts?: TaskAttemptState[];
+	workerExitStatus?: WorkerExitStatus;
+	terminalEvidence?: OperationTerminalEvidence[];
 	taskPacket?: TaskPacket;
 	verification?: VerificationEvidence;
 	graph?: TaskGraphNode;

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 && Number.isFinite(usage.cost)) 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 && Number.isFinite(usage.cost)) 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/team-config.ts

@@ -5,6 +5,7 @@ export interface TeamRole {
 	agent: string;
 	description?: string;
 	model?: string;
+	/** Additional skills for this role; false disables role-default injected skills for tasks using this role. */
 	skills?: string[] | false;
 	maxConcurrency?: number;
 }