@narumitw/pi-subagents 2.1.4 → 3.0.0

package/src/stateful-render.ts

@@ -1,318 +0,0 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import {
-	COLLAPSED_LIST_LIMIT,
-	expansionHint,
-	type RenderStatus,
-	recordList,
-	recordValue,
-	renderFallbackResult,
-	safeBlock,
-	safeLine,
-	statusBadge,
-	stringValue,
-	type ToolRendererContext,
-	textResult,
-	toolHeader,
-} from "./render-common.js";
-
-export type StatefulRenderTool = "spawn" | "send" | "await" | "manage" | "mailbox";
-
-export function createStatefulToolRenderer(tool: StatefulRenderTool) {
-	return {
-		renderCall(args: unknown, theme: Theme) {
-			return renderStatefulCall(tool, recordValue(args) ?? {}, theme);
-		},
-		renderResult(
-			result: AgentToolResult<unknown>,
-			options: ToolRenderResultOptions,
-			theme: Theme,
-			context: ToolRendererContext<unknown>,
-		) {
-			return renderStatefulResult(tool, result, options, theme, context);
-		},
-	};
-}
-
-function renderStatefulCall(tool: StatefulRenderTool, args: Record<string, unknown>, theme: Theme) {
-	if (tool === "spawn") {
-		const metadata = [
-			`[${safeLine(args.agentScope, "user", 64)}]`,
-			"detached",
-			safeLine(args.workspaceMode, "shared", 64),
-		];
-		if (typeof args.thinkingLevel === "string") metadata.push(`thinking:${args.thinkingLevel}`);
-		if (typeof args.timeoutMs === "number") metadata.push(`timeout:${args.timeoutMs}ms`);
-		if (typeof args.idleTimeoutMs === "number") metadata.push(`idle:${args.idleTimeoutMs}ms`);
-		if (typeof args.maxTurns === "number") metadata.push(`turns:${args.maxTurns}`);
-		if (typeof args.maxToolCalls === "number") metadata.push(`tools:${args.maxToolCalls}`);
-		return new Text(
-			[
-				toolHeader(theme, "subagent_spawn", args.agent, metadata),
-				`  ${theme.fg("dim", safeLine(args.task, "...", 2 * 1024))}`,
-			].join("\n"),
-			0,
-			0,
-		);
-	}
-	if (tool === "send") {
-		const metadata = ["follow-up"];
-		if (typeof args.timeoutMs === "number") metadata.push(`timeout:${args.timeoutMs}ms`);
-		if (typeof args.idleTimeoutMs === "number") metadata.push(`idle:${args.idleTimeoutMs}ms`);
-		if (typeof args.maxTurns === "number") metadata.push(`turns:${args.maxTurns}`);
-		if (typeof args.maxToolCalls === "number") metadata.push(`tools:${args.maxToolCalls}`);
-		return new Text(
-			[
-				toolHeader(theme, "subagent_send", args.agentId, metadata),
-				`  ${theme.fg("dim", safeLine(args.task, "...", 2 * 1024))}`,
-			].join("\n"),
-			0,
-			0,
-		);
-	}
-	if (tool === "await") {
-		const metadata = ["blocking"];
-		if (typeof args.timeoutMs === "number") metadata.push(`timeout:${args.timeoutMs}ms`);
-		return new Text(toolHeader(theme, "subagent_await", args.agentId, metadata), 0, 0);
-	}
-	if (tool === "manage") {
-		const metadata: string[] = [];
-		if (typeof args.agentId === "string") metadata.push(`id:${safeLine(args.agentId, "", 256)}`);
-		if (args.subtree === true) metadata.push("subtree");
-		return new Text(toolHeader(theme, "subagent_manage", args.action, metadata), 0, 0);
-	}
-	const metadata = [`id:${safeLine(args.agentId, "...", 256)}`];
-	if (args.action === "read") {
-		metadata.push(args.acknowledge === false ? "leave unread" : "acknowledge");
-	}
-	const lines = [toolHeader(theme, "subagent_mailbox", args.action, metadata)];
-	if (args.action === "send") {
-		lines.push(`  ${theme.fg("dim", safeLine(args.message, "...", 2 * 1024))}`);
-	}
-	return new Text(lines.join("\n"), 0, 0);
-}
-
-function renderStatefulResult(
-	tool: StatefulRenderTool,
-	result: AgentToolResult<unknown>,
-	options: ToolRenderResultOptions,
-	theme: Theme,
-	context: ToolRendererContext<unknown>,
-) {
-	const details = recordValue(result.details);
-	const args = recordValue(context.args) ?? {};
-	if (!details) return renderFallbackResult(result, options, theme, context.isError);
-	if (tool === "spawn" || tool === "send" || tool === "await") {
-		const agent = recordValue(details.agent);
-		if (!agent) return renderFallbackResult(result, options, theme, context.isError);
-		if (tool === "await" && details.timedOut === true) {
-			return new Text(renderAwaitTimeout(agent, result, options.expanded, theme), 0, 0);
-		}
-		return new Text(renderAgentResult(agent, result, options.expanded, theme), 0, 0);
-	}
-	if (tool === "manage") {
-		return new Text(renderManageResult(args, details, result, options.expanded, theme), 0, 0);
-	}
-	return new Text(renderMailboxResult(args, details, options.expanded, theme), 0, 0);
-}
-
-function renderAgentResult(
-	agent: Record<string, unknown>,
-	result: AgentToolResult<unknown>,
-	expanded: boolean,
-	theme: Theme,
-): string {
-	const state = safeLine(agent.state, "unknown", 128);
-	const lines = [
-		`${statusBadge(theme, lifecycleStatus(state))} · ${theme.fg("accent", safeLine(agent.id, "agent", 256))} · ${theme.fg("toolOutput", safeLine(agent.agent, "subagent", 256))} · ${theme.fg("muted", state)}`,
-	];
-	const thinking = stringValue(agent.thinkingLevel);
-	const timeout =
-		typeof agent.currentTimeoutMs === "number"
-			? agent.currentTimeoutMs
-			: typeof agent.timeoutMs === "number"
-				? agent.timeoutMs
-				: 0;
-	const idleTimeout =
-		typeof agent.currentIdleTimeoutMs === "number"
-			? agent.currentIdleTimeoutMs
-			: typeof agent.idleTimeoutMs === "number"
-				? agent.idleTimeoutMs
-				: 0;
-	const maxTurns =
-		typeof agent.currentMaxTurns === "number"
-			? agent.currentMaxTurns
-			: typeof agent.maxTurns === "number"
-				? agent.maxTurns
-				: 0;
-	const maxToolCalls =
-		typeof agent.currentMaxToolCalls === "number"
-			? agent.currentMaxToolCalls
-			: typeof agent.maxToolCalls === "number"
-				? agent.maxToolCalls
-				: 0;
-	const unread = typeof agent.unreadMessages === "number" ? agent.unreadMessages : 0;
-	if (thinking || timeout || idleTimeout || maxTurns || maxToolCalls || unread > 0) {
-		lines.push(
-			theme.fg(
-				"dim",
-				[
-					thinking && `thinking:${safeLine(thinking, "", 128)}`,
-					timeout && `timeout:${timeout}ms`,
-					idleTimeout && `idle:${idleTimeout}ms`,
-					maxTurns && `turns:${maxTurns}`,
-					maxToolCalls && `tools:${maxToolCalls}`,
-					unread > 0 && `unread:${unread}`,
-				]
-					.filter(Boolean)
-					.join(" · "),
-			),
-		);
-	}
-	if (expanded) {
-		const task = safeBlock(agent.currentTask, "", 2 * 1024).trim();
-		const error = safeBlock(agent.error, "", 2 * 1024).trim();
-		if (task) lines.push(theme.fg("dim", `task: ${task}`));
-		if (error) lines.push(theme.fg("error", `error: ${error}`));
-		const content = safeBlock(textResult(result), "", 8 * 1024).trim();
-		if (content) lines.push(theme.fg("toolOutput", content));
-	} else lines.push(expansionHint());
-	return lines.join("\n");
-}
-
-function renderAwaitTimeout(
-	agent: Record<string, unknown>,
-	result: AgentToolResult<unknown>,
-	expanded: boolean,
-	theme: Theme,
-): string {
-	const lines = [
-		`${statusBadge(theme, "running")} · ${theme.fg("accent", safeLine(agent.id, "agent", 256))} · ${theme.fg("warning", "wait timed out")} · ${theme.fg("muted", safeLine(agent.state, "unknown", 128))}`,
-	];
-	if (expanded) {
-		const content = safeBlock(textResult(result), "", 8 * 1024).trim();
-		if (content) lines.push(theme.fg("toolOutput", content));
-	} else lines.push(expansionHint());
-	return lines.join("\n");
-}
-
-function renderManageResult(
-	args: Record<string, unknown>,
-	details: Record<string, unknown>,
-	result: AgentToolResult<unknown>,
-	expanded: boolean,
-	theme: Theme,
-): string {
-	const action = safeLine(args.action, "action", 128);
-	const agents = recordList(details.agents);
-	const primary = recordValue(details.agent);
-	if (action === "list") {
-		const lines = [
-			`${statusBadge(theme, "completed")} · list · ${agents.length} agent${agents.length === 1 ? "" : "s"}`,
-		];
-		const selected = expanded ? agents : agents.slice(0, COLLAPSED_LIST_LIMIT);
-		for (const agent of selected) lines.push(formatAgentLine(agent, theme, expanded));
-		if (agents.length === 0) lines.push(theme.fg("muted", "(no retained agents)"));
-		if (agents.length > selected.length)
-			lines.push(theme.fg("muted", `… ${agents.length - selected.length} omitted`));
-		if (!expanded && agents.length > 0) lines.push(expansionHint());
-		return lines.join("\n");
-	}
-
-	const subtree = args.subtree === true;
-	const affected = subtree ? agents.length : agents.length > 0 ? agents.length : primary ? 1 : 0;
-	const status: RenderStatus = action === "interrupt" ? "interrupted" : "closed";
-	const lines = [
-		`${statusBadge(theme, status)} · ${affected} agent${affected === 1 ? "" : "s"}${subtree ? theme.fg("muted", " · subtree") : ""}`,
-	];
-	const selected = agents.length > 0 ? agents : !subtree && primary ? [primary] : [];
-	for (const agent of expanded ? selected : selected.slice(0, COLLAPSED_LIST_LIMIT)) {
-		lines.push(formatAgentLine(agent, theme, expanded));
-	}
-	if (selected.length === 0) {
-		const content = safeBlock(textResult(result), "(no output)", 8 * 1024);
-		lines.push(theme.fg("toolOutput", content));
-	}
-	if (!expanded && selected.length > 0) lines.push(expansionHint());
-	return lines.join("\n");
-}
-
-function renderMailboxResult(
-	args: Record<string, unknown>,
-	details: Record<string, unknown>,
-	expanded: boolean,
-	theme: Theme,
-): string {
-	const action = safeLine(args.action, "action", 64);
-	if (action === "send") {
-		const message = recordValue(details.message);
-		if (!message) return `${statusBadge(theme, "completed")} · Queued message`;
-		const lines = [
-			`${theme.fg("success", "✓")} ${theme.fg("success", "Queued")} · ${theme.fg("accent", safeLine(message.id, "message", 256))} · ${theme.fg("muted", `to ${safeLine(message.recipientId, safeLine(args.agentId), 256)}`)}`,
-		];
-		if (expanded) {
-			lines.push(theme.fg("toolOutput", safeBlock(message.content, "(empty message)", 2 * 1024)));
-		} else lines.push(expansionHint());
-		return lines.join("\n");
-	}
-
-	const messages = recordList(details.messages);
-	const acknowledged = args.acknowledge === false ? "left unread" : "acknowledged";
-	const lines = [
-		`${statusBadge(theme, "completed")} · ${messages.length} message${messages.length === 1 ? "" : "s"} · ${acknowledged}`,
-	];
-	const selected = expanded ? messages : messages.slice(0, COLLAPSED_LIST_LIMIT);
-	for (const message of selected) {
-		const content = expanded
-			? safeBlock(message.content, "(empty message)", 2 * 1024)
-			: safeLine(message.content, "(empty message)", 512);
-		lines.push(
-			`${theme.fg("muted", "• ")}${theme.fg("accent", safeLine(message.id, "message", 256))} ${theme.fg("muted", `from ${safeLine(message.senderId, "unknown", 256)}: `)}${theme.fg("toolOutput", content)}`,
-		);
-	}
-	if (messages.length === 0) lines.push(theme.fg("muted", "(no unread messages)"));
-	if (messages.length > selected.length)
-		lines.push(theme.fg("muted", `… ${messages.length - selected.length} omitted`));
-	if (!expanded && messages.length > 0) lines.push(expansionHint());
-	return lines.join("\n");
-}
-
-function formatAgentLine(agent: Record<string, unknown>, theme: Theme, expanded: boolean): string {
-	const unread = typeof agent.unreadMessages === "number" ? agent.unreadMessages : 0;
-	const lines = [
-		`${theme.fg("muted", "• ")}${theme.fg("accent", safeLine(agent.id, "agent", 256))} ${theme.fg("toolOutput", safeLine(agent.agent, "subagent", 256))} ${theme.fg("muted", safeLine(agent.state, "unknown", 128))}${unread > 0 ? theme.fg("warning", ` · unread:${unread}`) : ""}`,
-	];
-	if (expanded) {
-		const task = safeBlock(agent.currentTask, "", 2 * 1024).trim();
-		const error = safeBlock(agent.error, "", 2 * 1024).trim();
-		if (task) lines.push(`  ${theme.fg("dim", `task: ${task}`)}`);
-		if (error) lines.push(`  ${theme.fg("error", `error: ${error}`)}`);
-	}
-	return lines.join("\n");
-}
-
-function lifecycleStatus(state: string): RenderStatus {
-	switch (state) {
-		case "starting":
-			return "starting";
-		case "running":
-			return "running";
-		case "idle":
-			return "idle";
-		case "partial":
-		case "blocked":
-		case "needs-input":
-		case "abstained":
-		case "stale":
-			return "warning";
-		case "failed":
-			return "failed";
-		case "interrupted":
-			return "interrupted";
-		case "closed":
-			return "closed";
-		default:
-			return "completed";
-	}
-}

