pi-legion 2.0.4 → 3.0.0

package/src/supervisor/routing-supervisor.ts

@@ -0,0 +1,179 @@
+/**
+ * Thin LegionSupervisor facade that routes by AgentConfig.spawnMode (#197).
+ *
+ * rpc → RpcSupervisor (unchanged internals)
+ * inprocess → InProcessSupervisor
+ *
+ * Same name must not be registered on both backends.
+ */
+
+import {
+	ErrorCodes,
+	SubagentError,
+	type InProcessLimits,
+} from "../shared/types.ts";
+import { InProcessSupervisor } from "./inprocess-supervisor.ts";
+import { RpcSupervisor } from "./rpc-supervisor.ts";
+import { resolveSpawnMode } from "./spawn-mode.ts";
+import type { UIProxy } from "./ui-proxy.ts";
+import type {
+	ChildHandle,
+	EventSubscriptionOptions,
+	LegionSupervisor,
+	SettleResult,
+	SpawnInput,
+	SupervisorEventListener,
+	UsageSnapshot,
+} from "./types.ts";
+
+export type SupervisorBackend = "rpc" | "inprocess";
+
+export interface RoutingSupervisorOptions {
+	rpc?: RpcSupervisor;
+	inprocess?: InProcessSupervisor;
+	/** Shared UI proxy preferred; otherwise each backend keeps its own. */
+	uiProxy?: UIProxy;
+	getInprocessLimits?: () => InProcessLimits | undefined;
+	onSpawnRefused?: (message: string) => void;
+}
+
+/**
+ * Routes LegionSupervisor calls to RpcSupervisor or InProcessSupervisor
+ * based on the resolved spawnMode of the target agent / registered child.
+ */
+export class RoutingSupervisor implements LegionSupervisor {
+	readonly rpc: RpcSupervisor;
+	readonly inprocess: InProcessSupervisor;
+	private readonly owners = new Map<string, SupervisorBackend>();
+	readonly uiProxy: UIProxy;
+
+	constructor(options: RoutingSupervisorOptions = {}) {
+		const onSpawnRefused = options.onSpawnRefused;
+		this.rpc =
+			options.rpc ??
+			new RpcSupervisor({
+				...(options.uiProxy ? { uiProxy: options.uiProxy } : {}),
+				...(onSpawnRefused ? { onSpawnRefused } : {}),
+			});
+		this.inprocess =
+			options.inprocess ??
+			new InProcessSupervisor({
+				...(options.uiProxy ? { uiProxy: options.uiProxy } : {}),
+				...(options.getInprocessLimits
+					? { getLimits: options.getInprocessLimits }
+					: {}),
+				...(onSpawnRefused ? { onSpawnRefused } : {}),
+			});
+		this.uiProxy = options.uiProxy ?? this.rpc.uiProxy;
+	}
+
+	async spawnChild(input: SpawnInput): Promise<ChildHandle> {
+		const mode = resolveSpawnMode(input.agent);
+		if (mode === "inprocess") {
+			if (input.agent.kind !== "pi") {
+				throw new SubagentError(
+					`spawnMode "inprocess" requires kind "pi" (received '${input.agent.kind}')`,
+					ErrorCodes.INVALID_PARAMS,
+				);
+			}
+			if (input.agent.worktree === true) {
+				throw new SubagentError(
+					`spawnMode "inprocess" cannot combine with worktree: true for '${input.name}'`,
+					ErrorCodes.INVALID_PARAMS,
+				);
+			}
+		}
+		const existing = this.owners.get(input.name);
+		if (existing && existing !== mode) {
+			const alive =
+				existing === "rpc"
+					? this.rpc.isAlive(input.name)
+					: this.inprocess.isAlive(input.name);
+			if (alive) {
+				throw new SubagentError(
+					`child '${input.name}' is already registered on ${existing}; cannot spawn as ${mode}`,
+					ErrorCodes.NAME_TAKEN,
+				);
+			}
+		}
+		const backend = mode === "inprocess" ? this.inprocess : this.rpc;
+		const handle = await backend.spawnChild(input);
+		this.owners.set(input.name, mode);
+		return handle;
+	}
+
+	async prompt(name: string, text: string): Promise<void> {
+		await this.backendFor(name).prompt(name, text);
+	}
+
+	async steer(name: string, text: string): Promise<void> {
+		await this.backendFor(name).steer(name, text);
+	}
+
+	async followUp(name: string, text: string): Promise<void> {
+		await this.backendFor(name).followUp(name, text);
+	}
+
+	async abort(name: string): Promise<void> {
+		await this.backendFor(name).abort(name);
+	}
+
+	waitSettled(
+		name: string,
+		timeoutMs?: number,
+		signal?: AbortSignal,
+	): Promise<SettleResult> {
+		return this.backendFor(name).waitSettled(name, timeoutMs, signal);
+	}
+
+	isAlive(name: string): boolean {
+		const owner = this.owners.get(name);
+		if (owner === "inprocess") return this.inprocess.isAlive(name);
+		if (owner === "rpc") return this.rpc.isAlive(name);
+		return this.rpc.isAlive(name) || this.inprocess.isAlive(name);
+	}
+
+	async stats(name: string): Promise<UsageSnapshot | null> {
+		return this.backendFor(name).stats(name);
+	}
+
+	retire(name: string, opts?: { graceful?: boolean }): Promise<void> {
+		return this.backendFor(name).retire(name, opts);
+	}
+
+	onEvent(
+		name: string,
+		listener: SupervisorEventListener,
+		options: EventSubscriptionOptions = {},
+	): () => void {
+		const owner = this.owners.get(name);
+		if (owner === "inprocess") {
+			return this.inprocess.onEvent(name, listener, options);
+		}
+		if (owner === "rpc") {
+			return this.rpc.onEvent(name, listener, options);
+		}
+		// Pre-spawn: subscribe on both so whichever backend wins still delivers.
+		const offRpc = this.rpc.onEvent(name, listener, options);
+		const offIn = this.inprocess.onEvent(name, listener, options);
+		return () => {
+			offRpc();
+			offIn();
+		};
+	}
+
+	private backendFor(name: string): LegionSupervisor {
+		const owner = this.owners.get(name);
+		if (owner === "inprocess") return this.inprocess;
+		if (owner === "rpc") return this.rpc;
+		if (this.inprocess.isAlive(name)) {
+			this.owners.set(name, "inprocess");
+			return this.inprocess;
+		}
+		if (this.rpc.isAlive(name)) {
+			this.owners.set(name, "rpc");
+			return this.rpc;
+		}
+		throw new SubagentError(`unknown child: ${name}`, ErrorCodes.NOT_FOUND);
+	}
+}

