@henryqw/pi-subagent 23.0.1 → 24.0.0

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.1",
+  "version": "24.0.0",
   "description": "Delegate bounded direct work or durable checked isolated task graphs to Pi roles.",
   "keywords": [
     "pi-package",

package/skills/pi-subagent/SKILL.md

@@ -26,12 +26,12 @@ Use one compact `role`/`name`/`task` packet, `tasks` for independent packets, or
 
 # Isolated requests
 
-Give the request a unique ID and goal. Give each task a unique ID, kind, Role, model class, bounded requirements, deliverable, `dependsOn`, and `contextFrom`. Changesets require focused task checks, and a graph containing changesets requires final checks. The root must have a `package.json` test script; `pnpm test` is added to final checks if missing and runs against the combined tip before Main promotion. Text context may name only completed text tasks and preserves declared order.
+Give the request a unique ID and goal. Give each task a unique ID, kind, Role, model class, bounded requirements, deliverable, `dependsOn`, and `contextFrom`. Changesets require focused task checks, and a graph containing changesets requires final checks. The root must have a `package.json` test script; `pnpm test` is added to final checks if missing and runs against the combined tip before Main promotion. Text context may name only completed text tasks, preserves declared order, and implies a scheduling dependency; do not repeat an edge in `dependsOn` and `contextFrom`.
 
 Every changeset advances automatically after preliminary checks pass. While a locally owned changeset task is actively working, the user may open `/subagent` to queue bounded same-worker revisions or withdraw all still-pending instructions into the native editor and submit one replacement. Cancellation after withdrawal leaves the originals removed; already-claimed instructions cannot be recalled. Each revision must produce a new clean commit and rerun preliminary checks. When no queued revision remains, the runner seals and durably records the exact ready candidate without waiting for sibling workers. There is no guaranteed post-completion editing window, and late follow-ups fail visibly.
 
 A ready candidate does not integrate automatically. Each checked worker triggers a follow-up while its siblings continue; inspect `subagent_status` and immediately use `subagent_stage` with the exact `generation`, `taskId`, `attempt`, candidate `tip`, and `expectedTip` to select and merge it into the owned integration checkout. Stage and resolve are available during the active wave; wait for the wave to settle before rejecting or revising. Resolve conflicts in the integration checkout and verify with `resolve`; never edit Main to resolve them. For dependents, `subagent_integrate advance` acknowledges a durable background wave, then reports checked candidates as they finish. When selected work is staged and the wave settles, use `subagent_integrate validate` on the exact `combinedTip` for full root checks and optional final judgment; `promote` requires passing evidence and unchanged Main. One Main-authored committed correction to a definitively failed combined validation can be recorded with `correct`, then revalidated. Only proven promotion triggers selected-worker termination and verified cleanup. Failures, ambiguity, conflicts, interruption, child-limit exhaustion, or Main drift retain work and never waive checks or identity guards. The extension never pushes, opens a pull request, publishes, or deploys.
 
-After a coordinator interruption in the canonical repository, ask the user to run `/subagent recover` once: it acquires the productive lease, classifies orphaned interruptions, preserves invalid files and retained work, and sends Main one follow-up with blockers and next actions. A live productive lease is read-only and cannot be taken over. Recovery never replays prompts, merges, promotion, or cleanup. Use `subagent_status` to inspect exact durable state without mutation, including candidate identities, generations, and retained resources. `subagent_resume` handles only the reported retry/verify/finalize continuation; it cannot replace Main's stage/integrate decisions or reset policy/corrections. `subagent_stage reject` or `revise` freezes a generation containing the candidate and invalidates dependent attempts; restage chosen work in a new generation. If Main advances cleanly before promotion, use `subagent_integrate refresh` with exact old/new Main and combined-tip identities; restage immutable candidates into the new generation and rerun combined validation. Dirty or divergent Main blocks refresh. At most two unreleased integration worktrees may coexist. Rejected candidates and superseded generations remain retained until Main explicitly calls `subagent_integrate release` with the exact generation and tip; for a rejected worker include its task ID and attempt after releasing all generations using it. Dirty/conflicted or unproved resources block release without force deletion. Impossible fresh dependent work after rejection needs a new request. `subagent_abort` cannot discard retained candidates or integration generations; it may finish once all are released. Old v4 state is rejected (current state is v5), not migrated. Status, abort, process I/O, termination, and verified post-promotion cleanup keep finite safety budgets.
+After a coordinator interruption in the canonical repository, ask the user to run `/subagent recover` once: it acquires the productive lease, classifies orphaned interruptions, preserves invalid files and retained work, and sends Main one follow-up with blockers and next actions. A live productive lease is read-only and cannot be taken over. Recovery never replays prompts, merges, promotion, or cleanup. Use `subagent_status` to inspect exact durable state without mutation, including candidate identities, generations, and retained resources. `subagent_resume` handles only the reported retry/verify/finalize continuation; it cannot replace Main's stage/integrate decisions or reset policy/corrections. `subagent_stage reject` or `revise` freezes a generation containing the candidate and invalidates dependent attempts; restage chosen work in a new generation. If Main advances cleanly before promotion, use `subagent_integrate refresh` with exact old/new Main and combined-tip identities; restage immutable candidates into the new generation and rerun combined validation. Dirty or divergent Main blocks refresh. At most two unreleased integration worktrees may coexist. Rejected candidates and superseded generations remain retained until Main explicitly calls `subagent_integrate release` with the exact generation and tip; for a rejected worker include its task ID and attempt after releasing all generations using it. Dirty/conflicted or unproved resources block release without force deletion. Impossible fresh dependent work after rejection needs a new request. `subagent_abort` cannot discard retained candidates or integration generations; release them first. For workers without candidates, abort cleans only proven unchanged, clean owned resources. If cleanup is deferred or blocked, inspect status and repeat abort after resolving the blocker. Dirty or committed work and uncertain allocations remain for manual recovery. Old v4 state is rejected (current state is v5), not migrated. Status, abort, process I/O, termination, and verified post-promotion cleanup keep finite safety budgets.
 
 All launches use the global policy in `config/pi-subagent/config.json`: productive concurrency, per-child turns/tokens, and idle timeout. Ephemeral children also have a hard runtime limit; isolated requests have a correction cap. Productive requests have no whole-run wall-clock deadline. Request fields cannot replenish or override limits.

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;
-}