@henryqw/pi-subagent 23.0.1 → 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

@@ -113,7 +113,7 @@ An isolated request has one durable ID, one goal, and 1–8 typed tasks:
       "modelClass": "balanced",
       "requirements": "Implement the smallest correct repair.",
       "deliverable": "A committed candidate in the owned worktree.",
-      "dependsOn": ["inspect"],
+      "dependsOn": [],
       "contextFrom": ["inspect"],
       "checks": [
         { "command": "pnpm", "args": ["test", "--", "refresh"] }
@@ -131,7 +131,7 @@ An isolated request has one durable ID, one goal, and 1–8 typed tasks:
 }
 ```
 
-`dependsOn` controls scheduling. `contextFrom` may name completed text tasks and preserves the declared order. Changesets require focused task checks; a graph with changesets requires final checks. A canonical root `package.json` test script is required: the runner adds `pnpm test` to final checks if missing, and Main runs it on the combined integration checkout before promotion. Checks and judgments bind to exact Git identities; candidate drift, Main drift, mutation during validation, ambiguity, or conflicts stop promotion and retain evidence.
+`dependsOn` controls scheduling. `contextFrom` also schedules dependencies and carries completed text outputs in the declared order. Do not repeat the same task in both fields. Changesets require focused task checks; a graph with changesets requires final checks. A canonical root `package.json` test script is required: the runner adds `pnpm test` to final checks if missing, and Main runs it on the combined integration checkout before promotion. Checks and judgments bind to exact Git identities; candidate drift, Main drift, mutation during validation, ambiguity, or conflicts stop promotion and retain evidence.
 
 `delegate_task`, `subagent_resume`, and `subagent_integrate advance` return a durable request ID after the wave is saved; productive work continues while Main is free. Main can do other work or end its turn instead of sleeping or polling. Pi sends a follow-up in the launching session whenever a checked worker becomes ready or a worker needs attention, and again when the wave finishes. A worker whose exact turn ends without a changed clean commit—including a failed or aborted turn—needs attention, not an inferred candidate; use `subagent_status` for its saved evidence. If delivery is missed, inspect `subagent_status`.
 
@@ -147,9 +147,11 @@ A queued follow-up runs after the current turn settles and must produce a new cl
 
 After a coordinator interruption, run `/subagent recover` once. It acquires the repository productive lease before changing any orphaned `pending` or `running` state, preserves unreadable state files and retained candidates, and reports blockers and existing continuations to Main without replaying prompts, merges, promotion, or cleanup. If another productive run holds the lease, it only reads status and reports the live owner; wait rather than taking over. Repeating the command is safe. Main uses `subagent_status` for exact identities and the recovery tools in the interface table above for deliberate decisions; the command never stages or promotes. Direct Herdr tab recovery remains in `/subagent`.
 
+If an isolated worker produced no candidate, `subagent_abort` terminates it and removes only proven unchanged, clean owned resources. Cleanup includes ignored-file checks and never discards unique commits. If productive work is still settling, termination is uncertain, or cleanup fails, the request stays aborted with retained-resource evidence. Inspect `subagent_status`, resolve the reported blocker, then repeat `subagent_abort` to reconcile cleanup; it does not replay worker prompts. Dirty work, unique commits, and uncertain allocations remain for deliberate manual recovery.
+
 The following details describe exact identity and retained-work requirements.
 
-A checked candidate stays retained if Main is dirty. Staging, combined validation, and promotion require Main to be clean at the pinned committed identity; clean your local edits deliberately before using those actions. No dirty work is replayed or merged automatically. Pass the exact `generation`, candidate (`taskId`, `attempt`, `candidate`) and `expectedTip` identities reported by status to stage; pass the generation and combined `expectedTip` to integrate. If Main advances cleanly before promotion, call `subagent_integrate refresh` with the recorded `expectedMain`, old `expectedTip`, and new clean `newMain`. Main must restage selected immutable candidates into the new generation and rerun combined checks. Dirty or divergent Main blocks refresh. Stale identities fail. If integration allocation was uncertain, `subagent_stage resolve` first proves the owned checkout is still at its base before starting the selected merge; otherwise it retains the intent. At most two integration worktrees may remain unreleased per request; a superseded generation is read-only. To release a superseded *clean* integration checkout, call `subagent_integrate` with `{ id, action: "release", generation, expectedTip }`, using that generation's last staged tip (or integration base when no stage completed). To release a rejected candidate after its worker has terminated and all generations using it are released, pass `{ id, action: "release", generation: <latest generation number, or 1>, taskId, attempt, expectedTip: <candidate tip> }`. Release persists each host/checkout/branch step, verifies ownership and cleanliness (including ignored files), and deletes the branch only if its ref still names the exact tip. Dirty, conflicted, changed, or uncertain resources remain for manual inspection; retry the same release after resolving the obstacle. Released checkouts free a retained slot; abort is available after every retained resource is released. Rejection can invalidate dependent work; if fresh dependent execution is impossible, start a new request instead of forcing promotion. Productive requests have no whole-run wall-clock deadline. Resume does not reset the recorded policy or correction count. Child limits, abort signals, process I/O, status inspection, exact termination, and cleanup retain finite safety bounds.
+A checked candidate stays retained if Main is dirty. Staging, combined validation, and promotion require Main to be clean at the pinned committed identity; clean your local edits deliberately before using those actions. No dirty work is replayed or merged automatically. Pass the exact `generation`, candidate (`taskId`, `attempt`, `candidate`) and `expectedTip` identities reported by status to stage; pass the generation and combined `expectedTip` to integrate. If Main advances cleanly before promotion, call `subagent_integrate refresh` with the recorded `expectedMain`, old `expectedTip`, and new clean `newMain`. Main must restage selected immutable candidates into the new generation and rerun combined checks. Dirty or divergent Main blocks refresh. Stale identities fail. If integration allocation was uncertain, `subagent_stage resolve` first proves the owned checkout is still at its base before starting the selected merge; otherwise it retains the intent. At most two integration worktrees may remain unreleased per request; a superseded generation is read-only. To release a superseded *clean* integration checkout, call `subagent_integrate` with `{ id, action: "release", generation, expectedTip }`, using that generation's last staged tip (or integration base when no stage completed). To release a rejected candidate after its worker has terminated and all generations using it are released, pass `{ id, action: "release", generation: <latest generation number, or 1>, taskId, attempt, expectedTip: <candidate tip> }`. Release persists each host/checkout/branch step, verifies ownership and cleanliness (including ignored files), and deletes the branch only if its ref still names the exact tip. Dirty, conflicted, changed, or uncertain resources remain for manual inspection; retry the same release after resolving the obstacle. Released checkouts free a retained slot; abort is available after every retained resource is released. Rejection can invalidate dependent work; if fresh dependent execution is impossible, start a new request instead of forcing promotion. Productive requests have no whole-run wall-clock deadline. Resume does not reset the recorded policy or correction count. Text tasks have two dispatch attempts; inspection failures before dispatch do not consume one. Verification requires passing preliminary checks and any required judgment; it cannot override failed review. Child limits, abort signals, process I/O, status inspection, exact termination, and cleanup retain finite safety bounds.
 
 The extension never pushes, opens a pull request, publishes, deploys, force-cleans recoverable work, or silently falls back to Main.
 
@@ -197,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/herdr-runtime.d.ts

@@ -95,6 +95,7 @@ export declare class HerdrHostRuntime implements HostRuntime {
         outcome: "unknown";
         failure: string;
     }>;
+    private proveAbsentAgentForCleanup;
     cleanupHost(input: {
         requestId: ExecuteRequest["id"];
         kind: HostCleanupKind;

package/dist/herdr-runtime.js

@@ -643,9 +643,41 @@ export class HerdrHostRuntime {
             return { outcome: "unknown", failure: safeText(error) };
         }
     }
+    async proveAbsentAgentForCleanup(allocation, attempt, context) {
+        requireIntentIdentity(allocation, attempt);
+        assertAgentIntent(allocation, attempt);
+        this.assertLeasePath(allocation.leasePath, attempt.correlationToken);
+        await this.assertPrivateLeaseDirectories(allocation.leasePath, true);
+        await this.assertPrivateLease(allocation.leasePath, true);
+        const agents = (await this.listAgents(allocation.worktreeCwd, context)).map((agent) => ({
+            name: typeof agent.name === "string" ? agent.name : undefined,
+            paneId: exactString(agent.pane_id, "Herdr listed agent pane ID"),
+            tabId: exactString(agent.tab_id, "Herdr listed agent tab ID"),
+        }));
+        if (agents.some((agent) => agent.name === allocation.agentName
+            || agent.paneId === allocation.paneId || agent.tabId === allocation.tabId)) {
+            throw new Error("The exact absent-agent allocation now has a matching Herdr agent.");
+        }
+        const paneIsAbsent = await this.paneAbsent(allocation.paneId, allocation.worktreeCwd, context);
+        if (!paneIsAbsent)
+            await this.assertStartableAgentPane(allocation, context, { requireExclusiveTty: true });
+        if ((await this.scanLease(allocation.leasePath, allocation.worktreeCwd, context, undefined, true)).length) {
+            throw new Error("The absent-agent process lease still has holders.");
+        }
+        await this.delay(50, context.signal);
+        if ((await this.scanLease(allocation.leasePath, allocation.worktreeCwd, context, undefined, true)).length) {
+            throw new Error("The absent-agent process lease did not remain empty for two consecutive scans.");
+        }
+        return paneIsAbsent;
+    }
     async cleanupHost(input, context) {
-        if (input.attempt.termination?.status !== "terminated") {
-            return { outcome: "blocked", failure: "Host cleanup requires exact recorded worker termination." };
+        const terminationProven = input.attempt.termination?.status === "terminated";
+        const agentIntents = input.attempt.allocations.filter((intent) => intent.kind === "agent");
+        const latestAgent = agentIntents.at(-1);
+        const neverOwned = !input.attempt.termination && latestAgent?.status === "absent"
+            && agentIntents.every((intent) => intent.status === "absent");
+        if (!terminationProven && !neverOwned) {
+            return { outcome: "blocked", failure: "Host cleanup requires exact worker termination or a definitive absent-agent allocation." };
         }
         try {
             if (input.kind === "worker_tab") {
@@ -663,8 +695,19 @@ export class HerdrHostRuntime {
                 if (tabId === allocation.workspaceRootTabId)
                     throw new Error("Saved worker tab aliases the workspace root tab.");
                 const paneId = exactString(allocation.paneId, "saved worker pane ID");
-                if (!await this.paneAbsent(paneId, allocation.worktreeCwd, context)) {
-                    return { outcome: "blocked", failure: "The exact saved worker pane still exists after termination." };
+                const paneIsAbsent = neverOwned
+                    ? await this.proveAbsentAgentForCleanup(latestAgent, input.attempt, context)
+                    : await this.paneAbsent(paneId, allocation.worktreeCwd, context);
+                if (!paneIsAbsent) {
+                    if (!neverOwned)
+                        return { outcome: "blocked", failure: "The exact saved worker pane still exists after termination." };
+                    const closed = await this.herdr.exec(["pane", "close", paneId], this.processOptions(allocation.worktreeCwd, context, HERDR_OPERATION_CAP_MS));
+                    if (closed.code !== 0 || closed.killed)
+                        return { outcome: "blocked", failure: safeText(herdrCommandFailure(["pane", "close"], closed)) };
+                    requireOkResponse(closed.stdout, "Herdr pane close response");
+                    if (!await this.paneAbsent(paneId, allocation.worktreeCwd, context)) {
+                        return { outcome: "blocked", failure: "The exact unstarted worker pane still exists after close." };
+                    }
                 }
                 const workspaceIsAbsent = await this.workspaceAbsent(workspaceId, workspace, context);
                 const tab = await this.getTab(tabId, allocation.worktreeCwd, context);
@@ -686,6 +729,9 @@ export class HerdrHostRuntime {
             const workerCleanup = input.attempt.cleanup.find((step) => step.kind === "worker_tab");
             if (workerCleanup?.status !== "completed")
                 return { outcome: "blocked", failure: "Workspace cleanup must follow worker-tab reconciliation." };
+            if (neverOwned && !await this.proveAbsentAgentForCleanup(latestAgent, input.attempt, context)) {
+                return { outcome: "blocked", failure: "The exact unstarted worker pane remains after worker-tab cleanup." };
+            }
             const allocation = ownedIntent(input.attempt, "workspace");
             requireIntentIdentity(allocation, input.attempt);
             assertWorkspaceIntent(allocation, input.attempt);

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.d.ts

@@ -334,6 +334,7 @@ export declare class IsolatedRunner {
     private cleanupPromoted;
     private requireExactIntegration;
     abort(id: string, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
+    private cleanupAborted;
     status(id: string, root: string, outerSignal?: AbortSignal): Promise<RunResponse>;
     private run;
     private dispatchTask;