@pi-ohm/subagents 0.6.4-dev.25614589665.1.cd7b959 → 0.6.4-dev.25632661332.1.3bf351f

package/dist/agent-controller.d.ts

@@ -0,0 +1,76 @@
+import { AgentToolResult, ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Api, Model, Static, Type } from "@earendil-works/pi-ai";
+import { Result } from "better-result";
+import { ThinkingLevel } from "@earendil-works/pi-agent-core";
+
+//#region src/agent-controller.d.ts
+declare const SpawnAgentArgsSchema: Type.TObject<{
+  task_name: Type.TString;
+  prompt: Type.TString;
+  summary: Type.TString;
+  agent_type: Type.TOptional<Type.TString>;
+  model: Type.TOptional<Type.TString>;
+  thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">]>>;
+  max_turns: Type.TOptional<Type.TNumber>;
+  run_in_background: Type.TOptional<Type.TBoolean>;
+  fork_context: Type.TOptional<Type.TBoolean>;
+}>;
+declare const SendAgentInputArgsSchema: Type.TObject<{
+  target: Type.TString;
+  prompt: Type.TString;
+  mode: Type.TOptional<Type.TUnion<[Type.TLiteral<"prompt">, Type.TLiteral<"steer">, Type.TLiteral<"follow_up">]>>;
+}>;
+declare const WaitAgentArgsSchema: Type.TObject<{
+  targets: Type.TArray<Type.TString>;
+  timeout_ms: Type.TOptional<Type.TNumber>;
+}>;
+declare const CloseAgentArgsSchema: Type.TObject<{
+  target: Type.TString;
+}>;
+declare const ResumeAgentArgsSchema: Type.TObject<{
+  id: Type.TString;
+}>;
+declare const GetAgentResultArgsSchema: Type.TObject<{
+  target: Type.TString;
+}>;
+declare const ListAgentsArgsSchema: Type.TObject<{
+  path_prefix: Type.TOptional<Type.TString>;
+}>;
+type SpawnAgentArgs = Static<typeof SpawnAgentArgsSchema>;
+type SendAgentInputArgs = Static<typeof SendAgentInputArgsSchema>;
+type WaitAgentArgs = Static<typeof WaitAgentArgsSchema>;
+type CloseAgentArgs = Static<typeof CloseAgentArgsSchema>;
+type ResumeAgentArgs = Static<typeof ResumeAgentArgsSchema>;
+type GetAgentResultArgs = Static<typeof GetAgentResultArgsSchema>;
+type ListAgentsArgs = Static<typeof ListAgentsArgsSchema>;
+interface ResolvedSpawnConfig {
+  readonly agentType: string;
+  readonly model: Model<Api>;
+  readonly modelKey: string;
+  readonly agentDir: string;
+  readonly thinking: ThinkingLevel;
+  readonly tools?: readonly string[];
+  readonly prompt: string;
+}
+declare function registerAgentControllerTool(pi: Pick<ExtensionAPI, "registerTool" | "appendEntry" | "getThinkingLevel" | "on">): void;
+declare function createSubagentToolRuntime(pi: Pick<ExtensionAPI, "appendEntry" | "getThinkingLevel">): SubagentToolRuntime;
+interface SubagentToolRuntime {
+  spawn(params: SpawnAgentArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  send(params: SendAgentInputArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  wait(params: WaitAgentArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  close(params: CloseAgentArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  resume(params: ResumeAgentArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  get(params: GetAgentResultArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  list(params: ListAgentsArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  dispose(): Promise<void>;
+}
+type ToolContext = Parameters<ToolDefinition["execute"]>[4];
+declare function createSubagentTools(runtime: SubagentToolRuntime): readonly ToolDefinition[];
+declare function resolveSpawnConfig(input: {
+  readonly cwd: string;
+  readonly params: SpawnAgentArgs;
+  readonly currentModel?: Model<Api>;
+  readonly currentThinking?: ThinkingLevel;
+}): Promise<Result<ResolvedSpawnConfig, Error>>;
+//#endregion
+export { SubagentToolRuntime, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveSpawnConfig };

package/dist/agent-controller.js

@@ -0,0 +1,443 @@
+import { isSubagentRuntimeConfig, resolveSubagentProfileRuntimeConfig, subagentsConfigModule } from "./config.js";
+import { AuthStorage, ModelRegistry, defineTool } from "@earendil-works/pi-coding-agent";
+import path from "node:path";
+import { Type, getModels, getProviders } from "@earendil-works/pi-ai";
+import { Result } from "better-result";
+import { PipController, createSdkPipRunner } from "@pi-ohm/core/pip";
+import { loadConfig, pickConfig, resolveExtensionConfigDir } from "@pi-ohm/core/config";
+
+//#region src/agent-controller.ts
+const defaultModel = "openai-codex/gpt-5.4-mini:medium";
+const ThinkingLevelSchema = Type.Union([
+	Type.Literal("off"),
+	Type.Literal("minimal"),
+	Type.Literal("low"),
+	Type.Literal("medium"),
+	Type.Literal("high"),
+	Type.Literal("xhigh")
+]);
+const SpawnAgentArgsSchema = Type.Object({
+	task_name: Type.String({ minLength: 1 }),
+	prompt: Type.String({ minLength: 1 }),
+	summary: Type.String({ minLength: 1 }),
+	agent_type: Type.Optional(Type.String({ minLength: 1 })),
+	model: Type.Optional(Type.String({ minLength: 1 })),
+	thinking: Type.Optional(ThinkingLevelSchema),
+	max_turns: Type.Optional(Type.Number()),
+	run_in_background: Type.Optional(Type.Boolean()),
+	fork_context: Type.Optional(Type.Boolean())
+});
+const SendAgentInputArgsSchema = Type.Object({
+	target: Type.String({ minLength: 1 }),
+	prompt: Type.String({ minLength: 1 }),
+	mode: Type.Optional(Type.Union([
+		Type.Literal("prompt"),
+		Type.Literal("steer"),
+		Type.Literal("follow_up")
+	]))
+});
+const WaitAgentArgsSchema = Type.Object({
+	targets: Type.Array(Type.String({ minLength: 1 })),
+	timeout_ms: Type.Optional(Type.Number())
+});
+const CloseAgentArgsSchema = Type.Object({ target: Type.String({ minLength: 1 }) });
+const ResumeAgentArgsSchema = Type.Object({ id: Type.String({ minLength: 1 }) });
+const GetAgentResultArgsSchema = Type.Object({ target: Type.String({ minLength: 1 }) });
+const ListAgentsArgsSchema = Type.Object({ path_prefix: Type.Optional(Type.String()) });
+function registerAgentControllerTool(pi) {
+	const runtime = createSubagentToolRuntime(pi);
+	for (const tool of createSubagentTools(runtime)) pi.registerTool(tool);
+	pi.on("session_shutdown", async () => {
+		await runtime.dispose();
+	});
+}
+function createSubagentToolRuntime(pi) {
+	const controllers = new Map();
+	return {
+		async spawn(params, ctx) {
+			const parentSessionId = ctx.sessionManager.getSessionId();
+			const record = getRecord(controllers, parentSessionId);
+			const config = await resolveSpawnConfig({
+				cwd: ctx.cwd,
+				params,
+				currentModel: ctx.model,
+				currentThinking: pi.getThinkingLevel()
+			});
+			if (Result.isError(config)) return toolError(config.error.message);
+			const key = controllerKey(config.value);
+			const currentController = record.controllers.get(key);
+			const created = currentController ? Result.ok(currentController) : createPipController({
+				pi,
+				config: config.value
+			});
+			if (Result.isError(created)) return toolError(created.error.message);
+			const controller = created.value;
+			if (!currentController) record.controllers.set(key, controller);
+			if (ctx.hasUI) ctx.ui.notify(`subagent spawned: ${params.task_name}`, "info");
+			const spawned = await controller.spawn({
+				ownerPackage: "@pi-ohm/subagents",
+				role: config.value.agentType,
+				parentSessionId,
+				cwd: ctx.cwd,
+				prompt: config.value.prompt,
+				runInBackground: params.run_in_background ?? true,
+				parentSessionFile: params.fork_context ? ctx.sessionManager.getSessionFile() : undefined
+			});
+			if (Result.isError(spawned)) return toolError(spawned.error.message);
+			record.taskIds.set(params.task_name, spawned.value.pipId);
+			record.taskControllers.set(spawned.value.pipId, controller);
+			if (ctx.hasUI && spawned.value.status.state !== "running") {
+				ctx.ui.notify(`subagent finished: ${params.task_name} (${spawned.value.status.state})`, "info");
+			}
+			return toolOk({
+				task_name: params.task_name,
+				task_id: spawned.value.pipId,
+				nickname: null,
+				child_session_path: spawned.value.childSessionPath,
+				status: spawned.value.status
+			});
+		},
+		async send(params, ctx) {
+			const record = getRecord(controllers, ctx.sessionManager.getSessionId());
+			const pipId = resolveTarget(record, params.target);
+			const controller = resolveController(record, pipId);
+			if (!controller) return toolError(`Subagent '${params.target}' was not found`);
+			const sent = await controller.send({
+				pipId,
+				prompt: params.prompt,
+				mode: params.mode
+			});
+			if (Result.isError(sent)) return toolError(sent.error.message);
+			return toolOk(sent.value);
+		},
+		async wait(params, ctx) {
+			const record = getRecord(controllers, ctx.sessionManager.getSessionId());
+			const statuses = {};
+			for (const target of params.targets) {
+				const pipId = resolveTarget(record, target);
+				const controller = resolveController(record, pipId);
+				if (!controller) {
+					statuses[target] = { state: "not_found" };
+					continue;
+				}
+				const waited = await controller.wait({
+					pipIds: [pipId],
+					timeoutMs: params.timeout_ms
+				});
+				if (Result.isError(waited)) return toolError(waited.error.message);
+				statuses[target] = waited.value.statuses[pipId] ?? { state: "not_found" };
+			}
+			return toolOk({
+				statuses,
+				timedOut: false
+			});
+		},
+		async close(params, ctx) {
+			const record = getRecord(controllers, ctx.sessionManager.getSessionId());
+			const pipId = resolveTarget(record, params.target);
+			const controller = resolveController(record, pipId);
+			if (!controller) return toolError(`Subagent '${params.target}' was not found`);
+			const closed = await controller.close({ pipId });
+			if (Result.isError(closed)) return toolError(closed.error.message);
+			if (ctx.hasUI) ctx.ui.notify(`subagent closed: ${params.target}`, "info");
+			return toolOk(closed.value);
+		},
+		async resume(params, ctx) {
+			const record = getRecord(controllers, ctx.sessionManager.getSessionId());
+			const pipId = resolveTarget(record, params.id);
+			const controller = resolveController(record, pipId);
+			if (!controller) return toolError(`Subagent '${params.id}' was not found`);
+			const resumed = await controller.resume({ pipId });
+			if (Result.isError(resumed)) return toolError(resumed.error.message);
+			return toolOk(resumed.value);
+		},
+		async get(params, ctx) {
+			const record = getRecord(controllers, ctx.sessionManager.getSessionId());
+			const pipId = resolveTarget(record, params.target);
+			const controller = resolveController(record, pipId);
+			if (!controller) return toolError(`Subagent '${params.target}' was not found`);
+			const found = await controller.get({ pipId });
+			if (Result.isError(found)) return toolError(found.error.message);
+			return toolOk({
+				target: params.target,
+				status: found.value.status,
+				result: statusResult(found.value.status),
+				session_path: found.value.childSessionPath
+			});
+		},
+		async list(params, ctx) {
+			const record = getRecord(controllers, ctx.sessionManager.getSessionId());
+			const agents = [];
+			for (const [agentName, pipId] of record.taskIds.entries()) {
+				if (params.path_prefix && !agentName.startsWith(params.path_prefix)) continue;
+				const controller = resolveController(record, pipId);
+				const found = controller ? await controller.get({ pipId }) : Result.ok(undefined);
+				const status = Result.isOk(found) && found.value ? found.value.status : { state: "not_found" };
+				agents.push({
+					agent_name: agentName,
+					agent_status: status,
+					task_id: pipId,
+					last_task_message: null
+				});
+			}
+			return toolOk({ agents });
+		},
+		async dispose() {
+			for (const record of controllers.values()) {
+				for (const [pipId, controller] of record.taskControllers.entries()) {
+					await controller.close({ pipId });
+				}
+			}
+			controllers.clear();
+		}
+	};
+}
+function createSubagentTools(runtime) {
+	return [
+		defineTool({
+			name: "spawn_agent",
+			label: "Spawn Agent",
+			description: "Spawn a Pi-backed subagent session and submit the initial prompt.",
+			parameters: SpawnAgentArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.spawn(params, ctx)
+		}),
+		defineTool({
+			name: "send_agent_input",
+			label: "Send Agent Input",
+			description: "Send follow-up input to an existing subagent session.",
+			parameters: SendAgentInputArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.send(params, ctx)
+		}),
+		defineTool({
+			name: "wait_agent",
+			label: "Wait Agent",
+			description: "Wait for one or more subagents and return their current statuses.",
+			parameters: WaitAgentArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.wait(params, ctx)
+		}),
+		defineTool({
+			name: "close_agent",
+			label: "Close Agent",
+			description: "Close a subagent session.",
+			parameters: CloseAgentArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.close(params, ctx)
+		}),
+		defineTool({
+			name: "resume_agent",
+			label: "Resume Agent",
+			description: "Resume a known subagent session in the current parent session runtime.",
+			parameters: ResumeAgentArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.resume(params, ctx)
+		}),
+		defineTool({
+			name: "get_agent_result",
+			label: "Get Agent Result",
+			description: "Get status and result text for a subagent session.",
+			parameters: GetAgentResultArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.get(params, ctx)
+		}),
+		defineTool({
+			name: "list_agents",
+			label: "List Agents",
+			description: "List subagents known to the current parent session runtime.",
+			parameters: ListAgentsArgsSchema,
+			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.list(params, ctx)
+		})
+	];
+}
+function getRecord(map, parentSessionId) {
+	const current = map.get(parentSessionId);
+	if (current) return current;
+	const record = createControllerRecord();
+	map.set(parentSessionId, record);
+	return record;
+}
+function createControllerRecord() {
+	return {
+		taskIds: new Map(),
+		taskControllers: new Map(),
+		controllers: new Map()
+	};
+}
+function createPipController(input) {
+	return Result.ok(new PipController({
+		runner: createSdkPipRunner({
+			model: input.config.model,
+			agentDir: input.config.agentDir,
+			thinkingLevel: input.config.thinking,
+			tools: input.config.tools
+		}),
+		entries: { write(entry) {
+			input.pi.appendEntry("pi-ohm.pip", entry);
+			return Result.ok(entry.pipId);
+		} }
+	}));
+}
+function controllerKey(config) {
+	return `${config.modelKey}:${config.thinking}:${config.tools?.join(",") ?? "default"}`;
+}
+async function resolveSpawnConfig(input) {
+	const loaded = await loadConfig({
+		cwd: input.cwd,
+		modules: [subagentsConfigModule]
+	});
+	if (Result.isError(loaded)) return Result.err(loaded.error);
+	const subagents = pickConfig({
+		loaded: loaded.value,
+		module: subagentsConfigModule,
+		is: isSubagentRuntimeConfig
+	});
+	if (Result.isError(subagents)) return Result.err(subagents.error);
+	const agentType = input.params.agent_type?.trim() || input.params.task_name.trim();
+	const currentModelPattern = input.currentModel ? modelKey(input.currentModel) : undefined;
+	const baseProfile = resolveSubagentProfileRuntimeConfig({
+		config: { subagents: subagents.value },
+		subagentId: agentType,
+		modelPattern: input.params.model ?? currentModelPattern
+	});
+	const profile = resolveSubagentProfileRuntimeConfig({
+		config: { subagents: subagents.value },
+		subagentId: agentType,
+		modelPattern: input.params.model ?? baseProfile?.model ?? currentModelPattern
+	});
+	const agentDir = resolveExtensionConfigDir();
+	const modelSpec = Result.try({
+		try: () => parseModelSpec({
+			agentDir,
+			spec: input.params.model ?? profile?.model,
+			currentModel: input.currentModel
+		}),
+		catch: (cause) => cause instanceof Error ? cause : new Error(String(cause))
+	});
+	if (Result.isError(modelSpec)) return Result.err(modelSpec.error);
+	const thinking = input.params.thinking ?? profile?.thinking ?? (input.params.model || profile?.model ? modelSpec.value.thinkingLevel : input.currentThinking) ?? modelSpec.value.thinkingLevel;
+	return Result.ok({
+		agentType,
+		model: modelSpec.value.model,
+		modelKey: modelSpec.value.modelKey,
+		agentDir,
+		thinking,
+		tools: resolveTools(profile),
+		prompt: resolvePrompt({
+			profile,
+			prompt: input.params.prompt
+		})
+	});
+}
+function modelKey(model) {
+	return `${model.provider}/${model.id}`;
+}
+function resolveTools(profile) {
+	if (!profile?.tools) return undefined;
+	const denied = new Set(Object.entries(profile.permissions).filter((entry) => entry[1] === "deny").map((entry) => entry[0]));
+	const tools = profile.tools.filter((tool) => !denied.has(tool.trim().toLowerCase()));
+	if (tools.length === 0) return undefined;
+	return tools;
+}
+function resolvePrompt(input) {
+	if (!input.profile?.prompt) return input.prompt;
+	return `${input.profile.prompt}\n\nTask:\n${input.prompt}`;
+}
+function resolveTarget(record, target) {
+	return record.taskIds.get(target) ?? target;
+}
+function resolveController(record, pipId) {
+	return record.taskControllers.get(pipId);
+}
+function parseModelSpec(input) {
+	if (!input.spec && input.currentModel) {
+		return {
+			model: input.currentModel,
+			modelKey: modelKey(input.currentModel),
+			thinkingLevel: "medium"
+		};
+	}
+	const spec = input.spec ?? defaultModel;
+	const slash = spec.indexOf("/");
+	if (slash <= 0 || slash >= spec.length - 1) {
+		throw new Error(`Invalid subagent model '${spec}'. Expected '<provider>/<model>'`);
+	}
+	const colon = spec.lastIndexOf(":");
+	const provider = spec.slice(0, slash).trim();
+	const modelId = spec.slice(slash + 1, colon > slash ? colon : undefined).trim();
+	if (provider.length === 0 || modelId.length === 0) {
+		throw new Error(`Invalid subagent model '${spec}'. Expected '<provider>/<model>'`);
+	}
+	const thinkingLevel = parseThinkingLevel(colon > slash ? spec.slice(colon + 1) : "medium");
+	const registry = ModelRegistry.create(AuthStorage.create(path.join(input.agentDir, "auth.json")), path.join(input.agentDir, "models.json"));
+	const registeredModel = registry.find(provider, modelId);
+	if (registeredModel) return {
+		model: registeredModel,
+		modelKey: `${provider}/${modelId}`,
+		thinkingLevel
+	};
+	const knownProvider = getProviders().find((candidate) => candidate === provider);
+	const model = knownProvider ? getModels(knownProvider).find((candidate) => candidate.id === modelId) ?? createExternalModel({
+		provider,
+		modelId
+	}) : createExternalModel({
+		provider,
+		modelId
+	});
+	return {
+		model,
+		modelKey: `${provider}/${modelId}`,
+		thinkingLevel
+	};
+}
+function createExternalModel(input) {
+	const api = input.provider;
+	return {
+		id: input.modelId,
+		name: input.modelId,
+		api,
+		provider: input.provider,
+		baseUrl: "",
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 128e3,
+		maxTokens: 8192
+	};
+}
+function parseThinkingLevel(input) {
+	const level = input.trim().toLowerCase();
+	if (level === "off") return "off";
+	if (level === "minimal") return "minimal";
+	if (level === "low") return "low";
+	if (level === "medium") return "medium";
+	if (level === "high") return "high";
+	if (level === "xhigh") return "xhigh";
+	throw new Error(`Unknown subagent thinking level '${input}'`);
+}
+function statusResult(status) {
+	if (status.state === "completed") return status.result;
+	if (status.state === "errored") return status.error;
+	return null;
+}
+function toolOk(value) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(value, null, 2)
+		}],
+		details: value
+	};
+}
+function toolError(message) {
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify({ error: message }, null, 2)
+		}],
+		details: { error: message }
+	};
+}
+
+//#endregion
+export { createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveSpawnConfig };

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { SubagentProfilePatch, SubagentProfilePatchSchema, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatch, SubagentProfileVariantPatchSchema, SubagentToolPermissionDecisionPatch, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, parseSubagentProfilePatch, parseSubagentProfileVariantPatch } from "./schema.js";
-import { Type } from "typebox";
 import * as _$_pi_ohm_core_config0 from "@pi-ohm/core/config";
