@henryqw/pi-subagent 24.0.0 → 25.0.0

package/CONTEXT.md

@@ -62,7 +62,7 @@ Own Role-configured Pi delegation through one `delegate_task` surface:
 ### Resource and launch policy
 
 - Ambient child extensions and Skills stay disabled. Only Role/caller resources plus required internal adapters load.
-- Every Role requires `tools`, `extensions`, and `skills` arrays. Omitted or empty `mcps` denies MCP access. Direct `pi-mcp-adapter` loading is rejected because it bypasses the allowlist.
+- Every Role requires `tools`, `extensions`, and `skills` arrays. `extensions` may name Pi built-in extensions as `builtin:<name>`. `mcps` names servers from the global `~/.pi/agent/mcp.json`; their tools load in the child with direct exposure. Omitted or empty `mcps` denies MCP access. Direct `pi-mcp-adapter` loading is rejected because it bypasses the allowlist.
 - Selected extensions are trusted executable bundles, not a sandbox. All tools and lifecycle behavior they register load together.
 - Role Skill names resolve through Main's effective Pi registry. Missing Roles, Skills, tools, MCP servers, routes, models, or thinking levels fail before the first productive turn.
 - Route precedence is call model class, then Role default, then registered Model Task assignment/default. A direct model replaces only the route model and must support its thinking level.

package/README.md

@@ -13,24 +13,17 @@ pi install npm:@henryqw/pi-subagent
 
 Run `/task-models` and configure the `fast`, `balanced`, `frontier`, and `fav` routes you use.
 
-Install `pi-mcp-adapter` only when a Role declares an MCP server allowlist:
-
-```bash
-pi install npm:pi-mcp-adapter
-```
-
 ## Works with
 
 | Package | Relationship | Purpose |
 | --- | --- | --- |
 | [`@henryqw/pi-task-models`](https://pi.henry.wang/extensions/pi-task-models) | Required | Provides the configured model routes for delegated Roles. |
-| [`pi-mcp-adapter`](https://github.com/nicobailon/pi-mcp-adapter) | Required | Loads the MCP servers named in a Role's `mcps` allowlist, only for Roles that declare one. |
 
 ## Use
 
 Ask Main to delegate a bounded task, such as “Have a scout trace sign-in without editing files.” Main uses `delegate_task`; you receive progress and a result or an actionable failure while Main remains available.
 
-Commands are for you; tools and the packaged skill are for Main. You do not need to call agent tools or manage candidate identities yourself.
+Commands are for you; tools and the packaged skill are for Main. You do not need to call agent tools or manage candidate identities yourself. Delegation and continuation tools use plain-object parameter schemas so providers that omit root-union tools can expose them; each mode and action still requires its exact arguments.
 
 | Surface | Type | Purpose |
 | --- | --- | --- |
@@ -181,14 +174,14 @@ Role Markdown lives in `~/.pi/agent/config/pi-subagent/` and requires frontmatte
 | `name`, `description` | Required non-empty text without terminal control characters |
 | `modelClass` | Optional `fast`, `balanced`, `frontier`, or `fav` default |
 | `tools` | Required array of base tool names; `[]` selects none |
-| `extensions` | Required array of trusted absolute paths or supported package sources |
+| `extensions` | Required array of trusted absolute paths, supported package sources, or Pi built-in extensions such as `builtin:codemode` |
 | `skills` | Required array of effective Pi Skill names |
-| `mcps` | Optional exact MCP server names; omitted or `[]` denies MCP access |
+| `mcps` | Optional exact server names from `~/.pi/agent/mcp.json` in Pi's native `mcpServers` format; omitted or `[]` denies MCP access |
 | body | Required system instructions |
 
 Roles describe responsibility and capabilities. They do not choose isolation; each request does. A same-named user Role overrides a built-in Role. The package ships `implementer`, `reviewer`, and `scout`.
 
-Children disable ambient extension and Skill discovery. Only declared resources and required internal policy adapters load. Missing Skills, tools, MCP servers, Roles, or routes fail before productive work starts. Main-only delegation and recovery tools plus `ask_question` are excluded from children.
+Children run with `--no-extensions`, so a Role must list the extension that registers its route model's provider, and only declared resources plus required internal policy adapters load. `builtin:<name>` entries load Pi built-in extensions (`builtin:codemode`, `builtin:tool-search`, `builtin:llama.cpp`) explicitly; `builtin:mcp` is rejected because it would connect every configured server and bypass `mcps`. The servers named in `mcps` come from the global `~/.pi/agent/mcp.json` only; their tools load in the child with direct exposure and are declared to the model as `mcp__<server>__<tool>` once the server connects. Missing Skills, tools, MCP servers, Roles, or routes fail before productive work starts. Main-only delegation and recovery tools plus `ask_question` are excluded from children.
 
 ## API
 

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type AvailableModel, type ModelTask, type ProfileName, type ResolvedTaskRoute, type ThinkingLevel } from "@henryqw/pi-task-models";
 export { DISPLAY_TEXT_CONTRACT, hasDisplayControlCharacters } from "./display-text.ts";
-export { parseRoleMcpAllowlist, selectRoleMcpConfig, type RoleMcpConfig } from "./mcp-role.ts";
+export { loadRoleMcpConfig, parseRoleMcpAllowlist } from "./mcp-role.ts";
 export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, DEFAULT_MAX_TURNS, EphemeralSubagentError, EXECUTION_BUDGET_ENV, formatDuration, type EphemeralSubagentActivityEvent, type EphemeralSubagentErrorCode, type EphemeralSubagentExecutionBudget, type EphemeralSubagentExecutor, type EphemeralSubagentExecutorOptions, type EphemeralSubagentResult, type EphemeralSubagentRunInput, type EphemeralSubagentTimeout, } from "./ephemeral.ts";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, type WorktreeDirtyInspection, type WorktreeInfo, type WorktreePayload, } from "./worktree.ts";
 export { prepareExactReviewEvidence, REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS, type PreparedReviewEvidence, type PrepareExactReviewEvidenceInput, } from "./review-evidence.ts";

