@henryqw/pi-subagent 23.0.2 → 24.0.1

package/extensions/config.ts

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

package/extensions/isolated.ts

@@ -17,9 +17,9 @@ import { RoleLaunchRuntime, type LaunchRuntimeOptions } from "../dist/launch-run
 import { IsolatedRunner, type OperationContext, type RunResponse } from "../dist/runner.js";
 import {
 	IdOnlySchema,
-	ResumeRequestSchema,
+	ResumeRequestParameters,
 	StageRequestSchema,
-	IntegrationActionSchema,
+	IntegrationActionParameters,
 	parseIntegrationAction,
 	parseStageRequest,
 	parseExecuteRequest,
@@ -77,7 +77,6 @@ export const createIsolatedComponents: CreateIsolatedComponents = ({
 		resolveRoot,
 		preflightHost: async ({ root }, operation) => await host.preflightHost({ root }, operation),
 		inspectMainBase: async (input, operation) => await git.inspectMainBase(input, operation),
-		executionBudget,
 	});
 	return {
 		resolveRoot,
@@ -615,7 +614,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		name: "subagent_resume",
 		label: "Subagent resume",
 		description: "Resume one unfinished isolated request without resetting its recorded policy or correction count.",
-		parameters: ResumeRequestSchema,
+		parameters: ResumeRequestParameters,
 		prepareArguments: parseResumeRequest,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;
@@ -642,7 +641,7 @@ export function registerIsolatedExtension(pi: ExtensionAPI, options: RegisterIso
 		name: "subagent_integrate",
 		label: "Subagent integrate",
 		description: "Main advances staged dependents, refreshes after clean Main drift, validates, corrects, promotes, reconciles an interrupted promotion, cleans up promoted resources, or explicitly releases rejected/superseded owned resources. Never replays an uncertain mutation.",
-		parameters: IntegrationActionSchema,
+		parameters: IntegrationActionParameters,
 		prepareArguments: parseIntegrationAction,
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			latestCtx = ctx;

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,13 +3,13 @@ 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 { DelegateTaskSchema, identifyWorkflowEntries, parseDelegateTask, runForegroundWorkflow, type Delegation, type ParsedWorkflow, type WorkflowEntry } from "./workflow.ts";
+import { ENTRY_STATUS_PRESENTATION, formatWorkflowResult, type BackgroundWorkflowTransportDetails, type WorkflowTransportEntry } from "./result-transport.ts";
+import { DelegateTaskParameters, 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";
 const WIDGET_KEY = "subagent-status";
@@ -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,
@@ -464,7 +460,7 @@ export default function subagentExtension(pi: ExtensionAPI): void {
 			"Isolation uses typed tasks and dependencies. Keep tightly coupled changes with one owner; do not split by file count. Failures, ambiguity, limits, and conflicts retain work and never waive checks or identity guards.",
 			`For delegate_task, ${MODEL_CLASS_GUIDANCE} A direct model replaces only the selected route's model; its thinking level stays unchanged.`,
 		],
-		parameters: DelegateTaskSchema,
+		parameters: DelegateTaskParameters,
 		prepareArguments(args) {
 			try {
 				const parsed = parseDelegateTask(args);
@@ -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

@@ -42,7 +42,20 @@ export const DirectWorkflowSchema = Type.Object({
 	chain: Type.Optional(Type.Array(DelegationSchema, { minItems: 1, maxItems: MAX_WORKFLOW_ENTRIES })),
 }, { additionalProperties: false, description: "Direct mode: exactly one compact single, tasks, or chain workflow" });
 
-export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema], { type: "object" });
+export const DelegateTaskSchema = Type.Union([DirectWorkflowSchema, ExecuteRequestSchema]);
+// Keep the strict mode union for parsing; expose a plain object root to tool providers.
+export const DelegateTaskParameters = Type.Object({
+	...DirectWorkflowSchema.properties,
+	mode: Type.Union([DirectWorkflowSchema.properties.mode, ExecuteRequestSchema.properties.mode]),
+	id: Type.Optional(ExecuteRequestSchema.properties.id),
+	goal: Type.Optional(ExecuteRequestSchema.properties.goal),
+	tasks: Type.Optional(Type.Union([
+		Type.Array(DelegationSchema, { minItems: 1, maxItems: MAX_WORKFLOW_ENTRIES }),
+		ExecuteRequestSchema.properties.tasks,
+	])),
+	finalChecks: ExecuteRequestSchema.properties.finalChecks,
+	finalJudgment: ExecuteRequestSchema.properties.finalJudgment,
+}, { additionalProperties: false });
 export const WorkflowSchema = DirectWorkflowSchema;
 
 export type Delegation = Static<typeof DelegationSchema> & { kind: "text" };

package/package.json

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

package/dist/working-evidence.d.ts

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