From 7ece19b0e866c40d0f19ba6ed2d1884e01faf2c3 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 12:16:55 +0200
Subject: [PATCH 01/36] chore: package structure

---
 package.json                              |  2 +-
 packages/orchestrator/CHANGELOG.md        |  3 ++
 packages/orchestrator/README.md           |  9 +++++
 packages/orchestrator/package.json        | 46 +++++++++++++++++++++++
 packages/orchestrator/src/cli.ts          | 30 +++++++++++++++
 packages/orchestrator/src/index.ts        |  0
 packages/orchestrator/tsconfig.build.json |  9 +++++
 tsconfig.json                             |  2 +
 8 files changed, 100 insertions(+), 1 deletion(-)
 create mode 100644 packages/orchestrator/CHANGELOG.md
 create mode 100644 packages/orchestrator/README.md
 create mode 100644 packages/orchestrator/package.json
 create mode 100644 packages/orchestrator/src/cli.ts
 create mode 100644 packages/orchestrator/src/index.ts
 create mode 100644 packages/orchestrator/tsconfig.build.json

diff --git a/package.json b/package.json
index c88d7123..537fb1de 100644
--- a/package.json
+++ b/package.json
@@ -12,7 +12,7 @@
 	],
 	"scripts": {
 		"clean": "npm run clean --workspaces",
-		"build": "cd packages/tui && npm run build && cd ../ai && npm run build && cd ../agent && npm run build && cd ../coding-agent && npm run build",
+		"build": "cd packages/tui && npm run build && cd ../ai && npm run build && cd ../agent && npm run build && cd ../coding-agent && npm run build && cd ../orchestrator && npm run build",
 		"check": "biome check --write --error-on-warnings . && npm run check:pinned-deps && npm run check:ts-imports && npm run check:shrinkwrap && tsgo --noEmit && npm run check:browser-smoke",
 		"check:browser-smoke": "node scripts/check-browser-smoke.mjs",
 		"check:pinned-deps": "node scripts/check-pinned-deps.mjs",
diff --git a/packages/orchestrator/CHANGELOG.md b/packages/orchestrator/CHANGELOG.md
new file mode 100644
index 00000000..1a588142
--- /dev/null
+++ b/packages/orchestrator/CHANGELOG.md
@@ -0,0 +1,3 @@
+# Changelog
+
+## [Unreleased]
diff --git a/packages/orchestrator/README.md b/packages/orchestrator/README.md
new file mode 100644
index 00000000..ee05c9eb
--- /dev/null
+++ b/packages/orchestrator/README.md
@@ -0,0 +1,9 @@
+# orchestrator
+
+Orchestrator package for pi.
+
+## CLI
+
+```bash
+orchestrator --help
+```
diff --git a/packages/orchestrator/package.json b/packages/orchestrator/package.json
new file mode 100644
index 00000000..a614b8da
--- /dev/null
+++ b/packages/orchestrator/package.json
@@ -0,0 +1,46 @@
+{
+	"name": "@earendil-works/pi-orchestrator",
+	"version": "0.79.6",
+	"description": "orchestrator package for pi",
+	"type": "module",
+	"bin": {
+		"orchestrator": "dist/cli.js"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"CHANGELOG.md"
+	],
+	"scripts": {
+		"clean": "shx rm -rf dist",
+		"dev": "tsgo -p tsconfig.build.json --watch --preserveWatchOutput",
+		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js",
+		"prepublishOnly": "npm run clean && npm run build"
+	},
+	"keywords": [
+		"pi",
+		"orchestrator"
+	],
+	"author": "Earendil Works",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/badlogic/pi-mono.git",
+		"directory": "packages/orchestrator"
+	},
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"dependencies": {},
+	"devDependencies": {
+		"shx": "0.4.0"
+	}
+}
diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
new file mode 100644
index 00000000..0ad2da39
--- /dev/null
+++ b/packages/orchestrator/src/cli.ts
@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")) as {
+	version: string;
+};
+
+function printHelp(): void {
+	console.log(`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator --help\n  orchestrator --version`);
+}
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+	printHelp();
+	process.exit(0);
+}
+
+if (args[0] === "--version" || args[0] === "-v") {
+	console.log(packageJson.version);
+	process.exit(0);
+}
+
+console.error(`Unknown command: ${args[0]}`);
+printHelp();
+process.exit(1);
diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
new file mode 100644
index 00000000..e69de29b
diff --git a/packages/orchestrator/tsconfig.build.json b/packages/orchestrator/tsconfig.build.json
new file mode 100644
index 00000000..695dd9ad
--- /dev/null
+++ b/packages/orchestrator/tsconfig.build.json
@@ -0,0 +1,9 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src"
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["node_modules", "dist", "**/*.d.ts", "src/**/*.d.ts"]
+}
diff --git a/tsconfig.json b/tsconfig.json
index 903f80f3..1e212e9d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -13,6 +13,8 @@
 			"@earendil-works/pi-coding-agent": ["./packages/coding-agent/src/index.ts"],
 			"@earendil-works/pi-coding-agent/hooks": ["./packages/coding-agent/src/core/hooks/index.ts"],
 			"@earendil-works/pi-coding-agent/*": ["./packages/coding-agent/src/*"],
+			"@earendil-works/pi-orchestrator": ["./packages/orchestrator/src/index.ts"],
+			"@earendil-works/pi-orchestrator/*": ["./packages/orchestrator/src/*"],
 			"typebox": ["./node_modules/typebox"],
 			"@earendil-works/pi-tui": ["./packages/tui/src/index.ts"],
 			"@earendil-works/pi-tui/*": ["./packages/tui/src/*"],

From d799c722000739de661e44940342115e8ec84979 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 12:56:33 +0200
Subject: [PATCH 02/36] feat: ipc socket

---
 packages/orchestrator/src/config.ts       | 27 +++++++++
 packages/orchestrator/src/index.ts        |  3 +
 packages/orchestrator/src/ipc/client.ts   | 63 +++++++++++++++++++
 packages/orchestrator/src/ipc/protocol.ts | 73 +++++++++++++++++++++++
 4 files changed, 166 insertions(+)
 create mode 100644 packages/orchestrator/src/config.ts
 create mode 100644 packages/orchestrator/src/ipc/client.ts
 create mode 100644 packages/orchestrator/src/ipc/protocol.ts

diff --git a/packages/orchestrator/src/config.ts b/packages/orchestrator/src/config.ts
new file mode 100644
index 00000000..64fb1008
--- /dev/null
+++ b/packages/orchestrator/src/config.ts
@@ -0,0 +1,27 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR_NAME = ".pi";
+const ENV_ORCHESTRATOR_DIR = "PI_ORCHESTRATOR_DIR";
+
+export function getOrchestratorDir(): string {
+	const envDir = process.env[ENV_ORCHESTRATOR_DIR];
+	if (envDir) {
+		return envDir;
+	}
+
+	const piDir = process.env.PI_CONFIG_DIR || join(homedir(), CONFIG_DIR_NAME);
+	return join(piDir, "orchestrator");
+}
+
+export function getMachinePath(): string {
+	return join(getOrchestratorDir(), "machine.json");
+}
+
+export function getInstancesPath(): string {
+	return join(getOrchestratorDir(), "instances.json");
+}
+
+export function getSocketPath(): string {
+	return join(getOrchestratorDir(), "orchestrator.sock");
+}
diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index e69de29b..67ecbe7a 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -0,0 +1,3 @@
+export * from "./config.ts";
+export * from "./ipc/client.ts";
+export * from "./ipc/protocol.ts";
diff --git a/packages/orchestrator/src/ipc/client.ts b/packages/orchestrator/src/ipc/client.ts
new file mode 100644
index 00000000..8029654a
--- /dev/null
+++ b/packages/orchestrator/src/ipc/client.ts
@@ -0,0 +1,63 @@
+import { createConnection } from "node:net";
+import { getSocketPath } from "../config.ts";
+import { encodeMessage, type OrchestratorRequest, type OrchestratorResponse, parseResponseLine } from "./protocol.ts";
+
+export async function sendIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
+	const socketPath = getSocketPath();
+
+	return new Promise<OrchestratorResponse>((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		let buffer = "";
+		let settled = false;
+
+		const cleanup = () => {
+			socket.removeAllListeners();
+			socket.end();
+		};
+
+		socket.on("connect", () => {
+			socket.write(encodeMessage(request));
+		});
+
+		socket.on("data", (chunk: Buffer | string) => {
+			buffer += chunk.toString();
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				return;
+			}
+
+			const line = buffer.slice(0, newlineIndex).trim();
+			if (!line) {
+				return;
+			}
+
+			try {
+				settled = true;
+				resolve(parseResponseLine(line));
+				cleanup();
+			} catch (error) {
+				settled = true;
+				reject(error);
+				cleanup();
+			}
+		});
+
+		socket.on("error", (error) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			reject(error);
+			cleanup();
+		});
+
+		socket.on("end", () => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			reject(new Error(`Orchestrator socket closed before a response was received: ${socketPath}`));
+			cleanup();
+		});
+	});
+}
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
new file mode 100644
index 00000000..7c275279
--- /dev/null
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -0,0 +1,73 @@
+export interface SpawnRequest {
+	type: "spawn";
+	cwd: string;
+	label?: string;
+	provider?: string;
+	model?: string;
+}
+
+export interface ListRequest {
+	type: "list";
+}
+
+export interface StopRequest {
+	type: "stop";
+	instanceId: string;
+}
+
+export interface StatusRequest {
+	type: "status";
+	instanceId: string;
+}
+
+export type OrchestratorRequest = SpawnRequest | ListRequest | StopRequest | StatusRequest;
+
+export interface InstanceSummary {
+	id: string;
+	status: "starting" | "online" | "stopping" | "stopped" | "error";
+	cwd: string;
+	label?: string;
+	sessionId?: string;
+}
+
+export interface ResponseBase {
+	type: string;
+	ok: boolean;
+	error?: string;
+}
+
+export interface SpawnResponse extends ResponseBase {
+	type: "spawn_result";
+	instance?: InstanceSummary;
+}
+
+export interface ListResponse extends ResponseBase {
+	type: "list_result";
+	instances?: InstanceSummary[];
+}
+
+export interface StopResponse extends ResponseBase {
+	type: "stop_result";
+	instanceId?: string;
+}
+
+export interface StatusResponse extends ResponseBase {
+	type: "status_result";
+	instance?: InstanceSummary;
+}
+
+export type OrchestratorResponse = SpawnResponse | ListResponse | StopResponse | StatusResponse;
+
+export function encodeMessage(message: OrchestratorRequest | OrchestratorResponse): string {
+	return `${JSON.stringify(message)}\n`;
+}
+
+export function parseRequestLine(line: string): OrchestratorRequest {
+	const value = JSON.parse(line) as OrchestratorRequest;
+	return value;
+}
+
+export function parseResponseLine(line: string): OrchestratorResponse {
+	const value = JSON.parse(line) as OrchestratorResponse;
+	return value;
+}

From 60fb6dc6a6324d00df2a4a1b42856910705af315 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 12:59:15 +0200
Subject: [PATCH 03/36] chore: add auth path getter too

---
 packages/orchestrator/src/config.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/packages/orchestrator/src/config.ts b/packages/orchestrator/src/config.ts
index 64fb1008..fab11bed 100644
--- a/packages/orchestrator/src/config.ts
+++ b/packages/orchestrator/src/config.ts
@@ -14,6 +14,10 @@ export function getOrchestratorDir(): string {
 	return join(piDir, "orchestrator");
 }
 
+export function getAuthPath(): string {
+	return join(getOrchestratorDir(), "auth.json");
+}
+
 export function getMachinePath(): string {
 	return join(getOrchestratorDir(), "machine.json");
 }

From 92e28e9c513f31fbfce29479b1f4a151dd69561e Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:06:34 +0200
Subject: [PATCH 04/36] feat: ipc server

---
 packages/orchestrator/src/index.ts        |   1 +
 packages/orchestrator/src/ipc/protocol.ts |  31 ++++++-
 packages/orchestrator/src/ipc/server.ts   | 107 ++++++++++++++++++++++
 3 files changed, 136 insertions(+), 3 deletions(-)
 create mode 100644 packages/orchestrator/src/ipc/server.ts

diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index 67ecbe7a..196332d8 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -1,3 +1,4 @@
 export * from "./config.ts";
 export * from "./ipc/client.ts";
 export * from "./ipc/protocol.ts";
+export * from "./ipc/server.ts";
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 7c275279..ebb2815f 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -20,7 +20,14 @@ export interface StatusRequest {
 	instanceId: string;
 }
 