package/src/supervisor/rpc-supervisor.ts

@@ -17,6 +17,8 @@ import { enrichFailureWithAutoDoctor } from "../extension/auto-doctor.ts";
 import { ErrorCodes, SubagentError } from "../shared/types.ts";
 import {
 	InMemoryUIProxy,
+	extensionActivityToUIRequest,
+	isExtensionActivity,
 	isExtensionUIRequest,
 	type ExtensionUIResponse,
 	type UIProxy,
@@ -295,6 +297,9 @@ export class RpcSupervisor implements LegionSupervisor {
 				cliPath: _cliPath,
 				tempDir: _tempDir,
 				stripLegionIdentity: _stripLegionIdentity,
+				// In-process identity never travels over the RPC channel; drop it so an
+				// accidental spread cannot leak a lineage object into argv building.
+				childLaunchContext: _childLaunchContext,
 				...buildInput
 			} = input;
 			const built = buildPiArgs({
@@ -634,6 +639,15 @@ export class RpcSupervisor implements LegionSupervisor {
 			return;
 		}
 
+		// Child-side setActivity / setProgramRecord → parent OSC busy fan-in (no PTY OSC parse).
+		if (isExtensionActivity(event)) {
+			this.uiProxy.enqueue({
+				childName: child.name,
+				request: extensionActivityToUIRequest(event),
+			});
+			return;
+		}
+
 		this.updateTurnState(child, record);
 
 		this.publishEvent(child, record);

package/src/supervisor/spawn-mode.ts

@@ -0,0 +1,35 @@
+/**
+ * Spawn-mode resolution helpers for #197 (rpc | inprocess).
+ */
+
+import type { AgentConfig, SpawnMode } from "../shared/types.ts";
+import { SPAWN_MODES } from "../shared/types.ts";
+
+/**
+ * Default backend when `spawnMode` is omitted.
+ *
+ * `inprocess` is only the *intent* here: `Orchestrator.launch` arbitrates an
+ * omitted mode down to `rpc` when the launch actually needs worktree
+ * isolation or the role is not `kind: pi` (see the arbitration comment in
+ * `src/runs/orchestrator.ts`). This resolver stays a pure config read and
+ * must never inspect `worktree`.
+ */
+export const DEFAULT_SPAWN_MODE: SpawnMode = "inprocess";
+
+/** Safe default for `inprocess.maxActive` when the inprocess block is set without it. */
+export const DEFAULT_INPROCESS_MAX_ACTIVE = 8;
+
+export function resolveSpawnMode(
+	agent: Pick<AgentConfig, "spawnMode"> | undefined,
+): SpawnMode {
+	const mode = agent?.spawnMode;
+	if (mode === undefined) return DEFAULT_SPAWN_MODE;
+	if ((SPAWN_MODES as readonly string[]).includes(mode)) return mode;
+	return DEFAULT_SPAWN_MODE;
+}
+
+export function isInProcessSpawn(
+	agent: Pick<AgentConfig, "spawnMode"> | undefined,
+): boolean {
+	return resolveSpawnMode(agent) === "inprocess";
+}

package/src/supervisor/types.ts

@@ -5,6 +5,7 @@
 import type { RpcClientOptions as PiRpcClientOptions } from "@earendil-works/pi-coding-agent";
 import type { Writable } from "node:stream";
 import type { BuildArgsInput } from "../runs/args.ts";
+import type { ChildLaunchContext } from "./child-context.ts";
 import type { UIProxy } from "./ui-proxy.ts";
 
 /**
@@ -17,6 +18,18 @@ export interface SpawnInput extends Omit<BuildArgsInput, "cwd" | "includeTask">
 	cwd: string;
 	/** Environment overlay passed to RpcClient. */
 	env?: Record<string, string>;
+	/**
+	 * In-process lineage identity (spawn-default-inprocess-v3 D5).
+	 *
+	 * Deliberately NOT named `childContext`: that inherited `BuildArgsInput`
+	 * field is the *string* settings-injected prompt context, and an interface
+	 * cannot narrow an inherited member to an object type (TS2430). The two
+	 * channels are unrelated — one is prompt text, this one is identity.
+	 *
+	 * Only the inprocess backend consumes it; RPC keeps using env lineage.
+	 * Absent → InProcessSupervisor derives a minimal fallback context.
+	 */
+	childLaunchContext?: ChildLaunchContext;
 	/** Whether to remove Legion lineage identity from the inherited environment. */
 	stripLegionIdentity?: boolean;
 	/** Optional Pi CLI entry point override. */

package/src/supervisor/ui-proxy.ts

@@ -68,6 +68,25 @@ export type ExtensionUIRequest =
 			id: string;
 			method: "set_editor_text";
 			text: string;
+	  }
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "setActivity";
+			source: string;
+			activity?: { message?: string };
+	  }
+	| {
+			type: "extension_ui_request";
+			id: string;
+			method: "setProgramRecord";
+			record: {
+				state: "idle" | "working" | "blocked" | "done" | "error" | "clear";
+				id: string;
+				app?: string;
+				kind?: "permission" | "question" | "auth";
+				message?: string;
+			};
 	  };
 
 /** Response payload; UIProxy adds the RPC envelope and request id. */
@@ -143,6 +162,14 @@ export function isExtensionUIRequest(value: unknown): value is ExtensionUIReques
 			return typeof record.title === "string";
 		case "set_editor_text":
 			return typeof record.text === "string";
+		case "setActivity":
+			return typeof record.source === "string";
+		case "setProgramRecord": {
+			const rec = record.record;
+			if (!rec || typeof rec !== "object" || Array.isArray(rec)) return false;
+			const body = rec as Record<string, unknown>;
+			return typeof body.id === "string" && typeof body.state === "string";
+		}
 		default:
 			return false;
 	}
