@selesai/code 0.13.15 → 0.13.18

package/dist/extensions/pi-subagents/src/runs/shared/async-status-projection.ts

@@ -1,6 +1,6 @@
 import { sanitizeDisplayText, truncateDisplayText } from "../../shared/display-text.ts";
 import { formatModelThinking } from "../../shared/formatters.ts";
-import type { AsyncJobState, AsyncJobStep, HostStepFreshnessV1, HostStepMonitorKind, HostStepNodeV1, HostStepState, HostStepVerdict, NestedRunSummary, NestedStepSummary, SubagentRunMode, WorkflowGraphSnapshot, WorkflowPreflightLaneV1, WorkflowPreflightV1 } from "../../shared/types.ts";
+import type { AsyncJobState, AsyncJobStep, HostStepFreshness, HostStepMonitorKind, HostStepNode, HostStepState, HostStepVerdict, NestedRunSummary, NestedStepSummary, SubagentRunMode, WorkflowGraphSnapshot, WorkflowPreflightLane, WorkflowPreflight } from "../../shared/types.ts";
 import { HOST_STEP_MAX_COUNT, HOST_STEP_MAX_DETAIL_CHARS, HOST_STEP_MAX_LABEL_CHARS, HOST_STEP_MAX_PROVIDER_CHARS, HOST_STEP_MAX_REASON_CHARS, HOST_STEP_MAX_REF_CHARS, HOST_STEP_MAX_ROLE_CHARS, HOST_STEP_MAX_TARGET_CHARS, hostStepReportName, parseHostStepNode, validHostStepNodes } from "./host-step-status.ts";
 import { workflowPreflightLaneForRuntimeKey } from "../../workflows/workflow-preflight.ts";
 import { workflowGraphStageNodes } from "./workflow-graph.ts";
@@ -32,7 +32,7 @@ function isAsyncStatusSnapshotState(value: string): value is AsyncStatusSnapshot
 	return Object.hasOwn(ASYNC_STATUS_SNAPSHOT_STATES, value);
 }
 