package/dist/index.js

@@ -4,10 +4,10 @@ import { fileURLToPath } from "node:url";
 import { DefaultPackageManager, getAgentDir, parseFrontmatter, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { extensionConfigDir } from "@henryqw/pi-config-store";
 import { hasDisplayControlCharacters } from "./display-text.js";
-import { parseRoleMcpAllowlist, selectRoleMcpConfig } from "./mcp-role.js";
+import { loadRoleMcpConfig, parseRoleMcpAllowlist } from "./mcp-role.js";
 import { loadTaskModelsConfig, modelReference, orderedProfileRoutes, PROFILE_NAMES, resolveConfiguredTaskRoute, resolveTaskModelRoute, } from "@henryqw/pi-task-models";
 export { DISPLAY_TEXT_CONTRACT, hasDisplayControlCharacters } from "./display-text.js";
-export { parseRoleMcpAllowlist, selectRoleMcpConfig } from "./mcp-role.js";
+export { loadRoleMcpConfig, parseRoleMcpAllowlist } from "./mcp-role.js";
 export { addUsage, capEphemeralSubagentOutput, createEphemeralSubagentExecutor, DEFAULT_MAX_TURNS, EphemeralSubagentError, EXECUTION_BUDGET_ENV, formatDuration, } from "./ephemeral.js";
 export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, } from "./worktree.js";
 export { prepareExactReviewEvidence, REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS, } from "./review-evidence.js";
@@ -66,12 +66,25 @@ const stringList = (value, field, source) => {
     }
     return value.map((item) => item.trim());
 };