@@ -224,3 +251,54 @@ export class InMemoryUIProxy implements UIProxy {
 		return () => this.listeners.delete(listener);
 	}
 }
+
+/** Top-level RPC event from Pi child `ui.setActivity` / `ui.setProgramRecord` (OSC busy fan-in). */
+export type ExtensionActivityEvent =
+	| {
+			type: "extension_activity";
+			id: string;
+			source: string;
+			activity: { message?: string } | null;
+			record?: undefined;
+	  }
+	| {
+			type: "extension_activity";
+			id: string;
+			record: {
+				state: "idle" | "working" | "blocked" | "done" | "error" | "clear";
+				id: string;
+				app?: string;
+				kind?: "permission" | "question" | "auth";
+				message?: string;
+			};
+	  };
+
+export function isExtensionActivity(value: unknown): value is ExtensionActivityEvent {
+	if (!value || typeof value !== "object") return false;
+	const record = value as Record<string, unknown>;
+	if (record.type !== "extension_activity" || typeof record.id !== "string") return false;
+	if (record.record && typeof record.record === "object" && !Array.isArray(record.record)) {
+		const body = record.record as Record<string, unknown>;
+		return typeof body.id === "string" && typeof body.state === "string";
+	}
+	return typeof record.source === "string";
+}
+
+/** Map a child extension_activity event into the UIProxy request shape. */
+export function extensionActivityToUIRequest(event: ExtensionActivityEvent): ExtensionUIRequest {
+	if ("record" in event && event.record) {
+		return {
+			type: "extension_ui_request",
+			id: event.id,
+			method: "setProgramRecord",
+			record: event.record,
+		};
+	}
+	return {
+		type: "extension_ui_request",
+		id: event.id,
+		method: "setActivity",
+		source: event.source,
+		...(event.activity ? { activity: event.activity } : {}),
+	};
+}