package/src/stateful-safety.ts

@@ -1,47 +0,0 @@
-import { realpathSync } from "node:fs";
-import * as path from "node:path";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { discoverAgents } from "./agents/discovery.js";
-import type { AgentScope, SubagentSettings } from "./agents/types.js";
-import { safeTerminalLine } from "./safe-text.js";
-import { readSubagentSettings } from "./settings-reader.js";
-
-export function isWriteCapable(tools: string[] | undefined): boolean {
-	if (!tools) return true;
-	return tools.some((tool) => ["bash", "write", "edit"].includes(tool));
-}
-
-export async function confirmProjectAgent(
-	name: string,
-	scope: AgentScope,
-	confirm: boolean,
-	ctx: ExtensionContext,
-	cwd: string,
-	settings?: SubagentSettings,
-): Promise<void> {
-	if (scope !== "project" && scope !== "both") return;
-	if (!isSameCwd(cwd, ctx.cwd)) {
-		throw new Error("Project-local subagent definitions cannot run with an overridden cwd");
-	}
-	if (!ctx.isProjectTrusted()) {
-		throw new Error("Project-local subagent definitions require a trusted project");
-	}
-	const discovery = discoverAgents(cwd, scope, settings ?? readSubagentSettings());
-	const agent = discovery.agents.find((candidate) => candidate.name === name);
-	if (agent?.source !== "project") return;
-	if (confirm && ctx.hasUI) {
-		const approved = await ctx.ui.confirm(
-			"Run project-local agent?",
-			`Agent: ${safeTerminalLine(name, 256)}\nSource: ${safeTerminalLine(agent.filePath)}`,
-		);
-		if (!approved) throw new Error("Project-local subagent was not approved");
-	}
-}
-
-function isSameCwd(left: string, right: string): boolean {
-	try {
-		return realpathSync(left) === realpathSync(right);
-	} catch {
-		return path.resolve(left) === path.resolve(right);
-	}
-}

