@henryqw/pi-subagent 23.0.2 → 24.0.0

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

@@ -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

@@ -139,14 +139,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<{
@@ -1083,6 +1076,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/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();
+	});
 }

package/extensions/config.ts

@@ -1,5 +1,6 @@
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { createConfigStore, extensionConfigPath } from "@henryqw/pi-config-store";
+import type { ExecutionPolicySnapshot } from "../dist/schema.js";
 
 export interface SubagentTimeoutConfig {
 	/** Minutes a child may stay idle before it is asked to stop. */
@@ -23,14 +24,7 @@ export interface LoadedSubagentConfig {
 	error?: string;
 }
 
-export interface EffectiveExecutionPolicy {
-	maxSubagents: number;
-	maxTurns: number;
-	maxTokens?: number;
-	childIdleMs: number;
-	childMaxMs: number;
-	maxCorrections: number;
-}
+export type EffectiveExecutionPolicy = ExecutionPolicySnapshot;
 
 type ParsedSubagentConfig = Omit<LoadedSubagentConfig, "source">;
 

package/extensions/isolated.ts

@@ -77,7 +77,6 @@ export const createIsolatedComponents: CreateIsolatedComponents = ({
 		resolveRoot,
 		preflightHost: async ({ root }, operation) => await host.preflightHost({ root }, operation),
 		inspectMainBase: async (input, operation) => await git.inspectMainBase(input, operation),
-		executionBudget,
 	});
 	return {
 		resolveRoot,

package/extensions/result-transport.ts

@@ -5,31 +5,21 @@ const EVIDENCE_PREVIEW_CODE_POINTS = 256;
 
 export type WorkflowTransportStatus = "pending" | "running" | "succeeded" | "rejected" | "skipped";
 
-type TransportEntryBase = {
+/** `assistantOutput` is read for running/succeeded entries and `failure` for rejected ones. */
+export type WorkflowTransportEntry = {
 	id: WorkflowEntry["id"];
 	index: WorkflowEntry["index"];
 	name: WorkflowEntry["delegation"]["name"];
 	role: WorkflowEntry["delegation"]["role"];
 	model?: string;
 	thinkingLevel?: string;
-};
-
-export type WorkflowTransportEntry =
-	| TransportEntryBase & { status: "pending" | "skipped"; assistantOutput?: never; failure?: never }
-	| TransportEntryBase & { status: "running" | "succeeded"; assistantOutput: string; failure?: never }
-	| TransportEntryBase & { status: "rejected"; assistantOutput?: never; failure: string };
-
-export type WorkflowTransportEntryDetails = {
-	id: string;
-	index: number;
-	name: string;
-	role: string;
 	status: WorkflowTransportStatus;
-	summary?: string;
-	model?: string;
-	thinkingLevel?: string;
+	assistantOutput?: string;
+	failure?: string;
 };
 
+export type WorkflowTransportEntryDetails = Omit<WorkflowTransportEntry, "assistantOutput" | "failure"> & { summary?: string };
+
 export type WorkflowTransportDetails = {
 	mode: WorkflowMode;
 	entries: WorkflowTransportEntryDetails[];
@@ -61,15 +51,12 @@ function workflowTitle(mode: WorkflowMode): string {
 }
 
 function statusCounts(entries: readonly WorkflowTransportEntry[]): string[] {
-	const count = (statuses: WorkflowTransportStatus[]) => entries.filter(({ status }) => statuses.includes(status)).length;
-	return ([
-		[["rejected"], "failed"],
-		[["succeeded"], "completed"],
-		[["skipped"], "skipped"],
-	] as const).flatMap(([statuses, word]) => {
-		const total = count([...statuses]);
-		return total ? [`${total} ${word}`] : [];
-	});
+	const count = (status: WorkflowTransportStatus) => entries.filter((entry) => entry.status === status).length;
+	return [
+		...(count("rejected") ? [`${count("rejected")} failed`] : []),
+		...(count("succeeded") ? [`${count("succeeded")} completed`] : []),
+		...(count("skipped") ? [`${count("skipped")} skipped`] : []),
+	];
 }
 
 export function displaySummary(text: string): string {
@@ -80,17 +67,13 @@ export function displaySummary(text: string): string {
 
 export type WorkflowEntryStatusPresentation = { glyph: string; fallback: string };
 
-const ENTRY_STATUS_PRESENTATION = {
+export const ENTRY_STATUS_PRESENTATION = {
 	pending: { glyph: "○", fallback: "queued" },
 	running: { glyph: "◌", fallback: "working" },
 	succeeded: { glyph: "✓", fallback: "completed" },
 	rejected: { glyph: "✗", fallback: "failed" },
 	skipped: { glyph: "–", fallback: "skipped" },
-} as const satisfies Record<WorkflowTransportEntryDetails["status"], WorkflowEntryStatusPresentation>;
-
-export function presentWorkflowEntryStatus(status: WorkflowTransportEntryDetails["status"]): WorkflowEntryStatusPresentation {
-	return ENTRY_STATUS_PRESENTATION[status];
-}
+} as const satisfies Record<WorkflowTransportStatus, WorkflowEntryStatusPresentation>;
 
 function sourceFor(entry: WorkflowTransportEntry): string | undefined {
 	if (entry.status === "rejected") return entry.failure;
@@ -122,7 +105,7 @@ export function formatWorkflowResult(mode: WorkflowMode, entries: readonly Workf
 	const lines = [
 		[`${workflowTitle(mode)} ${failed ? "failed" : "completed"}`, ...statusCounts(ordered)].join(" · "),
 		...positioned.map(({ entry, position }) => {
-			const { glyph, fallback } = presentWorkflowEntryStatus(entry.status);
+			const { glyph, fallback } = ENTRY_STATUS_PRESENTATION[entry.status];
 			const summary = displaySummary(sourceFor(entry) ?? "") || fallback;
 			return `${glyph} [${position}/${ordered.length}] ${entry.name} · ${entry.role} — ${summary}`;
 		}),

package/extensions/role-mcp.ts

@@ -2,19 +2,15 @@ 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 {
-	parseRoleMcpAllowlist,
-	ROLE_MCP_POLICY_FLAG,
-	roleMcpFlagValue,
-	selectRoleMcpConfig,
-} from "@henryqw/pi-subagent";
+import { roleMcpAllowlistFromArgv, ROLE_MCP_POLICY_FLAG, selectRoleMcpConfig } from "@henryqw/pi-subagent";
 
 export default function roleMcp(pi: ExtensionAPI): void {
 	pi.registerFlag(ROLE_MCP_POLICY_FLAG, {
 		description: "Internal Pi Subagent Role MCP policy",
 		type: "string",
 	});
-	const allowlist = parseRoleMcpAllowlist(roleMcpFlagValue(process.argv, `--${ROLE_MCP_POLICY_FLAG}`));
+	// 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);
 }

package/extensions/role-tools.ts

@@ -3,7 +3,6 @@ import { isAbsolute } from "node:path";
 import { isToolCallEventType, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
 	CHILD_EXCLUDED_TOOL_NAMES,
-	EXECUTION_BUDGET_FLAG,
 	EXECUTION_BUDGET_ENV,
 	PI_SUBAGENT_PROCESS_LEASE,
 	ROLE_TOOL_POLICY_FLAG,
@@ -48,9 +47,8 @@ function configuredTools(value: unknown): string[] {
 	return [...new Set(parsed.map((name) => name.trim()))];
 }
 
-function executionBudget(value: string | boolean | undefined): EphemeralSubagentExecutionBudget | undefined {
+function executionBudget(value: string | undefined): EphemeralSubagentExecutionBudget | undefined {
 	if (value === undefined) return;
-	if (typeof value !== "string") throw new Error(`${EXECUTION_BUDGET_ENV} must be a JSON execution budget.`);
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(value);
@@ -106,11 +104,7 @@ export default function roleTools(pi: ExtensionAPI): void {
 		description: "Internal Pi Subagent Role tool policy",
 		type: "string",
 	});
-	pi.registerFlag(EXECUTION_BUDGET_FLAG, {
-		description: "Internal Pi Subagent execution budget",
-		type: "string",
-	});
-	const budget = executionBudget(pi.getFlag(EXECUTION_BUDGET_FLAG) ?? process.env[EXECUTION_BUDGET_ENV]);
+	const budget = executionBudget(process.env[EXECUTION_BUDGET_ENV]);
 	let handoffSent = false;
 	pi.on("session_start", () => {
 		const selected = configuredTools(pi.getFlag(ROLE_TOOL_POLICY_FLAG));

package/extensions/subagent-command.ts

@@ -45,8 +45,8 @@ const errorText = (error: unknown): string => clean(error instanceof Error ? err
 const completed = (status: string) => ["completed", "success", "failed", "failure", "aborted", "integrated"].includes(status);
 const priority = (status: string) => /attention|blocked|retained|failed/i.test(status) ? 0 : completed(status) ? 2 : 1;
 
-type Pick<T> = { label: string; value: T };
-async function choose<T>(ctx: ExtensionContext, title: string, items: readonly Pick<T>[]): Promise<T | undefined> {
+type Choice<T> = { label: string; value: T };
+async function choose<T>(ctx: ExtensionContext, title: string, items: readonly Choice<T>[]): Promise<T | undefined> {
 	// Numeric suffixes are UI-only. Never parse display text into an identity.
 	const labels = items.map((item, index) => `${clean(item.label, 145)} [${index + 1}]`);
 	const selected = await ctx.ui.select(title, labels);
@@ -100,7 +100,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 				if (unavailable) ctx.ui.notify(`Isolated inventory unavailable (${unavailable}). Direct branch recovery remains available; check the canonical Git checkout/configuration.`, "warning");
 				if (inventory?.invalidIds.length) for (const id of inventory.invalidIds) ctx.ui.notify(`Unreadable isolated state ID: ${JSON.stringify(id)}. Preserve this file; inspect the state store before making changes.`, "warning");
 				type Selection = { kind: "direct"; task: DirectTask } | { kind: "isolated"; request: IsolatedRequest; root: string } | { kind: "refresh" } | { kind: "history" } | { kind: "close" };
-				const selections: Pick<Selection>[] = [
+				const selections: Choice<Selection>[] = [
 					...direct.filter((task) => history || !completed(task.status)).map((task) => ({ label: `Direct · ${task.name} · ${task.status} · ${task.id}`, value: { kind: "direct" as const, task } })),
 					...(inventory?.requests ?? []).filter((request) => history || !completed(request.status) || /retained/i.test(request.status)).map((request) => ({ label: `Isolated · ${request.name} · ${request.status} · ${request.id}`, value: { kind: "isolated" as const, request, root: inventory!.root } })),
 					{ label: "Refresh", value: { kind: "refresh" as const } },
@@ -108,7 +108,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 					{ label: "Close", value: { kind: "close" as const } },
 				];
 				const taskChoices = selections.splice(0, selections.length - 3);
-				const rank = ({ value }: Pick<Selection>) => value.kind === "direct" ? priority(value.task.status)
+				const rank = ({ value }: Choice<Selection>) => value.kind === "direct" ? priority(value.task.status)
 					: value.kind === "isolated" ? priority(value.request.status) : 3;
 				taskChoices.sort((a, b) => rank(a) - rank(b));
 				selections.unshift(...taskChoices);
@@ -129,7 +129,7 @@ export function registerSubagentCommand(pi: ExtensionAPI, adapter: SubagentComma
 					if (!valid()) return;
 					type Action = "inspect" | "send" | "edit" | "back";
 					const eligible = request.tasks.filter((task) => task.kind === "changeset" && adapter.canFollowup(root, request.id, task.id));
-					const actions: Pick<Action>[] = [
+					const actions: Choice<Action>[] = [
 						{ label: "Inspect status and recovery", value: "inspect" },
 						...(eligible.length ? [{ label: "Send follow-up instructions", value: "send" as const }, { label: "Edit queued instructions (withdraw ALL pending; Cancel leaves withdrawn)", value: "edit" as const }] : []),
 						{ label: "Back / refresh", value: "back" },

package/extensions/subagent.ts

@@ -3,12 +3,12 @@ import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-c
 import { type Component, Text, type TUI, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { availableTaskModels, loadTaskModelsConfig, modelReference, registerModelTask, resolveAvailableModel, type ResolvedTaskRoute, taskThinkingLevels } from "@henryqw/pi-task-models";
 import { capEphemeralSubagentOutput as capOutput, createEphemeralSubagentExecutor, DELEGATE_TASK, formatDuration, loadRoles, prepareRoleLaunch, ROLE_TOOL_POLICY_FLAG, type Role } from "@henryqw/pi-subagent";
-import { DEFAULT_EXECUTION_POLICY, DEFAULT_TIMEOUT_CONFIG, readSubagentConfig, resolveExecutionPolicy, type EffectiveExecutionPolicy } from "./config.ts";
-import { createCheckoutAdmission, roleCanWrite, roleIsReadOnlyScout } from "./admission.ts";
+import { readSubagentConfig, resolveExecutionPolicy, type EffectiveExecutionPolicy } from "./config.ts";
+import { registerCheckoutAdmission, roleCanWrite, roleIsReadOnlyScout } from "./admission.ts";
 import { registerIsolatedExtension } from "./isolated.ts";
 import { registerSubagentCommand, type DirectTask } from "./subagent-command.ts";
 import { MODEL_CLASS_GUIDANCE } from "./model-class-policy.ts";
-import { formatWorkflowResult, presentWorkflowEntryStatus, type BackgroundWorkflowTransportDetails, type WorkflowTransportEntry } from "./result-transport.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 { createDirectHerdr, type DirectHandle, type DirectTab } from "../dist/direct-herdr.js";
 import { materializeTransientLaunch } from "../dist/launch-runtime.js";
@@ -140,7 +140,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 		const glyph = details.recovery ? "■" : details.outcome === "completed" ? "✓" : "✗";
 		const color = details.recovery ? "warning" : details.outcome === "completed" ? "success" : "error";
 		const rows = details.entries.map(({ name, role, status, summary }) => {
-			const { glyph, fallback } = presentWorkflowEntryStatus(status);
+			const { glyph, fallback } = ENTRY_STATUS_PRESENTATION[status];
 			return `${glyph} ${name} · ${role} — ${details.recovery ? fallback : summary || fallback}`;
 		});
 		const raw = content.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, " ");
@@ -159,13 +159,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 	try {
 		initialPolicy = resolveExecutionPolicy(loadedConfig);
 	} catch {
-		initialPolicy = {
-			maxSubagents: DEFAULT_EXECUTION_POLICY.maxSubagents,
-			maxTurns: DEFAULT_EXECUTION_POLICY.maxTurns,
-			childIdleMs: DEFAULT_TIMEOUT_CONFIG.idleMinutes * 60_000,
-			childMaxMs: DEFAULT_TIMEOUT_CONFIG.maxMinutes * 60_000,
-			maxCorrections: DEFAULT_EXECUTION_POLICY.maxCorrections,
-		};
+		initialPolicy = resolveExecutionPolicy({ source: "missing", config: {} });
 	}
 	const executor = createEphemeralSubagentExecutor({
 		maxConcurrency: initialPolicy.maxSubagents,
@@ -179,13 +173,15 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			const parsed = parseDelegateTask(input);
 			if (parsed.mode === "isolated") return true;
 			const roles = new Map(loadRoles().map((role) => [role.name, role]));
-			return parsed.workflow.delegations.some((delegation) => roleCanWrite(roles.get(delegation.role) ?? { name: delegation.role } as Role));
+			return parsed.workflow.delegations.some((delegation) => {
+				const role = roles.get(delegation.role);
+				return !role || roleCanWrite(role);
+			});
 		} catch {
 			return true;
 		}
 	};
-	const admission = createCheckoutAdmission();
-	admission.register(pi, canWrite);
+	registerCheckoutAdmission(pi, canWrite);
 	const isolatedSurface = registerIsolatedExtension(pi, {
 		executor,
 		policy: initialPolicy,
@@ -513,9 +509,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 				const prepared = entry.delegation.model === undefined ? route : prepareRoleLaunch(pi, context, {
 					role, route: replaceRouteModel(context, entry.delegation.model, route),
 				});
-				const base = states.get(entry.id)!;
-				states.set(entry.id, { id: base.id, index: base.index, name: base.name, role: base.role,
-				model: modelReference(prepared.model), thinkingLevel: prepared.thinkingLevel, status: "running", assistantOutput: "" });
+				states.set(entry.id, { ...states.get(entry.id)!, model: modelReference(prepared.model), thinkingLevel: prepared.thinkingLevel, status: "running", assistantOutput: "" });
 				startWidgetItem(entry.id, taskId, role.name, prepared.model.id, prepared.thinkingLevel, entry.delegation.name, ctx);
 				const transient = await materializeTransientLaunch({ launch: prepared, prompt: prepared.systemPrompt,
 					promptArgIndex: prepared.promptArgIndex }, activeSignal);
@@ -578,17 +572,12 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 								const tokens = await handle.usageTokens();
 								if (tokens !== undefined && widgetItems.has(entry.id)) widgetItems.get(entry.id)!.tokens = tokens;
 							} catch { /* Optional telemetry. */ }
-							const base = states.get(entry.id)!;
-							states.set(entry.id, { id: base.id, index: base.index, name: base.name, role: base.role,
-								...(base.model ? { model: base.model } : {}), ...(base.thinkingLevel ? { thinkingLevel: base.thinkingLevel } : {}),
-								status: "succeeded", assistantOutput: answer });
+							states.set(entry.id, { ...states.get(entry.id)!, status: "succeeded", assistantOutput: answer });
 							finishWidgetItem(entry.id, "success");
 							return answer;
 						} catch (error) {
-							const base = states.get(entry.id)!;
-							states.set(entry.id, { id: base.id, index: base.index, name: base.name, role: base.role,
-								...(base.model ? { model: base.model } : {}), ...(base.thinkingLevel ? { thinkingLevel: base.thinkingLevel } : {}),
-								status: "rejected", failure: `${tabByEntry.has(entry.id) ? `recover from Herdr tab ${tabByEntry.get(entry.id)!.tabId}, agent ${tabByEntry.get(entry.id)!.name}, session ${tabByEntry.get(entry.id)!.sessionFile}: ` : ""}${capOutput(error instanceof Error ? error.message : String(error))}` });
+							const { assistantOutput: _partial, ...base } = states.get(entry.id)!;
+							states.set(entry.id, { ...base, status: "rejected", failure: `${tabByEntry.has(entry.id) ? `recover from Herdr tab ${tabByEntry.get(entry.id)!.tabId}, agent ${tabByEntry.get(entry.id)!.name}, session ${tabByEntry.get(entry.id)!.sessionFile}: ` : ""}${capOutput(error instanceof Error ? error.message : String(error))}` });
 							finishWidgetItem(entry.id, "failure");
 							throw error;
 						} finally { release(); }

package/extensions/workflow.ts

@@ -43,7 +43,6 @@ export const DirectWorkflowSchema = Type.Object({
 }, { additionalProperties: false, description: "Direct mode: exactly one compact single, tasks, or chain workflow" });
 
 export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema], { type: "object" });
-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": "23.0.2",
+  "version": "24.0.0",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",

package/dist/working-evidence.d.ts

@@ -1,25 +0,0 @@
-export interface WorkingCheckoutState {
-    head: string;
-    indexHash: string;
-    rawManifestHash: string;
-}
-export interface WorkingSnapshotIdentity extends WorkingCheckoutState {
-    tree: string;
-}
-export interface WorkingCheckoutBaseline extends WorkingSnapshotIdentity {
-    worktree: string;
-}
-export interface PreparedWorkingChangeEvidence {
-    baseline: WorkingCheckoutBaseline;
-    identity: WorkingSnapshotIdentity;
-    changedPaths: string[];
-    patchPath: string;
-    rawEvidencePath: string;
-    cleanup(): Promise<void>;
-}
-/** Capture mutation-detection identity without requiring a clean checkout or constructing Git objects. */
-export declare function captureWorkingCheckoutState(cwd: string, signal?: AbortSignal): Promise<WorkingCheckoutState>;
-export declare function captureWorkingCheckoutBaseline(cwd: string, signal?: AbortSignal): Promise<WorkingCheckoutBaseline>;
-export declare function prepareWorkingChangeEvidence(baseline: WorkingCheckoutBaseline, signal?: AbortSignal): Promise<PreparedWorkingChangeEvidence>;
-export declare function sameWorkingCheckoutState(left: WorkingCheckoutState, right: WorkingCheckoutState): boolean;
-export declare function sameWorkingSnapshot(left: WorkingSnapshotIdentity, right: WorkingSnapshotIdentity): boolean;

package/dist/working-evidence.js

@@ -1,261 +0,0 @@
-import { createHash } from "node:crypto";
-import { spawn } from "node:child_process";
-import { constants } from "node:fs";
-import { chmod, copyFile, lstat, mkdir, mkdtemp, open, readFile, readlink, realpath, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import { inspectIndexFlags } from "./worktree.js";
-import { runGit as runCapturedGit } from "./git-process.js";
-import { REVIEW_MAX_PATCH_BYTES, REVIEW_MAX_PATHS } from "./review-evidence.js";
-const GIT_TIMEOUT_MS = 30_000;
-const OUTPUT_LIMIT = REVIEW_MAX_PATCH_BYTES + 1;
-const MANIFEST_MAX_BYTES = 512 * 1024;
-function hash(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function line(value, field) {
-    const text = value.toString("utf8").replace(/\r?\n$/, "");
-    if (!text || text.includes("�") || /[\r\n\0]/.test(text))
-        throw new Error(`Git returned malformed ${field}.`);
-    return text;
-}
-function oid(value, field) {
-    const result = line(value, field);
-    if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(result))
-        throw new Error(`Git returned invalid ${field}.`);
-    return result;
-}
-async function command(args, cwd, env = process.env, signal, limit = OUTPUT_LIMIT) {
-    signal?.throwIfAborted();
-    const child = spawn("git", args, { cwd, env, signal, timeout: GIT_TIMEOUT_MS, stdio: ["ignore", "pipe", "pipe"] });
-    const stdout = [];
-    const stderr = [];
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-    let overflow = false;
-    const collect = (chunks, chunk, current) => {
-        const available = limit - current;
-        if (available <= 0) {
-            overflow = true;
-            return 0;
-        }
-        chunks.push(chunk.subarray(0, available));
-        if (chunk.length > available)
-            overflow = true;
-        return Math.min(chunk.length, available);
-    };
-    child.stdout.on("data", (chunk) => { stdoutBytes += collect(stdout, chunk, stdoutBytes); if (overflow)
-        child.kill(); });
-    child.stderr.on("data", (chunk) => { stderrBytes += collect(stderr, chunk, stderrBytes); if (overflow)
-        child.kill(); });
-    const code = await new Promise((resolveCode, reject) => {
-        child.once("error", reject);
-        child.once("close", resolveCode);
-    });
-    signal?.throwIfAborted();
-    if (overflow)
-        throw new Error(`Working-change evidence exceeds ${limit - 1} bytes.`);
-    return { code: code ?? -1, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) };
-}
-async function git(args, cwd, env, signal) {
-    const result = await command(args, cwd, env, signal);
-    if (result.code !== 0) {
-        const detail = result.stderr.toString("utf8").slice(0, 200).trim();
-        throw new Error(`git ${args.join(" ")} failed with exit ${result.code}${detail ? `: ${detail}` : ""}`);
-    }
-    return result.stdout;
-}
-function paths(value) {
-    if (!value.length)
-        return [];
-    const text = value.toString("utf8");
-    if (text.includes("�") || value.at(-1) !== 0)
-        throw new Error("Git returned malformed working-change paths.");
-    const result = text.slice(0, -1).split("\0");
-    if (result.length > REVIEW_MAX_PATHS)
-        throw new Error(`Working-change evidence exceeds ${REVIEW_MAX_PATHS} paths.`);
-    for (const path of result) {
-        if (!path || path.includes("\0") || isAbsolute(path) || path.split(/[\\/]/).some((part) => !part || part === "." || part === "..")) {
-            throw new Error(`Git returned malformed or unsupported path: ${JSON.stringify(path)}`);
-        }
-    }
-    return result;
-}
-async function indexPath(worktree, signal) {
-    const raw = line(await git(["rev-parse", "--git-path", "index"], worktree, undefined, signal), "index path");
-    const path = isAbsolute(raw) ? raw : resolve(worktree, raw);
-    return await realpath(path);
-}
-async function repositoryObjects(worktree, signal) {
-    const raw = line(await git(["rev-parse", "--git-common-dir"], worktree, undefined, signal), "common Git directory");
-    const directory = isAbsolute(raw) ? raw : resolve(worktree, raw);
-    return await realpath(join(directory, "objects"));
-}
-async function assertNoExternalFilters(worktree, signal) {
-    const result = await command(["config", "--get-regexp", "^filter\\..*\\.(clean|process)$"], worktree, process.env, signal, 64 * 1024);
-    if (result.code === 1 && result.stdout.length === 0)
-        return;
-    if (result.code !== 0)
-        throw new Error("Could not inspect effective Git content filters.");
-    throw new Error("Checked direct changesets reject configured Git clean/process filters; use isolated mode or remove the filter configuration before retrying.");
-}
-async function assertSupportedIndex(worktree, signal) {
-    const flags = await inspectIndexFlags(worktree, runCapturedGit, signal);
-    if (flags.failure)
-        throw new Error(`Working-change index inspection failed: ${flags.failure}`);
-    if (flags.hidden)
-        throw new Error("Checked direct changesets reject assume-unchanged or skip-worktree index entries.");
-    const stage = (await git(["ls-files", "--stage", "-z"], worktree, undefined, signal)).toString("utf8");
-    if (stage.includes("�") || /(?:^|\0)160000 /.test(stage))
-        throw new Error("Checked direct changesets reject Git links.");
-}
-async function rawManifest(worktree, signal) {
-    const listed = paths(await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], worktree, undefined, signal));
-    const entries = [];
-    for (const path of [...new Set(listed)].sort()) {
-        signal?.throwIfAborted();
-        const absolute = join(worktree, path);
-        let info;
-        try {
-            info = await lstat(absolute);
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                entries.push({ path, kind: "absent" });
-                continue;
-            }
-            throw error;
-        }
-        if (info.isSymbolicLink()) {
-            const target = await readlink(absolute, { encoding: "buffer" });
-            entries.push({ path, kind: "symlink", mode: info.mode & 0o7777, size: target.length, hash: hash(target) });
-        }
-        else if (info.isFile()) {
-            const contents = await readFile(absolute);
-            entries.push({ path, kind: "file", mode: info.mode & 0o7777, size: contents.length, hash: hash(contents) });
-        }
-        else {
-            throw new Error(`Checked direct evidence rejects unsupported working path type: ${path}`);
-        }
-    }
-    const json = `${JSON.stringify(entries)}\n`;
-    if (Buffer.byteLength(json, "utf8") > MANIFEST_MAX_BYTES)
-        throw new Error(`Working-change raw manifest exceeds ${MANIFEST_MAX_BYTES} bytes.`);
-    return { json, digest: hash(json) };
-}
-async function actualIdentity(worktree, signal) {
-    const [head, index] = await Promise.all([
-        git(["rev-parse", "--verify", "HEAD"], worktree, undefined, signal),
-        readFile(await indexPath(worktree, signal)),
-    ]);
-    return { head: oid(head, "HEAD"), indexHash: hash(index) };
-}
-async function privateSnapshot(worktree, directory, signal) {
-    const privateIndex = join(directory, "index");
-    const objectDirectory = join(directory, "objects");
-    await mkdir(objectDirectory, { mode: 0o700 });
-    await copyFile(await indexPath(worktree, signal), privateIndex, constants.COPYFILE_EXCL);
-    await chmod(privateIndex, 0o600);
-    const env = {
-        ...process.env,
-        GIT_INDEX_FILE: privateIndex,
-        GIT_OBJECT_DIRECTORY: objectDirectory,
-        GIT_ALTERNATE_OBJECT_DIRECTORIES: await repositoryObjects(worktree, signal),
-        GIT_CONFIG_NOSYSTEM: "1",
-    };
-    await git(["add", "-A", "--", "."], worktree, env, signal);
-    const tree = oid(await git(["write-tree"], worktree, env, signal), "private working tree");
-    const manifest = await rawManifest(worktree, signal);
-    return { tree, manifest };
-}
-async function makeDirectory() {
-    const directory = await mkdtemp(join(tmpdir(), "pi-subagent-working-review-"));
-    await chmod(directory, 0o700);
-    let cleaning;
-    return { directory, cleanup: () => cleaning ??= rm(directory, { recursive: true, force: true }) };
-}
-async function capture(worktree, directory, signal) {
-    await assertNoExternalFilters(worktree, signal);
-    await assertSupportedIndex(worktree, signal);
-    const before = await actualIdentity(worktree, signal);
-    const snapshot = await privateSnapshot(worktree, directory, signal);
-    const afterManifest = await rawManifest(worktree, signal);
-    const after = await actualIdentity(worktree, signal);
-    if (before.head !== after.head || before.indexHash !== after.indexHash || snapshot.manifest.digest !== afterManifest.digest) {
-        throw new Error("Working checkout changed while direct evidence was being captured.");
-    }
-    return {
-        identity: { ...before, tree: snapshot.tree, rawManifestHash: snapshot.manifest.digest },
-        manifest: snapshot.manifest.json,
-    };
-}
-async function canonicalRoot(cwd, signal) {
-    const canonical = await realpath(cwd);
-    return await realpath(line(await git(["rev-parse", "--show-toplevel"], canonical, undefined, signal), "checkout root"));
-}
-/** Capture mutation-detection identity without requiring a clean checkout or constructing Git objects. */
-export async function captureWorkingCheckoutState(cwd, signal) {
-    const worktree = await canonicalRoot(cwd, signal);
-    const before = await actualIdentity(worktree, signal);
-    const manifest = await rawManifest(worktree, signal);
-    const after = await actualIdentity(worktree, signal);
-    if (before.head !== after.head || before.indexHash !== after.indexHash) {
-        throw new Error("Working checkout changed while direct state was being captured.");
-    }
-    return { ...before, rawManifestHash: manifest.digest };
-}
-export async function captureWorkingCheckoutBaseline(cwd, signal) {
-    const worktree = await canonicalRoot(cwd, signal);
-    const branch = await command(["symbolic-ref", "-q", "HEAD"], worktree, process.env, signal, 64 * 1024);
-    if (branch.code !== 0)
-        throw new Error("Checked direct changesets require an attached branch.");
-    if ((await git(["status", "--porcelain=v1", "--untracked-files=all", "--ignore-submodules=none"], worktree, undefined, signal)).length) {
-        throw new Error("Checked direct changesets require a clean initial checkout; settle existing work or choose authorized isolated mode. No files were stashed, reset, or deleted.");
-    }
-    const owned = await makeDirectory();
-    try {
-        const captured = await capture(worktree, owned.directory, signal);
-        return { worktree, ...captured.identity };
-    }
-    finally {
-        await owned.cleanup();
-    }
-}
-export async function prepareWorkingChangeEvidence(baseline, signal) {
-    const owned = await makeDirectory();
-    try {
-        const captured = await capture(baseline.worktree, owned.directory, signal);
-        if (captured.identity.head !== baseline.head)
-            throw new Error("Checked direct changesets cannot move HEAD or create commits.");
-        const env = {
-            ...process.env,
-            GIT_OBJECT_DIRECTORY: join(owned.directory, "objects"),
-            GIT_ALTERNATE_OBJECT_DIRECTORIES: await repositoryObjects(baseline.worktree, signal),
-            GIT_CONFIG_NOSYSTEM: "1",
-        };
-        const raw = await git(["diff", "--no-ext-diff", "--no-textconv", "--ignore-submodules=none", "--raw", "-z", baseline.tree, captured.identity.tree], baseline.worktree, env, signal);
-        if (raw.toString("utf8").includes("160000"))
-            throw new Error("Checked direct changesets reject changed Git links.");
-        const changedPaths = paths(await git(["diff", "--no-ext-diff", "--no-textconv", "--ignore-submodules=none", "--name-only", "-z", baseline.tree, captured.identity.tree], baseline.worktree, env, signal));
-        const patch = await git(["--no-pager", "diff", "--no-ext-diff", "--no-textconv", "--ignore-submodules=none", "--binary", baseline.tree, captured.identity.tree], baseline.worktree, env, signal);
-        if (patch.length > REVIEW_MAX_PATCH_BYTES)
-            throw new Error(`Working-change evidence exceeds ${REVIEW_MAX_PATCH_BYTES} bytes.`);
-        const patchPath = join(owned.directory, "review.patch");
-        const rawEvidencePath = join(owned.directory, "raw-manifest.json");
-        const patchFile = await open(patchPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
-        await patchFile.writeFile(patch);
-        await patchFile.close();
-        await writeFile(rawEvidencePath, captured.manifest, { mode: 0o600, flag: "wx" });
-        return { baseline, identity: captured.identity, changedPaths, patchPath, rawEvidencePath, cleanup: owned.cleanup };
-    }
-    catch (error) {
-        await owned.cleanup();
-        throw error;
-    }
-}
-export function sameWorkingCheckoutState(left, right) {
-    return left.head === right.head && left.indexHash === right.indexHash && left.rawManifestHash === right.rawManifestHash;
-}
-export function sameWorkingSnapshot(left, right) {
-    return sameWorkingCheckoutState(left, right) && left.tree === right.tree;
-}