@henryqw/pi-subagent 23.0.2 → 24.0.1

package/CONTEXT.md

@@ -76,7 +76,7 @@ Own Role-configured Pi delegation through one `delegate_task` surface:
 - Recognized Pi JSON events renew idle timeout; raw bytes do not. Child maximum runtime always terminates ephemeral children.
 - Output, stderr, protocol events, callback draining, and inherited descendant streams are bounded.
 - Low-level worktree finalization returns explicit `pruned`, `retained`, or `recovery` evidence and never force-deletes uncertain work.
-- Exact review and working-change helpers produce bounded private evidence; callers must preserve identity guards and verdict validation.
+- Exact review helpers produce bounded private evidence; callers must preserve identity guards and verdict validation.
 
 ## Owned storage
 

package/README.md

@@ -30,7 +30,7 @@ pi install npm:pi-mcp-adapter
 
 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 |
 | --- | --- | --- |
@@ -199,7 +199,7 @@ Children disable ambient extension and Skill discovery. Only declared resources
 | `prepareRoleLaunch`, `finalizeRoleLaunch` | functions | Prepare Role prompts, arguments, and tool policy. |
 | `createEphemeralSubagentExecutor` | function | Run bounded no-session Pi children through a FIFO pool. |
 | `createChildWorktree`, `finalizeChildWorktree` | functions | Create and conservatively finalize child worktrees. |
-| `prepareExactReviewEvidence`, `prepareWorkingChangeEvidence` | functions | Prepare private exact review or working-change evidence. |
+| `prepareExactReviewEvidence` | function | Prepare private exact base-to-tip review evidence. |
 | `ExecuteRequestSchema`, `StageRequestSchema`, `IntegrationActionSchema` | schemas | Validate checked request and integration inputs. |
 | `IsolatedRunner`, `FileRunStore` | classes | Run checked work and persist durable request state. |
 | `RoleLaunchRuntime`, `HerdrHostRuntime`, `CheckedGitRuntime` | classes | Supply launch, host, and Git behavior to the runner. |

package/dist/index.d.ts

@@ -1,17 +1,16 @@
 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, roleMcpFlagValue, selectRoleMcpConfig, type RoleMcpConfig } from "./mcp-role.ts";
+export { parseRoleMcpAllowlist, selectRoleMcpConfig, type RoleMcpConfig } 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, worktreeContextNote, type WorktreeDirtyInspection, type WorktreeInfo, type WorktreePayload, } from "./worktree.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";
-export { captureWorkingCheckoutBaseline, captureWorkingCheckoutState, prepareWorkingChangeEvidence, sameWorkingCheckoutState, sameWorkingSnapshot, type PreparedWorkingChangeEvidence, type WorkingCheckoutBaseline, type WorkingCheckoutState, type WorkingSnapshotIdentity, } from "./working-evidence.ts";
 export declare const PI_SUBAGENT_PROCESS_LEASE = "PI_SUBAGENT_PROCESS_LEASE";
 export declare const ROLE_MCP_POLICY_FLAG = "pi-subagent-role-mcps";
+/** Read child MCP policy before Pi binds registered extension flag values. */
+export declare function roleMcpAllowlistFromArgv(args: readonly string[]): string[];
 export declare const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
-export declare const EXECUTION_BUDGET_FLAG = "pi-subagent-execution-budget";
 export declare const CHILD_EXCLUDED_TOOL_NAMES: readonly ["delegate_task", "ask_question", "subagent_status", "subagent_resume", "subagent_stage", "subagent_abort"];
