pi-crew 0.1.49 → 0.2.0

package/src/runtime/auto-resume.ts

@@ -0,0 +1,100 @@
+/**
+ * Auto-resume controller with settle window — prevents premature context injection
+ * by waiting for Pi's setTimeout(0) + setTimeout(100) to drain before resuming.
+ *
+ * Distilled from pi-autoresearch's auto-resume / settle-window pattern.
+ */
+
+/** Time to wait before auto-resuming (ms). Outlasts Pi's setTimeout(0) + setTimeout(100). */
+export const SETTLE_WINDOW_MS = 800;
+
+/** Maximum number of auto-resume turns before forcing a stop. */
+export const MAX_AUTORESUME_TURNS = 20;
+
+/**
+ * Controller for scheduling auto-resume actions with a settle window.
+ *
+ * The settle window ensures that pending async operations (e.g., Pi's
+ * internal setTimeout(0) and setTimeout(100) callbacks) have completed
+ * before the resume callback fires.
+ */
+export class AutoResumeController {
+	private timerId: ReturnType<typeof setTimeout> | null = null;
+	private turnCount = 0;
+	private cancelled = false;
+
+	/**
+	 * Get the current auto-resume turn count.
+	 */
+	get currentTurnCount(): number {
+		return this.turnCount;
+	}
+
+	/**
+	 * Get the maximum allowed auto-resume turns.
+	 */
+	get maxTurns(): number {
+		return MAX_AUTORESUME_TURNS;
+	}
+
+	/**
+	 * Schedule an auto-resume callback after the settle window elapses.
+	 *
+	 * If a resume is already pending, it is cancelled first (debounce behavior).
+	 * If the turn limit has been reached, the callback is not scheduled.
+	 *
+	 * @param message - Description of why the resume is being scheduled
+	 * @param callback - Function to call after the settle window
+	 */
+	scheduleResume(message: string, callback: () => void): void {
+		// Cancel any existing pending resume
+		this.cancelResume();
+
+		// Enforce turn limit
+		if (this.turnCount >= MAX_AUTORESUME_TURNS) {
+			return;
+		}
+
+		this.cancelled = false;
+		this.turnCount++;
+
+		this.timerId = setTimeout(() => {
+			if (!this.cancelled) {
+				this.timerId = null;
+				callback();
+			}
+		}, SETTLE_WINDOW_MS);
+
+		// Prevent the timer from keeping the process alive
+		if (this.timerId && typeof this.timerId === "object" && "unref" in this.timerId) {
+			this.timerId.unref();
+		}
+	}
+
+	/**
+	 * Cancel any pending auto-resume.
+	 */
+	cancelResume(): void {
+		if (this.timerId !== null) {
+			clearTimeout(this.timerId);
+			this.timerId = null;
+		}
+		this.cancelled = true;
+	}
+
+	/**
+	 * Check whether an auto-resume is currently pending.
+	 */
+	hasPendingResume(): boolean {
+		return this.timerId !== null;
+	}
+
+	/**
+	 * Reset the turn counter. Called when a new agent starts processing
+	 * to allow a fresh set of auto-resume turns.
+	 */
+	resetTurnCount(): void {
+		this.turnCount = 0;
+		this.cancelled = false;
+	}
+}

package/src/runtime/background-runner.ts

@@ -4,7 +4,17 @@ import { appendEvent } from "../state/event-log.ts";
 import { loadRunManifestById, saveRunManifest, updateRunStatus } from "../state/state-store.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import { loadConfig } from "../config/config.ts";