package/src/stateful-tool-params.ts

@@ -1,215 +0,0 @@
-import { StringEnum } from "@earendil-works/pi-ai";
-import { Type } from "typebox";
-
-const MANAGE_ACTIONS = ["interrupt", "close"] as const;
-const MAILBOX_ACTIONS = ["send", "read"] as const;
-const MAX_MAILBOX_MESSAGE_LENGTH = 16 * 1024;
-
-export const ManageParamsSchema = Type.Object(
-	{
-		action: StringEnum(MANAGE_ACTIONS, {
-			description: "Interrupt active work or close an agent and release its resources.",
-		}),
-		agentId: Type.Optional(
-			Type.String({
-				minLength: 1,
-				description: "Required agent ID or canonical task path for interrupt and close.",
-			}),
-		),
-		subtree: Type.Optional(
-			Type.Boolean({
-				default: false,
-				description: "Interrupt or close the target and all descendants child-first.",
-			}),
-		),
-	},
-	{ additionalProperties: false },
-);
-
-export const MailboxParamsSchema = Type.Object(
-	{
-		action: StringEnum(MAILBOX_ACTIONS, {
-			description: "Use send for queue-only delivery or read to inspect unread mailbox messages.",
-		}),
-		agentId: Type.String({
-			minLength: 1,
-			description: "Mailbox owner or recipient agent ID or canonical task path.",
-		}),
-		message: Type.Optional(
-			Type.String({
-				minLength: 1,
-				maxLength: MAX_MAILBOX_MESSAGE_LENGTH,
-				description: "Message content required by send; sending does not start a turn.",
-			}),
-		),
-		senderId: Type.Optional(
-			Type.String({ description: "Optional sender agent ID or canonical task path." }),
-		),
-		deduplicationKey: Type.Optional(
-			Type.String({ maxLength: 256, description: "Optional idempotency key for send." }),
-		),
-		acknowledge: Type.Optional(
-			Type.Boolean({ default: true, description: "Mark returned read messages as acknowledged." }),
-		),
-		limit: Type.Optional(
-			Type.Number({ minimum: 1, maximum: 20, default: 20, description: "Maximum messages." }),
-		),
-	},
-	{ additionalProperties: false },
-);
-
-export type ValidatedManageParams = {
-	action: "interrupt" | "close";
-	agentId: string;
-	subtree?: boolean;
-};
-
-export type ValidatedMailboxParams =
-	| {
-			action: "send";
-			agentId: string;
-			message: string;
-			senderId?: string;
-			deduplicationKey?: string;
-	  }
-	| { action: "read"; agentId: string; acknowledge?: boolean; limit?: number };
-
-export function validateManageParams(params: unknown): ValidatedManageParams {
-	const values = parameterRecord(params, "subagent_manage");
-	assertKnownKeys("subagent_manage", values, ["action", "agentId", "subtree"]);
-	const action = values.action;
-	if (action === "list") {
-		throw new Error(
-			'subagent_manage no longer supports "list"; use subagent_inspect action "list_runs"',
-		);
-	}
-	if (
-		typeof action !== "string" ||
-		!MANAGE_ACTIONS.includes(action as (typeof MANAGE_ACTIONS)[number])
-	) {
-		throw new Error(`subagent_manage action must be one of: ${MANAGE_ACTIONS.join(", ")}`);
-	}
-	assertRequiredString("subagent_manage", action, values, "agentId");
-	assertOptionalBoolean("subagent_manage", action, values, "subtree");
-	return {
-		action,
-		agentId: values.agentId,
-		...(values.subtree === undefined ? {} : { subtree: values.subtree }),
-	} as ValidatedManageParams;
-}
-
-export function validateMailboxParams(params: unknown): ValidatedMailboxParams {
-	const values = parameterRecord(params, "subagent_mailbox");
-	assertKnownKeys("subagent_mailbox", values, [
-		"action",
-		"agentId",
-		"message",
-		"senderId",
-		"deduplicationKey",
-		"acknowledge",
-		"limit",
-	]);
-	const action = values.action;
-	if (
-		typeof action !== "string" ||
-		!MAILBOX_ACTIONS.includes(action as (typeof MAILBOX_ACTIONS)[number])
-	) {
-		throw new Error(`subagent_mailbox action must be one of: ${MAILBOX_ACTIONS.join(", ")}`);
-	}
-	if (action === "send") {
-		assertRequiredString("subagent_mailbox", action, values, "agentId");
-		assertRequiredString("subagent_mailbox", action, values, "message");
-		const message = values.message as string;
-		if (message.length > MAX_MAILBOX_MESSAGE_LENGTH) {
-			throw new Error(
-				`subagent_mailbox action "send" requires message at most ${MAX_MAILBOX_MESSAGE_LENGTH} characters`,
-			);
-		}
-		assertOptionalString("subagent_mailbox", action, values, "senderId");
-		assertOptionalString("subagent_mailbox", action, values, "deduplicationKey");
-		if (typeof values.deduplicationKey === "string" && values.deduplicationKey.length > 256) {
-			throw new Error(
-				'subagent_mailbox action "send" requires deduplicationKey at most 256 characters',
-			);
-		}
-		return {
-			action,
-			agentId: values.agentId,
-			message,
-			...(values.senderId === undefined ? {} : { senderId: values.senderId }),
-			...(values.deduplicationKey === undefined
-				? {}
-				: { deduplicationKey: values.deduplicationKey }),
-		} as ValidatedMailboxParams;
-	}
-	assertRequiredString("subagent_mailbox", action, values, "agentId");
-	assertOptionalBoolean("subagent_mailbox", action, values, "acknowledge");
-	if (
-		values.limit !== undefined &&
-		(typeof values.limit !== "number" ||
-			!Number.isFinite(values.limit) ||
-			values.limit < 1 ||
-			values.limit > 20)
-	) {
-		throw new Error('subagent_mailbox action "read" requires limit between 1 and 20');
-	}
-	return {
-		action,
-		agentId: values.agentId,
-		...(values.acknowledge === undefined ? {} : { acknowledge: values.acknowledge }),
-		...(values.limit === undefined ? {} : { limit: values.limit }),
-	} as ValidatedMailboxParams;
-}
-
-function parameterRecord(params: unknown, toolName: string): Record<string, unknown> {
-	if (!params || typeof params !== "object" || Array.isArray(params)) {
-		throw new Error(`${toolName} parameters must be an object`);
-	}
-	return params as Record<string, unknown>;
-}
-
-function assertKnownKeys(
-	toolName: string,
-	values: Record<string, unknown>,
-	allowed: readonly string[],
-): void {
-	const unexpected = Object.keys(values).find(
-		(key) => values[key] !== undefined && !allowed.includes(key),
-	);
-	if (unexpected) throw new Error(`${toolName} does not accept ${unexpected}`);
-}
-
-function assertRequiredString(
-	toolName: string,
-	action: string,
-	values: Record<string, unknown>,
-	key: string,
-): void {
-	const value = values[key];
-	if (value === undefined) throw new Error(`${toolName} action "${action}" requires ${key}`);
-	if (typeof value !== "string" || value.length === 0) {
-		throw new Error(`${toolName} action "${action}" requires ${key} to be a non-empty string`);
-	}
-}
-
-function assertOptionalString(
-	toolName: string,
-	action: string,
-	values: Record<string, unknown>,
-	key: string,
-): void {
-	if (values[key] !== undefined && typeof values[key] !== "string") {
-		throw new Error(`${toolName} action "${action}" requires ${key} to be a string`);
-	}
-}
-
-function assertOptionalBoolean(
-	toolName: string,
-	action: string,
-	values: Record<string, unknown>,
-	key: string,
-): void {
-	if (values[key] !== undefined && typeof values[key] !== "boolean") {
-		throw new Error(`${toolName} action "${action}" requires ${key} to be a boolean`);
-	}
-}

