pi-crew 0.1.46 → 0.1.49

package/src/state/state-store.ts

@@ -27,12 +27,15 @@ interface ManifestCacheEntry {
 	manifestSize: number;
 	tasksMtimeMs: number;
 	tasksSize: number;
+	cachedAt?: number;
 }
 
+const MANIFEST_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const manifestCache = new Map<string, ManifestCacheEntry>();
 
 function setManifestCache(stateRoot: string, entry: ManifestCacheEntry): void {
 	if (manifestCache.has(stateRoot)) manifestCache.delete(stateRoot);
+	entry.cachedAt = Date.now();
 	manifestCache.set(stateRoot, entry);
 	while (manifestCache.size > DEFAULT_CACHE.manifestMaxEntries) {
 		const oldest = manifestCache.keys().next().value;
@@ -196,6 +199,15 @@ export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTa
 	invalidateRunCache(manifest.stateRoot);
 }
 
+/** M8: Atomically save manifest + tasks and invalidate cache once to prevent stale reads between saves */
+export async function saveManifestAndTasksAtomic(manifest: TeamRunManifest, tasks: TeamTaskState[]): Promise<void> {
+	await Promise.all([
+		atomicWriteJsonAsync(path.join(manifest.stateRoot, "manifest.json"), manifest),
+		atomicWriteJsonAsync(manifest.tasksPath, tasks),
+	]);
+	invalidateRunCache(manifest.stateRoot);
+}
+
 export interface UpdateRunStatusOptions {
 	data?: Record<string, unknown>;
 	metadata?: Parameters<typeof appendEvent>[1]["metadata"];
@@ -266,11 +278,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)) {
+		// TTL eviction: expire stale entries even if mtime matches
+		if (cached.cachedAt && Date.now() - cached.cachedAt > MANIFEST_CACHE_TTL_MS) {
+			manifestCache.delete(stateRoot);
+		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
+		} else {
+			return { manifest: cached.manifest, tasks: cached.tasks };
 		}
-		return { manifest: cached.manifest, tasks: cached.tasks };
 	}
 
 	const manifest = readJsonFile<TeamRunManifest>(manifestPath);
@@ -307,11 +323,15 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 	}
 	const tasksMtimeMs = tasksStat?.mtimeMs ?? 0;
 	if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0)) {
-		if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
+		// TTL eviction: expire stale entries even if mtime matches
+		if (cached.cachedAt && Date.now() - cached.cachedAt > MANIFEST_CACHE_TTL_MS) {
+			manifestCache.delete(stateRoot);
+		} else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
 			manifestCache.delete(stateRoot);
 			return undefined;
+		} else {
+			return { manifest: cached.manifest, tasks: cached.tasks };
 		}
-		return { manifest: cached.manifest, tasks: cached.tasks };
 	}
 	const manifest = await readJsonFileAsync<TeamRunManifest>(manifestPath);
 	if (!manifest || !validateRunManifestPaths(cwd, runId, manifest, stateRoot, tasksPath)) return undefined;

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

@@ -39,6 +39,17 @@ export interface VerificationEvidence {
 	notes?: string;
 }
 