-import { executeTeamRun } from "./team-runner.ts";
+// Heavy runtime — lazy-loaded to avoid pulling team-runner into background-runner
+// at module load time. Only needed when a background run actually starts.
+import type { executeTeamRun as ExecuteTeamRunFn } from "./team-runner.ts";
+let _cachedExecuteTeamRun: typeof ExecuteTeamRunFn | undefined;
+async function executeTeamRun(...args: Parameters<typeof ExecuteTeamRunFn>): Promise<Awaited<ReturnType<typeof ExecuteTeamRunFn>>> {
+	if (!_cachedExecuteTeamRun) {
+		const mod = await import("./team-runner.ts");
+		_cachedExecuteTeamRun = mod.executeTeamRun;
+	}
+	return _cachedExecuteTeamRun(...args);
+}
 import { resolveCrewRuntime, runtimeResolutionState } from "./runtime-resolver.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
 import { expandParallelResearchWorkflow } from "./parallel-research.ts";

package/src/runtime/cancellation-token.ts

@@ -1,89 +1,89 @@
-import { CrewCancellationError, type CancellationReason, cancellationReasonFromUnknown } from "./cancellation.ts";
-
-export interface CancellationTokenState {
-	aborted: boolean;
-	reason?: CancellationReason;
-	lastHeartbeatAt?: string;
-	lastHeartbeatStage?: string;
-}
-
-export interface CancellationTokenOptions {
-	signal?: AbortSignal;
-	onHeartbeat?: (state: CancellationTokenState) => void;
-	now?: () => Date;
-}
-
-export class CancellationToken {
-	readonly #controller = new AbortController();
-	readonly #onHeartbeat?: (state: CancellationTokenState) => void;
-	readonly #now: () => Date;
-	#reason?: CancellationReason;
-	#lastHeartbeatAt?: string;
-	#lastHeartbeatStage?: string;
-
-	constructor(options: CancellationTokenOptions = {}) {
-		this.#onHeartbeat = options.onHeartbeat;
-		this.#now = options.now ?? (() => new Date());
-		if (options.signal?.aborted) this.abort(options.signal.reason);
-		else if (options.signal) options.signal.addEventListener("abort", () => this.abort(options.signal?.reason), { once: true });
-	}
-
-	get signal(): AbortSignal { return this.#controller.signal; }
-	get aborted(): boolean { return this.#controller.signal.aborted; }
-	get reason(): CancellationReason | undefined { return this.#reason; }
-	get lastHeartbeatAt(): string | undefined { return this.#lastHeartbeatAt; }
-	get lastHeartbeatStage(): string | undefined { return this.#lastHeartbeatStage; }
-
-	heartbeat(stage?: string): CancellationTokenState {
-		this.throwIfCancelled();
-		this.#lastHeartbeatAt = this.#now().toISOString();
-		this.#lastHeartbeatStage = stage;
-		const state = this.state();
-		this.#onHeartbeat?.(state);
-		return state;
-	}
-
-	throwIfCancelled(): void {
-		if (this.aborted) throw new CrewCancellationError(this.#reason ?? cancellationReasonFromUnknown(this.#controller.signal.reason));
-	}
-
-	abort(reason?: unknown): void {
-		if (this.aborted) return;
-		this.#reason = cancellationReasonFromUnknown(reason);
-		this.#controller.abort(this.#reason);
-	}
-
-	wait(ms: number): Promise<void> {
-		this.throwIfCancelled();
-		if (ms <= 0) return Promise.resolve();
-		return new Promise((resolve, reject) => {
-			let timeout: NodeJS.Timeout | undefined;
-			const cleanup = (): void => {
-				if (timeout) clearTimeout(timeout);
-				this.signal.removeEventListener("abort", onAbort);
-			};
-			const onAbort = (): void => {
-				cleanup();
-				reject(new CrewCancellationError(this.#reason ?? cancellationReasonFromUnknown(this.signal.reason)));
-			};
-			timeout = setTimeout(() => {
-				cleanup();
-				resolve();
-			}, ms);
-			this.signal.addEventListener("abort", onAbort, { once: true });
-		});
-	}
-
-	state(): CancellationTokenState {
-		return {
-			aborted: this.aborted,
-			...(this.#reason ? { reason: this.#reason } : {}),
-			...(this.#lastHeartbeatAt ? { lastHeartbeatAt: this.#lastHeartbeatAt } : {}),
-			...(this.#lastHeartbeatStage ? { lastHeartbeatStage: this.#lastHeartbeatStage } : {}),
-		};
-	}
-}
-
-export function createCancellationToken(options: CancellationTokenOptions = {}): CancellationToken {
-	return new CancellationToken(options);
-}
+import { CrewCancellationError, type CancellationReason, cancellationReasonFromUnknown } from "./cancellation.ts";
+
+export interface CancellationTokenState {
+	aborted: boolean;
+	reason?: CancellationReason;
+	lastHeartbeatAt?: string;
+	lastHeartbeatStage?: string;
+}
+
+export interface CancellationTokenOptions {
+	signal?: AbortSignal;
+	onHeartbeat?: (state: CancellationTokenState) => void;
+	now?: () => Date;
+}
+
+export class CancellationToken {
+	readonly #controller = new AbortController();
+	readonly #onHeartbeat?: (state: CancellationTokenState) => void;
+	readonly #now: () => Date;
+	#reason?: CancellationReason;
+	#lastHeartbeatAt?: string;
+	#lastHeartbeatStage?: string;
+
+	constructor(options: CancellationTokenOptions = {}) {
+		this.#onHeartbeat = options.onHeartbeat;
+		this.#now = options.now ?? (() => new Date());
+		if (options.signal?.aborted) this.abort(options.signal.reason);
+		else if (options.signal) options.signal.addEventListener("abort", () => this.abort(options.signal?.reason), { once: true });
+	}
+
+	get signal(): AbortSignal { return this.#controller.signal; }
+	get aborted(): boolean { return this.#controller.signal.aborted; }
+	get reason(): CancellationReason | undefined { return this.#reason; }
+	get lastHeartbeatAt(): string | undefined { return this.#lastHeartbeatAt; }
+	get lastHeartbeatStage(): string | undefined { return this.#lastHeartbeatStage; }
+
+	heartbeat(stage?: string): CancellationTokenState {
+		this.throwIfCancelled();
+		this.#lastHeartbeatAt = this.#now().toISOString();
+		this.#lastHeartbeatStage = stage;
+		const state = this.state();
+		this.#onHeartbeat?.(state);
+		return state;
+	}
+
+	throwIfCancelled(): void {
+		if (this.aborted) throw new CrewCancellationError(this.#reason ?? cancellationReasonFromUnknown(this.#controller.signal.reason));
+	}
+
+	abort(reason?: unknown): void {
+		if (this.aborted) return;
+		this.#reason = cancellationReasonFromUnknown(reason);
+		this.#controller.abort(this.#reason);
+	}
+
+	wait(ms: number): Promise<void> {
+		this.throwIfCancelled();
+		if (ms <= 0) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			let timeout: NodeJS.Timeout | undefined;
+			const cleanup = (): void => {
+				if (timeout) clearTimeout(timeout);
+				this.signal.removeEventListener("abort", onAbort);
+			};
+			const onAbort = (): void => {
+				cleanup();
+				reject(new CrewCancellationError(this.#reason ?? cancellationReasonFromUnknown(this.signal.reason)));
+			};
+			timeout = setTimeout(() => {
+				cleanup();
+				resolve();
+			}, ms);
+			this.signal.addEventListener("abort", onAbort, { once: true });
+		});
+	}
+
+	state(): CancellationTokenState {
+		return {
+			aborted: this.aborted,
+			...(this.#reason ? { reason: this.#reason } : {}),
+			...(this.#lastHeartbeatAt ? { lastHeartbeatAt: this.#lastHeartbeatAt } : {}),
+			...(this.#lastHeartbeatStage ? { lastHeartbeatStage: this.#lastHeartbeatStage } : {}),
+		};
+	}
+}
+
+export function createCancellationToken(options: CancellationTokenOptions = {}): CancellationToken {
+	return new CancellationToken(options);
+}

package/src/runtime/cancellation.ts

@@ -1,61 +1,61 @@
-import type { OperationTerminalEvidence } from "../state/types.ts";
-
-export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
-
-export interface CancellationReason {
-	code: CancellationReasonCode;
-	message: string;
-	cause?: unknown;
-}
-
-export function buildSyntheticTerminalEvidence(
-	operation: "worker" | "tool" | "model",
-	reason: CancellationReason,
-	startedAt?: string,
-): OperationTerminalEvidence {
-	return { operation, status: "cancelled", startedAt, finishedAt: new Date().toISOString(), reason };
-}
-
-const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
-
-export class CrewCancellationError extends Error {
-	readonly reason: CancellationReason;
-
-	constructor(reason: CancellationReason) {
-		super(reason.message);
-		this.name = "CrewCancellationError";
-		this.reason = reason;
-	}
-}
-
-function reasonFromString(value: string): CancellationReason {
-	const trimmed = value.trim();
-	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
-	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
-}
-
-export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
-	if (value instanceof CrewCancellationError) return value.reason;
-	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
-	if (typeof value === "string") return reasonFromString(value);
-	if (value && typeof value === "object" && !Array.isArray(value)) {
-		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
-		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
-		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
-		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
-		return { code, message, cause: record.cause ?? value };
-	}
-	return { code: "caller_cancelled", message: "Cancelled by caller." };
-}
-
-export function cancellationReasonFromSignal(signal: AbortSignal | undefined): CancellationReason {
-	return cancellationReasonFromUnknown(signal?.reason);
-}
-
-export function cancellationErrorFromSignal(signal: AbortSignal | undefined): CrewCancellationError {
-	return new CrewCancellationError(cancellationReasonFromSignal(signal));
-}
-
-export function throwIfCancelled(signal: AbortSignal | undefined): void {
-	if (signal?.aborted) throw cancellationErrorFromSignal(signal);
-}
+import type { OperationTerminalEvidence } from "../state/types.ts";
+
+export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
+
+export interface CancellationReason {
+	code: CancellationReasonCode;
+	message: string;
+	cause?: unknown;
+}
+
+export function buildSyntheticTerminalEvidence(
+	operation: "worker" | "tool" | "model",
+	reason: CancellationReason,
+	startedAt?: string,
+): OperationTerminalEvidence {
+	return { operation, status: "cancelled", startedAt, finishedAt: new Date().toISOString(), reason };
+}
+
+const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+
+export class CrewCancellationError extends Error {
+	readonly reason: CancellationReason;
+
+	constructor(reason: CancellationReason) {
+		super(reason.message);
+		this.name = "CrewCancellationError";
+		this.reason = reason;
+	}
+}
+
+function reasonFromString(value: string): CancellationReason {
+	const trimmed = value.trim();
+	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
+	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
+}
+
+export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
+	if (value instanceof CrewCancellationError) return value.reason;
+	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
+	if (typeof value === "string") return reasonFromString(value);
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
+		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
+		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
+		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
+		return { code, message, cause: record.cause ?? value };
+	}
+	return { code: "caller_cancelled", message: "Cancelled by caller." };
+}
+
+export function cancellationReasonFromSignal(signal: AbortSignal | undefined): CancellationReason {
+	return cancellationReasonFromUnknown(signal?.reason);
+}
+
+export function cancellationErrorFromSignal(signal: AbortSignal | undefined): CrewCancellationError {
+	return new CrewCancellationError(cancellationReasonFromSignal(signal));
+}
+
+export function throwIfCancelled(signal: AbortSignal | undefined): void {
+	if (signal?.aborted) throw cancellationErrorFromSignal(signal);
+}

package/src/runtime/capability-inventory.ts

@@ -1,116 +1,116 @@
-import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
-import { discoverAgents } from "../agents/discover-agents.ts";
-import { discoverTeams } from "../teams/discover-teams.ts";
-import { discoverWorkflows } from "../workflows/discover-workflows.ts";
-import { discoverSkills } from "../skills/discover-skills.ts";
-import type { PiTeamsConfig } from "../config/config.ts";
-
-export type CapabilityKind = "team" | "workflow" | "agent" | "skill" | "tool" | "runtime";
-export type CapabilitySource = "builtin" | "project" | "user" | "package" | "git";
-export type CapabilityState = "active" | "disabled" | "shadowed" | "missing";
-
-export interface CapabilityItem {
-	id: string;
-	kind: CapabilityKind;
-	name: string;
-	description: string;
-	source: CapabilitySource;
-	path?: string;
-	state: CapabilityState;
-	disabledReason?: string;
-	shadowedBy?: string;
-}
-
-function normalizeAgents(agents: AgentConfig[], source: CapabilitySource, disabledIds: Set<string>): CapabilityItem[] {
-	return agents.map((agent) => {
-		const id = `agent:${agent.name}`;
-		const configDisabled = disabledIds.has(id);
-		const agentDisabled = agent.disabled || configDisabled;
-		return {
-			id,
-			kind: "agent" as const,
-			name: agent.name,
-			description: agent.description,
-			source,
-			path: agent.filePath,
-			state: agentDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : agent.disabled ? "disabled in config" : undefined,
-		};
-	});
-}
-
-function normalizeSkills(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
-	const skills = discoverSkills(cwd);
-	return skills.map((skill) => {
-		const id = `skill:${skill.name}`;
-		const configDisabled = disabledIds.has(id);
-		return {
-			id,
-			kind: "skill" as const,
-			name: skill.name,
-			description: skill.description,
-			source: skill.source as CapabilitySource,
-			path: skill.path,
-			state: configDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : undefined,
-		};
-	});
-}
-
-function normalizeTeams(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
-	const result = discoverTeams(cwd);
-	return [...result.builtin, ...result.user, ...result.project].map((team) => {
-		const id = `team:${team.name}`;
-		const configDisabled = disabledIds.has(id);
-		return {
-			id,
-			kind: "team" as const,
-			name: team.name,
-			description: team.description,
-			source: team.source as CapabilitySource,
-			path: team.filePath,
-			state: configDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : undefined,
-		};
-	});
-}
-
-function normalizeWorkflows(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
-	const result = discoverWorkflows(cwd);
-	return [...result.builtin, ...result.user, ...result.project].map((workflow) => {
-		const id = `workflow:${workflow.name}`;
-		const configDisabled = disabledIds.has(id);
-		return {
-			id,
-			kind: "workflow" as const,
-			name: workflow.name,
-			description: workflow.description,
-			source: workflow.source as CapabilitySource,
-			path: workflow.filePath,
-			state: configDisabled ? "disabled" : "active",
-			disabledReason: configDisabled ? "disabled by policy" : undefined,
-		};
-	});
-}
-
-export function buildCapabilityInventory(cwd: string, config?: PiTeamsConfig): CapabilityItem[] {
-	const disabledIds = new Set<string>(config?.policy?.disabledCapabilities ?? []);
-	const agents = discoverAgents(cwd);
-	const items = [
-		...normalizeTeams(cwd, disabledIds),
-		...normalizeWorkflows(cwd, disabledIds),
-		...normalizeAgents([...agents.builtin, ...agents.user, ...agents.project], "builtin", disabledIds),
-		...normalizeSkills(cwd, disabledIds),
-	];
-
-	// Mark shadowed resources: project/user items with same kind:name as a builtin
-	const builtinNames = new Set(items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`));
-	for (const item of items) {
-		if (item.source !== "builtin" && item.source !== "package" && builtinNames.has(`${item.kind}:${item.name}`)) {
-			item.state = "shadowed";
-			item.shadowedBy = `builtin:${item.kind}:${item.name}`;
-		}
-	}
-
-	return items.sort((a, b) => a.id.localeCompare(b.id));
-}
+import type { AgentConfig, ResourceSource } from "../agents/agent-config.ts";
+import { discoverAgents } from "../agents/discover-agents.ts";
+import { discoverTeams } from "../teams/discover-teams.ts";
+import { discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { discoverSkills } from "../skills/discover-skills.ts";
+import type { PiTeamsConfig } from "../config/config.ts";
+
+export type CapabilityKind = "team" | "workflow" | "agent" | "skill" | "tool" | "runtime";
+export type CapabilitySource = "builtin" | "project" | "user" | "package" | "git";
+export type CapabilityState = "active" | "disabled" | "shadowed" | "missing";
+
+export interface CapabilityItem {
+	id: string;
+	kind: CapabilityKind;
+	name: string;
+	description: string;
+	source: CapabilitySource;
+	path?: string;
+	state: CapabilityState;
+	disabledReason?: string;
+	shadowedBy?: string;
+}
+
+function normalizeAgents(agents: AgentConfig[], source: CapabilitySource, disabledIds: Set<string>): CapabilityItem[] {
+	return agents.map((agent) => {
+		const id = `agent:${agent.name}`;
+		const configDisabled = disabledIds.has(id);
+		const agentDisabled = agent.disabled || configDisabled;
+		return {
+			id,
+			kind: "agent" as const,
+			name: agent.name,
+			description: agent.description,
+			source,
+			path: agent.filePath,
+			state: agentDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : agent.disabled ? "disabled in config" : undefined,
+		};
+	});
+}
+
+function normalizeSkills(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const skills = discoverSkills(cwd);
+	return skills.map((skill) => {
+		const id = `skill:${skill.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "skill" as const,
+			name: skill.name,
+			description: skill.description,
+			source: skill.source as CapabilitySource,
+			path: skill.path,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+function normalizeTeams(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const result = discoverTeams(cwd);
+	return [...result.builtin, ...result.user, ...result.project].map((team) => {
+		const id = `team:${team.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "team" as const,
+			name: team.name,
+			description: team.description,
+			source: team.source as CapabilitySource,
+			path: team.filePath,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+function normalizeWorkflows(cwd: string, disabledIds: Set<string>): CapabilityItem[] {
+	const result = discoverWorkflows(cwd);
+	return [...result.builtin, ...result.user, ...result.project].map((workflow) => {
+		const id = `workflow:${workflow.name}`;
+		const configDisabled = disabledIds.has(id);
+		return {
+			id,
+			kind: "workflow" as const,
+			name: workflow.name,
+			description: workflow.description,
+			source: workflow.source as CapabilitySource,
+			path: workflow.filePath,
+			state: configDisabled ? "disabled" : "active",
+			disabledReason: configDisabled ? "disabled by policy" : undefined,
+		};
+	});
+}
+
+export function buildCapabilityInventory(cwd: string, config?: PiTeamsConfig): CapabilityItem[] {
+	const disabledIds = new Set<string>(config?.policy?.disabledCapabilities ?? []);
+	const agents = discoverAgents(cwd);
+	const items = [
+		...normalizeTeams(cwd, disabledIds),
+		...normalizeWorkflows(cwd, disabledIds),
+		...normalizeAgents([...agents.builtin, ...agents.user, ...agents.project], "builtin", disabledIds),
+		...normalizeSkills(cwd, disabledIds),
+	];
+
+	// Mark shadowed resources: project/user items with same kind:name as a builtin
+	const builtinNames = new Set(items.filter((item) => item.source === "builtin" || item.source === "package").map((item) => `${item.kind}:${item.name}`));
+	for (const item of items) {
+		if (item.source !== "builtin" && item.source !== "package" && builtinNames.has(`${item.kind}:${item.name}`)) {
+			item.state = "shadowed";
+			item.shadowedBy = `builtin:${item.kind}:${item.name}`;
+		}
+	}
+
+	return items.sort((a, b) => a.id.localeCompare(b.id));
+}