@aeondave/pi-persona 1.17.3 → 1.17.4

package/src/extension/broker-host.ts

@@ -2,7 +2,8 @@
  * Supervisor-side broker lifecycle (spec B1-B7): the ONE cross-process host every child-engine
  * leg connects to. Started lazily on the first child-engine build; a failed bind is reported to
  * the user ONCE, children built while it is failed spawn without a bus endpoint (so they never
- * burn the connect backoff against a dead socket), and the next build retries.
+ * burn the connect backoff against a dead socket), and the next build retries. Result readers
+ * use the separate strict awaited preflight on this SAME host, never bus-less degradation.
  */
 
 import { mkdirSync } from "node:fs";
@@ -11,6 +12,7 @@ import { dirname } from "node:path";
 import type { EngineAdapterBroker } from "../engine/adapter.ts";
 import { type BrokerHost, startBrokerHost } from "../bus/broker/host.ts";
 import type { InProcessBus } from "../bus/inproc.ts";
+import { RESULT_READ_TIMEOUT_MS, type PreparedResultReader, type ScopedReader } from "../bus/result-reader.ts";
 
 export interface SupervisorBrokerDeps {
 	bus: InProcessBus;
@@ -49,6 +51,8 @@ export class SupervisorBroker {
 	private readonly expected = new Set<string>();
 	private readonly preHostSteers = new Map<string, string[]>();
 	private readonly deps: SupervisorBrokerDeps;
+	private generation = 0;
+	private readonly preparingReaders = new Set<() => void>();
 
 	constructor(deps: SupervisorBrokerDeps) {
 		this.deps = deps;
@@ -82,6 +86,7 @@ export class SupervisorBroker {
 			}
 		}
 		const start = this.deps.startHost ?? startBrokerHost;
+		const generation = this.generation;
 		this.promise = start({
 			bus: this.deps.bus,
 			supervisorHandle: this.deps.supervisorHandle,
@@ -90,6 +95,7 @@ export class SupervisorBroker {
 		});
 		this.promise.then(
 			(h) => {
+				if (generation !== this.generation) return; // close() owns the late host's teardown
 				this.hostRef = h;
 				this.lastError = undefined;
 				this.warned = false;
@@ -98,6 +104,7 @@ export class SupervisorBroker {
 				this.preHostSteers.clear();
 			},
 			(err) => {
+				if (generation !== this.generation) return;
 				this.promise = undefined; // a later build retries
 				this.lastError = err instanceof Error ? err.message : String(err);
 				const dropped = [...this.preHostSteers.values()].reduce((n, texts) => n + texts.length, 0);
@@ -112,6 +119,46 @@ export class SupervisorBroker {
 		);
 	}
 
+	/** Strict reader preflight, unlike ordinary bus-less degradation. Call ensure(endpoint)
+	 * first, then await this BEFORE adapter registration/spawn. The owner must revoke on
+	 * settlement/spawn failure and close this broker when the owning session changes. */
+	async prepareResultReader(handle: string, reader: ScopedReader, signal?: AbortSignal): Promise<PreparedResultReader> {
+		const generation = this.generation;
+		let revoked = false;
+		const revoke = (): void => {
+			if (revoked) return;
+			revoked = true;
+			try { reader.revoke(); } catch { /* fixed diagnostic, even if cleanup throws */ }
+		};
+		const fail = (): Error => new Error("Result reader preparation failed.");
+		const hostPromise = this.promise;
+		if (!hostPromise || signal?.aborted) { revoke(); throw fail(); }
+		return new Promise<PreparedResultReader>((resolve, reject) => {
+			let settled = false;
+			const cleanup = (): void => {
+				settled = true;
+				clearTimeout(timer);
+				this.preparingReaders.delete(cancel);
+				signal?.removeEventListener("abort", cancel);
+			};
+			const cancel = (): void => {
+				if (settled) return;
+				revoke(); cleanup(); reject(fail());
+			};
+			const timer = setTimeout(cancel, RESULT_READ_TIMEOUT_MS);
+			timer.unref?.();
+			this.preparingReaders.add(cancel);
+			signal?.addEventListener("abort", cancel, { once: true });
+			void hostPromise.then(async (host) => {
+				if (settled) return;
+				const grant = await host.prepareResultReader(handle, { read: (request, s) => reader.read(request, s), revoke }, signal);
+				if (settled || generation !== this.generation || signal?.aborted) { grant.revoke(); cancel(); return; }
+				cleanup();
+				resolve(grant);
+			}).catch(cancel);
+		});
+	}
+
 	/** The adapter-facing deps, or undefined while the last start failed (children spawn bus-less). */
 	adapterDeps(endpoint: string): EngineAdapterBroker | undefined {
 		const failedBefore = this.state() === "failed";
@@ -141,6 +188,7 @@ export class SupervisorBroker {
 				return true;
 			},
 			hasPendingAskFrom: (handle) => this.deps.bus.hasPendingAskFrom(handle),
+			prepareResultReader: (handle, reader, signal) => this.prepareResultReader(handle, reader, signal),
 		};
 	}
 
@@ -164,18 +212,22 @@ export class SupervisorBroker {
 	}
 
 	async close(): Promise<void> {
-		if (this.promise) {
-			try {
-				const h = await this.promise;
-				await h.close();
-			} catch {
-				/* best-effort — never block shutdown on a broker teardown error */
-			}
-		}
+		this.generation++;
+		for (const cancel of this.preparingReaders) cancel();
+		const host = this.hostRef;
+		const pending = this.promise;
 		this.hostRef = undefined;
 		this.promise = undefined;
+		this.lastError = undefined;
 		this.peers.clear();
 		this.expected.clear();
 		this.preHostSteers.clear();
+		try {
+			// Invoke immediately: bound readers revoke before the first await.
+			if (host) await host.close();
+			else if (pending) await (await pending).close();
+		} catch {
+			/* best-effort — never block shutdown on a broker teardown error */
+		}
 	}
 }

package/src/extension/engine.ts

@@ -21,6 +21,7 @@ import { emptyUsage, type ProgressSnapshot } from "../engine/stream.ts";
 import type { AgentRunSpec, StrategyEngine } from "../orchestration/sdk.ts";
 import type { AgentResult } from "../orchestration/types.ts";
 import type { InProcessBus } from "../bus/inproc.ts";
+import type { ResultArchiveView } from "../results/retrieval.ts";
 
 export interface EngineFactories {
 	makeEngine: typeof makeEngine;
@@ -45,6 +46,10 @@ export interface BuildEngineDeps {
 	runLimits: RunLimits;
 	bus: InProcessBus;
 	supervisorHandle: string;
+	/** The live terminal-result archive (a GETTER: the owning session can change across runs).
+	 *  Feeds both engines' reference-handoff preflight + scoped `read_result` readers.
+	 *  Absent ⇒ reference-handoff legs fail closed on both engines (no archive to page). */
+	resultArchive?: () => ResultArchiveView | undefined;
 	/** Breadcrumb for a provider reroute (toast + log); absent ⇒ silent, as before. */
 	onFallback?: (info: { from: string; to: string; agent: string }) => void;
 	/** Injected git runner for the non-worktree files-changed report (tests only); defaults to
@@ -69,7 +74,7 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 		const {
 			agents, contractDefs, controller, host, config, personaConfigs, lastCtx, workerSpineText,
 			engineFactories, makeBrokerDeps, userAgentDir, childPiSettingsEnv, runLimits: RUN_LIMITS,
-			bus, supervisorHandle: SUPERVISOR, onFallback,
+			bus, supervisorHandle: SUPERVISOR, onFallback, resultArchive,
 		} = d();
 			const resolveAgent = (n: string): AgentConfig | undefined => agents.find((a) => a.name === n);
 			// A named contract file (contracts/<name>.contract.json) wins; "default" is the built-in.
@@ -111,7 +116,7 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 			const getBrokerDeps = (): EngineAdapterBroker | undefined => {
 				if (!brokerDepsBuilt) {
 					brokerDepsBuilt = true;
-					const sessionId = (lastCtx as { sessionManager?: { getSessionId?: () => string } } | undefined)?.sessionManager?.getSessionId?.();
+					const sessionId = lastCtx?.sessionManager.getSessionId();
 					if (config.broker && lastCtx && sessionId) brokerDepsMemo = makeBrokerDeps(lastCtx);
 				}
 				return brokerDepsMemo;
@@ -137,6 +142,9 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 				if (onProgress) deps.childOptions.onProgress = onProgress;
 				const brokerDeps = getBrokerDeps();
 				if (brokerDeps) deps.broker = brokerDeps;
+				// Reference-handoff legs page the owning session's terminal archive (strict preflight
+				// + scoped reader); the getter is read at LEG time so a mid-run session switch is seen.
+				if (resultArchive !== undefined) deps.resultArchive = resultArchive;
 				// Peer messaging obeys the persona's bus capability, and blocking asks are honoured
 				// only for async runs — same guards as the inproc engine below (spec B7 / §4.9).
 				const caps = controller.capabilities;
@@ -164,6 +172,7 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 				// can't answer, so blocking there would deadlock; the tool downgrades to one-way).
 				ideps.bus = bus;
 				ideps.supervisorHandle = SUPERVISOR;
+				if (resultArchive !== undefined) ideps.resultArchive = resultArchive;
 				if (controller.activePersona?.coaching) ideps.coaching = true;
 				// Peer messaging obeys the persona's bus capability (canUseBus; Task: sibling peer comm).
 				const caps = controller.capabilities;
@@ -187,6 +196,7 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 				if (onProgress) deps.childOptions.onProgress = onProgress;
 				const brokerDeps = getBrokerDeps();
 				if (brokerDeps) deps.broker = brokerDeps;
+				if (resultArchive !== undefined) deps.resultArchive = resultArchive;
 				// Peer messaging obeys the persona's bus capability, and blocking asks are honoured
 				// only for async runs — same guards as the inproc engine above (spec B7 / §4.9).
 				const caps = controller.capabilities;
@@ -248,9 +258,9 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 						const preflight = await worktreePreflight(root, defaultGitExec);
 						if (!preflight.ok) return isolatedWorktreeFailure(spec, preflight.error);
 						try {
-							return await withWorktree(root, defaultGitExec, async (dir) => {
+							return await withWorktree(root, defaultGitExec, async (dir, baseCommit) => {
 								const result = await childEngineAt(dir).run({ ...spec, isolation: "none" }, perProgress, perSignal, perSteer);
-								const artifact = await captureWorktreeArtifact(dir, defaultGitExec);
+								const artifact = await captureWorktreeArtifact(dir, baseCommit, defaultGitExec);
 								const hasOutputArtifact = hasUnifiedDiff(result.output);
 								if (!result.ok) {
 									return artifact.ok && artifact.diff.trim().length > 0
@@ -314,38 +324,27 @@ export function createBuildEngine(d: () => BuildEngineDeps): BuildEngine {
 // The host's model-level availability snapshot, plus the exact active model. A provider's
 // credentials do not grant every model in its catalog. Extension-native bridges can be
 // absent from an auth snapshot: restore only their explicit registered model lists in that
-// case, never every inherited model under their provider id. Older facades without an
-// availability API retain their historical getAll() fallback.
+// case, never every inherited model under their provider id.
 export function configuredModels(ctx: ExtensionContext): ModelCostMetadata[] {
 	const reg = ctx.modelRegistry;
 	const all = reg.getAll();
-	let available: typeof all;
-	try {
-		available = reg.getAvailable();
-	} catch {
-		return all;
-	}
+	const available = reg.getAvailable();
 	const byRef = new Map(available.map((m) => [`${m.provider}\0${m.id}`, m]));
 	if (ctx.model) byRef.set(`${ctx.model.provider}\0${ctx.model.id}`, ctx.model);
 	const availableProviders = new Set(available.map((m) => m.provider));
 	const declaredRefs = new Set<string>();
-	let registered: readonly string[] = [];
-	try {
-		registered = reg.getRegisteredProviderIds?.() ?? [];
-	} catch {
-		/* a third-party/older registry facade may not expose extension provider ids */
-	}
+	const registered = reg.getRegisteredProviderIds();
 	for (const provider of registered) {
 		// A populated snapshot can intentionally exclude individual models for this credential.
 		if (availableProviders.has(provider)) continue;
 		let native: ReturnType<typeof reg.getRegisteredNativeProvider>;
 		try {
-			native = reg.getRegisteredNativeProvider?.(provider);
+			native = reg.getRegisteredNativeProvider(provider);
 			// An empty credential-filtered list is authoritative too; it need not be a stale snapshot.
-			if (reg.getProvider?.(provider)?.filterModels || native?.filterModels) continue;
+			if (reg.getProvider(provider)?.filterModels || native?.filterModels) continue;
 		} catch { continue; }
 		try {
-			const models = reg.getRegisteredProviderConfig?.(provider)?.models;
+			const models = reg.getRegisteredProviderConfig(provider)?.models;
 			if (Array.isArray(models)) {
 				for (const model of models) {
 					if ((model.type === undefined || model.type === "chat") && typeof model.id === "string") declaredRefs.add(`${provider}\0${model.id}`);