-export interface AsyncStatusSnapshotActivityV1 {
+export interface AsyncStatusSnapshotActivity {
 	state?: string;
 	currentTool?: string;
 	lastActivityAt?: number;
@@ -41,7 +41,7 @@ export interface AsyncStatusSnapshotActivityV1 {
 	toolCount?: number;
 }
 
-export interface AsyncStatusSnapshotHostStepV1 {
+export interface AsyncStatusSnapshotHostStep {
 	kind: HostStepMonitorKind;
 	provider?: string;
 	role?: string;
@@ -54,7 +54,7 @@ export interface AsyncStatusSnapshotHostStepV1 {
 	report?: string;
 }
 
-export interface AsyncStatusSnapshotNodeV1 {
+export interface AsyncStatusSnapshotNode {
 	id: string;
 	kind: AsyncStatusSnapshotKind | "host-step";
 	label: string;
@@ -62,12 +62,12 @@ export interface AsyncStatusSnapshotNodeV1 {
 	startedAt?: number;
 	updatedAt?: number;
 	endedAt?: number;
-	activity?: AsyncStatusSnapshotActivityV1;
-	hostStep?: AsyncStatusSnapshotHostStepV1;
-	children?: AsyncStatusSnapshotNodeV1[];
+	activity?: AsyncStatusSnapshotActivity;
+	hostStep?: AsyncStatusSnapshotHostStep;
+	children?: AsyncStatusSnapshotNode[];
 }
 
-export interface AsyncStatusSnapshotCapsV1 {
+export interface AsyncStatusSnapshotCaps {
 	maxRuns: number;
 	maxChildrenPerNode: number;
 	maxDepth: number;
@@ -75,19 +75,19 @@ export interface AsyncStatusSnapshotCapsV1 {
 	maxSerializedBytes: number;
 }
 
-export interface AsyncStatusSnapshotOmittedV1 {
+export interface AsyncStatusSnapshotOmitted {
 	runs: number;
 	children: number;
 	byteLimitExceeded: boolean;
 }
 
-export interface AsyncStatusSnapshotV1 {
+export interface AsyncStatusSnapshot {
 	kind: typeof ASYNC_STATUS_SNAPSHOT_KIND;
 	version: typeof ASYNC_STATUS_SNAPSHOT_VERSION;
 	generatedAt: number;
-	caps: AsyncStatusSnapshotCapsV1;
-	omitted: AsyncStatusSnapshotOmittedV1;
-	runs: AsyncStatusSnapshotNodeV1[];
+	caps: AsyncStatusSnapshotCaps;
+	omitted: AsyncStatusSnapshotOmitted;
+	runs: AsyncStatusSnapshotNode[];
 }
 
 export interface AsyncStatusSnapshotOptions {
@@ -117,19 +117,19 @@ export interface AsyncStatusWorkflowRow {
 	reasonCode?: string;
 	detail?: string;
 	target?: string;
-	freshness?: HostStepFreshnessV1;
+	freshness?: HostStepFreshness;
 	reportPath?: string;
-	preflight?: WorkflowPreflightLaneV1;
+	preflight?: WorkflowPreflightLane;
 }
 
 interface ProjectionContext {
-	caps: AsyncStatusSnapshotCapsV1;
-	omitted: AsyncStatusSnapshotOmittedV1;
+	caps: AsyncStatusSnapshotCaps;
+	omitted: AsyncStatusSnapshotOmitted;
 }
 
-function validHostStepList(source: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | undefined): HostStepNodeV1[] {
+function validHostStepList(source: readonly HostStepNode[] | WorkflowGraphSnapshot | undefined): HostStepNode[] {
 	if (source && "nodes" in source) return validHostStepNodes(source);
-	const hostSteps: HostStepNodeV1[] = [];
+	const hostSteps: HostStepNode[] = [];
 	for (const [index, value] of (source ?? []).slice(0, HOST_STEP_MAX_COUNT).entries()) {
 		try {
 			hostSteps.push(parseHostStepNode(value, `hostSteps[${index}]`));
@@ -140,7 +140,7 @@ function validHostStepList(source: readonly HostStepNodeV1[] | WorkflowGraphSnap
 	return hostSteps;
 }
 
-function resolveCaps(options: AsyncStatusSnapshotOptions): AsyncStatusSnapshotCapsV1 {
+function resolveCaps(options: AsyncStatusSnapshotOptions): AsyncStatusSnapshotCaps {
 	return {
 		maxRuns: Math.max(0, Math.floor(options.maxRuns ?? DEFAULT_MAX_RUNS)),
 		maxChildrenPerNode: Math.max(0, Math.floor(options.maxChildrenPerNode ?? DEFAULT_MAX_CHILDREN_PER_NODE)),
@@ -199,13 +199,13 @@ function activityFor(source: {
 	currentToolStartedAt?: unknown;
 	turnCount?: unknown;
 	toolCount?: unknown;
-}, ctx: ProjectionContext): AsyncStatusSnapshotActivityV1 | undefined {
+}, ctx: ProjectionContext): AsyncStatusSnapshotActivity | undefined {
 	const currentTool = publicOptionalText(source.currentTool, ctx.caps.maxStringLength);
 	const lastActivityAt = publicTime(source.lastActivityAt);
 	const currentToolStartedAt = publicTime(source.currentToolStartedAt);
 	const turnCount = publicCount(source.turnCount);
 	const toolCount = publicCount(source.toolCount);
-	const activity: AsyncStatusSnapshotActivityV1 = {
+	const activity: AsyncStatusSnapshotActivity = {
 		...(typeof source.activityState === "string" ? { state: publicText(source.activityState, "unknown", ctx.caps.maxStringLength) } : {}),
 		...(currentTool ? { currentTool } : {}),
 		...(lastActivityAt !== undefined ? { lastActivityAt } : {}),
@@ -216,19 +216,19 @@ function activityFor(source: {
 	return Object.keys(activity).length ? activity : undefined;
 }
 
-function appendBoundedChildren(children: AsyncStatusSnapshotNodeV1[], source: readonly AsyncStatusSnapshotNodeV1[], ctx: ProjectionContext): void {
+function appendBoundedChildren(children: AsyncStatusSnapshotNode[], source: readonly AsyncStatusSnapshotNode[], ctx: ProjectionContext): void {
 	const remaining = Math.max(0, ctx.caps.maxChildrenPerNode - children.length);
 	children.push(...source.slice(0, remaining));
 	ctx.omitted.children += Math.max(0, source.length - remaining);
 }
 
-function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = normalizeState(step.status);
 	const startedAt = publicTime(step.startedAt);
 	const endedAt = publicTime(step.endedAt);
 	const updatedAt = endedAt ?? publicTime(step.lastActivityAt) ?? startedAt;
 	const activity = activityFor(step, ctx);
-	const node: AsyncStatusSnapshotNodeV1 = {
+	const node: AsyncStatusSnapshotNode = {
 		id: publicText("workflowKey" in step && step.workflowKey ? step.workflowKey : "runId" in step && step.runId ? step.runId : `step:${index}`, `step:${index}`, ctx.caps.maxStringLength),
 		kind: "step",
 		label: publicText("label" in step && step.label ? step.label : step.agent, "step", ctx.caps.maxStringLength),
@@ -240,7 +240,7 @@ function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, dept
 	};
 	if (depth < ctx.caps.maxDepth && step.children?.length) {
 		const nested = step.children.map((child, childIndex) => projectNestedRun(child, childIndex, depth + 1, ctx));
-		const bounded: AsyncStatusSnapshotNodeV1[] = [];
+		const bounded: AsyncStatusSnapshotNode[] = [];
 		appendBoundedChildren(bounded, nested, ctx);
 		if (bounded.length) node.children = bounded;
 	} else if (step.children?.length) {
@@ -249,7 +249,7 @@ function projectStep(step: AsyncJobStep | NestedStepSummary, index: number, dept
 	return node;
 }
 
-function projectWorkflowGraphNode(node: WorkflowGraphSnapshot["nodes"][number], index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectWorkflowGraphNode(node: WorkflowGraphSnapshot["nodes"][number], index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const step: AsyncJobStep = {
 		agent: node.agent ?? node.label,
 		status: workflowGraphStepStatus(node.status),
@@ -259,13 +259,13 @@ function projectWorkflowGraphNode(node: WorkflowGraphSnapshot["nodes"][number],
 	return projectStep(step, node.flatIndex ?? index, depth, ctx);
 }
 
-function projectNestedRun(child: NestedRunSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectNestedRun(child: NestedRunSummary, index: number, depth: number, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = normalizeState(child.state);
 	const startedAt = publicTime(child.startedAt);
 	const endedAt = publicTime(child.endedAt);
 	const updatedAt = publicTime(child.lastUpdate) ?? endedAt ?? publicTime(child.lastActivityAt) ?? startedAt;
 	const activity = activityFor(child, ctx);
-	const node: AsyncStatusSnapshotNodeV1 = {
+	const node: AsyncStatusSnapshotNode = {
 		id: publicText(child.id, `nested:${index}`, ctx.caps.maxStringLength),
 		kind: kindForMode(child.mode),
 		label: child.agent ? publicText(child.agent, "subagent", ctx.caps.maxStringLength) : labelForAgents(child.agents, child.mode ?? "subagent", ctx.caps.maxStringLength),
@@ -278,7 +278,7 @@ function projectNestedRun(child: NestedRunSummary, index: number, depth: number,
 	if (depth < ctx.caps.maxDepth) {
 		const nestedSteps = child.steps?.map((step, stepIndex) => projectStep(step, stepIndex, depth + 1, ctx)) ?? [];
 		const nestedChildren = child.children?.map((nested, childIndex) => projectNestedRun(nested, childIndex, depth + 1, ctx)) ?? [];
-		const bounded: AsyncStatusSnapshotNodeV1[] = [];
+		const bounded: AsyncStatusSnapshotNode[] = [];
 		appendBoundedChildren(bounded, [...nestedSteps, ...nestedChildren], ctx);
 		if (bounded.length) node.children = bounded;
 	} else {
@@ -295,11 +295,11 @@ function hostStepSnapshotState(state: HostStepState, verdict: HostStepVerdict |
 	return verdict === undefined || verdict === "inconclusive" ? "partial" : "complete";
 }
 
-function projectHostStep(hostStep: HostStepNodeV1, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectHostStep(hostStep: HostStepNode, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = hostStepSnapshotState(hostStep.state, hostStep.verdict);
 	const detail = publicOptionalText(hostStep.detail, ctx.caps.maxStringLength);
 	const report = publicOptionalText(hostStepReportName(hostStep.reportPath), ctx.caps.maxStringLength);
-	const hostMetadata: AsyncStatusSnapshotHostStepV1 = {
+	const hostMetadata: AsyncStatusSnapshotHostStep = {
 		kind: hostStep.monitorKind,
 		state: hostStep.state,
 		...(hostStep.provider ? { provider: publicText(hostStep.provider, "provider", ctx.caps.maxStringLength) } : {}),
@@ -322,12 +322,12 @@ function projectHostStep(hostStep: HostStepNodeV1, ctx: ProjectionContext): Asyn
 	};
 }
 
-function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnapshotNodeV1 {
+function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnapshotNode {
 	const state = normalizeState(job.status);
 	const startedAt = publicTime(job.startedAt);
 	const updatedAt = publicTime(job.updatedAt) ?? startedAt;
 	const activity = activityFor(job, ctx);
-	const node: AsyncStatusSnapshotNodeV1 = {
+	const node: AsyncStatusSnapshotNode = {
 		id: publicText(job.asyncId, "async", ctx.caps.maxStringLength),
 		kind: kindForMode(job.mode),
 		label: labelForAgents(job.agents, job.mode ?? "subagent", ctx.caps.maxStringLength),
@@ -349,7 +349,7 @@ function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnap
 		const ordinaryChildren = [...stepChildren, ...graphChildren, ...nestedChildren];
 		const retainedHostSteps = hostStepChildren.slice(0, ctx.caps.maxChildrenPerNode);
 		const retainedOrdinaryChildren = ordinaryChildren.slice(0, ctx.caps.maxChildrenPerNode - retainedHostSteps.length);
-		const bounded: AsyncStatusSnapshotNodeV1[] = [];
+		const bounded: AsyncStatusSnapshotNode[] = [];
 		bounded.push(...retainedOrdinaryChildren, ...retainedHostSteps);
 		ctx.omitted.children += ordinaryChildren.length - retainedOrdinaryChildren.length + hostStepChildren.length - retainedHostSteps.length;
 		if (bounded.length) node.children = bounded;
@@ -362,11 +362,11 @@ function projectRun(job: AsyncJobState, ctx: ProjectionContext): AsyncStatusSnap
 	return node;
 }
 
-function snapshotBytes(snapshot: AsyncStatusSnapshotV1): number {
+function snapshotBytes(snapshot: AsyncStatusSnapshot): number {
 	return Buffer.byteLength(JSON.stringify(snapshot), "utf8");
 }
 
-function enforceByteLimit(snapshot: AsyncStatusSnapshotV1): void {
+function enforceByteLimit(snapshot: AsyncStatusSnapshot): void {
 	if (snapshotBytes(snapshot) <= snapshot.caps.maxSerializedBytes) return;
 	snapshot.omitted.byteLimitExceeded = true;
 	const runs = snapshot.runs;
@@ -401,7 +401,7 @@ function workflowStepName(step: AsyncJobStep, index: number): string {
 	return `${phase}${key}${label} (${step.agent})`;
 }
 
-function hostStepRow(hostStep: HostStepNodeV1): AsyncStatusWorkflowRow {
+function hostStepRow(hostStep: HostStepNode): AsyncStatusWorkflowRow {
 	const freshness = hostStep.freshness
 		? {
 			expectedRef: publicText(hostStep.freshness.expectedRef, "ref", HOST_STEP_MAX_REF_CHARS),
@@ -425,11 +425,11 @@ function hostStepRow(hostStep: HostStepNodeV1): AsyncStatusWorkflowRow {
 }
 
 
-function isWorkflowPreflight(value: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | WorkflowPreflightV1 | undefined): value is WorkflowPreflightV1 {
+function isWorkflowPreflight(value: readonly HostStepNode[] | WorkflowGraphSnapshot | WorkflowPreflight | undefined): value is WorkflowPreflight {
 	return value !== undefined && !Array.isArray(value) && "lanes" in value;
 }
 
-function isWorkflowGraph(value: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | WorkflowPreflightV1 | undefined): value is WorkflowGraphSnapshot {
+function isWorkflowGraph(value: readonly HostStepNode[] | WorkflowGraphSnapshot | WorkflowPreflight | undefined): value is WorkflowGraphSnapshot {
 	return value !== undefined && !Array.isArray(value) && "nodes" in value;
 }
 
@@ -465,7 +465,7 @@ function workflowGraphRowName(node: WorkflowGraphSnapshot["nodes"][number]): str
 	return `${phase ? `${phase}: ` : ""}${key}${label && label !== node.id ? ` · ${label}` : ""}${agent ? ` (${agent})` : ""}`;
 }
 
-function projectWorkflowGraphRow(node: WorkflowGraphSnapshot["nodes"][number], preflight?: WorkflowPreflightLaneV1): AsyncStatusWorkflowRow {
+function projectWorkflowGraphRow(node: WorkflowGraphSnapshot["nodes"][number], preflight?: WorkflowPreflightLane): AsyncStatusWorkflowRow {
 	return {
 		name: workflowGraphRowName(node),
 		state: workflowGraphRowState(node.status),
@@ -476,14 +476,14 @@ function projectWorkflowGraphRow(node: WorkflowGraphSnapshot["nodes"][number], p
 /** Project authoritative workflow facts into compact rows, annotated by preflight hints. */
 export function projectAsyncWorkflowRows(
 	steps: readonly AsyncJobStep[] | undefined,
-	hostStepsOrPreflight?: readonly HostStepNodeV1[] | WorkflowGraphSnapshot | WorkflowPreflightV1,
-	preflightOverride?: WorkflowPreflightV1,
+	hostStepsOrPreflight?: readonly HostStepNode[] | WorkflowGraphSnapshot | WorkflowPreflight,
+	preflightOverride?: WorkflowPreflight,
 ): AsyncStatusWorkflowRow[] {
 	const preflight = preflightOverride ?? (isWorkflowPreflight(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined);
 	const graph = isWorkflowGraph(hostStepsOrPreflight) ? hostStepsOrPreflight : undefined;
 	const hostSteps = isWorkflowPreflight(hostStepsOrPreflight) || graph ? undefined : hostStepsOrPreflight;
 	const loaded = steps ?? [];
-	const preflightForKey = (key: string, groupKeys: readonly (string | undefined)[] = []): WorkflowPreflightLaneV1 | undefined =>
+	const preflightForKey = (key: string, groupKeys: readonly (string | undefined)[] = []): WorkflowPreflightLane | undefined =>
 		workflowPreflightLaneForRuntimeKey(preflight, key, groupKeys);
 	if (graph) {
 		const loadedIndexesByKey = new Map<string, number[]>();
@@ -526,7 +526,7 @@ export function projectAsyncWorkflowRows(
 	];
 }
 
-function projectLoadedWorkflowRow(step: AsyncJobStep, index: number, preflight?: WorkflowPreflightLaneV1): AsyncStatusWorkflowRow {
+function projectLoadedWorkflowRow(step: AsyncJobStep, index: number, preflight?: WorkflowPreflightLane): AsyncStatusWorkflowRow {
 	const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
 	const activity = workflowStepActivity(step);
 	return {
@@ -543,7 +543,7 @@ function projectLoadedWorkflowRow(step: AsyncJobStep, index: number, preflight?:
 }
 
 /** Project already-loaded async status facts into the bounded public snapshot shape. */
-export function projectAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, options: AsyncStatusSnapshotOptions = {}): AsyncStatusSnapshotV1 {
+export function projectAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, options: AsyncStatusSnapshotOptions = {}): AsyncStatusSnapshot {
 	const caps = resolveCaps(options);
 	const ctx: ProjectionContext = { caps, omitted: { runs: 0, children: 0, byteLimitExceeded: false } };
 	const sorted = [...jobs].sort((left, right) => {
@@ -552,7 +552,7 @@ export function projectAsyncStatusSnapshot(jobs: Iterable<AsyncJobState>, option
 		return rightUpdated - leftUpdated || left.asyncId.localeCompare(right.asyncId);
 	});
 	ctx.omitted.runs += Math.max(0, sorted.length - caps.maxRuns);
-	const snapshot: AsyncStatusSnapshotV1 = {
+	const snapshot: AsyncStatusSnapshot = {
 		kind: ASYNC_STATUS_SNAPSHOT_KIND,
 		version: ASYNC_STATUS_SNAPSHOT_VERSION,
 		generatedAt: options.generatedAt ?? Date.now(),

package/dist/extensions/pi-subagents/src/runs/shared/capability-ceiling.ts

@@ -2,7 +2,6 @@ import { Buffer } from "node:buffer";
 
 export const SUBAGENT_CAPABILITY_CEILING_VERSION = 1 as const;
 export const SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY = "pi-subagents.capability-ceiling.v1";
-export const SUBAGENT_CAPABILITY_CEILING_ENV = "SELESAI_SUBAGENT_CAPABILITY_CEILING_V1";
 
 export type SubagentCapabilityCeiling =
 	| { allowedTools: readonly string[]; allowedAgents?: readonly string[]; denyExtensions?: boolean }
@@ -167,7 +166,7 @@ export function resolveSubagentCapabilityCeiling(sessionId: string | undefined,
 }
 
 export function resolveCurrentSubagentCapabilityCeiling(sessionId: string | undefined): ResolvedSubagentCapabilityCeiling | undefined {
-	return resolveSubagentCapabilityCeiling(sessionId, decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]));
+	return resolveSubagentCapabilityCeiling(sessionId, undefined);
 }
 
 export function isAgentAllowedByCapabilityCeiling(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): boolean {

package/dist/extensions/pi-subagents/src/runs/shared/child-hooks.ts

@@ -0,0 +1,174 @@
+import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
+import { listBackgroundWorkProviders } from "../../api/background-work.ts";
+import { ReadonlyDrainObservation } from "./readonly-drain-observation.ts";
+import registerFanoutChildSubagentExtension from "../../extension/fanout-child.ts";
+import registerSubagentFastModeExtension from "./fast-mode-extension.ts";
+import registerSubagentPromptRuntime from "./subagent-prompt-runtime.ts";
+import type { ChildRuntimeConfig } from "./child-runtime-config.ts";
+import type { ChildToolDiagnostic } from "./tool-availability.ts";
+import type { ChildSessionLaunch } from "./child-session.ts";
+import type { ChildTranscriptWriter } from "../../shared/child-transcript.ts";
+import { projectRuntimeAcknowledgedExtensions } from "./runtime-acknowledged-extensions.ts";
+
+/** Inline extension shape accepted by pi's resource loader (`extensionFactories`). */
+export interface ChildHookExtension {
+	name: string;
+	factory: (pi: ExtensionAPI) => void;
+}
+
+type OwnedCapture = Required<Pick<ChildRuntimeConfig, "toolDiagnostic" | "runtimeAcknowledgements">>;
+type PromptProof = { config: ChildRuntimeConfig; snapshot: string; factories?: ChildHookExtension["factory"][]; observeNext?: ReadonlyDrainObservation; observation?: ReadonlyDrainObservation; capture?: OwnedCapture; reporting?: { launch: ChildSessionLaunch; callback: ChildSessionLaunch["onExtensionError"] } };
+const promptProofs = new WeakMap<ChildHookExtension["factory"], PromptProof>();
+
+function ownedProof(hooks: ChildHookExtension[]): PromptProof | undefined {
+	const proof = hooks[0] && promptProofs.get(hooks[0].factory);
+	return proof?.factories?.length === hooks.length && proof.factories.every((factory, index) => hooks[index]?.factory === factory) ? proof : undefined;
+}
+
+/** The host's mandatory transcript reporting, owned by the existing hook certificate. */
+export function withChildSessionErrorReporting(session: Omit<ChildSessionLaunch, "onExtensionError">, transcriptWriter: ChildTranscriptWriter | undefined): ChildSessionLaunch {
+	const launch: ChildSessionLaunch = { ...session, onExtensionError: (error) => {
+		transcriptWriter?.writeStderrLine(`Extension error (${error.extensionPath}, ${error.event}): ${error.error instanceof Error ? error.error.message : String(error.error)}`);
+	} };
+	const proof = ownedProof(launch.hooks);
+	if (proof?.capture && proof.config === launch.runtime) proof.reporting = { launch, callback: launch.onExtensionError };
+	return launch;
+}
+
+export function isReadonlyChildSessionReporting(launch: ChildSessionLaunch): boolean {
+	const proof = ownedProof(launch.hooks);
+	const descriptor = Object.getOwnPropertyDescriptor(launch, "onExtensionError");
+	if (descriptor && (!descriptor.enumerable || !("value" in descriptor))) return false;
+	return proof?.reporting ? proof.reporting.launch === launch && proof.reporting.callback === descriptor?.value : !descriptor && !("onExtensionError" in launch);
+}
+
+/** Admit only own enumerable data: inspecting descriptors must not invoke getters. */
+function dataKeys(value: unknown): string[] | undefined {
+	if (!value || typeof value !== "object" || Object.getPrototypeOf(value) !== Object.prototype) return undefined;
+	const keys = Reflect.ownKeys(value);
+	for (const key of keys) {
+		const descriptor = Object.getOwnPropertyDescriptor(value, key)!;
+		if (typeof key !== "string" || !descriptor.enumerable || !("value" in descriptor)) return undefined;
+	}
+	return keys as string[];
+}
+
+/** Only reviewed data and the capture callbacks constructed below; no caller callback opt-in. */
+function readonlyConfig(config: ChildRuntimeConfig, capture?: OwnedCapture): string | undefined {
+	const strings = ["runId", "agent", "sessionName", "forkCacheKey", "parentSessionId", "orchestratorSessionId"];
+	const numbers = ["childIndex", "depth", "maxDepth"];
+	const booleans = ["inheritProjectContext", "inheritGlobalContext", "inheritSkills"];
+	const keys = dataKeys(config);
+	if (!keys) return undefined;
+	if (capture && (config.toolDiagnostic !== capture.toolDiagnostic || config.runtimeAcknowledgements !== capture.runtimeAcknowledgements)) return undefined;
+	const waitKeys = dataKeys(config.waitTool);
+	if (!waitKeys || waitKeys.some((key) => key !== "enabled")) return undefined;
+	if (config.fast !== false || config.fanoutChild !== false || config.waitTool.enabled !== false) return undefined;
+	for (const key of keys) {
+		const value = Object.getOwnPropertyDescriptor(config, key)!.value;
+		if (["fast", "fanoutChild", "waitTool"].includes(key)) continue;
+		if (capture && (key === "toolDiagnostic" || key === "runtimeAcknowledgements")) continue;
+		if (capture && key === "requiredTools" && Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype) {
+			const descriptors = Object.getOwnPropertyDescriptors(value);
+			if (Reflect.ownKeys(descriptors).length !== value.length + 1) return undefined;
+			for (let i = 0; i < value.length; i++) {
+				const descriptor = descriptors[String(i)];
+				if (!descriptor?.enumerable || !("value" in descriptor) || !["read", "ls"].includes(descriptor.value)) return undefined;
+			}
+			continue;
+		}
+		if (strings.includes(key) && (value === undefined || typeof value === "string")) continue;
+		if (numbers.includes(key) && (value === undefined || (typeof value === "number" && Number.isInteger(value) && value >= 0))) continue;
+		if (booleans.includes(key) && (value === undefined || typeof value === "boolean")) continue;
+		return undefined;
+	}
+	return JSON.stringify(config);
+}
+
+function noBackgroundProviders(): boolean {
+	try {
+		return listBackgroundWorkProviders().length === 0;
+	} catch { return false; }
+}
+
+/** Internal proof of the captured closure/config, not its caller-controlled display name. */
+export function isReadonlyChildHookProfile(hooks: ChildHookExtension[], config: ChildRuntimeConfig): boolean {
+	const proof = ownedProof(hooks);
+	if (!proof) return false;
+	const valid = proof.config === config && readonlyConfig(config, proof.capture) === proof.snapshot && noBackgroundProviders();
+	if (!valid) proof.observation?.deny();
+	return valid && (proof.observation?.check() ?? true);
+}
+
+/** Arm just the next installation; ordinary installations retain the original API/handlers. */
+export function observeReadonlyChildHookDrain(hooks: ChildHookExtension[], enabled: boolean, sessionFile: string): void {
+	const proof = ownedProof(hooks);
+	if (!proof) return;
+	if (enabled) {
+		proof.observation?.deny();
+		proof.observation = undefined;
+	}
+	proof.observeNext = enabled ? new ReadonlyDrainObservation(sessionFile, () => readonlyConfig(proof.config, proof.capture) === proof.snapshot && noBackgroundProviders()) : undefined;
+}
+
+export function captureReadonlyChildDrain(hooks: ChildHookExtension[]): (() => boolean) {
+	const proof = ownedProof(hooks);
+	const observation = proof?.observation;
+	return () => !!observation && proof?.observation === observation && observation.settled();
+}
+
+/**
+ * The child-side hooks pi-subagents installs in every child, keyed off the
+ * launch config. The registrations live in `subagent-prompt-runtime.ts`,
+ * `fast-mode-extension.ts`, and `fanout-child.ts`.
+ */
+export function createChildHooks(config: ChildRuntimeConfig): ChildHookExtension[] {
+	return childHooks(config);
+}
+
+/** Launch-owned bookkeeping, paired with the same private hook certificate (no callback registration API). */
+export function createCapturedChildHooks(config: ChildRuntimeConfig, runner = false) {
+	let diagnostic: ChildToolDiagnostic | undefined;
+	let acknowledgedIds: string[] | undefined;
+	let completionIntentContext: Pick<ExtensionContext, "model" | "modelRegistry"> | undefined;
+	const capture: OwnedCapture = {
+		toolDiagnostic: (value) => { diagnostic = value; },
+		runtimeAcknowledgements: (ids) => { acknowledgedIds = ids; },
+	};
+	Object.assign(config, capture);
+	const hooks = childHooks(config, capture);
+	if (runner) {
+		hooks.push({ name: "pi-subagents:completion-intent", factory: (pi) => pi.on("session_start", (_event, childCtx) => {
+			// Retain only attempt model services, not the live child session.
+			completionIntentContext = { model: childCtx.model, modelRegistry: childCtx.modelRegistry };
+		}) });
+		const proof = promptProofs.get(hooks[0]!.factory);
+		if (proof) proof.factories = hooks.map((hook) => hook.factory);
+	}
+	return {
+		hooks,
+		completionIntentContext: () => completionIntentContext,
+		toolDiagnostic: () => diagnostic,
+		runtimeAcknowledgedExtensions: () => acknowledgedIds ? projectRuntimeAcknowledgedExtensions(acknowledgedIds) : undefined,
+	};
+}
+
+function childHooks(config: ChildRuntimeConfig, capture?: OwnedCapture): ChildHookExtension[] {
+	const snapshot = readonlyConfig(config, capture);
+	const proof: PromptProof | undefined = snapshot === undefined ? undefined : { config, snapshot, capture };
+	const hooks: ChildHookExtension[] = [
+		{ name: "pi-subagents:prompt-runtime", factory: function promptRuntime(pi) {
+			if (!proof?.observeNext) return registerSubagentPromptRuntime(pi, config);
+			proof.observation = proof.observeNext;
+			proof.observeNext = undefined;
+			registerSubagentPromptRuntime(pi, config, proof.observation);
+		} },
+	];
+	if (proof) {
+		proof.factories = hooks.map((hook) => hook.factory);
+		promptProofs.set(hooks[0]!.factory, proof);
+	}
+	if (config.fast) hooks.push({ name: "pi-subagents:fast-mode", factory: (pi) => registerSubagentFastModeExtension(pi) });
+	if (config.fanoutChild) hooks.push({ name: "pi-subagents:fanout-child", factory: (pi) => registerFanoutChildSubagentExtension(pi, config) });
+	return hooks;
+}

package/dist/extensions/pi-subagents/src/runs/shared/child-identity.ts

@@ -14,11 +14,11 @@ export type AsyncStatusChildResolution =
 	| { ok: false; code: "not_found" | "ambiguous"; message: string };
 
 export function asyncStatusChildIdentity(step: AsyncStatusStep, index: number): string {
-	return step.workflowKey ?? step.runId ?? `step:${index}`;
+	return asyncStatusChildIdentityCandidates(step, index)[0]!;
 }
 
 export function asyncStatusChildIdentityCandidates(step: AsyncStatusStep, index: number): string[] {
-	return [...new Set([step.workflowKey, step.runId, `step:${index}`].filter((value): value is string => typeof value === "string" && value.length > 0))];
+	return [...new Set([step.childId, step.workflowKey, step.runId, `step:${index}`].filter((value): value is string => typeof value === "string" && value.length > 0))];
 }
 
 export function resolveAsyncStatusChild(
@@ -48,4 +48,15 @@ export function resolveAsyncStatusChild(
 
 export function isStoppableAsyncStatusStep(step: AsyncStatusStep): boolean {
 	return step.status === "pending" || step.status === "running";
-}
+}
+
+export function stopStoppableAsyncStatusChildren(
+	status: Pick<AsyncStatus, "steps">,
+	stopChild: ((childId: string, message?: string) => boolean) | undefined,
+	message: string,
+): void {
+	if (!stopChild) return;
+	for (const [index, step] of (status.steps ?? []).entries()) {
+		if (isStoppableAsyncStatusStep(step)) stopChild(asyncStatusChildIdentity(step, index), message);
+	}
+}