@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/src/agents/chain-serializer.ts

@@ -22,6 +22,10 @@ function parseStepBody(agent: string, sectionBody: string): ChainStepConfig {
 		const key = keyValue.trim().toLowerCase();
 		const rawValue = rawValueValue.trim();
 
+		if (key === "machine") {
+			if (rawValue) step.machine = rawValue;
+			continue;
+		}
 		if (key === "output") {
 			if (rawValue === "false") step.output = false;
 			else if (rawValue) step.output = rawValue;
@@ -257,6 +261,7 @@ export function serializeChain(config: ChainConfig): string {
 	for (let i = 0; i < config.steps.length; i++) {
 		const step = config.steps[i]!;
 		lines.push(`## ${step.agent}`);
+		if (step.machine) lines.push(`machine: ${step.machine}`);
 		if (step.output === false) lines.push("output: false");
 		else if (step.output) lines.push(`output: ${step.output}`);
 		if (step.phase) lines.push(`phase: ${step.phase}`);
@@ -277,4 +282,4 @@ export function serializeChain(config: ChainConfig): string {
 	}
 
 	return `${lines.join("\n")}\n`;
-}
+}

package/dist/extensions/pi-subagents/src/agents/global-npm-root.ts

@@ -0,0 +1,58 @@
+import { exec, execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+/** Optional global package discovery; a failure never prevents local discovery. */
+export async function resolveGlobalNpmRoot(options: {
+	env?: NodeJS.ProcessEnv;
+	platform?: NodeJS.Platform;
+	timeoutMs?: number;
+} = {}): Promise<string | null> {
+	const env = options.env ?? process.env;
+	const offline = env.PI_OFFLINE?.toLowerCase();
+	if (offline === "1" || offline === "true" || offline === "yes") return null;
+
+	if ((options.platform ?? process.platform) === "win32" && env.APPDATA) {
+		const appDataRoot = path.join(env.APPDATA, "npm", "node_modules");
+		try {
+			if ((await fs.stat(appDataRoot)).isDirectory()) return await fs.realpath(appDataRoot);
+		} catch {
+			// Invalid APPDATA roots fall back to npm (including disappearing directories).
+		}
+	}
+
+	const timeoutMs = options.timeoutMs ?? 5000;
+	const output = await new Promise<string | null>((resolve) => {
+		let settled = false;
+		const finish = (value: string | null) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(value);
+		};
+		const commandOptions = {
+			encoding: "utf8",
+			timeout: timeoutMs,
+			windowsHide: true,
+			env,
+			maxBuffer: 64 * 1024,
+		} as const;
+		// POSIX npm is executable directly: killing a shell would leave npm running.
+		// Windows npm.cmd requires a shell, matching the existing command behavior.
+		const callback = (error: Error | null, stdout: string) => finish(error ? null : stdout.trim());
+		const child = (options.platform ?? process.platform) === "win32"
+			? exec("npm root -g", commandOptions, callback)
+			: execFile("npm", ["root", "-g"], commandOptions, callback);
+		// Resolve at the deadline even if inherited pipes hold the callback open.
+		const timer = setTimeout(() => {
+			child.kill();
+			finish(null);
+		}, timeoutMs);
+	});
+	if (!output) return null;
+	try {
+		return await fs.realpath(output);
+	} catch {
+		return null;
+	}
+}

package/dist/extensions/pi-subagents/src/agents/proactive-skills.ts

@@ -27,6 +27,7 @@ export interface ProactiveSkillSubagentRecommendation {
 export interface AvailableSkill {
 	name: string;
 	description?: string;
+	disableModelInvocation?: boolean;
 }
 
 function positiveInteger(value: unknown): number | undefined {
@@ -140,7 +141,9 @@ export function recommendProactiveSkillSubagents(input: {
 	}
 
 	return [...counts.entries()]
-		.filter(([skill, sources]) => sources.size >= config.minReferences && (!availableByName || availableByName.has(skill)))
+		// Hidden skills (disable-model-invocation: true) are user-only and must
+		// never surface in model-facing proactive recommendations.
+		.filter(([skill, sources]) => sources.size >= config.minReferences && (!availableByName || availableByName.has(skill)) && availableByName?.get(skill)?.disableModelInvocation !== true)
 		.map(([skill, sources]) => {
 			const description = availableByName?.get(skill)?.description;
 			return {
@@ -191,4 +194,4 @@ export function buildProactiveSkillSubagentRecommendationLines(input: {
 		availableSkills,
 		...(input.config !== undefined ? { config: input.config } : {}),
 	}));
-}
+}

package/dist/extensions/pi-subagents/src/agents/runtime-agent-registry.ts

@@ -5,7 +5,7 @@ import { validateAcceptanceInput } from "../runs/shared/acceptance.ts";
 import { validatePermissionRules, type PermissionRules } from "../runs/shared/permissions.ts";
 import { validateToolBudgetConfig } from "../runs/shared/tool-budget.ts";
 import { BUILTIN_AGENT_NAMES } from "./builtin-names.ts";
-import type { AgentConfig, AgentDefaultContext, AgentDiscoveryDiagnostic } from "./agents.ts";
+import { applyRuntimeAgentSettings, type AgentConfig, type AgentDefaultContext, type AgentDiscoveryDiagnostic, type RuntimeAgentSettingsContext } from "./agents.ts";
 
 export const RUNTIME_AGENT_REGISTRY_KEY = "pi-subagents.runtime-agents.v1";
 
@@ -24,7 +24,6 @@ export interface RuntimeAgentDefinition {
 	allowNestedSubagents?: boolean;
 	mcpDirectTools?: readonly string[];
 	model?: string;
-	fallbackModels?: readonly string[];
 	thinking?: string | false;
 	systemPromptMode?: "append" | "replace";
 	inheritProjectContext?: boolean;
@@ -37,6 +36,7 @@ export interface RuntimeAgentDefinition {
 	defaultAcceptance?: AcceptanceInput;
 	acceptanceRole?: AcceptanceRole;
 	runner?: AgentRunnerConfig;
+	machine?: string;
 	skills?: readonly string[];
 	skillPath?: readonly string[];
 	extensions?: readonly string[];
@@ -48,7 +48,6 @@ export interface RuntimeAgentDefinition {
 	defaultProgress?: boolean;
 	interactive?: boolean;
 	maxSubagentDepth?: number;
-	completionGuard?: boolean;
 	toolBudget?: ToolBudgetConfig;
 	permissions?: PermissionRules;
 }
@@ -199,11 +198,11 @@ function validateDefinition(value: unknown): RuntimeAgentDefinition {
 	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Runtime agent definition must be an object.");
 	const definition = value as Record<string, unknown>;
 	const supported = new Set([
-		"description", "systemPrompt", "aliases", "tools", "excludeTools", "allowNestedSubagents", "mcpDirectTools", "model", "fallbackModels", "thinking",
+		"description", "systemPrompt", "aliases", "tools", "excludeTools", "allowNestedSubagents", "mcpDirectTools", "model", "thinking",
 		"systemPromptMode", "inheritProjectContext", "inheritGlobalContext", "inheritSkills", "defaultContext", "defaultAsync", "defaultTimeoutMs",
-		"defaultToolTimeoutMs", "defaultAcceptance", "acceptanceRole", "runner", "skills", "skillPath",
+		"defaultToolTimeoutMs", "defaultAcceptance", "acceptanceRole", "runner", "machine", "skills", "skillPath",
 		"extensions", "subagentOnlyExtensions", "mutationTools", "output", "outputMode", "defaultReads", "defaultProgress", "interactive",
-		"maxSubagentDepth", "completionGuard", "toolBudget", "permissions",
+		"maxSubagentDepth", "toolBudget", "permissions",
 	]);
 	const unknown = Object.keys(definition).filter((key) => !supported.has(key));
 	if (unknown.length > 0) throw new Error(`Runtime agent definition has unknown fields: ${unknown.join(", ")}.`);
@@ -223,7 +222,7 @@ function validateDefinition(value: unknown): RuntimeAgentDefinition {
 	const allowNestedSubagents = validateBoolean(definition.allowNestedSubagents, "Runtime agent definition allowNestedSubagents");
 	const mcpDirectTools = validateStringList(definition.mcpDirectTools, "Runtime agent definition mcpDirectTools");
 	const model = validateOptionalString(definition.model, "Runtime agent definition model");
-	const fallbackModels = validateStringList(definition.fallbackModels, "Runtime agent definition fallbackModels");
+	if ((definition as Record<string, unknown>).fallbackModels !== undefined) throw new Error("Runtime agent definition fallbackModels was removed; configure one model instead.");
 	const inheritProjectContext = validateBoolean(definition.inheritProjectContext, "Runtime agent definition inheritProjectContext");
 	const inheritGlobalContext = validateBoolean(definition.inheritGlobalContext, "Runtime agent definition inheritGlobalContext");
 	const inheritSkills = validateBoolean(definition.inheritSkills, "Runtime agent definition inheritSkills");
@@ -237,12 +236,12 @@ function validateDefinition(value: unknown): RuntimeAgentDefinition {
 	const extensions = validateStringList(definition.extensions, "Runtime agent definition extensions");
 	const subagentOnlyExtensions = validateStringList(definition.subagentOnlyExtensions, "Runtime agent definition subagentOnlyExtensions");
 	const mutationTools = validateStringList(definition.mutationTools, "Runtime agent definition mutationTools");
+	const machine = validateOptionalString(definition.machine, "Runtime agent definition machine");
 	const output = validateOptionalString(definition.output, "Runtime agent definition output");
 	const defaultReads = validateStringList(definition.defaultReads, "Runtime agent definition defaultReads");
 	const defaultProgress = validateBoolean(definition.defaultProgress, "Runtime agent definition defaultProgress");
 	const interactive = validateBoolean(definition.interactive, "Runtime agent definition interactive");
 	const maxSubagentDepth = validatePositiveInteger(definition.maxSubagentDepth, "Runtime agent definition maxSubagentDepth");
-	const completionGuard = validateBoolean(definition.completionGuard, "Runtime agent definition completionGuard");
 	const toolBudget = validateToolBudget(definition.toolBudget);
 	const permissions = validatePermissionRules(definition.permissions, "Runtime agent definition permissions");
 	return {
@@ -254,7 +253,6 @@ function validateDefinition(value: unknown): RuntimeAgentDefinition {
 		...(allowNestedSubagents !== undefined ? { allowNestedSubagents } : {}),
 		...(mcpDirectTools ? { mcpDirectTools } : {}),
 		...(model ? { model } : {}),
-		...(fallbackModels ? { fallbackModels } : {}),
 		...(thinking !== undefined ? { thinking: thinking as string | false } : {}),
 		...(systemPromptMode !== undefined ? { systemPromptMode: systemPromptMode as "append" | "replace" } : {}),
 		...(inheritProjectContext !== undefined ? { inheritProjectContext } : {}),
@@ -272,13 +270,13 @@ function validateDefinition(value: unknown): RuntimeAgentDefinition {
 		...(extensions ? { extensions } : {}),
 		...(subagentOnlyExtensions ? { subagentOnlyExtensions } : {}),
 		...(mutationTools ? { mutationTools } : {}),
+		...(machine ? { machine } : {}),
 		...(output ? { output } : {}),
 		...(outputMode !== undefined ? { outputMode: outputMode as OutputMode } : {}),
 		...(defaultReads ? { defaultReads } : {}),
 		...(defaultProgress !== undefined ? { defaultProgress } : {}),
 		...(interactive !== undefined ? { interactive } : {}),
 		...(maxSubagentDepth !== undefined ? { maxSubagentDepth } : {}),
-		...(completionGuard !== undefined ? { completionGuard } : {}),
 		...(toolBudget !== undefined ? { toolBudget } : {}),
 		...(permissions !== undefined ? { permissions } : {}),
 	};
@@ -334,7 +332,6 @@ function toAgentConfig(name: string, definition: RuntimeAgentDefinition): AgentC
 		...(definition.allowNestedSubagents !== undefined ? { allowNestedSubagents: definition.allowNestedSubagents } : {}),
 		...(definition.mcpDirectTools !== undefined ? { mcpDirectTools: [...definition.mcpDirectTools] } : {}),
 		...(definition.model !== undefined ? { model: definition.model } : {}),
-		...(definition.fallbackModels !== undefined ? { fallbackModels: [...definition.fallbackModels] } : {}),
 		...(definition.thinking !== undefined ? { thinking: definition.thinking } : {}),
 		systemPromptMode: definition.systemPromptMode ?? defaultSystemPromptMode(name),
 		inheritProjectContext: definition.inheritProjectContext ?? defaultInheritProjectContext(name),
@@ -354,13 +351,13 @@ function toAgentConfig(name: string, definition: RuntimeAgentDefinition): AgentC
 		...(definition.extensions !== undefined ? { extensions: [...definition.extensions] } : {}),
 		...(definition.subagentOnlyExtensions !== undefined ? { subagentOnlyExtensions: [...definition.subagentOnlyExtensions] } : {}),
 		...(definition.mutationTools !== undefined ? { mutationTools: [...definition.mutationTools] } : {}),
+		...(definition.machine !== undefined ? { machine: definition.machine } : {}),
 		...(definition.output !== undefined ? { output: definition.output } : {}),
 		...(definition.outputMode !== undefined ? { outputMode: definition.outputMode } : {}),
 		...(definition.defaultReads !== undefined ? { defaultReads: [...definition.defaultReads] } : {}),
 		...(definition.defaultProgress !== undefined ? { defaultProgress: definition.defaultProgress } : {}),
 		...(definition.interactive !== undefined ? { interactive: definition.interactive } : {}),
 		...(definition.maxSubagentDepth !== undefined ? { maxSubagentDepth: definition.maxSubagentDepth } : {}),
-		...(definition.completionGuard !== undefined ? { completionGuard: definition.completionGuard } : {}),
 		...(definition.toolBudget !== undefined ? { toolBudget: definition.toolBudget } : {}),
 		...(definition.permissions !== undefined ? { permissions: definition.permissions } : {}),
 	};
@@ -420,10 +417,17 @@ function assertNoConfiguredCollision(configuredAgents: readonly AgentConfig[], r
 	}
 }
 
-export function mergeRuntimeAgents<T extends { agents: AgentConfig[]; agentDiagnostics?: AgentDiscoveryDiagnostic[] }>(pi: RuntimeAgentOwner, discovered: T, configuredAgents: readonly AgentConfig[] = discovered.agents): T {
-	const runtimeAgents = listRuntimeAgentConfigs(pi).filter((agent) => agent.disabled !== true);
-	if (runtimeAgents.length === 0) return discovered;
-	assertNoIdentityCollisions(runtimeAgents, "Runtime agent registration");
-	assertNoConfiguredCollision(configuredAgents, runtimeAgents);
+/**
+ * Append registered runtime agents to a discovery result. With `settings`, the
+ * runtime agents also receive the subagent model-tier settings that apply in
+ * that discovery context (see `applyRuntimeAgentSettings`); without it they
+ * carry only their registered definition.
+ */
+export function mergeRuntimeAgents<T extends { agents: AgentConfig[]; agentDiagnostics?: AgentDiscoveryDiagnostic[] }>(pi: RuntimeAgentOwner, discovered: T, configuredAgents: readonly AgentConfig[] = discovered.agents, settings?: RuntimeAgentSettingsContext): T {
+	const registered = listRuntimeAgentConfigs(pi).filter((agent) => agent.disabled !== true);
+	if (registered.length === 0) return discovered;
+	assertNoIdentityCollisions(registered, "Runtime agent registration");
+	assertNoConfiguredCollision(configuredAgents, registered);
+	const runtimeAgents = settings ? applyRuntimeAgentSettings(registered, settings) : registered;
 	return { ...discovered, agents: [...discovered.agents, ...runtimeAgents] };
-}
+}

package/dist/extensions/pi-subagents/src/agents/skills.ts

@@ -6,6 +6,7 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
 import { parseFrontmatter } from "./frontmatter.ts";
 import { getAgentDir, getProjectConfigDir } from "../shared/utils.ts";
 
@@ -26,6 +27,7 @@ interface ResolvedSkill {
 	content: string;
 	description?: string;
 	source: SkillSource;
+	disableModelInvocation?: boolean;
 }
 
 interface SkillCacheEntry {
@@ -38,6 +40,7 @@ interface CachedSkillEntry {
 	filePath: string;
 	source: SkillSource;
 	description?: string;
+	disableModelInvocation?: boolean;
 	order: number;
 }
 
@@ -142,7 +145,7 @@ function getGlobalNpmRoot(): string | null {
 	}
 
 	try {
-		cachedGlobalNpmRoot = fs.realpathSync(execSync("npm root -g", { encoding: "utf-8", timeout: 5000, windowsHide: true }).trim());
+		cachedGlobalNpmRoot = fs.realpathSync(execSync("npm root -g", { encoding: "utf-8", timeout: 5000, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }).trim());
 		return cachedGlobalNpmRoot;
 	} catch {
 		// Global npm root is optional in constrained environments.
@@ -399,11 +402,30 @@ function parseSkillDescription(content: string): string | undefined {
 	return parseFrontmatter(content).frontmatter.description;
 }
 
-function maybeReadSkillDescription(filePath: string): string | undefined {
+function maybeReadSkillMetadata(filePath: string): Pick<CachedSkillEntry, "description" | "disableModelInvocation"> {
 	try {
-		return parseSkillDescription(fs.readFileSync(filePath, "utf-8"));
+		const content = fs.readFileSync(filePath, "utf-8");
+		return { description: parseSkillDescription(content), disableModelInvocation: maybeReadSkillDisableModelInvocation(content) };
 	} catch {
-		// Description parsing is best-effort metadata extraction.
+		return {};
+	}
+}
+
+function maybeReadSkillDisableModelInvocation(content: string): boolean | undefined {
+	try {
+		const normalized = content.replace(/\r\n/g, "\n");
+		if (!normalized.startsWith("---")) return undefined;
+		const endIndex = normalized.indexOf("\n---", 3);
+		if (endIndex === -1) return undefined;
+		const parsed: unknown = parseYaml(normalized.slice(4, endIndex));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+		// Match the pi host's skill loader semantics: only YAML boolean true
+		// disables model invocation; strings and other values stay invocable.
+		// Hidden skills remain user-invocable via explicit `/skill:name` commands
+		// but must stay out of the model-facing default skill set.
+		return (parsed as Record<string, unknown>)["disable-model-invocation"] === true ? true : undefined;
+	} catch {
+		// Best-effort metadata extraction.
 		return undefined;
 	}
 }
@@ -418,17 +440,18 @@ function collectFilesystemSkills(cwd: string, agentDir: string, skillPaths: Skil
 		const resolvedFile = path.resolve(filePath);
 		if (!fs.existsSync(resolvedFile)) return;
 		const source = inferSkillSource(resolvedFile, cwd, agentDir, sourceHint);
-		const description = maybeReadSkillDescription(resolvedFile);
+		const { description, disableModelInvocation } = maybeReadSkillMetadata(resolvedFile);
 		const existingIndex = seen.get(resolvedFile);
 		if (existingIndex !== undefined) {
 			const existing = entries[existingIndex];
 			if (existing && (SOURCE_PRIORITY[source] ?? 0) > (SOURCE_PRIORITY[existing.source] ?? 0)) {
-				const { description: _description, ...existingWithoutDescription } = existing;
+				const { description: _description, disableModelInvocation: _disableModelInvocation, ...existingWithoutMetadata } = existing;
 				entries[existingIndex] = {
-					...existingWithoutDescription,
+					...existingWithoutMetadata,
 					name,
 					source,
 					...(description !== undefined ? { description } : {}),
+					...(disableModelInvocation !== undefined ? { disableModelInvocation } : {}),
 				};
 			}
 			return;
@@ -439,6 +462,7 @@ function collectFilesystemSkills(cwd: string, agentDir: string, skillPaths: Skil
 			filePath: resolvedFile,
 			source,
 			...(description !== undefined ? { description } : {}),
+			...(disableModelInvocation !== undefined ? { disableModelInvocation } : {}),
 			order: order++,
 		});
 	};
@@ -598,11 +622,13 @@ function readSkill(
 		const raw = fs.readFileSync(skillPath, "utf-8");
 		const content = stripSkillFrontmatter(raw);
 		const description = parseSkillDescription(raw);
+		const disableModelInvocation = maybeReadSkillDisableModelInvocation(raw);
 		const skill: ResolvedSkill = {
 			name: skillName,
 			path: skillPath,
 			content,
 			...(description !== undefined ? { description } : {}),
+			...(disableModelInvocation !== undefined ? { disableModelInvocation } : {}),
 			source,
 		};
 
@@ -679,7 +705,12 @@ export function resolveSkillsWithFallback(
 }
 
 export function buildSkillInjection(skills: ResolvedSkill[]): string {
-	if (skills.length === 0) return "";
+	// Hidden skills (disable-model-invocation: true) must never reach a child
+	// prompt, even if a caller resolves them by name. This is the single
+	// chokepoint every prompt-injection path funnels through, so filtering
+	// here closes the leak regardless of which caller assembled the list.
+	const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
+	if (visibleSkills.length === 0) return "";
 
 	const lines = [
 		"The following configured skills are available to this subagent.",
@@ -688,7 +719,7 @@ export function buildSkillInjection(skills: ResolvedSkill[]): string {
 		"",
 		"<available_skills>",
 	];
-	for (const skill of skills) {
+	for (const skill of visibleSkills) {
 		lines.push("  <skill>");
 		lines.push(`    <name>${escapeXmlText(skill.name)}</name>`);
 		lines.push(`    <description>${escapeXmlText(skill.description ?? "")}</description>`);
@@ -736,6 +767,7 @@ export function discoverAvailableSkills(cwd: string): Array<{
 	name: string;
 	source: SkillSource;
 	description?: string;
+	disableModelInvocation?: boolean;
 }> {
 	const skills = getCachedSkills(cwd);
 	return skills
@@ -744,6 +776,7 @@ export function discoverAvailableSkills(cwd: string): Array<{
 			name: s.name,
 			source: s.source,
 			...(s.description !== undefined ? { description: s.description } : {}),
+			...(s.disableModelInvocation !== undefined ? { disableModelInvocation: s.disableModelInvocation } : {}),
 		}))
 		.sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -751,4 +784,4 @@ export function discoverAvailableSkills(cwd: string): Array<{
 export function clearSkillCache(): void {
 	skillCache.clear();
 	loadSkillsCache = null;
-}
+}

package/dist/extensions/pi-subagents/src/api/delegation.ts

@@ -1,3 +1,5 @@
+import type { IntercomBridgeConfig } from "../shared/types.ts";
+
 // This is the established extension-to-extension transport. The structured
 // delegation API intentionally reuses it instead of adding a second event
 // protocol. Unstructured legacy direct payloads are rejected.
@@ -35,6 +37,8 @@ export interface SubagentDelegationRequest {
 	toolBudget?: SubagentDelegationToolBudget;
 	skill?: string | string[] | boolean;
 	artifacts?: boolean;
+	/** Per-launch bridge config; replaces the global `intercomBridge` config. Pass the same value to preflight to compare digests. */
+	intercomBridge?: IntercomBridgeConfig;
 	result: SubagentDelegationResultRequest;
 }
 
@@ -44,6 +48,20 @@ export interface SubagentDelegationStarted {
 	nodeId: string;
 }
 
+/**
+ * Cumulative usage for one attempt at one observation time. This snapshot is
+ * emitted only when every counter is known, finite, and non-negative. It does
+ * not combine retries or replace authoritative terminal usage; absence means
+ * unavailable, not zero. UPDATE `tokens` keeps its input-plus-output meaning.
+ */
+export interface SubagentDelegationUpdateUsage {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	turns: number;
+}
+
 export interface SubagentDelegationUpdate extends SubagentDelegationStarted {
 	runId?: string;
 	currentTool?: string;
@@ -55,6 +73,7 @@ export interface SubagentDelegationUpdate extends SubagentDelegationStarted {
 	toolCount?: number;
 	durationMs?: number;
 	tokens?: number;
+	usage?: SubagentDelegationUpdateUsage;
 }
 
 export type SubagentDelegationStatus =
@@ -109,4 +128,4 @@ export interface SubagentDelegationInvalidResponse {
 
 export type SubagentDelegationResponse = SubagentDelegationTerminalResponse | SubagentDelegationInvalidResponse;
 
-export interface SubagentDelegationCancel extends SubagentDelegationStarted {}
+export interface SubagentDelegationCancel extends SubagentDelegationStarted {}

package/dist/extensions/pi-subagents/src/api/inspectors.ts

@@ -0,0 +1,27 @@
+import type { ExtensionAPI } from "@selesai/code";
+import type { InspectorPlugin } from "../inspectors/types.ts";
+
+export type { InspectorContext, InspectorLaunch, InspectorParams, InspectorPlugin, InspectorTarget } from "../inspectors/types.ts";
+
+export const INSPECTOR_REGISTER_EVENT = "pi-subagents:inspector-register:v1";
+
+export interface InspectorRegistration {
+	dispose(): void;
+}
+
+export interface InspectorRegistrationRequest {
+	version: 1;
+	plugin: InspectorPlugin;
+	result?:
+		| { ok: true; registration: InspectorRegistration }
+		| { ok: false; error: Error };
+}
+
+/** Register with the installed owner, even when each extension has its own module root. */
+export function registerInspector(pi: Pick<ExtensionAPI, "events">, plugin: InspectorPlugin): InspectorRegistration {
+	const request: InspectorRegistrationRequest = { version: 1, plugin };
+	pi.events.emit(INSPECTOR_REGISTER_EVENT, request);
+	if (!request.result) throw new Error("pi-subagents is not installed, not ready, or does not support inspector registration.");
+	if (!request.result.ok) throw request.result.error;
+	return request.result.registration;
+}