@selesai/code 0.13.38 → 0.13.40

package/dist/modes/rpc/rpc-release-transport.test.js

@@ -0,0 +1,329 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { RpcClient } from "./rpc-client.js";
+// Run after npm run build. Real bundled extensions and JSONL host, no model calls.
+const rawSend = (client, command) => client.send(command);
+const hostEnv = (dir, extensions) => ({
+    SELESAI_CODING_AGENT_DIR: dir,
+    RPC_SUBAGENT_EXTENSION: extensions ? resolve("dist/extensions/pi-subagents/index.ts") : "",
+    RPC_INTERCOM_EXTENSION: extensions ? resolve("dist/extensions/pi-intercom/index.ts") : "",
+    PI_INTERCOM_STABLE_ID: "", SELESAI_SUBAGENT_CHILD: "", SELESAI_SUBAGENT_RUN_ID: "", SELESAI_SUBAGENT_ORCHESTRATOR_TARGET: "",
+    SELESAI_SUBAGENT_ORCHESTRATOR_SESSION_ID: "", SELESAI_SUBAGENT_PARENT_SESSION: "",
+});
+const host = (dir, extensions) => new RpcClient({ cliPath: resolve("dist/modes/rpc/test-fixtures/intercom-host.js"), cwd: dir, env: hostEnv(dir, extensions) });
+/** Resolves with the host's exit code/signal; attach BEFORE sending the command that should end the process. */
+const exitOf = (client) => {
+    const child = client.process;
+    return new Promise(done => child.once("exit", (code, signal) => done({ code, signal })));
+};
+const stillRunning = (client) => client.process.exitCode === null;
+const within = (promise, ms, what) => Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new Error(`timed out waiting for ${what}`)), ms))]);
+describe("release JSONL transport (atomic release)", () => {
+    it("releases an idle session with the extensions loaded: released:true, then a gentle exit 0", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-go-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const exited = exitOf(client);
+            const reply = await rawSend(client, { type: "release", version: 1 });
+            expect(reply).toMatchObject({ type: "response", command: "release", success: true, data: { released: true, readiness: { version: 1, safe: true, blockers: [] } } });
+            const data = reply.data;
+            expect(data.readiness.contributors).toEqual(expect.arrayContaining(["subagents", "intercom", "scheduler"]));
+            expect(await within(exited, 15_000, "host exit")).toEqual({ code: 0, signal: null });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("RpcClient.release() returns the typed result", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-client-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const exited = exitOf(client);
+            const result = await client.release();
+            expect(result.released).toBe(true);
+            expect(result.readiness).toMatchObject({ safe: true, blockers: [] });
+            expect(await within(exited, 15_000, "host exit")).toEqual({ code: 0, signal: null });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("refuses commands that follow a committed release, and keeps answering the release probes", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-refuse-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const exited = exitOf(client);
+            // Sent back to back: the host reads both lines in order, the release commits synchronously before the next line is looked at.
+            const [released, refused, probe, again, bad] = await Promise.all([
+                rawSend(client, { type: "release", version: 1 }),
+                rawSend(client, { type: "get_state" }),
+                rawSend(client, { type: "release_readiness", version: 1 }),
+                rawSend(client, { type: "release", version: 1 }),
+                rawSend(client, { type: "release", version: 2 }),
+            ]);
+            expect(released).toMatchObject({ command: "release", success: true, data: { released: true } });
+            expect(refused).toMatchObject({ type: "response", command: "get_state", success: false, error: "Session is releasing" });
+            expect(probe).toMatchObject({ command: "release_readiness", success: true, data: { safe: false, blockers: [{ source: "core", kind: "releasing" }] } });
+            expect(again).toMatchObject({ command: "release", success: true, data: { released: true } });
+            expect(bad).toMatchObject({ command: "release", success: false, error: expect.stringContaining("version") });
+            expect(await within(exited, 15_000, "host exit")).toEqual({ code: 0, signal: null });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("does not release when nobody answered (extensions absent): released:false and the host keeps running", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-nobody-"));
+        const client = host(dir, false);
+        try {
+            await client.start();
+            const result = await client.release();
+            expect(result).toMatchObject({ released: false, readiness: { version: 1, safe: true, blockers: [], contributors: [] } });
+            await new Promise(done => setTimeout(done, 500));
+            expect(stillRunning(client)).toBe(true);
+            expect(await client.getState()).toMatchObject({ isStreaming: false });
+            expect(await client.releaseReadiness()).toMatchObject({ safe: true, blockers: [] });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("does not release while a core blocker exists, then releases once it clears", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-blocked-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const running = client.bash("sleep 2");
+            // `bash` registers asynchronously; probe (read-only) until the blocker is visible so `release` cannot fire early.
+            let probe = await client.releaseReadiness();
+            for (let attempt = 0; attempt < 40 && probe.safe; attempt++) {
+                await new Promise(done => setTimeout(done, 50));
+                probe = await client.releaseReadiness();
+            }
+            expect(probe.safe).toBe(false);
+            const blocked = await client.release();
+            expect(blocked.released).toBe(false);
+            expect(blocked.readiness.safe).toBe(false);
+            expect(blocked.readiness.blockers).toEqual(expect.arrayContaining([expect.objectContaining({ source: "core", kind: "pending_bash" })]));
+            expect(stillRunning(client)).toBe(true);
+            await running;
+            const exited = exitOf(client);
+            const released = await client.release();
+            expect(released).toMatchObject({ released: true, readiness: { safe: true, blockers: [] } });
+            expect(await within(exited, 15_000, "host exit")).toEqual({ code: 0, signal: null });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("rejects malformed release commands and keeps running", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-malformed-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            expect(await rawSend(client, { type: "release", version: 2 })).toMatchObject({ command: "release", success: false, error: expect.stringContaining("version") });
+            expect(await rawSend(client, { type: "release" })).toMatchObject({ command: "release", success: false });
+            expect(await rawSend(client, { type: "release", version: 1, method: "spawn" })).toMatchObject({ command: "release", success: false, error: expect.stringContaining("Malformed") });
+            expect(stillRunning(client)).toBe(true);
+            expect(await client.releaseReadiness()).toMatchObject({ safe: true, blockers: [] });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("release_readiness JSONL transport", () => {
+    it("is safe and lists every contributor for an idle session with the extensions loaded", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-live-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const readiness = await client.releaseReadiness();
+            expect(readiness).toMatchObject({ version: 1, safe: true, blockers: [] });
+            expect(readiness.contributors).toEqual(expect.arrayContaining(["subagents", "intercom", "scheduler"]));
+            expect((await client.getState()).isRetrying).toBe(false);
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("reports safe with no contributors when the extensions are absent", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-missing-"));
+        const client = host(dir, false);
+        try {
+            await client.start();
+            expect(await client.releaseReadiness()).toMatchObject({ version: 1, safe: true, blockers: [], contributors: [] });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("rejects malformed commands", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-bad-"));
+        const client = host(dir, false);
+        try {
+            await client.start();
+            expect(await rawSend(client, { type: "release_readiness", version: 2 })).toMatchObject({ command: "release_readiness", success: false, error: expect.stringContaining("version") });
+            expect(await rawSend(client, { type: "release_readiness" })).toMatchObject({ success: false });
+            expect(await rawSend(client, { type: "release_readiness", version: 1, method: "spawn" })).toMatchObject({ success: false, error: expect.stringContaining("Malformed") });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("is scoped to the session binding and rotates its epoch on new_session", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-scope-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const state = await client.getState();
+            const first = await client.releaseReadiness();
+            expect(first.sessionId).toBe(state.sessionId);
+            await client.newSession();
+            const next = await client.releaseReadiness();
+            const nextState = await client.getState();
+            expect(next.sessionId).toBe(nextState.sessionId);
+            expect(next.sessionId).not.toBe(first.sessionId);
+            expect(next.epoch).not.toBe(first.epoch);
+            expect(next).toMatchObject({ safe: true, blockers: [] });
+            expect(next.contributors).toEqual(expect.arrayContaining(["subagents", "intercom", "scheduler"]));
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("blocks while a bash command is running and clears once it finishes", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-release-bash-"));
+        const client = host(dir, false);
+        try {
+            await client.start();
+            const running = client.bash("sleep 2");
+            let blocked = await client.releaseReadiness();
+            for (let attempt = 0; attempt < 20 && blocked.safe; attempt++) {
+                await new Promise(done => setTimeout(done, 50));
+                blocked = await client.releaseReadiness();
+            }
+            expect(blocked.safe).toBe(false);
+            expect(blocked.blockers).toEqual(expect.arrayContaining([expect.objectContaining({ source: "core", kind: "pending_bash" })]));
+            await running;
+            const idle = await client.releaseReadiness();
+            expect(idle).toMatchObject({ safe: true, blockers: [] });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe("stop_all_background JSONL transport (kill switch)", () => {
+    it("answers on an idle session with an empty stopped list and the post-stop readiness; repeating it is a no-op", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-stopall-idle-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const state = await client.getState();
+            const reply = await rawSend(client, { type: "stop_all_background", version: 1 });
+            expect(reply).toMatchObject({
+                type: "response", command: "stop_all_background", success: true,
+                data: { version: 1, sessionId: state.sessionId, stopped: [], remaining: { version: 1, safe: true, blockers: [] } },
+            });
+            const data = reply.data;
+            expect(data.remaining.contributors).toEqual(expect.arrayContaining(["subagents", "intercom", "scheduler"]));
+            const again = await client.stopAllBackground();
+            expect(again).toMatchObject({ sessionId: state.sessionId, stopped: [], remaining: { safe: true, blockers: [] } });
+            expect(stillRunning(client)).toBe(true);
+            expect(await client.getState()).toMatchObject({ isStreaming: false });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("also answers when no extension is loaded (core only)", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-stopall-core-"));
+        const client = host(dir, false);
+        try {
+            await client.start();
+            expect(await client.stopAllBackground()).toMatchObject({ stopped: [], remaining: { safe: true, blockers: [], contributors: [] } });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("aborts a running bash command, reports it, and leaves nothing pending", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-stopall-bash-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const running = client.bash("sleep 30");
+            let probe = await client.releaseReadiness();
+            for (let attempt = 0; attempt < 40 && probe.safe; attempt++) {
+                await new Promise(done => setTimeout(done, 50));
+                probe = await client.releaseReadiness();
+            }
+            expect(probe.safe).toBe(false);
+            const startedAt = Date.now();
+            const result = await client.stopAllBackground();
+            expect(result.stopped).toEqual([expect.objectContaining({ source: "core", kind: "bash", ok: true })]);
+            await within(running, 10_000, "aborted bash to return");
+            expect(Date.now() - startedAt).toBeLessThan(10_000);
+            expect(await client.releaseReadiness()).toMatchObject({ safe: true, blockers: [] });
+            expect(await client.stopAllBackground()).toMatchObject({ stopped: [] });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("rejects malformed requests with success:false and keeps running", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-stopall-bad-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            expect(await rawSend(client, { type: "stop_all_background", version: 2 })).toMatchObject({ command: "stop_all_background", success: false, error: expect.stringContaining("version") });
+            expect(await rawSend(client, { type: "stop_all_background" })).toMatchObject({ command: "stop_all_background", success: false });
+            expect(await rawSend(client, { type: "stop_all_background", version: 1, method: "spawn" })).toMatchObject({ success: false, error: "Malformed stop_all_background command" });
+            expect(stillRunning(client)).toBe(true);
+            expect(await client.releaseReadiness()).toMatchObject({ safe: true, blockers: [] });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("is refused with \"Session is releasing\" once a release is committed", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-stopall-releasing-"));
+        const client = host(dir, true);
+        try {
+            await client.start();
+            const exited = exitOf(client);
+            const [released, refused] = await Promise.all([
+                rawSend(client, { type: "release", version: 1 }),
+                rawSend(client, { type: "stop_all_background", version: 1 }),
+            ]);
+            expect(released).toMatchObject({ command: "release", success: true, data: { released: true } });
+            expect(refused).toMatchObject({ type: "response", command: "stop_all_background", success: false, error: "Session is releasing" });
+            expect(await within(exited, 15_000, "host exit")).toEqual({ code: 0, signal: null });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/modes/rpc/rpc-subagent-transport.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modes/rpc/rpc-subagent-transport.test.js

@@ -0,0 +1,60 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { RpcClient } from "./rpc-client.js";
+// Run after npm run build. Real bundled extension and JSONL host, no model calls.
+describe("Subagent RPC JSONL transport", () => {
+    it("reports an explicit unavailable snapshot when extension is absent", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-observe-missing-"));
+        const client = new RpcClient({ cliPath: resolve("dist/modes/rpc/test-fixtures/intercom-host.js"), cwd: dir,
+            env: { SELESAI_CODING_AGENT_DIR: dir, RPC_INTERCOM_EXTENSION: "", RPC_SUBAGENT_EXTENSION: "" } });
+        try {
+            await client.start();
+            expect(await client.subagentStatus()).toMatchObject({ version: 1, available: false, capabilities: { snapshot: true, events: false }, runs: [], omitted: { runs: 0, children: 0 } });
+        }
+        finally {
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("binds real native extension snapshots and scopes both streams across switch/reload", async () => {
+        const dir = mkdtempSync(join(tmpdir(), "rpc-observe-live-"));
+        const client = new RpcClient({ cliPath: resolve("dist/modes/rpc/test-fixtures/intercom-host.js"), cwd: dir,
+            env: { SELESAI_CODING_AGENT_DIR: dir, RPC_SUBAGENT_EXTENSION: resolve("dist/extensions/pi-subagents/index.ts"),
+                RPC_INTERCOM_EXTENSION: resolve("dist/extensions/pi-intercom/index.ts"), PI_INTERCOM_STABLE_ID: "", SELESAI_SUBAGENT_CHILD: "",
+                SELESAI_SUBAGENT_RUN_ID: "", SELESAI_SUBAGENT_ORCHESTRATOR_TARGET: "", SELESAI_SUBAGENT_ORCHESTRATOR_SESSION_ID: "", SELESAI_SUBAGENT_PARENT_SESSION: "" } });
+        const events = [];
+        const off = client.onEvent(event => events.push(event));
+        try {
+            await client.start();
+            const first = await client.subagentStatus();
+            expect(first.available).toBe(true);
+            expect(first.capabilities).toEqual({ snapshot: true, events: true });
+            expect(first.runs).toEqual([]);
+            const firstIntercom = await client.intercomStatus();
+            expect(firstIntercom.scope).toEqual({ version: 1, sessionId: first.sessionId, epoch: first.epoch });
+            expect(events.some(event => event.type === "subagent_event" && event.snapshot.epoch === first.epoch)).toBe(true);
+            await client.newSession();
+            const next = await client.subagentStatus();
+            expect(next.sessionId).not.toBe(first.sessionId);
+            expect(next.epoch).not.toBe(first.epoch);
+            await client.reload();
+            const reloaded = await client.subagentStatus();
+            expect(reloaded.available).toBe(true);
+            expect(reloaded.sessionId).toBe(next.sessionId);
+            expect(reloaded.epoch).not.toBe(next.epoch);
+            expect((await client.intercomStatus()).scope.epoch).toBe(reloaded.epoch);
+            const initial = events.filter(event => event.type === "subagent_event" && event.revision === 1);
+            const epochs = new Set(initial.map(event => event.type === "subagent_event" ? event.epoch : ""));
+            expect(epochs.has(first.epoch) && epochs.has(next.epoch) && epochs.has(reloaded.epoch)).toBe(true);
+            expect(events.some(event => event.type === "agent_start")).toBe(false);
+            expect(events.filter(event => event.type.startsWith("intercom_")).every(event => "scope" in event && event.scope.version === 1)).toBe(true);
+        }
+        finally {
+            off();
+            await client.stop();
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/modes/rpc/rpc-types.d.ts

@@ -1,9 +1,17 @@
+import type { SubagentRpcCommand, SubagentRpcEvent, SubagentRpcResponse } from "../../core/subagent-rpc.ts";
+export type { SubagentRpcCommand, SubagentRpcEvent, SubagentRpcResponse, SubagentRpcSnapshot, SubagentRpcNode, SubagentRpcFleet, SubagentRpcTokens, SubagentRpcLifecycle, RpcObservationScope } from "../../core/subagent-rpc.ts";
+import type { ReleaseCommand, ReleaseReadinessCommand, ReleaseReadinessResponse, ReleaseResponse, StopAllBackgroundCommand, StopAllBackgroundResponse } from "../../core/release-rpc.ts";
+export type { ReleaseCommand, ReleaseResponse, ReleaseResult, ReleaseReadinessCommand, ReleaseReadinessResponse, ReleaseReadiness, ReleaseBlocker, ReleaseBlockerSource, StopAllBackgroundCommand, StopAllBackgroundResponse, StopAllBackgroundResult, StopAllBackgroundItem } from "../../core/release-rpc.ts";
 /**
  * RPC protocol types for headless operation.
  *
  * Commands are sent as JSON lines on stdin.
  * Responses and events are emitted as JSON lines on stdout.
  */
+import type { IntercomRpcCommand, IntercomRpcResponse, IntercomRpcEvent } from "../../core/intercom-rpc.ts";
+import type { AgentSessionEvent } from "../../core/agent-session.ts";
+export type { IntercomRpcCommand, IntercomRpcResponse, IntercomRpcEvent, IntercomRpcStatus, IntercomRpcDelivery, IntercomRpcMessageOptions, IntercomRpcDataMap } from "../../core/intercom-rpc.ts";
+export type RpcEvent = AgentSessionEvent | IntercomRpcEvent | SubagentRpcEvent | RpcExtensionUIRequest;
 import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { ImageContent, Model } from "@earendil-works/pi-ai";
 import type { SessionStats } from "../../core/agent-session.ts";
@@ -14,7 +22,7 @@ import type { CompactionResult } from "../../core/compaction/index.ts";
 import type { BranchSummaryEntry, SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
 import type { SourceInfo } from "../../core/source-info.ts";
 import type { ChangelogEntry } from "../../utils/changelog.ts";
-export type RpcCommand = {
+export type RpcCommand = IntercomRpcCommand | SubagentRpcCommand | ReleaseReadinessCommand | ReleaseCommand | StopAllBackgroundCommand | {
     id?: string;
     type: "prompt";
     message: string;
@@ -304,6 +312,8 @@ export interface RpcSessionState {
     thinkingLevel: ThinkingLevel;
     isStreaming: boolean;
     isCompacting: boolean;
+    /** True while an auto-retry is in flight (including the backoff sleep between attempts). */
+    isRetrying: boolean;
     steeringMode: "all" | "one-at-a-time";
     followUpMode: "all" | "one-at-a-time";
     sessionFile?: string;
@@ -326,7 +336,7 @@ export interface WorkflowState {
     step: number;
     done: boolean;
 }
-export type RpcResponse = {
+export type RpcResponse = IntercomRpcResponse | SubagentRpcResponse | ReleaseReadinessResponse | ReleaseResponse | StopAllBackgroundResponse | {
     id?: string;
     type: "response";
     command: "prompt";

package/dist/modes/rpc/rpc-types.js

@@ -1,7 +1 @@
-/**
- * RPC protocol types for headless operation.
- *
- * Commands are sent as JSON lines on stdin.
- * Responses and events are emitted as JSON lines on stdout.
- */
 export {};

package/dist/modes/rpc/subagent-bridge.d.ts

@@ -0,0 +1,23 @@
+import type { EventBus } from "../../core/event-bus.ts";
+import { type RpcObservationScope, type SubagentRpcCommand, type SubagentRpcEvent } from "../../core/subagent-rpc.ts";
+import type { RpcResponse } from "./rpc-types.ts";
+/** One native source per host binding. Subscription callbacks cannot cross generations. */
+export declare class RpcSubagentBridge {
+    private disposed;
+    private unsubscribe;
+    private source;
+    private revision;
+    private fingerprint;
+    private value;
+    private bus;
+    private output;
+    private scope;
+    private sourceError;
+    constructor(bus: EventBus | undefined, output: (event: SubagentRpcEvent) => void, scope: RpcObservationScope);
+    private missing;
+    /** Call after extension binding, including startup, session switch and reload. */
+    initialize(): void;
+    private update;
+    request(command: SubagentRpcCommand): RpcResponse;
+    dispose(): void;
+}

package/dist/modes/rpc/subagent-bridge.js

@@ -0,0 +1,93 @@
+import { SUBAGENT_OBSERVE_EVENT, isSubagentRpcProjection, } from "../../core/subagent-rpc.js";
+/** One native source per host binding. Subscription callbacks cannot cross generations. */
+export class RpcSubagentBridge {
+    disposed = false;
+    unsubscribe;
+    source;
+    revision = 0;
+    fingerprint = "";
+    value;
+    bus;
+    output;
+    scope;
+    sourceError;
+    constructor(bus, output, scope) {
+        this.bus = bus;
+        this.output = output;
+        this.scope = scope;
+        this.value = this.missing();
+    }
+    missing() {
+        return { ...this.scope, revision: this.revision, available: false, capabilities: { snapshot: true, events: false },
+            fleet: { version: 1, entries: [], totalActive: 0, topLevelAsyncCapacity: { used: 0, limit: 0 }, omitted: 0 }, runs: [], omitted: { runs: 0, children: 0 } };
+    }
+    /** Call after extension binding, including startup, session switch and reload. */
+    initialize() {
+        if (this.disposed)
+            return;
+        const request = { version: 1, sessionId: this.scope.sessionId, accept: source => {
+                if (!this.source && source && typeof source.snapshot === "function" && typeof source.subscribe === "function")
+                    this.source = source;
+            } };
+        this.bus?.emit(SUBAGENT_OBSERVE_EVENT, request);
+        if (this.source) {
+            try {
+                this.unsubscribe = this.source.subscribe(projection => {
+                    if (this.disposed)
+                        return;
+                    if (projection === null)
+                        this.source = undefined;
+                    try {
+                        this.update(projection);
+                        this.sourceError = undefined;
+                    }
+                    catch (error) {
+                        this.sourceError = error.message;
+                    }
+                });
+                this.update(this.source.snapshot(), true);
+            }
+            catch (error) {
+                this.sourceError = error.message;
+                this.update(null, true);
+            }
+        }
+        else
+            this.update(null, true);
+    }
+    update(projection, force = false) {
+        if (projection !== null && !isSubagentRpcProjection(projection))
+            throw new Error("Malformed subagent observation projection");
+        const fingerprint = JSON.stringify(projection);
+        if (!force && fingerprint === this.fingerprint)
+            return;
+        this.fingerprint = fingerprint;
+        this.revision++;
+        this.value = projection === null ? this.missing() : {
+            ...this.scope, revision: this.revision, available: true, capabilities: { snapshot: true, events: true },
+            ...JSON.parse(fingerprint),
+        };
+        this.output({ type: "subagent_event", ...this.scope, revision: this.revision, snapshot: this.value });
+    }
+    request(command) {
+        const failure = (error) => ({ id: command.id, type: "response", command: command.type, success: false, error });
+        if (command.version !== 1)
+            return failure("Unsupported subagent_status version; expected 1");
+        if (Object.keys(command).some(key => !["type", "version", "id"].includes(key))
+            || command.id !== undefined && (typeof command.id !== "string" || command.id.length > 128 || /[\r\n]/.test(command.id)))
+            return failure("Malformed subagent_status command");
+        if (this.disposed)
+            return failure("Subagent observation session ended");
+        try {
+            if (this.sourceError)
+                return failure(this.sourceError);
+            if (this.source)
+                this.update(this.source.snapshot());
+            return { id: command.id, type: "response", command: "subagent_status", success: true, data: this.value };
+        }
+        catch (error) {
+            return failure(error.message);
+        }
+    }
+    dispose() { this.disposed = true; this.unsubscribe?.(); this.source = undefined; }
+}

package/dist/modes/rpc/test-fixtures/intercom-host.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modes/rpc/test-fixtures/intercom-host.js

@@ -0,0 +1,13 @@
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, SessionManager, runRpcMode, } from "../../../index.js";
+// No unrelated bundled startup/onboarding extensions: this fixture exercises the shipped RPC host.
+const cwd = process.cwd();
+const agentDir = process.env.SELESAI_CODING_AGENT_DIR;
+const createRuntime = async options => {
+    const services = await createAgentSessionServices({ cwd: options.cwd, agentDir: options.agentDir, resourceLoaderOptions: { noExtensions: true, noSkills: true, noContextFiles: true, additionalExtensionPaths: [process.env.RPC_INTERCOM_EXTENSION, process.env.RPC_SUBAGENT_EXTENSION].filter((value) => Boolean(value)) } });
+    const result = await createAgentSessionFromServices({ services, sessionManager: options.sessionManager, sessionStartEvent: options.sessionStartEvent });
+    return { ...result, services, diagnostics: [] };
+};
+const runtime = await createAgentSessionRuntime(createRuntime, {
+    cwd, agentDir, sessionManager: SessionManager.create(cwd, agentDir),
+});
+await runRpcMode(runtime);