@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/src/shared/journal-reader.ts

@@ -0,0 +1,333 @@
+import * as fs from "node:fs";
+import * as parserModule from "stream-json/core/parser.js";
+import type { Token } from "stream-json/core/parser.js";
+
+type JsonObject = Record<string, any>;
+export type Projection = (path: readonly (string | number)[], root?: JsonObject) => boolean | number;
+type KeyLimit = (parentPath: readonly (string | number)[], root?: JsonObject) => number;
+export interface ProjectionLimits { depth: number; nodes: number; arrayLength: number; keyLength: number }
+export interface JournalRecord { value: JsonObject; start: number; end: number }
+export type JournalPolicy = "strict" | "live" | "inspect";
+
+// The public synchronous tokenizer is exported by 3.7.0 but omitted from its declarations.
+const jsonParser = (parserModule as unknown as {
+	jsonParser(options: object): (chunk: string | symbol) => { values: Token[] } | symbol;
+}).jsonParser;
+const endInput = Symbol.for("object-stream.none");
+
+/** Validate everything, assembling only selected fields. Discarded strings are never packed. */
+export class JsonProjection {
+	private parse = jsonParser({ packValues: false });
+	private stack: Array<{ path: (string | number)[]; value?: any; key: string; index: number }> = [];
+	private scalar?: { path: (string | number)[]; text: string; limit: number; number: boolean };
+	private key = false;
+	private keyLimit = 4096;
+	private keys: KeyLimit;
+	private limits?: ProjectionLimits;
+	private nodes = 0;
+	value?: JsonObject;
+	private select: Projection;
+	private stringChunk?: (path: readonly (string | number)[], text: string, root?: JsonObject) => void;
+	constructor(select: Projection, stringChunk?: (path: readonly (string | number)[], text: string, root?: JsonObject) => void,
+		keys: KeyLimit = () => 4096, limits?: ProjectionLimits) { this.select = select; this.stringChunk = stringChunk; this.keys = keys; this.limits = limits; }
+
+	private selected(path: (string | number)[]): boolean | number {
+		const keep = this.stack.length && this.stack.at(-1)!.value === undefined ? false : this.select(path, this.value);
+		if (keep && this.limits && ++this.nodes > this.limits.nodes) throw new RangeError("JSON projection exceeds its assembled-node budget.");
+		return keep;
+	}
+	private nextPath(): (string | number)[] {
+		const parent = this.stack.at(-1);
+		if (this.limits && (this.stack.length > this.limits.depth || parent && parent.index >= this.limits.arrayLength)) throw new RangeError("JSON projection exceeds its depth or array-position budget.");
+		return parent ? [...parent.path, Array.isArray(parent.value) || parent.index >= 0 ? parent.index++ : parent.key] : [];
+	}
+	private put(path: (string | number)[], value: any): void {
+		const parent = this.stack.at(-1);
+		if (!parent) this.value = value;
+		else if (parent.value !== undefined) Object.defineProperty(parent.value, path.at(-1)!, { value, enumerable: true, writable: true, configurable: true });
+	}
+	write(chunk: string | symbol): void {
+		const output = this.parse(chunk);
+		if (typeof output === "symbol") return;
+		for (const token of output.values) {
+			switch (token.name) {
+				case "startKey": {
+					const parent = this.stack.at(-1)!;
+					this.key = true; parent.key = "";
+					this.keyLimit = parent.value === undefined ? 0 : this.keys(parent.path, this.value);
+					break;
+				}
+				case "endKey": this.key = false; break;
+				case "startObject": case "startArray": {
+					const path = this.nextPath(), keep = this.selected(path);
+					const value = keep ? token.name === "startArray" ? [] : {} : undefined;
+					if (keep) this.put(path, value);
+					this.stack.push({ path, value, key: "", index: token.name === "startArray" ? 0 : -1 });
+					break;
+				}
+				case "endObject": case "endArray": this.stack.pop(); break;
+				case "startString": case "startNumber": {
+					const path = this.nextPath(), keep = this.selected(path);
+					this.scalar = { path, text: "", limit: keep === true ? Infinity : Number(keep) || 0, number: token.name === "startNumber" };
+					break;
+				}
+				case "stringChunk": case "numberChunk":
+					if (this.key) {
+						const parent = this.stack.at(-1)!;
+						if (parent.value !== undefined && this.limits && parent.key.length + token.value.length > this.limits.keyLength) throw new RangeError("JSON projection exceeds its property-key budget.");
+						if (parent.key.length < this.keyLimit) parent.key += token.value.slice(0, this.keyLimit - parent.key.length);
+					} else if (this.scalar) {
+						if (token.name === "stringChunk") this.stringChunk?.(this.scalar.path, token.value, this.value);
+						if (this.scalar.text.length < this.scalar.limit) this.scalar.text += token.value.slice(0, this.scalar.limit - this.scalar.text.length);
+					}
+					break;
+				case "endString": case "endNumber": {
+					const scalar = this.scalar!;
+					if (scalar.limit) this.put(scalar.path, scalar.number ? Number(scalar.text) : scalar.text);
+					this.scalar = undefined;
+					break;
+				}
+				case "trueValue": case "falseValue": case "nullValue": {
+					const path = this.nextPath();
+					if (this.selected(path)) this.put(path, token.value);
+					break;
+				}
+			}
+		}
+	}
+	finish(): JsonObject | undefined { this.write(endInput); return this.value; }
+}
+
+/** Byte-framed JSONL. Publication framing is independent of malformed-record tolerance. */
+export class JournalFrames {
+	private projection: JsonProjection;
+	private decoder = new TextDecoder("utf8", { fatal: true });
+	private error?: unknown;
+	private nonblank = false;
+	private start: number;
+	offset: number;
+	private select: Projection;
+	private record: (record: JournalRecord) => void;
+	private policy: JournalPolicy;
+	private malformed?: (start: number, end: number, error: unknown) => void;
+	private stringChunk?: ConstructorParameters<typeof JsonProjection>[1];
+	private keys?: KeyLimit;
+	private requireNewline: boolean;
+	private limits?: ProjectionLimits;
+	constructor(select: Projection, record: (record: JournalRecord) => void,
+		policy: JournalPolicy = "strict", offset = 0,
+		malformed?: (start: number, end: number, error: unknown) => void,
+		stringChunk?: ConstructorParameters<typeof JsonProjection>[1], keys?: KeyLimit, requireNewline = policy === "live", limits?: ProjectionLimits) {
+		this.select = select; this.record = record; this.policy = policy; this.malformed = malformed;
+		this.stringChunk = stringChunk; this.keys = keys;
+		this.requireNewline = requireNewline; this.limits = limits;
+		this.start = this.offset = offset;
+		this.projection = new JsonProjection(select, stringChunk, keys, limits);
+	}
+	private part(bytes: Buffer): void {
+		if (!this.nonblank && bytes.some((byte) => ![9, 10, 13, 32].includes(byte))) this.nonblank = true;
+		if (!this.error) try { this.projection.write(this.decoder.decode(bytes, { stream: true })); } catch (error) { this.error = error; }
+	}
+	private commit(end: number): void {
+		let record: JournalRecord | undefined, malformed: unknown;
+		const start = this.start;
+		if (this.nonblank) {
+			let value: JsonObject | undefined;
+			if (!this.error) try {
+				this.projection.write(this.decoder.decode());
+				value = this.projection.finish();
+				if (!value || typeof value !== "object" || Array.isArray(value)) throw new SyntaxError("JSONL records must be objects");
+			} catch (error) { this.error = error; }
+			if (this.error) {
+				if (this.policy !== "inspect") throw new SyntaxError(`Invalid JSONL record at byte ${this.start}: ${String(this.error)}`, { cause: this.error });
+				malformed = this.error;
+			} else record = { value: value!, start, end };
+		}
+		this.start = end;
+		this.projection = new JsonProjection(this.select, this.stringChunk, this.keys, this.limits);
+		this.decoder = new TextDecoder("utf8", { fatal: true });
+		this.error = undefined;
+		this.nonblank = false;
+		if (malformed) this.malformed?.(start, end, malformed);
+		else if (record) this.record(record);
+	}
+	write(bytes: Buffer): void {
+		const offset = this.offset;
+		this.offset += bytes.length;
+		let from = 0;
+		for (let newline = bytes.indexOf(10); newline >= 0; newline = bytes.indexOf(10, from)) {
+			this.part(bytes.subarray(from, newline));
+			this.commit(offset + newline + 1);
+			from = newline + 1;
+		}
+		this.part(bytes.subarray(from));
+	}
+	finish(): number {
+		if (this.requireNewline) {
+			if (this.policy === "strict" && this.nonblank) throw new SyntaxError(`Unpublished JSONL record at byte ${this.start}: newline required`);
+		} else if (this.offset > this.start) this.commit(this.offset);
+		return this.start;
+	}
+}
+
+export function scanJournal(file: string | number, select: Projection, record: (record: JournalRecord) => void,
+	options: { policy?: JournalPolicy; requireNewline?: boolean; start?: number; end?: number; malformed?: (start: number, end: number, error: unknown) => void; stringChunk?: ConstructorParameters<typeof JsonProjection>[1]; keys?: KeyLimit } = {}): number {
+	const fd = typeof file === "number" ? file : fs.openSync(file, "r");
+	try {
+		const end = Math.min(options.end ?? Infinity, fs.fstatSync(fd).size);
+		const frames = new JournalFrames(select, record, options.policy, options.start ?? 0, options.malformed, options.stringChunk, options.keys, options.requireNewline);
+		const buffer = Buffer.allocUnsafe(64 * 1024);
+		for (let offset = options.start ?? 0; offset < end;) {
+			const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, end - offset), offset);
+			if (!count) throw new Error("Journal truncated while reading");
+			frames.write(buffer.subarray(0, count)); offset += count;
+		}
+		return frames.finish();
+	} finally { if (typeof file !== "number") fs.closeSync(fd); }
+}
+
+export function readJsonProjection(file: string, select: Projection): any {
+	// ponytail: selected frozen schemas and acceptance values fit their consumer's
+	// heap, including arbitrary property names; discarded owner messages do not.
+	const fd = fs.openSync(file, "r"), decoder = new TextDecoder("utf8", { fatal: true }), projection = new JsonProjection(select, undefined, () => Infinity);
+	try {
+		const end = fs.fstatSync(fd).size, bytes = Buffer.allocUnsafe(64 * 1024);
+		for (let offset = 0; offset < end;) {
+			const count = fs.readSync(fd, bytes, 0, Math.min(bytes.length, end - offset), offset);
+			if (!count) throw new Error("JSON file truncated while reading");
+			projection.write(decoder.decode(bytes.subarray(0, count), { stream: true })); offset += count;
+		}
+		projection.write(decoder.decode());
+		const value = projection.finish();
+		if (!value || typeof value !== "object" || Array.isArray(value)) throw new SyntaxError("Owner records must be objects");
+		return value;
+	} catch (error) { throw new SyntaxError(`Invalid JSON file ${file}: ${String(error)}`, { cause: error }); }
+	finally { fs.closeSync(fd); }
+}
+
+/** Compact owner reads never hydrate transcript arrays or historical output strings. */
+export const ownerProjection: Projection = (path) => {
+	const resultField = path.length === 2 && path[0] === "result"
+		|| path.length === 3 && path[0] === "results" && typeof path[1] === "number"
+		|| path.length === 4 && path[0] === "children" && typeof path[1] === "number" && path[2] === "result";
+	if (resultField && path.at(-1) === "messages") return false;
+	const preview = resultField && ["output", "finalOutput", "initialOutput", "rawOutput"].includes(String(path.at(-1)))
+		|| path.length === 1 && path[0] === "summary"
+		|| path.length === 3 && path[0] === "children" && typeof path[1] === "number" && path[2] === "summary";
+	return preview ? 8192 : true;
+};
+
+const entryFields = new Set(["type", "id", "parentId", "timestamp", "version", "cwd", "parentSession", "checkpoint", "provider", "model", "modelId", "thinkingLevel", "customType", "usage", "firstKeptEntryId", "fromId"]);
+const messageFields = new Set(["role", "provider", "model", "responseModel", "thinkingLevel", "usage", "stopReason", "errorMessage", "timestamp", "toolCallId", "toolName", "isError", "content", "command", "output", "exitCode", "cancelled"]);
+/** Metadata/previews, never unrelated custom data, image bytes or raw tool details. */
+export const nativeProjection: Projection = (path, root) => {
+	if (!path.length) return true;
+	if (path[0] === "message") {
+		if (path.length === 1) return true;
+		if (!messageFields.has(String(path[1]))) return false;
+		if (path[1] === "content") {
+			if (path.length <= 3) return 2048;
+			if (path[3] === "arguments") {
+				if (path.length === 4) return true;
+				if (path.length === 5) return Object.keys(root?.message?.content?.[Number(path[2])]?.arguments ?? {}).length < 32 ? 2048 : false;
+				return path.length === 6 && path[5] === 0 ? 2048 : false;
+			}
+			return ["type", "id", "name", "text", "thinking", "mimeType", "arguments"].includes(String(path[3])) ? 2048 : false;
+		}
+		return path[1] === "usage" ? true : 4096;
+	}
+	if (path[0] === "summary" || path[0] === "content") return 2048;
+	if (path[0] === "details") return path.length === 1 || ["bodyText", "message", "from"].includes(String(path[1])) ? 2048 : false;
+	return entryFields.has(String(path[0])) ? 4096 : false;
+};
+
+export interface NativeRecord extends JournalRecord { value: JsonObject & { id: string; type: string } }
+export class NativeJournal {
+	readonly records: NativeRecord[] = [];
+	readonly byId = new Map<string, NativeRecord>();
+	readonly stamp: string;
+	readonly end: number;
+	readonly file: string;
+	constructor(file: string, policy: JournalPolicy = "inspect", requireNewline = policy === "live") {
+		this.file = file;
+		const fd = fs.openSync(file, "r");
+		try {
+			const stat = fs.fstatSync(fd, { bigint: true });
+			this.stamp = journalStamp(stat); this.end = Number(stat.size);
+			let parent: string | null = null;
+			scanJournal(fd, nativeProjection, (record) => {
+				const entry = record.value;
+				if (entry.type !== "session") {
+					// Read-only legacy v1 presentation uses stable offset IDs, without rewriting the source.
+					entry.id ??= `legacy-${record.start}`;
+					if (this.records[0]?.value.version === 1) entry.parentId = parent;
+					parent = entry.id;
+				}
+				this.records.push(record as NativeRecord); this.byId.set(entry.id, record as NativeRecord);
+			}, { policy, requireNewline, end: this.end });
+			if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== this.stamp) throw new Error("Journal changed while indexing; refresh history.");
+		} finally { fs.closeSync(fd); }
+		if (this.records[0]?.value.type !== "session") throw new Error("Not a readable native Pi session.");
+	}
+	branch(leaf?: string | null, endedAt?: number): NativeRecord[] {
+		if (leaf === null) return [];
+		const eligible = endedAt === undefined ? this.records : this.records.filter((record) => record.value.type === "session" || Date.parse(record.value.timestamp) <= endedAt);
+		let current = leaf ? this.byId.get(leaf) : eligible.findLast((record) => record.value.type !== "session");
+		const path: NativeRecord[] = [], seen = new Set<string>(), allowed = new Set(eligible.map((record) => record.value.id));
+		while (current && current.value.type !== "session" && allowed.has(current.value.id)) {
+			if (seen.has(current.value.id)) throw new Error("Cyclic journal ancestry");
+			seen.add(current.value.id); path.push(current);
+			current = this.byId.get(current.value.parentId);
+		}
+		return path.reverse();
+	}
+	body(record: NativeRecord): any {
+		const fd = fs.openSync(this.file, "r");
+		try {
+			if (journalStamp(fs.fstatSync(fd, { bigint: true })) !== this.stamp) throw new Error("Journal changed; refresh before reading history.");
+			// ponytail: explicitly requested individual bodies must fit the consumer's heap;
+			// metadata and previews stay bounded. Use pages for large output.
+			const bytes = Buffer.alloc(record.end - record.start);
+			if (fs.readSync(fd, bytes, 0, bytes.length, record.start) !== bytes.length) throw new Error("Journal truncated");
+			const body = JSON.parse(bytes.toString("utf8"));
+			if (body.type !== "session") { body.id ??= record.value.id; body.parentId ??= record.value.parentId; }
+			return body;
+		} finally { fs.closeSync(fd); }
+	}
+	configuration(endedAt?: number, leaf?: string | null): { model?: string; thinking?: string; modelRecordedAt?: number } {
+		const result: ReturnType<NativeJournal["configuration"]> = {};
+		let model: NativeRecord["value"] | undefined;
+		for (const { value } of this.branch(leaf, endedAt)) {
+			if (value.type === "thinking_level_change") result.thinking = value.thinkingLevel;
+			if (value.type === "model_change" || value.type === "message" && value.message?.role === "assistant") model = value;
+		}
+		if (model) {
+			result.model = model.type === "model_change" ? `${model.provider}/${model.modelId}` : `${model.message.provider}/${model.message.model}`;
+			result.modelRecordedAt = Date.parse(model.timestamp);
+		}
+		return result;
+	}
+}
+
+export function journalStamp(stat: fs.BigIntStats): string { return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`; }
+
+/** Read a UTF-8 page or tail without reading its preceding output. */
+export function readOutputPage(file: string, options: { offset?: number; length?: number } = {}): { text: string; offset: number; nextOffset?: number; size: number } {
+	const fd = fs.openSync(file, "r");
+	try {
+		const size = fs.fstatSync(fd).size, length = options.length ?? 64 * 1024;
+		if (!Number.isSafeInteger(length) || length < 1 || length > 1024 * 1024 || options.offset !== undefined && (!Number.isSafeInteger(options.offset) || options.offset < 0)) throw new Error("Invalid output page");
+		const offset = Math.min(size, options.offset ?? Math.max(0, size - length));
+		const bytes = Buffer.alloc(Math.min(length, size - offset));
+		const count = fs.readSync(fd, bytes, 0, bytes.length, offset);
+		let start = 0, end = count;
+		while (start < end && (bytes[start]! & 0xc0) === 0x80) start++;
+		if (offset + end < size) {
+			let last = end - 1;
+			while (last >= start && (bytes[last]! & 0xc0) === 0x80) last--;
+			const lead = bytes[last]!, width = lead < 0x80 ? 1 : lead < 0xe0 ? 2 : lead < 0xf0 ? 3 : 4;
+			if (last + width > end) end = last;
+		}
+		return { text: bytes.subarray(start, end).toString("utf8"), offset: offset + start, size, ...(offset + end < size ? { nextOffset: offset + end } : {}) };
+	} finally { fs.closeSync(fd); }
+}

package/src/shared/lazy-tools.ts

@@ -0,0 +1,36 @@
+import { getCurrentSystemMessage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext, SessionManager } from "@earendil-works/pi-coding-agent";
+
+const declarations = new WeakMap<ExtensionContext["sessionManager"], {
+	leaf: string | null; count: number | undefined; current: ReturnType<typeof getCurrentSystemMessage>;
+}>();
+
+/** Only our unnamespaced tools are owned here; foreign public IDs pass through untouched. */
+export function activateTools(pi: ExtensionAPI, names: readonly string[]): void {
+	const available = pi.getAllTools();
+	const active = pi.getActiveTools();
+	const added = names.filter((name) => !active.includes(name) && available.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace)));
+	if (added.length) pi.setActiveTools([...active, ...new Set(added)]);
+}
+
+/** Official 1.0 SDK creation omits initial resume restoration; tree/reload are native. */
+export function restoreLazyTools(pi: ExtensionAPI, ctx: ExtensionContext, loader: string, names: readonly string[]): void {
+	const available = pi.getAllTools();
+	// A tool-only allowlist must remain usable without its discovery entry.
+	if (!available.some((tool) => tool.name === loader && !("namespace" in tool && tool.namespace))) {
+		activateTools(pi, names);
+		return;
+	}
+	const manager = ctx.sessionManager, leaf = manager.getLeafId(), count = (manager as Partial<SessionManager>).getEntryCount?.();
+	let cached = declarations.get(manager);
+	if (count === undefined || !cached || cached.leaf !== leaf || cached.count !== count) {
+		cached = { leaf, count, current: getCurrentSystemMessage(manager.buildSessionProjection().messages) };
+		declarations.set(manager, cached);
+	}
+	const declared = cached.current;
+	if (!declared) return;
+	const selected = declared?.toolsAdded ?? [];
+	const restored = names.filter((name) => selected.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace))
+		&& available.some((tool) => tool.name === name && !("namespace" in tool && tool.namespace)));
+	activateTools(pi, restored);
+}

package/src/shared/model-info.ts

@@ -0,0 +1,81 @@
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type ThinkingLevel = typeof THINKING_LEVELS[number];
+export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
+
+export interface ModelInfo {
+	provider: string;
+	id: string;
+	fullId: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: ThinkingLevelMap;
+}
+
+interface RegistryModelLike {
+	provider: string;
+	id: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: ThinkingLevelMap;
+}
+
+export function toModelInfo(model: RegistryModelLike): ModelInfo {
+	return {
+		provider: model.provider,
+		id: model.id,
+		fullId: `${model.provider}/${model.id}`,
+		reasoning: model.reasoning,
+		thinkingLevelMap: model.thinkingLevelMap,
+	};
+}
+
+export function providerQualifiedModelId(provider: string | undefined, model: string | undefined): string | undefined {
+	if (!model) return undefined;
+	return provider && !model.startsWith(`${provider}/`) ? `${provider}/${model}` : model;
+}
+
+/** Resolve the effective thinking level from a model string (which may contain a known suffix like `:high`)
+ * and an explicit thinking config value. Returns `undefined` when no thinking is applicable
+ * (e.g. no model was specified, or the model has no suffix and no config was provided). */
+export function resolveEffectiveThinking(model: string | undefined, configThinking: string | undefined): string | undefined {
+	if (!model) return undefined;
+	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
+	if (thinkingSuffix) return thinkingSuffix.slice(1);
+	return THINKING_LEVELS.find((level) => level === configThinking);
+}
+
+export function splitKnownThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
+	const colonIdx = model.lastIndexOf(":");
+	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
+	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
+	if (!suffix) return { baseModel: model, thinkingSuffix: "" };
+	return {
+		baseModel: model.substring(0, colonIdx),
+		thinkingSuffix: `:${suffix}`,
+	};
+}
+
+export function findModelInfo(model: string | undefined, availableModels: ModelInfo[] | undefined, preferredProvider?: string): ModelInfo | undefined {
+	if (!model || !availableModels || availableModels.length === 0) return undefined;
+	const { baseModel } = splitKnownThinkingSuffix(model);
+	const exact = availableModels.find((entry) => entry.fullId === baseModel);
+	if (exact) return exact;
+
+	const matches = availableModels.filter((entry) => entry.id === baseModel);
+	if (preferredProvider) {
+		const preferred = matches.find((entry) => entry.provider === preferredProvider);
+		if (preferred) return preferred;
+	}
+	return matches.length === 1 ? matches[0] : undefined;
+}
+
+export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
+	if (!model) return [...THINKING_LEVELS];
+	if (model.reasoning === false) return ["off"];
+
+	const levels = THINKING_LEVELS.filter((level) => {
+		const mapped = model.thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh" || level === "max") return mapped !== undefined;
+		return true;
+	});
+	return levels;
+}

package/src/shared/native-session.ts

@@ -0,0 +1,8 @@
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { requirePiPackageRoot } from "../runs/shared/pi-spawn.ts";
+
+// Detached Node runners do not get Pi's extension-loader package aliases.
+const root = requirePiPackageRoot();
+const sessionModule: Pick<typeof import("@earendil-works/pi-coding-agent"), "buildSessionContext" | "parseSessionEntries" | "migrateSessionEntries" | "SessionManager"> = await import(pathToFileURL(path.join(root, "dist/index.js")).href);
+export const { buildSessionContext, parseSessionEntries, migrateSessionEntries, SessionManager } = sessionModule;

package/src/shared/native-tui.ts

@@ -0,0 +1,10 @@
+import { findPackageJSON } from "node:module";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { requirePiPackageRoot } from "../runs/shared/pi-spawn.ts";
+
+// Detached Node workers use the selected host's TUI, without extension-loader aliases.
+const manifest = findPackageJSON("@earendil-works/pi-tui", pathToFileURL(path.join(requirePiPackageRoot(), "dist/index.js")));
+if (!manifest) throw new Error("Could not locate the selected Pi TUI package.");
+const tui: Pick<typeof import("@earendil-works/pi-tui"), "stripTerminalSequences"> = await import(new URL("./dist/utils.js", pathToFileURL(manifest)).href);
+export const { stripTerminalSequences } = tui;

package/src/shared/native-typebox.ts

@@ -0,0 +1,14 @@
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { requirePiPackageRoot } from "../runs/shared/pi-spawn.ts";
+
+// Detached Node runners do not get Pi's extension-loader package aliases.
+const require = createRequire(path.join(requirePiPackageRoot(), "dist/index.js"));
+const typebox: typeof import("typebox") = await import(pathToFileURL(require.resolve("typebox")).href);
+const compile: typeof import("typebox/compile") = await import(pathToFileURL(require.resolve("typebox/compile")).href);
+const value: typeof import("typebox/value") = await import(pathToFileURL(require.resolve("typebox/value")).href);
+
+export const { Type } = typebox;
+export const { Compile } = compile;
+export const { Check, Errors } = value;