-export declare const CHILD_EXCLUDED_TOOLS: string;
 export declare const DELEGATE_TASK: {
     readonly id: "pi-subagent/delegateTask";
     readonly label: "Subagent delegation";
@@ -91,7 +90,7 @@ export declare function prepareRoleLaunch(pi: Pick<ExtensionAPI, "getCommands">,
 export declare function prepareRoleLaunch(pi: Pick<ExtensionAPI, "getCommands">, ctx: ExtensionContext, input: CreateRoleLaunchInput): PreparedRoleLaunch;
 /** Resolve and prepare a configured Role with its package-owned resources. */
 export declare function resolveConfiguredRoleLaunch(pi: Pick<ExtensionAPI, "getCommands">, ctx: ExtensionContext, input: ResolveConfiguredRoleLaunchInput): Promise<PreparedRoleLaunch>;
-/** Restore the system prompt pair after a caller has prepared its launch argv. */
+/** Insert the system prompt pair after a caller has prepared its launch argv. */
 export declare function finalizeRoleLaunch(prepared: PreparedRoleLaunch): ResolvedRoleLaunch;
 export * from "./composition.ts";
 export * from "./git-runtime.ts";

package/dist/index.js

@@ -4,22 +4,28 @@ 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 { selectRoleMcpConfig } from "./mcp-role.js";
+import { parseRoleMcpAllowlist, selectRoleMcpConfig } 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, roleMcpFlagValue, selectRoleMcpConfig } from "./mcp-role.js";
+export { parseRoleMcpAllowlist, selectRoleMcpConfig } 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, worktreeContextNote, } from "./worktree.js";
+export { createChildWorktree, finalizeChildWorktree, inspectIndexFlags, inspectWorktreeDirty, WorktreeSetupError, } from "./worktree.js";
 export { prepareExactReviewEvidence, REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS, } from "./review-evidence.js";
-export { captureWorkingCheckoutBaseline, captureWorkingCheckoutState, prepareWorkingChangeEvidence, sameWorkingCheckoutState, sameWorkingSnapshot, } from "./working-evidence.js";
 const CODEX_ALIAS = /^openai-codex-(?:[2-9]|[1-9]\d+)$/;
 const MULTI_CODEX_EXTENSION = fileURLToPath(import.meta.resolve("@henryqw/pi-multi-codex/extensions/multi-codex.ts"));
 const ROLE_MCP_EXTENSION = fileURLToPath(new URL("../extensions/role-mcp.ts", import.meta.url));
 const ROLE_TOOLS_EXTENSION = fileURLToPath(new URL("../extensions/role-tools.ts", import.meta.url));
 export const PI_SUBAGENT_PROCESS_LEASE = "PI_SUBAGENT_PROCESS_LEASE";
 export const ROLE_MCP_POLICY_FLAG = "pi-subagent-role-mcps";
+/** Read child MCP policy before Pi binds registered extension flag values. */
+export function roleMcpAllowlistFromArgv(args) {
+    const flag = `--${ROLE_MCP_POLICY_FLAG}`;
+    const indexes = args.flatMap((arg, index) => arg === flag ? [index] : []);
+    if (indexes.length !== 1)
+        throw new Error(`${flag} must appear exactly once.`);
+    return parseRoleMcpAllowlist(args[indexes[0] + 1]);
+}
 export const ROLE_TOOL_POLICY_FLAG = "pi-subagent-role-tools";