+export interface TaskOutputSchema {
+	/** Output format expected from the worker */
+	format: "json" | "markdown" | "text";
+	/** JTD or JSON Schema for validating JSON output (only when format="json") */
+	schema?: Record<string, unknown>;
+	/** Human-readable description of expected output */
+	description?: string;
+	/** Example of valid output (for prompt guidance) */
+	example?: string;
+}
+
 export interface TaskPacket {
 	objective: string;
 	scope: TaskScope;
@@ -53,6 +64,7 @@ export interface TaskPacket {
 	constraints: string[];
 	expectedArtifacts: string[];
 	verification: VerificationContract;
+	outputSchema?: TaskOutputSchema;
 }
 
 export type PolicyDecisionAction = "retry" | "reassign" | "escalate" | "block" | "notify" | "cleanup" | "closeout" | "fail";
@@ -218,6 +230,7 @@ export interface TeamTaskState {
 	role: string;
 	agent: string;
 	title: string;
+	displayName?: string;
 	status: TeamTaskStatus;
 	dependsOn: string[];
 	cwd: string;
@@ -253,4 +266,11 @@ export interface TeamTaskState {
 		retryCount?: number;
 		lastDecision?: PolicyDecision;
 	};
+	controlReservation?: ControlReservation;
+}
+
+export interface ControlReservation {
+	reservedAt: string;
+	controllerId: string;
+	acceptsControlEvents: boolean;
 }

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-serializer.ts

@@ -1,38 +1,38 @@
-import type { TeamConfig, TeamRole } from "./team-config.ts";
-
-function line(key: string, value: string | string[] | undefined): string | undefined {
-	if (value === undefined) return undefined;
-	if (Array.isArray(value)) return `${key}: ${value.join(", ")}`;
-	return `${key}: ${value}`;
-}
-
-function serializeRole(role: TeamRole): string {
-	const parts = [`agent=${role.agent}`];
-	if (role.model) parts.push(`model=${role.model}`);
-	if (role.skills === false) parts.push("skills=false");
-	else if (role.skills?.length) parts.push(`skills=${role.skills.join(",")}`);
-	if (role.maxConcurrency !== undefined) parts.push(`maxConcurrency=${role.maxConcurrency}`);
-	if (role.description) parts.push(role.description);
-	return `- ${role.name}: ${parts.join(" ")}`;
-}
-
-export function serializeTeam(team: TeamConfig): string {
-	const lines = [
-		"---",
-		`name: ${team.name}`,
-		`description: ${team.description}`,
-		team.defaultWorkflow ? `defaultWorkflow: ${team.defaultWorkflow}` : undefined,
-		team.workspaceMode ? `workspaceMode: ${team.workspaceMode}` : undefined,
-		team.maxConcurrency !== undefined ? `maxConcurrency: ${team.maxConcurrency}` : undefined,
-		line("triggers", team.routing?.triggers),
-		line("useWhen", team.routing?.useWhen),
-		line("avoidWhen", team.routing?.avoidWhen),
-		line("cost", team.routing?.cost),
-		line("category", team.routing?.category),
-		"---",
-		"",
-		...team.roles.map(serializeRole),
-		"",
-	].filter((entry): entry is string => entry !== undefined);
-	return lines.join("\n");
-}
+import type { TeamConfig, TeamRole } from "./team-config.ts";
+
+function line(key: string, value: string | string[] | undefined): string | undefined {
+	if (value === undefined) return undefined;
+	if (Array.isArray(value)) return `${key}: ${value.join(", ")}`;
+	return `${key}: ${value}`;
+}
+
+function serializeRole(role: TeamRole): string {
+	const parts = [`agent=${role.agent}`];
+	if (role.model) parts.push(`model=${role.model}`);
+	if (role.skills === false) parts.push("skills=false");
+	else if (role.skills?.length) parts.push(`skills=${role.skills.join(",")}`);
+	if (role.maxConcurrency !== undefined) parts.push(`maxConcurrency=${role.maxConcurrency}`);
+	if (role.description) parts.push(role.description);
+	return `- ${role.name}: ${parts.join(" ")}`;
+}
+
+export function serializeTeam(team: TeamConfig): string {
+	const lines = [
+		"---",
+		`name: ${team.name}`,
+		`description: ${team.description}`,
+		team.defaultWorkflow ? `defaultWorkflow: ${team.defaultWorkflow}` : undefined,
+		team.workspaceMode ? `workspaceMode: ${team.workspaceMode}` : undefined,
+		team.maxConcurrency !== undefined ? `maxConcurrency: ${team.maxConcurrency}` : undefined,
+		line("triggers", team.routing?.triggers),
+		line("useWhen", team.routing?.useWhen),
+		line("avoidWhen", team.routing?.avoidWhen),
+		line("cost", team.routing?.cost),
+		line("category", team.routing?.category),
+		"---",
+		"",
+		...team.roles.map(serializeRole),
+		"",
+	].filter((entry): entry is string => entry !== undefined);
+	return lines.join("\n");
+}

package/src/types/diff.d.ts

@@ -1,18 +1,18 @@
-declare module "diff" {
-	export interface Change {
-		value: string;
-		count?: number;
-		added?: boolean;
-		removed?: boolean;
-	}
-
-	export interface DiffOptions {
-		ignoreCase?: boolean;
-		newlineIsToken?: boolean;
-		ignoreWhitespace?: boolean;
-		stripTrailingCr?: boolean;
-		oneChangePerToken?: boolean;
-	}
-
-	export function diffWords(oldStr: string, newStr: string, options?: DiffOptions): Change[];
-}
+declare module "diff" {
+	export interface Change {
+		value: string;
+		count?: number;
+		added?: boolean;
+		removed?: boolean;
+	}
+
+	export interface DiffOptions {
+		ignoreCase?: boolean;
+		newlineIsToken?: boolean;
+		ignoreWhitespace?: boolean;
+		stripTrailingCr?: boolean;
+		oneChangePerToken?: boolean;
+	}
+
+	export function diffWords(oldStr: string, newStr: string, options?: DiffOptions): Change[];
+}

package/src/ui/agent-management-overlay.ts

@@ -0,0 +1,144 @@
+/**
+ * Agent Management Overlay — displays discovered agents with their configuration.
+ * Read-only view of agent definitions from builtin/user/project sources.
+ * Future: enable/disable toggle, model override editing.
+ */
+import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
+import { truncate } from "../utils/visual.ts";
+
+export interface AgentEntry {
+	name: string;
+	description: string;
+	source: ResourceSource;
+	model?: string;
+	thinking?: string;
+	loadMode?: string;
+	contextMode?: string;
+	disabled?: boolean;
+	filePath: string;
+}
+
+export function agentToEntry(agent: AgentConfig): AgentEntry {
+	return {
+		name: agent.name,
+		description: agent.description,
+		source: agent.source,
+		model: agent.model,
+		thinking: agent.thinking,
+		loadMode: agent.loadMode,
+		contextMode: agent.contextMode,
+		disabled: agent.disabled,
+		filePath: agent.filePath,
+	};
+}
+
+function sourceIcon(source: ResourceSource): string {
+	switch (source) {
+		case "builtin": return "📦";
+		case "user": return "👤";
+		case "project": return "📂";
+		case "git": return "🔗";
+	}
+}
+
+function sourceLabel(source: ResourceSource): string {
+	switch (source) {
+		case "builtin": return "builtin";
+		case "user": return "user";
+		case "project": return "project";
+		case "git": return "git";
+	}
+}
+
+export interface AgentOverlayState {
+	entries: AgentEntry[];
+	selectedIndex: number;
+	scrollOffset: number;
+	expanded: Set<number>;
+	maxVisible: number;
+}
+
+export function createAgentOverlayState(entries: AgentEntry[], maxVisible = 20): AgentOverlayState {
+	return {
+		entries: entries.sort((a, b) => {
+			const order: Record<ResourceSource, number> = { project: 0, user: 1, git: 2, builtin: 3 };
+			const diff = (order[a.source] ?? 4) - (order[b.source] ?? 4);
+			return diff !== 0 ? diff : a.name.localeCompare(b.name);
+		}),
+		selectedIndex: 0,
+		scrollOffset: 0,
+		expanded: new Set(),
+		maxVisible,
+	};
+}
+
+export function moveSelection(state: AgentOverlayState, direction: -1 | 1): AgentOverlayState {
+	const next = Math.max(0, Math.min(state.entries.length - 1, state.selectedIndex + direction));
+	const visibleStart = state.scrollOffset;
+	const visibleEnd = state.scrollOffset + state.maxVisible;
+	const newScroll = next < visibleStart
+		? next
+		: next >= visibleEnd
+			? Math.max(0, next - state.maxVisible + 1)
+			: state.scrollOffset;
+	return { ...state, selectedIndex: next, scrollOffset: newScroll };
+}
+
+export function toggleExpand(state: AgentOverlayState): AgentOverlayState {
+	const expanded = new Set(state.expanded);
+	if (expanded.has(state.selectedIndex)) {
+		expanded.delete(state.selectedIndex);
+	} else {
+		expanded.add(state.selectedIndex);
+	}
+	return { ...state, expanded };
+}
+
+export function renderAgentOverlay(state: AgentOverlayState, width: number): string[] {
+	const lines: string[] = [];
+	const header = ` Agent Configuration (${state.entries.length} agents)`;
+	lines.push(truncate(header, width));
+	lines.push(truncate("─".repeat(Math.min(width, 60)), width));
+
+	if (state.entries.length === 0) {
+		lines.push(truncate(" No agents discovered.", width));
+		return lines;
+	}
+
+	const visible = state.entries.slice(
+		state.scrollOffset,
+		state.scrollOffset + state.maxVisible,
+	);
+
+	for (const [i, entry] of visible.entries()) {
+		const globalIndex = state.scrollOffset + i;
+		const isSelected = globalIndex === state.selectedIndex;
+		const isExpanded = state.expanded.has(globalIndex);
+		const cursor = isSelected ? "▸" : " ";
+	const disabled = entry.disabled ? " [disabled]" : "";
+	const model = entry.model ? ` (${entry.model})` : "";
+
+	const summary = `${cursor} ${sourceIcon(entry.source)} ${entry.name}${model}${disabled}`;
+	lines.push(truncate(summary, width));
+
+	if (isExpanded) {
+		const desc = `    ${entry.description}`;
+		lines.push(truncate(desc, width));
+		const meta: string[] = [`    source: ${sourceLabel(entry.source)}`];
+		if (entry.model) meta.push(`model: ${entry.model}`);
+		if (entry.thinking) meta.push(`thinking: ${entry.thinking}`);
+		if (entry.loadMode) meta.push(`loadMode: ${entry.loadMode}`);
+		if (entry.contextMode) meta.push(`context: ${entry.contextMode}`);
+		meta.push(`file: ${entry.filePath}`);
+		lines.push(truncate(meta.join(" · "), width));
+		lines.push(truncate("─".repeat(Math.min(width - 4, 50)), width));
+	}
+	}
+
+	if (state.scrollOffset + state.maxVisible < state.entries.length) {
+		const remaining = state.entries.length - state.scrollOffset - state.maxVisible;
+		lines.push(truncate(`  … +${remaining} more`, width));
+	}
+
+	return lines;
+}