+// Pi 0.99 built-in extensions (`builtin:<name>`, see Pi's settings docs); Pi exports no list of them.
+// `builtin:mcp` is excluded: it connects every server in mcp.json and would bypass the Role `mcps` allowlist.
+const BUILTIN_EXTENSION_NAMES = ["codemode", "tool-search", "llama.cpp"];
+const BUILTIN_EXTENSION_PREFIX = "builtin:";
 function validateExtension(extension, source) {
     const value = cleanText(extension, "extension", source);
+    if (value.startsWith(BUILTIN_EXTENSION_PREFIX)) {
+        if (value === `${BUILTIN_EXTENSION_PREFIX}mcp`) {
+            throw new Error(`${source} must select MCP servers with mcps instead of loading builtin:mcp directly.`);
+        }
+        if (!BUILTIN_EXTENSION_NAMES.includes(value.slice(BUILTIN_EXTENSION_PREFIX.length))) {
+            throw new Error(`${source}: unknown built-in extension ${value}; use ${BUILTIN_EXTENSION_NAMES.map((name) => `${BUILTIN_EXTENSION_PREFIX}${name}`).join(", ")}.`);
+        }
+        return value;
+    }
     const packageSource = /^(?:npm|git|github|https?|ssh):/.test(value);
     const userPath = isAbsolute(value) || value.startsWith("~/") || value.startsWith("~\\") || value.startsWith("file://");
     if (!packageSource && !userPath) {
-        throw new Error(`${source}: extensions entries must be absolute paths or package sources.`);
+        throw new Error(`${source}: extensions entries must be absolute paths, package sources, or builtin:<name>.`);
     }
     return value;
 }