-export const EXECUTION_BUDGET_FLAG = "pi-subagent-execution-budget";
 export const CHILD_EXCLUDED_TOOL_NAMES = [
     "delegate_task",
     "ask_question",
@@ -28,7 +34,6 @@ export const CHILD_EXCLUDED_TOOL_NAMES = [
     "subagent_stage",
     "subagent_abort",
 ];
-export const CHILD_EXCLUDED_TOOLS = CHILD_EXCLUDED_TOOL_NAMES.join(",");
 const SYSTEM_PROMPT_FLAG = "--append-system-prompt";
 const CHILD_IDENTITY_POLICY = "You are a delegated Pi Subagent, not Main. Execute the assigned Role and task directly. Main-only delegation rules do not apply. Recursive delegation is unavailable; do not seek or invoke delegation tools.";
 export const DELEGATE_TASK = {
@@ -238,9 +243,10 @@ export async function resolveRolePackageResources(role, ctx) {
     };
 }
 export function createRoleLaunch(pi, ctx, input) {
-    return createRoleLaunchFromSkills(ctx, input, resolveRoleSkills(pi, input.role));
+    return finalizeRoleLaunch(prepareRoleLaunchFromSkills(ctx, input, resolveRoleSkills(pi, input.role)));
 }
-function createRoleLaunchFromSkills(ctx, input, skills) {
+/** Build the prompt-free argv and tool policy; the Role prompt stays separate until `finalizeRoleLaunch`. */
+function prepareRoleLaunchFromSkills(ctx, input, skills) {
     const role = input.role;
     const mcps = mcpList(role.mcps, `Role ${role.name}`);
     const tools = roleToolPolicy(role, input.tools);
@@ -262,7 +268,7 @@ function createRoleLaunchFromSkills(ctx, input, skills) {
             throw new Error(`Invalid launch environment value: ${key}`);
         return [key, value];
     }));
-    const args = ["--no-session", "--no-extensions", "--no-skills", "--exclude-tools", CHILD_EXCLUDED_TOOLS];
+    const args = ["--no-session", "--no-extensions", "--no-skills", "--exclude-tools", CHILD_EXCLUDED_TOOL_NAMES.join(",")];
     if (mcps.length)
         args.push(`--${ROLE_MCP_POLICY_FLAG}`, JSON.stringify(mcps));
     for (const extension of new Set(extensions))
@@ -274,46 +280,30 @@ function createRoleLaunchFromSkills(ctx, input, skills) {
     if (input.route.thinkingLevel)
         args.push("--thinking", input.route.thinkingLevel);
     args.push(ctx.isProjectTrusted() ? "--approve" : "--no-approve");
-    args.push(SYSTEM_PROMPT_FLAG, `${CHILD_IDENTITY_POLICY}\n\n${cleanText(role.systemPrompt, "system prompt", `Role ${role.name}`)}`);
     return {
         env,
         args,
         model: input.route.model,
         thinkingLevel: input.route.thinkingLevel,
         missingSkills: skills.missing,
+        role: role.name,
+        tools: Object.freeze(tools),
+        systemPrompt: `${CHILD_IDENTITY_POLICY}\n\n${cleanText(role.systemPrompt, "system prompt", `Role ${role.name}`)}`,
+        promptArgIndex: args.length,
     };
 }
-export function resolveRoleLaunch(pi, ctx, input) {
+function prepareResolvedRoleLaunch(pi, ctx, input) {
     const { task, modelClass, agentDir, ...launchInput } = input;
     const selectedClass = modelClass ?? input.role.modelClass;
-    return createRoleLaunch(pi, ctx, {
+    return prepareRoleLaunchFromSkills(ctx, {
         ...launchInput,
         route: selectedClass === undefined
             ? resolveConfiguredTaskRoute(ctx, task, agentDir)
             : resolveTaskRoute(ctx, selectedClass, agentDir),
-    });
+    }, resolveRoleSkills(pi, input.role));
 }
-function stripRoleSystemPrompt(rawArgs) {
-    const indexes = rawArgs.flatMap((arg, index) => arg === SYSTEM_PROMPT_FLAG ? [index] : []);
-    if (indexes.length !== 1)
-        throw new Error(`Role launch must contain exactly one ${SYSTEM_PROMPT_FLAG} pair.`);
-    const promptArgIndex = indexes[0];
-    const systemPrompt = rawArgs[promptArgIndex + 1];
-    if (typeof systemPrompt !== "string" || !systemPrompt.includes("\n") || !systemPrompt.trim() || systemPrompt.includes("\0")) {
-        throw new Error(`Role ${SYSTEM_PROMPT_FLAG} value must be the exact multiline Role prompt.`);
-    }
-    const args = [...rawArgs.slice(0, promptArgIndex), ...rawArgs.slice(promptArgIndex + 2)];
-    if (args.includes(SYSTEM_PROMPT_FLAG) || args.includes(systemPrompt)) {
-        throw new Error("Sanitized Role argv must contain no prompt flag or raw Role prompt.");
-    }
-    return { args, systemPrompt, promptArgIndex };
-}
-function prepareResolvedRoleLaunch(roleDefinition, launch, additionalTools = []) {
-    const role = parseRoleName(roleDefinition.name);
-    rejectRetiredRoleIsolation(roleDefinition.isolation, `Role ${role}`);
-    const tools = Object.freeze(roleToolPolicy(roleDefinition, additionalTools));
-    const { args, systemPrompt, promptArgIndex } = stripRoleSystemPrompt(launch.args);
-    return { ...launch, args, role, tools, systemPrompt, promptArgIndex };
+export function resolveRoleLaunch(pi, ctx, input) {
+    return finalizeRoleLaunch(prepareResolvedRoleLaunch(pi, ctx, input));
 }
 function assertNoMissingRoleSkills(role, launch) {
     if (!launch.missingSkills.length)
@@ -321,11 +311,13 @@ function assertNoMissingRoleSkills(role, launch) {
     throw new Error(`Role ${parseRoleName(role.name)} requires missing Skills: ${launch.missingSkills.join(", ")}.`);
 }
 export function prepareRoleLaunch(pi, ctx, input) {
-    const launch = "route" in input
-        ? createRoleLaunch(pi, ctx, input)
-        : resolveRoleLaunch(pi, ctx, input);
-    assertNoMissingRoleSkills(input.role, launch);
-    return prepareResolvedRoleLaunch(input.role, launch, input.tools);
+    const role = parseRoleName(input.role.name);
+    rejectRetiredRoleIsolation(input.role.isolation, `Role ${role}`);
+    const prepared = "route" in input
+        ? prepareRoleLaunchFromSkills(ctx, input, resolveRoleSkills(pi, input.role))
+        : prepareResolvedRoleLaunch(pi, ctx, input);
+    assertNoMissingRoleSkills(input.role, prepared);
+    return { ...prepared, role };
 }
 /** Resolve and prepare a configured Role with its package-owned resources. */
 export async function resolveConfiguredRoleLaunch(pi, ctx, input) {
@@ -347,36 +339,22 @@ export async function resolveConfiguredRoleLaunch(pi, ctx, input) {
         ...namedSkills,
         paths: [...new Set([...namedSkills.paths, ...resources.skills])],
     };
-    const launch = createRoleLaunchFromSkills(ctx, {
+    const prepared = prepareRoleLaunchFromSkills(ctx, {
         role: effectiveRole,
         route: resolveTaskRoute(ctx, input.modelClass),
     }, skills);
-    assertNoMissingRoleSkills(effectiveRole, launch);
-    const additions = [
+    assertNoMissingRoleSkills(effectiveRole, prepared);
+    const args = [
+        ...prepared.args,
         "--no-prompt-templates",
         "--no-themes",
         ...resources.prompts.flatMap((path) => ["--prompt-template", path]),
         ...resources.themes.flatMap((path) => ["--theme", path]),
     ];
-    const promptArgIndex = launch.args.indexOf(SYSTEM_PROMPT_FLAG);
-    if (promptArgIndex < 0)
-        throw new Error(`Resolved Role launch has no ${SYSTEM_PROMPT_FLAG}.`);
-    const args = [...launch.args];
-    args.splice(promptArgIndex, 0, ...additions);
-    return prepareResolvedRoleLaunch(effectiveRole, { ...launch, args });
+    return { ...prepared, args, promptArgIndex: args.length };
 }
-/** Restore the system prompt pair after a caller has prepared its launch argv. */
+/** Insert the system prompt pair after a caller has prepared its launch argv. */
 export function finalizeRoleLaunch(prepared) {
-    if (prepared.args.includes(SYSTEM_PROMPT_FLAG)) {
-        throw new Error(`Prepared Role launch already contains ${SYSTEM_PROMPT_FLAG}.`);
-    }
-    if (!Number.isSafeInteger(prepared.promptArgIndex)
-        || prepared.promptArgIndex < 0 || prepared.promptArgIndex > prepared.args.length) {
-        throw new Error("Prepared Role launch has an invalid system prompt insertion index.");
-    }
-    if (typeof prepared.systemPrompt !== "string" || !prepared.systemPrompt.trim() || prepared.systemPrompt.includes("\0")) {
-        throw new Error("Prepared Role launch has an invalid system prompt.");
-    }
     const args = [...prepared.args];
     args.splice(prepared.promptArgIndex, 0, SYSTEM_PROMPT_FLAG, prepared.systemPrompt);
     return {

package/dist/launch-runtime.d.ts

@@ -1,5 +1,4 @@
 import { type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { EphemeralSubagentExecutionBudget } from "./ephemeral.ts";
 import type { CoordinatorRuntime, OperationContext, TransientLaunchHandle, VerifiedLaunch } from "./runner.ts";
 import { type ExecuteRequest, type ModelClass, type WorkspaceIdentity } from "./schema.ts";
 export declare const ISOLATED_MODEL_TASK: {
@@ -21,7 +20,6 @@ export interface LaunchRuntimeOptions {
     inspectMainBase(input: {
         root: string;
     }, context: OperationContext): Promise<WorkspaceIdentity>;
-    executionBudget?: () => Omit<EphemeralSubagentExecutionBudget, "startedAt">;
     now?: () => number;
     randomToken?: () => string;
 }

package/dist/launch-runtime.js

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { chmod, lstat, mkdtemp, open, realpath, rmdir, unlink } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { isAbsolute, join, normalize, relative, sep } from "node:path";
-import { EXECUTION_BUDGET_FLAG, resolveConfiguredRoleLaunch } from "./index.js";
+import { resolveConfiguredRoleLaunch } from "./index.js";
 import { registerModelTask } from "@henryqw/pi-task-models";
 const PROMPT_FLAG = "--append-system-prompt";
 const DIRECTORY_MODE = 0o700;
@@ -130,20 +130,13 @@ export class RoleLaunchRuntime {
         if (prepared.missingSkills.length) {
             throw new Error(`Role ${role} requires missing Skills: ${prepared.missingSkills.join(", ")}.`);
         }
-        const executionBudget = this.options.executionBudget?.();
         return Object.freeze({
             launch: Object.freeze({
                 role: prepared.role,
                 modelClass,
                 model: `${prepared.model.provider}/${prepared.model.id}`,
                 thinkingLevel: prepared.thinkingLevel,
-                args: Object.freeze([
-                    ...prepared.args,
-                    ...(executionBudget === undefined ? [] : [
-                        `--${EXECUTION_BUDGET_FLAG}`,
-                        JSON.stringify({ ...executionBudget, startedAt: this.now() }),
-                    ]),
-                ]),
+                args: Object.freeze([...prepared.args]),
                 env: Object.freeze({ ...prepared.env }),
                 tools: Object.freeze([...prepared.tools]),
             }),

package/dist/mcp-role.d.ts

@@ -3,5 +3,4 @@ export interface RoleMcpConfig {
     settings?: Record<string, unknown>;
 }
 export declare function parseRoleMcpAllowlist(value: unknown): string[];
-export declare function roleMcpFlagValue(args: readonly string[], flag: string): string | undefined;
 export declare function selectRoleMcpConfig(config: RoleMcpConfig, allowlist: readonly string[]): RoleMcpConfig;

package/dist/mcp-role.js

@@ -17,17 +17,6 @@ export function parseRoleMcpAllowlist(value) {
         throw new Error("The Role MCP policy flag contains duplicate MCP server names.");
     return names;
 }
-export function roleMcpFlagValue(args, flag) {
-    const indexes = args.flatMap((arg, index) => arg === flag ? [index] : []);
-    if (indexes.length > 1)
-        throw new Error(`${flag} must appear at most once.`);
-    if (!indexes.length)
-        return;
-    const value = args[indexes[0] + 1];
-    if (value === undefined)
-        throw new Error(`${flag} requires a value.`);
-    return value;
-}
 export function selectRoleMcpConfig(config, allowlist) {
     const missing = allowlist.filter((name) => !Object.hasOwn(config.mcpServers, name));
     if (missing.length)

package/dist/runner.js

@@ -69,7 +69,7 @@ class DurableRunStopped extends Error {
 }
 class ProductiveScope {
     signal;
-    constructor(_timeoutMs, _now, outerSignal) {
+    constructor(outerSignal) {
         this.signal = outerSignal ?? new AbortController().signal;
     }
     async call(operation) {
@@ -150,10 +150,6 @@ class FollowupControl {
         this.sealed = true;
         return undefined;
     }
-    invalidate() {
-        this.sealed = true;
-        this.queue.length = 0;
-    }
     close() {
         this.sealed = true;
         this.queue.length = 0;
@@ -662,7 +658,7 @@ export class IsolatedRunner {
     async execute(value, cwd, outerSignal) {
         const request = parseExecuteRequest(value);
         const policy = Object.freeze({ ...this.currentPolicy() });
-        const scope = new ProductiveScope(policy.childMaxMs, () => this.coordinatorRuntime.now(), outerSignal);
+        const scope = new ProductiveScope(outerSignal);
         const canonicalCwd = realpathSync.native(cwd);
         const prepared = await scope.call(async (context) => await this.coordinatorRuntime.preflight({ request, cwd: canonicalCwd }, context));
         const root = realpathSync.native(prepared.root);
@@ -748,8 +744,7 @@ export class IsolatedRunner {
                 return loaded;
             }, { productiveRunLease: lifecycle.lease });
             const state = handle.state;
-            const current = this.currentPolicy();
-            const scope = new ProductiveScope(Math.min(state.policy.childMaxMs, current.childMaxMs), () => this.coordinatorRuntime.now(), outerSignal);
+            const scope = new ProductiveScope(outerSignal);
             try {
                 if (request.action === "finalize")
                     return await this.finalize(handle, scope);
@@ -782,8 +777,6 @@ export class IsolatedRunner {
                 throw error;
             }
             finally {
-                if (scope instanceof DeadlineScope)
-                    scope.close();
                 this.closeRequestControls(root, request.id);
                 if (!lifecycle.stopped) {
                     delete state.recovery;
@@ -820,7 +813,7 @@ export class IsolatedRunner {
                     ? generation.combinedTip ?? generation.stages.at(-1)?.tip ?? generation.integrationBase : state.main;
                 if (!sameIdentity(action.expectedTip, expected))
                     throw new Error("Rejection recovery has a stale integration tip.");
-                const scope = new ProductiveScope(Math.min(state.policy.childMaxMs, this.currentPolicy().childMaxMs), () => this.coordinatorRuntime.now(), outerSignal);
+                const scope = new ProductiveScope(outerSignal);
                 const termination = attempt.termination;
                 const result = await scope.call((context) => this.hostRuntime.reconcileWorkerTermination({
                     task: changesetTaskRequest(state, task.taskId), attempt, workerId: termination.workerId,
@@ -841,7 +834,7 @@ export class IsolatedRunner {
                 || !sameIdentity(attempt.readiness.candidate, action.candidate)) {
                 throw new Error("Stage action refers to a stale or unowned candidate.");
             }
-            const scope = new ProductiveScope(Math.min(state.policy.childMaxMs, this.currentPolicy().childMaxMs), () => this.coordinatorRuntime.now(), outerSignal);
+            const scope = new ProductiveScope(outerSignal);
             const generations = state.integration.generations;
             let generation = generations.at(-1);
             const nextNumber = generation?.status === "superseded" ? generation.number + 1 : generation?.number ?? 1;
@@ -1100,7 +1093,7 @@ export class IsolatedRunner {
             const request = parseExecuteRequest(state.request);
             const generation = state.integration.generations.at(-1);
             if (action.action === "release") {
-                const scope = new ProductiveScope(Math.min(state.policy.childMaxMs, this.currentPolicy().childMaxMs), () => this.coordinatorRuntime.now(), outerSignal);
+                const scope = new ProductiveScope(outerSignal);
                 if (action.taskId !== undefined || action.attempt !== undefined) {
                     if (!action.taskId || !action.attempt || action.generation !== (generation?.number ?? 1)) {
                         throw new Error("Candidate release requires the latest generation and exact task attempt.");
@@ -1149,7 +1142,7 @@ export class IsolatedRunner {
                 if (state.integration.generations.filter((item) => item.worktree && !item.cleanup?.every((step) => step.status === "completed")).length >= MAX_RETAINED_INTEGRATION_GENERATIONS) {
                     throw new Error("Retained integration worktree limit is exhausted.");
                 }
-                const scope = new ProductiveScope(Math.min(state.policy.childMaxMs, this.currentPolicy().childMaxMs), () => this.coordinatorRuntime.now(), outerSignal);
+                const scope = new ProductiveScope(outerSignal);
                 const actualMain = await scope.call((context) => this.gitRuntime.inspectMain({ root }, context));
                 if (!isCleanCommitted(action.newMain) || !sameIdentity(actualMain, action.newMain)) {
                     throw new Error("Refresh requires the exact new clean Main identity.");
@@ -1233,7 +1226,7 @@ export class IsolatedRunner {
                 || (terminal(state) && !(state.status === "completed" && action.action === "cleanup"))
                 || (state.status !== "needs_attention" && !(state.status === "completed" && action.action === "cleanup")))
                 throw new Error("Integration action has a stale generation or combined tip.");
-            const scope = new ProductiveScope(Math.min(state.policy.childMaxMs, this.currentPolicy().childMaxMs), () => this.coordinatorRuntime.now(), outerSignal);
+            const scope = new ProductiveScope(outerSignal);
             const receipts = this.stageReceipts(generation);
             if (action.action === "advance") {
                 if (generation.status !== "staging" || generation.stages.some((stage) => stage.status !== "staged")
@@ -1603,7 +1596,7 @@ export class IsolatedRunner {
             }
             const activeControls = this.activeControls(root, id);
             for (const { control } of activeControls)
-                control.invalidate();
+                control.close();
             if (!activeControls.length
                 && !lifecycle.productiveRunLeaseActive
                 && this.recoverInterrupted(state)) {

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>;
@@ -139,14 +144,7 @@ type ExecuteRequestInput = Static<typeof ExecuteRequestSchema>;
 export type ExecuteRequest = Omit<ExecuteRequestInput, "finalChecks"> & {
     finalChecks: CheckCommand[];
 };
-export interface ExecutionPolicySnapshot {
-    maxSubagents: number;
-    maxTurns: number;
-    maxTokens?: number;
-    childIdleMs: number;
-    childMaxMs: number;
-    maxCorrections: number;
-}
+export type ExecutionPolicySnapshot = Static<typeof ExecutionPolicySnapshotSchema>;
 export type ResumeRequest = Static<typeof ResumeRequestSchema>;
 export type WorkspaceIdentity = Static<typeof WorkspaceSchema>;
 declare const WorktreeRecordSchema: Type.TObject<{
@@ -376,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;
@@ -1083,6 +1106,14 @@ declare const WaveStateSchema: Type.TObject<{
     taskIds: Type.TArray<Type.TString>;
     status: Type.TUnion<[Type.TLiteral<"dispatching">, Type.TLiteral<"integrating">, Type.TLiteral<"completed">, Type.TLiteral<"needs_attention">]>;
 }>;
+declare const ExecutionPolicySnapshotSchema: Type.TObject<{
+    maxSubagents: Type.TInteger;
+    maxTurns: Type.TInteger;
+    maxTokens: Type.TOptional<Type.TInteger>;
+    childIdleMs: Type.TNumber;
+    childMaxMs: Type.TNumber;
+    maxCorrections: Type.TInteger;
+}>;
 declare const IntegrationCandidateSchema: Type.TObject<{
     taskId: Type.TString;
     attempt: Type.TInteger;

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/dist/worktree.d.ts

@@ -57,5 +57,3 @@ export declare function inspectWorktreeDirty(cwd: string, run?: GitRunner, inclu
  * recorded; any uncertainty preserves work and omits unknown measurements.
  */
 export declare function finalizeChildWorktree(info: WorktreeInfo, run?: GitRunner): Promise<WorktreePayload>;
-/** Context block telling the child to work inside its isolated worktree. */
-export declare function worktreeContextNote(info: WorktreeInfo): string;

package/dist/worktree.js

@@ -269,7 +269,3 @@ export async function finalizeChildWorktree(info, run = runGit) {
     }
     return { outcome: "pruned", path: info.path, branch: info.branch };
 }
-/** Context block telling the child to work inside its isolated worktree. */
-export function worktreeContextNote(info) {
-    return `\n\n[WORKTREE ISOLATION] Work only in ${info.path} on ${info.branch}; do not use main checkout. Commit changes to this branch for parent review.`;
-}

package/extensions/admission.ts

@@ -14,10 +14,6 @@ export function roleIsReadOnlyScout(role: Role): boolean {
 	return !roleCanWrite(role) && role.extensions.length === 0 && !role.mcps?.length;
 }
 
-export interface CheckoutAdmission {
-	register(pi: ExtensionAPI, directCanWrite: (input: unknown) => boolean): void;
-}
-
 async function checkoutKey(pi: ExtensionAPI, ctx: ExtensionContext): Promise<string> {
 	const cwd = await realpath(ctx.cwd);
 	const result = await pi.exec("git", ["rev-parse", "--show-toplevel"], { cwd, timeout: 5_000 });
@@ -32,7 +28,7 @@ async function checkoutKey(pi: ExtensionAPI, ctx: ExtensionContext): Promise<str
  * not an OS sandbox: external processes and trusted extension lifecycle code
  * remain outside interception.
  */
-export function createCheckoutAdmission(): CheckoutAdmission {
+export function registerCheckoutAdmission(pi: ExtensionAPI, directCanWrite: (input: unknown) => boolean): void {
 	const ownerByCheckout = new Map<string, string>();
 	const checkoutByCall = new Map<string, string>();
 	const release = (toolCallId: string) => {
@@ -41,30 +37,26 @@ export function createCheckoutAdmission(): CheckoutAdmission {
 		checkoutByCall.delete(toolCallId);
 		if (ownerByCheckout.get(key) === toolCallId) ownerByCheckout.delete(key);
 	};
-	return {
-		register(pi, directCanWrite) {
-			pi.on("tool_call", async (event, ctx) => {
-				const potentiallyWriting = event.toolName === "delegate_task"
-					? directCanWrite(event.input)
-					: !READ_ONLY_TOOLS.has(event.toolName);
-				if (!potentiallyWriting) return;
-				const key = await checkoutKey(pi, ctx);
-				const owner = ownerByCheckout.get(key);
-				if (owner && owner !== event.toolCallId) {
-					return {
-						block: true,
-						reason: `Checkout ${key} already has an admitted Pi writer (${owner}); retry after it settles.`,
-					};
-				}
-				ownerByCheckout.set(key, event.toolCallId);
-				checkoutByCall.set(event.toolCallId, key);
-			});
-			pi.on("tool_result", (event) => release(event.toolCallId));
-			pi.on("tool_execution_end", (event) => release(event.toolCallId));
-			pi.on("session_shutdown", () => {
-				ownerByCheckout.clear();
-				checkoutByCall.clear();
-			});
-		},
-	};
+	pi.on("tool_call", async (event, ctx) => {
+		const potentiallyWriting = event.toolName === "delegate_task"
+			? directCanWrite(event.input)
+			: !READ_ONLY_TOOLS.has(event.toolName);
+		if (!potentiallyWriting) return;
+		const key = await checkoutKey(pi, ctx);
+		const owner = ownerByCheckout.get(key);
+		if (owner && owner !== event.toolCallId) {
+			return {
+				block: true,
+				reason: `Checkout ${key} already has an admitted Pi writer (${owner}); retry after it settles.`,
+			};
+		}
+		ownerByCheckout.set(key, event.toolCallId);
+		checkoutByCall.set(event.toolCallId, key);
+	});
+	pi.on("tool_result", (event) => release(event.toolCallId));
+	pi.on("tool_execution_end", (event) => release(event.toolCallId));
+	pi.on("session_shutdown", () => {
+		ownerByCheckout.clear();
+		checkoutByCall.clear();
+	});
 }