@narumitw/pi-subagents 0.43.0 → 0.46.0

package/src/inspect-render.ts

@@ -0,0 +1,234 @@
+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 type { SubagentInspectParams } from "./inspect.js";
+import {
+	booleanValue,
+	COLLAPSED_LIST_LIMIT,
+	expansionHint,
+	numberValue,
+	recordList,
+	recordValue,
+	renderFallbackResult,
+	safeBlock,
+	safeLine,
+	statusBadge,
+	stringValue,
+	type ToolRendererContext,
+	toolHeader,
+} from "./render-common.js";
+
+export function renderInspectCall(args: Partial<SubagentInspectParams>, theme: Theme) {
+	const action = safeLine(args.action, "...", 128);
+	const metadata: string[] = [];
+	if (args.agentScope) metadata.push(`[${args.agentScope}]`);
+	if (args.agent) metadata.push(`agent:${safeLine(args.agent, "", 256)}`);
+	if (args.agentId) metadata.push(`id:${safeLine(args.agentId, "", 256)}`);
+	if (args.includeClosed) metadata.push("include closed");
+	return new Text(toolHeader(theme, "subagent_inspect", action, metadata), 0, 0);
+}
+
+export function renderInspectResult(
+	result: AgentToolResult<Record<string, unknown>>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	context: ToolRendererContext<SubagentInspectParams>,
+) {
+	const details = recordValue(result.details);
+	const action = stringValue(details?.action);
+	if (!details || !action) return renderFallbackResult(result, options, theme, context.isError);
+
+	const rendered = renderAction(action, details, options.expanded, theme);
+	if (!rendered) return renderFallbackResult(result, options, theme, context.isError);
+	return new Text(rendered, 0, 0);
+}
+
+function renderAction(
+	action: string,
+	details: Record<string, unknown>,
+	expanded: boolean,
+	theme: Theme,
+): string | undefined {
+	switch (action) {
+		case "list_agents":
+			return renderList("agent", recordList(details.agents), details, expanded, theme, formatAgent);
+		case "get_agent": {
+			const agent = recordValue(details.agent);
+			if (!agent) return undefined;
+			const lines = [
+				`${statusBadge(theme, "completed")} · ${theme.fg("toolTitle", theme.bold(safeLine(agent.name, "agent", 256)))}${theme.fg("muted", ` (${safeLine(agent.source, "unknown", 128)})`)}`,
+				formatAgent(agent, theme, true),
+			];
+			if (!expanded) lines.push(expansionHint());
+			return lines.join("\n");
+		}
+		case "list_runs":
+			return renderList("run", recordList(details.runs), details, expanded, theme, formatRun);
+		case "get_run": {
+			const run = recordValue(details.run);
+			if (!run) return undefined;
+			const lines = [
+				`${statusBadge(theme, "completed")} · run ${theme.fg("accent", safeLine(run.id, "run", 256))}`,
+				formatRun(run, theme, true),
+			];
+			if (!expanded) lines.push(expansionHint());
+			return lines.join("\n");
+		}
+		case "list_models":
+			return renderList(
+				"model",
+				recordList(details.models),
+				details,
+				expanded,
+				theme,
+				formatModel,
+				stringValue(details.source),
+			);
+		case "status":
+			return renderStatus(details, expanded, theme);
+		case "diagnose":
+			return renderDiagnose(details, expanded, theme);
+		default:
+			return undefined;
+	}
+}
+
+function renderList(
+	label: string,
+	items: Record<string, unknown>[],
+	details: Record<string, unknown>,
+	expanded: boolean,
+	theme: Theme,
+	format: (item: Record<string, unknown>, theme: Theme, expanded: boolean) => string,
+	source = "",
+): string {
+	const returned = numberValue(details.returned, items.length);
+	const omitted = numberValue(details.omitted);
+	const noun = `${label}${returned === 1 ? "" : "s"}`;
+	const lines = [
+		`${statusBadge(theme, "completed")} · ${returned} ${noun}${source ? theme.fg("muted", ` · ${safeLine(source, "", 256)}`) : ""}`,
+	];
+	const selected = expanded ? items : items.slice(0, COLLAPSED_LIST_LIMIT);
+	for (const item of selected) lines.push(format(item, theme, expanded));
+	const hidden = Math.max(0, items.length - selected.length) + omitted;
+	if (hidden > 0) lines.push(theme.fg("muted", `… ${hidden} omitted`));
+	if (items.length === 0) lines.push(theme.fg("muted", `(no ${label}s)`));
+	if (!expanded && (items.length > 0 || omitted > 0)) lines.push(expansionHint());
+	return lines.join("\n");
+}
+
+function formatAgent(agent: Record<string, unknown>, theme: Theme, expanded: boolean): string {
+	const name = safeLine(agent.name, "agent", 256);
+	const source = safeLine(agent.source, "unknown", 128);
+	const model = stringValue(agent.model);
+	const toolCount = typeof agent.toolCount === "number" ? agent.toolCount : undefined;
+	const description = safeBlock(agent.description, "", 512).trim();
+	const lines = [
+		`${theme.fg("muted", "• ")}${theme.fg("accent", name)} ${theme.fg("muted", source)}${model ? theme.fg("dim", ` · ${safeLine(model, "", 256)}`) : ""}${toolCount !== undefined ? theme.fg("dim", ` · ${toolCount} tools`) : ""}`,
+	];
+	if (description) lines.push(`  ${theme.fg("toolOutput", description)}`);
+	if (expanded) {
+		const path = stringValue(agent.path);
+		const consultTools = stringList(agent.consultTools);
+		if (path) lines.push(`  ${theme.fg("dim", `path: ${safeLine(path, "", 2 * 1024)}`)}`);
+		lines.push(`  ${theme.fg("dim", `consult tools: ${consultTools.join(", ") || "none"}`)}`);
+	}
+	return lines.join("\n");
+}
+
+function formatRun(run: Record<string, unknown>, theme: Theme, expanded: boolean): string {
+	const id = safeLine(run.id, "run", 256);
+	const agent = safeLine(run.agent, "agent", 256);
+	const state = safeLine(run.state, "unknown", 128);
+	const unread = numberValue(run.unreadMessages);
+	const lines = [
+		`${theme.fg("muted", "• ")}${theme.fg("accent", id)} ${theme.fg("toolOutput", agent)} ${theme.fg("muted", state)}${unread > 0 ? theme.fg("warning", ` · unread:${unread}`) : ""}`,
+	];
+	if (expanded) {
+		const thinking = stringValue(run.thinkingLevel);
+		const task = safeBlock(run.currentTask, "", 2 * 1024).trim();
+		const error = safeBlock(run.error, "", 2 * 1024).trim();
+		lines.push(
+			`  ${theme.fg("dim", `${numberValue(run.historyCount)} history · ${thinking ? `thinking:${safeLine(thinking, "", 128)} · ` : ""}${numberValue(run.children)} children`)}`,
+		);
+		if (task) lines.push(`  ${theme.fg("dim", `task: ${task}`)}`);
+		if (error) lines.push(`  ${theme.fg("error", `error: ${error}`)}`);
+	}
+	return lines.join("\n");
+}
+
+function formatModel(model: Record<string, unknown>, theme: Theme, expanded: boolean): string {
+	const identity = `${safeLine(model.provider, "provider", 256)}/${safeLine(model.id, "model", 256)}`;
+	const current = booleanValue(model.current) ? theme.fg("success", " · current") : "";
+	const reasoning = booleanValue(model.reasoning) ? theme.fg("dim", " · reasoning") : "";
+	const lines = [`${theme.fg("muted", "• ")}${theme.fg("accent", identity)}${current}${reasoning}`];
+	if (expanded) {
+		const name = stringValue(model.name);
+		const thinking = stringValue(model.thinkingLevel);
+		if (name) lines.push(`  ${theme.fg("toolOutput", safeLine(name, "", 512))}`);
+		lines.push(
+			`  ${theme.fg("dim", `context:${numberValue(model.contextWindow)} · max:${numberValue(model.maxTokens)}${thinking ? ` · thinking:${safeLine(thinking, "", 128)}` : ""}`)}`,
+		);
+	}
+	return lines.join("\n");
+}
+
+function renderStatus(
+	details: Record<string, unknown>,
+	expanded: boolean,
+	theme: Theme,
+): string | undefined {
+	const status = recordValue(details.status);
+	const stateful = recordValue(status?.stateful);
+	if (!status || !stateful) return undefined;
+	const lines = [
+		`${statusBadge(theme, "completed")} · runtime status`,
+		`${theme.fg("muted", "workflow: ")}${theme.fg("accent", safeLine(status.workflow, "unknown", 128))} · ${numberValue(stateful.activeAgents)} active · ${numberValue(stateful.retainedAgents)} retained`,
+		`${theme.fg("muted", "stateful: ")}${stateful.initialized === true ? "initialized" : "not initialized"} · resources: ${safeLine(status.consultResources, "unknown", 128)}`,
+	];
+	if (expanded) {
+		const delivery = stringValue(stateful.completionDelivery);
+		const transport = stringValue(stateful.transport);
+		if (transport || delivery) {
+			lines.push(
+				theme.fg(
+					"dim",
+					[
+						transport && `transport:${safeLine(transport)}`,
+						delivery && `delivery:${safeLine(delivery)}`,
+					]
+						.filter(Boolean)
+						.join(" · "),
+				),
+			);
+		}
+	} else lines.push(expansionHint());
+	return lines.join("\n");
+}
+
+function renderDiagnose(details: Record<string, unknown>, expanded: boolean, theme: Theme): string {
+	const checks = recordList(details.checks);
+	const hasFail = checks.some((check) => check.status === "fail");
+	const hasWarning = checks.some((check) => check.status === "warning");
+	const overall = hasFail ? "failed" : hasWarning ? "warnings" : "passed";
+	const status = hasFail ? "failed" : hasWarning ? "warning" : "completed";
+	const lines = [`${statusBadge(theme, status)} · Diagnostics ${overall}`];
+	const selected = expanded ? checks : checks.slice(0, COLLAPSED_LIST_LIMIT);
+	for (const check of selected) {
+		const checkStatus = safeLine(check.status, "unknown", 64);
+		const color =
+			checkStatus === "fail" ? "error" : checkStatus === "warning" ? "warning" : "success";
+		lines.push(
+			`${theme.fg(color, checkStatus.toUpperCase())} ${theme.fg("accent", safeLine(check.name, "check", 256))} · ${theme.fg("toolOutput", safeBlock(check.message, "", 2 * 1024))}`,
+		);
+	}
+	if (checks.length === 0) lines.push(theme.fg("muted", "(no diagnostic checks)"));
+	if (!expanded && checks.length > 0) lines.push(expansionHint());
+	return lines.join("\n");
+}
+
+function stringList(value: unknown): string[] {
+	return Array.isArray(value)
+		? value.flatMap((item) => (typeof item === "string" ? [safeLine(item, "", 256)] : []))
+		: [];
+}