@@ -231,7 +244,9 @@ export async function resolveRolePackageResources(role, ctx) {
     const resolved = await packageManager(ctx).resolveExtensionSources([...sources]);
     const resourceGroups = [resolved.extensions, resolved.skills, resolved.prompts, resolved.themes]
         .map((resources) => resources.filter((resource) => resource.enabled));
-    const resolvedSources = new Set(resourceGroups.flat().map((resource) => resource.metadata.source));
+    // Built-in extensions resolve to their `builtin:<name>` path with the bare source `builtin`.
+    const resolvedSources = new Set(resourceGroups.flat()
+        .map((resource) => resource.metadata.source === "builtin" ? resource.path : resource.metadata.source));
     const missing = sources.filter((source) => !resolvedSources.has(source));
     if (missing.length)
         throw new Error(`Role extension sources resolved no resources: ${missing.join(", ")}.`);
@@ -317,6 +332,9 @@ export function prepareRoleLaunch(pi, ctx, input) {
         ? prepareRoleLaunchFromSkills(ctx, input, resolveRoleSkills(pi, input.role))
         : prepareResolvedRoleLaunch(pi, ctx, input);
     assertNoMissingRoleSkills(input.role, prepared);
+    // Validate the mcp.json the child reads: its environment inherits Main's, with launch overrides on top.
+    if (input.role.mcps?.length)
+        loadRoleMcpConfig(prepared.env.PI_CODING_AGENT_DIR ?? getAgentDir(), input.role.mcps);
     return { ...prepared, role };
 }
 /** Resolve and prepare a configured Role with its package-owned resources. */
@@ -328,10 +346,8 @@ export async function resolveConfiguredRoleLaunch(pi, ctx, input) {
     if (matches.length !== 1)
         throw new Error(`Required configured Role ${roleName} is missing or ambiguous.`);
     const role = matches[0];
-    if (role.mcps?.length) {
-        const { loadMcpConfig } = await import("pi-mcp-adapter/config");
-        selectRoleMcpConfig(loadMcpConfig(join(getAgentDir(), "mcp.json"), ctx.cwd), role.mcps);
-    }
+    if (role.mcps?.length)
+        loadRoleMcpConfig(getAgentDir(), role.mcps);
     const resources = await resolveRolePackageResources(role, ctx);
     const effectiveRole = { ...role, extensions: resources.extensions };
     const namedSkills = resolveRoleSkills(pi, effectiveRole);

package/dist/mcp-role.d.ts

@@ -1,6 +1,8 @@
-export interface RoleMcpConfig {
-    mcpServers: Record<string, unknown>;
-    settings?: Record<string, unknown>;
-}
+import type { LoadedMcpConfig } from "@earendil-works/pi-coding-agent";
 export declare function parseRoleMcpAllowlist(value: unknown): string[];
-export declare function selectRoleMcpConfig(config: RoleMcpConfig, allowlist: readonly string[]): RoleMcpConfig;
+/**
+ * Select the Role's allowlisted servers from the global `mcp.json` in Pi's native `mcpServers`
+ * shape; the project `.pi/mcp.json` is ignored. A `--no-extensions` child has no codemode tool, so
+ * every selected server is forced to direct exposure and codemode is never activated.
+ */
+export declare function loadRoleMcpConfig(agentDir: string, allowlist: readonly string[]): LoadedMcpConfig;

package/dist/mcp-role.js

@@ -1,3 +1,5 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 export function parseRoleMcpAllowlist(value) {
     if (typeof value !== "string")
         throw new Error("The Role MCP policy flag must contain a JSON array of MCP server names.");
@@ -17,14 +19,60 @@ export function parseRoleMcpAllowlist(value) {
         throw new Error("The Role MCP policy flag contains duplicate MCP server names.");
     return names;
 }
-export function selectRoleMcpConfig(config, allowlist) {
-    const missing = allowlist.filter((name) => !Object.hasOwn(config.mcpServers, name));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const isStringRecord = (value) => isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+/** Documented optional fields of an `mcpServers` entry and their shapes (see Pi's docs/mcp.md). */
+const FIELD_CHECKS = {
+    args: [(value) => Array.isArray(value) && value.every((item) => typeof item === "string"), "an array of strings"],
+    env: [isStringRecord, "an object of strings"],
+    headers: [isStringRecord, "an object of strings"],
+    cwd: [(value) => typeof value === "string", "a string"],
+    timeout: [(value) => typeof value === "number" && Number.isFinite(value) && value > 0, "a positive number"],
+    enabled: [(value) => typeof value === "boolean", "a boolean"],
+    oauth: [isRecord, "an object"],
+};
+/**
+ * Select the Role's allowlisted servers from the global `mcp.json` in Pi's native `mcpServers`
+ * shape; the project `.pi/mcp.json` is ignored. A `--no-extensions` child has no codemode tool, so
+ * every selected server is forced to direct exposure and codemode is never activated.
+ */
+export function loadRoleMcpConfig(agentDir, allowlist) {
+    const path = join(agentDir, "mcp.json");
+    let parsed = {};
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) {
+            throw new Error(`${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    if (!isRecord(parsed) || (parsed.mcpServers !== undefined && !isRecord(parsed.mcpServers))) {
+        throw new Error(`${path}: expected an object with an "mcpServers" object.`);
+    }
+    const configured = parsed.mcpServers ?? {};
+    const missing = allowlist.filter((name) => !Object.hasOwn(configured, name));
     if (missing.length)
         throw new Error(`Role MCP servers are not configured: ${missing.join(", ")}.`);
-    const mcpServers = Object.fromEntries(allowlist.map((name) => [name, config.mcpServers[name]]));
-    const { agentPluginPaths: _agentPluginPaths, hostConfigDiscovery: _hostConfigDiscovery, ...settings } = config.settings ?? {};
-    return {
-        mcpServers,
-        ...(Object.keys(settings).length ? { settings } : {}),
-    };
+    const servers = allowlist.map((name) => {
+        const value = configured[name];
+        if (!isRecord(value))
+            throw new Error(`${path}: MCP server "${name}" must be an object.`);
+        if (value.enabled === false)
+            throw new Error(`${path}: Role MCP server "${name}" is disabled.`);
+        const stdio = typeof value.command === "string" && value.command.trim() !== "" && (value.type === undefined || value.type === "stdio");
+        const http = typeof value.url === "string" && value.url.trim() !== "" && (value.type === undefined || value.type === "http" || value.type === "streamable-http");
+        if (stdio === http) {
+            throw new Error(`${path}: MCP server "${name}" needs either a "command" (stdio) or a "url" (http or streamable-http).`);
+        }
+        for (const [field, [valid, shape]] of Object.entries(FIELD_CHECKS)) {
+            if (value[field] !== undefined && !valid(value[field]))
+                throw new Error(`${path}: MCP server "${name}" field "${field}" must be ${shape}.`);
+        }
+        const { toolExposure: _toolExposure, ...config } = value;
+        return { name, config: { ...config, exposure: "direct" }, source: path, scope: "global" };
+    });
+    return { servers, autoEnableCodemode: false, errors: [] };
 }

package/dist/schema.d.ts

@@ -129,6 +129,11 @@ export declare const ResumeRequestSchema: Type.TUnion<[Type.TObject<{
     id: Type.TString;
     action: Type.TLiteral<"finalize">;
 }>]>;
+export declare const ResumeRequestParameters: Type.TObject<{
+    id: Type.TString;
+    action: Type.TUnion<[Type.TLiteral<"retry">, Type.TLiteral<"verify">, Type.TLiteral<"finalize">]>;
+    taskId: Type.TOptional<Type.TString>;
+}>;
 export type IdOnly = Static<typeof IdOnlySchema>;
 export type CheckCommand = Static<typeof CheckCommandSchema>;
 export type Judgment = Static<typeof JudgmentSchema>;
@@ -369,6 +374,31 @@ export declare const IntegrationActionSchema: Type.TUnion<[Type.TObject<{
     taskId: Type.TOptional<Type.TString>;
     attempt: Type.TOptional<Type.TInteger>;
 }>]>;
+export declare const IntegrationActionParameters: Type.TObject<{
+    id: Type.TString;
+    generation: Type.TInteger;
+    action: Type.TUnion<[Type.TLiteral<"refresh">, Type.TUnion<[Type.TLiteral<"advance">, Type.TLiteral<"validate">, Type.TLiteral<"correct">, Type.TLiteral<"promote">, Type.TLiteral<"reconcile">, Type.TLiteral<"cleanup">]>, Type.TLiteral<"release">]>;
+    expectedTip: Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>;
+    expectedMain: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    newMain: Type.TOptional<Type.TObject<{
+        branch: Type.TString;
+        head: Type.TString;
+        index: Type.TString;
+        tree: Type.TString;
+    }>>;
+    taskId: Type.TOptional<Type.TString>;
+    attempt: Type.TOptional<Type.TInteger>;
+}>;
 export type IntegrationAction = Static<typeof IntegrationActionSchema>;
 export declare function parseIntegrationAction(value: unknown): IntegrationAction;
 export declare function parseStageRequest(value: unknown): StageRequest;

package/dist/schema.js

@@ -65,7 +65,17 @@ export const ResumeRequestSchema = Type.Union([
     Type.Object({ id: IdSchema, action: Type.Literal("retry"), taskId: IdSchema }, { additionalProperties: false }),
     Type.Object({ id: IdSchema, action: Type.Literal("verify"), taskId: IdSchema }, { additionalProperties: false }),
     Type.Object({ id: IdSchema, action: Type.Literal("finalize") }, { additionalProperties: false }),
-], { type: "object" });
+]);
+// Tool parameters need a plain object root; the action union remains the validation boundary.
+export const ResumeRequestParameters = Type.Object({
+    id: IdSchema,
+    action: Type.Union([
+        ResumeRequestSchema.anyOf[0].properties.action,
+        ResumeRequestSchema.anyOf[1].properties.action,
+        ResumeRequestSchema.anyOf[2].properties.action,
+    ]),
+    taskId: Type.Optional(IdSchema),
+}, { additionalProperties: false });
 const AllocationLifecycleFields = {
     generation: Type.Integer({ minimum: 1, maximum: 2 }),
     token: Type.String({ pattern: TOKEN_PATTERN }),
@@ -167,7 +177,21 @@ export const IntegrationActionSchema = Type.Union([
         taskId: Type.Optional(IdSchema),
         attempt: Type.Optional(Type.Integer({ minimum: 1, maximum: 2 })),
     }, { additionalProperties: false }),
-], { type: "object" });
+]);
+export const IntegrationActionParameters = Type.Object({
+    id: IntegrationActionSchema.anyOf[0].properties.id,
+    generation: IntegrationActionSchema.anyOf[0].properties.generation,
+    action: Type.Union([
+        IntegrationActionSchema.anyOf[0].properties.action,
+        IntegrationActionSchema.anyOf[1].properties.action,
+        IntegrationActionSchema.anyOf[2].properties.action,
+    ]),
+    expectedTip: IntegrationActionSchema.anyOf[0].properties.expectedTip,
+    expectedMain: Type.Optional(IntegrationActionSchema.anyOf[0].properties.expectedMain),
+    newMain: Type.Optional(IntegrationActionSchema.anyOf[0].properties.newMain),
+    taskId: IntegrationActionSchema.anyOf[2].properties.taskId,
+    attempt: IntegrationActionSchema.anyOf[2].properties.attempt,
+}, { additionalProperties: false });
 export function parseIntegrationAction(value) {
     if (!Check(IntegrationActionSchema, value))
         throw schemaValidationError("subagent_integrate requires an exact generation and tip", Errors(IntegrationActionSchema, value));

package/docs/orchestration.md

@@ -139,7 +139,7 @@ Every child launch:
 5. excludes Main-only delegation/recovery tools and `ask_question`; and
 6. prepends the delegated-subagent identity contract.
 
-An empty `tools` list adds no base tools, though selected extension tools can still activate. Omitted or empty `mcps` denies MCP access. Loading `pi-mcp-adapter` directly is rejected because it bypasses the allowlist.
+An empty `tools` list adds no base tools, though selected extension tools can still activate. Children run with `--no-extensions`, so a Role must list the extension that registers its route model's provider; `builtin:<name>` entries load Pi built-in extensions. `mcps` names servers from the global `~/.pi/agent/mcp.json` in Pi's native format, and their tools load in the child with direct exposure. Omitted or empty `mcps` denies MCP access. Loading `pi-mcp-adapter` directly is rejected because it bypasses the allowlist.
 
 Isolated Herdr Role launches receive the same turn, token, and child-runtime budget metadata as ephemeral launches. Retained workers therefore keep one non-refilling session budget across follow-ups rather than receiving a new request budget.
 

package/extensions/isolated.ts

@@ -17,9 +17,9 @@ import { RoleLaunchRuntime, type LaunchRuntimeOptions } from "../dist/launch-run
 import { IsolatedRunner, type OperationContext, type RunResponse } from "../dist/runner.js";
 import {
 	IdOnlySchema,
-	ResumeRequestSchema,
+	ResumeRequestParameters,
 	StageRequestSchema,
-	IntegrationActionSchema,
+	IntegrationActionParameters,
 	parseIntegrationAction,
 	parseStageRequest,
 	parseExecuteRequest,
@@ -614,7 +614,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		name: "subagent_resume",
 		label: "Subagent resume",
 		description: "Resume one unfinished isolated request without resetting its recorded policy or correction count.",
-		parameters: ResumeRequestSchema,
+		parameters: ResumeRequestParameters,
 		prepareArguments: parseResumeRequest,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;
@@ -641,7 +641,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		name: "subagent_integrate",
 		label: "Subagent integrate",
 		description: "Main advances staged dependents, refreshes after clean Main drift, validates, corrects, promotes, reconciles an interrupted promotion, cleans up promoted resources, or explicitly releases rejected/superseded owned resources. Never replays an uncertain mutation.",
-		parameters: IntegrationActionSchema,
+		parameters: IntegrationActionParameters,
 		prepareArguments: parseIntegrationAction,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;

package/extensions/role-mcp.ts

@@ -1,16 +1,12 @@
-import { join } from "node:path";
-import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createMcpAdapter } from "pi-mcp-adapter";
-import { loadMcpConfig } from "pi-mcp-adapter/config";
-import { roleMcpAllowlistFromArgv, ROLE_MCP_POLICY_FLAG, selectRoleMcpConfig } from "@henryqw/pi-subagent";
+import { createMcpExtension, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadRoleMcpConfig, roleMcpAllowlistFromArgv, ROLE_MCP_POLICY_FLAG } from "@henryqw/pi-subagent";
 
-export default function roleMcp(pi: ExtensionAPI): void {
+export default function roleMcp(pi: ExtensionAPI): void | Promise<void> {
 	pi.registerFlag(ROLE_MCP_POLICY_FLAG, {
 		description: "Internal Pi Subagent Role MCP policy",
 		type: "string",
 	});
-	// Pi binds extension flag values after factories load.
-	const allowlist = roleMcpAllowlistFromArgv(process.argv);
-	const config = selectRoleMcpConfig(loadMcpConfig(join(getAgentDir(), "mcp.json"), process.cwd()), allowlist);
-	createMcpAdapter({ config })(pi);
+	// Pi binds extension flag values after factories load. Throwing here exits the child non-zero.
+	const config = loadRoleMcpConfig(getAgentDir(), roleMcpAllowlistFromArgv(process.argv));
+	return createMcpExtension({ loadConfig: () => config })(pi);
 }

package/extensions/subagent.ts

@@ -9,7 +9,7 @@ import { registerIsolatedExtension } from "./isolated.ts";
 import { registerSubagentCommand, type DirectTask } from "./subagent-command.ts";
 import { MODEL_CLASS_GUIDANCE } from "./model-class-policy.ts";
 import { ENTRY_STATUS_PRESENTATION, formatWorkflowResult, type BackgroundWorkflowTransportDetails, type WorkflowTransportEntry } from "./result-transport.ts";
-import { DelegateTaskSchema, identifyWorkflowEntries, parseDelegateTask, runForegroundWorkflow, type Delegation, type ParsedWorkflow, type WorkflowEntry } from "./workflow.ts";
+import { DelegateTaskParameters, identifyWorkflowEntries, parseDelegateTask, runForegroundWorkflow, type Delegation, type ParsedWorkflow, type WorkflowEntry } from "./workflow.ts";
 import { createDirectHerdr, type DirectHandle, type DirectTab } from "../dist/direct-herdr.js";
 import { materializeTransientLaunch } from "../dist/launch-runtime.js";
 const WIDGET_KEY = "subagent-status";
@@ -460,7 +460,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			"Isolation uses typed tasks and dependencies. Keep tightly coupled changes with one owner; do not split by file count. Failures, ambiguity, limits, and conflicts retain work and never waive checks or identity guards.",
 			`For delegate_task, ${MODEL_CLASS_GUIDANCE} A direct model replaces only the selected route's model; its thinking level stays unchanged.`,
 		],
-		parameters: DelegateTaskSchema,
+		parameters: DelegateTaskParameters,
 		prepareArguments(args) {
 			try {
 				const parsed = parseDelegateTask(args);

package/extensions/workflow.ts

@@ -42,7 +42,21 @@ export const DirectWorkflowSchema = Type.Object({
 	chain: Type.Optional(Type.Array(DelegationSchema, { minItems: 1, maxItems: MAX_WORKFLOW_ENTRIES })),
 }, { additionalProperties: false, description: "Direct mode: exactly one compact single, tasks, or chain workflow" });
 
-export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema], { type: "object" });
+export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema]);
+// Keep the strict mode union for parsing; expose a plain object root to tool providers.
+export const DelegateTaskParameters = Type.Object({
+	...DirectWorkflowSchema.properties,
+	mode: Type.Union([DirectWorkflowSchema.properties.mode, ExecuteRequestSchema.properties.mode]),
+	id: Type.Optional(ExecuteRequestSchema.properties.id),
+	goal: Type.Optional(ExecuteRequestSchema.properties.goal),
+	tasks: Type.Optional(Type.Union([
+		Type.Array(DelegationSchema, { minItems: 1, maxItems: MAX_WORKFLOW_ENTRIES }),
+		ExecuteRequestSchema.properties.tasks,
+	])),
+	finalChecks: ExecuteRequestSchema.properties.finalChecks,
+	finalJudgment: ExecuteRequestSchema.properties.finalJudgment,
+}, { additionalProperties: false });
+export const WorkflowSchema = DirectWorkflowSchema;
 
 export type Delegation = Static<typeof DelegationSchema> & { kind: "text" };
 export type WorkflowMode = "single" | "parallel" | "chain";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "24.0.0",
+  "version": "25.0.0",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",
@@ -40,9 +40,9 @@
     "pack:check": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.86.0 <0.88.0",
-    "@earendil-works/pi-coding-agent": ">=0.86.0 <0.88.0",
-    "@earendil-works/pi-tui": ">=0.86.0 <0.88.0",
+    "@earendil-works/pi-ai": ">=0.99.1 <0.100.0",
+    "@earendil-works/pi-coding-agent": ">=0.99.1 <0.100.0",
+    "@earendil-works/pi-tui": ">=0.99.1 <0.100.0",
     "typebox": "^1.3.15"
   },
   "repository": {
@@ -74,9 +74,9 @@
     "proper-lockfile": "^4.1.2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.0",
-    "@earendil-works/pi-coding-agent": "0.87.0",
-    "@earendil-works/pi-tui": "0.87.0",
+    "@earendil-works/pi-ai": "0.99.1",
+    "@earendil-works/pi-coding-agent": "0.99.1",
+    "@earendil-works/pi-tui": "0.99.1",
     "@types/proper-lockfile": "^4.1.4"
   }
 }