@henryqw/pi-subagent 22.2.0 → 22.2.2

package/dist/herdr-runtime.d.ts

@@ -1,5 +1,6 @@
 import { type ExecuteRequest, type HostAllocationIntent, type HostAllocationPlan, type TaskAttempt, type TaskRequest, type WorkspaceIdentity } from "./schema.ts";
 import { type AllocationReconciliation, type HostAllocationKind, type HostAllocationResult, type HostCleanupKind, type HostRuntime, type InFlightTaskCandidateInspector, type OperationContext, type TextTaskContext, type TransientLaunchHandle, type VerifiedLaunch, type WorkerResult } from "./runner.ts";
+import { type EphemeralSubagentExecutionBudget } from "./ephemeral.ts";
 export interface HostProcessOptions {
     cwd: string;
     signal: AbortSignal;
@@ -21,6 +22,7 @@ export interface HerdrHostRuntimeOptions {
     env?: NodeJS.ProcessEnv;
     leaseDirectory?: string;
     lsofCommand?: string;
+    executionBudget?: () => Omit<EphemeralSubagentExecutionBudget, "startedAt">;
 }
 export declare function workspaceLabel(attempt: Pick<TaskAttempt, "correlationToken">): string;
 export declare class HerdrHostRuntime implements HostRuntime {
@@ -34,6 +36,7 @@ export declare class HerdrHostRuntime implements HostRuntime {
     private readonly env;
     private readonly leaseDirectory;
     private readonly lsofCommand;
+    private readonly executionBudget?;
     constructor(options: HerdrHostRuntimeOptions);
     /** Fail-closed Herdr caller/capability gate. This method creates no state or host resource. */
     preflightHost(input: {

package/dist/herdr-runtime.js

@@ -8,6 +8,7 @@ import { createHerdrClient, hasHerdrErrorCode, herdrCommandFailure, startPiAgent
 import { isCleanCommitted, } from "./schema.js";
 import { buildChangesetTaskPrompt, withTransientLaunch, } from "./runner.js";
 import { runProcess as defaultRunProcess } from "./process.js";
+import { EXECUTION_BUDGET_ENV } from "./ephemeral.js";
 const MIN_HERDR_VERSION = [0, 9, 0];
 const MIN_HERDR_PROTOCOL = 22;
 const HERDR_OPERATION_CAP_MS = 30_000;
@@ -151,9 +152,6 @@ function worktreeIntent(attempt) {
 export function workspaceLabel(attempt) {
     return attempt.correlationToken.slice(-6);
 }
-function legacyWorkspaceLabel(requestId, task, attempt) {
-    return `${requestId}/${task.id}#${attempt.number}`;
-}
 function expectedWorkerLabel(task) {
     return `${task.role}/${task.modelClass}`;
 }
@@ -173,10 +171,9 @@ function requireIntentIdentity(intent, attempt) {
         throw new Error(`${intent.kind} allocation intent does not match the task attempt.`);
     }
 }
-function assertWorkspaceIntent(intent, requestId, task, attempt) {
+function assertWorkspaceIntent(intent, attempt) {
     const worktree = worktreeIntent(attempt);
-    const label = exactString(intent.label, "workspace label");
-    if ((label !== workspaceLabel(attempt) && label !== legacyWorkspaceLabel(requestId, task, attempt))
+    if (exactString(intent.label, "workspace label") !== workspaceLabel(attempt)
         || exactAbsolutePath(intent.worktreeCwd, "workspace worktree cwd") !== worktree.cwd
         || exactAbsolutePath(intent.mainRoot, "workspace Main root") !== worktree.repoRoot) {
         throw new Error("Workspace allocation plan drifted from the exact owned worktree.");
@@ -252,6 +249,7 @@ export class HerdrHostRuntime {
     env;
     leaseDirectory;
     lsofCommand;
+    executionBudget;
     constructor(options) {
         this.inspectInFlightCandidate = options.inspectInFlightTaskCandidate;
         this.execute = options.runProcess ?? defaultRunProcess;
@@ -263,6 +261,7 @@ export class HerdrHostRuntime {
         this.env = options.env ?? process.env;
         this.leaseDirectory = resolve(options.leaseDirectory ?? join(extensionConfigDir("pi-subagent"), "leases"));
         this.lsofCommand = options.lsofCommand ?? "lsof";
+        this.executionBudget = options.executionBudget;
     }
     /** Fail-closed Herdr caller/capability gate. This method creates no state or host resource. */
     async preflightHost(input, context) {
@@ -365,7 +364,7 @@ export class HerdrHostRuntime {
         if (input.intent.kind === "workspace") {
             if (input.acquireLaunch)
                 throw new Error("Role launch acquisition is valid only at the exact agent allocation boundary.");
-            return await this.allocateWorkspace(input.intent, input.requestId, input.task, input.attempt, context);
+            return await this.allocateWorkspace(input.intent, input.attempt, context);
         }
         if (input.intent.kind === "worker_tab") {
             if (input.acquireLaunch)
@@ -378,7 +377,7 @@ export class HerdrHostRuntime {
         requireIntentIdentity(input.intent, input.attempt);
         const allocation = input.intent;
         if (allocation.kind === "workspace") {
-            assertWorkspaceIntent(allocation, input.requestId, input.task, input.attempt);
+            assertWorkspaceIntent(allocation, input.attempt);
             await this.assertRepositoryIdentity(allocation, context);
             const response = await this.herdr.json(["worktree", "list", "--cwd", allocation.worktreeCwd], this.processOptions(allocation.herdrRepoRoot, context, HERDR_OPERATION_CAP_MS));
             const result = resultRecord(response, "Herdr worktree list response");
@@ -653,7 +652,7 @@ export class HerdrHostRuntime {
                 assertWorkerTabIntent(allocation, input.task, input.attempt);
                 const leasePath = exactString(allocation.leasePath, "saved worker lease path");
                 this.assertLeasePath(leasePath, input.attempt.correlationToken);
-                assertWorkspaceIntent(workspace, input.requestId, input.task, input.attempt);
+                assertWorkspaceIntent(workspace, input.attempt);
                 await this.assertRepositoryIdentity(workspace, context);
                 const tabId = exactString(allocation.tabId, "saved worker tab ID");
                 const workspaceId = exactString(workspace.workspaceId, "saved workspace ID");
@@ -685,7 +684,7 @@ export class HerdrHostRuntime {
                 return { outcome: "blocked", failure: "Workspace cleanup must follow worker-tab reconciliation." };
             const allocation = ownedIntent(input.attempt, "workspace");
             requireIntentIdentity(allocation, input.attempt);
-            assertWorkspaceIntent(allocation, input.requestId, input.task, input.attempt);
+            assertWorkspaceIntent(allocation, input.attempt);
             await this.assertRepositoryIdentity(allocation, context);
             const workspaceId = exactString(allocation.workspaceId, "saved workspace ID");
             if (await this.workspaceAbsent(workspaceId, allocation, context))
@@ -705,8 +704,8 @@ export class HerdrHostRuntime {
             return { outcome: "blocked", failure: safeText(error) };
         }
     }
-    async allocateWorkspace(allocation, requestId, task, attempt, context) {
-        assertWorkspaceIntent(allocation, requestId, task, attempt);
+    async allocateWorkspace(allocation, attempt, context) {
+        assertWorkspaceIntent(allocation, attempt);
         await this.assertRepositoryIdentity(allocation, context);
         const args = ["worktree", "open", "--cwd", allocation.herdrRepoRoot, "--path", allocation.worktreeCwd, "--label", allocation.label, "--no-focus"];
         const response = await this.herdr.exec(args, this.processOptions(allocation.herdrRepoRoot, context, HERDR_OPERATION_CAP_MS));
@@ -741,9 +740,12 @@ export class HerdrHostRuntime {
         assertWorkerTabIntent(allocation, task, attempt);
         await this.createPrivateLease(allocation.leasePath, allocation.token);
         await this.waitForStableWorkspacePanes(allocation.workspaceId, allocation.worktreeCwd, context);
+        const budget = this.executionBudget?.();
         const args = [
             "tab", "create", "--workspace", allocation.workspaceId, "--cwd", allocation.worktreeCwd,
-            "--label", allocation.label, "--env", `${PROCESS_LEASE_ENV}=${allocation.leasePath}`, "--no-focus",
+            "--label", allocation.label, "--env", `${PROCESS_LEASE_ENV}=${allocation.leasePath}`,
+            ...(budget ? ["--env", `${EXECUTION_BUDGET_ENV}=${JSON.stringify({ ...budget, startedAt: this.now() })}`] : []),
+            "--no-focus",
         ];
         const response = await this.herdr.exec(args, this.processOptions(allocation.worktreeCwd, context, HERDR_OPERATION_CAP_MS));
         if (response.code !== 0 || response.killed) {
@@ -783,8 +785,9 @@ export class HerdrHostRuntime {
         return await withTransientLaunch(handle, async (launch) => {
             if (launch.role !== expectedRole)
                 throw new Error("Agent start acquisition returned the wrong Role.");
-            if (Object.keys(launch.env).length)
+            if (Object.keys(launch.env).some((name) => name !== EXECUTION_BUDGET_ENV || !this.executionBudget)) {
                 throw new Error("Herdr agent launch must not receive caller Role environment variables.");
+            }
             const response = await startPiAgent(this.herdr, {
                 name: allocation.agentName,
                 pane: allocation.paneId,
@@ -827,6 +830,15 @@ export class HerdrHostRuntime {
             if (lifecycle.status === "unknown") {
                 return { outcome: "unknown", diagnostic: "Delivered prompt lifecycle is unknown." };
             }
+            if (lifecycle.status === "working") {
+                try {
+                    await this.delay(STALLED_PROMPT_POLL_MS, context.signal);
+                }
+                catch (error) {
+                    return { outcome: this.contextInterrupted(context) ? "interrupted" : "unknown", diagnostic: `Delivered prompt polling failed: ${safeText(error)}` };
+                }
+                continue;
+            }
             let inspection;
             try {
                 inspection = await this.inspectInFlightCandidate({ root: allocation.worktreeCwd, task: input.task, attempt: input.attempt }, this.childContext(context, GIT_INSPECTION_CAP_MS));

package/dist/integration-git.js

@@ -45,12 +45,15 @@ async function sharedHistory(base, tip, cwd, signal) {
 /** Check helper-derived names even after a safely removed checkout is no longer present. */
 async function ownershipMetadata(root, info, signal) {
     const canonical = await realpath(root);
-    const first = (await requireGit(["worktree", "list", "--porcelain", "-z"], root, signal)).split("\0")[0];
-    const primary = first.startsWith("worktree ") ? await realpath(first.slice("worktree ".length)) : "";
+    const listed = await requireGit(["worktree", "list", "--porcelain", "-z"], root, signal);
+    const primary = listed.split("\0", 1)[0];
+    if (!primary?.startsWith("worktree "))
+        throw new Error("Primary Git worktree is unavailable.");
+    const repoRoot = await realpath(primary.slice("worktree ".length));
     if (await realpath(await requireGit(["rev-parse", "--show-toplevel"], root, signal)) !== canonical
-        || info.repoRoot !== primary || info.cwd !== info.path
+        || info.repoRoot !== repoRoot || info.cwd !== info.path
         || !/^pi-subagent\/subagent-[0-9a-f]{24}$/.test(info.branch)
-        || info.path !== join(primary, ".worktrees", basename(info.branch))) {
+        || info.path !== join(repoRoot, ".worktrees", basename(info.branch))) {
         throw new Error("Git worktree is not an exact owned checkout of Main.");
     }
 }

package/dist/runner.js

@@ -940,6 +940,7 @@ export class IsolatedRunner {
             if (generation && generation.status !== "staging" && generation.status !== "conflict")
                 throw new Error("Stage action has a stale generation.");
             const previousStage = generation?.stages.at(-1);
+            const pendingAllocation = action.action === "resolve" && previousStage?.status === "pending";
             const expected = previousStage?.status === "staged"
                 ? previousStage.tip : previousStage?.onto ?? generation?.integrationBase;
             if (action.action === "stage" && generation?.stages.some((stage) => stage.status !== "staged")) {
@@ -974,6 +975,18 @@ export class IsolatedRunner {
             const actualMain = await scope.call((context) => this.gitRuntime.inspectMain({ root }, context));
             if (!sameIdentity(actualMain, state.main))
                 throw new Error("Main changed or became dirty; staging is blocked.");
+            if (pendingAllocation) {
+                if (!generation?.worktree || generation.status !== "staging" || generation.stages.length !== 1
+                    || !sameIdentity(action.expectedTip, generation.integrationBase)) {
+                    throw new Error("Pending integration allocation is not an exact initial stage.");
+                }
+                const checkout = generation.worktree;
+                const base = await scope.call((context) => this.integrationGit.inspectCombined(root, checkout, state.main, [], context.signal));
+                if (!sameIdentity(base, generation.integrationBase))
+                    throw new Error("Pending integration checkout is not the clean recorded base.");
+                previousStage.status = "staging";
+                await this.saveProductive(handle); // Explicit resolve proves allocation; merge intent precedes the first merge.
+            }
             if (!generation) {
                 if (action.action !== "stage")
                     throw new Error("No integration generation exists to resolve.");
@@ -1018,15 +1031,9 @@ export class IsolatedRunner {
                 }
                 await this.saveProductive(handle); // Exact candidate and previous tip before merge.
             }
-            let outcome = await scope.call((context) => action.action === "stage"
+            const outcome = await scope.call((context) => action.action === "stage" || pendingAllocation
                 ? this.integrationGit.stage(root, worktree, state.main, receipts, worker, candidate.tip, context.signal)
                 : this.integrationGit.reconcileStage(root, worktree, state.main, receipts, worker, candidate.tip, context.signal));
-            if (action.action === "resolve" && stage.status === "pending"
-                && outcome.outcome === "ready" && outcome.value === "not_started") {
-                stage.status = "staging";
-                await this.saveProductive(handle); // Read-only proof before Main's explicit merge request.
-                outcome = await scope.call((context) => this.integrationGit.stage(root, worktree, state.main, receipts, worker, candidate.tip, context.signal));
-            }
             if (outcome.outcome === "ready" && outcome.value !== "not_started") {
                 stage.status = "staged";
                 stage.tip = outcome.value.tip;

package/dist/worktree.d.ts

@@ -46,7 +46,7 @@ export declare function inspectIndexFlags(cwd: string, run?: GitRunner, signal?:
     hidden: boolean;
     failure?: string;
 }>;
-/** Proves a worktree has no tracked, untracked, ignored, index-hidden, or nested submodule work. */
+/** Proves a worktree has no tracked, untracked, index-hidden, or nested submodule work; cleanup also checks ignored files. */
 export declare function inspectWorktreeDirty(cwd: string, run?: GitRunner, includeIgnored?: boolean): Promise<WorktreeDirtyInspection>;
 /**
  * Inspects and possibly prunes a child worktree after it finishes. Commit count

package/dist/worktree.js

@@ -187,7 +187,7 @@ async function inspectDirty(run, cwd, includeIgnored = true) {
         return { dirty: false, failure: "assume-unchanged or skip-worktree index entries remain" };
     return { dirty: false };
 }
-/** Proves a worktree has no tracked, untracked, ignored, index-hidden, or nested submodule work. */
+/** Proves a worktree has no tracked, untracked, index-hidden, or nested submodule work; cleanup also checks ignored files. */
 export async function inspectWorktreeDirty(cwd, run = runGit, includeIgnored = true) {
     const root = await inspectDirty(run, cwd, includeIgnored);
     if (root.dirty || root.failure)
@@ -232,7 +232,7 @@ export async function finalizeChildWorktree(info, run = runGit) {
     const countFailure = counted.code !== 0
         ? `rev-list exit ${counted.code}: ${counted.stderr.trim().slice(0, 200)}`
         : Number.isNaN(commits) ? "rev-list produced non-numeric output" : undefined;
-    const inspection = checkoutExists ? await inspectDirty(run, info.path) : undefined;
+    const inspection = checkoutExists ? await inspectDirty(run, info.path, true) : undefined;
     const measurements = {
         ...(countFailure === undefined ? { commits } : {}),
         ...(inspection?.failure === undefined && inspection !== undefined ? { dirty: inspection.dirty } : {}),

package/extensions/isolated.ts

@@ -65,18 +65,19 @@ export const createIsolatedComponents: CreateIsolatedComponents = ({
 		: await directRunProcess(command, args, options);
 	const resolveRoot = createCanonicalGitRootResolver({ runProcess });
 	const git = new CheckedGitRuntime({ runProcess, executeReview: createExactJudgmentExecutor(executor) });
-	const host = new HerdrHostRuntime({ inspectInFlightTaskCandidate: git.inspectInFlightTaskCandidate.bind(git), runProcess });
+	const executionBudget = () => ({
+		maxTurns: policy.maxTurns,
+		maxMs: null,
+		...(policy.maxTokens === undefined ? {} : { maxTokens: policy.maxTokens }),
+	});
+	const host = new HerdrHostRuntime({ inspectInFlightTaskCandidate: git.inspectInFlightTaskCandidate.bind(git), runProcess, executionBudget });
 	const coordinator = new RoleLaunchRuntime({
 		pi,
 		context,
 		resolveRoot,
 		preflightHost: async ({ root }, operation) => await host.preflightHost({ root }, operation),
 		inspectMain: async (input, operation) => await git.inspectMain(input, operation),
-		executionBudget: () => ({
-			maxTurns: policy.maxTurns,
-			maxMs: null,
-			...(policy.maxTokens === undefined ? {} : { maxTokens: policy.maxTokens }),
-		}),
+		executionBudget,
 	});
 	return {
 		resolveRoot,

package/extensions/result-transport.ts

@@ -3,7 +3,7 @@ import type { WorkflowEntry, WorkflowMode } from "./workflow.ts";
 
 const EVIDENCE_PREVIEW_CODE_POINTS = 256;
 
-export type WorkflowTransportStatus = "pending" | "running" | "succeeded" | "failed" | "rejected" | "skipped";
+export type WorkflowTransportStatus = "pending" | "running" | "succeeded" | "rejected" | "skipped";
 
 type TransportEntryBase = {
 	id: WorkflowEntry["id"];
@@ -17,7 +17,7 @@ type TransportEntryBase = {
 export type WorkflowTransportEntry =
 	| TransportEntryBase & { status: "pending" | "skipped"; assistantOutput?: never; failure?: never }
 	| TransportEntryBase & { status: "running" | "succeeded"; assistantOutput: string; failure?: never }
-	| TransportEntryBase & { status: "failed" | "rejected"; assistantOutput?: never; failure: string };
+	| TransportEntryBase & { status: "rejected"; assistantOutput?: never; failure: string };
 
 export type WorkflowTransportEntryDetails = {
 	id: string;
@@ -37,7 +37,7 @@ export type WorkflowTransportDetails = {
 
 export type BackgroundWorkflowTransportDetails = WorkflowTransportDetails & {
 	taskId: string;
-	outcome: "completed" | "failed" | "aborted";
+	outcome: "completed" | "failed";
 	recovery?: true;
 };
 
@@ -63,7 +63,7 @@ function workflowTitle(mode: WorkflowMode): string {
 function statusCounts(entries: readonly WorkflowTransportEntry[]): string[] {
 	const count = (statuses: WorkflowTransportStatus[]) => entries.filter(({ status }) => statuses.includes(status)).length;
 	return ([
-		[["failed", "rejected"], "failed"],
+		[["rejected"], "failed"],
 		[["succeeded"], "completed"],
 		[["skipped"], "skipped"],
 	] as const).flatMap(([statuses, word]) => {
@@ -84,7 +84,6 @@ const ENTRY_STATUS_PRESENTATION = {
 	pending: { glyph: "○", fallback: "queued" },
 	running: { glyph: "◌", fallback: "working" },
 	succeeded: { glyph: "✓", fallback: "completed" },
-	failed: { glyph: "✗", fallback: "failed" },
 	rejected: { glyph: "✗", fallback: "failed" },
 	skipped: { glyph: "–", fallback: "skipped" },
 } as const satisfies Record<WorkflowTransportEntryDetails["status"], WorkflowEntryStatusPresentation>;
@@ -94,7 +93,7 @@ export function presentWorkflowEntryStatus(status: WorkflowTransportEntryDetails
 }
 
 function sourceFor(entry: WorkflowTransportEntry): string | undefined {
-	if (entry.status === "failed" || entry.status === "rejected") return entry.failure;
+	if (entry.status === "rejected") return entry.failure;
 	if (entry.status === "running" || entry.status === "succeeded") return entry.assistantOutput;
 }
 
@@ -103,7 +102,7 @@ function evidenceFor(entry: WorkflowTransportEntry, position: number, total: num
 	if (source === undefined || !source) return;
 	const [preview, remainder] = splitEvidence(source);
 	return {
-		heading: `- [${position}/${total}] ${entry.name} · ${entry.role} · ${entry.status === "failed" || entry.status === "rejected" ? "failure" : "result"}:`,
+		heading: `- [${position}/${total}] ${entry.name} · ${entry.role} · ${entry.status === "rejected" ? "failure" : "result"}:`,
 		preview,
 		remainder,
 	};
@@ -114,7 +113,7 @@ export function formatWorkflowResult(mode: WorkflowMode, entries: readonly Workf
 	if (ordered.some(({ status }) => status === "pending" || status === "running")) {
 		throw new TypeError("Final workflow transport requires terminal entry states.");
 	}
-	const failed = ordered.some(({ status }) => status === "failed" || status === "rejected");
+	const failed = ordered.some(({ status }) => status === "rejected");
 	const positioned = ordered.map((entry, index) => ({ entry, position: index + 1 }));
 	const evidence = positioned.flatMap(({ entry, position }) => {
 		const value = evidenceFor(entry, position, ordered.length);

package/extensions/subagent.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 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 EphemeralSubagentTimeout, type Role } from "@henryqw/pi-subagent";
+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 } from "./admission.ts";
 import { registerIsolatedExtension } from "./isolated.ts";
@@ -18,8 +18,7 @@ const MAX_WIDGET_ITEMS = 8;
 const MAX_WIDGET_LINES = 6;
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
-type TimeoutPolicy = EphemeralSubagentTimeout;
-type WidgetStatus = "working" | "success" | "failure" | "aborted";
+type WidgetStatus = "working" | "success" | "failure";
 type WidgetItem = {
 	role: string;
 	model: string;
@@ -42,7 +41,6 @@ function statusGlyph(status: WidgetStatus, spinnerIndex: number, theme: Theme):
 		case "working": return theme.fg("accent", SPINNER_FRAMES[spinnerIndex % SPINNER_FRAMES.length]!);
 		case "success": return theme.fg("success", "✓");
 		case "failure": return theme.fg("error", "✗");
-		case "aborted": return theme.fg("warning", "■");
 	}
 }
 
@@ -51,7 +49,6 @@ function statusLabel(status: WidgetStatus): string {
 		case "working": return "working";
 		case "success": return "complete";
 		case "failure": return "failed";
-		case "aborted": return "stopped";
 	}
 }
 
@@ -87,11 +84,11 @@ function renderWidgetRows(
 	});
 	const hidden = ordered.slice(visible.length);
 	if (hidden.length) {
-		const counts: Record<WidgetStatus, number> = { working: 0, success: 0, failure: 0, aborted: 0 };
+		const counts: Record<WidgetStatus, number> = { working: 0, success: 0, failure: 0 };
 		for (const { status } of hidden) counts[status] += 1;
 		lines.push(truncateToWidth(theme.fg("muted", [
 			`… ${hidden.length} more`,
-			...(["working", "success", "failure", "aborted"] as const).flatMap((status) =>
+			...(["working", "success", "failure"] as const).flatMap((status) =>
 				counts[status] ? [`${counts[status]} ${statusLabel(status)}`] : []),
 		].join(" · ")), width));
 	}
@@ -128,10 +125,7 @@ const roleSummary = (): string => {
 	}
 };
 
-export default function subagentExtension(
-	pi: ExtensionAPI,
-	overrideTimeoutPolicy?: TimeoutPolicy,
-): void {
+export default function subagentExtension(pi: ExtensionAPI): void {
 	if (process.argv.includes(`--${ROLE_TOOL_POLICY_FLAG}`)) return;
 	registerModelTask(pi, DELEGATE_TASK);
 	pi.registerMessageRenderer(DIRECT_RESULT_TYPE, (message, { expanded, outputPad }, theme) => {
@@ -142,11 +136,9 @@ export default function subagentExtension(
 		if (!details?.entries) return new Text(content, outputPad, 0);
 		const count = details.entries.length;
 		const subject = count === 1 ? "Direct subagent" : `${count} direct subagents`;
-		const state = details.recovery ? "stopped; recovery needed"
-			: details.outcome === "completed" ? "completed"
-				: details.outcome === "failed" ? "failed" : "stopped";
-		const glyph = details.recovery || details.outcome === "aborted" ? "■" : details.outcome === "completed" ? "✓" : "✗";
-		const color = details.recovery || details.outcome === "aborted" ? "warning" : details.outcome === "completed" ? "success" : "error";
+		const state = details.recovery ? "stopped; recovery needed" : details.outcome;
+		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);
 			return `${glyph} ${name} · ${role} — ${details.recovery ? fallback : summary || fallback}`;
@@ -175,20 +167,11 @@ export default function subagentExtension(
 			maxCorrections: DEFAULT_EXECUTION_POLICY.maxCorrections,
 		};
 	}
-	const timeoutPolicy: TimeoutPolicy = overrideTimeoutPolicy ?? {
-		idleMs: initialPolicy.childIdleMs,
-		maxMs: initialPolicy.childMaxMs,
-	};
-	const effectiveInitialPolicy: EffectiveExecutionPolicy = {
-		...initialPolicy,
-		childIdleMs: timeoutPolicy.idleMs,
-		childMaxMs: timeoutPolicy.maxMs ?? initialPolicy.childMaxMs,
-	};
 	const executor = createEphemeralSubagentExecutor({
-		maxConcurrency: effectiveInitialPolicy.maxSubagents,
-		maxTurns: effectiveInitialPolicy.maxTurns,
-		maxTokens: effectiveInitialPolicy.maxTokens,
-		timeout: timeoutPolicy,
+		maxConcurrency: initialPolicy.maxSubagents,
+		maxTurns: initialPolicy.maxTurns,
+		maxTokens: initialPolicy.maxTokens,
+		timeout: { idleMs: initialPolicy.childIdleMs, maxMs: initialPolicy.childMaxMs },
 	});
 	const currentPolicy = (): EffectiveExecutionPolicy => resolveExecutionPolicy(readSubagentConfig());
 	const canWrite = (input: unknown): boolean => {
@@ -205,7 +188,7 @@ export default function subagentExtension(
 	admission.register(pi, canWrite);
 	const isolatedSurface = registerIsolatedExtension(pi, {
 		executor,
-		policy: effectiveInitialPolicy,
+		policy: initialPolicy,
 		currentPolicy,
 	});
 	let directSequence = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@henryqw/pi-subagent",
-  "version": "22.2.0",
+  "version": "22.2.2",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",