package/src/inspect.ts

@@ -2,12 +2,21 @@ import * as path from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
-import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
+import {
+	type AgentConfig,
+	type AgentScope,
+	type ConsultationCwdPolicy,
+	type DelegationCwdPolicy,
+	discoverAgents,
+} from "./agents.js";
 import { resolveConsultTools } from "./consult-policy.js";
+import { renderInspectCall, renderInspectResult } from "./inspect-render.js";
 import type { AgentRunInspectionDetail, AgentRunInspectionSummary } from "./registry.js";
 import { boundedPrivateText, boundText, safeDisplayPath, safeTerminalLine } from "./safe-text.js";
 import {
+	inspectCompletionDeliverySettings,
 	inspectConsultResourceSettings,
+	inspectCwdPolicySettings,
 	inspectDelegationWorkflowSettings,
 	inspectSubagentSettings,
 	resolveDelegationWorkflow,
@@ -49,6 +58,8 @@ export type SubagentInspectParams = Static<typeof SubagentInspectParams>;
 export interface SubagentInspectRuntime {
 	getBlockingEnabled(): boolean;
 	getConsultResourcePolicy(): "project-context" | "none" | "all";
+	getConsultationCwdPolicy(): ConsultationCwdPolicy;
+	getDelegationCwdPolicy(): DelegationCwdPolicy;
 	getRuntimeStatus(): StatefulSubagentRuntimeStatus;
 	listRunInspection(includeClosed?: boolean): AgentRunInspectionSummary[];
 	getRunInspection(agentId: string): AgentRunInspectionDetail | undefined;
@@ -79,6 +90,12 @@ export function registerSubagentInspect(pi: ExtensionAPI, runtime: SubagentInspe
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx): Promise<InspectToolResult> {
 			return executeSubagentInspect(validateInspectParams(params), ctx, runtime);
 		},
+		renderCall(args, theme) {
+			return renderInspectCall(args, theme);
+		},
+		renderResult(result, options, theme, context) {
+			return renderInspectResult(result, options, theme, context);
+		},
 	});
 }
 