+import { Type } from "typebox";
 
 //#region src/config.d.ts
 declare const SubagentsConfigSchema: Type.TRecord<"^.*$", Type.TUnknown>;
@@ -9,6 +9,9 @@ interface SubagentsConfig {
 }
 interface SubagentProfileRuntimeConfig {
   model?: string;
+  thinking?: SubagentThinkingLevel;
+  tools?: readonly string[];
+  maxTurns?: number;
   prompt?: string;
   description?: string;
   whenToUse?: readonly string[];
@@ -18,6 +21,9 @@ interface SubagentProfileRuntimeConfig {
 type SubagentToolPermissionDecision = "allow" | "deny" | "inherit";
 interface SubagentProfileVariantRuntimeConfig {
   model?: string;
+  thinking?: SubagentThinkingLevel;
+  tools?: readonly string[];
+  maxTurns?: number;
   prompt?: string;
   description?: string;
   whenToUse?: readonly string[];
@@ -25,6 +31,9 @@ interface SubagentProfileVariantRuntimeConfig {
 }
 interface ResolvedSubagentProfileRuntimeConfig {
   model?: string;
+  thinking?: SubagentThinkingLevel;
+  tools?: readonly string[];
+  maxTurns?: number;
   prompt?: string;
   description?: string;
   whenToUse?: readonly string[];
@@ -43,6 +52,7 @@ interface SubagentRuntimeConfig {
   profiles: Record<string, SubagentProfileRuntimeConfig>;
 }
 type SubagentBackend = "none" | "interactive-shell" | "interactive-sdk" | "custom-plugin";
+type SubagentThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 interface RuntimeConfigWithSubagents {
   readonly subagents?: SubagentRuntimeConfig;
 }
@@ -66,4 +76,4 @@ declare function resolveSubagentProfileRuntimeConfig(input: {
 }): ResolvedSubagentProfileRuntimeConfig | undefined;
 declare function isSubagentRuntimeConfig(value: unknown): value is SubagentRuntimeConfig;
 //#endregion
-export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentProfileRuntimeConfig, SubagentBackend, type SubagentProfilePatch, SubagentProfilePatchSchema, SubagentProfileRuntimeConfig, SubagentProfileVariantMapPatchSchema, type SubagentProfileVariantPatch, SubagentProfileVariantPatchSchema, SubagentProfileVariantRuntimeConfig, SubagentRuntimeConfig, SubagentToolPermissionDecision, type SubagentToolPermissionDecisionPatch, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfig, SubagentsConfigSchema, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentProfilePatch, parseSubagentProfileVariantPatch, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule };
+export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentProfileRuntimeConfig, SubagentBackend, type SubagentProfilePatch, SubagentProfilePatchSchema, SubagentProfileRuntimeConfig, SubagentProfileVariantMapPatchSchema, type SubagentProfileVariantPatch, SubagentProfileVariantPatchSchema, SubagentProfileVariantRuntimeConfig, SubagentRuntimeConfig, SubagentThinkingLevel, SubagentToolPermissionDecision, type SubagentToolPermissionDecisionPatch, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfig, SubagentsConfigSchema, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentProfilePatch, parseSubagentProfileVariantPatch, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule };

package/dist/config.js

@@ -1,7 +1,7 @@
 import { SubagentProfilePatchSchema, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, parseSubagentProfilePatch, parseSubagentProfileVariantPatch } from "./schema.js";
 import { Result } from "better-result";
-import { Type } from "typebox";
 import { registerConfig } from "@pi-ohm/core/config";
+import { Type } from "typebox";
 
 //#region src/config.ts
 const SubagentsConfigSchema = Type.Record(Type.String({ minLength: 1 }), Type.Unknown());
@@ -34,14 +34,6 @@ const SUBAGENT_RUNTIME_RESERVED_KEYS = new Set([
 	"permissions",
 	"profiles"
 ]);
-const SUBAGENT_THINKING_LEVELS = new Set([
-	"off",
-	"minimal",
-	"low",
-	"medium",
-	"high",
-	"xhigh"
-]);
 function isJsonMap(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -62,6 +54,26 @@ function normalizePositiveInteger(value, fallback) {
 	if (!Number.isInteger(value) || value <= 0) return fallback;
 	return value;
 }
+function normalizeOptionalPositiveInteger(value) {
+	if (typeof value !== "number") return undefined;
+	if (!Number.isInteger(value) || value <= 0) return undefined;
+	return value;
+}
+function isSubagentThinkingLevel(value) {
+	return value === "off" || value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh";
+}
+function normalizeThinking(value) {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (!isSubagentThinkingLevel(normalized)) return undefined;
+	return normalized;
+}
+function normalizeStringList(value) {
+	if (!Array.isArray(value)) return undefined;
+	const normalized = value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+	if (normalized.length === 0) return undefined;
+	return normalized;
+}
 function normalizeSubagentBackend(value, fallback) {
 	if (value === "none" || value === "interactive-shell" || value === "interactive-sdk" || value === "custom-plugin") {
 		return value;
@@ -131,7 +143,7 @@ function stripThinkingSuffix(modelId) {
 		return trimmed;
 	}
 	const suffix = trimmed.slice(colonIndex + 1).trim().toLowerCase();
-	if (!SUBAGENT_THINKING_LEVELS.has(suffix)) {
+	if (!isSubagentThinkingLevel(suffix)) {
 		return trimmed;
 	}
 	return trimmed.slice(0, colonIndex).trim();
@@ -140,6 +152,9 @@ function mergeSubagentVariantConfig(patch, fallback) {
 	const parsedPatch = parseSubagentProfileVariantPatch(patch);
 	if (!parsedPatch) return fallback;
 	const model = normalizeSubagentModelOverride(parsedPatch.model);
+	const thinking = normalizeThinking(parsedPatch.thinking);
+	const tools = normalizeStringList(parsedPatch.tools);
+	const maxTurns = normalizeOptionalPositiveInteger(parsedPatch.maxTurns);
 	const prompt = parsedPatch.prompt;
 	const description = parsedPatch.description;
 	const whenToUse = parsedPatch.whenToUse;
@@ -148,12 +163,15 @@ function mergeSubagentVariantConfig(patch, fallback) {
 	const merged = {
 		...fallback,
 		...model ? { model } : {},
+		...thinking ? { thinking } : {},
+		...tools ? { tools } : {},
+		...maxTurns ? { maxTurns } : {},
 		...prompt ? { prompt } : {},
 		...description ? { description } : {},
 		...whenToUse ? { whenToUse } : {},
 		...Object.keys(permissions).length > 0 ? { permissions } : {}
 	};
-	const hasValues = merged.model !== undefined || merged.prompt !== undefined || merged.description !== undefined || merged.whenToUse !== undefined || merged.permissions !== undefined;
+	const hasValues = merged.model !== undefined || merged.thinking !== undefined || merged.tools !== undefined || merged.maxTurns !== undefined || merged.prompt !== undefined || merged.description !== undefined || merged.whenToUse !== undefined || merged.permissions !== undefined;
 	if (!hasValues) return undefined;
 	return merged;
 }
@@ -174,6 +192,9 @@ function mergeSubagentProfileConfig(patch, fallback) {
 	const parsedPatch = parseSubagentProfilePatch(patch);
 	if (!parsedPatch) return fallback;
 	const model = normalizeSubagentModelOverride(parsedPatch.model);
+	const thinking = normalizeThinking(parsedPatch.thinking);
+	const tools = normalizeStringList(parsedPatch.tools);
+	const maxTurns = normalizeOptionalPositiveInteger(parsedPatch.maxTurns);
 	const prompt = parsedPatch.prompt;
 	const description = parsedPatch.description;
 	const whenToUse = parsedPatch.whenToUse;
@@ -183,13 +204,16 @@ function mergeSubagentProfileConfig(patch, fallback) {
 	const merged = {
 		...fallback,
 		...model ? { model } : {},
+		...thinking ? { thinking } : {},
+		...tools ? { tools } : {},
+		...maxTurns ? { maxTurns } : {},
 		...prompt ? { prompt } : {},
 		...description ? { description } : {},
 		...whenToUse ? { whenToUse } : {},
 		...Object.keys(permissions).length > 0 ? { permissions } : {},
 		...Object.keys(variants).length > 0 ? { variants } : {}
 	};
-	const hasValues = merged.model !== undefined || merged.prompt !== undefined || merged.description !== undefined || merged.whenToUse !== undefined || merged.permissions !== undefined || merged.variants !== undefined;
+	const hasValues = merged.model !== undefined || merged.thinking !== undefined || merged.tools !== undefined || merged.maxTurns !== undefined || merged.prompt !== undefined || merged.description !== undefined || merged.whenToUse !== undefined || merged.permissions !== undefined || merged.variants !== undefined;
 	if (!hasValues) return undefined;
 	return merged;
 }
@@ -320,6 +344,9 @@ function resolveSubagentProfileRuntimeConfig(input) {
 	});
 	return {
 		model: variant?.model ?? profile.model,
+		thinking: variant?.thinking ?? profile.thinking,
+		tools: variant?.tools ?? profile.tools,
+		maxTurns: variant?.maxTurns ?? profile.maxTurns,
 		prompt: variant?.prompt ?? profile.prompt,
 		description: variant?.description ?? profile.description,
 		whenToUse: variant?.whenToUse ?? profile.whenToUse,

package/dist/extension.d.ts

@@ -1,8 +1,9 @@
+import { SubagentToolRuntime, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveSpawnConfig } from "./agent-controller.js";
 import { SubagentProfilePatch, SubagentProfilePatchSchema, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatch, SubagentProfileVariantPatchSchema, SubagentToolPermissionDecisionPatch, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, parseSubagentProfilePatch, parseSubagentProfileVariantPatch } from "./schema.js";
-import { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentProfileRuntimeConfig, SubagentBackend, SubagentProfileRuntimeConfig, SubagentProfileVariantRuntimeConfig, SubagentRuntimeConfig, SubagentToolPermissionDecision, SubagentsConfig, SubagentsConfigSchema, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule } from "./config.js";
+import { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentProfileRuntimeConfig, SubagentBackend, SubagentProfileRuntimeConfig, SubagentProfileVariantRuntimeConfig, SubagentRuntimeConfig, SubagentThinkingLevel, SubagentToolPermissionDecision, SubagentsConfig, SubagentsConfigSchema, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule } from "./config.js";
 import { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 //#region src/extension.d.ts
-declare function registerSubagentsExtension(_pi: ExtensionAPI): void;
+declare function registerSubagentsExtension(pi: ExtensionAPI): void;
 //#endregion
-export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentProfileRuntimeConfig, SubagentBackend, SubagentProfilePatch, SubagentProfilePatchSchema, SubagentProfileRuntimeConfig, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatch, SubagentProfileVariantPatchSchema, SubagentProfileVariantRuntimeConfig, SubagentRuntimeConfig, SubagentToolPermissionDecision, SubagentToolPermissionDecisionPatch, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfig, SubagentsConfigSchema, registerSubagentsExtension as default, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentProfilePatch, parseSubagentProfileVariantPatch, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule };
+export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentProfileRuntimeConfig, SubagentBackend, SubagentProfilePatch, SubagentProfilePatchSchema, SubagentProfileRuntimeConfig, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatch, SubagentProfileVariantPatchSchema, SubagentProfileVariantRuntimeConfig, SubagentRuntimeConfig, SubagentThinkingLevel, SubagentToolPermissionDecision, SubagentToolPermissionDecisionPatch, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentToolRuntime, SubagentsConfig, SubagentsConfigSchema, createSubagentToolRuntime, createSubagentTools, registerSubagentsExtension as default, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentProfilePatch, parseSubagentProfileVariantPatch, registerAgentControllerTool, resolveSpawnConfig, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule };

package/dist/extension.js

@@ -1,8 +1,11 @@
 import { SubagentProfilePatchSchema, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, parseSubagentProfilePatch, parseSubagentProfileVariantPatch } from "./schema.js";
 import { DEFAULT_SUBAGENT_RUNTIME_CONFIG, SubagentsConfigSchema, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule } from "./config.js";
+import { createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveSpawnConfig } from "./agent-controller.js";
 
 //#region src/extension.ts
-function registerSubagentsExtension(_pi) {}
+function registerSubagentsExtension(pi) {
+	registerAgentControllerTool(pi);
+}
 
 //#endregion
-export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, SubagentProfilePatchSchema, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfigSchema, registerSubagentsExtension as default, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentProfilePatch, parseSubagentProfileVariantPatch, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule };
+export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, SubagentProfilePatchSchema, SubagentProfileVariantMapPatchSchema, SubagentProfileVariantPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfigSchema, createSubagentToolRuntime, createSubagentTools, registerSubagentsExtension as default, getSubagentConfiguredModel, getSubagentProfileRuntimeConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentProfilePatch, parseSubagentProfileVariantPatch, registerAgentControllerTool, resolveSpawnConfig, resolveSubagentProfileRuntimeConfig, resolveSubagentVariantPattern, subagentsConfigModule };

package/dist/schema.d.ts

@@ -5,6 +5,9 @@ declare const SubagentToolPermissionDecisionSchema: Type.TUnion<[Type.TLiteral<"
 declare const SubagentToolPermissionMapSchema: Type.TRecord<"^.*$", Type.TUnion<[Type.TLiteral<"allow">, Type.TLiteral<"deny">, Type.TLiteral<"inherit">, Type.TLiteral<"ask">]>>;
 declare const SubagentProfileVariantPatchSchema: Type.TObject<{
   model: Type.TOptional<Type.TString>;
+  thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">]>>;
+  tools: Type.TOptional<Type.TArray<Type.TString>>;
+  maxTurns: Type.TOptional<Type.TInteger>;
   prompt: Type.TOptional<Type.TString>;
   description: Type.TOptional<Type.TString>;
   whenToUse: Type.TOptional<Type.TArray<Type.TString>>;
@@ -12,6 +15,9 @@ declare const SubagentProfileVariantPatchSchema: Type.TObject<{
 }>;
 declare const SubagentProfileVariantMapPatchSchema: Type.TRecord<"^.*$", Type.TObject<{
   model: Type.TOptional<Type.TString>;
+  thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">]>>;
+  tools: Type.TOptional<Type.TArray<Type.TString>>;
+  maxTurns: Type.TOptional<Type.TInteger>;
   prompt: Type.TOptional<Type.TString>;
   description: Type.TOptional<Type.TString>;
   whenToUse: Type.TOptional<Type.TArray<Type.TString>>;
@@ -19,12 +25,18 @@ declare const SubagentProfileVariantMapPatchSchema: Type.TRecord<"^.*$", Type.TO
 }>>;
 declare const SubagentProfilePatchSchema: Type.TObject<{
   model: Type.TOptional<Type.TString>;
+  thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">]>>;
+  tools: Type.TOptional<Type.TArray<Type.TString>>;
+  maxTurns: Type.TOptional<Type.TInteger>;
   prompt: Type.TOptional<Type.TString>;
   description: Type.TOptional<Type.TString>;
   whenToUse: Type.TOptional<Type.TArray<Type.TString>>;
   permissions: Type.TOptional<Type.TRecord<"^.*$", Type.TUnion<[Type.TLiteral<"allow">, Type.TLiteral<"deny">, Type.TLiteral<"inherit">, Type.TLiteral<"ask">]>>>;
   variants: Type.TOptional<Type.TRecord<"^.*$", Type.TObject<{
     model: Type.TOptional<Type.TString>;
+    thinking: Type.TOptional<Type.TUnion<[Type.TLiteral<"off">, Type.TLiteral<"minimal">, Type.TLiteral<"low">, Type.TLiteral<"medium">, Type.TLiteral<"high">, Type.TLiteral<"xhigh">]>>;
+    tools: Type.TOptional<Type.TArray<Type.TString>>;
+    maxTurns: Type.TOptional<Type.TInteger>;
     prompt: Type.TOptional<Type.TString>;
     description: Type.TOptional<Type.TString>;
     whenToUse: Type.TOptional<Type.TArray<Type.TString>>;

package/dist/schema.js

@@ -13,6 +13,16 @@ const SubagentToolPermissionDecisionSchema = Type.Union([
 const SubagentToolPermissionMapSchema = Type.Record(NonEmptyStringSchema, SubagentToolPermissionDecisionSchema);
 const SubagentProfileVariantPatchSchema = Type.Object({
 	model: Type.Optional(NonEmptyStringSchema),
+	thinking: Type.Optional(Type.Union([
+		Type.Literal("off"),
+		Type.Literal("minimal"),
+		Type.Literal("low"),
+		Type.Literal("medium"),
+		Type.Literal("high"),
+		Type.Literal("xhigh")
+	])),
+	tools: Type.Optional(NonEmptyStringArraySchema),
+	maxTurns: Type.Optional(Type.Integer({ minimum: 1 })),
 	prompt: Type.Optional(NonEmptyStringSchema),
 	description: Type.Optional(NonEmptyStringSchema),
 	whenToUse: Type.Optional(NonEmptyStringArraySchema),
@@ -21,6 +31,16 @@ const SubagentProfileVariantPatchSchema = Type.Object({
 const SubagentProfileVariantMapPatchSchema = Type.Record(NonEmptyStringSchema, SubagentProfileVariantPatchSchema);
 const SubagentProfilePatchSchema = Type.Object({
 	model: Type.Optional(NonEmptyStringSchema),
+	thinking: Type.Optional(Type.Union([
+		Type.Literal("off"),
+		Type.Literal("minimal"),
+		Type.Literal("low"),
+		Type.Literal("medium"),
+		Type.Literal("high"),
+		Type.Literal("xhigh")
+	])),
+	tools: Type.Optional(NonEmptyStringArraySchema),
+	maxTurns: Type.Optional(Type.Integer({ minimum: 1 })),
 	prompt: Type.Optional(NonEmptyStringSchema),
 	description: Type.Optional(NonEmptyStringSchema),
 	whenToUse: Type.Optional(NonEmptyStringArraySchema),
@@ -42,6 +62,19 @@ function toTrimmedStringArray(value) {
 	if (normalized.length === 0) return undefined;
 	return normalized;
 }
+function toPositiveInteger(value) {
+	if (typeof value !== "number") return undefined;
+	if (!Number.isInteger(value) || value <= 0) return undefined;
+	return value;
+}
+function toThinking(value) {
+	const trimmed = toTrimmedString(value)?.toLowerCase();
+	if (!trimmed) return undefined;
+	if (trimmed !== "off" && trimmed !== "minimal" && trimmed !== "low" && trimmed !== "medium" && trimmed !== "high" && trimmed !== "xhigh") {
+		return undefined;
+	}
+	return trimmed;
+}
 function normalizeSubagentPermissionMapInput(value) {
 	if (!isObjectRecord(value)) return undefined;
 	const normalized = {};
@@ -63,12 +96,18 @@ function normalizeSubagentPermissionMapInput(value) {
 function normalizeSubagentProfileVariantPatchInput(input) {
 	if (!isObjectRecord(input)) return input;
 	const model = toTrimmedString(Reflect.get(input, "model"));
+	const thinking = toThinking(Reflect.get(input, "thinking"));
+	const tools = toTrimmedStringArray(Reflect.get(input, "tools"));
+	const maxTurns = toPositiveInteger(Reflect.get(input, "maxTurns"));
 	const prompt = toTrimmedString(Reflect.get(input, "prompt"));
 	const description = toTrimmedString(Reflect.get(input, "description"));
 	const whenToUse = toTrimmedStringArray(Reflect.get(input, "whenToUse"));
 	const permissions = normalizeSubagentPermissionMapInput(Reflect.get(input, "permissions"));
 	return {
 		...model ? { model } : {},
+		...thinking ? { thinking } : {},
+		...tools ? { tools } : {},
+		...maxTurns ? { maxTurns } : {},
 		...prompt ? { prompt } : {},
 		...description ? { description } : {},
 		...whenToUse ? { whenToUse } : {},
@@ -95,6 +134,9 @@ function normalizeSubagentProfileVariantMapInput(input) {
 function normalizeSubagentProfilePatchInput(input) {
 	if (!isObjectRecord(input)) return input;
 	const model = toTrimmedString(Reflect.get(input, "model"));
+	const thinking = toThinking(Reflect.get(input, "thinking"));
+	const tools = toTrimmedStringArray(Reflect.get(input, "tools"));
+	const maxTurns = toPositiveInteger(Reflect.get(input, "maxTurns"));
 	const prompt = toTrimmedString(Reflect.get(input, "prompt"));
 	const description = toTrimmedString(Reflect.get(input, "description"));
 	const whenToUse = toTrimmedStringArray(Reflect.get(input, "whenToUse"));
@@ -102,6 +144,9 @@ function normalizeSubagentProfilePatchInput(input) {
 	const variants = normalizeSubagentProfileVariantMapInput(Reflect.get(input, "variants"));
 	return {
 		...model ? { model } : {},
+		...thinking ? { thinking } : {},
+		...tools ? { tools } : {},
+		...maxTurns ? { maxTurns } : {},
 		...prompt ? { prompt } : {},
 		...description ? { description } : {},
 		...whenToUse ? { whenToUse } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-ohm/subagents",
-  "version": "0.6.4-dev.25614589665.1.cd7b959",
+  "version": "0.6.4-dev.25632661332.1.3bf351f",
   "homepage": "https://github.com/pi-ohm/pi-ohm/tree/dev/packages/subagents#readme",
   "repository": {
     "type": "git",
@@ -30,14 +30,15 @@
     "provenance": true
   },
   "scripts": {
-    "build": "vp pack src/extension.ts src/config.ts"
+    "build": "vp pack src/extension.ts src/config.ts src/agent-controller.ts"
   },
   "dependencies": {
     "@earendil-works/pi-agent-core": "0.74.0",
+    "@earendil-works/pi-ai": "0.74.0",
     "@earendil-works/pi-coding-agent": "0.74.0",
-    "@pi-ohm/core": "0.6.4-dev.25614589665.1.cd7b959",
-    "@pi-ohm/tui": "0.6.4-dev.25614589665.1.cd7b959",
-    "better-result": "^2.6.0",
+    "@pi-ohm/core": "0.6.4-dev.25632661332.1.3bf351f",
+    "@pi-ohm/tui": "0.6.4-dev.25632661332.1.3bf351f",
+    "better-result": "2.9.2",
     "typebox": "^1.0.68",
     "zod": "^4"
   },