@narumitw/pi-subagents 0.42.0 → 0.43.1

package/src/params.ts

@@ -1,11 +1,13 @@
 import { StringEnum } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
 import { THINKING_LEVELS } from "./agents.js";
+import { MAX_SUBAGENT_TIMEOUT_MS } from "./limits.js";
 
 const TimeoutMs = Type.Number({
 	description:
 		"Hard timeout in milliseconds for each subagent subprocess. Defaults to PI_SUBAGENT_TIMEOUT_MS or 600000.",
 	minimum: 1,
+	maximum: MAX_SUBAGENT_TIMEOUT_MS,
 });
 
 const ThinkingLevelSchema = StringEnum(THINKING_LEVELS, {

package/src/persistence.ts

@@ -167,6 +167,8 @@ function isStoredState(value: unknown): value is StoredState {
 			Number.isFinite(record.updatedAt) &&
 			(record.parentId === undefined || typeof record.parentId === "string") &&
 			(record.thinkingLevel === undefined || isThinkingLevel(record.thinkingLevel)) &&
+			(record.workspaceMode === undefined || record.workspaceMode === "worktree") &&
+			(record.target === undefined || isTargetPolicyAudit(record.target)) &&
 			(record.children === undefined ||
 				(Array.isArray(record.children) &&
 					record.children.every((id) => typeof id === "string"))) &&
@@ -178,6 +180,33 @@ function isStoredState(value: unknown): value is StoredState {
 	});
 }
 
+function isTargetPolicyAudit(value: unknown): boolean {
+	if (!value || typeof value !== "object") return false;
+	const target = value as Record<string, unknown>;
+	if (
+		typeof target.cwd !== "string" ||
+		(target.boundary !== "current-workspace" && target.boundary !== "external") ||
+		!target.trust ||
+		typeof target.trust !== "object"
+	) {
+		return false;
+	}
+	const trust = target.trust as Record<string, unknown>;
+	return (
+		[
+			"session-trusted",
+			"session-untrusted",
+			"saved-trusted",
+			"saved-denied",
+			"unsaved",
+			"trust-error",
+		].includes(String(trust.kind)) &&
+		typeof trust.projectTrusted === "boolean" &&
+		(trust.sourcePath === undefined || typeof trust.sourcePath === "string") &&
+		(trust.warning === undefined || typeof trust.warning === "string")
+	);
+}
+
 function isAgentTurn(value: unknown): boolean {
 	if (!value || typeof value !== "object") return false;
 	const turn = value as Record<string, unknown>;

package/src/registry.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { SubagentThinkingLevel } from "./agents.js";
+import type { TargetPolicyAudit } from "./cwd-policy.js";
 import { DEFAULT_MAX_CONTEXT_BYTES, DEFAULT_MAX_OUTPUT_BYTES, truncateUtf8 } from "./limits.js";
 import { type AgentTurnRunner, normalizeTransport, type SubagentTransport } from "./transport.js";
 
@@ -50,11 +51,38 @@ export interface ManagedAgent {
 	context?: string;
 	contextSourceIds?: string[];
 	contextTruncated?: boolean;
+	workspaceMode?: "worktree";
+	target?: TargetPolicyAudit;
 	policy?: { inherited: string[]; overridden: string[]; unsupported: string[] };
 	mailbox: AgentMailboxMessage[];
 	currentMailboxMessageIds?: string[];
 }
 
+export interface AgentRunInspectionSummary {
+	id: string;
+	agent: string;
+	state: AgentLifecycleState;
+	createdAt: number;
+	updatedAt: number;
+	historyCount: number;
+	unreadMessages: number;
+}
+
+export interface AgentRunInspectionDetail extends AgentRunInspectionSummary {
+	cwd: string;
+	thinkingLevel?: SubagentThinkingLevel;
+	currentTask?: string;
+	error?: string;
+	workspaceMode?: "worktree";
+	target?: TargetPolicyAudit;
+	policy?: { inherited: string[]; overridden: string[]; unsupported: string[] };
+}
+
+export interface AgentInspectionCounts {
+	activeAgents: number;
+	retainedAgents: number;
+}
+
 export interface TurnOutcome {
 	output: string;
 	exitCode: number;
@@ -220,6 +248,8 @@ export class AgentRegistry {
 		context?: string;
 		contextSourceIds?: string[];
 		contextTruncated?: boolean;
+		workspaceMode?: "worktree";
+		target?: TargetPolicyAudit;
 	}): Promise<ManagedAgent> {
 		if (!input.task.trim()) throw new Error("Subagent tasks cannot be empty");
 		const task = truncateUtf8(input.task, this.maxTaskBytes).text;
@@ -263,6 +293,8 @@ export class AgentRegistry {
 			context: input.context,
 			contextSourceIds: input.contextSourceIds,
 			contextTruncated: input.contextTruncated,
+			workspaceMode: input.workspaceMode,
+			target: input.target,
 		};
 		this.agents.set(record.id, record);
 		if (parent) {
@@ -500,6 +532,44 @@ export class AgentRegistry {
 		if (shutdownError) throw shutdownError;
 	}
 
+	inspectionCounts(): AgentInspectionCounts {
+		let activeAgents = 0;
+		let retainedAgents = 0;
+		for (const agent of this.agents.values()) {
+			if (agent.state === "starting" || agent.state === "running") activeAgents++;
+			if (agent.state !== "closed") retainedAgents++;
+		}
+		return { activeAgents, retainedAgents };
+	}
+
+	listInspection(includeClosed = false): AgentRunInspectionSummary[] {
+		return [...this.agents.values()]
+			.filter((agent) => includeClosed || agent.state !== "closed")
+			.sort((left, right) => left.createdAt - right.createdAt)
+			.map((agent) => this.inspectSummary(agent));
+	}
+
+	getInspection(id: string): AgentRunInspectionDetail | undefined {
+		const agent = this.agents.get(id);
+		if (!agent) return undefined;
+		return {
+			...this.inspectSummary(agent),
+			cwd: agent.cwd,
+			thinkingLevel: agent.thinkingLevel,
+			currentTask: agent.currentTask,
+			error: agent.error,
+			workspaceMode: agent.workspaceMode,
+			target: agent.target ? { ...agent.target, trust: { ...agent.target.trust } } : undefined,
+			policy: agent.policy
+				? {
+						inherited: [...agent.policy.inherited],
+						overridden: [...agent.policy.overridden],
+						unsupported: [...agent.policy.unsupported],
+					}
+				: undefined,
+		};
+	}
+
 	list(includeClosed = false, rootId?: string): ManagedAgent[] {
 		return [...this.agents.values()]
 			.filter((agent) => !rootId || agent.rootId === rootId)
@@ -755,6 +825,22 @@ export class AgentRegistry {
 		return next;
 	}
 
+	private inspectSummary(agent: ManagedAgent): AgentRunInspectionSummary {
+		let unreadMessages = 0;
+		for (const message of agent.mailbox) {
+			if (message.readAt === undefined) unreadMessages++;
+		}
+		return {
+			id: agent.id,
+			agent: agent.agent,
+			state: agent.state,
+			createdAt: agent.createdAt,
+			updatedAt: agent.updatedAt,
+			historyCount: agent.history.length,
+			unreadMessages,
+		};
+	}
+
 	private copy(agent: ManagedAgent): ManagedAgent {
 		return {
 			...agent,
@@ -765,6 +851,7 @@ export class AgentRegistry {
 				: undefined,
 			history: agent.history.map((turn) => ({ ...turn })),
 			mailbox: agent.mailbox.map((message) => ({ ...message })),
+			target: agent.target ? { ...agent.target, trust: { ...agent.target.trust } } : undefined,
 			policy: agent.policy
 				? {
 						inherited: [...agent.policy.inherited],

package/src/render-common.ts

@@ -0,0 +1,252 @@
+import * as os from "node:os";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import {
+	keyHint,
+	type Theme,
+	type ThemeColor,
+	type ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { boundedPrivateText, safeTerminalLine } from "./safe-text.js";
+
+export const COLLAPSED_LIST_LIMIT = 5;
+export const COLLAPSED_ANSWER_LINES = 3;
+
+export interface ToolRendererContext<TArgs> {
+	args: TArgs;
+	isError: boolean;
+}
+
+export type RenderStatus =
+	| "starting"
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "interrupted"
+	| "idle"
+	| "closed"
+	| "warning";
+
+const STATUS_PRESENTATION: Record<
+	RenderStatus,
+	{ icon: string; label: string; color: ThemeColor }
+> = {
+	starting: { icon: "⏳", label: "Starting", color: "warning" },
+	running: { icon: "⏳", label: "Running", color: "warning" },
+	completed: { icon: "✓", label: "Completed", color: "success" },
+	failed: { icon: "✗", label: "Failed", color: "error" },
+	cancelled: { icon: "■", label: "Cancelled", color: "warning" },
+	interrupted: { icon: "■", label: "Interrupted", color: "warning" },
+	idle: { icon: "○", label: "Idle", color: "muted" },
+	closed: { icon: "✓", label: "Closed", color: "muted" },
+	warning: { icon: "◐", label: "Warning", color: "warning" },
+};
+
+export function recordValue(value: unknown): Record<string, unknown> | undefined {
+	return value !== null && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: undefined;
+}
+
+export function recordList(value: unknown): Record<string, unknown>[] {
+	return Array.isArray(value)
+		? value.flatMap((item) => {
+				const record = recordValue(item);
+				return record ? [record] : [];
+			})
+		: [];
+}
+
+export function stringValue(value: unknown, fallback = ""): string {
+	return typeof value === "string" ? value : fallback;
+}
+
+export function numberValue(value: unknown, fallback = 0): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export function booleanValue(value: unknown): boolean {
+	return value === true;
+}
+
+export function safeLine(value: unknown, fallback = "...", maxBytes = 2 * 1024): string {
+	if (typeof value !== "string" || !value.trim()) return fallback;
+	return safeTerminalLine(value, maxBytes) || fallback;
+}
+
+export function safeBlock(value: unknown, fallback = "", maxBytes = 50 * 1024): string {
+	if (typeof value !== "string" || !value) return fallback;
+	return boundedPrivateText(value, maxBytes);
+}
+
+export function previewLines(value: unknown, maxLines = COLLAPSED_ANSWER_LINES): string {
+	const text = safeBlock(value, "", 8 * 1024).trim();
+	return text.split("\n").slice(0, maxLines).join("\n");
+}
+
+export function textResult(result: AgentToolResult<unknown>): string {
+	return result.content
+		.flatMap((part) => (part.type === "text" ? [part.text] : []))
+		.join("\n")
+		.trim();
+}
+
+export function toolHeader(
+	theme: Theme,
+	toolName: string,
+	primary?: unknown,
+	metadata: readonly string[] = [],
+): string {
+	let text = theme.fg("toolTitle", theme.bold(`${toolName} `));
+	if (primary !== undefined) text += theme.fg("accent", safeLine(primary));
+	const safeMetadata = metadata.filter(Boolean).map((item) => safeLine(item, "", 512));
+	if (safeMetadata.length > 0) text += theme.fg("muted", ` · ${safeMetadata.join(" · ")}`);
+	return text.trimEnd();
+}
+
+export function statusBadge(theme: Theme, status: RenderStatus, suffix?: string): string {
+	const presentation = STATUS_PRESENTATION[status];
+	const label = suffix
+		? `${presentation.label} · ${safeLine(suffix, "", 2 * 1024)}`
+		: presentation.label;
+	return `${theme.fg(presentation.color, presentation.icon)} ${theme.fg(presentation.color, label)}`;
+}
+
+export function renderFallbackResult(
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	isError = false,
+) {
+	const status: RenderStatus = isError ? "failed" : options.isPartial ? "running" : "completed";
+	const content = safeBlock(textResult(result), "(no output)", 8 * 1024);
+	return new Text(`${statusBadge(theme, status)}\n${theme.fg("toolOutput", content)}`, 0, 0);
+}
+
+export function expansionHint(): string {
+	return keyHint("app.tools.expand", "to expand");
+}
+
+export interface RenderActivityItem {
+	type: "text" | "toolCall";
+	text?: string;
+	name?: string;
+	args?: Record<string, unknown>;
+}
+
+export function projectRenderActivity(value: unknown): RenderActivityItem[] {
+	if (!Array.isArray(value)) return [];
+	const items: RenderActivityItem[] = [];
+	for (const item of value) {
+		const record = recordValue(item);
+		if (!record) continue;
+		if (record.type === "text" && typeof record.text === "string") {
+			items.push({ type: "text", text: safeBlock(record.text, "", 1024) });
+			continue;
+		}
+		if (record.type === "toolCall" && typeof record.name === "string") {
+			items.push({
+				type: "toolCall",
+				name: safeLine(record.name, "tool", 256),
+				args: recordValue(record.args) ?? {},
+			});
+		}
+	}
+	return items;
+}
+
+export function renderActivityLines(
+	items: readonly RenderActivityItem[],
+	theme: Theme,
+	limit?: number,
+	total = items.length,
+): string {
+	const selected = limit === undefined ? items : items.slice(-limit);
+	const lines: string[] = [];
+	const skipped = Math.max(0, total - selected.length);
+	if (skipped > 0) lines.push(theme.fg("muted", `… ${skipped} earlier activities`));
+	for (const item of selected) {
+		if (item.type === "text") {
+			const text = safeBlock(item.text, "", 1024).trim();
+			if (text) lines.push(theme.fg("toolOutput", text));
+		} else {
+			lines.push(
+				theme.fg("muted", "→ ") +
+					formatToolActivity(item.name ?? "tool", item.args ?? {}, theme.fg.bind(theme)),
+			);
+		}
+	}
+	return lines.join("\n");
+}
+
+export function formatToolActivity(
+	toolNameValue: unknown,
+	argsValue: unknown,
+	themeFg: (color: ThemeColor, text: string) => string,
+): string {
+	const toolName = safeLine(toolNameValue, "tool", 256);
+	const args = recordValue(argsValue) ?? {};
+	const shortenPath = (value: unknown, fallback = ".") => {
+		const filePath = safeLine(value, fallback, 2 * 1024);
+		const home = os.homedir();
+		return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+	};
+
+	switch (toolName) {
+		case "bash": {
+			const command = safeLine(args.command, "...", 512);
+			return themeFg("muted", "$ ") + themeFg("toolOutput", command);
+		}
+		case "read": {
+			const filePath = shortenPath(args.file_path ?? args.path, "...");
+			const offset = typeof args.offset === "number" ? args.offset : undefined;
+			const limit = typeof args.limit === "number" ? args.limit : undefined;
+			let text = themeFg("accent", filePath);
+			if (offset !== undefined || limit !== undefined) {
+				const startLine = offset ?? 1;
+				const endLine = limit !== undefined ? startLine + limit - 1 : "";
+				text += themeFg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+			}
+			return themeFg("muted", "read ") + text;
+		}
+		case "write": {
+			const filePath = shortenPath(args.file_path ?? args.path, "...");
+			const content = safeBlock(args.content, "", 2 * 1024);
+			const lines = content ? content.split("\n").length : 0;
+			return (
+				themeFg("muted", "write ") +
+				themeFg("accent", filePath) +
+				(lines > 1 ? themeFg("dim", ` (${lines} lines)`) : "")
+			);
+		}
+		case "edit":
+			return (
+				themeFg("muted", "edit ") +
+				themeFg("accent", shortenPath(args.file_path ?? args.path, "..."))
+			);
+		case "ls":
+			return themeFg("muted", "ls ") + themeFg("accent", shortenPath(args.path));
+		case "find":
+			return (
+				themeFg("muted", "find ") +
+				themeFg("accent", safeLine(args.pattern, "*", 512)) +
+				themeFg("dim", ` in ${shortenPath(args.path)}`)
+			);
+		case "grep":
+			return (
+				themeFg("muted", "grep ") +
+				themeFg("accent", `/${safeLine(args.pattern, "", 512)}/`) +
+				themeFg("dim", ` in ${shortenPath(args.path)}`)
+			);
+		default: {
+			let serialized = "{}";
+			try {
+				serialized = JSON.stringify(args);
+			} catch {
+				serialized = "{…}";
+			}
+			return themeFg("accent", toolName) + themeFg("dim", ` ${safeLine(serialized, "{}", 512)}`);
+		}
+	}
+}