package/src/stateful.ts

@@ -1,12 +0,0 @@
-export {
-	buildDetachedCompletionMessage,
-	CompletionDeliveryBroker,
-} from "./completion-delivery.js";
-export { formatStatefulAgentLine } from "./stateful-agent-view.js";
-export { resolveCompletionDelivery, resolveStatefulTransportKind } from "./stateful-config.js";
-export {
-	buildStatefulTurnPrompt,
-	resolveStatefulTurnTimeout,
-} from "./stateful-prompt.js";
-export * from "./stateful-registration.js";
-export { isWriteCapable } from "./stateful-safety.js";

package/src/subagent-details.ts

@@ -1,43 +0,0 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { SchedulingDecision } from "./adaptive-scheduler.js";
-import type { AgentScope } from "./agents/types.js";
-import type { OrchestrationMetrics } from "./orchestration-metrics.js";
-import type { PanelSynthesis } from "./panel-contract.js";
-import type { PanelEvidenceArtifact } from "./panel-evidence.js";
-import type { PanelFailure } from "./panel-failure.js";
-import type { PanelPhaseBudgets, PanelPreset } from "./panel-planning.js";
-import type { SingleResult } from "./runner-types.js";
-import type { WorkItemLedgerSnapshot } from "./work-item-ledger.js";
-
-export interface PanelDetails {
-	id: string;
-	preset: PanelPreset;
-	sharedTaskPreview: string;
-	state: "running" | "completed" | "degraded" | "insufficient-panel" | "failed" | "cancelled";
-	reviewerIds: string[];
-	validReviewCount: number;
-	failedReviewCount: number;
-	blockingObjectionCount: number;
-	dissentCount: number;
-	budgets: PanelPhaseBudgets;
-	evidence: PanelEvidenceArtifact[];
-	failures: PanelFailure[];
-	synthesis?: PanelSynthesis;
-	synthesizerResult?: SingleResult;
-	cleanupComplete: boolean;
-}
-
-export interface SubagentDetails {
-	mode: "single" | "parallel" | "chain" | "workflow" | "panel";
-	agentScope: AgentScope;
-	projectAgentsDir: string | null;
-	results: SingleResult[];
-	aggregator?: SingleResult;
-	workflow?: WorkItemLedgerSnapshot;
-	schedulerDecisions?: SchedulingDecision[];
-	metrics?: OrchestrationMetrics;
-	panel?: PanelDetails;
-	isError?: boolean;
-}
-
-export type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => void;