@@ -280,9 +297,26 @@ function projectRun(run: AgentRunInspectionDetail, ctx: ExtensionContext): Recor
 	return {
 		...projectRunSummary(run),
 		cwd: safeDisplayPath(run.cwd, ctx.cwd),
+		workspaceMode: run.workspaceMode ?? "shared",
 		thinkingLevel: run.thinkingLevel,
 		currentTask: run.currentTask ? boundedPrivateText(run.currentTask, 2 * 1024) : undefined,
 		error: run.error ? boundedPrivateText(run.error, 2 * 1024) : undefined,
+		target: run.target
+			? {
+					cwd: safeDisplayPath(run.target.cwd, ctx.cwd),
+					boundary: run.target.boundary,
+					trust: {
+						kind: run.target.trust.kind,
+						projectTrusted: run.target.trust.projectTrusted,
+						sourcePath: run.target.trust.sourcePath
+							? safeDisplayPath(run.target.trust.sourcePath, ctx.cwd)
+							: undefined,
+						warning: run.target.trust.warning
+							? boundedPrivateText(run.target.trust.warning, 512)
+							: undefined,
+					},
+				}
+			: undefined,
 		policy: run.policy
 			? {
 					inherited: projectToolNames(run.policy.inherited),
@@ -323,17 +357,31 @@ function projectStatus(runtime: SubagentInspectRuntime): Record<string, unknown>
 	const workflow = resolveDelegationWorkflow(runtime.getBlockingEnabled(), stateful.enabled);
 	const configured = inspectDelegationWorkflowSettings();
 	const resources = inspectConsultResourceSettings();
+	const cwdPolicy = inspectCwdPolicySettings();
+	const completion = inspectCompletionDeliverySettings();
 	return {
 		workflow,
 		configuredWorkflow: configured.value,
+		configuredWorkflowSource: configured.source,
 		stateful,
+		configuredCompletionDelivery: completion.value,
+		configuredCompletionDeliverySource: completion.source,
 		consultResources: runtime.getConsultResourcePolicy(),
+		consultationCwdPolicy: runtime.getConsultationCwdPolicy(),
+		configuredConsultationCwdPolicy: cwdPolicy.consultation.value,
+		consultationCwdPolicySource: cwdPolicy.consultation.source,
+		delegationCwdPolicy: runtime.getDelegationCwdPolicy(),
+		configuredDelegationCwdPolicy: cwdPolicy.delegation.value,
+		delegationCwdPolicySource: cwdPolicy.delegation.source,
 		configuredConsultResources: resources.value,
 		consultResourcesSource: resources.source,
 		settingsPath: safeDisplayPath(resources.path, process.cwd()),
 		settingsError:
-			configured.error || resources.error
-				? boundedPrivateText(configured.error ?? resources.error ?? "", 2 * 1024)
+			configured.error || resources.error || cwdPolicy.error || completion.error
+				? boundedPrivateText(
+						configured.error ?? resources.error ?? cwdPolicy.error ?? completion.error ?? "",
+						2 * 1024,
+					)
 				: undefined,
 	};
 }

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/pi-invocation.ts

@@ -0,0 +1,168 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getPackageDir } from "@earendil-works/pi-coding-agent";
+
+const CORE_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+const MAX_DISPLAY_PATH_LENGTH = 500;
+
+export interface PiInvocation {
+	command: string;
+	args: string[];
+}
+
+export interface PiInvocationRuntime {
+	execPath: string;
+	packageDir: string;
+	runtimeKind: "node" | "bun" | "unsupported";
+}
+
+export class PiInvocationError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "PiInvocationError";
+	}
+}
+
+function displayPath(value: string): string {
+	const suffix = value.length > MAX_DISPLAY_PATH_LENGTH ? "…" : "";
+	return JSON.stringify(`${value.slice(0, MAX_DISPLAY_PATH_LENGTH)}${suffix}`);
+}
+
+function resolutionError(packageDir: string, reason: string): PiInvocationError {
+	return new PiInvocationError(
+		`Unable to resolve the Pi CLI from the loaded ${CORE_PACKAGE_NAME} package at ${displayPath(packageDir)}: ${reason}. Reinstall the matching Pi core package before using the subprocess transport.`,
+	);
+}
+
+function currentRuntime(): PiInvocationRuntime {
+	let packageDir: string;
+	try {
+		packageDir = getPackageDir();
+	} catch {
+		throw resolutionError("<unavailable>", "Pi core did not provide its package directory");
+	}
+	const runtimeKind = process.versions.bun
+		? "bun"
+		: process.release.name === "node" && !process.versions.electron
+			? "node"
+			: "unsupported";
+	return {
+		execPath: process.execPath,
+		packageDir,
+		runtimeKind,
+	};
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isWithinDirectory(parent: string, candidate: string): boolean {
+	const relative = path.relative(parent, candidate);
+	return (
+		relative === "" ||
+		(!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative))
+	);
+}
+
+function readCoreManifest(packageDir: string): Record<string, unknown> {
+	const manifestPath = path.join(packageDir, "package.json");
+	let source: string;
+	try {
+		source = fs.readFileSync(manifestPath, "utf8");
+	} catch {
+		throw resolutionError(packageDir, "the package manifest is unavailable");
+	}
+	let manifest: unknown;
+	try {
+		manifest = JSON.parse(source);
+	} catch {
+		throw resolutionError(packageDir, "the package manifest is invalid JSON");
+	}
+	if (!isRecord(manifest)) {
+		throw resolutionError(packageDir, "the package manifest is invalid");
+	}
+	if (manifest.name !== CORE_PACKAGE_NAME) {
+		throw resolutionError(packageDir, "the package manifest has an unexpected package name");
+	}
+	return manifest;
+}
+
+function resolveDeclaredBin(packageDir: string, manifest: Record<string, unknown>): string {
+	const bin = manifest.bin;
+	const piBin = isRecord(bin) ? bin.pi : undefined;
+	if (typeof piBin !== "string" || !piBin.trim()) {
+		throw resolutionError(packageDir, "package.json bin.pi must be a non-empty string");
+	}
+	const candidate = path.resolve(packageDir, piBin);
+	if (path.isAbsolute(piBin) || !isWithinDirectory(packageDir, candidate)) {
+		throw resolutionError(packageDir, "the declared bin.pi target escapes the package directory");
+	}
+	return candidate;
+}
+
+function resolveExistingFile(packageDir: string, candidate: string, reason: string): string {
+	let resolved: string;
+	try {
+		resolved = fs.realpathSync(candidate);
+		if (!fs.statSync(resolved).isFile()) throw new Error("not a file");
+	} catch {
+		throw resolutionError(packageDir, reason);
+	}
+	if (!isWithinDirectory(packageDir, resolved)) {
+		throw resolutionError(packageDir, "the declared bin.pi target escapes the package directory");
+	}
+	return resolved;
+}
+
+function resolveStandaloneExecutable(
+	packageDir: string,
+	runtime: PiInvocationRuntime,
+): string | undefined {
+	if (runtime.runtimeKind !== "bun") return undefined;
+	const { execPath } = runtime;
+	if (!/^pi(?:\.exe)?$/i.test(path.basename(execPath))) return undefined;
+	let resolved: string;
+	let mode: number;
+	try {
+		resolved = fs.realpathSync(execPath);
+		const stat = fs.statSync(resolved);
+		if (!stat.isFile()) throw new Error("not a file");
+		mode = stat.mode;
+	} catch {
+		throw resolutionError(packageDir, "the standalone Pi executable is unavailable");
+	}
+	if (path.dirname(resolved) !== packageDir) return undefined;
+	if (process.platform !== "win32" && (mode & 0o111) === 0) {
+		throw resolutionError(packageDir, "the standalone Pi executable is not executable");
+	}
+	return resolved;
+}
+
+export function resolvePiInvocation(
+	args: string[],
+	runtime: PiInvocationRuntime = currentRuntime(),
+): PiInvocation {
+	let packageDir: string;
+	try {
+		packageDir = fs.realpathSync(runtime.packageDir);
+		if (!fs.statSync(packageDir).isDirectory()) throw new Error("not a directory");
+	} catch {
+		throw resolutionError(runtime.packageDir, "the package directory is unavailable");
+	}
+
+	const manifest = readCoreManifest(packageDir);
+	const declaredBin = resolveDeclaredBin(packageDir, manifest);
+	const standalone = resolveStandaloneExecutable(packageDir, runtime);
+	if (standalone) return { command: standalone, args: [...args] };
+
+	if (runtime.runtimeKind !== "node" && runtime.runtimeKind !== "bun") {
+		throw resolutionError(packageDir, "the host does not provide a supported Node or Bun runtime");
+	}
+	const cliPath = resolveExistingFile(
+		packageDir,
+		declaredBin,
+		"the declared bin.pi target is unavailable",
+	);
+	return { command: runtime.execPath, args: [cliPath, ...args] };
+}

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,6 +51,8 @@ export interface ManagedAgent {
 	context?: string;
 	contextSourceIds?: string[];
 	contextTruncated?: boolean;
+	workspaceMode?: "worktree";
+	target?: TargetPolicyAudit;
 	policy?: { inherited: string[]; overridden: string[]; unsupported: string[] };
 	mailbox: AgentMailboxMessage[];
 	currentMailboxMessageIds?: string[];
@@ -70,6 +73,8 @@ export interface AgentRunInspectionDetail extends AgentRunInspectionSummary {
 	thinkingLevel?: SubagentThinkingLevel;
 	currentTask?: string;
 	error?: string;
+	workspaceMode?: "worktree";
+	target?: TargetPolicyAudit;
 	policy?: { inherited: string[]; overridden: string[]; unsupported: string[] };
 }
 
@@ -243,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;
@@ -286,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) {
@@ -549,6 +558,8 @@ export class AgentRegistry {
 			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],
@@ -840,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],