pi-subagents 0.65.0 → 0.66.0

package/src/runs/background/runner-aliases.ts

@@ -7,11 +7,12 @@
  * this extension and are not installed next to it. pi's own extension loader
  * aliases those specifiers to the copies shipped inside the installed pi
  * package; the parent computes the same map and hands it to the runner
- * through `JITI_ALIAS`, so the runner's child sessions and hooks share one
- * copy of every host package.
+ * through `JITI_ALIAS`, so child sessions and hooks retain host API identity.
+ * Only Pi 0.85.0's missing server exports may come from this extension.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { fileURLToPath } from "node:url";
 
 export const JITI_ALIAS_ENV = "JITI_ALIAS";
 
@@ -19,6 +20,9 @@ export const JITI_ALIAS_ENV = "JITI_ALIAS";
 export const HOST_PEER_ALIASES: ReadonlyArray<{ specifier: string; pkg: string; subpath: string }> = [
 	{ specifier: "@earendil-works/pi-coding-agent", pkg: "@earendil-works/pi-coding-agent", subpath: "." },
 	{ specifier: "@earendil-works/pi-agent-core", pkg: "@earendil-works/pi-agent-core", subpath: "." },
+	{ specifier: "@earendil-works/pi-agent-core/node", pkg: "@earendil-works/pi-agent-core", subpath: "./node" },
+	{ specifier: "@earendil-works/chord", pkg: "@earendil-works/chord", subpath: "." },
+	{ specifier: "@earendil-works/chord/context", pkg: "@earendil-works/chord", subpath: "./context" },
 	{ specifier: "@earendil-works/pi-tui", pkg: "@earendil-works/pi-tui", subpath: "." },
 	{ specifier: "@earendil-works/pi-ai", pkg: "@earendil-works/pi-ai", subpath: "./compat" },
 	{ specifier: "@earendil-works/pi-ai/compat", pkg: "@earendil-works/pi-ai", subpath: "./compat" },
@@ -29,8 +33,16 @@ export const HOST_PEER_ALIASES: ReadonlyArray<{ specifier: string; pkg: string;
 	{ specifier: "typebox/value", pkg: "typebox", subpath: "./value" },
 ];
 
+/** Experimental dependencies accidentally published in exactly Pi 0.85.0. */
+const PI0850_PEER_ALIASES = [
+	{ specifier: "@earendil-works/pi-server", pkg: "@earendil-works/pi-server", subpath: "." },
+	{ specifier: "@earendil-works/pi-server/unix", pkg: "@earendil-works/pi-server", subpath: "./unix" },
+	{ specifier: "@earendil-works/pi-client/unix", pkg: "@earendil-works/pi-client", subpath: "./unix" },
+];
+
 interface PackageManifest {
 	name?: unknown;
+	version?: unknown;
 	main?: unknown;
 	exports?: unknown;
 }
@@ -95,7 +107,11 @@ export function resolvePackageSubpath(packageDir: string, subpath: string): stri
 
 /** Find `pkg` as the pi package itself, one of its dependencies, or a sibling in a hoisted install. */
 export function findHostPeerPackageDir(piPackageRoot: string, pkg: string): string | undefined {
-	if (readManifest(piPackageRoot)?.name === pkg) return piPackageRoot;
+	return findPeerPackageDir(piPackageRoot, pkg, readManifest(piPackageRoot)?.name);
+}
+
+function findPeerPackageDir(piPackageRoot: string, pkg: string, hostName: unknown): string | undefined {
+	if (hostName === pkg) return piPackageRoot;
 	const candidates = [path.join(piPackageRoot, "node_modules", pkg)];
 	let dir = piPackageRoot;
 	for (;;) {
@@ -112,14 +128,36 @@ export function findHostPeerPackageDir(piPackageRoot: string, pkg: string): stri
 }
 
 /** The alias map the runner needs, or the specifiers that could not be resolved. */
-export function resolveHostPeerAliases(piPackageRoot: string): { aliases: Record<string, string>; missing: string[] } {
+export function resolveHostPeerAliases(
+	piPackageRoot: string,
+	extensionRoot = fileURLToPath(new URL("../../../", import.meta.url)),
+): { aliases: Record<string, string>; missing: string[]; supplemental: string[] } {
 	const aliases: Record<string, string> = {};
 	const missing: string[] = [];
-	for (const { specifier, pkg, subpath } of HOST_PEER_ALIASES) {
-		const packageDir = findHostPeerPackageDir(piPackageRoot, pkg);
-		const target = packageDir ? resolvePackageSubpath(packageDir, subpath) : undefined;
+	const supplemental: string[] = [];
+	const hostManifest = readManifest(piPackageRoot);
+	const isPi0850 = hostManifest?.version === "0.85.0";
+	const required = isPi0850 ? [...HOST_PEER_ALIASES, ...PI0850_PEER_ALIASES] : HOST_PEER_ALIASES;
+	for (const { specifier, pkg, subpath } of required) {
+		const packageDir = findPeerPackageDir(piPackageRoot, pkg, hostManifest?.name);
+		let target = packageDir ? resolvePackageSubpath(packageDir, subpath) : undefined;
+		// Pi 0.85.0 omitted this runtime dependency. Never replace working host
+		// exports or extend this exact version contract to other peers/hosts.
+		if ((!target || !fs.existsSync(target))
+			&& (specifier === "@earendil-works/pi-server" || specifier === "@earendil-works/pi-server/unix")
+			&& isPi0850
+			&& (!packageDir || readManifest(packageDir)?.version === "0.85.0")) {
+			const localDir = findHostPeerPackageDir(extensionRoot, pkg);
+			if (localDir && readManifest(localDir)?.version === "0.85.0") {
+				const localTarget = resolvePackageSubpath(localDir, subpath);
+				if (localTarget && fs.existsSync(localTarget)) {
+					target = localTarget;
+					supplemental.push(specifier);
+				}
+			}
+		}
 		if (target && fs.existsSync(target)) aliases[specifier] = target;
 		else missing.push(specifier);
 	}
-	return { aliases, missing };
+	return { aliases, missing, supplemental };
 }

package/src/runs/background/runner-child-launch.ts

@@ -0,0 +1,86 @@
+/** Native runner construction, separate from its executable entrypoint and attempt loop. */
+import * as path from "node:path";
+import { buildInProcessChildLaunch, type BuildInProcessChildLaunchInput, type InheritedChildRuntime } from "../shared/child-launch.ts";
+import { deriveForkPromptCacheKey } from "../shared/child-tool-plan.ts";
+import { normalizeExtensionBindings } from "../shared/extension-bindings.ts";
+import type { RunnerSubagentStep } from "../shared/parallel-utils.ts";
+import { formatAcceptancePrompt } from "../shared/acceptance.ts";
+import { isAgentContract } from "../shared/agent-contract.ts";
+
+export interface RunnerChildLaunchContext {
+	cwd: string;
+	id: string;
+	flatIndex: number;
+	artifactsDir?: string;
+	childIntercomTarget?: string;
+	orchestratorIntercomTarget?: string;
+	nestedRoute?: BuildInProcessChildLaunchInput["nestedRoute"];
+	runFanoutBudget?: BuildInProcessChildLaunchInput["runFanoutBudget"];
+	capabilityCeiling?: BuildInProcessChildLaunchInput["capabilityCeiling"];
+	inheritedChildRuntime?: InheritedChildRuntime;
+}
+
+export function buildRunnerChildLaunch(step: RunnerSubagentStep, ctx: RunnerChildLaunchContext, attempt: {
+	model?: string;
+	sessionEnabled: boolean;
+	sessionDir?: string;
+	sessionName?: string;
+	structuredOutput?: BuildInProcessChildLaunchInput["structuredOutput"];
+	childWatchdog?: BuildInProcessChildLaunchInput["childWatchdog"];
+	watchdogStatus: NonNullable<BuildInProcessChildLaunchInput["watchdogStatus"]>;
+}) {
+	// Resource-backed system instructions survive SDK split-turn compaction verbatim.
+	const acceptancePrompt = step.effectiveAcceptance
+		? formatAcceptancePrompt(step.effectiveAcceptance, { reportOptional: isAgentContract(step.agentContract), structuredOutput: Boolean(step.structuredOutput?.acceptanceReportPath) })
+		: "";
+	return buildInProcessChildLaunch({
+		parentSessionId: step.parentSessionId,
+		forkCacheKey: step.context === "fork" ? deriveForkPromptCacheKey(step.parentSessionId) : undefined,
+		sessionEnabled: attempt.sessionEnabled,
+		sessionDir: attempt.sessionDir,
+		sessionFile: step.sessionFile,
+		model: attempt.model,
+		inheritProjectContext: step.inheritProjectContext,
+		inheritGlobalContext: step.inheritGlobalContext,
+		inheritSkills: step.inheritSkills,
+		requireReadTool: Boolean(step.skills?.length),
+		tools: step.tools,
+		excludeTools: step.excludeTools,
+		allowNestedSubagents: step.allowNestedSubagents,
+		extensions: step.extensions,
+		subagentOnlyExtensions: step.subagentOnlyExtensions,
+		fast: step.fast,
+		modelCandidates: step.modelCandidates,
+		systemPrompt: acceptancePrompt ? `${step.systemPrompt ?? ""}\n${acceptancePrompt}` : step.systemPrompt ?? "",
+		systemPromptMode: step.systemPromptMode,
+		mcpDirectTools: step.mcpDirectTools,
+		extensionBindings: normalizeExtensionBindings(step.extensionBindings)?.value,
+		capabilityCeiling: step.capabilityCeiling ?? ctx.capabilityCeiling,
+		cwd: step.cwd ?? ctx.cwd,
+		intercomSessionName: ctx.childIntercomTarget,
+		sessionName: attempt.sessionName,
+		orchestratorIntercomTarget: ctx.orchestratorIntercomTarget,
+		runId: ctx.id,
+		childAgentName: step.agent,
+		childIndex: ctx.flatIndex,
+		nestedRoute: ctx.nestedRoute,
+		runFanoutBudget: ctx.runFanoutBudget ? {
+			...ctx.runFanoutBudget,
+			...(step.runFanoutPath ? { parentPath: `${ctx.runFanoutBudget.parentPath ? `${ctx.runFanoutBudget.parentPath}/` : ""}${step.runFanoutPath}` } : {}),
+		} : undefined,
+		structuredOutput: attempt.structuredOutput,
+		toolBudget: step.toolBudget,
+		permissionRules: step.permissionRules,
+		permissionAuditPath: step.permissionRules && ctx.artifactsDir
+			? path.join(ctx.artifactsDir, "permission-audit", `${ctx.id}-${ctx.flatIndex}.jsonl`) : undefined,
+		childWatchdog: attempt.childWatchdog,
+		// registerChildWatchdog returns before reading the sink when unconfigured.
+		...(attempt.childWatchdog ? { watchdogStatus: attempt.watchdogStatus } : {}),
+		waitToolEnabled: step.waitToolEnabled,
+		waitToolDefaultTimeoutMs: step.waitToolDefaultTimeoutMs,
+		thinkingCeiling: step.thinkingCeiling,
+		maxSubagentDepth: step.maxSubagentDepth,
+		inherited: ctx.inheritedChildRuntime,
+		host: "runner",
+	});
+}

package/src/runs/background/stale-run-reconciler.ts

@@ -9,6 +9,7 @@ import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, type NestedRoute } from "../shared/nested-events.ts";
 import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.ts";
+import type { RawDrainStatusObserver } from "../shared/readonly-drain-observation.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
 
@@ -352,9 +353,10 @@ export function checkPidLiveness(pid: number, kill: KillFn = process.kill): PidL
 	}
 }
 
-export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOptions = {}): ReconcileAsyncRunResult {
+export function reconcileAsyncRun(asyncDir: string, options: ReconcileAsyncRunOptions = {}, observeStatus?: RawDrainStatusObserver): ReconcileAsyncRunResult {
 	const now = options.now?.() ?? Date.now();
 	const status = readStatus(asyncDir);
+	observeStatus?.(status);
 	const startedStatus = !status && options.startedRun ? buildStartedStatus(asyncDir, options.startedRun, now) : undefined;
 	const effectiveStatus = status ?? startedStatus;
 	if (!effectiveStatus) return { status: null, repaired: false };