-export type OrchestratorRequest = SpawnRequest | ListRequest | StopRequest | StatusRequest;
+export interface RequestMap {
+	spawn: SpawnRequest;
+	list: ListRequest;
+	stop: StopRequest;
+	status: StatusRequest;
+}
+
+export type OrchestratorRequest = RequestMap[keyof RequestMap];
 
 export interface InstanceSummary {
 	id: string;
@@ -31,7 +38,6 @@ export interface InstanceSummary {
 }
 
 export interface ResponseBase {
-	type: string;
 	ok: boolean;
 	error?: string;
 }
@@ -56,7 +62,26 @@ export interface StatusResponse extends ResponseBase {
 	instance?: InstanceSummary;
 }
 
-export type OrchestratorResponse = SpawnResponse | ListResponse | StopResponse | StatusResponse;
+export interface ErrorResponse extends ResponseBase {
+	type: "error";
+	ok: false;
+	error: string;
+}
+
+export interface ResponseMap {
+	spawn: SpawnResponse;
+	list: ListResponse;
+	stop: StopResponse;
+	status: StatusResponse;
+}
+
+export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
+
+export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer K }
+	? K extends keyof ResponseMap
+		? ResponseMap[K] | ErrorResponse
+		: ErrorResponse
+	: ErrorResponse;
 
 export function encodeMessage(message: OrchestratorRequest | OrchestratorResponse): string {
 	return `${JSON.stringify(message)}\n`;
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
new file mode 100644
index 00000000..59d91b57
--- /dev/null
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -0,0 +1,107 @@
+import { existsSync, unlinkSync } from "node:fs";
+import { createConnection, createServer, type Server } from "node:net";
+import { getSocketPath } from "../config.ts";
+import {
+	type ErrorResponse,
+	encodeMessage,
+	type OrchestratorRequest,
+	parseRequestLine,
+	type ResponseFor,
+} from "./protocol.ts";
+
+export type IpcRequestHandler = <T extends OrchestratorRequest>(request: T) => Promise<ResponseFor<T>> | ResponseFor<T>;
+
+export async function startIpcServer(handler: IpcRequestHandler): Promise<Server> {
+	const socketPath = getSocketPath();
+	await removeStaleSocketIfNeeded(socketPath);
+
+	const server = createServer((socket) => {
+		let buffer = "";
+
+		socket.on("data", async (chunk: Buffer | string) => {
+			buffer += chunk.toString();
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				return;
+			}
+
+			const line = buffer.slice(0, newlineIndex).trim();
+			buffer = buffer.slice(newlineIndex + 1);
+			if (!line) {
+				return;
+			}
+
+			try {
+				const request = parseRequestLine(line);
+				const response = await handler(request);
+				socket.end(encodeMessage(response));
+			} catch (error) {
+				const response: ErrorResponse = {
+					type: "error",
+					ok: false,
+					error: error instanceof Error ? error.message : String(error),
+				};
+				socket.end(encodeMessage(response));
+			}
+		});
+	});
+
+	await new Promise<void>((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(socketPath, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+
+	return server;
+}
+
+async function removeStaleSocketIfNeeded(socketPath: string): Promise<void> {
+	if (!existsSync(socketPath)) {
+		return;
+	}
+
+	const isLive = await isSocketLive(socketPath);
+	if (isLive) {
+		throw new Error(`orchestrator is already running: ${socketPath}`);
+	}
+
+	unlinkSync(socketPath);
+}
+
+async function isSocketLive(socketPath: string): Promise<boolean> {
+	return new Promise<boolean>((resolve, reject) => {
+		const socket = createConnection(socketPath);
+		let settled = false;
+
+		const finish = (result: boolean) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			socket.removeAllListeners();
+			socket.destroy();
+			resolve(result);
+		};
+
+		socket.on("connect", () => finish(true));
+		socket.on("error", (error: NodeJS.ErrnoException) => {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOENT") {
+				finish(false);
+				return;
+			}
+			if (error.code === "EPIPE" || error.code === "ECONNRESET") {
+				finish(false);
+				return;
+			}
+			if (settled) {
+				return;
+			}
+			settled = true;
+			socket.removeAllListeners();
+			socket.destroy();
+			reject(error);
+		});
+	});
+}

From 5f60fc01d748594318318d1f160bd4a93595c3b3 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:09:48 +0200
Subject: [PATCH 05/36] feat: machine and instance storage

---
 packages/orchestrator/src/index.ts        |  2 +
 packages/orchestrator/src/ipc/protocol.ts |  4 +-
 packages/orchestrator/src/storage.ts      | 62 +++++++++++++++++++++++
 packages/orchestrator/src/types.ts        | 18 +++++++
 4 files changed, 85 insertions(+), 1 deletion(-)
 create mode 100644 packages/orchestrator/src/storage.ts
 create mode 100644 packages/orchestrator/src/types.ts

diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index 196332d8..4f017322 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -2,3 +2,5 @@ export * from "./config.ts";
 export * from "./ipc/client.ts";
 export * from "./ipc/protocol.ts";
 export * from "./ipc/server.ts";
+export * from "./storage.ts";
+export * from "./types.ts";
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index ebb2815f..87c24c7a 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -1,3 +1,5 @@
+import type { InstanceStatus } from "../types.ts";
+
 export interface SpawnRequest {
 	type: "spawn";
 	cwd: string;
@@ -31,7 +33,7 @@ export type OrchestratorRequest = RequestMap[keyof RequestMap];
 
 export interface InstanceSummary {
 	id: string;
-	status: "starting" | "online" | "stopping" | "stopped" | "error";
+	status: InstanceStatus;
 	cwd: string;
 	label?: string;
 	sessionId?: string;
diff --git a/packages/orchestrator/src/storage.ts b/packages/orchestrator/src/storage.ts
new file mode 100644
index 00000000..29eb3213
--- /dev/null
+++ b/packages/orchestrator/src/storage.ts
@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { getInstancesPath, getMachinePath, getOrchestratorDir } from "./config.ts";
+import type { InstanceRecord, MachineRecord } from "./types.ts";
+
+function ensureOrchestratorDir(): void {
+	const orchestratorDir = getOrchestratorDir();
+	if (!existsSync(orchestratorDir)) {
+		mkdirSync(orchestratorDir, { recursive: true });
+	}
+}
+
+export function loadMachine(): MachineRecord | undefined {
+	const machinePath = getMachinePath();
+	if (!existsSync(machinePath)) {
+		return undefined;
+	}
+
+	const data = readFileSync(machinePath, "utf-8");
+	return JSON.parse(data) as MachineRecord;
+}
+
+export function saveMachine(machine: MachineRecord): void {
+	ensureOrchestratorDir();
+	writeFileSync(getMachinePath(), JSON.stringify(machine, null, 2));
+}
+
+export function loadInstances(): InstanceRecord[] {
+	const instancesPath = getInstancesPath();
+	if (!existsSync(instancesPath)) {
+		return [];
+	}
+
+	const data = readFileSync(instancesPath, "utf-8");
+	return JSON.parse(data) as InstanceRecord[];
+}
+
+export function saveInstances(instances: InstanceRecord[]): void {
+	ensureOrchestratorDir();
+	writeFileSync(getInstancesPath(), JSON.stringify(instances, null, 2));
+}
+
+export function getInstance(instanceId: string): InstanceRecord | undefined {
+	return loadInstances().find((instance) => instance.id === instanceId);
+}
+
+export function upsertInstance(instance: InstanceRecord): void {
+	const instances = loadInstances();
+	const index = instances.findIndex((existing) => existing.id === instance.id);
+	if (index === -1) {
+		instances.push(instance);
+		saveInstances(instances);
+		return;
+	}
+
+	instances[index] = instance;
+	saveInstances(instances);
+}
+
+export function removeInstance(instanceId: string): void {
+	const instances = loadInstances().filter((instance) => instance.id !== instanceId);
+	saveInstances(instances);
+}
diff --git a/packages/orchestrator/src/types.ts b/packages/orchestrator/src/types.ts
new file mode 100644
index 00000000..d2e4d06e
--- /dev/null
+++ b/packages/orchestrator/src/types.ts
@@ -0,0 +1,18 @@
+export type InstanceStatus = "starting" | "online" | "stopping" | "stopped" | "error";
+
+export interface MachineRecord {
+	id: string;
+	createdAt: string;
+	lastSeenAt?: string;
+	label?: string;
+}
+
+export interface InstanceRecord {
+	id: string;
+	status: InstanceStatus;
+	cwd: string;
+	createdAt: string;
+	lastSeenAt?: string;
+	label?: string;
+	sessionId?: string;
+}

From 83e8c3d39ba6576e3c902f8777ec3d95b05a74bd Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:14:01 +0200
Subject: [PATCH 06/36] feat: handler

---
 packages/orchestrator/src/handler.ts    | 96 +++++++++++++++++++++++++
 packages/orchestrator/src/index.ts      |  1 +
 packages/orchestrator/src/ipc/server.ts | 18 ++++-
 3 files changed, 113 insertions(+), 2 deletions(-)
 create mode 100644 packages/orchestrator/src/handler.ts

diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
new file mode 100644
index 00000000..894308bb
--- /dev/null
+++ b/packages/orchestrator/src/handler.ts
@@ -0,0 +1,96 @@
+import { randomUUID } from "node:crypto";
+import type {
+	ErrorResponse,
+	InstanceSummary,
+	ListRequest,
+	ListResponse,
+	OrchestratorRequest,
+	OrchestratorResponse,
+	SpawnRequest,
+	SpawnResponse,
+	StatusRequest,
+	StatusResponse,
+	StopRequest,
+	StopResponse,
+} from "./ipc/protocol.ts";
+import { getInstance, loadInstances, removeInstance, upsertInstance } from "./storage.ts";
+import type { InstanceRecord } from "./types.ts";
+
+function toInstanceSummary(instance: InstanceRecord): InstanceSummary {
+	return {
+		id: instance.id,
+		status: instance.status,
+		cwd: instance.cwd,
+		label: instance.label,
+		sessionId: instance.sessionId,
+	};
+}
+
+function unknownInstanceError(instanceId: string): ErrorResponse {
+	return {
+		type: "error",
+		ok: false,
+		error: `Unknown instance: ${instanceId}`,
+	};
+}
+
+// Overhead types
+export async function handleIpcRequest(request: SpawnRequest): Promise<SpawnResponse | ErrorResponse>;
+export async function handleIpcRequest(request: ListRequest): Promise<ListResponse | ErrorResponse>;
+export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
+export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
+export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
+	switch (request.type) {
+		case "spawn": {
+			const instance: InstanceRecord = {
+				id: randomUUID(),
+				status: "starting",
+				cwd: request.cwd,
+				createdAt: new Date().toISOString(),
+				lastSeenAt: new Date().toISOString(),
+				label: request.label,
+			};
+			upsertInstance(instance);
+			return {
+				type: "spawn_result",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
+
+		case "list": {
+			return {
+				type: "list_result",
+				ok: true,
+				instances: loadInstances().map(toInstanceSummary),
+			};
+		}
+
+		case "status": {
+			const instance = getInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+
+			return {
+				type: "status_result",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
+
+		case "stop": {
+			const instance = getInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+
+			removeInstance(request.instanceId);
+			return {
+				type: "stop_result",
+				ok: true,
+				instanceId: request.instanceId,
+			};
+		}
+	}
+}
diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index 4f017322..e16fbc5f 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -1,4 +1,5 @@
 export * from "./config.ts";
+export * from "./handler.ts";
 export * from "./ipc/client.ts";
 export * from "./ipc/protocol.ts";
 export * from "./ipc/server.ts";
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 59d91b57..860181b9 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -4,12 +4,26 @@ import { getSocketPath } from "../config.ts";
 import {
 	type ErrorResponse,
 	encodeMessage,
+	type ListRequest,
+	type ListResponse,
 	type OrchestratorRequest,
+	type OrchestratorResponse,
 	parseRequestLine,
-	type ResponseFor,
+	type SpawnRequest,
+	type SpawnResponse,
+	type StatusRequest,
+	type StatusResponse,
+	type StopRequest,
+	type StopResponse,
 } from "./protocol.ts";
 
-export type IpcRequestHandler = <T extends OrchestratorRequest>(request: T) => Promise<ResponseFor<T>> | ResponseFor<T>;
+export interface IpcRequestHandler {
+	(request: SpawnRequest): Promise<SpawnResponse | ErrorResponse> | SpawnResponse | ErrorResponse;
+	(request: ListRequest): Promise<ListResponse | ErrorResponse> | ListResponse | ErrorResponse;
+	(request: StopRequest): Promise<StopResponse | ErrorResponse> | StopResponse | ErrorResponse;
+	(request: StatusRequest): Promise<StatusResponse | ErrorResponse> | StatusResponse | ErrorResponse;
+	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
+}
 
 export async function startIpcServer(handler: IpcRequestHandler): Promise<Server> {
 	const socketPath = getSocketPath();

From 946b9c7dee4ffc89d125616d6c000afa9a0c27f5 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:16:10 +0200
Subject: [PATCH 07/36] feat: serve and command

---
 packages/orchestrator/src/cli.ts     | 36 ++++++++++++++++++----------
 packages/orchestrator/src/handler.ts |  1 +
 packages/orchestrator/src/index.ts   |  1 +
 packages/orchestrator/src/serve.ts   | 26 ++++++++++++++++++++
 4 files changed, 52 insertions(+), 12 deletions(-)
 create mode 100644 packages/orchestrator/src/serve.ts

diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index 0ad2da39..e6b7da5f 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -2,6 +2,7 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { serve } from "./serve.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -10,21 +11,32 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 };
 
 function printHelp(): void {
-	console.log(`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator --help\n  orchestrator --version`);
+	console.log(
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator --help\n  orchestrator --version`,
+	);
 }
 
-const args = process.argv.slice(2);
+async function main(): Promise<void> {
+	const args = process.argv.slice(2);
 
-if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+	if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+		printHelp();
+		process.exit(0);
+	}
+
+	if (args[0] === "--version" || args[0] === "-v") {
+		console.log(packageJson.version);
+		process.exit(0);
+	}
+
+	if (args[0] === "serve") {
+		await serve();
+		return;
+	}
+
+	console.error(`Unknown command: ${args[0]}`);
 	printHelp();
-	process.exit(0);
+	process.exit(1);
 }
 
-if (args[0] === "--version" || args[0] === "-v") {
-	console.log(packageJson.version);
-	process.exit(0);
-}
-
-console.error(`Unknown command: ${args[0]}`);
-printHelp();
-process.exit(1);
+await main();
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 894308bb..0e894ba0 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -39,6 +39,7 @@ export async function handleIpcRequest(request: SpawnRequest): Promise<SpawnResp
 export async function handleIpcRequest(request: ListRequest): Promise<ListResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
+export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
 	switch (request.type) {
 		case "spawn": {
diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index e16fbc5f..459cd58f 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -3,5 +3,6 @@ export * from "./handler.ts";
 export * from "./ipc/client.ts";
 export * from "./ipc/protocol.ts";
 export * from "./ipc/server.ts";
+export * from "./serve.ts";
 export * from "./storage.ts";
 export * from "./types.ts";
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
new file mode 100644
index 00000000..1651086b
--- /dev/null
+++ b/packages/orchestrator/src/serve.ts
@@ -0,0 +1,26 @@
+import { existsSync, unlinkSync } from "node:fs";
+import { getSocketPath } from "./config.ts";
+import { handleIpcRequest } from "./handler.ts";
+import { startIpcServer } from "./ipc/server.ts";
+
+export async function serve(): Promise<void> {
+	const socketPath = getSocketPath();
+	const server = await startIpcServer(handleIpcRequest);
+
+	const cleanup = () => {
+		server.close();
+		if (existsSync(socketPath)) {
+			unlinkSync(socketPath);
+		}
+	};
+
+	process.on("SIGINT", () => {
+		cleanup();
+		process.exit(0);
+	});
+
+	process.on("SIGTERM", () => {
+		cleanup();
+		process.exit(0);
+	});
+}

From 2a2dc0e99f1aabacdd346fb792b3a6fb222fa6b9 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:19:03 +0200
Subject: [PATCH 08/36] feat: commands

---
 packages/orchestrator/src/cli.ts | 48 +++++++++++++++++++++++++++++++-
 1 file changed, 47 insertions(+), 1 deletion(-)

diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index e6b7da5f..7e057634 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { cwd } from "node:process";
 import { fileURLToPath } from "node:url";
+import { sendIpcRequest } from "./ipc/client.ts";
 import { serve } from "./serve.ts";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -12,10 +14,22 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 
 function printHelp(): void {
 	console.log(
-		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator --help\n  orchestrator --version`,
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator --help\n  orchestrator --version`,
 	);
 }
 
+function printResponse(response: unknown): void {
+	console.log(JSON.stringify(response, null, 2));
+}
+
+function getFlagValue(args: string[], flag: string): string | undefined {
+	const index = args.indexOf(flag);
+	if (index === -1 || index + 1 >= args.length) {
+		return undefined;
+	}
+	return args[index + 1];
+}
+
 async function main(): Promise<void> {
 	const args = process.argv.slice(2);
 
@@ -34,6 +48,38 @@ async function main(): Promise<void> {
 		return;
 	}
 
+	if (args[0] === "list") {
+		printResponse(await sendIpcRequest({ type: "list" }));
+		return;
+	}
+
+	if (args[0] === "spawn") {
+		const spawnCwd = getFlagValue(args, "--cwd") ?? cwd();
+		const label = getFlagValue(args, "--label");
+		printResponse(await sendIpcRequest({ type: "spawn", cwd: spawnCwd, label }));
+		return;
+	}
+
+	if (args[0] === "status") {
+		const instanceId = args[1];
+		if (!instanceId) {
+			console.error("Usage: orchestrator status <instance-id>");
+			process.exit(1);
+		}
+		printResponse(await sendIpcRequest({ type: "status", instanceId }));
+		return;
+	}
+
+	if (args[0] === "stop") {
+		const instanceId = args[1];
+		if (!instanceId) {
+			console.error("Usage: orchestrator stop <instance-id>");
+			process.exit(1);
+		}
+		printResponse(await sendIpcRequest({ type: "stop", instanceId }));
+		return;
+	}
+
 	console.error(`Unknown command: ${args[0]}`);
 	printHelp();
 	process.exit(1);

From 0cbdc283a3d90b55314c0168cadc89c285a19444 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:19:42 +0200
Subject: [PATCH 09/36] fix: lifecycle

---
 packages/orchestrator/src/serve.ts | 31 ++++++++++++++++++++++++------
 1 file changed, 25 insertions(+), 6 deletions(-)

diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index 1651086b..5183ca60 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -1,26 +1,45 @@
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { dirname } from "node:path";
 import { getSocketPath } from "./config.ts";
 import { handleIpcRequest } from "./handler.ts";
 import { startIpcServer } from "./ipc/server.ts";
 
 export async function serve(): Promise<void> {
 	const socketPath = getSocketPath();
+	mkdirSync(dirname(socketPath), { recursive: true });
 	const server = await startIpcServer(handleIpcRequest);
+	console.log(`orchestrator listening on ${socketPath}`);
 
+	let cleanedUp = false;
 	const cleanup = () => {
+		if (cleanedUp) {
+			return;
+		}
+		cleanedUp = true;
 		server.close();
 		if (existsSync(socketPath)) {
 			unlinkSync(socketPath);
 		}
 	};
 
-	process.on("SIGINT", () => {
+	const shutdown = (exitCode: number) => {
 		cleanup();
-		process.exit(0);
+		process.exit(exitCode);
+	};
+
+	process.on("SIGINT", () => shutdown(0));
+	process.on("SIGTERM", () => shutdown(0));
+	process.on("exit", cleanup);
+	process.on("uncaughtException", (error) => {
+		console.error(error);
+		shutdown(1);
+	});
+	process.on("unhandledRejection", (reason) => {
+		console.error(reason);
+		shutdown(1);
 	});
 
-	process.on("SIGTERM", () => {
-		cleanup();
-		process.exit(0);
+	await new Promise<void>(() => {
+		// Keep the process alive until a signal or fatal error triggers shutdown.
 	});
 }

From 0d02df760f40f1c323b1c4bd5421faa9ef9e511a Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:25:50 +0200
Subject: [PATCH 10/36] feat: supervisor

---
 packages/orchestrator/package.json      |  4 +-
 packages/orchestrator/src/handler.ts    | 19 ++---
 packages/orchestrator/src/index.ts      |  1 +
 packages/orchestrator/src/supervisor.ts | 99 +++++++++++++++++++++++++
 4 files changed, 109 insertions(+), 14 deletions(-)
 create mode 100644 packages/orchestrator/src/supervisor.ts

diff --git a/packages/orchestrator/package.json b/packages/orchestrator/package.json
index a614b8da..555169bc 100644
--- a/packages/orchestrator/package.json
+++ b/packages/orchestrator/package.json
@@ -39,7 +39,9 @@
 	"engines": {
 		"node": ">=22.19.0"
 	},
-	"dependencies": {},
+	"dependencies": {
+		"@earendil-works/pi-coding-agent": "0.79.6"
+	},
 	"devDependencies": {
 		"shx": "0.4.0"
 	}
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 0e894ba0..317a9247 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import type {
 	ErrorResponse,
 	InstanceSummary,
@@ -13,7 +12,7 @@ import type {
 	StopRequest,
 	StopResponse,
 } from "./ipc/protocol.ts";
-import { getInstance, loadInstances, removeInstance, upsertInstance } from "./storage.ts";
+import { supervisor } from "./supervisor.ts";
 import type { InstanceRecord } from "./types.ts";
 
 function toInstanceSummary(instance: InstanceRecord): InstanceSummary {
@@ -43,15 +42,10 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
 	switch (request.type) {
 		case "spawn": {
-			const instance: InstanceRecord = {
-				id: randomUUID(),
-				status: "starting",
+			const instance = await supervisor.spawnInstance({
 				cwd: request.cwd,
-				createdAt: new Date().toISOString(),
-				lastSeenAt: new Date().toISOString(),
 				label: request.label,
-			};
-			upsertInstance(instance);
+			});
 			return {
 				type: "spawn_result",
 				ok: true,
@@ -63,12 +57,12 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 			return {
 				type: "list_result",
 				ok: true,
-				instances: loadInstances().map(toInstanceSummary),
+				instances: supervisor.listInstances().map(toInstanceSummary),
 			};
 		}
 
 		case "status": {
-			const instance = getInstance(request.instanceId);
+			const instance = supervisor.getInstance(request.instanceId);
 			if (!instance) {
 				return unknownInstanceError(request.instanceId);
 			}
@@ -81,12 +75,11 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 		}
 
 		case "stop": {
-			const instance = getInstance(request.instanceId);
+			const instance = await supervisor.stopInstance(request.instanceId);
 			if (!instance) {
 				return unknownInstanceError(request.instanceId);
 			}
 
-			removeInstance(request.instanceId);
 			return {
 				type: "stop_result",
 				ok: true,
diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index 459cd58f..cfa24b03 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -5,4 +5,5 @@ export * from "./ipc/protocol.ts";
 export * from "./ipc/server.ts";
 export * from "./serve.ts";
 export * from "./storage.ts";
+export * from "./supervisor.ts";
 export * from "./types.ts";
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
new file mode 100644
index 00000000..be874d44
--- /dev/null
+++ b/packages/orchestrator/src/supervisor.ts
@@ -0,0 +1,99 @@
+import { randomUUID } from "node:crypto";
+import {
+	type AgentSessionRuntime,
+	type CreateAgentSessionRuntimeFactory,
+	createAgentSessionFromServices,
+	createAgentSessionRuntime,
+	createAgentSessionServices,
+	getAgentDir,
+	SessionManager,
+} from "@earendil-works/pi-coding-agent";
+import { getInstance, loadInstances, removeInstance, upsertInstance } from "./storage.ts";
+import type { InstanceRecord } from "./types.ts";
+
+interface LiveInstance {
+	runtime: AgentSessionRuntime;
+	record: InstanceRecord;
+}
+
+function cloneInstance(record: InstanceRecord): InstanceRecord {
+	return { ...record };
+}
+
+async function createRuntime(cwd: string): Promise<AgentSessionRuntime> {
+	const agentDir = getAgentDir();
+	const sessionManager = SessionManager.inMemory(cwd);
+	const runtimeFactory: CreateAgentSessionRuntimeFactory = async ({
+		cwd,
+		agentDir,
+		sessionManager,
+		sessionStartEvent,
+	}) => {
+		const services = await createAgentSessionServices({ cwd, agentDir });
+		const created = await createAgentSessionFromServices({
+			services,
+			sessionManager,
+			sessionStartEvent,
+		});
+		return {
+			...created,
+			services,
+			diagnostics: services.diagnostics,
+		};
+	};
+
+	return createAgentSessionRuntime(runtimeFactory, {
+		cwd,
+		agentDir,
+		sessionManager,
+	});
+}
+
+export class OrchestratorSupervisor {
+	private readonly liveInstances = new Map<string, LiveInstance>();
+
+	listInstances(): InstanceRecord[] {
+		return loadInstances().map(cloneInstance);
+	}
+
+	getInstance(instanceId: string): InstanceRecord | undefined {
+		const live = this.liveInstances.get(instanceId);
+		if (live) {
+			return cloneInstance(live.record);
+		}
+		const stored = getInstance(instanceId);
+		return stored ? cloneInstance(stored) : undefined;
+	}
+
+	async spawnInstance(options: { cwd: string; label?: string }): Promise<InstanceRecord> {
+		const runtime = await createRuntime(options.cwd);
+		const now = new Date().toISOString();
+		const record: InstanceRecord = {
+			id: randomUUID(),
+			status: "online",
+			cwd: options.cwd,
+			createdAt: now,
+			lastSeenAt: now,
+			label: options.label,
+			sessionId: runtime.session.sessionId,
+		};
+
+		this.liveInstances.set(record.id, { runtime, record });
+		upsertInstance(record);
+		return cloneInstance(record);
+	}
+
+	async stopInstance(instanceId: string): Promise<InstanceRecord | undefined> {
+		const live = this.liveInstances.get(instanceId);
+		if (!live) {
+			return undefined;
+		}
+
+		await live.runtime.dispose();
+		this.liveInstances.delete(instanceId);
+		removeInstance(instanceId);
+		return cloneInstance(live.record);
+	}
+}
+
+export const supervisor = new OrchestratorSupervisor();

From 8bc92fc90bdd56c76e093e083fb95792c14a1805 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 13:32:17 +0200
Subject: [PATCH 11/36] feat: rpc bridge

---
 packages/orchestrator/src/cli.ts          | 19 ++++++-
 packages/orchestrator/src/handler.ts      | 16 ++++++
 packages/orchestrator/src/ipc/protocol.ts | 14 +++++
 packages/orchestrator/src/ipc/server.ts   |  3 ++
 packages/orchestrator/src/rpc-bridge.ts   | 63 +++++++++++++++++++++++
 packages/orchestrator/src/supervisor.ts   | 12 +++++
 6 files changed, 126 insertions(+), 1 deletion(-)
 create mode 100644 packages/orchestrator/src/rpc-bridge.ts

diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index 7e057634..13be25a5 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -14,7 +14,7 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 
 function printHelp(): void {
 	console.log(
-		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator --help\n  orchestrator --version`,
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator --help\n  orchestrator --version`,
 	);
 }
 
@@ -80,6 +80,23 @@ async function main(): Promise<void> {
 		return;
 	}
 
+	if (args[0] === "rpc") {
+		const instanceId = args[1];
+		const commandJson = args[2];
+		if (!instanceId || !commandJson) {
+			console.error("Usage: orchestrator rpc <instance-id> <json-command>");
+			process.exit(1);
+		}
+		printResponse(
+			await sendIpcRequest({
+				type: "rpc",
+				instanceId,
+				command: JSON.parse(commandJson),
+			}),
+		);
+		return;
+	}
+
 	console.error(`Unknown command: ${args[0]}`);
 	printHelp();
 	process.exit(1);
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 317a9247..dab6ee6b 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -5,6 +5,8 @@ import type {
 	ListResponse,
 	OrchestratorRequest,
 	OrchestratorResponse,
+	RpcBridgeResponse,
+	RpcRequest,
 	SpawnRequest,
 	SpawnResponse,
 	StatusRequest,
@@ -38,6 +40,7 @@ export async function handleIpcRequest(request: SpawnRequest): Promise<SpawnResp
 export async function handleIpcRequest(request: ListRequest): Promise<ListResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
+export async function handleIpcRequest(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
 	switch (request.type) {
@@ -86,5 +89,18 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 				instanceId: request.instanceId,
 			};
 		}
+
+		case "rpc": {
+			const response = await supervisor.handleRpc(request.instanceId, request.command);
+			if (!response) {
+				return unknownInstanceError(request.instanceId);
+			}
+
+			return {
+				type: "rpc_result",
+				ok: true,
+				response,
+			};
+		}
 	}
 }
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 87c24c7a..b4313783 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -1,3 +1,4 @@
+import type { RpcCommand, RpcResponse } from "@earendil-works/pi-coding-agent";
 import type { InstanceStatus } from "../types.ts";
 
 export interface SpawnRequest {
@@ -22,11 +23,18 @@ export interface StatusRequest {
 	instanceId: string;
 }
 
+export interface RpcRequest {
+	type: "rpc";
+	instanceId: string;
+	command: RpcCommand;
+}
+
 export interface RequestMap {
 	spawn: SpawnRequest;
 	list: ListRequest;
 	stop: StopRequest;
 	status: StatusRequest;
+	rpc: RpcRequest;
 }
 
 export type OrchestratorRequest = RequestMap[keyof RequestMap];
@@ -64,6 +72,11 @@ export interface StatusResponse extends ResponseBase {
 	instance?: InstanceSummary;
 }
 
+export interface RpcBridgeResponse extends ResponseBase {
+	type: "rpc_result";
+	response: RpcResponse;
+}
+
 export interface ErrorResponse extends ResponseBase {
 	type: "error";
 	ok: false;
@@ -75,6 +88,7 @@ export interface ResponseMap {
 	list: ListResponse;
 	stop: StopResponse;
 	status: StatusResponse;
+	rpc: RpcBridgeResponse;
 }
 
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 860181b9..7138a492 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -9,6 +9,8 @@ import {
 	type OrchestratorRequest,
 	type OrchestratorResponse,
 	parseRequestLine,
+	type RpcBridgeResponse,
+	type RpcRequest,
 	type SpawnRequest,
 	type SpawnResponse,
 	type StatusRequest,
@@ -22,6 +24,7 @@ export interface IpcRequestHandler {
 	(request: ListRequest): Promise<ListResponse | ErrorResponse> | ListResponse | ErrorResponse;
 	(request: StopRequest): Promise<StopResponse | ErrorResponse> | StopResponse | ErrorResponse;
 	(request: StatusRequest): Promise<StatusResponse | ErrorResponse> | StatusResponse | ErrorResponse;
+	(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse> | RpcBridgeResponse | ErrorResponse;
 	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
 }
 
diff --git a/packages/orchestrator/src/rpc-bridge.ts b/packages/orchestrator/src/rpc-bridge.ts
new file mode 100644
index 00000000..a1d2c760
--- /dev/null
+++ b/packages/orchestrator/src/rpc-bridge.ts
@@ -0,0 +1,63 @@
+import type { AgentSessionRuntime, RpcCommand, RpcResponse, RpcSessionState } from "@earendil-works/pi-coding-agent";
+
+function success<T extends RpcCommand["type"]>(id: string | undefined, command: T, data?: object | null): RpcResponse {
+	if (data === undefined) {
+		return { id, type: "response", command, success: true } as RpcResponse;
+	}
+	return { id, type: "response", command, success: true, data } as RpcResponse;
+}
+
+function error(id: string | undefined, command: string, message: string): RpcResponse {
+	return { id, type: "response", command, success: false, error: message };
+}
+
+export async function handleRpcCommand(runtime: AgentSessionRuntime, command: RpcCommand): Promise<RpcResponse> {
+	const session = runtime.session;
+	const id = command.id;
+
+	switch (command.type) {
+		case "prompt": {
+			await session.prompt(command.message, {
+				images: command.images,
+				streamingBehavior: command.streamingBehavior,
+				source: "rpc",
+			});
+			return success(id, "prompt");
+		}
+
+		case "abort": {
+			await session.abort();
+			return success(id, "abort");
+		}
+
+		case "get_state": {
+			const state: RpcSessionState = {
+				model: session.model,
+				thinkingLevel: session.thinkingLevel,
+				isStreaming: session.isStreaming,
+				isCompacting: session.isCompacting,
+				steeringMode: session.steeringMode,
+				followUpMode: session.followUpMode,
+				sessionFile: session.sessionFile,
+				sessionId: session.sessionId,
+				sessionName: session.sessionName,
+				autoCompactionEnabled: session.autoCompactionEnabled,
+				messageCount: session.messages.length,
+				pendingMessageCount: session.pendingMessageCount,
+			};
+			return success(id, "get_state", state);
+		}
+
+		case "get_last_assistant_text": {
+			const text = session.getLastAssistantText() ?? null;
+			return success(id, "get_last_assistant_text", { text });
+		}
+
+		case "get_messages": {
+			return success(id, "get_messages", { messages: session.messages });
+		}
+
+		default:
+			return error(id, command.type, `Unsupported RPC command: ${command.type}`);
+	}
+}
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index be874d44..24bcca57 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -6,8 +6,11 @@ import {
 	createAgentSessionRuntime,
 	createAgentSessionServices,
 	getAgentDir,
+	type RpcCommand,
+	type RpcResponse,
 	SessionManager,
 } from "@earendil-works/pi-coding-agent";
+import { handleRpcCommand } from "./rpc-bridge.ts";
 import { getInstance, loadInstances, removeInstance, upsertInstance } from "./storage.ts";
 import type { InstanceRecord } from "./types.ts";
 
@@ -94,6 +97,15 @@ export class OrchestratorSupervisor {
 		removeInstance(instanceId);
 		return cloneInstance(live.record);
 	}
+
+	async handleRpc(instanceId: string, command: RpcCommand): Promise<RpcResponse | undefined> {
+		const live = this.liveInstances.get(instanceId);
+		if (!live) {
+			return undefined;
+		}
+
+		return handleRpcCommand(live.runtime, command);
+	}
 }
 
 export const supervisor = new OrchestratorSupervisor();

From 52b7f7749e4a69a18673226d3775a91078173384 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 14:07:39 +0200
Subject: [PATCH 12/36] feat: support rpc commands

---
 packages/orchestrator/src/rpc-bridge.ts | 155 +++++++++++++++++++++++-
 1 file changed, 153 insertions(+), 2 deletions(-)

diff --git a/packages/orchestrator/src/rpc-bridge.ts b/packages/orchestrator/src/rpc-bridge.ts
index a1d2c760..84df33fd 100644
--- a/packages/orchestrator/src/rpc-bridge.ts
+++ b/packages/orchestrator/src/rpc-bridge.ts
@@ -11,6 +11,10 @@ function error(id: string | undefined, command: string, message: string): RpcRes
 	return { id, type: "response", command, success: false, error: message };
 }
 
+function unsupported(id: string | undefined, command: RpcCommand["type"]): RpcResponse {
+	return error(id, command, `Unsupported RPC command in orchestrator bridge: ${command}`);
+}
+
 export async function handleRpcCommand(runtime: AgentSessionRuntime, command: RpcCommand): Promise<RpcResponse> {
 	const session = runtime.session;
 	const id = command.id;
@@ -25,11 +29,27 @@ export async function handleRpcCommand(runtime: AgentSessionRuntime, command: Rp
 			return success(id, "prompt");
 		}
 
+		case "steer": {
+			await session.steer(command.message, command.images);
+			return success(id, "steer");
+		}
+
+		case "follow_up": {
+			await session.followUp(command.message, command.images);
+			return success(id, "follow_up");
+		}
+
 		case "abort": {
 			await session.abort();
 			return success(id, "abort");
 		}
 
+		case "new_session":
+		case "switch_session":
+		case "fork":
+		case "clone":
+			return unsupported(id, command.type);
+
 		case "get_state": {
 			const state: RpcSessionState = {
 				model: session.model,
@@ -48,16 +68,147 @@ export async function handleRpcCommand(runtime: AgentSessionRuntime, command: Rp
 			return success(id, "get_state", state);
 		}
 
+		case "set_model": {
+			const models = await session.modelRegistry.getAvailable();
+			const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
+			if (!model) {
+				return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
+			}
+			await session.setModel(model);
+			return success(id, "set_model", model);
+		}
+
+		case "cycle_model": {
+			const result = await session.cycleModel();
+			return success(id, "cycle_model", result ?? null);
+		}
+
+		case "get_available_models": {
+			const models = await session.modelRegistry.getAvailable();
+			return success(id, "get_available_models", { models });
+		}
+
+		case "set_thinking_level": {
+			session.setThinkingLevel(command.level);
+			return success(id, "set_thinking_level");
+		}
+
+		case "cycle_thinking_level": {
+			const level = session.cycleThinkingLevel();
+			return success(id, "cycle_thinking_level", level ? { level } : null);
+		}
+
+		case "set_steering_mode": {
+			session.setSteeringMode(command.mode);
+			return success(id, "set_steering_mode");
+		}
+
+		case "set_follow_up_mode": {
+			session.setFollowUpMode(command.mode);
+			return success(id, "set_follow_up_mode");
+		}
+
+		case "compact": {
+			const result = await session.compact(command.customInstructions);
+			return success(id, "compact", result);
+		}
+
+		case "set_auto_compaction": {
+			session.setAutoCompactionEnabled(command.enabled);
+			return success(id, "set_auto_compaction");
+		}
+
+		case "set_auto_retry": {
+			session.setAutoRetryEnabled(command.enabled);
+			return success(id, "set_auto_retry");
+		}
+
+		case "abort_retry": {
+			session.abortRetry();
+			return success(id, "abort_retry");
+		}
+
+		case "bash": {
+			const result = await session.executeBash(command.command, undefined, {
+				excludeFromContext: command.excludeFromContext,
+			});
+			return success(id, "bash", result);
+		}
+
+		case "abort_bash": {
+			session.abortBash();
+			return success(id, "abort_bash");
+		}
+
+		case "get_session_stats": {
+			const stats = session.getSessionStats();
+			return success(id, "get_session_stats", stats);
+		}
+
+		case "export_html": {
+			const path = await session.exportToHtml(command.outputPath);
+			return success(id, "export_html", { path });
+		}
+
+		case "get_fork_messages": {
+			const messages = session.getUserMessagesForForking();
+			return success(id, "get_fork_messages", { messages });
+		}
+
 		case "get_last_assistant_text": {
 			const text = session.getLastAssistantText() ?? null;
 			return success(id, "get_last_assistant_text", { text });
 		}
 
+		case "set_session_name": {
+			const name = command.name.trim();
+			if (!name) {
+				return error(id, "set_session_name", "Session name cannot be empty");
+			}
+			session.setSessionName(name);
+			return success(id, "set_session_name");
+		}
+
 		case "get_messages": {
 			return success(id, "get_messages", { messages: session.messages });
 		}
 
-		default:
-			return error(id, command.type, `Unsupported RPC command: ${command.type}`);
+		case "get_commands": {
+			const commands = [];
+
+			for (const registeredCommand of session.extensionRunner.getRegisteredCommands()) {
+				commands.push({
+					name: registeredCommand.invocationName,
+					description: registeredCommand.description,
+					source: "extension",
+					sourceInfo: registeredCommand.sourceInfo,
+				});
+			}
+
+			for (const template of session.promptTemplates) {
+				commands.push({
+					name: template.name,
+					description: template.description,
+					source: "prompt",
+					sourceInfo: template.sourceInfo,
+				});
+			}
+
+			for (const skill of session.resourceLoader.getSkills().skills) {
+				commands.push({
+					name: `skill:${skill.name}`,
+					description: skill.description,
+					source: "skill",
+					sourceInfo: skill.sourceInfo,
+				});
+			}
+
+			return success(id, "get_commands", { commands });
+		}
+
+		default: {
+			const unknownCommand = command as { type: string };
+			return error(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
+		}
 	}
 }

From 9bfafc8c029f31eb3d37aedf6b7198fa3f39b4eb Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:03:43 +0200
Subject: [PATCH 13/36] feat: radius connection

---
 packages/orchestrator/src/handler.ts      |   1 +
 packages/orchestrator/src/ipc/protocol.ts |   1 +
 packages/orchestrator/src/radius.ts       | 157 ++++++++++++++++++++++
 packages/orchestrator/src/serve.ts        |   8 ++
 packages/orchestrator/src/supervisor.ts   |  12 +-
 packages/orchestrator/src/types.ts        |   2 +
 6 files changed, 177 insertions(+), 4 deletions(-)
 create mode 100644 packages/orchestrator/src/radius.ts

diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index dab6ee6b..35ed49b9 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -24,6 +24,7 @@ function toInstanceSummary(instance: InstanceRecord): InstanceSummary {
 		cwd: instance.cwd,
 		label: instance.label,
 		sessionId: instance.sessionId,
+		sessionFile: instance.sessionFile,
 	};
 }
 
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index b4313783..8c194c32 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -45,6 +45,7 @@ export interface InstanceSummary {
 	cwd: string;
 	label?: string;
 	sessionId?: string;
+	sessionFile?: string;
 }
 
 export interface ResponseBase {
diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
new file mode 100644
index 00000000..f3aaacb5
--- /dev/null
+++ b/packages/orchestrator/src/radius.ts
@@ -0,0 +1,157 @@
+import { hostname, platform } from "node:os";
+import { getOrchestratorDir, getSocketPath } from "./config.ts";
+import { loadMachine, saveMachine } from "./storage.ts";
+import type { InstanceRecord, MachineRecord } from "./types.ts";
+
+const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
+const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
+
+interface RegisterMachineResponse {
+	id: string;
+	heartbeatIntervalMs: number;
+	expiresInMs: number;
+}
+
+interface RegisterPiResponse {
+	id: string;
+	heartbeatIntervalMs: number;
+	expiresInMs: number;
+}
+
+async function post<T>(path: string, body: unknown): Promise<T> {
+	const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${getRadiusApiKey()}`,
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify(body),
+	});
+
+	if (!response.ok) {
+		throw new Error(`Radius request failed: ${response.status} ${await response.text()}`);
+	}
+
+	return (await response.json()) as T;
+}
+
+function maybePost(path: string, body: unknown): Promise<Response> {
+	return fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${getRadiusApiKey()}`,
+			"Content-Type": "application/json",
+		},
+		body: JSON.stringify(body),
+	});
+}
+
+export function getRadiusUrl(): string {
+	return process.env.PI_RADIUS_URL || DEFAULT_RADIUS_URL;
+}
+
+export function getRadiusOrchestratorBaseUrl(): string {
+	const explicitUrl = process.env.PI_RADIUS_ORCHESTRATOR_URL;
+	if (explicitUrl) {
+		return explicitUrl;
+	}
+
+	return new URL(DEFAULT_ORCHESTRATOR_BASE_PATH, getRadiusUrl()).toString();
+}
+
+export function getRadiusApiKey(): string {
+	const apiKey = process.env.PI_RADIUS_API_KEY;
+	if (!apiKey) {
+		throw new Error("PI_RADIUS_API_KEY is required for Radius integration");
+	}
+	return apiKey;
+}
+
+export function isRadiusEnabled(): boolean {
+	return !!process.env.PI_RADIUS_API_KEY;
+}
+
+export class RadiusPresence {
+	private heartbeatTimer?: NodeJS.Timeout;
+	private machine?: MachineRecord;
+
+	async start(label?: string): Promise<MachineRecord | undefined> {
+		if (!isRadiusEnabled()) {
+			return undefined;
+		}
+
+		const registered = await post<RegisterMachineResponse>("/v1/machines/register", {
+			label,
+			hostname: hostname(),
+			platform: platform(),
+			arch: process.arch,
+			version: "0.79.6",
+			capabilities: { spawn: true, relay: false, iroh: false },
+		});
+
+		const now = new Date().toISOString();
+		this.machine = {
+			id: registered.id,
+			createdAt: now,
+			lastSeenAt: now,
+			label,
+		};
+		saveMachine(this.machine);
+		this.heartbeatTimer = setInterval(() => {
+			void this.heartbeatMachine();
+		}, registered.heartbeatIntervalMs);
+		return this.machine;
+	}
+
+	async stop(): Promise<void> {
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = undefined;
+		}
+		if (!this.machine || !isRadiusEnabled()) {
+			return;
+		}
+		await maybePost(`/v1/machines/${this.machine.id}/disconnect`, {});
+		this.machine = undefined;
+	}
+
+	async registerPi(instance: InstanceRecord): Promise<InstanceRecord> {
+		if (!isRadiusEnabled()) {
+			return instance;
+		}
+		const machine = this.machine ?? loadMachine();
+		if (!machine) {
+			throw new Error("No registered machine available for Pi registration");
+		}
+		const registered = await post<RegisterPiResponse>("/v1/pis/register", {
+			machineId: machine.id,
+			label: instance.label,
+			cwd: instance.cwd,
+			hostname: hostname(),
+			pid: process.pid,
+			transport: "local-rpc",
+			capabilities: { rpc: true, relay: false, iroh: false },
+			sessionId: instance.sessionId,
+		});
+		return { ...instance, radiusPiId: registered.id };
+	}
+
+	async disconnectPi(instance: InstanceRecord): Promise<void> {
+		if (!isRadiusEnabled() || !instance.radiusPiId) {
+			return;
+		}
+		await maybePost(`/v1/pis/${instance.radiusPiId}/disconnect`, {});
+	}
+
+	private async heartbeatMachine(): Promise<void> {
+		if (!this.machine || !isRadiusEnabled()) {
+			return;
+		}
+		await maybePost(`/v1/machines/${this.machine.id}/heartbeat`, {
+			cwd: getOrchestratorDir(),
+			socketPath: getSocketPath(),
+		});
+	}
+}
+
+export const radiusPresence = new RadiusPresence();
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index 5183ca60..97b07676 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -3,10 +3,17 @@ import { dirname } from "node:path";
 import { getSocketPath } from "./config.ts";
 import { handleIpcRequest } from "./handler.ts";
 import { startIpcServer } from "./ipc/server.ts";
+import { getRadiusOrchestratorBaseUrl, isRadiusEnabled, radiusPresence } from "./radius.ts";
 
 export async function serve(): Promise<void> {
 	const socketPath = getSocketPath();
 	mkdirSync(dirname(socketPath), { recursive: true });
+	if (isRadiusEnabled()) {
+		await radiusPresence.start();
+		console.log(`radius integration enabled: ${socketPath} -> ${getRadiusOrchestratorBaseUrl()}`);
+	} else {
+		console.log("radius integration disabled: set PI_RADIUS_API_KEY to enable");
+	}
 	const server = await startIpcServer(handleIpcRequest);
 	console.log(`orchestrator listening on ${socketPath}`);
 
@@ -17,6 +24,7 @@ export async function serve(): Promise<void> {
 		}
 		cleanedUp = true;
 		server.close();
+		void radiusPresence.stop();
 		if (existsSync(socketPath)) {
 			unlinkSync(socketPath);
 		}
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 24bcca57..d99db09a 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -10,6 +10,7 @@ import {
 	type RpcResponse,
 	SessionManager,
 } from "@earendil-works/pi-coding-agent";
+import { radiusPresence } from "./radius.ts";
 import { handleRpcCommand } from "./rpc-bridge.ts";
 import { getInstance, loadInstances, removeInstance, upsertInstance } from "./storage.ts";
 import type { InstanceRecord } from "./types.ts";
@@ -25,7 +26,7 @@ function cloneInstance(record: InstanceRecord): InstanceRecord {
 
 async function createRuntime(cwd: string): Promise<AgentSessionRuntime> {
 	const agentDir = getAgentDir();
-	const sessionManager = SessionManager.inMemory(cwd);
+	const sessionManager = SessionManager.create(cwd);
 	const runtimeFactory: CreateAgentSessionRuntimeFactory = async ({
 		cwd,
 		agentDir,
@@ -79,11 +80,13 @@ export class OrchestratorSupervisor {
 			lastSeenAt: now,
 			label: options.label,
 			sessionId: runtime.session.sessionId,
+			sessionFile: runtime.session.sessionFile,
 		};
 
-		this.liveInstances.set(record.id, { runtime, record });
-		upsertInstance(record);
-		return cloneInstance(record);
+		const registeredRecord = await radiusPresence.registerPi(record);
+		this.liveInstances.set(registeredRecord.id, { runtime, record: registeredRecord });
+		upsertInstance(registeredRecord);
+		return cloneInstance(registeredRecord);
 	}
 
 	async stopInstance(instanceId: string): Promise<InstanceRecord | undefined> {
@@ -92,6 +95,7 @@ export class OrchestratorSupervisor {
 			return undefined;
 		}
 
+		await radiusPresence.disconnectPi(live.record);
 		await live.runtime.dispose();
 		this.liveInstances.delete(instanceId);
 		removeInstance(instanceId);
diff --git a/packages/orchestrator/src/types.ts b/packages/orchestrator/src/types.ts
index d2e4d06e..c4738ccc 100644
--- a/packages/orchestrator/src/types.ts
+++ b/packages/orchestrator/src/types.ts
@@ -15,4 +15,6 @@ export interface InstanceRecord {
 	lastSeenAt?: string;
 	label?: string;
 	sessionId?: string;
+	sessionFile?: string;
+	radiusPiId?: string;
 }

From a6d88ddc3a546691d94d943d87c51edae175bebf Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:16:03 +0200
Subject: [PATCH 14/36] fix: use raius pi id for persistence

---
 packages/orchestrator/src/handler.ts      |  1 +
 packages/orchestrator/src/ipc/protocol.ts |  1 +
 packages/orchestrator/src/radius.ts       | 78 ++++++++++++++++-------
 packages/orchestrator/src/serve.ts        | 48 ++++++++------
 packages/orchestrator/src/storage.ts      | 10 ++-
 packages/orchestrator/src/supervisor.ts   | 21 +++++-
 packages/orchestrator/src/types.ts        |  5 ++
 7 files changed, 119 insertions(+), 45 deletions(-)

diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 35ed49b9..bfac58a3 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -25,6 +25,7 @@ function toInstanceSummary(instance: InstanceRecord): InstanceSummary {
 		label: instance.label,
 		sessionId: instance.sessionId,
 		sessionFile: instance.sessionFile,
+		radiusPiId: instance.radiusPiId,
 	};
 }
 
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 8c194c32..796418ab 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -46,6 +46,7 @@ export interface InstanceSummary {
 	label?: string;
 	sessionId?: string;
 	sessionFile?: string;
+	radiusPiId?: string;
 }
 
 export interface ResponseBase {
diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index f3aaacb5..39a9237a 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -1,21 +1,18 @@
 import { hostname, platform } from "node:os";
 import { getOrchestratorDir, getSocketPath } from "./config.ts";
 import { loadMachine, saveMachine } from "./storage.ts";
-import type { InstanceRecord, MachineRecord } from "./types.ts";
+import type { InstanceRecord, MachineRecord, RadiusRegistration } from "./types.ts";
 
 const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
 const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
+const ORCHESTRATOR_VERSION = "0.79.6";
 
-interface RegisterMachineResponse {
+interface RegisterMachineResponse extends RadiusRegistration {
 	id: string;
-	heartbeatIntervalMs: number;
-	expiresInMs: number;
 }
 
-interface RegisterPiResponse {
+interface RegisterPiResponse extends RadiusRegistration {
 	id: string;
-	heartbeatIntervalMs: number;
-	expiresInMs: number;
 }
 
 async function post<T>(path: string, body: unknown): Promise<T> {
@@ -35,8 +32,8 @@ async function post<T>(path: string, body: unknown): Promise<T> {
 	return (await response.json()) as T;
 }
 
-function maybePost(path: string, body: unknown): Promise<Response> {
-	return fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
+async function maybePost(path: string, body: unknown): Promise<void> {
+	const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
 		method: "POST",
 		headers: {
 			Authorization: `Bearer ${getRadiusApiKey()}`,
@@ -44,6 +41,9 @@ function maybePost(path: string, body: unknown): Promise<Response> {
 		},
 		body: JSON.stringify(body),
 	});
+	if (!response.ok) {
+		throw new Error(`Radius request failed: ${response.status} ${await response.text()}`);
+	}
 }
 
 export function getRadiusUrl(): string {
@@ -72,7 +72,8 @@ export function isRadiusEnabled(): boolean {
 }
 
 export class RadiusPresence {
-	private heartbeatTimer?: NodeJS.Timeout;
+	private machineHeartbeatTimer?: NodeJS.Timeout;
+	private readonly piHeartbeatTimers = new Map<string, NodeJS.Timeout>();
 	private machine?: MachineRecord;
 
 	async start(label?: string): Promise<MachineRecord | undefined> {
@@ -80,39 +81,44 @@ export class RadiusPresence {
 			return undefined;
 		}
 
-		const registered = await post<RegisterMachineResponse>("/v1/machines/register", {
+		const existingMachine = loadMachine();
+		const registered = await post<RegisterMachineResponse>("machines/register", {
+			machineId: existingMachine?.id,
 			label,
 			hostname: hostname(),
 			platform: platform(),
 			arch: process.arch,
-			version: "0.79.6",
+			version: ORCHESTRATOR_VERSION,
 			capabilities: { spawn: true, relay: false, iroh: false },
 		});
 
-		const now = new Date().toISOString();
+		const timestamp = new Date().toISOString();
 		this.machine = {
 			id: registered.id,
-			createdAt: now,
-			lastSeenAt: now,
+			createdAt: existingMachine?.createdAt ?? timestamp,
+			lastSeenAt: timestamp,
 			label,
 		};
 		saveMachine(this.machine);
-		this.heartbeatTimer = setInterval(() => {
+		this.machineHeartbeatTimer = setInterval(() => {
 			void this.heartbeatMachine();
 		}, registered.heartbeatIntervalMs);
 		return this.machine;
 	}
 
 	async stop(): Promise<void> {
-		if (this.heartbeatTimer) {
-			clearInterval(this.heartbeatTimer);
-			this.heartbeatTimer = undefined;
+		if (this.machineHeartbeatTimer) {
+			clearInterval(this.machineHeartbeatTimer);
+			this.machineHeartbeatTimer = undefined;
+		}
+		for (const [instanceId, timer] of this.piHeartbeatTimers) {
+			clearInterval(timer);
+			this.piHeartbeatTimers.delete(instanceId);
 		}
 		if (!this.machine || !isRadiusEnabled()) {
 			return;
 		}
-		await maybePost(`/v1/machines/${this.machine.id}/disconnect`, {});
-		this.machine = undefined;
+		await maybePost(`machines/${this.machine.id}/disconnect`, {});
 	}
 
 	async registerPi(instance: InstanceRecord): Promise<InstanceRecord> {
@@ -123,7 +129,7 @@ export class RadiusPresence {
 		if (!machine) {
 			throw new Error("No registered machine available for Pi registration");
 		}
-		const registered = await post<RegisterPiResponse>("/v1/pis/register", {
+		const registered = await post<RegisterPiResponse>("pis/register", {
 			machineId: machine.id,
 			label: instance.label,
 			cwd: instance.cwd,
@@ -133,25 +139,49 @@ export class RadiusPresence {
 			capabilities: { rpc: true, relay: false, iroh: false },
 			sessionId: instance.sessionId,
 		});
+		this.startPiHeartbeat(instance.id, registered.heartbeatIntervalMs, registered.id);
 		return { ...instance, radiusPiId: registered.id };
 	}
 
 	async disconnectPi(instance: InstanceRecord): Promise<void> {
+		const timer = this.piHeartbeatTimers.get(instance.id);
+		if (timer) {
+			clearInterval(timer);
+			this.piHeartbeatTimers.delete(instance.id);
+		}
 		if (!isRadiusEnabled() || !instance.radiusPiId) {
 			return;
 		}
-		await maybePost(`/v1/pis/${instance.radiusPiId}/disconnect`, {});
+		await maybePost(`pis/${instance.radiusPiId}/disconnect`, {});
+	}
+
+	private startPiHeartbeat(instanceId: string, intervalMs: number, radiusPiId: string): void {
+		const existingTimer = this.piHeartbeatTimers.get(instanceId);
+		if (existingTimer) {
+			clearInterval(existingTimer);
+		}
+		const timer = setInterval(() => {
+			void this.heartbeatPi(radiusPiId);
+		}, intervalMs);
+		this.piHeartbeatTimers.set(instanceId, timer);
 	}
 
 	private async heartbeatMachine(): Promise<void> {
 		if (!this.machine || !isRadiusEnabled()) {
 			return;
 		}
-		await maybePost(`/v1/machines/${this.machine.id}/heartbeat`, {
+		await maybePost(`machines/${this.machine.id}/heartbeat`, {
 			cwd: getOrchestratorDir(),
 			socketPath: getSocketPath(),
 		});
 	}
+
+	private async heartbeatPi(radiusPiId: string): Promise<void> {
+		if (!isRadiusEnabled()) {
+			return;
+		}
+		await maybePost(`pis/${radiusPiId}/heartbeat`, {});
+	}
 }
 
 export const radiusPresence = new RadiusPresence();
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index 97b07676..42d785bc 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -4,47 +4,57 @@ import { getSocketPath } from "./config.ts";
 import { handleIpcRequest } from "./handler.ts";
 import { startIpcServer } from "./ipc/server.ts";
 import { getRadiusOrchestratorBaseUrl, isRadiusEnabled, radiusPresence } from "./radius.ts";
+import { supervisor } from "./supervisor.ts";
 
 export async function serve(): Promise<void> {
 	const socketPath = getSocketPath();
 	mkdirSync(dirname(socketPath), { recursive: true });
+	await supervisor.recoverAfterRestart();
 	if (isRadiusEnabled()) {
-		await radiusPresence.start();
+		const machine = await radiusPresence.start();
 		console.log(`radius integration enabled: ${socketPath} -> ${getRadiusOrchestratorBaseUrl()}`);
+		if (machine) {
+			console.log(`radius machine id: ${machine.id}`);
+		}
 	} else {
 		console.log("radius integration disabled: set PI_RADIUS_API_KEY to enable");
 	}
 	const server = await startIpcServer(handleIpcRequest);
 	console.log(`orchestrator listening on ${socketPath}`);
 
-	let cleanedUp = false;
-	const cleanup = () => {
-		if (cleanedUp) {
-			return;
+	let shutdownPromise: Promise<void> | undefined;
+	const shutdown = async (exitCode: number) => {
+		if (shutdownPromise) {
+			await shutdownPromise;
+			process.exit(exitCode);
 		}
-		cleanedUp = true;
-		server.close();
-		void radiusPresence.stop();
-		if (existsSync(socketPath)) {
-			unlinkSync(socketPath);
-		}
-	};
 
-	const shutdown = (exitCode: number) => {
-		cleanup();
+		shutdownPromise = (async () => {
+			server.close();
+			await supervisor.shutdown();
+			await radiusPresence.stop();
+			if (existsSync(socketPath)) {
+				unlinkSync(socketPath);
+			}
+		})();
+
+		await shutdownPromise;
 		process.exit(exitCode);
 	};
 
-	process.on("SIGINT", () => shutdown(0));
-	process.on("SIGTERM", () => shutdown(0));
-	process.on("exit", cleanup);
+	process.on("SIGINT", () => {
+		void shutdown(0);
+	});
+	process.on("SIGTERM", () => {
+		void shutdown(0);
+	});
 	process.on("uncaughtException", (error) => {
 		console.error(error);
-		shutdown(1);
+		void shutdown(1);
 	});
 	process.on("unhandledRejection", (reason) => {
 		console.error(reason);
-		shutdown(1);
+		void shutdown(1);
 	});
 
 	await new Promise<void>(() => {
diff --git a/packages/orchestrator/src/storage.ts b/packages/orchestrator/src/storage.ts
index 29eb3213..7c75f185 100644
--- a/packages/orchestrator/src/storage.ts
+++ b/packages/orchestrator/src/storage.ts
@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { getInstancesPath, getMachinePath, getOrchestratorDir } from "./config.ts";
 import type { InstanceRecord, MachineRecord } from "./types.ts";
 
@@ -24,6 +24,14 @@ export function saveMachine(machine: MachineRecord): void {
 	writeFileSync(getMachinePath(), JSON.stringify(machine, null, 2));
 }
 
+export function deleteMachine(): void {
+	const machinePath = getMachinePath();
+	if (!existsSync(machinePath)) {
+		return;
+	}
+	rmSync(machinePath);
+}
+
 export function loadInstances(): InstanceRecord[] {
 	const instancesPath = getInstancesPath();
 	if (!existsSync(instancesPath)) {
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index d99db09a..38b4025a 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -12,7 +12,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { radiusPresence } from "./radius.ts";
 import { handleRpcCommand } from "./rpc-bridge.ts";
-import { getInstance, loadInstances, removeInstance, upsertInstance } from "./storage.ts";
+import { getInstance, loadInstances, removeInstance, saveInstances, upsertInstance } from "./storage.ts";
 import type { InstanceRecord } from "./types.ts";
 
 interface LiveInstance {
@@ -56,6 +56,19 @@ async function createRuntime(cwd: string): Promise<AgentSessionRuntime> {
 export class OrchestratorSupervisor {
 	private readonly liveInstances = new Map<string, LiveInstance>();
 
+	async recoverAfterRestart(): Promise<void> {
+		const recoveredAt = new Date().toISOString();
+		const instances = loadInstances().map((instance) => ({
+			...instance,
+			status: instance.status === "online" || instance.status === "starting" ? "stopped" : instance.status,
+			lastSeenAt: recoveredAt,
+		}));
+		for (const instance of instances) {
+			await radiusPresence.disconnectPi(instance);
+		}
+		saveInstances(instances);
+	}
+
 	listInstances(): InstanceRecord[] {
 		return loadInstances().map(cloneInstance);
 	}
@@ -110,6 +123,12 @@ export class OrchestratorSupervisor {
 
 		return handleRpcCommand(live.runtime, command);
 	}
+
+	async shutdown(): Promise<void> {
+		for (const instanceId of [...this.liveInstances.keys()]) {
+			await this.stopInstance(instanceId);
+		}
+	}
 }
 
 export const supervisor = new OrchestratorSupervisor();
diff --git a/packages/orchestrator/src/types.ts b/packages/orchestrator/src/types.ts
index c4738ccc..847b2943 100644
--- a/packages/orchestrator/src/types.ts
+++ b/packages/orchestrator/src/types.ts
@@ -7,6 +7,11 @@ export interface MachineRecord {
 	label?: string;
 }
 
+export interface RadiusRegistration {
+	heartbeatIntervalMs: number;
+	expiresInMs: number;
+}
+
 export interface InstanceRecord {
 	id: string;
 	status: InstanceStatus;

From f1d9f762981aec27dd52ad7501ae2f7b1fd45d50 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:31:59 +0200
Subject: [PATCH 15/36] fix: heartbeat 3 404s re-register, if still fails
 disconnect

---
 packages/orchestrator/src/radius.ts     | 222 +++++++++++++++++++-----
 packages/orchestrator/src/supervisor.ts |  29 ++++
 2 files changed, 207 insertions(+), 44 deletions(-)

diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index 39a9237a..b737f5ac 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -6,6 +6,7 @@ import type { InstanceRecord, MachineRecord, RadiusRegistration } from "./types.
 const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
 const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
 const ORCHESTRATOR_VERSION = "0.79.6";
+const NOT_FOUND_RETRY_THRESHOLD = 3;
 
 interface RegisterMachineResponse extends RadiusRegistration {
 	id: string;
@@ -15,6 +16,28 @@ interface RegisterPiResponse extends RadiusRegistration {
 	id: string;
 }
 
+interface RadiusPresenceCoordinator {
+	getLiveInstance(instanceId: string): InstanceRecord | undefined;
+	listLiveInstances(): InstanceRecord[];
+	updateInstance(instance: InstanceRecord): void;
+}
+
+interface PiHeartbeatState {
+	timer: NodeJS.Timeout;
+	radiusPiId: string;
+	consecutiveNotFoundCount: number;
+}
+
+class RadiusHttpError extends Error {
+	readonly status: number;
+
+	constructor(status: number, message: string) {
+		super(message);
+		this.name = "RadiusHttpError";
+		this.status = status;
+	}
+}
+
 async function post<T>(path: string, body: unknown): Promise<T> {
 	const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
 		method: "POST",
@@ -26,7 +49,7 @@ async function post<T>(path: string, body: unknown): Promise<T> {
 	});
 
 	if (!response.ok) {
-		throw new Error(`Radius request failed: ${response.status} ${await response.text()}`);
+		throw new RadiusHttpError(response.status, `Radius request failed: ${response.status} ${await response.text()}`);
 	}
 
 	return (await response.json()) as T;
@@ -42,10 +65,14 @@ async function maybePost(path: string, body: unknown): Promise<void> {
 		body: JSON.stringify(body),
 	});
 	if (!response.ok) {
-		throw new Error(`Radius request failed: ${response.status} ${await response.text()}`);
+		throw new RadiusHttpError(response.status, `Radius request failed: ${response.status} ${await response.text()}`);
 	}
 }
 
+function isNotFoundError(error: unknown): error is RadiusHttpError {
+	return error instanceof RadiusHttpError && error.status === 404;
+}
+
 export function getRadiusUrl(): string {
 	return process.env.PI_RADIUS_URL || DEFAULT_RADIUS_URL;
 }
@@ -73,36 +100,22 @@ export function isRadiusEnabled(): boolean {
 
 export class RadiusPresence {
 	private machineHeartbeatTimer?: NodeJS.Timeout;
-	private readonly piHeartbeatTimers = new Map<string, NodeJS.Timeout>();
+	private machineConsecutiveNotFoundCount = 0;
+	private readonly piHeartbeatStates = new Map<string, PiHeartbeatState>();
 	private machine?: MachineRecord;
+	private coordinator?: RadiusPresenceCoordinator;
+
+	setCoordinator(coordinator: RadiusPresenceCoordinator): void {
+		this.coordinator = coordinator;
+	}
 
 	async start(label?: string): Promise<MachineRecord | undefined> {
 		if (!isRadiusEnabled()) {
 			return undefined;
 		}
 
-		const existingMachine = loadMachine();
-		const registered = await post<RegisterMachineResponse>("machines/register", {
-			machineId: existingMachine?.id,
-			label,
-			hostname: hostname(),
-			platform: platform(),
-			arch: process.arch,
-			version: ORCHESTRATOR_VERSION,
-			capabilities: { spawn: true, relay: false, iroh: false },
-		});
-
-		const timestamp = new Date().toISOString();
-		this.machine = {
-			id: registered.id,
-			createdAt: existingMachine?.createdAt ?? timestamp,
-			lastSeenAt: timestamp,
-			label,
-		};
-		saveMachine(this.machine);
-		this.machineHeartbeatTimer = setInterval(() => {
-			void this.heartbeatMachine();
-		}, registered.heartbeatIntervalMs);
+		const registered = await this.registerMachine(label);
+		this.startMachineHeartbeat(registered.heartbeatIntervalMs);
 		return this.machine;
 	}
 
@@ -111,9 +124,9 @@ export class RadiusPresence {
 			clearInterval(this.machineHeartbeatTimer);
 			this.machineHeartbeatTimer = undefined;
 		}
-		for (const [instanceId, timer] of this.piHeartbeatTimers) {
-			clearInterval(timer);
-			this.piHeartbeatTimers.delete(instanceId);
+		for (const [instanceId, state] of this.piHeartbeatStates) {
+			clearInterval(state.timer);
+			this.piHeartbeatStates.delete(instanceId);
 		}
 		if (!this.machine || !isRadiusEnabled()) {
 			return;
@@ -139,15 +152,16 @@ export class RadiusPresence {
 			capabilities: { rpc: true, relay: false, iroh: false },
 			sessionId: instance.sessionId,
 		});
+		const registeredInstance = { ...instance, radiusPiId: registered.id };
 		this.startPiHeartbeat(instance.id, registered.heartbeatIntervalMs, registered.id);
-		return { ...instance, radiusPiId: registered.id };
+		return registeredInstance;
 	}
 
 	async disconnectPi(instance: InstanceRecord): Promise<void> {
-		const timer = this.piHeartbeatTimers.get(instance.id);
-		if (timer) {
-			clearInterval(timer);
-			this.piHeartbeatTimers.delete(instance.id);
+		const state = this.piHeartbeatStates.get(instance.id);
+		if (state) {
+			clearInterval(state.timer);
+			this.piHeartbeatStates.delete(instance.id);
 		}
 		if (!isRadiusEnabled() || !instance.radiusPiId) {
 			return;
@@ -155,32 +169,152 @@ export class RadiusPresence {
 		await maybePost(`pis/${instance.radiusPiId}/disconnect`, {});
 	}
 
+	private async registerMachine(label?: string): Promise<RegisterMachineResponse> {
+		const existingMachine = this.machine ?? loadMachine();
+		const registered = await post<RegisterMachineResponse>("machines/register", {
+			machineId: existingMachine?.id,
+			label,
+			hostname: hostname(),
+			platform: platform(),
+			arch: process.arch,
+			version: ORCHESTRATOR_VERSION,
+			capabilities: { spawn: true, relay: false, iroh: false },
+		});
+
+		const timestamp = new Date().toISOString();
+		this.machine = {
+			id: registered.id,
+			createdAt: existingMachine?.createdAt ?? timestamp,
+			lastSeenAt: timestamp,
+			label,
+		};
+		saveMachine(this.machine);
+		this.machineConsecutiveNotFoundCount = 0;
+		return registered;
+	}
+
+	private startMachineHeartbeat(intervalMs: number): void {
+		if (this.machineHeartbeatTimer) {
+			clearInterval(this.machineHeartbeatTimer);
+		}
+		this.machineHeartbeatTimer = setInterval(() => {
+			void this.heartbeatMachine();
+		}, intervalMs);
+	}
+
 	private startPiHeartbeat(instanceId: string, intervalMs: number, radiusPiId: string): void {
-		const existingTimer = this.piHeartbeatTimers.get(instanceId);
-		if (existingTimer) {
-			clearInterval(existingTimer);
+		const existingState = this.piHeartbeatStates.get(instanceId);
+		if (existingState) {
+			clearInterval(existingState.timer);
 		}
 		const timer = setInterval(() => {
-			void this.heartbeatPi(radiusPiId);
+			void this.heartbeatPi(instanceId);
 		}, intervalMs);
-		this.piHeartbeatTimers.set(instanceId, timer);
+		this.piHeartbeatStates.set(instanceId, {
+			timer,
+			radiusPiId,
+			consecutiveNotFoundCount: 0,
+		});
 	}
 
 	private async heartbeatMachine(): Promise<void> {
 		if (!this.machine || !isRadiusEnabled()) {
 			return;
 		}
-		await maybePost(`machines/${this.machine.id}/heartbeat`, {
-			cwd: getOrchestratorDir(),
-			socketPath: getSocketPath(),
-		});
+
+		try {
+			await maybePost(`machines/${this.machine.id}/heartbeat`, {
+				cwd: getOrchestratorDir(),
+				socketPath: getSocketPath(),
+			});
+			this.machineConsecutiveNotFoundCount = 0;
+		} catch (error) {
+			if (!isNotFoundError(error)) {
+				console.error("Radius machine heartbeat failed", error);
+				return;
+			}
+
+			this.machineConsecutiveNotFoundCount += 1;
+			if (this.machineConsecutiveNotFoundCount < NOT_FOUND_RETRY_THRESHOLD) {
+				return;
+			}
+
+			try {
+				await this.reRegisterMachineAndPis();
+			} catch (recoveryError) {
+				console.error("Radius machine re-registration failed", recoveryError);
+			}
+		}
 	}
 
-	private async heartbeatPi(radiusPiId: string): Promise<void> {
+	private async heartbeatPi(instanceId: string): Promise<void> {
 		if (!isRadiusEnabled()) {
 			return;
 		}
-		await maybePost(`pis/${radiusPiId}/heartbeat`, {});
+
+		const state = this.piHeartbeatStates.get(instanceId);
+		if (!state) {
+			return;
+		}
+
+		try {
+			await maybePost(`pis/${state.radiusPiId}/heartbeat`, {});
+			state.consecutiveNotFoundCount = 0;
+		} catch (error) {
+			if (!isNotFoundError(error)) {
+				console.error(`Radius Pi heartbeat failed for instance ${instanceId}`, error);
+				return;
+			}
+
+			state.consecutiveNotFoundCount += 1;
+			if (state.consecutiveNotFoundCount < NOT_FOUND_RETRY_THRESHOLD) {
+				return;
+			}
+
+			try {
+				const recovered = await this.reRegisterPi(instanceId);
+				if (!recovered) {
+					console.error(`Radius Pi re-registration skipped for instance ${instanceId}`);
+				}
+			} catch (recoveryError) {
+				console.error(`Radius Pi re-registration failed for instance ${instanceId}`, recoveryError);
+			}
+		}
+	}
+
+	private async reRegisterMachineAndPis(): Promise<void> {
+		const registered = await this.registerMachine(this.machine?.label);
+		this.startMachineHeartbeat(registered.heartbeatIntervalMs);
+
+		const instances = this.coordinator?.listLiveInstances() ?? [];
+		for (const instance of instances) {
+			try {
+				await this.reRegisterPi(instance.id);
+			} catch (error) {
+				console.error(`Radius Pi re-registration failed for instance ${instance.id}`, error);
+			}
+		}
+	}
+
+	private async reRegisterPi(instanceId: string): Promise<boolean> {
+		const instance = this.coordinator?.getLiveInstance(instanceId);
+		if (!instance) {
+			const state = this.piHeartbeatStates.get(instanceId);
+			if (state) {
+				clearInterval(state.timer);
+				this.piHeartbeatStates.delete(instanceId);
+			}
+			return false;
+		}
+
+		if (!this.machine) {
+			await this.reRegisterMachineAndPis();
+			return true;
+		}
+
+		const registeredInstance = await this.registerPi(instance);
+		this.coordinator?.updateInstance(registeredInstance);
+		return true;
 	}
 }
 
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 38b4025a..88f5a752 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -56,6 +56,23 @@ async function createRuntime(cwd: string): Promise<AgentSessionRuntime> {
 export class OrchestratorSupervisor {
 	private readonly liveInstances = new Map<string, LiveInstance>();
 
+	updateInstance(instance: InstanceRecord): void {
+		const live = this.liveInstances.get(instance.id);
+		if (live) {
+			live.record = instance;
+		}
+		upsertInstance(instance);
+	}
+
+	getLiveInstance(instanceId: string): InstanceRecord | undefined {
+		const live = this.liveInstances.get(instanceId);
+		return live ? cloneInstance(live.record) : undefined;
+	}
+
+	listLiveInstances(): InstanceRecord[] {
+		return [...this.liveInstances.values()].map((live) => cloneInstance(live.record));
+	}
+
 	async recoverAfterRestart(): Promise<void> {
 		const recoveredAt = new Date().toISOString();
 		const instances = loadInstances().map((instance) => ({
@@ -132,3 +149,15 @@ export class OrchestratorSupervisor {
 }
 
 export const supervisor = new OrchestratorSupervisor();
+
+radiusPresence.setCoordinator({
+	getLiveInstance(instanceId) {
+		return supervisor.getLiveInstance(instanceId);
+	},
+	listLiveInstances() {
+		return supervisor.listLiveInstances();
+	},
+	updateInstance(instance) {
+		supervisor.updateInstance(instance);
+	},
+});

From 5cb528428a47e4159d3ed3fa5bf441fa0d24749b Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:39:14 +0200
Subject: [PATCH 16/36] fix: bridge missing rpc commands

---
 packages/orchestrator/src/cli.ts          | 48 ++++++++++++++-
 packages/orchestrator/src/handler.ts      | 38 ++++++++++++
 packages/orchestrator/src/ipc/protocol.ts | 33 ++++++++++-
 packages/orchestrator/src/ipc/server.ts   | 72 +++++++++++++++++++++++
 packages/orchestrator/src/rpc-bridge.ts   | 58 +++++++++++++-----
 packages/orchestrator/src/serve.ts        |  8 ++-
 packages/orchestrator/src/supervisor.ts   | 58 +++++++++++++++++-
 7 files changed, 294 insertions(+), 21 deletions(-)

diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index 13be25a5..02fb3caa 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
+import { createConnection } from "node:net";
 import { dirname, join } from "node:path";
 import { cwd } from "node:process";
 import { fileURLToPath } from "node:url";
+import { getSocketPath } from "./config.ts";
 import { sendIpcRequest } from "./ipc/client.ts";
+import { encodeMessage } from "./ipc/protocol.ts";
 import { serve } from "./serve.ts";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -14,7 +17,7 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 
 function printHelp(): void {
 	console.log(
-		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator --help\n  orchestrator --version`,
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator attach <instance-id>\n  orchestrator --help\n  orchestrator --version`,
 	);
 }
 
@@ -30,6 +33,39 @@ function getFlagValue(args: string[], flag: string): string | undefined {
 	return args[index + 1];
 }
 
+async function attach(instanceId: string): Promise<void> {
+	const socket = createConnection(getSocketPath());
+	process.stdin.setEncoding("utf8");
+
+	await new Promise<void>((resolve, reject) => {
+		socket.once("connect", () => {
+			socket.write(encodeMessage({ type: "attach", instanceId }));
+			resolve();
+		});
+		socket.once("error", reject);
+	});
+
+	socket.on("data", (chunk: Buffer | string) => {
+		process.stdout.write(chunk.toString());
+	});
+	socket.on("error", (error) => {
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	});
+	socket.on("end", () => {
+		process.exit(0);
+	});
+	process.stdin.on("data", (chunk: string) => {
+		const lines = chunk
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0);
+		for (const line of lines) {
+			socket.write(encodeMessage({ type: "attach_rpc", command: JSON.parse(line) }));
+		}
+	});
+}
+
 async function main(): Promise<void> {
 	const args = process.argv.slice(2);
 
@@ -97,6 +133,16 @@ async function main(): Promise<void> {
 		return;
 	}
 
+	if (args[0] === "attach") {
+		const instanceId = args[1];
+		if (!instanceId) {
+			console.error("Usage: orchestrator attach <instance-id>");
+			process.exit(1);
+		}
+		await attach(instanceId);
+		return;
+	}
+
 	console.error(`Unknown command: ${args[0]}`);
 	printHelp();
 	process.exit(1);
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index bfac58a3..382030c5 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -1,4 +1,8 @@
+import type { AgentSessionEvent, RpcCommand } from "@earendil-works/pi-coding-agent";
 import type {
+	AttachReadyResponse,
+	AttachRequest,
+	AttachRpcResponse,
 	ErrorResponse,
 	InstanceSummary,
 	ListRequest,
@@ -43,6 +47,7 @@ export async function handleIpcRequest(request: ListRequest): Promise<ListRespon
 export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
 export async function handleIpcRequest(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse>;
+export async function handleIpcRequest(request: AttachRequest): Promise<AttachReadyResponse | ErrorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
 	switch (request.type) {
@@ -104,5 +109,38 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 				response,
 			};
 		}
+
+		case "attach": {
+			const instance = supervisor.getInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+			return {
+				type: "attach_ready",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
 	}
 }
+
+export function attachIpcInstance(
+	instanceId: string,
+	onResponse: (response: AttachRpcResponse) => void,
+	onSessionEvent: (event: AgentSessionEvent) => void,
+): { handleRequest(request: { type: "attach_rpc"; command: RpcCommand }): Promise<void>; close(): void } | undefined {
+	const handle = supervisor.attachInstance(instanceId, onSessionEvent);
+	if (!handle) {
+		return undefined;
+	}
+
+	return {
+		async handleRequest(request): Promise<void> {
+			const response = await handle.handleRpc(request.command);
+			onResponse({ type: "attach_rpc_result", response });
+		},
+		close(): void {
+			handle.close();
+		},
+	};
+}
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 796418ab..09744a73 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -1,4 +1,4 @@
-import type { RpcCommand, RpcResponse } from "@earendil-works/pi-coding-agent";
+import type { AgentSessionEvent, RpcCommand, RpcResponse } from "@earendil-works/pi-coding-agent";
 import type { InstanceStatus } from "../types.ts";
 
 export interface SpawnRequest {
@@ -29,12 +29,23 @@ export interface RpcRequest {
 	command: RpcCommand;
 }
 
+export interface AttachRequest {
+	type: "attach";
+	instanceId: string;
+}
+
+export interface AttachRpcRequest {
+	type: "attach_rpc";
+	command: RpcCommand;
+}
+
 export interface RequestMap {
 	spawn: SpawnRequest;
 	list: ListRequest;
 	stop: StopRequest;
 	status: StatusRequest;
 	rpc: RpcRequest;
+	attach: AttachRequest;
 }
 
 export type OrchestratorRequest = RequestMap[keyof RequestMap];
@@ -79,6 +90,21 @@ export interface RpcBridgeResponse extends ResponseBase {
 	response: RpcResponse;
 }
 
+export interface AttachReadyResponse extends ResponseBase {
+	type: "attach_ready";
+	instance?: InstanceSummary;
+}
+
+export interface AttachEventResponse {
+	type: "attach_event";
+	event: AgentSessionEvent;
+}
+
+export interface AttachRpcResponse {
+	type: "attach_rpc_result";
+	response: RpcResponse;
+}
+
 export interface ErrorResponse extends ResponseBase {
 	type: "error";
 	ok: false;
@@ -91,9 +117,12 @@ export interface ResponseMap {
 	stop: StopResponse;
 	status: StatusResponse;
 	rpc: RpcBridgeResponse;
+	attach: AttachReadyResponse;
 }
 
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
+export type AttachClientRequest = AttachRpcRequest;
+export type AttachServerResponse = AttachReadyResponse | AttachEventResponse | AttachRpcResponse | ErrorResponse;
 
 export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer K }
 	? K extends keyof ResponseMap
@@ -101,7 +130,7 @@ export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer
 		: ErrorResponse
 	: ErrorResponse;
 
-export function encodeMessage(message: OrchestratorRequest | OrchestratorResponse): string {
+export function encodeMessage(message: unknown): string {
 	return `${JSON.stringify(message)}\n`;
 }
 
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 7138a492..2dce45d0 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -2,6 +2,10 @@ import { existsSync, unlinkSync } from "node:fs";
 import { createConnection, createServer, type Server } from "node:net";
 import { getSocketPath } from "../config.ts";
 import {
+	type AttachClientRequest,
+	type AttachReadyResponse,
+	type AttachRequest,
+	type AttachRpcResponse,
 	type ErrorResponse,
 	encodeMessage,
 	type ListRequest,
@@ -25,7 +29,18 @@ export interface IpcRequestHandler {
 	(request: StopRequest): Promise<StopResponse | ErrorResponse> | StopResponse | ErrorResponse;
 	(request: StatusRequest): Promise<StatusResponse | ErrorResponse> | StatusResponse | ErrorResponse;
 	(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse> | RpcBridgeResponse | ErrorResponse;
+	(request: AttachRequest): Promise<AttachReadyResponse | ErrorResponse> | AttachReadyResponse | ErrorResponse;
 	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
+	attach(
+		instanceId: string,
+		onEvent: (response: AttachRpcResponse) => void,
+		onSessionEvent: (event: import("@earendil-works/pi-coding-agent").AgentSessionEvent) => void,
+	):
+		| {
+				handleRequest(request: AttachClientRequest): Promise<void>;
+				close(): void;
+		  }
+		| undefined;
 }
 
 export async function startIpcServer(handler: IpcRequestHandler): Promise<Server> {
@@ -50,6 +65,63 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 
 			try {
 				const request = parseRequestLine(line);
+				if (request.type === "attach") {
+					const response = await handler(request);
+					if (!response.ok || !response.instance) {
+						socket.end(encodeMessage(response));
+						return;
+					}
+
+					const attachment = handler.attach(
+						request.instanceId,
+						(response) => {
+							socket.write(encodeMessage(response));
+						},
+						(event) => {
+							socket.write(encodeMessage({ type: "attach_event", event }));
+						},
+					);
+					if (!attachment) {
+						socket.end(
+							encodeMessage({ type: "error", ok: false, error: `Unknown instance: ${request.instanceId}` }),
+						);
+						return;
+					}
+
+					socket.write(encodeMessage(response));
+					socket.removeAllListeners("data");
+					socket.on("data", (attachChunk: Buffer | string) => {
+						buffer += attachChunk.toString();
+						for (;;) {
+							const attachNewlineIndex = buffer.indexOf("\n");
+							if (attachNewlineIndex === -1) {
+								break;
+							}
+							const attachLine = buffer.slice(0, attachNewlineIndex).trim();
+							buffer = buffer.slice(attachNewlineIndex + 1);
+							if (!attachLine) {
+								continue;
+							}
+							void (async () => {
+								try {
+									const attachRequest = JSON.parse(attachLine) as AttachClientRequest;
+									await attachment.handleRequest(attachRequest);
+								} catch (attachError) {
+									socket.write(
+										encodeMessage({
+											type: "error",
+											ok: false,
+											error: attachError instanceof Error ? attachError.message : String(attachError),
+										}),
+									);
+								}
+							})();
+						}
+					});
+					socket.once("close", () => attachment.close());
+					return;
+				}
+
 				const response = await handler(request);
 				socket.end(encodeMessage(response));
 			} catch (error) {
diff --git a/packages/orchestrator/src/rpc-bridge.ts b/packages/orchestrator/src/rpc-bridge.ts
index 84df33fd..4f549c10 100644
--- a/packages/orchestrator/src/rpc-bridge.ts
+++ b/packages/orchestrator/src/rpc-bridge.ts
@@ -11,22 +11,33 @@ function error(id: string | undefined, command: string, message: string): RpcRes
 	return { id, type: "response", command, success: false, error: message };
 }
 
-function unsupported(id: string | undefined, command: RpcCommand["type"]): RpcResponse {
-	return error(id, command, `Unsupported RPC command in orchestrator bridge: ${command}`);
-}
-
 export async function handleRpcCommand(runtime: AgentSessionRuntime, command: RpcCommand): Promise<RpcResponse> {
 	const session = runtime.session;
 	const id = command.id;
 
 	switch (command.type) {
 		case "prompt": {
-			await session.prompt(command.message, {
-				images: command.images,
-				streamingBehavior: command.streamingBehavior,
-				source: "rpc",
+			return await new Promise<RpcResponse>((resolve) => {
+				let settled = false;
+				void session
+					.prompt(command.message, {
+						images: command.images,
+						streamingBehavior: command.streamingBehavior,
+						source: "rpc",
+						preflightResult: (didSucceed) => {
+							if (!settled && didSucceed) {
+								settled = true;
+								resolve(success(id, "prompt"));
+							}
+						},
+					})
+					.catch((rpcError: unknown) => {
+						if (!settled) {
+							settled = true;
+							resolve(error(id, "prompt", rpcError instanceof Error ? rpcError.message : String(rpcError)));
+						}
+					});
 			});
-			return success(id, "prompt");
 		}
 
 		case "steer": {
@@ -44,11 +55,30 @@ export async function handleRpcCommand(runtime: AgentSessionRuntime, command: Rp
 			return success(id, "abort");
 		}
 
-		case "new_session":
-		case "switch_session":
-		case "fork":
-		case "clone":
-			return unsupported(id, command.type);
+		case "new_session": {
+			const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
+			const result = await runtime.newSession(options);
+			return success(id, "new_session", result);
+		}
+
+		case "switch_session": {
+			const result = await runtime.switchSession(command.sessionPath);
+			return success(id, "switch_session", result);
+		}
+
+		case "fork": {
+			const result = await runtime.fork(command.entryId);
+			return success(id, "fork", { text: result.selectedText ?? "", cancelled: result.cancelled });
+		}
+
+		case "clone": {
+			const leafId = session.sessionManager.getLeafId();
+			if (!leafId) {
+				return error(id, "clone", "Cannot clone session: no current entry selected");
+			}
+			const result = await runtime.fork(leafId, { position: "at" });
+			return success(id, "clone", { cancelled: result.cancelled });
+		}
 
 		case "get_state": {
 			const state: RpcSessionState = {
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index 42d785bc..176c6539 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { getSocketPath } from "./config.ts";
-import { handleIpcRequest } from "./handler.ts";
+import { attachIpcInstance, handleIpcRequest } from "./handler.ts";
 import { startIpcServer } from "./ipc/server.ts";
 import { getRadiusOrchestratorBaseUrl, isRadiusEnabled, radiusPresence } from "./radius.ts";
 import { supervisor } from "./supervisor.ts";
@@ -19,7 +19,11 @@ export async function serve(): Promise<void> {
 	} else {
 		console.log("radius integration disabled: set PI_RADIUS_API_KEY to enable");
 	}
-	const server = await startIpcServer(handleIpcRequest);
+	const server = await startIpcServer(
+		Object.assign(handleIpcRequest, {
+			attach: attachIpcInstance,
+		}),
+	);
 	console.log(`orchestrator listening on ${socketPath}`);
 
 	let shutdownPromise: Promise<void> | undefined;
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 88f5a752..9c2ef4b5 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -1,5 +1,7 @@
 import { randomUUID } from "node:crypto";
 import {
+	type AgentSessionEvent,
+	type AgentSessionEventListener,
 	type AgentSessionRuntime,
 	type CreateAgentSessionRuntimeFactory,
 	createAgentSessionFromServices,
@@ -18,6 +20,8 @@ import type { InstanceRecord } from "./types.ts";
 interface LiveInstance {
 	runtime: AgentSessionRuntime;
 	record: InstanceRecord;
+	subscribers: Set<AgentSessionEventListener>;
+	unsubscribeSession?: () => void;
 }
 
 function cloneInstance(record: InstanceRecord): InstanceRecord {
@@ -56,6 +60,29 @@ async function createRuntime(cwd: string): Promise<AgentSessionRuntime> {
 export class OrchestratorSupervisor {
 	private readonly liveInstances = new Map<string, LiveInstance>();
 
+	private syncInstanceRecord(live: LiveInstance): void {
+		live.record = {
+			...live.record,
+			sessionId: live.runtime.session.sessionId,
+			sessionFile: live.runtime.session.sessionFile,
+			lastSeenAt: new Date().toISOString(),
+		};
+		upsertInstance(live.record);
+	}
+
+	private bindLiveInstance(live: LiveInstance): void {
+		live.unsubscribeSession?.();
+		live.unsubscribeSession = live.runtime.session.subscribe((event) => {
+			for (const subscriber of live.subscribers) {
+				subscriber(event);
+			}
+		});
+		live.runtime.setRebindSession(async () => {
+			this.syncInstanceRecord(live);
+			this.bindLiveInstance(live);
+		});
+	}
+
 	updateInstance(instance: InstanceRecord): void {
 		const live = this.liveInstances.get(instance.id);
 		if (live) {
@@ -64,6 +91,27 @@ export class OrchestratorSupervisor {
 		upsertInstance(instance);
 	}
 
+	attachInstance(
+		instanceId: string,
+		onEvent: (event: AgentSessionEvent) => void,
+	): { handleRpc(command: RpcCommand): Promise<RpcResponse>; close(): void } | undefined {
+		const live = this.liveInstances.get(instanceId);
+		if (!live) {
+			return undefined;
+		}
+		live.subscribers.add(onEvent);
+		return {
+			handleRpc: async (command) => {
+				const response = await handleRpcCommand(live.runtime, command);
+				this.syncInstanceRecord(live);
+				return response;
+			},
+			close: () => {
+				live.subscribers.delete(onEvent);
+			},
+		};
+	}
+
 	getLiveInstance(instanceId: string): InstanceRecord | undefined {
 		const live = this.liveInstances.get(instanceId);
 		return live ? cloneInstance(live.record) : undefined;
@@ -114,7 +162,9 @@ export class OrchestratorSupervisor {
 		};
 
 		const registeredRecord = await radiusPresence.registerPi(record);
-		this.liveInstances.set(registeredRecord.id, { runtime, record: registeredRecord });
+		const live: LiveInstance = { runtime, record: registeredRecord, subscribers: new Set() };
+		this.bindLiveInstance(live);
+		this.liveInstances.set(registeredRecord.id, live);
 		upsertInstance(registeredRecord);
 		return cloneInstance(registeredRecord);
 	}
@@ -126,6 +176,8 @@ export class OrchestratorSupervisor {
 		}
 
 		await radiusPresence.disconnectPi(live.record);
+		live.unsubscribeSession?.();
+		live.runtime.setRebindSession(undefined);
 		await live.runtime.dispose();
 		this.liveInstances.delete(instanceId);
 		removeInstance(instanceId);
@@ -138,7 +190,9 @@ export class OrchestratorSupervisor {
 			return undefined;
 		}
 
-		return handleRpcCommand(live.runtime, command);
+		const response = await handleRpcCommand(live.runtime, command);
+		this.syncInstanceRecord(live);
+		return response;
 	}
 
 	async shutdown(): Promise<void> {

From 4806b8f9f43bc1e89cc504dbbca92fb4c6bf6069 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:41:47 +0200
Subject: [PATCH 17/36] fix: use radius creds instead of api key

---
 packages/orchestrator/src/ipc/protocol.ts |  3 +-
 packages/orchestrator/src/radius.ts       | 35 +++++++++++++++++------
 packages/orchestrator/src/serve.ts        |  2 +-
 3 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 09744a73..93d7e597 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -123,6 +123,7 @@ export interface ResponseMap {
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
 export type AttachClientRequest = AttachRpcRequest;
 export type AttachServerResponse = AttachReadyResponse | AttachEventResponse | AttachRpcResponse | ErrorResponse;
+export type ProtocolMessage = OrchestratorRequest | OrchestratorResponse | AttachClientRequest | AttachServerResponse;
 
 export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer K }
 	? K extends keyof ResponseMap
@@ -130,7 +131,7 @@ export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer
 		: ErrorResponse
 	: ErrorResponse;
 
-export function encodeMessage(message: unknown): string {
+export function encodeMessage(message: ProtocolMessage): string {
 	return `${JSON.stringify(message)}\n`;
 }
 
diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index b737f5ac..a6dcad7f 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -1,4 +1,5 @@
 import { hostname, platform } from "node:os";
+import { AuthStorage, type OAuthCredential } from "@earendil-works/pi-coding-agent";
 import { getOrchestratorDir, getSocketPath } from "./config.ts";
 import { loadMachine, saveMachine } from "./storage.ts";
 import type { InstanceRecord, MachineRecord, RadiusRegistration } from "./types.ts";
@@ -7,6 +8,7 @@ const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
 const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
 const ORCHESTRATOR_VERSION = "0.79.6";
 const NOT_FOUND_RETRY_THRESHOLD = 3;
+const RADIUS_PROVIDER = "radius";
 
 interface RegisterMachineResponse extends RadiusRegistration {
 	id: string;
@@ -42,7 +44,7 @@ async function post<T>(path: string, body: unknown): Promise<T> {
 	const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
 		method: "POST",
 		headers: {
-			Authorization: `Bearer ${getRadiusApiKey()}`,
+			Authorization: `Bearer ${getRadiusAccessToken()}`,
 			"Content-Type": "application/json",
 		},
 		body: JSON.stringify(body),
@@ -59,7 +61,7 @@ async function maybePost(path: string, body: unknown): Promise<void> {
 	const response = await fetch(new URL(path, getRadiusOrchestratorBaseUrl()), {
 		method: "POST",
 		headers: {
-			Authorization: `Bearer ${getRadiusApiKey()}`,
+			Authorization: `Bearer ${getRadiusAccessToken()}`,
 			"Content-Type": "application/json",
 		},
 		body: JSON.stringify(body),
@@ -86,16 +88,33 @@ export function getRadiusOrchestratorBaseUrl(): string {
 	return new URL(DEFAULT_ORCHESTRATOR_BASE_PATH, getRadiusUrl()).toString();
 }
 
-export function getRadiusApiKey(): string {
-	const apiKey = process.env.PI_RADIUS_API_KEY;
-	if (!apiKey) {
-		throw new Error("PI_RADIUS_API_KEY is required for Radius integration");
+const radiusAuthStorage = AuthStorage.create();
+
+function getStoredRadiusCredential(): OAuthCredential | undefined {
+	radiusAuthStorage.reload();
+	const credential = radiusAuthStorage.get(RADIUS_PROVIDER);
+	if (!credential || credential.type !== "oauth") {
+		return undefined;
 	}
-	return apiKey;
+	return credential;
+}
+
+export function getRadiusAccessToken(): string {
+	const storedCredential = getStoredRadiusCredential();
+	if (typeof storedCredential?.access === "string" && storedCredential.access) {
+		return storedCredential.access;
+	}
+
+	const apiKey = process.env.PI_RADIUS_API_KEY;
+	if (apiKey) {
+		return apiKey;
+	}
+
+	throw new Error("Radius credentials are required in ~/.pi/agent/auth.json or PI_RADIUS_API_KEY");
 }
 
 export function isRadiusEnabled(): boolean {
-	return !!process.env.PI_RADIUS_API_KEY;
+	return !!getStoredRadiusCredential()?.access || !!process.env.PI_RADIUS_API_KEY;
 }
 
 export class RadiusPresence {
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index 176c6539..acc4e9fc 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -17,7 +17,7 @@ export async function serve(): Promise<void> {
 			console.log(`radius machine id: ${machine.id}`);
 		}
 	} else {
-		console.log("radius integration disabled: set PI_RADIUS_API_KEY to enable");
+		console.log("radius integration disabled: login radius in ~/.pi/agent/auth.json or set PI_RADIUS_API_KEY");
 	}
 	const server = await startIpcServer(
 		Object.assign(handleIpcRequest, {

From c4e89b033737a0bf3d26227d8a48c9a6b58520e7 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:55:35 +0200
Subject: [PATCH 18/36] feat: ui attach rpc support

---
 packages/orchestrator/src/attach-ui.ts    | 207 ++++++++++++++++++++++
 packages/orchestrator/src/cli.ts          |   8 +-
 packages/orchestrator/src/handler.ts      |  25 ++-
 packages/orchestrator/src/ipc/protocol.ts |  17 +-
 packages/orchestrator/src/ipc/server.ts   |   4 +
 packages/orchestrator/src/radius.ts       | 108 ++++++++---
 packages/orchestrator/src/supervisor.ts   |  34 +++-
 7 files changed, 369 insertions(+), 34 deletions(-)
 create mode 100644 packages/orchestrator/src/attach-ui.ts

diff --git a/packages/orchestrator/src/attach-ui.ts b/packages/orchestrator/src/attach-ui.ts
new file mode 100644
index 00000000..05c8a9d7
--- /dev/null
+++ b/packages/orchestrator/src/attach-ui.ts
@@ -0,0 +1,207 @@
+import { randomUUID } from "node:crypto";
+import type {
+	AgentSessionRuntime,
+	ExtensionUIContext,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+} from "@earendil-works/pi-coding-agent";
+
+import { theme } from "../../coding-agent/src/modes/interactive/theme/theme.ts";
+
+type DialogRequest =
+	| Extract<RpcExtensionUIRequest, { method: "select" }>
+	| Extract<RpcExtensionUIRequest, { method: "confirm" }>
+	| Extract<RpcExtensionUIRequest, { method: "input" }>
+	| Extract<RpcExtensionUIRequest, { method: "editor" }>;
+
+type FireAndForgetRequest = Exclude<RpcExtensionUIRequest, DialogRequest>;
+
+interface PendingExtensionRequest {
+	resolve(response: RpcExtensionUIResponse): void;
+	cancel(): void;
+}
+
+export class AttachUiBridge {
+	private readonly pendingRequests = new Map<string, PendingExtensionRequest>();
+	private onRequest?: (request: RpcExtensionUIRequest) => void;
+
+	attach(onRequest: (request: RpcExtensionUIRequest) => void): () => void {
+		this.onRequest = onRequest;
+		return () => {
+			if (this.onRequest === onRequest) {
+				this.onRequest = undefined;
+			}
+		};
+	}
+
+	handleResponse(response: RpcExtensionUIResponse): void {
+		const pending = this.pendingRequests.get(response.id);
+		if (!pending) {
+			return;
+		}
+		this.pendingRequests.delete(response.id);
+		pending.resolve(response);
+	}
+
+	createUiContext(): ExtensionUIContext {
+		const requestDialog = <T>(
+			request: DialogRequest,
+			fallbackValue: T,
+			parseResponse: (response: RpcExtensionUIResponse) => T,
+		): Promise<T> => {
+			if (!this.onRequest) {
+				return Promise.resolve(fallbackValue);
+			}
+
+			return new Promise<T>((resolve) => {
+				this.pendingRequests.set(request.id, {
+					resolve: (response) => resolve(parseResponse(response)),
+					cancel: () => resolve(fallbackValue),
+				});
+				this.onRequest?.(request);
+			});
+		};
+
+		const emit = (request: FireAndForgetRequest): void => {
+			if (!this.onRequest) {
+				return;
+			}
+			this.onRequest(request);
+		};
+
+		return {
+			select: async (title, options, opts) =>
+				requestDialog(
+					{
+						type: "extension_ui_request",
+						id: randomUUID(),
+						method: "select",
+						title,
+						options,
+						timeout: opts?.timeout,
+					},
+					undefined,
+					(response) => ("value" in response ? response.value : undefined),
+				),
+			confirm: async (title, message, opts) =>
+				requestDialog(
+					{
+						type: "extension_ui_request",
+						id: randomUUID(),
+						method: "confirm",
+						title,
+						message,
+						timeout: opts?.timeout,
+					},
+					false,
+					(response) => ("confirmed" in response ? response.confirmed : false),
+				),
+			input: async (title, placeholder, opts) =>
+				requestDialog(
+					{
+						type: "extension_ui_request",
+						id: randomUUID(),
+						method: "input",
+						title,
+						placeholder,
+						timeout: opts?.timeout,
+					},
+					undefined,
+					(response) => ("value" in response ? response.value : undefined),
+				),
+			notify: (message, notifyType) => {
+				emit({ type: "extension_ui_request", id: randomUUID(), method: "notify", message, notifyType });
+			},
+			onTerminalInput: () => () => {},
+			setStatus: (statusKey, statusText) => {
+				emit({ type: "extension_ui_request", id: randomUUID(), method: "setStatus", statusKey, statusText });
+			},
+			setWorkingMessage: () => {},
+			setWorkingVisible: () => {},
+			setWorkingIndicator: () => {},
+			setHiddenThinkingLabel: () => {},
+			setWidget: (widgetKey, widgetLines, options) => {
+				if (widgetLines === undefined || Array.isArray(widgetLines)) {
+					emit({
+						type: "extension_ui_request",
+						id: randomUUID(),
+						method: "setWidget",
+						widgetKey,
+						widgetLines,
+						widgetPlacement: options?.placement,
+					});
+				}
+			},
+			setFooter: () => {},
+			setHeader: () => {},
+			setTitle: (title) => {
+				emit({ type: "extension_ui_request", id: randomUUID(), method: "setTitle", title });
+			},
+			custom: async () => Promise.reject(new Error("Custom UI not supported in orchestrator attach mode")),
+			pasteToEditor: (text) => {
+				emit({ type: "extension_ui_request", id: randomUUID(), method: "set_editor_text", text });
+			},
+			setEditorText: (text) => {
+				emit({ type: "extension_ui_request", id: randomUUID(), method: "set_editor_text", text });
+			},
+			getEditorText: () => "",
+			editor: async (title, prefill) =>
+				requestDialog(
+					{ type: "extension_ui_request", id: randomUUID(), method: "editor", title, prefill },
+					undefined,
+					(response) => ("value" in response ? response.value : undefined),
+				),
+			addAutocompleteProvider: () => {},
+			setEditorComponent: () => {},
+			getEditorComponent: () => undefined,
+			get theme() {
+				return theme;
+			},
+			getAllThemes: () => [],
+			getTheme: () => undefined,
+			setTheme: () => ({ success: false, error: "Theme switching not supported in orchestrator attach mode" }),
+			getToolsExpanded: () => false,
+			setToolsExpanded: () => {},
+		};
+	}
+
+	cancelPendingRequests(): void {
+		for (const [id, pending] of this.pendingRequests) {
+			this.pendingRequests.delete(id);
+			pending.cancel();
+		}
+	}
+}
+
+export async function bindAttachExtensions(runtime: AgentSessionRuntime, uiBridge: AttachUiBridge): Promise<void> {
+	const session = runtime.session;
+	await session.bindExtensions({
+		uiContext: uiBridge.createUiContext(),
+		mode: "rpc",
+		commandContextActions: {
+			waitForIdle: () => session.agent.waitForIdle(),
+			newSession: async (options) => runtime.newSession(options),
+			fork: async (entryId, forkOptions) => {
+				const result = await runtime.fork(entryId, forkOptions);
+				return { cancelled: result.cancelled };
+			},
+			navigateTree: async (targetId, options) => {
+				const result = await session.navigateTree(targetId, {
+					summarize: options?.summarize,
+					customInstructions: options?.customInstructions,
+					replaceInstructions: options?.replaceInstructions,
+					label: options?.label,
+				});
+				return { cancelled: result.cancelled };
+			},
+			switchSession: async (sessionPath, options) => runtime.switchSession(sessionPath, options),
+			reload: async () => {
+				await session.reload();
+			},
+		},
+		shutdownHandler: () => {},
+		onError: (error) => {
+			console.error("Extension error in orchestrator attach mode", error);
+		},
+	});
+}
diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index 02fb3caa..bb763730 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -4,6 +4,7 @@ import { createConnection } from "node:net";
 import { dirname, join } from "node:path";
 import { cwd } from "node:process";
 import { fileURLToPath } from "node:url";
+import type { RpcCommand, RpcExtensionUIResponse } from "@earendil-works/pi-coding-agent";
 import { getSocketPath } from "./config.ts";
 import { sendIpcRequest } from "./ipc/client.ts";
 import { encodeMessage } from "./ipc/protocol.ts";
@@ -61,7 +62,12 @@ async function attach(instanceId: string): Promise<void> {
 			.map((line) => line.trim())
 			.filter((line) => line.length > 0);
 		for (const line of lines) {
-			socket.write(encodeMessage({ type: "attach_rpc", command: JSON.parse(line) }));
+			const parsed = JSON.parse(line) as RpcCommand | RpcExtensionUIResponse;
+			if (parsed.type === "extension_ui_response") {
+				socket.write(encodeMessage(parsed));
+				continue;
+			}
+			socket.write(encodeMessage({ type: "attach_rpc", command: parsed }));
 		}
 	});
 }
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 382030c5..efcfb104 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -1,4 +1,9 @@
-import type { AgentSessionEvent, RpcCommand } from "@earendil-works/pi-coding-agent";
+import type {
+	AgentSessionEvent,
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+} from "@earendil-works/pi-coding-agent";
 import type {
 	AttachReadyResponse,
 	AttachRequest,
@@ -128,16 +133,26 @@ export function attachIpcInstance(
 	instanceId: string,
 	onResponse: (response: AttachRpcResponse) => void,
 	onSessionEvent: (event: AgentSessionEvent) => void,
-): { handleRequest(request: { type: "attach_rpc"; command: RpcCommand }): Promise<void>; close(): void } | undefined {
-	const handle = supervisor.attachInstance(instanceId, onSessionEvent);
+	onUiRequest: (request: RpcExtensionUIRequest) => void,
+):
+	| {
+			handleRequest(request: { type: "attach_rpc"; command: RpcCommand } | RpcExtensionUIResponse): Promise<void>;
+			close(): void;
+	  }
+	| undefined {
+	const handle = supervisor.attachInstance(instanceId, onSessionEvent, onUiRequest);
 	if (!handle) {
 		return undefined;
 	}
 
 	return {
 		async handleRequest(request): Promise<void> {
-			const response = await handle.handleRpc(request.command);
-			onResponse({ type: "attach_rpc_result", response });
+			if (request.type === "attach_rpc") {
+				const response = await handle.handleRpc(request.command);
+				onResponse({ type: "attach_rpc_result", response });
+				return;
+			}
+			handle.handleUiResponse(request);
 		},
 		close(): void {
 			handle.close();
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 93d7e597..43929a71 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -1,4 +1,10 @@
-import type { AgentSessionEvent, RpcCommand, RpcResponse } from "@earendil-works/pi-coding-agent";
+import type {
+	AgentSessionEvent,
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+	RpcResponse,
+} from "@earendil-works/pi-coding-agent";
 import type { InstanceStatus } from "../types.ts";
 
 export interface SpawnRequest {
@@ -121,8 +127,13 @@ export interface ResponseMap {
 }
 
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
-export type AttachClientRequest = AttachRpcRequest;
-export type AttachServerResponse = AttachReadyResponse | AttachEventResponse | AttachRpcResponse | ErrorResponse;
+export type AttachClientRequest = AttachRpcRequest | RpcExtensionUIResponse;
+export type AttachServerResponse =
+	| AttachReadyResponse
+	| AttachEventResponse
+	| AttachRpcResponse
+	| RpcExtensionUIRequest
+	| ErrorResponse;
 export type ProtocolMessage = OrchestratorRequest | OrchestratorResponse | AttachClientRequest | AttachServerResponse;
 
 export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer K }
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 2dce45d0..bb43a0a1 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -35,6 +35,7 @@ export interface IpcRequestHandler {
 		instanceId: string,
 		onEvent: (response: AttachRpcResponse) => void,
 		onSessionEvent: (event: import("@earendil-works/pi-coding-agent").AgentSessionEvent) => void,
+		onUiRequest: (request: import("@earendil-works/pi-coding-agent").RpcExtensionUIRequest) => void,
 	):
 		| {
 				handleRequest(request: AttachClientRequest): Promise<void>;
@@ -80,6 +81,9 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 						(event) => {
 							socket.write(encodeMessage({ type: "attach_event", event }));
 						},
+						(request) => {
+							socket.write(encodeMessage(request));
+						},
 					);
 					if (!attachment) {
 						socket.end(
diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index a6dcad7f..71d39922 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -8,6 +8,8 @@ const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
 const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
 const ORCHESTRATOR_VERSION = "0.79.6";
 const NOT_FOUND_RETRY_THRESHOLD = 3;
+const HEARTBEAT_BACKOFF_BASE_MS = 1_000;
+const HEARTBEAT_BACKOFF_MAX_MS = 30_000;
 const RADIUS_PROVIDER = "radius";
 
 interface RegisterMachineResponse extends RadiusRegistration {
@@ -25,9 +27,11 @@ interface RadiusPresenceCoordinator {
 }
 
 interface PiHeartbeatState {
-	timer: NodeJS.Timeout;
+	timer?: NodeJS.Timeout;
+	intervalMs: number;
 	radiusPiId: string;
 	consecutiveNotFoundCount: number;
+	transientFailureCount: number;
 }
 
 class RadiusHttpError extends Error {
@@ -75,6 +79,15 @@ function isNotFoundError(error: unknown): error is RadiusHttpError {
 	return error instanceof RadiusHttpError && error.status === 404;
 }
 
+function computeBackoffDelayMs(failureCount: number): number {
+	const exponentialDelay = Math.min(
+		HEARTBEAT_BACKOFF_MAX_MS,
+		HEARTBEAT_BACKOFF_BASE_MS * 2 ** Math.max(0, failureCount - 1),
+	);
+	const jitterMs = Math.floor(Math.random() * Math.max(250, exponentialDelay / 4));
+	return Math.min(HEARTBEAT_BACKOFF_MAX_MS, exponentialDelay + jitterMs);
+}
+
 export function getRadiusUrl(): string {
 	return process.env.PI_RADIUS_URL || DEFAULT_RADIUS_URL;
 }
@@ -119,7 +132,9 @@ export function isRadiusEnabled(): boolean {
 
 export class RadiusPresence {
 	private machineHeartbeatTimer?: NodeJS.Timeout;
+	private machineHeartbeatIntervalMs = 0;
 	private machineConsecutiveNotFoundCount = 0;
+	private machineTransientFailureCount = 0;
 	private readonly piHeartbeatStates = new Map<string, PiHeartbeatState>();
 	private machine?: MachineRecord;
 	private coordinator?: RadiusPresenceCoordinator;
@@ -140,11 +155,13 @@ export class RadiusPresence {
 
 	async stop(): Promise<void> {
 		if (this.machineHeartbeatTimer) {
-			clearInterval(this.machineHeartbeatTimer);
+			clearTimeout(this.machineHeartbeatTimer);
 			this.machineHeartbeatTimer = undefined;
 		}
 		for (const [instanceId, state] of this.piHeartbeatStates) {
-			clearInterval(state.timer);
+			if (state.timer) {
+				clearTimeout(state.timer);
+			}
 			this.piHeartbeatStates.delete(instanceId);
 		}
 		if (!this.machine || !isRadiusEnabled()) {
@@ -179,7 +196,9 @@ export class RadiusPresence {
 	async disconnectPi(instance: InstanceRecord): Promise<void> {
 		const state = this.piHeartbeatStates.get(instance.id);
 		if (state) {
-			clearInterval(state.timer);
+			if (state.timer) {
+				clearTimeout(state.timer);
+			}
 			this.piHeartbeatStates.delete(instance.id);
 		}
 		if (!isRadiusEnabled() || !instance.radiusPiId) {
@@ -209,31 +228,54 @@ export class RadiusPresence {
 		};
 		saveMachine(this.machine);
 		this.machineConsecutiveNotFoundCount = 0;
+		this.machineTransientFailureCount = 0;
 		return registered;
 	}
 
 	private startMachineHeartbeat(intervalMs: number): void {
+		this.machineHeartbeatIntervalMs = intervalMs;
+		this.scheduleMachineHeartbeat(intervalMs);
+	}
+
+	private scheduleMachineHeartbeat(delayMs: number): void {
 		if (this.machineHeartbeatTimer) {
-			clearInterval(this.machineHeartbeatTimer);
+			clearTimeout(this.machineHeartbeatTimer);
 		}
-		this.machineHeartbeatTimer = setInterval(() => {
+		this.machineHeartbeatTimer = setTimeout(() => {
 			void this.heartbeatMachine();
-		}, intervalMs);
+		}, delayMs);
 	}
 
 	private startPiHeartbeat(instanceId: string, intervalMs: number, radiusPiId: string): void {
 		const existingState = this.piHeartbeatStates.get(instanceId);
-		if (existingState) {
-			clearInterval(existingState.timer);
+		if (existingState?.timer) {
+			clearTimeout(existingState.timer);
 		}
-		const timer = setInterval(() => {
-			void this.heartbeatPi(instanceId);
-		}, intervalMs);
-		this.piHeartbeatStates.set(instanceId, {
-			timer,
+		const state: PiHeartbeatState = existingState ?? {
+			intervalMs,
 			radiusPiId,
 			consecutiveNotFoundCount: 0,
-		});
+			transientFailureCount: 0,
+		};
+		state.intervalMs = intervalMs;
+		state.radiusPiId = radiusPiId;
+		state.consecutiveNotFoundCount = 0;
+		state.transientFailureCount = 0;
+		this.piHeartbeatStates.set(instanceId, state);
+		this.schedulePiHeartbeat(instanceId, intervalMs);
+	}
+
+	private schedulePiHeartbeat(instanceId: string, delayMs: number): void {
+		const state = this.piHeartbeatStates.get(instanceId);
+		if (!state) {
+			return;
+		}
+		if (state.timer) {
+			clearTimeout(state.timer);
+		}
+		state.timer = setTimeout(() => {
+			void this.heartbeatPi(instanceId);
+		}, delayMs);
 	}
 
 	private async heartbeatMachine(): Promise<void> {
@@ -247,21 +289,31 @@ export class RadiusPresence {
 				socketPath: getSocketPath(),
 			});
 			this.machineConsecutiveNotFoundCount = 0;
+			this.machineTransientFailureCount = 0;
+			this.scheduleMachineHeartbeat(this.machineHeartbeatIntervalMs);
 		} catch (error) {
 			if (!isNotFoundError(error)) {
-				console.error("Radius machine heartbeat failed", error);
+				this.machineTransientFailureCount += 1;
+				const delayMs = computeBackoffDelayMs(this.machineTransientFailureCount);
+				console.error(`Radius machine heartbeat failed; retrying in ${delayMs}ms`, error);
+				this.scheduleMachineHeartbeat(delayMs);
 				return;
 			}
 
+			this.machineTransientFailureCount = 0;
 			this.machineConsecutiveNotFoundCount += 1;
 			if (this.machineConsecutiveNotFoundCount < NOT_FOUND_RETRY_THRESHOLD) {
+				this.scheduleMachineHeartbeat(this.machineHeartbeatIntervalMs);
 				return;
 			}
 
 			try {
 				await this.reRegisterMachineAndPis();
 			} catch (recoveryError) {
-				console.error("Radius machine re-registration failed", recoveryError);
+				this.machineTransientFailureCount += 1;
+				const delayMs = computeBackoffDelayMs(this.machineTransientFailureCount);
+				console.error(`Radius machine re-registration failed; retrying in ${delayMs}ms`, recoveryError);
+				this.scheduleMachineHeartbeat(delayMs);
 			}
 		}
 	}
@@ -279,14 +331,21 @@ export class RadiusPresence {
 		try {
 			await maybePost(`pis/${state.radiusPiId}/heartbeat`, {});
 			state.consecutiveNotFoundCount = 0;
+			state.transientFailureCount = 0;
+			this.schedulePiHeartbeat(instanceId, state.intervalMs);
 		} catch (error) {
 			if (!isNotFoundError(error)) {
-				console.error(`Radius Pi heartbeat failed for instance ${instanceId}`, error);
+				state.transientFailureCount += 1;
+				const delayMs = computeBackoffDelayMs(state.transientFailureCount);
+				console.error(`Radius Pi heartbeat failed for instance ${instanceId}; retrying in ${delayMs}ms`, error);
+				this.schedulePiHeartbeat(instanceId, delayMs);
 				return;
 			}
 
+			state.transientFailureCount = 0;
 			state.consecutiveNotFoundCount += 1;
 			if (state.consecutiveNotFoundCount < NOT_FOUND_RETRY_THRESHOLD) {
+				this.schedulePiHeartbeat(instanceId, state.intervalMs);
 				return;
 			}
 
@@ -294,9 +353,16 @@ export class RadiusPresence {
 				const recovered = await this.reRegisterPi(instanceId);
 				if (!recovered) {
 					console.error(`Radius Pi re-registration skipped for instance ${instanceId}`);
+					this.schedulePiHeartbeat(instanceId, computeBackoffDelayMs(1));
 				}
 			} catch (recoveryError) {
-				console.error(`Radius Pi re-registration failed for instance ${instanceId}`, recoveryError);
+				state.transientFailureCount += 1;
+				const delayMs = computeBackoffDelayMs(state.transientFailureCount);
+				console.error(
+					`Radius Pi re-registration failed for instance ${instanceId}; retrying in ${delayMs}ms`,
+					recoveryError,
+				);
+				this.schedulePiHeartbeat(instanceId, delayMs);
 			}
 		}
 	}
@@ -320,7 +386,9 @@ export class RadiusPresence {
 		if (!instance) {
 			const state = this.piHeartbeatStates.get(instanceId);
 			if (state) {
-				clearInterval(state.timer);
+				if (state.timer) {
+					clearTimeout(state.timer);
+				}
 				this.piHeartbeatStates.delete(instanceId);
 			}
 			return false;
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 9c2ef4b5..886cbf26 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -9,9 +9,12 @@ import {
 	createAgentSessionServices,
 	getAgentDir,
 	type RpcCommand,
+	type RpcExtensionUIRequest,
+	type RpcExtensionUIResponse,
 	type RpcResponse,
 	SessionManager,
 } from "@earendil-works/pi-coding-agent";
+import { AttachUiBridge, bindAttachExtensions } from "./attach-ui.ts";
 import { radiusPresence } from "./radius.ts";
 import { handleRpcCommand } from "./rpc-bridge.ts";
 import { getInstance, loadInstances, removeInstance, saveInstances, upsertInstance } from "./storage.ts";
@@ -21,6 +24,7 @@ interface LiveInstance {
 	runtime: AgentSessionRuntime;
 	record: InstanceRecord;
 	subscribers: Set<AgentSessionEventListener>;
+	uiBridge: AttachUiBridge;
 	unsubscribeSession?: () => void;
 }
 
@@ -70,7 +74,8 @@ export class OrchestratorSupervisor {
 		upsertInstance(live.record);
 	}
 
-	private bindLiveInstance(live: LiveInstance): void {
+	private async bindLiveInstance(live: LiveInstance): Promise<void> {
+		await bindAttachExtensions(live.runtime, live.uiBridge);
 		live.unsubscribeSession?.();
 		live.unsubscribeSession = live.runtime.session.subscribe((event) => {
 			for (const subscriber of live.subscribers) {
@@ -79,7 +84,7 @@ export class OrchestratorSupervisor {
 		});
 		live.runtime.setRebindSession(async () => {
 			this.syncInstanceRecord(live);
-			this.bindLiveInstance(live);
+			await this.bindLiveInstance(live);
 		});
 	}
 
@@ -94,20 +99,33 @@ export class OrchestratorSupervisor {
 	attachInstance(
 		instanceId: string,
 		onEvent: (event: AgentSessionEvent) => void,
-	): { handleRpc(command: RpcCommand): Promise<RpcResponse>; close(): void } | undefined {
+		onUiRequest: (request: RpcExtensionUIRequest) => void,
+	):
+		| {
+				handleRpc(command: RpcCommand): Promise<RpcResponse>;
+				handleUiResponse(response: RpcExtensionUIResponse): void;
+				close(): void;
+		  }
+		| undefined {
 		const live = this.liveInstances.get(instanceId);
 		if (!live) {
 			return undefined;
 		}
 		live.subscribers.add(onEvent);
+		const detachUi = live.uiBridge.attach(onUiRequest);
 		return {
 			handleRpc: async (command) => {
 				const response = await handleRpcCommand(live.runtime, command);
 				this.syncInstanceRecord(live);
 				return response;
 			},
+			handleUiResponse: (response) => {
+				live.uiBridge.handleResponse(response);
+			},
 			close: () => {
+				detachUi();
 				live.subscribers.delete(onEvent);
+				live.uiBridge.cancelPendingRequests();
 			},
 		};
 	}
@@ -162,8 +180,13 @@ export class OrchestratorSupervisor {
 		};
 
 		const registeredRecord = await radiusPresence.registerPi(record);
-		const live: LiveInstance = { runtime, record: registeredRecord, subscribers: new Set() };
-		this.bindLiveInstance(live);
+		const live: LiveInstance = {
+			runtime,
+			record: registeredRecord,
+			subscribers: new Set(),
+			uiBridge: new AttachUiBridge(),
+		};
+		await this.bindLiveInstance(live);
 		this.liveInstances.set(registeredRecord.id, live);
 		upsertInstance(registeredRecord);
 		return cloneInstance(registeredRecord);
@@ -177,6 +200,7 @@ export class OrchestratorSupervisor {
 
 		await radiusPresence.disconnectPi(live.record);
 		live.unsubscribeSession?.();
+		live.uiBridge.cancelPendingRequests();
 		live.runtime.setRebindSession(undefined);
 		await live.runtime.dispose();
 		this.liveInstances.delete(instanceId);

From 337de9b078d616f19acdc023c6fff278a61abf5d Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 15:59:32 +0200
Subject: [PATCH 19/36] fix: RPC parity, UX polish, logging

---
 packages/orchestrator/src/cli.ts        | 20 ++++++++----
 packages/orchestrator/src/radius.ts     | 42 ++++++++++++++++++++-----
 packages/orchestrator/src/rpc-bridge.ts | 14 +++++----
 3 files changed, 56 insertions(+), 20 deletions(-)

diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index bb763730..674376e4 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -18,7 +18,7 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 
 function printHelp(): void {
 	console.log(
-		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator attach <instance-id>\n  orchestrator --help\n  orchestrator --version`,
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator attach <instance-id>\n  orchestrator --help\n  orchestrator --version\n\nAttach stdin expects JSONL RpcCommand or extension_ui_response messages.`,
 	);
 }
 
@@ -36,6 +36,7 @@ function getFlagValue(args: string[], flag: string): string | undefined {
 
 async function attach(instanceId: string): Promise<void> {
 	const socket = createConnection(getSocketPath());
+	let stdinBuffer = "";
 	process.stdin.setEncoding("utf8");
 
 	await new Promise<void>((resolve, reject) => {
@@ -49,6 +50,7 @@ async function attach(instanceId: string): Promise<void> {
 	socket.on("data", (chunk: Buffer | string) => {
 		process.stdout.write(chunk.toString());
 	});
+	console.error(`attached to ${instanceId}; send JSONL RpcCommand or extension_ui_response on stdin`);
 	socket.on("error", (error) => {
 		console.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
@@ -57,11 +59,17 @@ async function attach(instanceId: string): Promise<void> {
 		process.exit(0);
 	});
 	process.stdin.on("data", (chunk: string) => {
-		const lines = chunk
-			.split("\n")
-			.map((line) => line.trim())
-			.filter((line) => line.length > 0);
-		for (const line of lines) {
+		stdinBuffer += chunk;
+		while (true) {
+			const newlineIndex = stdinBuffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				return;
+			}
+			const line = stdinBuffer.slice(0, newlineIndex).trim();
+			stdinBuffer = stdinBuffer.slice(newlineIndex + 1);
+			if (!line) {
+				continue;
+			}
 			const parsed = JSON.parse(line) as RpcCommand | RpcExtensionUIResponse;
 			if (parsed.type === "extension_ui_response") {
 				socket.write(encodeMessage(parsed));
diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index 71d39922..cb503fab 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -88,6 +88,22 @@ function computeBackoffDelayMs(failureCount: number): number {
 	return Math.min(HEARTBEAT_BACKOFF_MAX_MS, exponentialDelay + jitterMs);
 }
 
+function formatRadiusError(error: unknown): string {
+	if (error instanceof RadiusHttpError) {
+		return `HTTP ${error.status}: ${error.message}`;
+	}
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+function logRadiusRetry(scope: string, action: string, delayMs: number, failureCount: number, error: unknown): void {
+	console.error(
+		`${scope} ${action} failed (attempt ${failureCount}); retrying in ${delayMs}ms: ${formatRadiusError(error)}`,
+	);
+}
+
 export function getRadiusUrl(): string {
 	return process.env.PI_RADIUS_URL || DEFAULT_RADIUS_URL;
 }
@@ -295,7 +311,7 @@ export class RadiusPresence {
 			if (!isNotFoundError(error)) {
 				this.machineTransientFailureCount += 1;
 				const delayMs = computeBackoffDelayMs(this.machineTransientFailureCount);
-				console.error(`Radius machine heartbeat failed; retrying in ${delayMs}ms`, error);
+				logRadiusRetry("Radius machine", "heartbeat", delayMs, this.machineTransientFailureCount, error);
 				this.scheduleMachineHeartbeat(delayMs);
 				return;
 			}
@@ -312,7 +328,13 @@ export class RadiusPresence {
 			} catch (recoveryError) {
 				this.machineTransientFailureCount += 1;
 				const delayMs = computeBackoffDelayMs(this.machineTransientFailureCount);
-				console.error(`Radius machine re-registration failed; retrying in ${delayMs}ms`, recoveryError);
+				logRadiusRetry(
+					"Radius machine",
+					"re-registration",
+					delayMs,
+					this.machineTransientFailureCount,
+					recoveryError,
+				);
 				this.scheduleMachineHeartbeat(delayMs);
 			}
 		}
@@ -337,7 +359,7 @@ export class RadiusPresence {
 			if (!isNotFoundError(error)) {
 				state.transientFailureCount += 1;
 				const delayMs = computeBackoffDelayMs(state.transientFailureCount);
-				console.error(`Radius Pi heartbeat failed for instance ${instanceId}; retrying in ${delayMs}ms`, error);
+				logRadiusRetry(`Radius Pi ${instanceId}`, "heartbeat", delayMs, state.transientFailureCount, error);
 				this.schedulePiHeartbeat(instanceId, delayMs);
 				return;
 			}
@@ -352,14 +374,18 @@ export class RadiusPresence {
 			try {
 				const recovered = await this.reRegisterPi(instanceId);
 				if (!recovered) {
-					console.error(`Radius Pi re-registration skipped for instance ${instanceId}`);
-					this.schedulePiHeartbeat(instanceId, computeBackoffDelayMs(1));
+					const delayMs = computeBackoffDelayMs(1);
+					console.error(`Radius Pi ${instanceId} re-registration skipped; retrying in ${delayMs}ms`);
+					this.schedulePiHeartbeat(instanceId, delayMs);
 				}
 			} catch (recoveryError) {
 				state.transientFailureCount += 1;
 				const delayMs = computeBackoffDelayMs(state.transientFailureCount);
-				console.error(
-					`Radius Pi re-registration failed for instance ${instanceId}; retrying in ${delayMs}ms`,
+				logRadiusRetry(
+					`Radius Pi ${instanceId}`,
+					"re-registration",
+					delayMs,
+					state.transientFailureCount,
 					recoveryError,
 				);
 				this.schedulePiHeartbeat(instanceId, delayMs);
@@ -376,7 +402,7 @@ export class RadiusPresence {
 			try {
 				await this.reRegisterPi(instance.id);
 			} catch (error) {
-				console.error(`Radius Pi re-registration failed for instance ${instance.id}`, error);
+				console.error(`Radius Pi ${instance.id} re-registration failed: ${formatRadiusError(error)}`);
 			}
 		}
 	}
diff --git a/packages/orchestrator/src/rpc-bridge.ts b/packages/orchestrator/src/rpc-bridge.ts
index 4f549c10..7a6cfa8d 100644
--- a/packages/orchestrator/src/rpc-bridge.ts
+++ b/packages/orchestrator/src/rpc-bridge.ts
@@ -11,6 +11,10 @@ function error(id: string | undefined, command: string, message: string): RpcRes
 	return { id, type: "response", command, success: false, error: message };
 }
 
+function assertNeverRpcCommand(command: never): never {
+	throw new Error(`Unknown command: ${(command as { type: string }).type}`);
+}
+
 export async function handleRpcCommand(runtime: AgentSessionRuntime, command: RpcCommand): Promise<RpcResponse> {
 	const session = runtime.session;
 	const id = command.id;
@@ -68,7 +72,7 @@ export async function handleRpcCommand(runtime: AgentSessionRuntime, command: Rp
 
 		case "fork": {
 			const result = await runtime.fork(command.entryId);
-			return success(id, "fork", { text: result.selectedText ?? "", cancelled: result.cancelled });
+			return success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
 		}
 
 		case "clone": {
@@ -186,7 +190,7 @@ export async function handleRpcCommand(runtime: AgentSessionRuntime, command: Rp
 		}
 
 		case "get_last_assistant_text": {
-			const text = session.getLastAssistantText() ?? null;
+			const text = session.getLastAssistantText();
 			return success(id, "get_last_assistant_text", { text });
 		}
 
@@ -236,9 +240,7 @@ export async function handleRpcCommand(runtime: AgentSessionRuntime, command: Rp
 			return success(id, "get_commands", { commands });
 		}
 
-		default: {
-			const unknownCommand = command as { type: string };
-			return error(id, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
-		}
+		default:
+			return assertNeverRpcCommand(command);
 	}
 }

From 1d5fd2356803311843554e40bf01d9c2ecef95dc Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 16:11:04 +0200
Subject: [PATCH 20/36] fix: theme in ui attach

---
 packages/orchestrator/src/attach-ui.ts    | 17 +++++++++++++----
 packages/orchestrator/src/handler.ts      |  9 ++++++++-
 packages/orchestrator/src/ipc/protocol.ts |  7 ++++++-
 packages/orchestrator/src/supervisor.ts   |  4 ++++
 4 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/packages/orchestrator/src/attach-ui.ts b/packages/orchestrator/src/attach-ui.ts
index 05c8a9d7..61eb41d3 100644
--- a/packages/orchestrator/src/attach-ui.ts
+++ b/packages/orchestrator/src/attach-ui.ts
@@ -6,8 +6,6 @@ import type {
 	RpcExtensionUIResponse,
 } from "@earendil-works/pi-coding-agent";
 
-import { theme } from "../../coding-agent/src/modes/interactive/theme/theme.ts";
-
 type DialogRequest =
 	| Extract<RpcExtensionUIRequest, { method: "select" }>
 	| Extract<RpcExtensionUIRequest, { method: "confirm" }>
@@ -24,6 +22,7 @@ interface PendingExtensionRequest {
 export class AttachUiBridge {
 	private readonly pendingRequests = new Map<string, PendingExtensionRequest>();
 	private onRequest?: (request: RpcExtensionUIRequest) => void;
+	private themeOverride?: unknown;
 
 	attach(onRequest: (request: RpcExtensionUIRequest) => void): () => void {
 		this.onRequest = onRequest;
@@ -34,6 +33,13 @@ export class AttachUiBridge {
 		};
 	}
 
+	setThemeOverride(theme: unknown): void {
+		// This comes from attach host context over JSONL IPC. Pi's Theme is a runtime class,
+		// not a wire-safe protocol type, so this remains opaque until we define a proper
+		// serializable theme snapshot/DTO for the attach protocol.
+		this.themeOverride = theme;
+	}
+
 	handleResponse(response: RpcExtensionUIResponse): void {
 		const pending = this.pendingRequests.get(response.id);
 		if (!pending) {
@@ -44,6 +50,7 @@ export class AttachUiBridge {
 	}
 
 	createUiContext(): ExtensionUIContext {
+		const uiBridge = this;
 		const requestDialog = <T>(
 			request: DialogRequest,
 			fallbackValue: T,
@@ -154,8 +161,10 @@ export class AttachUiBridge {
 			addAutocompleteProvider: () => {},
 			setEditorComponent: () => {},
 			getEditorComponent: () => undefined,
-			get theme() {
-				return theme;
+			get theme(): ExtensionUIContext["theme"] {
+				// If the attach host provides a theme object, forward it. Otherwise attach mode
+				// still has no real TUI/theme runtime, so fall back to an empty placeholder.
+				return (uiBridge.themeOverride ?? {}) as ExtensionUIContext["theme"];
 			},
 			getAllThemes: () => [],
 			getTheme: () => undefined,
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index efcfb104..7d1c8ab3 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -5,6 +5,7 @@ import type {
 	RpcExtensionUIResponse,
 } from "@earendil-works/pi-coding-agent";
 import type {
+	AttachHostContextRequest,
 	AttachReadyResponse,
 	AttachRequest,
 	AttachRpcResponse,
@@ -136,7 +137,9 @@ export function attachIpcInstance(
 	onUiRequest: (request: RpcExtensionUIRequest) => void,
 ):
 	| {
-			handleRequest(request: { type: "attach_rpc"; command: RpcCommand } | RpcExtensionUIResponse): Promise<void>;
+			handleRequest(
+				request: { type: "attach_rpc"; command: RpcCommand } | AttachHostContextRequest | RpcExtensionUIResponse,
+			): Promise<void>;
 			close(): void;
 	  }
 	| undefined {
@@ -152,6 +155,10 @@ export function attachIpcInstance(
 				onResponse({ type: "attach_rpc_result", response });
 				return;
 			}
+			if (request.type === "attach_host_context") {
+				handle.setHostTheme(request.theme);
+				return;
+			}
 			handle.handleUiResponse(request);
 		},
 		close(): void {
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 43929a71..1f4040a0 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -45,6 +45,11 @@ export interface AttachRpcRequest {
 	command: RpcCommand;
 }
 
+export interface AttachHostContextRequest {
+	type: "attach_host_context";
+	theme?: unknown;
+}
+
 export interface RequestMap {
 	spawn: SpawnRequest;
 	list: ListRequest;
@@ -127,7 +132,7 @@ export interface ResponseMap {
 }
 
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
-export type AttachClientRequest = AttachRpcRequest | RpcExtensionUIResponse;
+export type AttachClientRequest = AttachRpcRequest | AttachHostContextRequest | RpcExtensionUIResponse;
 export type AttachServerResponse =
 	| AttachReadyResponse
 	| AttachEventResponse
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 886cbf26..24dddfbd 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -104,6 +104,7 @@ export class OrchestratorSupervisor {
 		| {
 				handleRpc(command: RpcCommand): Promise<RpcResponse>;
 				handleUiResponse(response: RpcExtensionUIResponse): void;
+				setHostTheme(theme: unknown): void;
 				close(): void;
 		  }
 		| undefined {
@@ -122,6 +123,9 @@ export class OrchestratorSupervisor {
 			handleUiResponse: (response) => {
 				live.uiBridge.handleResponse(response);
 			},
+			setHostTheme: (theme) => {
+				live.uiBridge.setThemeOverride(theme);
+			},
 			close: () => {
 				detachUi();
 				live.subscribers.delete(onEvent);

From ac92f92b65943d5f54837e065dc025957c302fa2 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 18 Jun 2026 16:15:03 +0200
Subject: [PATCH 21/36] fix: not found errors

---
 packages/orchestrator/src/radius.ts | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index cb503fab..aacd7130 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -183,7 +183,13 @@ export class RadiusPresence {
 		if (!this.machine || !isRadiusEnabled()) {
 			return;
 		}
-		await maybePost(`machines/${this.machine.id}/disconnect`, {});
+		try {
+			await maybePost(`machines/${this.machine.id}/disconnect`, {});
+		} catch (error) {
+			if (!isNotFoundError(error)) {
+				throw error;
+			}
+		}
 	}
 
 	async registerPi(instance: InstanceRecord): Promise<InstanceRecord> {
@@ -220,7 +226,13 @@ export class RadiusPresence {
 		if (!isRadiusEnabled() || !instance.radiusPiId) {
 			return;
 		}
-		await maybePost(`pis/${instance.radiusPiId}/disconnect`, {});
+		try {
+			await maybePost(`pis/${instance.radiusPiId}/disconnect`, {});
+		} catch (error) {
+			if (!isNotFoundError(error)) {
+				throw error;
+			}
+		}
 	}
 
 	private async registerMachine(label?: string): Promise<RegisterMachineResponse> {

From a7b0138ef012eb4ce8730755bfb4f0fb7a17fb76 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Mon, 22 Jun 2026 14:45:56 +0200
Subject: [PATCH 22/36] fix: raw rpc

---
 packages/orchestrator/src/attach-ui.ts    | 216 -------------------
 packages/orchestrator/src/cli.ts          |  20 +-
 packages/orchestrator/src/handler.ts      |  52 ++---
 packages/orchestrator/src/index.ts        |   1 +
 packages/orchestrator/src/ipc/protocol.ts |  47 +----
 packages/orchestrator/src/ipc/server.ts   |  47 +++--
 packages/orchestrator/src/rpc-bridge.ts   | 246 ----------------------
 packages/orchestrator/src/rpc-process.ts  | 183 ++++++++++++++++
 packages/orchestrator/src/supervisor.ts   | 145 ++++++-------
 9 files changed, 315 insertions(+), 642 deletions(-)
 delete mode 100644 packages/orchestrator/src/attach-ui.ts
 delete mode 100644 packages/orchestrator/src/rpc-bridge.ts
 create mode 100644 packages/orchestrator/src/rpc-process.ts

diff --git a/packages/orchestrator/src/attach-ui.ts b/packages/orchestrator/src/attach-ui.ts
deleted file mode 100644
index 61eb41d3..00000000
--- a/packages/orchestrator/src/attach-ui.ts
+++ /dev/null
@@ -1,216 +0,0 @@
-import { randomUUID } from "node:crypto";
-import type {
-	AgentSessionRuntime,
-	ExtensionUIContext,
-	RpcExtensionUIRequest,
-	RpcExtensionUIResponse,
-} from "@earendil-works/pi-coding-agent";
-
-type DialogRequest =
-	| Extract<RpcExtensionUIRequest, { method: "select" }>
-	| Extract<RpcExtensionUIRequest, { method: "confirm" }>
-	| Extract<RpcExtensionUIRequest, { method: "input" }>
-	| Extract<RpcExtensionUIRequest, { method: "editor" }>;
-
-type FireAndForgetRequest = Exclude<RpcExtensionUIRequest, DialogRequest>;
-
-interface PendingExtensionRequest {
-	resolve(response: RpcExtensionUIResponse): void;
-	cancel(): void;
-}
-
-export class AttachUiBridge {
-	private readonly pendingRequests = new Map<string, PendingExtensionRequest>();
-	private onRequest?: (request: RpcExtensionUIRequest) => void;
-	private themeOverride?: unknown;
-
-	attach(onRequest: (request: RpcExtensionUIRequest) => void): () => void {
-		this.onRequest = onRequest;
-		return () => {
-			if (this.onRequest === onRequest) {
-				this.onRequest = undefined;
-			}
-		};
-	}
-
-	setThemeOverride(theme: unknown): void {
-		// This comes from attach host context over JSONL IPC. Pi's Theme is a runtime class,
-		// not a wire-safe protocol type, so this remains opaque until we define a proper
-		// serializable theme snapshot/DTO for the attach protocol.
-		this.themeOverride = theme;
-	}
-
-	handleResponse(response: RpcExtensionUIResponse): void {
-		const pending = this.pendingRequests.get(response.id);
-		if (!pending) {
-			return;
-		}
-		this.pendingRequests.delete(response.id);
-		pending.resolve(response);
-	}
-
-	createUiContext(): ExtensionUIContext {
-		const uiBridge = this;
-		const requestDialog = <T>(
-			request: DialogRequest,
-			fallbackValue: T,
-			parseResponse: (response: RpcExtensionUIResponse) => T,
-		): Promise<T> => {
-			if (!this.onRequest) {
-				return Promise.resolve(fallbackValue);
-			}
-
-			return new Promise<T>((resolve) => {
-				this.pendingRequests.set(request.id, {
-					resolve: (response) => resolve(parseResponse(response)),
-					cancel: () => resolve(fallbackValue),
-				});
-				this.onRequest?.(request);
-			});
-		};
-
-		const emit = (request: FireAndForgetRequest): void => {
-			if (!this.onRequest) {
-				return;
-			}
-			this.onRequest(request);
-		};
-
-		return {
-			select: async (title, options, opts) =>
-				requestDialog(
-					{
-						type: "extension_ui_request",
-						id: randomUUID(),
-						method: "select",
-						title,
-						options,
-						timeout: opts?.timeout,
-					},
-					undefined,
-					(response) => ("value" in response ? response.value : undefined),
-				),
-			confirm: async (title, message, opts) =>
-				requestDialog(
-					{
-						type: "extension_ui_request",
-						id: randomUUID(),
-						method: "confirm",
-						title,
-						message,
-						timeout: opts?.timeout,
-					},
-					false,
-					(response) => ("confirmed" in response ? response.confirmed : false),
-				),
-			input: async (title, placeholder, opts) =>
-				requestDialog(
-					{
-						type: "extension_ui_request",
-						id: randomUUID(),
-						method: "input",
-						title,
-						placeholder,
-						timeout: opts?.timeout,
-					},
-					undefined,
-					(response) => ("value" in response ? response.value : undefined),
-				),
-			notify: (message, notifyType) => {
-				emit({ type: "extension_ui_request", id: randomUUID(), method: "notify", message, notifyType });
-			},
-			onTerminalInput: () => () => {},
-			setStatus: (statusKey, statusText) => {
-				emit({ type: "extension_ui_request", id: randomUUID(), method: "setStatus", statusKey, statusText });
-			},
-			setWorkingMessage: () => {},
-			setWorkingVisible: () => {},
-			setWorkingIndicator: () => {},
-			setHiddenThinkingLabel: () => {},
-			setWidget: (widgetKey, widgetLines, options) => {
-				if (widgetLines === undefined || Array.isArray(widgetLines)) {
-					emit({
-						type: "extension_ui_request",
-						id: randomUUID(),
-						method: "setWidget",
-						widgetKey,
-						widgetLines,
-						widgetPlacement: options?.placement,
-					});
-				}
-			},
-			setFooter: () => {},
-			setHeader: () => {},
-			setTitle: (title) => {
-				emit({ type: "extension_ui_request", id: randomUUID(), method: "setTitle", title });
-			},
-			custom: async () => Promise.reject(new Error("Custom UI not supported in orchestrator attach mode")),
-			pasteToEditor: (text) => {
-				emit({ type: "extension_ui_request", id: randomUUID(), method: "set_editor_text", text });
-			},
-			setEditorText: (text) => {
-				emit({ type: "extension_ui_request", id: randomUUID(), method: "set_editor_text", text });
-			},
-			getEditorText: () => "",
-			editor: async (title, prefill) =>
-				requestDialog(
-					{ type: "extension_ui_request", id: randomUUID(), method: "editor", title, prefill },
-					undefined,
-					(response) => ("value" in response ? response.value : undefined),
-				),
-			addAutocompleteProvider: () => {},
-			setEditorComponent: () => {},
-			getEditorComponent: () => undefined,
-			get theme(): ExtensionUIContext["theme"] {
-				// If the attach host provides a theme object, forward it. Otherwise attach mode
-				// still has no real TUI/theme runtime, so fall back to an empty placeholder.
-				return (uiBridge.themeOverride ?? {}) as ExtensionUIContext["theme"];
-			},
-			getAllThemes: () => [],
-			getTheme: () => undefined,
-			setTheme: () => ({ success: false, error: "Theme switching not supported in orchestrator attach mode" }),
-			getToolsExpanded: () => false,
-			setToolsExpanded: () => {},
-		};
-	}
-
-	cancelPendingRequests(): void {
-		for (const [id, pending] of this.pendingRequests) {
-			this.pendingRequests.delete(id);
-			pending.cancel();
-		}
-	}
-}
-
-export async function bindAttachExtensions(runtime: AgentSessionRuntime, uiBridge: AttachUiBridge): Promise<void> {
-	const session = runtime.session;
-	await session.bindExtensions({
-		uiContext: uiBridge.createUiContext(),
-		mode: "rpc",
-		commandContextActions: {
-			waitForIdle: () => session.agent.waitForIdle(),
-			newSession: async (options) => runtime.newSession(options),
-			fork: async (entryId, forkOptions) => {
-				const result = await runtime.fork(entryId, forkOptions);
-				return { cancelled: result.cancelled };
-			},
-			navigateTree: async (targetId, options) => {
-				const result = await session.navigateTree(targetId, {
-					summarize: options?.summarize,
-					customInstructions: options?.customInstructions,
-					replaceInstructions: options?.replaceInstructions,
-					label: options?.label,
-				});
-				return { cancelled: result.cancelled };
-			},
-			switchSession: async (sessionPath, options) => runtime.switchSession(sessionPath, options),
-			reload: async () => {
-				await session.reload();
-			},
-		},
-		shutdownHandler: () => {},
-		onError: (error) => {
-			console.error("Extension error in orchestrator attach mode", error);
-		},
-	});
-}
diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index 674376e4..88304ed6 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -18,7 +18,7 @@ const packageJson = JSON.parse(readFileSync(join(__dirname, "../package.json"),
 
 function printHelp(): void {
 	console.log(
-		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator attach <instance-id>\n  orchestrator --help\n  orchestrator --version\n\nAttach stdin expects JSONL RpcCommand or extension_ui_response messages.`,
+		`orchestrator v${packageJson.version}\n\nUsage:\n  orchestrator serve\n  orchestrator list\n  orchestrator spawn [--cwd <path>] [--label <label>]\n  orchestrator status <instance-id>\n  orchestrator stop <instance-id>\n  orchestrator rpc <instance-id> <json-command>\n  orchestrator rpc-stream <instance-id>\n  orchestrator --help\n  orchestrator --version\n\nRPC stream stdin expects JSONL RpcCommand or extension_ui_response messages.`,
 	);
 }
 
@@ -34,14 +34,14 @@ function getFlagValue(args: string[], flag: string): string | undefined {
 	return args[index + 1];
 }
 
-async function attach(instanceId: string): Promise<void> {
+async function rpcStream(instanceId: string): Promise<void> {
 	const socket = createConnection(getSocketPath());
 	let stdinBuffer = "";
 	process.stdin.setEncoding("utf8");
 
 	await new Promise<void>((resolve, reject) => {
 		socket.once("connect", () => {
-			socket.write(encodeMessage({ type: "attach", instanceId }));
+			socket.write(encodeMessage({ type: "rpc", instanceId }));
 			resolve();
 		});
 		socket.once("error", reject);
@@ -50,7 +50,7 @@ async function attach(instanceId: string): Promise<void> {
 	socket.on("data", (chunk: Buffer | string) => {
 		process.stdout.write(chunk.toString());
 	});
-	console.error(`attached to ${instanceId}; send JSONL RpcCommand or extension_ui_response on stdin`);
+	console.error(`connected to rpc stream ${instanceId}; send JSONL RpcCommand or extension_ui_response on stdin`);
 	socket.on("error", (error) => {
 		console.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
@@ -71,11 +71,7 @@ async function attach(instanceId: string): Promise<void> {
 				continue;
 			}
 			const parsed = JSON.parse(line) as RpcCommand | RpcExtensionUIResponse;
-			if (parsed.type === "extension_ui_response") {
-				socket.write(encodeMessage(parsed));
-				continue;
-			}
-			socket.write(encodeMessage({ type: "attach_rpc", command: parsed }));
+			socket.write(encodeMessage(parsed));
 		}
 	});
 }
@@ -147,13 +143,13 @@ async function main(): Promise<void> {
 		return;
 	}
 
-	if (args[0] === "attach") {
+	if (args[0] === "rpc-stream") {
 		const instanceId = args[1];
 		if (!instanceId) {
-			console.error("Usage: orchestrator attach <instance-id>");
+			console.error("Usage: orchestrator rpc-stream <instance-id>");
 			process.exit(1);
 		}
-		await attach(instanceId);
+		await rpcStream(instanceId);
 		return;
 	}
 
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 7d1c8ab3..1aea0219 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -3,12 +3,9 @@ import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
 	RpcExtensionUIResponse,
+	RpcResponse,
 } from "@earendil-works/pi-coding-agent";
 import type {
-	AttachHostContextRequest,
-	AttachReadyResponse,
-	AttachRequest,
-	AttachRpcResponse,
 	ErrorResponse,
 	InstanceSummary,
 	ListRequest,
@@ -16,6 +13,7 @@ import type {
 	OrchestratorRequest,
 	OrchestratorResponse,
 	RpcBridgeResponse,
+	RpcReadyResponse,
 	RpcRequest,
 	SpawnRequest,
 	SpawnResponse,
@@ -52,8 +50,9 @@ export async function handleIpcRequest(request: SpawnRequest): Promise<SpawnResp
 export async function handleIpcRequest(request: ListRequest): Promise<ListResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
-export async function handleIpcRequest(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse>;
-export async function handleIpcRequest(request: AttachRequest): Promise<AttachReadyResponse | ErrorResponse>;
+export async function handleIpcRequest(
+	request: RpcRequest,
+): Promise<RpcBridgeResponse | RpcReadyResponse | ErrorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
 	switch (request.type) {
@@ -104,6 +103,17 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 		}
 
 		case "rpc": {
+			if (!request.command) {
+				const instance = supervisor.getInstance(request.instanceId);
+				if (!instance) {
+					return unknownInstanceError(request.instanceId);
+				}
+				return {
+					type: "rpc_ready",
+					ok: true,
+					instance: toInstanceSummary(instance),
+				};
+			}
 			const response = await supervisor.handleRpc(request.instanceId, request.command);
 			if (!response) {
 				return unknownInstanceError(request.instanceId);
@@ -115,31 +125,17 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 				response,
 			};
 		}
-
-		case "attach": {
-			const instance = supervisor.getInstance(request.instanceId);
-			if (!instance) {
-				return unknownInstanceError(request.instanceId);
-			}
-			return {
-				type: "attach_ready",
-				ok: true,
-				instance: toInstanceSummary(instance),
-			};
-		}
 	}
 }
 
 export function attachIpcInstance(
 	instanceId: string,
-	onResponse: (response: AttachRpcResponse) => void,
+	onResponse: (response: RpcResponse) => void,
 	onSessionEvent: (event: AgentSessionEvent) => void,
 	onUiRequest: (request: RpcExtensionUIRequest) => void,
 ):
 	| {
-			handleRequest(
-				request: { type: "attach_rpc"; command: RpcCommand } | AttachHostContextRequest | RpcExtensionUIResponse,
-			): Promise<void>;
+			handleRequest(request: RpcCommand | RpcExtensionUIResponse): Promise<void>;
 			close(): void;
 	  }
 	| undefined {
@@ -150,16 +146,12 @@ export function attachIpcInstance(
 
 	return {
 		async handleRequest(request): Promise<void> {
-			if (request.type === "attach_rpc") {
-				const response = await handle.handleRpc(request.command);
-				onResponse({ type: "attach_rpc_result", response });
+			if (request.type === "extension_ui_response") {
+				handle.handleUiResponse(request);
 				return;
 			}
-			if (request.type === "attach_host_context") {
-				handle.setHostTheme(request.theme);
-				return;
-			}
-			handle.handleUiResponse(request);
+			const response = await handle.handleRpc(request);
+			onResponse(response);
 		},
 		close(): void {
 			handle.close();
diff --git a/packages/orchestrator/src/index.ts b/packages/orchestrator/src/index.ts
index cfa24b03..8f1c28df 100644
--- a/packages/orchestrator/src/index.ts
+++ b/packages/orchestrator/src/index.ts
@@ -3,6 +3,7 @@ export * from "./handler.ts";
 export * from "./ipc/client.ts";
 export * from "./ipc/protocol.ts";
 export * from "./ipc/server.ts";
+export * from "./rpc-process.ts";
 export * from "./serve.ts";
 export * from "./storage.ts";
 export * from "./supervisor.ts";
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index 1f4040a0..ab6af46e 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -32,22 +32,7 @@ export interface StatusRequest {
 export interface RpcRequest {
 	type: "rpc";
 	instanceId: string;
-	command: RpcCommand;
-}
-
-export interface AttachRequest {
-	type: "attach";
-	instanceId: string;
-}
-
-export interface AttachRpcRequest {
-	type: "attach_rpc";
-	command: RpcCommand;
-}
-
-export interface AttachHostContextRequest {
-	type: "attach_host_context";
-	theme?: unknown;
+	command?: RpcCommand;
 }
 
 export interface RequestMap {
@@ -56,7 +41,6 @@ export interface RequestMap {
 	stop: StopRequest;
 	status: StatusRequest;
 	rpc: RpcRequest;
-	attach: AttachRequest;
 }
 
 export type OrchestratorRequest = RequestMap[keyof RequestMap];
@@ -101,21 +85,11 @@ export interface RpcBridgeResponse extends ResponseBase {
 	response: RpcResponse;
 }
 
-export interface AttachReadyResponse extends ResponseBase {
-	type: "attach_ready";
+export interface RpcReadyResponse extends ResponseBase {
+	type: "rpc_ready";
 	instance?: InstanceSummary;
 }
 
-export interface AttachEventResponse {
-	type: "attach_event";
-	event: AgentSessionEvent;
-}
-
-export interface AttachRpcResponse {
-	type: "attach_rpc_result";
-	response: RpcResponse;
-}
-
 export interface ErrorResponse extends ResponseBase {
 	type: "error";
 	ok: false;
@@ -127,19 +101,18 @@ export interface ResponseMap {
 	list: ListResponse;
 	stop: StopResponse;
 	status: StatusResponse;
-	rpc: RpcBridgeResponse;
-	attach: AttachReadyResponse;
+	rpc: RpcBridgeResponse | RpcReadyResponse;
 }
 
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
-export type AttachClientRequest = AttachRpcRequest | AttachHostContextRequest | RpcExtensionUIResponse;
-export type AttachServerResponse =
-	| AttachReadyResponse
-	| AttachEventResponse
-	| AttachRpcResponse
+export type RpcClientMessage = RpcCommand | RpcExtensionUIResponse;
+export type RpcServerMessage =
+	| RpcReadyResponse
+	| RpcResponse
+	| AgentSessionEvent
 	| RpcExtensionUIRequest
 	| ErrorResponse;
-export type ProtocolMessage = OrchestratorRequest | OrchestratorResponse | AttachClientRequest | AttachServerResponse;
+export type ProtocolMessage = OrchestratorRequest | OrchestratorResponse | RpcClientMessage | RpcServerMessage;
 
 export type ResponseFor<T extends OrchestratorRequest> = T extends { type: infer K }
 	? K extends keyof ResponseMap
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index bb43a0a1..b6a6afab 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -2,10 +2,6 @@ import { existsSync, unlinkSync } from "node:fs";
 import { createConnection, createServer, type Server } from "node:net";
 import { getSocketPath } from "../config.ts";
 import {
-	type AttachClientRequest,
-	type AttachReadyResponse,
-	type AttachRequest,
-	type AttachRpcResponse,
 	type ErrorResponse,
 	encodeMessage,
 	type ListRequest,
@@ -14,6 +10,8 @@ import {
 	type OrchestratorResponse,
 	parseRequestLine,
 	type RpcBridgeResponse,
+	type RpcClientMessage,
+	type RpcReadyResponse,
 	type RpcRequest,
 	type SpawnRequest,
 	type SpawnResponse,
@@ -28,17 +26,22 @@ export interface IpcRequestHandler {
 	(request: ListRequest): Promise<ListResponse | ErrorResponse> | ListResponse | ErrorResponse;
 	(request: StopRequest): Promise<StopResponse | ErrorResponse> | StopResponse | ErrorResponse;
 	(request: StatusRequest): Promise<StatusResponse | ErrorResponse> | StatusResponse | ErrorResponse;
-	(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse> | RpcBridgeResponse | ErrorResponse;
-	(request: AttachRequest): Promise<AttachReadyResponse | ErrorResponse> | AttachReadyResponse | ErrorResponse;
+	(
+		request: RpcRequest,
+	):
+		| Promise<RpcBridgeResponse | RpcReadyResponse | ErrorResponse>
+		| RpcBridgeResponse
+		| RpcReadyResponse
+		| ErrorResponse;
 	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
 	attach(
 		instanceId: string,
-		onEvent: (response: AttachRpcResponse) => void,
+		onResponse: (response: import("@earendil-works/pi-coding-agent").RpcResponse) => void,
 		onSessionEvent: (event: import("@earendil-works/pi-coding-agent").AgentSessionEvent) => void,
 		onUiRequest: (request: import("@earendil-works/pi-coding-agent").RpcExtensionUIRequest) => void,
 	):
 		| {
-				handleRequest(request: AttachClientRequest): Promise<void>;
+				handleRequest(request: RpcClientMessage): Promise<void>;
 				close(): void;
 		  }
 		| undefined;
@@ -66,9 +69,9 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 
 			try {
 				const request = parseRequestLine(line);
-				if (request.type === "attach") {
+				if (request.type === "rpc" && request.command === undefined) {
 					const response = await handler(request);
-					if (!response.ok || !response.instance) {
+					if (!response.ok || response.type !== "rpc_ready" || !response.instance) {
 						socket.end(encodeMessage(response));
 						return;
 					}
@@ -79,7 +82,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 							socket.write(encodeMessage(response));
 						},
 						(event) => {
-							socket.write(encodeMessage({ type: "attach_event", event }));
+							socket.write(encodeMessage(event));
 						},
 						(request) => {
 							socket.write(encodeMessage(request));
@@ -94,28 +97,28 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 
 					socket.write(encodeMessage(response));
 					socket.removeAllListeners("data");
-					socket.on("data", (attachChunk: Buffer | string) => {
-						buffer += attachChunk.toString();
+					socket.on("data", (rpcChunk: Buffer | string) => {
+						buffer += rpcChunk.toString();
 						for (;;) {
-							const attachNewlineIndex = buffer.indexOf("\n");
-							if (attachNewlineIndex === -1) {
+							const rpcNewlineIndex = buffer.indexOf("\n");
+							if (rpcNewlineIndex === -1) {
 								break;
 							}
-							const attachLine = buffer.slice(0, attachNewlineIndex).trim();
-							buffer = buffer.slice(attachNewlineIndex + 1);
-							if (!attachLine) {
+							const rpcLine = buffer.slice(0, rpcNewlineIndex).trim();
+							buffer = buffer.slice(rpcNewlineIndex + 1);
+							if (!rpcLine) {
 								continue;
 							}
 							void (async () => {
 								try {
-									const attachRequest = JSON.parse(attachLine) as AttachClientRequest;
-									await attachment.handleRequest(attachRequest);
-								} catch (attachError) {
+									const rpcRequest = JSON.parse(rpcLine) as RpcClientMessage;
+									await attachment.handleRequest(rpcRequest);
+								} catch (rpcError) {
 									socket.write(
 										encodeMessage({
 											type: "error",
 											ok: false,
-											error: attachError instanceof Error ? attachError.message : String(attachError),
+											error: rpcError instanceof Error ? rpcError.message : String(rpcError),
 										}),
 									);
 								}
diff --git a/packages/orchestrator/src/rpc-bridge.ts b/packages/orchestrator/src/rpc-bridge.ts
deleted file mode 100644
index 7a6cfa8d..00000000
--- a/packages/orchestrator/src/rpc-bridge.ts
+++ /dev/null
@@ -1,246 +0,0 @@
-import type { AgentSessionRuntime, RpcCommand, RpcResponse, RpcSessionState } from "@earendil-works/pi-coding-agent";
-
-function success<T extends RpcCommand["type"]>(id: string | undefined, command: T, data?: object | null): RpcResponse {
-	if (data === undefined) {
-		return { id, type: "response", command, success: true } as RpcResponse;
-	}
-	return { id, type: "response", command, success: true, data } as RpcResponse;
-}
-
-function error(id: string | undefined, command: string, message: string): RpcResponse {
-	return { id, type: "response", command, success: false, error: message };
-}
-
-function assertNeverRpcCommand(command: never): never {
-	throw new Error(`Unknown command: ${(command as { type: string }).type}`);
-}
-
-export async function handleRpcCommand(runtime: AgentSessionRuntime, command: RpcCommand): Promise<RpcResponse> {
-	const session = runtime.session;
-	const id = command.id;
-
-	switch (command.type) {
-		case "prompt": {
-			return await new Promise<RpcResponse>((resolve) => {
-				let settled = false;
-				void session
-					.prompt(command.message, {
-						images: command.images,
-						streamingBehavior: command.streamingBehavior,
-						source: "rpc",
-						preflightResult: (didSucceed) => {
-							if (!settled && didSucceed) {
-								settled = true;
-								resolve(success(id, "prompt"));
-							}
-						},
-					})
-					.catch((rpcError: unknown) => {
-						if (!settled) {
-							settled = true;
-							resolve(error(id, "prompt", rpcError instanceof Error ? rpcError.message : String(rpcError)));
-						}
-					});
-			});
-		}
-
-		case "steer": {
-			await session.steer(command.message, command.images);
-			return success(id, "steer");
-		}
-
-		case "follow_up": {
-			await session.followUp(command.message, command.images);
-			return success(id, "follow_up");
-		}
-
-		case "abort": {
-			await session.abort();
-			return success(id, "abort");
-		}
-
-		case "new_session": {
-			const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
-			const result = await runtime.newSession(options);
-			return success(id, "new_session", result);
-		}
-
-		case "switch_session": {
-			const result = await runtime.switchSession(command.sessionPath);
-			return success(id, "switch_session", result);
-		}
-
-		case "fork": {
-			const result = await runtime.fork(command.entryId);
-			return success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
-		}
-
-		case "clone": {
-			const leafId = session.sessionManager.getLeafId();
-			if (!leafId) {
-				return error(id, "clone", "Cannot clone session: no current entry selected");
-			}
-			const result = await runtime.fork(leafId, { position: "at" });
-			return success(id, "clone", { cancelled: result.cancelled });
-		}
-
-		case "get_state": {
-			const state: RpcSessionState = {
-				model: session.model,
-				thinkingLevel: session.thinkingLevel,
-				isStreaming: session.isStreaming,
-				isCompacting: session.isCompacting,
-				steeringMode: session.steeringMode,
-				followUpMode: session.followUpMode,
-				sessionFile: session.sessionFile,
-				sessionId: session.sessionId,
-				sessionName: session.sessionName,
-				autoCompactionEnabled: session.autoCompactionEnabled,
-				messageCount: session.messages.length,
-				pendingMessageCount: session.pendingMessageCount,
-			};
-			return success(id, "get_state", state);
-		}
-
-		case "set_model": {
-			const models = await session.modelRegistry.getAvailable();
-			const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
-			if (!model) {
-				return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
-			}
-			await session.setModel(model);
-			return success(id, "set_model", model);
-		}
-
-		case "cycle_model": {
-			const result = await session.cycleModel();
-			return success(id, "cycle_model", result ?? null);
-		}
-
-		case "get_available_models": {
-			const models = await session.modelRegistry.getAvailable();
-			return success(id, "get_available_models", { models });
-		}
-
-		case "set_thinking_level": {
-			session.setThinkingLevel(command.level);
-			return success(id, "set_thinking_level");
-		}
-
-		case "cycle_thinking_level": {
-			const level = session.cycleThinkingLevel();
-			return success(id, "cycle_thinking_level", level ? { level } : null);
-		}
-
-		case "set_steering_mode": {
-			session.setSteeringMode(command.mode);
-			return success(id, "set_steering_mode");
-		}
-
-		case "set_follow_up_mode": {
-			session.setFollowUpMode(command.mode);
-			return success(id, "set_follow_up_mode");
-		}
-
-		case "compact": {
-			const result = await session.compact(command.customInstructions);
-			return success(id, "compact", result);
-		}
-
-		case "set_auto_compaction": {
-			session.setAutoCompactionEnabled(command.enabled);
-			return success(id, "set_auto_compaction");
-		}
-
-		case "set_auto_retry": {
-			session.setAutoRetryEnabled(command.enabled);
-			return success(id, "set_auto_retry");
-		}
-
-		case "abort_retry": {
-			session.abortRetry();
-			return success(id, "abort_retry");
-		}
-
-		case "bash": {
-			const result = await session.executeBash(command.command, undefined, {
-				excludeFromContext: command.excludeFromContext,
-			});
-			return success(id, "bash", result);
-		}
-
-		case "abort_bash": {
-			session.abortBash();
-			return success(id, "abort_bash");
-		}
-
-		case "get_session_stats": {
-			const stats = session.getSessionStats();
-			return success(id, "get_session_stats", stats);
-		}
-
-		case "export_html": {
-			const path = await session.exportToHtml(command.outputPath);
-			return success(id, "export_html", { path });
-		}
-
-		case "get_fork_messages": {
-			const messages = session.getUserMessagesForForking();
-			return success(id, "get_fork_messages", { messages });
-		}
-
-		case "get_last_assistant_text": {
-			const text = session.getLastAssistantText();
-			return success(id, "get_last_assistant_text", { text });
-		}
-
-		case "set_session_name": {
-			const name = command.name.trim();
-			if (!name) {
-				return error(id, "set_session_name", "Session name cannot be empty");
-			}
-			session.setSessionName(name);
-			return success(id, "set_session_name");
-		}
-
-		case "get_messages": {
-			return success(id, "get_messages", { messages: session.messages });
-		}
-
-		case "get_commands": {
-			const commands = [];
-
-			for (const registeredCommand of session.extensionRunner.getRegisteredCommands()) {
-				commands.push({
-					name: registeredCommand.invocationName,
-					description: registeredCommand.description,
-					source: "extension",
-					sourceInfo: registeredCommand.sourceInfo,
-				});
-			}
-
-			for (const template of session.promptTemplates) {
-				commands.push({
-					name: template.name,
-					description: template.description,
-					source: "prompt",
-					sourceInfo: template.sourceInfo,
-				});
-			}
-
-			for (const skill of session.resourceLoader.getSkills().skills) {
-				commands.push({
-					name: `skill:${skill.name}`,
-					description: skill.description,
-					source: "skill",
-					sourceInfo: skill.sourceInfo,
-				});
-			}
-
-			return success(id, "get_commands", { commands });
-		}
-
-		default:
-			return assertNeverRpcCommand(command);
-	}
-}
diff --git a/packages/orchestrator/src/rpc-process.ts b/packages/orchestrator/src/rpc-process.ts
new file mode 100644
index 00000000..99da6ab0
--- /dev/null
+++ b/packages/orchestrator/src/rpc-process.ts
@@ -0,0 +1,183 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import type {
+	AgentSessionEvent,
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+	RpcResponse,
+} from "@earendil-works/pi-coding-agent";
+
+interface PendingRequest {
+	resolve(response: RpcResponse): void;
+	reject(error: Error): void;
+}
+
+export interface RpcProcessInstance {
+	process: ChildProcess;
+	send(command: RpcCommand): Promise<RpcResponse>;
+	handleUiResponse(response: RpcExtensionUIResponse): void;
+	setUiRequestHandler(handler?: (request: RpcExtensionUIRequest) => void): void;
+	onEvent(listener: (event: AgentSessionEvent) => void): () => void;
+	onExit(listener: (error?: Error) => void): () => void;
+	dispose(): Promise<void>;
+}
+
+function resolveCodingAgentCli(): string {
+	const require = createRequire(import.meta.url);
+	return require.resolve("@earendil-works/pi-coding-agent/dist/cli.js");
+}
+
+function toError(error: unknown): Error {
+	return error instanceof Error ? error : new Error(String(error));
+}
+
+export function createRpcProcessInstance(options: { cwd: string }): RpcProcessInstance {
+	const cliPath = resolveCodingAgentCli();
+	const child = spawn(process.execPath, [cliPath, "--mode", "rpc"], {
+		cwd: options.cwd,
+		env: process.env,
+		stdio: ["pipe", "pipe", "pipe"],
+	});
+	if (!child.stdin || !child.stdout) {
+		throw new Error("Failed to create RPC process stdio");
+	}
+
+	let exited = false;
+	let nextRequestId = 0;
+	let stdoutBuffer = "";
+	let stderrBuffer = "";
+	const pendingRequests = new Map<string, PendingRequest>();
+	const eventListeners = new Set<(event: AgentSessionEvent) => void>();
+	const exitListeners = new Set<(error?: Error) => void>();
+
+	const rejectAllPending = (error: Error) => {
+		for (const [id, pending] of pendingRequests) {
+			pendingRequests.delete(id);
+			pending.reject(error);
+		}
+	};
+
+	const notifyExit = (error?: Error) => {
+		for (const listener of exitListeners) {
+			listener(error);
+		}
+	};
+
+	let uiRequestHandler: ((request: RpcExtensionUIRequest) => void) | undefined;
+
+	const handleLine = (line: string) => {
+		const parsed = JSON.parse(line) as { type?: string; id?: string };
+		if (parsed.type === "response") {
+			if (parsed.id) {
+				const pending = pendingRequests.get(parsed.id);
+				if (pending) {
+					pendingRequests.delete(parsed.id);
+					pending.resolve(parsed as RpcResponse);
+				}
+			}
+			return;
+		}
+
+		if (parsed.type === "extension_ui_request") {
+			uiRequestHandler?.(parsed as RpcExtensionUIRequest);
+			return;
+		}
+
+		for (const listener of eventListeners) {
+			listener(parsed as AgentSessionEvent);
+		}
+	};
+
+	child.stdout.setEncoding("utf8");
+	child.stdout.on("data", (chunk: string) => {
+		stdoutBuffer += chunk;
+		while (true) {
+			const newlineIndex = stdoutBuffer.indexOf("\n");
+			if (newlineIndex === -1) {
+				break;
+			}
+			const line = stdoutBuffer.slice(0, newlineIndex).trim();
+			stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+			if (!line) {
+				continue;
+			}
+			handleLine(line);
+		}
+	});
+
+	child.stderr?.setEncoding("utf8");
+	child.stderr?.on("data", (chunk: string) => {
+		stderrBuffer += chunk;
+	});
+
+	child.once("error", (error) => {
+		exited = true;
+		const wrapped = new Error(`RPC process error: ${error.message}. Stderr: ${stderrBuffer}`);
+		rejectAllPending(wrapped);
+		notifyExit(wrapped);
+	});
+
+	child.once("exit", (code, signal) => {
+		exited = true;
+		const error = new Error(`RPC process exited (code=${code} signal=${signal}). Stderr: ${stderrBuffer}`);
+		rejectAllPending(error);
+		notifyExit(error);
+	});
+
+	const send = async (command: RpcCommand): Promise<RpcResponse> => {
+		if (exited) {
+			throw new Error(`RPC process is not running. Stderr: ${stderrBuffer}`);
+		}
+		const id = command.id ?? `orchestrator_${++nextRequestId}_${randomUUID()}`;
+		const fullCommand = { ...command, id };
+		return new Promise<RpcResponse>((resolve, reject) => {
+			pendingRequests.set(id, { resolve, reject });
+			child.stdin.write(`${JSON.stringify(fullCommand)}\n`, (error) => {
+				if (!error) {
+					return;
+				}
+				pendingRequests.delete(id);
+				reject(toError(error));
+			});
+		});
+	};
+
+	return {
+		process: child,
+		send,
+		handleUiResponse(response) {
+			if (exited) {
+				return;
+			}
+			child.stdin.write(`${JSON.stringify(response)}\n`);
+		},
+		setUiRequestHandler(handler) {
+			uiRequestHandler = handler;
+		},
+		onEvent(listener) {
+			eventListeners.add(listener);
+			return () => {
+				eventListeners.delete(listener);
+			};
+		},
+		onExit(listener) {
+			exitListeners.add(listener);
+			return () => {
+				exitListeners.delete(listener);
+			};
+		},
+		async dispose() {
+			uiRequestHandler = undefined;
+			rejectAllPending(new Error("RPC process disposed"));
+			if (exited) {
+				return;
+			}
+			child.kill("SIGTERM");
+			await new Promise<void>((resolve) => {
+				child.once("exit", () => resolve());
+			});
+		},
+	};
+}
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 24dddfbd..070edadd 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -1,90 +1,80 @@
 import { randomUUID } from "node:crypto";
-import {
-	type AgentSessionEvent,
-	type AgentSessionEventListener,
-	type AgentSessionRuntime,
-	type CreateAgentSessionRuntimeFactory,
-	createAgentSessionFromServices,
-	createAgentSessionRuntime,
-	createAgentSessionServices,
-	getAgentDir,
-	type RpcCommand,
-	type RpcExtensionUIRequest,
-	type RpcExtensionUIResponse,
-	type RpcResponse,
-	SessionManager,
+import type {
+	AgentSessionEvent,
+	AgentSessionEventListener,
+	RpcCommand,
+	RpcExtensionUIRequest,
+	RpcExtensionUIResponse,
+	RpcResponse,
 } from "@earendil-works/pi-coding-agent";
-import { AttachUiBridge, bindAttachExtensions } from "./attach-ui.ts";
 import { radiusPresence } from "./radius.ts";
-import { handleRpcCommand } from "./rpc-bridge.ts";
+import { createRpcProcessInstance, type RpcProcessInstance } from "./rpc-process.ts";
 import { getInstance, loadInstances, removeInstance, saveInstances, upsertInstance } from "./storage.ts";
 import type { InstanceRecord } from "./types.ts";
 
 interface LiveInstance {
-	runtime: AgentSessionRuntime;
+	rpc: RpcProcessInstance;
 	record: InstanceRecord;
 	subscribers: Set<AgentSessionEventListener>;
-	uiBridge: AttachUiBridge;
-	unsubscribeSession?: () => void;
+	onUiRequest?: (request: RpcExtensionUIRequest) => void;
+	unsubscribeEvents?: () => void;
+	unsubscribeExit?: () => void;
 }
 
 function cloneInstance(record: InstanceRecord): InstanceRecord {
 	return { ...record };
 }
 
-async function createRuntime(cwd: string): Promise<AgentSessionRuntime> {
-	const agentDir = getAgentDir();
-	const sessionManager = SessionManager.create(cwd);
-	const runtimeFactory: CreateAgentSessionRuntimeFactory = async ({
-		cwd,
-		agentDir,
-		sessionManager,
-		sessionStartEvent,
-	}) => {
-		const services = await createAgentSessionServices({ cwd, agentDir });
-		const created = await createAgentSessionFromServices({
-			services,
-			sessionManager,
-			sessionStartEvent,
-		});
-		return {
-			...created,
-			services,
-			diagnostics: services.diagnostics,
-		};
-	};
-
-	return createAgentSessionRuntime(runtimeFactory, {
-		cwd,
-		agentDir,
-		sessionManager,
-	});
+function isGetStateSuccess(
+	response: RpcResponse,
+): response is Extract<
+	RpcResponse,
+	{ success: true; command: "get_state"; data: { sessionId: string; sessionFile?: string } }
+> {
+	return response.success === true && response.command === "get_state" && "data" in response;
 }
 
 export class OrchestratorSupervisor {
 	private readonly liveInstances = new Map<string, LiveInstance>();
 
-	private syncInstanceRecord(live: LiveInstance): void {
+	private async syncInstanceRecord(live: LiveInstance): Promise<void> {
+		const response = await live.rpc.send({ type: "get_state" });
+		if (!isGetStateSuccess(response)) {
+			live.record = {
+				...live.record,
+				lastSeenAt: new Date().toISOString(),
+			};
+			upsertInstance(live.record);
+			return;
+		}
 		live.record = {
 			...live.record,
-			sessionId: live.runtime.session.sessionId,
-			sessionFile: live.runtime.session.sessionFile,
+			sessionId: response.data.sessionId,
+			sessionFile: response.data.sessionFile,
 			lastSeenAt: new Date().toISOString(),
 		};
 		upsertInstance(live.record);
 	}
 
-	private async bindLiveInstance(live: LiveInstance): Promise<void> {
-		await bindAttachExtensions(live.runtime, live.uiBridge);
-		live.unsubscribeSession?.();
-		live.unsubscribeSession = live.runtime.session.subscribe((event) => {
+	private bindLiveInstance(live: LiveInstance): void {
+		live.unsubscribeEvents?.();
+		live.unsubscribeExit?.();
+		live.unsubscribeEvents = live.rpc.onEvent((event) => {
 			for (const subscriber of live.subscribers) {
 				subscriber(event);
 			}
 		});
-		live.runtime.setRebindSession(async () => {
-			this.syncInstanceRecord(live);
-			await this.bindLiveInstance(live);
+		live.unsubscribeExit = live.rpc.onExit(() => {
+			live.record = {
+				...live.record,
+				status: "stopped",
+				lastSeenAt: new Date().toISOString(),
+			};
+			upsertInstance(live.record);
+			this.liveInstances.delete(live.record.id);
+		});
+		live.rpc.setUiRequestHandler((request) => {
+			live.onUiRequest?.(request);
 		});
 	}
 
@@ -113,23 +103,22 @@ export class OrchestratorSupervisor {
 			return undefined;
 		}
 		live.subscribers.add(onEvent);
-		const detachUi = live.uiBridge.attach(onUiRequest);
+		live.onUiRequest = onUiRequest;
 		return {
 			handleRpc: async (command) => {
-				const response = await handleRpcCommand(live.runtime, command);
-				this.syncInstanceRecord(live);
+				const response = await live.rpc.send(command);
+				await this.syncInstanceRecord(live);
 				return response;
 			},
 			handleUiResponse: (response) => {
-				live.uiBridge.handleResponse(response);
-			},
-			setHostTheme: (theme) => {
-				live.uiBridge.setThemeOverride(theme);
+				live.rpc.handleUiResponse(response);
 			},
+			setHostTheme: (_theme) => {},
 			close: () => {
-				detachUi();
+				if (live.onUiRequest === onUiRequest) {
+					live.onUiRequest = undefined;
+				}
 				live.subscribers.delete(onEvent);
-				live.uiBridge.cancelPendingRequests();
 			},
 		};
 	}
@@ -170,7 +159,7 @@ export class OrchestratorSupervisor {
 	}
 
 	async spawnInstance(options: { cwd: string; label?: string }): Promise<InstanceRecord> {
-		const runtime = await createRuntime(options.cwd);
+		const rpc = createRpcProcessInstance({ cwd: options.cwd });
 		const now = new Date().toISOString();
 		const record: InstanceRecord = {
 			id: randomUUID(),
@@ -179,21 +168,19 @@ export class OrchestratorSupervisor {
 			createdAt: now,
 			lastSeenAt: now,
 			label: options.label,
-			sessionId: runtime.session.sessionId,
-			sessionFile: runtime.session.sessionFile,
 		};
 
 		const registeredRecord = await radiusPresence.registerPi(record);
 		const live: LiveInstance = {
-			runtime,
+			rpc,
 			record: registeredRecord,
 			subscribers: new Set(),
-			uiBridge: new AttachUiBridge(),
 		};
-		await this.bindLiveInstance(live);
+		this.bindLiveInstance(live);
 		this.liveInstances.set(registeredRecord.id, live);
-		upsertInstance(registeredRecord);
-		return cloneInstance(registeredRecord);
+		await this.syncInstanceRecord(live);
+		upsertInstance(live.record);
+		return cloneInstance(live.record);
 	}
 
 	async stopInstance(instanceId: string): Promise<InstanceRecord | undefined> {
@@ -203,10 +190,10 @@ export class OrchestratorSupervisor {
 		}
 
 		await radiusPresence.disconnectPi(live.record);
-		live.unsubscribeSession?.();
-		live.uiBridge.cancelPendingRequests();
-		live.runtime.setRebindSession(undefined);
-		await live.runtime.dispose();
+		live.unsubscribeEvents?.();
+		live.unsubscribeExit?.();
+		live.onUiRequest = undefined;
+		await live.rpc.dispose();
 		this.liveInstances.delete(instanceId);
 		removeInstance(instanceId);
 		return cloneInstance(live.record);
@@ -218,8 +205,8 @@ export class OrchestratorSupervisor {
 			return undefined;
 		}
 
-		const response = await handleRpcCommand(live.runtime, command);
-		this.syncInstanceRecord(live);
+		const response = await live.rpc.send(command);
+		await this.syncInstanceRecord(live);
 		return response;
 	}
 

From d79e3061ad13b6e7443c74fa24a9c66bba8bdaaf Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Mon, 22 Jun 2026 14:53:07 +0200
Subject: [PATCH 23/36] cleanup: one shot vs stream

---
 packages/orchestrator/src/cli.ts          |  2 +-
 packages/orchestrator/src/handler.ts      | 29 ++++++++++++-----------
 packages/orchestrator/src/ipc/protocol.ts | 11 +++++++--
 packages/orchestrator/src/ipc/server.ts   | 12 ++++------
 packages/orchestrator/src/supervisor.ts   |  2 --
 5 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/packages/orchestrator/src/cli.ts b/packages/orchestrator/src/cli.ts
index 88304ed6..856dd658 100644
--- a/packages/orchestrator/src/cli.ts
+++ b/packages/orchestrator/src/cli.ts
@@ -41,7 +41,7 @@ async function rpcStream(instanceId: string): Promise<void> {
 
 	await new Promise<void>((resolve, reject) => {
 		socket.once("connect", () => {
-			socket.write(encodeMessage({ type: "rpc", instanceId }));
+			socket.write(encodeMessage({ type: "rpc_stream", instanceId }));
 			resolve();
 		});
 		socket.once("error", reject);
diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 1aea0219..89fcb154 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -15,6 +15,7 @@ import type {
 	RpcBridgeResponse,
 	RpcReadyResponse,
 	RpcRequest,
+	RpcStreamRequest,
 	SpawnRequest,
 	SpawnResponse,
 	StatusRequest,
@@ -50,9 +51,8 @@ export async function handleIpcRequest(request: SpawnRequest): Promise<SpawnResp
 export async function handleIpcRequest(request: ListRequest): Promise<ListResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StopRequest): Promise<StopResponse | ErrorResponse>;
 export async function handleIpcRequest(request: StatusRequest): Promise<StatusResponse | ErrorResponse>;
-export async function handleIpcRequest(
-	request: RpcRequest,
-): Promise<RpcBridgeResponse | RpcReadyResponse | ErrorResponse>;
+export async function handleIpcRequest(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse>;
+export async function handleIpcRequest(request: RpcStreamRequest): Promise<RpcReadyResponse | ErrorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse>;
 export async function handleIpcRequest(request: OrchestratorRequest): Promise<OrchestratorResponse> {
 	switch (request.type) {
@@ -103,17 +103,6 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 		}
 
 		case "rpc": {
-			if (!request.command) {
-				const instance = supervisor.getInstance(request.instanceId);
-				if (!instance) {
-					return unknownInstanceError(request.instanceId);
-				}
-				return {
-					type: "rpc_ready",
-					ok: true,
-					instance: toInstanceSummary(instance),
-				};
-			}
 			const response = await supervisor.handleRpc(request.instanceId, request.command);
 			if (!response) {
 				return unknownInstanceError(request.instanceId);
@@ -125,6 +114,18 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 				response,
 			};
 		}
+
+		case "rpc_stream": {
+			const instance = supervisor.getInstance(request.instanceId);
+			if (!instance) {
+				return unknownInstanceError(request.instanceId);
+			}
+			return {
+				type: "rpc_ready",
+				ok: true,
+				instance: toInstanceSummary(instance),
+			};
+		}
 	}
 }
 
diff --git a/packages/orchestrator/src/ipc/protocol.ts b/packages/orchestrator/src/ipc/protocol.ts
index ab6af46e..0f9f09ed 100644
--- a/packages/orchestrator/src/ipc/protocol.ts
+++ b/packages/orchestrator/src/ipc/protocol.ts
@@ -32,7 +32,12 @@ export interface StatusRequest {
 export interface RpcRequest {
 	type: "rpc";
 	instanceId: string;
-	command?: RpcCommand;
+	command: RpcCommand;
+}
+
+export interface RpcStreamRequest {
+	type: "rpc_stream";
+	instanceId: string;
 }
 
 export interface RequestMap {
@@ -41,6 +46,7 @@ export interface RequestMap {
 	stop: StopRequest;
 	status: StatusRequest;
 	rpc: RpcRequest;
+	rpc_stream: RpcStreamRequest;
 }
 
 export type OrchestratorRequest = RequestMap[keyof RequestMap];
@@ -101,7 +107,8 @@ export interface ResponseMap {
 	list: ListResponse;
 	stop: StopResponse;
 	status: StatusResponse;
-	rpc: RpcBridgeResponse | RpcReadyResponse;
+	rpc: RpcBridgeResponse;
+	rpc_stream: RpcReadyResponse;
 }
 
 export type OrchestratorResponse = ResponseMap[keyof ResponseMap] | ErrorResponse;
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index b6a6afab..1c45a6db 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -13,6 +13,7 @@ import {
 	type RpcClientMessage,
 	type RpcReadyResponse,
 	type RpcRequest,
+	type RpcStreamRequest,
 	type SpawnRequest,
 	type SpawnResponse,
 	type StatusRequest,
@@ -26,13 +27,8 @@ export interface IpcRequestHandler {
 	(request: ListRequest): Promise<ListResponse | ErrorResponse> | ListResponse | ErrorResponse;
 	(request: StopRequest): Promise<StopResponse | ErrorResponse> | StopResponse | ErrorResponse;
 	(request: StatusRequest): Promise<StatusResponse | ErrorResponse> | StatusResponse | ErrorResponse;
-	(
-		request: RpcRequest,
-	):
-		| Promise<RpcBridgeResponse | RpcReadyResponse | ErrorResponse>
-		| RpcBridgeResponse
-		| RpcReadyResponse
-		| ErrorResponse;
+	(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse> | RpcBridgeResponse | ErrorResponse;
+	(request: RpcStreamRequest): Promise<RpcReadyResponse | ErrorResponse> | RpcReadyResponse | ErrorResponse;
 	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
 	attach(
 		instanceId: string,
@@ -69,7 +65,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 
 			try {
 				const request = parseRequestLine(line);
-				if (request.type === "rpc" && request.command === undefined) {
+				if (request.type === "rpc_stream") {
 					const response = await handler(request);
 					if (!response.ok || response.type !== "rpc_ready" || !response.instance) {
 						socket.end(encodeMessage(response));
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index 070edadd..bb484f49 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -94,7 +94,6 @@ export class OrchestratorSupervisor {
 		| {
 				handleRpc(command: RpcCommand): Promise<RpcResponse>;
 				handleUiResponse(response: RpcExtensionUIResponse): void;
-				setHostTheme(theme: unknown): void;
 				close(): void;
 		  }
 		| undefined {
@@ -113,7 +112,6 @@ export class OrchestratorSupervisor {
 			handleUiResponse: (response) => {
 				live.rpc.handleUiResponse(response);
 			},
-			setHostTheme: (_theme) => {},
 			close: () => {
 				if (live.onUiRequest === onUiRequest) {
 					live.onUiRequest = undefined;

From 555ab2e5482b1617b244c2dd2cf6eeb25d846e99 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Mon, 22 Jun 2026 14:56:41 +0200
Subject: [PATCH 24/36] cleanup: small optimizations

---
 packages/orchestrator/src/handler.ts     |  4 +--
 packages/orchestrator/src/ipc/server.ts  | 10 +++----
 packages/orchestrator/src/rpc-process.ts | 37 ++++++++++++++----------
 packages/orchestrator/src/serve.ts       |  4 +--
 packages/orchestrator/src/supervisor.ts  | 30 +++++++++++++++++--
 5 files changed, 58 insertions(+), 27 deletions(-)

diff --git a/packages/orchestrator/src/handler.ts b/packages/orchestrator/src/handler.ts
index 89fcb154..fbffa971 100644
--- a/packages/orchestrator/src/handler.ts
+++ b/packages/orchestrator/src/handler.ts
@@ -129,7 +129,7 @@ export async function handleIpcRequest(request: OrchestratorRequest): Promise<Or
 	}
 }
 
-export function attachIpcInstance(
+export function openRpcStream(
 	instanceId: string,
 	onResponse: (response: RpcResponse) => void,
 	onSessionEvent: (event: AgentSessionEvent) => void,
@@ -140,7 +140,7 @@ export function attachIpcInstance(
 			close(): void;
 	  }
 	| undefined {
-	const handle = supervisor.attachInstance(instanceId, onSessionEvent, onUiRequest);
+	const handle = supervisor.openRpcStream(instanceId, onSessionEvent, onUiRequest);
 	if (!handle) {
 		return undefined;
 	}
diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 1c45a6db..18ed7d49 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -30,7 +30,7 @@ export interface IpcRequestHandler {
 	(request: RpcRequest): Promise<RpcBridgeResponse | ErrorResponse> | RpcBridgeResponse | ErrorResponse;
 	(request: RpcStreamRequest): Promise<RpcReadyResponse | ErrorResponse> | RpcReadyResponse | ErrorResponse;
 	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
-	attach(
+	openRpcStream(
 		instanceId: string,
 		onResponse: (response: import("@earendil-works/pi-coding-agent").RpcResponse) => void,
 		onSessionEvent: (event: import("@earendil-works/pi-coding-agent").AgentSessionEvent) => void,
@@ -72,7 +72,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 						return;
 					}
 
-					const attachment = handler.attach(
+					const rpcStream = handler.openRpcStream(
 						request.instanceId,
 						(response) => {
 							socket.write(encodeMessage(response));
@@ -84,7 +84,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 							socket.write(encodeMessage(request));
 						},
 					);
-					if (!attachment) {
+					if (!rpcStream) {
 						socket.end(
 							encodeMessage({ type: "error", ok: false, error: `Unknown instance: ${request.instanceId}` }),
 						);
@@ -108,7 +108,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 							void (async () => {
 								try {
 									const rpcRequest = JSON.parse(rpcLine) as RpcClientMessage;
-									await attachment.handleRequest(rpcRequest);
+									await rpcStream.handleRequest(rpcRequest);
 								} catch (rpcError) {
 									socket.write(
 										encodeMessage({
@@ -121,7 +121,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 							})();
 						}
 					});
-					socket.once("close", () => attachment.close());
+					socket.once("close", () => rpcStream.close());
 					return;
 				}
 
diff --git a/packages/orchestrator/src/rpc-process.ts b/packages/orchestrator/src/rpc-process.ts
index 99da6ab0..221fe2eb 100644
--- a/packages/orchestrator/src/rpc-process.ts
+++ b/packages/orchestrator/src/rpc-process.ts
@@ -69,24 +69,31 @@ export function createRpcProcessInstance(options: { cwd: string }): RpcProcessIn
 
 	const handleLine = (line: string) => {
 		const parsed = JSON.parse(line) as { type?: string; id?: string };
-		if (parsed.type === "response") {
-			if (parsed.id) {
+
+		switch (parsed.type) {
+			case "response": {
+				if (!parsed.id) {
+					return;
+				}
 				const pending = pendingRequests.get(parsed.id);
-				if (pending) {
-					pendingRequests.delete(parsed.id);
-					pending.resolve(parsed as RpcResponse);
+				if (!pending) {
+					return;
+				}
+				pendingRequests.delete(parsed.id);
+				pending.resolve(parsed as RpcResponse);
+				return;
+			}
+
+			case "extension_ui_request": {
+				uiRequestHandler?.(parsed as RpcExtensionUIRequest);
+				return;
+			}
+
+			default: {
+				for (const listener of eventListeners) {
+					listener(parsed as AgentSessionEvent);
 				}
 			}
-			return;
-		}
-
-		if (parsed.type === "extension_ui_request") {
-			uiRequestHandler?.(parsed as RpcExtensionUIRequest);
-			return;
-		}
-
-		for (const listener of eventListeners) {
-			listener(parsed as AgentSessionEvent);
 		}
 	};
 
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index acc4e9fc..ffa444ab 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { dirname } from "node:path";
 import { getSocketPath } from "./config.ts";
-import { attachIpcInstance, handleIpcRequest } from "./handler.ts";
+import { handleIpcRequest, openRpcStream } from "./handler.ts";
 import { startIpcServer } from "./ipc/server.ts";
 import { getRadiusOrchestratorBaseUrl, isRadiusEnabled, radiusPresence } from "./radius.ts";
 import { supervisor } from "./supervisor.ts";
@@ -21,7 +21,7 @@ export async function serve(): Promise<void> {
 	}
 	const server = await startIpcServer(
 		Object.assign(handleIpcRequest, {
-			attach: attachIpcInstance,
+			openRpcStream,
 		}),
 	);
 	console.log(`orchestrator listening on ${socketPath}`);
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index bb484f49..a1007814 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -25,6 +25,26 @@ function cloneInstance(record: InstanceRecord): InstanceRecord {
 	return { ...record };
 }
 
+// Only refresh persisted session metadata after commands that can plausibly change
+// the instance identity/details we store in instances.json. Most RPCs mutate transient
+// runtime state only, so forcing a follow-up get_state after every command is wasted IO.
+//
+// - new_session / switch_session / fork / clone can change sessionId/sessionFile
+// - set_session_name changes a persisted session detail we may want reflected externally
+// - prompt can materialize or advance persisted session state after the child processes it
+const SESSION_METADATA_COMMANDS: ReadonlySet<RpcCommand["type"]> = new Set([
+	"new_session",
+	"switch_session",
+	"fork",
+	"clone",
+	"set_session_name",
+	"prompt",
+]);
+
+function shouldRefreshSessionMetadata(command: RpcCommand): boolean {
+	return SESSION_METADATA_COMMANDS.has(command.type);
+}
+
 function isGetStateSuccess(
 	response: RpcResponse,
 ): response is Extract<
@@ -86,7 +106,7 @@ export class OrchestratorSupervisor {
 		upsertInstance(instance);
 	}
 
-	attachInstance(
+	openRpcStream(
 		instanceId: string,
 		onEvent: (event: AgentSessionEvent) => void,
 		onUiRequest: (request: RpcExtensionUIRequest) => void,
@@ -106,7 +126,9 @@ export class OrchestratorSupervisor {
 		return {
 			handleRpc: async (command) => {
 				const response = await live.rpc.send(command);
-				await this.syncInstanceRecord(live);
+				if (shouldRefreshSessionMetadata(command)) {
+					await this.syncInstanceRecord(live);
+				}
 				return response;
 			},
 			handleUiResponse: (response) => {
@@ -204,7 +226,9 @@ export class OrchestratorSupervisor {
 		}
 
 		const response = await live.rpc.send(command);
-		await this.syncInstanceRecord(live);
+		if (shouldRefreshSessionMetadata(command)) {
+			await this.syncInstanceRecord(live);
+		}
 		return response;
 	}
 

From 13a18600c69722e88923e674d3b893c639f47757 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Mon, 22 Jun 2026 15:11:14 +0200
Subject: [PATCH 25/36] fix: rpc stream

---
 packages/orchestrator/src/ipc/server.ts  |  2 +-
 packages/orchestrator/src/rpc-process.ts | 12 +++++++++---
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 18ed7d49..fc77e6f3 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -72,6 +72,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 						return;
 					}
 
+					socket.removeAllListeners("data");
 					const rpcStream = handler.openRpcStream(
 						request.instanceId,
 						(response) => {
@@ -92,7 +93,6 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 					}
 
 					socket.write(encodeMessage(response));
-					socket.removeAllListeners("data");
 					socket.on("data", (rpcChunk: Buffer | string) => {
 						buffer += rpcChunk.toString();
 						for (;;) {
diff --git a/packages/orchestrator/src/rpc-process.ts b/packages/orchestrator/src/rpc-process.ts
index 221fe2eb..4c37d734 100644
--- a/packages/orchestrator/src/rpc-process.ts
+++ b/packages/orchestrator/src/rpc-process.ts
@@ -1,6 +1,8 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import type {
 	AgentSessionEvent,
 	RpcCommand,
@@ -25,8 +27,12 @@ export interface RpcProcessInstance {
 }
 
 function resolveCodingAgentCli(): string {
-	const require = createRequire(import.meta.url);
-	return require.resolve("@earendil-works/pi-coding-agent/dist/cli.js");
+	const packageDir = dirname(fileURLToPath(import.meta.url));
+	const workspaceCli = join(packageDir, "../../coding-agent/dist/cli.js");
+	if (existsSync(workspaceCli)) {
+		return workspaceCli;
+	}
+	throw new Error(`Unable to find coding-agent RPC CLI: ${workspaceCli}`);
 }
 
 function toError(error: unknown): Error {

From d9910555620eec78e40c317afcefb3e24b53face Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Mon, 22 Jun 2026 15:24:01 +0200
Subject: [PATCH 26/36] fix: no dynamic imports

---
 packages/orchestrator/src/ipc/server.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index fc77e6f3..9d0d2708 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -1,5 +1,6 @@
 import { existsSync, unlinkSync } from "node:fs";
 import { createConnection, createServer, type Server } from "node:net";
+import type { AgentSessionEvent, RpcExtensionUIRequest, RpcResponse } from "@earendil-works/pi-coding-agent";
 import { getSocketPath } from "../config.ts";
 import {
 	type ErrorResponse,
@@ -32,9 +33,9 @@ export interface IpcRequestHandler {
 	(request: OrchestratorRequest): Promise<OrchestratorResponse> | OrchestratorResponse;
 	openRpcStream(
 		instanceId: string,
-		onResponse: (response: import("@earendil-works/pi-coding-agent").RpcResponse) => void,
-		onSessionEvent: (event: import("@earendil-works/pi-coding-agent").AgentSessionEvent) => void,
-		onUiRequest: (request: import("@earendil-works/pi-coding-agent").RpcExtensionUIRequest) => void,
+		onResponse: (response: RpcResponse) => void,
+		onSessionEvent: (event: AgentSessionEvent) => void,
+		onUiRequest: (request: RpcExtensionUIRequest) => void,
 	):
 		| {
 				handleRequest(request: RpcClientMessage): Promise<void>;

From cc12750e8e0176ec6bd5468bcd76f902a159ba15 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Mon, 22 Jun 2026 16:00:35 +0200
Subject: [PATCH 27/36] fix: serialize rpc requests, no eager rewrites

---
 packages/orchestrator/src/ipc/server.ts | 31 ++++++++++++++++---------
 packages/orchestrator/src/serve.ts      | 30 ++++++++++++++++--------
 2 files changed, 40 insertions(+), 21 deletions(-)

diff --git a/packages/orchestrator/src/ipc/server.ts b/packages/orchestrator/src/ipc/server.ts
index 9d0d2708..c389e141 100644
--- a/packages/orchestrator/src/ipc/server.ts
+++ b/packages/orchestrator/src/ipc/server.ts
@@ -11,7 +11,6 @@ import {
 	type OrchestratorResponse,
 	parseRequestLine,
 	type RpcBridgeResponse,
-	type RpcClientMessage,
 	type RpcReadyResponse,
 	type RpcRequest,
 	type RpcStreamRequest,
@@ -38,7 +37,7 @@ export interface IpcRequestHandler {
 		onUiRequest: (request: RpcExtensionUIRequest) => void,
 	):
 		| {
-				handleRequest(request: RpcClientMessage): Promise<void>;
+				handleRequest(request: RpcRequest["command"] | { type: "extension_ui_response" }): Promise<void>;
 				close(): void;
 		  }
 		| undefined;
@@ -94,6 +93,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 					}
 
 					socket.write(encodeMessage(response));
+					let rpcRequestQueue = Promise.resolve();
 					socket.on("data", (rpcChunk: Buffer | string) => {
 						buffer += rpcChunk.toString();
 						for (;;) {
@@ -106,20 +106,29 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 							if (!rpcLine) {
 								continue;
 							}
-							void (async () => {
-								try {
-									const rpcRequest = JSON.parse(rpcLine) as RpcClientMessage;
-									await rpcStream.handleRequest(rpcRequest);
-								} catch (rpcError) {
+							rpcRequestQueue = rpcRequestQueue
+								.then(async () => {
+									try {
+										await rpcStream.handleRequest(JSON.parse(rpcLine));
+									} catch (rpcError: unknown) {
+										socket.write(
+											encodeMessage({
+												type: "error",
+												ok: false,
+												error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+											}),
+										);
+									}
+								})
+								.catch((rpcError: Error) => {
 									socket.write(
 										encodeMessage({
 											type: "error",
 											ok: false,
-											error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+											error: rpcError.message,
 										}),
 									);
-								}
-							})();
+								});
 						}
 					});
 					socket.once("close", () => rpcStream.close());
@@ -128,7 +137,7 @@ export async function startIpcServer(handler: IpcRequestHandler): Promise<Server
 
 				const response = await handler(request);
 				socket.end(encodeMessage(response));
-			} catch (error) {
+			} catch (error: unknown) {
 				const response: ErrorResponse = {
 					type: "error",
 					ok: false,
diff --git a/packages/orchestrator/src/serve.ts b/packages/orchestrator/src/serve.ts
index ffa444ab..5f07b954 100644
--- a/packages/orchestrator/src/serve.ts
+++ b/packages/orchestrator/src/serve.ts
@@ -9,21 +9,31 @@ import { supervisor } from "./supervisor.ts";
 export async function serve(): Promise<void> {
 	const socketPath = getSocketPath();
 	mkdirSync(dirname(socketPath), { recursive: true });
-	await supervisor.recoverAfterRestart();
-	if (isRadiusEnabled()) {
-		const machine = await radiusPresence.start();
-		console.log(`radius integration enabled: ${socketPath} -> ${getRadiusOrchestratorBaseUrl()}`);
-		if (machine) {
-			console.log(`radius machine id: ${machine.id}`);
-		}
-	} else {
-		console.log("radius integration disabled: login radius in ~/.pi/agent/auth.json or set PI_RADIUS_API_KEY");
-	}
 	const server = await startIpcServer(
 		Object.assign(handleIpcRequest, {
 			openRpcStream,
 		}),
 	);
+
+	try {
+		await supervisor.recoverAfterRestart();
+		if (isRadiusEnabled()) {
+			const machine = await radiusPresence.start();
+			console.log(`radius integration enabled: ${socketPath} -> ${getRadiusOrchestratorBaseUrl()}`);
+			if (machine) {
+				console.log(`radius machine id: ${machine.id}`);
+			}
+		} else {
+			console.log("radius integration disabled: login radius in ~/.pi/agent/auth.json or set PI_RADIUS_API_KEY");
+		}
+	} catch (error) {
+		server.close();
+		if (existsSync(socketPath)) {
+			unlinkSync(socketPath);
+		}
+		throw error;
+	}
+
 	console.log(`orchestrator listening on ${socketPath}`);
 
 	let shutdownPromise: Promise<void> | undefined;

From 77f1fa621a82eb99494d99a1897356a5de0551a4 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 25 Jun 2026 09:29:12 +0200
Subject: [PATCH 28/36] docs: experimental

---
 packages/orchestrator/README.md    | 4 +++-
 packages/orchestrator/package.json | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/orchestrator/README.md b/packages/orchestrator/README.md
index ee05c9eb..aabd7243 100644
--- a/packages/orchestrator/README.md
+++ b/packages/orchestrator/README.md
@@ -1,4 +1,6 @@
-# orchestrator
+# @earendil-works/pi-orchestrator
+
+Experimental. This package is under active development and may change or be removed without notice. Its CLI, APIs, and behavior are not yet stable.
 
 Orchestrator package for pi.
 
diff --git a/packages/orchestrator/package.json b/packages/orchestrator/package.json
index 555169bc..617414dc 100644
--- a/packages/orchestrator/package.json
+++ b/packages/orchestrator/package.json
@@ -1,7 +1,7 @@
 {
 	"name": "@earendil-works/pi-orchestrator",
 	"version": "0.79.6",
-	"description": "orchestrator package for pi",
+	"description": "experimental orchestrator package for pi",
 	"type": "module",
 	"bin": {
 		"orchestrator": "dist/cli.js"

From 0563baa51dfa86759b7fc4ae38cc463b7f364b53 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 25 Jun 2026 09:51:21 +0200
Subject: [PATCH 29/36] feat: add experimental orchestrator package metadata

---
 package-lock.json | 43 ++++++++++++++++++++++++++++---------------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index d4811db6..c9508f4d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -807,6 +807,10 @@
 			"resolved": "packages/coding-agent",
 			"link": true
 		},
+		"node_modules/@earendil-works/pi-orchestrator": {
+			"resolved": "packages/orchestrator",
+			"link": true
+		},
 		"node_modules/@earendil-works/pi-tui": {
 			"resolved": "packages/tui",
 			"link": true
@@ -1503,9 +1507,6 @@
 			"cpu": [
 				"arm64"
 			],
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1522,9 +1523,6 @@
 			"cpu": [
 				"arm64"
 			],
-			"libc": [
-				"musl"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1541,9 +1539,6 @@
 			"cpu": [
 				"riscv64"
 			],
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1560,9 +1555,6 @@
 			"cpu": [
 				"x64"
 			],
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1579,9 +1571,6 @@
 			"cpu": [
 				"x64"
 			],
-			"libc": [
-				"musl"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -3860,6 +3849,7 @@
 			"resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
 			"integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==",
 			"license": "MIT",
+			"peer": true,
 			"bin": {
 				"jiti": "lib/jiti-cli.mjs"
 			}
@@ -5197,6 +5187,7 @@
 			"integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"engines": {
 				"node": ">=12"
 			},
@@ -5265,6 +5256,7 @@
 			"integrity": "sha512-TvncJykhxAzFCk0VQZKBTClall4Pm7qXDSodb6uxi8QFa8X8mT6ABjxxsQ2opDRYxG7AzcRWXaFtruz5HJKuWg==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"esbuild": "~0.28.0"
 			},
@@ -5345,6 +5337,7 @@
 			"integrity": "sha512-/4XH147Ui7OGTjg3HbdWe5arnZQSbfuRzdr9Ec7TQi5I7R+ir0Rlc9GIvD4v0XZurELqA035KVXJXpR61xhiTA==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"esbuild": "^0.27.0",
 				"fdir": "^6.5.0",
@@ -5945,6 +5938,7 @@
 			"integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"engines": {
 				"node": ">=12"
 			},
@@ -5958,6 +5952,7 @@
 			"integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@types/chai": "^5.2.2",
 				"@vitest/expect": "3.2.4",
@@ -6161,6 +6156,7 @@
 			"resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
 			"integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
 			"license": "MIT",
+			"peer": true,
 			"funding": {
 				"url": "https://github.com/sponsors/colinhacks"
 			}
@@ -6363,6 +6359,23 @@
 			"dev": true,
 			"license": "MIT"
 		},
+		"packages/orchestrator": {
+			"name": "@earendil-works/pi-orchestrator",
+			"version": "0.79.6",
+			"license": "MIT",
+			"dependencies": {
+				"@earendil-works/pi-coding-agent": "0.79.6"
+			},
+			"bin": {
+				"orchestrator": "dist/cli.js"
+			},
+			"devDependencies": {
+				"shx": "0.4.0"
+			},
+			"engines": {
+				"node": ">=22.19.0"
+			}
+		},
 		"packages/tui": {
 			"name": "@earendil-works/pi-tui",
 			"version": "0.79.6",

From 7e6e59b6e448462f92af950bf2fab184f50aa784 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Thu, 25 Jun 2026 09:59:53 +0200
Subject: [PATCH 30/36] fix: stale version

---
 package-lock.json                         | 95 ++++++-----------------
 packages/coding-agent/npm-shrinkwrap.json | 24 ++----
 packages/orchestrator/package.json        |  4 +-
 3 files changed, 32 insertions(+), 91 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 841495d6..2b23ffdb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -801,29 +801,6 @@
 			"resolved": "packages/tui",
 			"link": true
 		},
-		"node_modules/@emnapi/core": {
-			"version": "1.10.0",
-			"resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
-			"integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"dependencies": {
-				"@emnapi/wasi-threads": "1.2.1",
-				"tslib": "^2.4.0"
-			}
-		},
-		"node_modules/@emnapi/runtime": {
-			"version": "1.10.0",
-			"resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
-			"integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"dependencies": {
-				"tslib": "^2.4.0"
-			}
-		},
 		"node_modules/@emnapi/wasi-threads": {
 			"version": "1.2.1",
 			"resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
@@ -1602,6 +1579,7 @@
 			"resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
 			"integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
 			"license": "Apache-2.0",
+			"peer": true,
 			"engines": {
 				"node": ">=8.0.0"
 			}
@@ -1781,9 +1759,6 @@
 				"arm64"
 			],
 			"dev": true,
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1801,9 +1776,6 @@
 				"arm64"
 			],
 			"dev": true,
-			"libc": [
-				"musl"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1821,9 +1793,6 @@
 				"ppc64"
 			],
 			"dev": true,
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1841,9 +1810,6 @@
 				"s390x"
 			],
 			"dev": true,
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1861,9 +1827,6 @@
 				"x64"
 			],
 			"dev": true,
-			"libc": [
-				"glibc"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1881,9 +1844,6 @@
 				"x64"
 			],
 			"dev": true,
-			"libc": [
-				"musl"
-			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -2697,6 +2657,7 @@
 			"dev": true,
 			"hasInstallScript": true,
 			"license": "MIT",
+			"peer": true,
 			"bin": {
 				"esbuild": "bin/esbuild"
 			},
@@ -3593,9 +3554,6 @@
 				"arm64"
 			],
 			"dev": true,
-			"libc": [
-				"glibc"
-			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -3617,9 +3575,6 @@
 				"arm64"
 			],
 			"dev": true,
-			"libc": [
-				"musl"
-			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -3641,9 +3596,6 @@
 				"x64"
 			],
 			"dev": true,
-			"libc": [
-				"glibc"
-			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -3665,9 +3617,6 @@
 				"x64"
 			],
 			"dev": true,
-			"libc": [
-				"musl"
-			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -5089,6 +5038,7 @@
 			"resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
 			"integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
 			"license": "MIT",
+			"peer": true,
 			"funding": {
 				"url": "https://github.com/sponsors/colinhacks"
 			}
@@ -5128,6 +5078,7 @@
 			"integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -5138,6 +5089,7 @@
 			"integrity": "sha512-G9/lgqibheLVBDRuya45EbsEXTYcWoSG+TLg7i2axuzx0Eq62eXn+aWXyaVdV5vKvFSWd6ywcX8hA7la9Pvu8g==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@bcoe/v8-coverage": "^1.0.2",
 				"@vitest/utils": "4.1.9",
@@ -5296,7 +5248,6 @@
 			"integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=12"
 			},
@@ -5491,6 +5442,7 @@
 			"integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -5858,6 +5810,7 @@
 			"integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -6012,23 +5965,6 @@
 			"dev": true,
 			"license": "MIT"
 		},
-		"packages/orchestrator": {
-			"name": "@earendil-works/pi-orchestrator",
-			"version": "0.79.6",
-			"license": "MIT",
-			"dependencies": {
-				"@earendil-works/pi-coding-agent": "0.79.6"
-			},
-			"bin": {
-				"orchestrator": "dist/cli.js"
-			},
-			"devDependencies": {
-				"shx": "0.4.0"
-			},
-			"engines": {
-				"node": ">=22.19.0"
-      }
-    },
 		"packages/coding-agent/node_modules/vitest": {
 			"version": "4.1.9",
 			"resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.9.tgz",
@@ -6146,6 +6082,23 @@
 				}
 			}
 		},
+		"packages/orchestrator": {
+			"name": "@earendil-works/pi-orchestrator",
+			"version": "0.80.2",
+			"license": "MIT",
+			"dependencies": {
+				"@earendil-works/pi-coding-agent": "0.80.2"
+			},
+			"bin": {
+				"orchestrator": "dist/cli.js"
+			},
+			"devDependencies": {
+				"shx": "0.4.0"
+			},
+			"engines": {
+				"node": ">=22.19.0"
+			}
+		},
 		"packages/tui": {
 			"name": "@earendil-works/pi-tui",
 			"version": "0.80.2",
diff --git a/packages/coding-agent/npm-shrinkwrap.json b/packages/coding-agent/npm-shrinkwrap.json
index 467adb3b..7a832161 100644
--- a/packages/coding-agent/npm-shrinkwrap.json
+++ b/packages/coding-agent/npm-shrinkwrap.json
@@ -628,9 +628,6 @@
 			"cpu": [
 				"arm64"
 			],
-			"libc": [
-				"glibc"
-			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-arm64-musl": {
@@ -647,9 +644,6 @@
 			"cpu": [
 				"arm64"
 			],
-			"libc": [
-				"musl"
-			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-riscv64-gnu": {
@@ -666,9 +660,6 @@
 			"cpu": [
 				"riscv64"
 			],
-			"libc": [
-				"glibc"
-			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-x64-gnu": {
@@ -685,9 +676,6 @@
 			"cpu": [
 				"x64"
 			],
-			"libc": [
-				"glibc"
-			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-x64-musl": {
@@ -704,9 +692,6 @@
 			"cpu": [
 				"x64"
 			],
-			"libc": [
-				"musl"
-			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-win32-arm64-msvc": {
@@ -780,7 +765,8 @@
 			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=8.0.0"
-			}
+			},
+			"peer": true
 		},
 		"node_modules/@opentelemetry/semantic-conventions": {
 			"version": "1.41.1",
@@ -1360,7 +1346,8 @@
 			"license": "MIT",
 			"bin": {
 				"jiti": "lib/jiti-cli.mjs"
-			}
+			},
+			"peer": true
 		},
 		"node_modules/json-bigint": {
 			"version": "1.0.0",
@@ -1824,7 +1811,8 @@
 			"license": "MIT",
 			"funding": {
 				"url": "https://github.com/sponsors/colinhacks"
-			}
+			},
+			"peer": true
 		},
 		"node_modules/zod-to-json-schema": {
 			"version": "3.25.2",
diff --git a/packages/orchestrator/package.json b/packages/orchestrator/package.json
index 617414dc..297bf452 100644
--- a/packages/orchestrator/package.json
+++ b/packages/orchestrator/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@earendil-works/pi-orchestrator",
-	"version": "0.79.6",
+	"version": "0.80.2",
 	"description": "experimental orchestrator package for pi",
 	"type": "module",
 	"bin": {
@@ -40,7 +40,7 @@
 		"node": ">=22.19.0"
 	},
 	"dependencies": {
-		"@earendil-works/pi-coding-agent": "0.79.6"
+		"@earendil-works/pi-coding-agent": "0.80.2"
 	},
 	"devDependencies": {
 		"shx": "0.4.0"

From 122527b22a957056b26645014f2f205394b2ca11 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Fri, 26 Jun 2026 10:01:16 +0200
Subject: [PATCH 31/36] fix: rpc-entry and bun support

---
 packages/coding-agent/package.json       |  5 ++++-
 packages/coding-agent/src/rpc-entry.ts   | 12 +++++++++++
 packages/orchestrator/package.json       |  3 ---
 packages/orchestrator/src/config.ts      |  7 +++++++
 packages/orchestrator/src/rpc-process.ts | 26 +++++++++++++++---------
 5 files changed, 39 insertions(+), 14 deletions(-)
 create mode 100644 packages/coding-agent/src/rpc-entry.ts

diff --git a/packages/coding-agent/package.json b/packages/coding-agent/package.json
index 8175de4f..c75ccb3a 100644
--- a/packages/coding-agent/package.json
+++ b/packages/coding-agent/package.json
@@ -15,6 +15,9 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
+		},
+		"./rpc-entry": {
+			"import": "./dist/rpc-entry.js"
 		}
 	},
 	"files": [
@@ -27,7 +30,7 @@
 	],
 	"scripts": {
 		"clean": "shx rm -rf dist",
-		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js && npm run copy-assets",
+		"build": "tsgo -p tsconfig.build.json && shx chmod +x dist/cli.js dist/rpc-entry.js && npm run copy-assets",
 		"build:binary": "npm --prefix ../tui run build && npm --prefix ../ai run build && npm --prefix ../agent run build && npm run build && bun build --compile ./dist/bun/cli.js ./src/utils/image-resize-worker.ts --outfile dist/pi && npm run copy-binary-assets",
 		"copy-assets": "shx mkdir -p dist/modes/interactive/theme && shx cp src/modes/interactive/theme/*.json dist/modes/interactive/theme/ && shx mkdir -p dist/modes/interactive/assets && shx cp src/modes/interactive/assets/*.png dist/modes/interactive/assets/ && shx mkdir -p dist/core/export-html/vendor && shx cp src/core/export-html/template.html src/core/export-html/template.css src/core/export-html/template.js dist/core/export-html/ && shx cp src/core/export-html/vendor/*.js dist/core/export-html/vendor/",
 		"copy-binary-assets": "shx cp package.json dist/ && shx cp README.md dist/ && shx cp CHANGELOG.md dist/ && shx mkdir -p dist/theme && shx cp src/modes/interactive/theme/*.json dist/theme/ && shx mkdir -p dist/assets && shx cp src/modes/interactive/assets/*.png dist/assets/ && shx mkdir -p dist/export-html/vendor && shx cp src/core/export-html/template.html dist/export-html/ && shx cp src/core/export-html/vendor/*.js dist/export-html/vendor/ && shx cp -r docs dist/ && shx cp -r examples dist/ && shx cp ../../node_modules/@silvia-odwyer/photon-node/photon_rs_bg.wasm dist/",
diff --git a/packages/coding-agent/src/rpc-entry.ts b/packages/coding-agent/src/rpc-entry.ts
new file mode 100644
index 00000000..a07f9b33
--- /dev/null
+++ b/packages/coding-agent/src/rpc-entry.ts
@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { APP_NAME } from "./config.ts";
+import { configureHttpDispatcher } from "./core/http-dispatcher.ts";
+import { main } from "./main.ts";
+
+process.title = `${APP_NAME}-rpc`;
+process.env.PI_CODING_AGENT = "true";
+process.emitWarning = (() => {}) as typeof process.emitWarning;
+
+configureHttpDispatcher();
+
+main(["--mode", "rpc", ...process.argv.slice(2)]);
diff --git a/packages/orchestrator/package.json b/packages/orchestrator/package.json
index 297bf452..b93e0800 100644
--- a/packages/orchestrator/package.json
+++ b/packages/orchestrator/package.json
@@ -3,9 +3,6 @@
 	"version": "0.80.2",
 	"description": "experimental orchestrator package for pi",
 	"type": "module",
-	"bin": {
-		"orchestrator": "dist/cli.js"
-	},
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"exports": {
diff --git a/packages/orchestrator/src/config.ts b/packages/orchestrator/src/config.ts
index fab11bed..d39131a1 100644
--- a/packages/orchestrator/src/config.ts
+++ b/packages/orchestrator/src/config.ts
@@ -4,6 +4,13 @@ import { join } from "node:path";
 const CONFIG_DIR_NAME = ".pi";
 const ENV_ORCHESTRATOR_DIR = "PI_ORCHESTRATOR_DIR";
 
+/**
+ * Detect if we're running as a Bun compiled binary.
+ * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+ */
+export const isBunBinary =
+	import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+
 export function getOrchestratorDir(): string {
 	const envDir = process.env[ENV_ORCHESTRATOR_DIR];
 	if (envDir) {
diff --git a/packages/orchestrator/src/rpc-process.ts b/packages/orchestrator/src/rpc-process.ts
index 4c37d734..3983a03c 100644
--- a/packages/orchestrator/src/rpc-process.ts
+++ b/packages/orchestrator/src/rpc-process.ts
@@ -1,8 +1,7 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import type {
 	AgentSessionEvent,
 	RpcCommand,
@@ -10,6 +9,7 @@ import type {
 	RpcExtensionUIResponse,
 	RpcResponse,
 } from "@earendil-works/pi-coding-agent";
+import { isBunBinary } from "./config.ts";
 
 interface PendingRequest {
 	resolve(response: RpcResponse): void;
@@ -26,13 +26,19 @@ export interface RpcProcessInstance {
 	dispose(): Promise<void>;
 }
 
-function resolveCodingAgentCli(): string {
-	const packageDir = dirname(fileURLToPath(import.meta.url));
-	const workspaceCli = join(packageDir, "../../coding-agent/dist/cli.js");
-	if (existsSync(workspaceCli)) {
-		return workspaceCli;
+const require = createRequire(import.meta.url);
+
+function getRpcSpawnCommand(): { command: string; args: string[] } {
+	if (isBunBinary) {
+		return {
+			command: join(dirname(process.execPath), process.platform === "win32" ? "pi.exe" : "pi"),
+			args: ["--mode", "rpc"],
+		};
 	}
-	throw new Error(`Unable to find coding-agent RPC CLI: ${workspaceCli}`);
+	return {
+		command: process.execPath,
+		args: [require.resolve("@earendil-works/pi-coding-agent/rpc-entry")],
+	};
 }
 
 function toError(error: unknown): Error {
@@ -40,8 +46,8 @@ function toError(error: unknown): Error {
 }
 
 export function createRpcProcessInstance(options: { cwd: string }): RpcProcessInstance {
-	const cliPath = resolveCodingAgentCli();
-	const child = spawn(process.execPath, [cliPath, "--mode", "rpc"], {
+	const rpcCommand = getRpcSpawnCommand();
+	const child = spawn(rpcCommand.command, rpcCommand.args, {
 		cwd: options.cwd,
 		env: process.env,
 		stdio: ["pipe", "pipe", "pipe"],

From 7f9300763e43d7242d22ef6a8b46a290157cccdb Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Fri, 26 Jun 2026 12:36:07 +0200
Subject: [PATCH 32/36] fix: orch (dynamic) version

---
 packages/orchestrator/src/config.ts | 33 ++++++++++++++++++++++++++++-
 packages/orchestrator/src/radius.ts |  5 ++---
 2 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/packages/orchestrator/src/config.ts b/packages/orchestrator/src/config.ts
index d39131a1..8bacdb73 100644
--- a/packages/orchestrator/src/config.ts
+++ b/packages/orchestrator/src/config.ts
@@ -1,9 +1,14 @@
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 
 const CONFIG_DIR_NAME = ".pi";
 const ENV_ORCHESTRATOR_DIR = "PI_ORCHESTRATOR_DIR";
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
 /**
  * Detect if we're running as a Bun compiled binary.
  * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
@@ -11,6 +16,32 @@ const ENV_ORCHESTRATOR_DIR = "PI_ORCHESTRATOR_DIR";
 export const isBunBinary =
 	import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
 
+interface PackageJson {
+	version?: string;
+}
+
+function getPackageJsonPath(): string {
+	let dir = __dirname;
+	while (dir !== dirname(dir)) {
+		const packageJsonPath = join(dir, "package.json");
+		if (existsSync(packageJsonPath)) {
+			return packageJsonPath;
+		}
+		dir = dirname(dir);
+	}
+	return join(__dirname, "package.json");
+}
+
+let pkg: PackageJson = {};
+try {
+	pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8")) as PackageJson;
+} catch (e: unknown) {
+	const err = e as NodeJS.ErrnoException;
+	if (err.code !== "ENOENT") throw e;
+}
+
+export const VERSION: string = pkg.version || "0.0.0";
+
 export function getOrchestratorDir(): string {
 	const envDir = process.env[ENV_ORCHESTRATOR_DIR];
 	if (envDir) {
diff --git a/packages/orchestrator/src/radius.ts b/packages/orchestrator/src/radius.ts
index aacd7130..2d6347f9 100644
--- a/packages/orchestrator/src/radius.ts
+++ b/packages/orchestrator/src/radius.ts
@@ -1,12 +1,11 @@
 import { hostname, platform } from "node:os";
 import { AuthStorage, type OAuthCredential } from "@earendil-works/pi-coding-agent";
-import { getOrchestratorDir, getSocketPath } from "./config.ts";
+import { getOrchestratorDir, getSocketPath, VERSION } from "./config.ts";
 import { loadMachine, saveMachine } from "./storage.ts";
 import type { InstanceRecord, MachineRecord, RadiusRegistration } from "./types.ts";
 
 const DEFAULT_RADIUS_URL = "https://radius.pi.dev/";
 const DEFAULT_ORCHESTRATOR_BASE_PATH = "/v1/";
-const ORCHESTRATOR_VERSION = "0.79.6";
 const NOT_FOUND_RETRY_THRESHOLD = 3;
 const HEARTBEAT_BACKOFF_BASE_MS = 1_000;
 const HEARTBEAT_BACKOFF_MAX_MS = 30_000;
@@ -243,7 +242,7 @@ export class RadiusPresence {
 			hostname: hostname(),
 			platform: platform(),
 			arch: process.arch,
-			version: ORCHESTRATOR_VERSION,
+			version: VERSION,
 			capabilities: { spawn: true, relay: false, iroh: false },
 		});
 

From 9505389beb3b4f7e1ae84d41162506376cd12c8c Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Fri, 26 Jun 2026 12:37:06 +0200
Subject: [PATCH 33/36] fix: git url

---
 packages/orchestrator/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/orchestrator/package.json b/packages/orchestrator/package.json
index b93e0800..da71a472 100644
--- a/packages/orchestrator/package.json
+++ b/packages/orchestrator/package.json
@@ -30,7 +30,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/badlogic/pi-mono.git",
+		"url": "git+https://github.com/earendil-works/pi.git",
 		"directory": "packages/orchestrator"
 	},
 	"engines": {

From 2f853bbce0ac112a0a69e9188ce22ea3dbdf1dfd Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Fri, 26 Jun 2026 12:47:09 +0200
Subject: [PATCH 34/36] fix: class RpcProcessInstance as state machine

---
 packages/orchestrator/src/rpc-process.ts | 271 +++++++++++------------
 packages/orchestrator/src/supervisor.ts  | 208 ++++++++++++-----
 2 files changed, 289 insertions(+), 190 deletions(-)

diff --git a/packages/orchestrator/src/rpc-process.ts b/packages/orchestrator/src/rpc-process.ts
index 3983a03c..b770862c 100644
--- a/packages/orchestrator/src/rpc-process.ts
+++ b/packages/orchestrator/src/rpc-process.ts
@@ -16,187 +16,186 @@ interface PendingRequest {
 	reject(error: Error): void;
 }
 
-export interface RpcProcessInstance {
-	process: ChildProcess;
-	send(command: RpcCommand): Promise<RpcResponse>;
-	handleUiResponse(response: RpcExtensionUIResponse): void;
-	setUiRequestHandler(handler?: (request: RpcExtensionUIRequest) => void): void;
-	onEvent(listener: (event: AgentSessionEvent) => void): () => void;
-	onExit(listener: (error?: Error) => void): () => void;
-	dispose(): Promise<void>;
-}
-
 const require = createRequire(import.meta.url);
 
-function getRpcSpawnCommand(): { command: string; args: string[] } {
-	if (isBunBinary) {
-		return {
-			command: join(dirname(process.execPath), process.platform === "win32" ? "pi.exe" : "pi"),
-			args: ["--mode", "rpc"],
-		};
-	}
-	return {
-		command: process.execPath,
-		args: [require.resolve("@earendil-works/pi-coding-agent/rpc-entry")],
-	};
-}
-
 function toError(error: unknown): Error {
 	return error instanceof Error ? error : new Error(String(error));
 }
 
-export function createRpcProcessInstance(options: { cwd: string }): RpcProcessInstance {
-	const rpcCommand = getRpcSpawnCommand();
-	const child = spawn(rpcCommand.command, rpcCommand.args, {
-		cwd: options.cwd,
-		env: process.env,
-		stdio: ["pipe", "pipe", "pipe"],
-	});
-	if (!child.stdin || !child.stdout) {
-		throw new Error("Failed to create RPC process stdio");
+export class RpcProcessInstance {
+	readonly process: ChildProcess;
+
+	private exited = false;
+	private nextRequestId = 0;
+	private stdoutBuffer = "";
+	private stderrBuffer = "";
+	private readonly pendingRequests = new Map<string, PendingRequest>();
+	private readonly eventListeners = new Set<(event: AgentSessionEvent) => void>();
+	private readonly exitListeners = new Set<(error?: Error) => void>();
+	private uiRequestHandler: ((request: RpcExtensionUIRequest) => void) | undefined;
+
+	constructor(options: { cwd: string }) {
+		const rpcCommand = this.getSpawnCommand();
+		this.process = spawn(rpcCommand.command, rpcCommand.args, {
+			cwd: options.cwd,
+			env: process.env,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		if (!this.process.stdin || !this.process.stdout) {
+			throw new Error("Failed to create RPC process stdio");
+		}
+		this.attachListeners();
 	}
 
-	let exited = false;
-	let nextRequestId = 0;
-	let stdoutBuffer = "";
-	let stderrBuffer = "";
-	const pendingRequests = new Map<string, PendingRequest>();
-	const eventListeners = new Set<(event: AgentSessionEvent) => void>();
-	const exitListeners = new Set<(error?: Error) => void>();
-
-	const rejectAllPending = (error: Error) => {
-		for (const [id, pending] of pendingRequests) {
-			pendingRequests.delete(id);
-			pending.reject(error);
+	private getSpawnCommand(): { command: string; args: string[] } {
+		if (isBunBinary) {
+			return {
+				command: join(dirname(process.execPath), process.platform === "win32" ? "pi.exe" : "pi"),
+				args: ["--mode", "rpc"],
+			};
 		}
-	};
+		return {
+			command: process.execPath,
+			args: [require.resolve("@earendil-works/pi-coding-agent/rpc-entry")],
+		};
+	}
 
-	const notifyExit = (error?: Error) => {
-		for (const listener of exitListeners) {
-			listener(error);
-		}
-	};
+	private attachListeners(): void {
+		this.process.stdout?.setEncoding("utf8");
+		this.process.stdout?.on("data", (chunk: string) => {
+			this.stdoutBuffer += chunk;
+			while (true) {
+				const newlineIndex = this.stdoutBuffer.indexOf("\n");
+				if (newlineIndex === -1) {
+					break;
+				}
+				const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+				this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+				if (!line) {
+					continue;
+				}
+				this.handleLine(line);
+			}
+		});
 
-	let uiRequestHandler: ((request: RpcExtensionUIRequest) => void) | undefined;
+		this.process.stderr?.setEncoding("utf8");
+		this.process.stderr?.on("data", (chunk: string) => {
+			this.stderrBuffer += chunk;
+		});
 
-	const handleLine = (line: string) => {
+		this.process.once("error", (error) => {
+			this.exited = true;
+			const wrapped = new Error(`RPC process error: ${error.message}. Stderr: ${this.stderrBuffer}`);
+			this.rejectAllPending(wrapped);
+			this.notifyExit(wrapped);
+		});
+
+		this.process.once("exit", (code, signal) => {
+			this.exited = true;
+			const error = new Error(`RPC process exited (code=${code} signal=${signal}). Stderr: ${this.stderrBuffer}`);
+			this.rejectAllPending(error);
+			this.notifyExit(error);
+		});
+	}
+
+	private handleLine(line: string): void {
 		const parsed = JSON.parse(line) as { type?: string; id?: string };
-
 		switch (parsed.type) {
 			case "response": {
 				if (!parsed.id) {
 					return;
 				}
-				const pending = pendingRequests.get(parsed.id);
+				const pending = this.pendingRequests.get(parsed.id);
 				if (!pending) {
 					return;
 				}
-				pendingRequests.delete(parsed.id);
+				this.pendingRequests.delete(parsed.id);
 				pending.resolve(parsed as RpcResponse);
 				return;
 			}
 
 			case "extension_ui_request": {
-				uiRequestHandler?.(parsed as RpcExtensionUIRequest);
+				this.uiRequestHandler?.(parsed as RpcExtensionUIRequest);
 				return;
 			}
 
 			default: {
-				for (const listener of eventListeners) {
+				for (const listener of this.eventListeners) {
 					listener(parsed as AgentSessionEvent);
 				}
 			}
 		}
-	};
+	}
 
-	child.stdout.setEncoding("utf8");
-	child.stdout.on("data", (chunk: string) => {
-		stdoutBuffer += chunk;
-		while (true) {
-			const newlineIndex = stdoutBuffer.indexOf("\n");
-			if (newlineIndex === -1) {
-				break;
-			}
-			const line = stdoutBuffer.slice(0, newlineIndex).trim();
-			stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
-			if (!line) {
-				continue;
-			}
-			handleLine(line);
+	private rejectAllPending(error: Error): void {
+		for (const [id, pending] of this.pendingRequests) {
+			this.pendingRequests.delete(id);
+			pending.reject(error);
 		}
-	});
+	}
 
-	child.stderr?.setEncoding("utf8");
-	child.stderr?.on("data", (chunk: string) => {
-		stderrBuffer += chunk;
-	});
-
-	child.once("error", (error) => {
-		exited = true;
-		const wrapped = new Error(`RPC process error: ${error.message}. Stderr: ${stderrBuffer}`);
-		rejectAllPending(wrapped);
-		notifyExit(wrapped);
-	});
-
-	child.once("exit", (code, signal) => {
-		exited = true;
-		const error = new Error(`RPC process exited (code=${code} signal=${signal}). Stderr: ${stderrBuffer}`);
-		rejectAllPending(error);
-		notifyExit(error);
-	});
-
-	const send = async (command: RpcCommand): Promise<RpcResponse> => {
-		if (exited) {
-			throw new Error(`RPC process is not running. Stderr: ${stderrBuffer}`);
+	private notifyExit(error?: Error): void {
+		for (const listener of this.exitListeners) {
+			listener(error);
 		}
-		const id = command.id ?? `orchestrator_${++nextRequestId}_${randomUUID()}`;
+	}
+
+	send(command: RpcCommand): Promise<RpcResponse> {
+		if (this.exited) {
+			throw new Error(`RPC process is not running. Stderr: ${this.stderrBuffer}`);
+		}
+		const id = command.id ?? `orchestrator_${++this.nextRequestId}_${randomUUID()}`;
 		const fullCommand = { ...command, id };
 		return new Promise<RpcResponse>((resolve, reject) => {
-			pendingRequests.set(id, { resolve, reject });
-			child.stdin.write(`${JSON.stringify(fullCommand)}\n`, (error) => {
+			this.pendingRequests.set(id, { resolve, reject });
+			this.process.stdin?.write(`${JSON.stringify(fullCommand)}\n`, (error) => {
 				if (!error) {
 					return;
 				}
-				pendingRequests.delete(id);
+				this.pendingRequests.delete(id);
 				reject(toError(error));
 			});
 		});
-	};
+	}
 
-	return {
-		process: child,
-		send,
-		handleUiResponse(response) {
-			if (exited) {
-				return;
-			}
-			child.stdin.write(`${JSON.stringify(response)}\n`);
-		},
-		setUiRequestHandler(handler) {
-			uiRequestHandler = handler;
-		},
-		onEvent(listener) {
-			eventListeners.add(listener);
-			return () => {
-				eventListeners.delete(listener);
-			};
-		},
-		onExit(listener) {
-			exitListeners.add(listener);
-			return () => {
-				exitListeners.delete(listener);
-			};
-		},
-		async dispose() {
-			uiRequestHandler = undefined;
-			rejectAllPending(new Error("RPC process disposed"));
-			if (exited) {
-				return;
-			}
-			child.kill("SIGTERM");
-			await new Promise<void>((resolve) => {
-				child.once("exit", () => resolve());
-			});
-		},
-	};
+	handleUiResponse(response: RpcExtensionUIResponse): void {
+		if (this.exited) {
+			return;
+		}
+		this.process.stdin?.write(`${JSON.stringify(response)}\n`);
+	}
+
+	setUiRequestHandler(handler?: (request: RpcExtensionUIRequest) => void): void {
+		this.uiRequestHandler = handler;
+	}
+
+	onEvent(listener: (event: AgentSessionEvent) => void): () => void {
+		this.eventListeners.add(listener);
+		return () => {
+			this.eventListeners.delete(listener);
+		};
+	}
+
+	onExit(listener: (error?: Error) => void): () => void {
+		this.exitListeners.add(listener);
+		return () => {
+			this.exitListeners.delete(listener);
+		};
+	}
+
+	async dispose(): Promise<void> {
+		this.uiRequestHandler = undefined;
+		this.rejectAllPending(new Error("RPC process disposed"));
+		if (this.exited) {
+			return;
+		}
+		this.process.kill("SIGTERM");
+		await new Promise<void>((resolve) => {
+			this.process.once("exit", () => resolve());
+		});
+	}
+}
+
+export function createRpcProcessInstance(options: { cwd: string }): RpcProcessInstance {
+	return new RpcProcessInstance(options);
 }
diff --git a/packages/orchestrator/src/supervisor.ts b/packages/orchestrator/src/supervisor.ts
index a1007814..1e375189 100644
--- a/packages/orchestrator/src/supervisor.ts
+++ b/packages/orchestrator/src/supervisor.ts
@@ -10,11 +10,17 @@ import type {
 import { radiusPresence } from "./radius.ts";
 import { createRpcProcessInstance, type RpcProcessInstance } from "./rpc-process.ts";
 import { getInstance, loadInstances, removeInstance, saveInstances, upsertInstance } from "./storage.ts";
-import type { InstanceRecord } from "./types.ts";
+import type { InstanceRecord, InstanceStatus } from "./types.ts";
+
+interface LiveInstanceResources {
+	rpcProcess?: RpcProcessInstance;
+	radiusPiId?: string;
+	sessionId?: string;
+}
 
 interface LiveInstance {
-	rpc: RpcProcessInstance;
 	record: InstanceRecord;
+	resources: LiveInstanceResources;
 	subscribers: Set<AgentSessionEventListener>;
 	onUiRequest?: (request: RpcExtensionUIRequest) => void;
 	unsubscribeEvents?: () => void;
@@ -57,51 +63,133 @@ function isGetStateSuccess(
 export class OrchestratorSupervisor {
 	private readonly liveInstances = new Map<string, LiveInstance>();
 
-	private async syncInstanceRecord(live: LiveInstance): Promise<void> {
-		const response = await live.rpc.send({ type: "get_state" });
-		if (!isGetStateSuccess(response)) {
-			live.record = {
-				...live.record,
-				lastSeenAt: new Date().toISOString(),
-			};
-			upsertInstance(live.record);
-			return;
-		}
+	private setStatus(live: LiveInstance, status: InstanceStatus): void {
 		live.record = {
 			...live.record,
-			sessionId: response.data.sessionId,
-			sessionFile: response.data.sessionFile,
+			status,
 			lastSeenAt: new Date().toISOString(),
 		};
 		upsertInstance(live.record);
 	}
 
-	private bindLiveInstance(live: LiveInstance): void {
+	private updateRecord(live: LiveInstance, updates: Partial<InstanceRecord>): void {
+		live.record = {
+			...live.record,
+			...updates,
+			lastSeenAt: new Date().toISOString(),
+		};
+		if (updates.radiusPiId !== undefined) {
+			live.resources.radiusPiId = updates.radiusPiId;
+		}
+		if (updates.sessionId !== undefined) {
+			live.resources.sessionId = updates.sessionId;
+		}
+		upsertInstance(live.record);
+	}
+
+	private clearBindings(live: LiveInstance): void {
 		live.unsubscribeEvents?.();
 		live.unsubscribeExit?.();
-		live.unsubscribeEvents = live.rpc.onEvent((event) => {
+		live.unsubscribeEvents = undefined;
+		live.unsubscribeExit = undefined;
+		live.onUiRequest = undefined;
+		live.resources.rpcProcess?.setUiRequestHandler(undefined);
+	}
+
+	private bindRpcProcess(live: LiveInstance, rpcProcess: RpcProcessInstance): void {
+		this.clearBindings(live);
+		live.resources.rpcProcess = rpcProcess;
+		live.unsubscribeEvents = rpcProcess.onEvent((event) => {
 			for (const subscriber of live.subscribers) {
 				subscriber(event);
 			}
 		});
-		live.unsubscribeExit = live.rpc.onExit(() => {
-			live.record = {
-				...live.record,
-				status: "stopped",
-				lastSeenAt: new Date().toISOString(),
-			};
-			upsertInstance(live.record);
-			this.liveInstances.delete(live.record.id);
+		live.unsubscribeExit = rpcProcess.onExit((error) => {
+			void this.handleUnexpectedRpcExit(live, error);
 		});
-		live.rpc.setUiRequestHandler((request) => {
+		rpcProcess.setUiRequestHandler((request) => {
 			live.onUiRequest?.(request);
 		});
 	}
 
+	private async handleUnexpectedRpcExit(live: LiveInstance, _error?: Error): Promise<void> {
+		if (this.liveInstances.get(live.record.id) !== live) {
+			return;
+		}
+		if (live.record.status === "stopping" || live.record.status === "stopped") {
+			return;
+		}
+		this.setStatus(live, "error");
+		this.clearBindings(live);
+		live.resources.rpcProcess = undefined;
+		if (live.resources.radiusPiId) {
+			try {
+				await radiusPresence.disconnectPi(live.record);
+				this.updateRecord(live, { radiusPiId: undefined });
+			} catch (error) {
+				console.error(`Failed to disconnect Radius Pi ${live.record.id}: ${String(error)}`);
+			}
+		}
+		this.liveInstances.delete(live.record.id);
+	}
+
+	private getRpcProcess(live: LiveInstance): RpcProcessInstance | undefined {
+		return live.resources.rpcProcess;
+	}
+
+	private async syncInstanceRecord(live: LiveInstance): Promise<void> {
+		const rpcProcess = this.getRpcProcess(live);
+		if (!rpcProcess) {
+			this.updateRecord(live, {});
+			return;
+		}
+		const response = await rpcProcess.send({ type: "get_state" });
+		if (!isGetStateSuccess(response)) {
+			this.updateRecord(live, {});
+			return;
+		}
+		this.updateRecord(live, {
+			sessionId: response.data.sessionId,
+			sessionFile: response.data.sessionFile,
+		});
+	}
+
+	private async cleanupAcquiredResources(live: LiveInstance): Promise<void> {
+		const rpcProcess = live.resources.rpcProcess;
+		this.clearBindings(live);
+		if (live.resources.radiusPiId) {
+			await radiusPresence.disconnectPi(live.record);
+			live.resources.radiusPiId = undefined;
+			live.record = {
+				...live.record,
+				radiusPiId: undefined,
+				lastSeenAt: new Date().toISOString(),
+			};
+		}
+		live.resources.sessionId = undefined;
+		if (rpcProcess) {
+			live.resources.rpcProcess = undefined;
+			await rpcProcess.dispose();
+		}
+	}
+
+	private async failSpawn(live: LiveInstance, error: unknown): Promise<never> {
+		this.setStatus(live, "error");
+		try {
+			await this.cleanupAcquiredResources(live);
+		} finally {
+			this.setStatus(live, "stopped");
+			this.liveInstances.delete(live.record.id);
+		}
+		throw error;
+	}
+
 	updateInstance(instance: InstanceRecord): void {
 		const live = this.liveInstances.get(instance.id);
 		if (live) {
 			live.record = instance;
+			live.resources.radiusPiId = instance.radiusPiId;
+			live.resources.sessionId = instance.sessionId;
 		}
 		upsertInstance(instance);
 	}
@@ -118,21 +206,22 @@ export class OrchestratorSupervisor {
 		  }
 		| undefined {
 		const live = this.liveInstances.get(instanceId);
-		if (!live) {
+		const rpcProcess = live ? this.getRpcProcess(live) : undefined;
+		if (!live || !rpcProcess) {
 			return undefined;
 		}
 		live.subscribers.add(onEvent);
 		live.onUiRequest = onUiRequest;
 		return {
 			handleRpc: async (command) => {
-				const response = await live.rpc.send(command);
+				const response = await rpcProcess.send(command);
 				if (shouldRefreshSessionMetadata(command)) {
 					await this.syncInstanceRecord(live);
 				}
 				return response;
 			},
 			handleUiResponse: (response) => {
-				live.rpc.handleUiResponse(response);
+				rpcProcess.handleUiResponse(response);
 			},
 			close: () => {
 				if (live.onUiRequest === onUiRequest) {
@@ -179,28 +268,33 @@ export class OrchestratorSupervisor {
 	}
 
 	async spawnInstance(options: { cwd: string; label?: string }): Promise<InstanceRecord> {
-		const rpc = createRpcProcessInstance({ cwd: options.cwd });
 		const now = new Date().toISOString();
-		const record: InstanceRecord = {
-			id: randomUUID(),
-			status: "online",
-			cwd: options.cwd,
-			createdAt: now,
-			lastSeenAt: now,
-			label: options.label,
-		};
-
-		const registeredRecord = await radiusPresence.registerPi(record);
 		const live: LiveInstance = {
-			rpc,
-			record: registeredRecord,
+			record: {
+				id: randomUUID(),
+				status: "starting",
+				cwd: options.cwd,
+				createdAt: now,
+				lastSeenAt: now,
+				label: options.label,
+			},
+			resources: {},
 			subscribers: new Set(),
 		};
-		this.bindLiveInstance(live);
-		this.liveInstances.set(registeredRecord.id, live);
-		await this.syncInstanceRecord(live);
+		this.liveInstances.set(live.record.id, live);
 		upsertInstance(live.record);
-		return cloneInstance(live.record);
+
+		try {
+			const rpcProcess = createRpcProcessInstance({ cwd: options.cwd });
+			this.bindRpcProcess(live, rpcProcess);
+			await this.syncInstanceRecord(live);
+			const registeredRecord = await radiusPresence.registerPi(live.record);
+			this.updateRecord(live, { radiusPiId: registeredRecord.radiusPiId });
+			this.setStatus(live, "online");
+			return cloneInstance(live.record);
+		} catch (error) {
+			return await this.failSpawn(live, error);
+		}
 	}
 
 	async stopInstance(instanceId: string): Promise<InstanceRecord | undefined> {
@@ -209,23 +303,29 @@ export class OrchestratorSupervisor {
 			return undefined;
 		}
 
-		await radiusPresence.disconnectPi(live.record);
-		live.unsubscribeEvents?.();
-		live.unsubscribeExit?.();
-		live.onUiRequest = undefined;
-		await live.rpc.dispose();
-		this.liveInstances.delete(instanceId);
-		removeInstance(instanceId);
+		this.setStatus(live, "stopping");
+		try {
+			await this.cleanupAcquiredResources(live);
+		} finally {
+			live.record = {
+				...live.record,
+				status: "stopped",
+				lastSeenAt: new Date().toISOString(),
+			};
+			this.liveInstances.delete(instanceId);
+			removeInstance(instanceId);
+		}
 		return cloneInstance(live.record);
 	}
 
 	async handleRpc(instanceId: string, command: RpcCommand): Promise<RpcResponse | undefined> {
 		const live = this.liveInstances.get(instanceId);
-		if (!live) {
+		const rpcProcess = live ? this.getRpcProcess(live) : undefined;
+		if (!live || !rpcProcess) {
 			return undefined;
 		}
 
-		const response = await live.rpc.send(command);
+		const response = await rpcProcess.send(command);
 		if (shouldRefreshSessionMetadata(command)) {
 			await this.syncInstanceRecord(live);
 		}

From 988990f1c2d7426a9ded484919b387d016652776 Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Fri, 26 Jun 2026 13:12:43 +0200
Subject: [PATCH 35/36] fix: lockfile drift

---
 package-lock.json                         | 26 -----------------------
 packages/coding-agent/npm-shrinkwrap.json |  9 +++-----
 2 files changed, 3 insertions(+), 32 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 2b23ffdb..c40b9f41 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -801,17 +801,6 @@
 			"resolved": "packages/tui",
 			"link": true
 		},
-		"node_modules/@emnapi/wasi-threads": {
-			"version": "1.2.1",
-			"resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
-			"integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
-			"dev": true,
-			"license": "MIT",
-			"optional": true,
-			"dependencies": {
-				"tslib": "^2.4.0"
-			}
-		},
 		"node_modules/@esbuild/aix-ppc64": {
 			"version": "0.28.1",
 			"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
@@ -1579,7 +1568,6 @@
 			"resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
 			"integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
 			"license": "Apache-2.0",
-			"peer": true,
 			"engines": {
 				"node": ">=8.0.0"
 			}
@@ -2657,7 +2645,6 @@
 			"dev": true,
 			"hasInstallScript": true,
 			"license": "MIT",
-			"peer": true,
 			"bin": {
 				"esbuild": "bin/esbuild"
 			},
@@ -3356,7 +3343,6 @@
 			"resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",
 			"integrity": "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==",
 			"license": "MIT",
-			"peer": true,
 			"bin": {
 				"jiti": "lib/jiti-cli.mjs"
 			}
@@ -4728,7 +4714,6 @@
 			"integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=12"
 			},
@@ -4767,7 +4752,6 @@
 			"integrity": "sha512-TvncJykhxAzFCk0VQZKBTClall4Pm7qXDSodb6uxi8QFa8X8mT6ABjxxsQ2opDRYxG7AzcRWXaFtruz5HJKuWg==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"esbuild": "~0.28.0"
 			},
@@ -4848,7 +4832,6 @@
 			"integrity": "sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"lightningcss": "^1.32.0",
 				"picomatch": "^4.0.4",
@@ -5038,7 +5021,6 @@
 			"resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
 			"integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
 			"license": "MIT",
-			"peer": true,
 			"funding": {
 				"url": "https://github.com/sponsors/colinhacks"
 			}
@@ -5078,7 +5060,6 @@
 			"integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -5089,7 +5070,6 @@
 			"integrity": "sha512-G9/lgqibheLVBDRuya45EbsEXTYcWoSG+TLg7i2axuzx0Eq62eXn+aWXyaVdV5vKvFSWd6ywcX8hA7la9Pvu8g==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@bcoe/v8-coverage": "^1.0.2",
 				"@vitest/utils": "4.1.9",
@@ -5295,7 +5275,6 @@
 			"integrity": "sha512-nE3/LEyc0z87uHYLZebqCUOaJr2hdtuPp7BQ4BosVFnfltxgAvMG08NyrSGlPpOUWvR27c5flSmYFTNr78L9GQ==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@vitest/expect": "4.1.9",
 				"@vitest/mocker": "4.1.9",
@@ -5442,7 +5421,6 @@
 			"integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -5810,7 +5788,6 @@
 			"integrity": "sha512-GUUEShf+PBCGW2KaXwcIt3Yk+e3pkKwWKb9GSyM9WQVE+ep2jzmHdGsHzu4wgcZy5fN9FBdVzjpBQsYlpfpgLA==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -6089,9 +6066,6 @@
 			"dependencies": {
 				"@earendil-works/pi-coding-agent": "0.80.2"
 			},
-			"bin": {
-				"orchestrator": "dist/cli.js"
-			},
 			"devDependencies": {
 				"shx": "0.4.0"
 			},
diff --git a/packages/coding-agent/npm-shrinkwrap.json b/packages/coding-agent/npm-shrinkwrap.json
index 7a832161..ad35371f 100644
--- a/packages/coding-agent/npm-shrinkwrap.json
+++ b/packages/coding-agent/npm-shrinkwrap.json
@@ -765,8 +765,7 @@
 			"license": "Apache-2.0",
 			"engines": {
 				"node": ">=8.0.0"
-			},
-			"peer": true
+			}
 		},
 		"node_modules/@opentelemetry/semantic-conventions": {
 			"version": "1.41.1",
@@ -1346,8 +1345,7 @@
 			"license": "MIT",
 			"bin": {
 				"jiti": "lib/jiti-cli.mjs"
-			},
-			"peer": true
+			}
 		},
 		"node_modules/json-bigint": {
 			"version": "1.0.0",
@@ -1811,8 +1809,7 @@
 			"license": "MIT",
 			"funding": {
 				"url": "https://github.com/sponsors/colinhacks"
-			},
-			"peer": true
+			}
 		},
 		"node_modules/zod-to-json-schema": {
 			"version": "3.25.2",

From 0760bbae9bc8b35ab6c4d15bf354f6627c47ce3e Mon Sep 17 00:00:00 2001
From: Cristina Poncela Cubeiro
 <140309543+cristinaponcela@users.noreply.github.com>
Date: Fri, 26 Jun 2026 13:30:29 +0200
Subject: [PATCH 36/36] fix: lockfile drift

---
 package-lock.json                         | 79 +++++++++++++++++++++++
 packages/coding-agent/npm-shrinkwrap.json | 15 +++++
 2 files changed, 94 insertions(+)

diff --git a/package-lock.json b/package-lock.json
index c40b9f41..072fb409 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -801,6 +801,40 @@
 			"resolved": "packages/tui",
 			"link": true
 		},
+		"node_modules/@emnapi/core": {
+			"version": "1.10.0",
+			"resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+			"integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
+			"dev": true,
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"@emnapi/wasi-threads": "1.2.1",
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/@emnapi/runtime": {
+			"version": "1.10.0",
+			"resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.10.0.tgz",
+			"integrity": "sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==",
+			"dev": true,
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"tslib": "^2.4.0"
+			}
+		},
+		"node_modules/@emnapi/wasi-threads": {
+			"version": "1.2.1",
+			"resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
+			"integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
+			"dev": true,
+			"license": "MIT",
+			"optional": true,
+			"dependencies": {
+				"tslib": "^2.4.0"
+			}
+		},
 		"node_modules/@esbuild/aix-ppc64": {
 			"version": "0.28.1",
 			"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
@@ -1369,6 +1403,9 @@
 			"cpu": [
 				"arm64"
 			],
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1385,6 +1422,9 @@
 			"cpu": [
 				"arm64"
 			],
+			"libc": [
+				"musl"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1401,6 +1441,9 @@
 			"cpu": [
 				"riscv64"
 			],
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1417,6 +1460,9 @@
 			"cpu": [
 				"x64"
 			],
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1433,6 +1479,9 @@
 			"cpu": [
 				"x64"
 			],
+			"libc": [
+				"musl"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1747,6 +1796,9 @@
 				"arm64"
 			],
 			"dev": true,
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1764,6 +1816,9 @@
 				"arm64"
 			],
 			"dev": true,
+			"libc": [
+				"musl"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1781,6 +1836,9 @@
 				"ppc64"
 			],
 			"dev": true,
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1798,6 +1856,9 @@
 				"s390x"
 			],
 			"dev": true,
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1815,6 +1876,9 @@
 				"x64"
 			],
 			"dev": true,
+			"libc": [
+				"glibc"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -1832,6 +1896,9 @@
 				"x64"
 			],
 			"dev": true,
+			"libc": [
+				"musl"
+			],
 			"license": "MIT",
 			"optional": true,
 			"os": [
@@ -3540,6 +3607,9 @@
 				"arm64"
 			],
 			"dev": true,
+			"libc": [
+				"glibc"
+			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -3561,6 +3631,9 @@
 				"arm64"
 			],
 			"dev": true,
+			"libc": [
+				"musl"
+			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -3582,6 +3655,9 @@
 				"x64"
 			],
 			"dev": true,
+			"libc": [
+				"glibc"
+			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
@@ -3603,6 +3679,9 @@
 				"x64"
 			],
 			"dev": true,
+			"libc": [
+				"musl"
+			],
 			"license": "MPL-2.0",
 			"optional": true,
 			"os": [
diff --git a/packages/coding-agent/npm-shrinkwrap.json b/packages/coding-agent/npm-shrinkwrap.json
index ad35371f..467adb3b 100644
--- a/packages/coding-agent/npm-shrinkwrap.json
+++ b/packages/coding-agent/npm-shrinkwrap.json
@@ -628,6 +628,9 @@
 			"cpu": [
 				"arm64"
 			],
+			"libc": [
+				"glibc"
+			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-arm64-musl": {
@@ -644,6 +647,9 @@
 			"cpu": [
 				"arm64"
 			],
+			"libc": [
+				"musl"
+			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-riscv64-gnu": {
@@ -660,6 +666,9 @@
 			"cpu": [
 				"riscv64"
 			],
+			"libc": [
+				"glibc"
+			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-x64-gnu": {
@@ -676,6 +685,9 @@
 			"cpu": [
 				"x64"
 			],
+			"libc": [
+				"glibc"
+			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-linux-x64-musl": {
@@ -692,6 +704,9 @@
 			"cpu": [
 				"x64"
 			],
+			"libc": [
+				"musl"
+			],
 			"optional": true
 		},
 		"node_modules/@mariozechner/clipboard-win32-arm64-msvc": {