antechamber 0.2.4 → 0.2.5

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.5] - 2026-10-15
+
+### Added
+
+- OmO terminal monitors now appear in OpenChamber as read-only child sessions of
+  the session that started them. They are listed under Subagents and keep a live
+  sidebar dot while the watch runs, and their transcript shows the watched
+  command, filter, event count and how the watch ended. A session with a live
+  watch is no longer evicted as idle, which used to stop the watch.
+- MCP servers configured in OmO now appear in OpenChamber's MCP status, and the
+  Authorize button for a server that needs sign-in runs OmO's native
+  `/mcp auth` flow in the running session. Status and authorization use the
+  most recently used live session in the directory. The flow never adds a
+  message to the conversation, and it never revives a dormant session.
+- Completing an MCP sign-in with a pasted code or redirect URL (OpenChamber's
+  callback page or paste box) now works through `/mcp/{name}/auth/callback`.
+  The code goes to OmO's waiting loopback listener, or to
+  `/mcp auth-complete` when OmO parked the flow.
+- OpenChamber 2.x now lists OmO MCP servers (`GET /api/mcp`) and can sign in
+  through `mcp_*` integrations. These run OmO's headless `/mcp auth-start` and
+  `/mcp auth-complete` with a paste-the-code step. A completed sign-in emits
+  `mcp.status.changed`.
+
 ## [0.2.4] - 2026-10-15
 
 ### Added

package/dist/lifecycle.d.ts

@@ -30,6 +30,7 @@ export declare class SessionLifecycle {
     private stopping;
     constructor(sessions: () => Iterable<ManagedSession>, options?: LifecycleOptions);
     touch(s: ManagedSession): void;
+    lastUsed(s: ManagedSession): number;
     private idle;
     /** Protect the caller across awaits, including admission of a dormant session. */
     use<T>(s: ManagedSession, action: () => Promise<T>): Promise<T>;

package/dist/lifecycle.js

@@ -45,6 +45,9 @@ export class SessionLifecycle {
     touch(s) {
         this.used.set(s, this.clock.now());
     }
+    lastUsed(s) {
+        return this.used.get(s) ?? 0;
+    }
     idle(s) {
         return (!this.active.has(s) &&
             s.pi !== undefined &&
@@ -52,6 +55,7 @@ export class SessionLifecycle {
             s.status.type === "idle" &&
             !s.hasPendingInteraction() &&
             !s.hasRunningChildren() &&
+            !s.hasBackgroundWork?.() &&
             s.piSessionId !== undefined &&
             s.piPath !== undefined);
     }

package/dist/mcp.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OpenCode MCP routes (v1 `/mcp*`, v2 `/api/mcp` and `mcp_*` integrations) backed by OmO's MCP service.
+ *
+ * OpenChamber scopes MCP calls by directory only, while OmO owns MCP per session process.
+ * Everything therefore targets the most recently used LIVE session in the directory; a
+ * dormant session is never revived just to answer an MCP request.
+ *
+ * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
+ * documented `/mcp` subcommands (docs/mcp.md "Auth"):
+ * - `/mcp auth <name>`: OmO opens a loopback listener and the browser, exchanges the code
+ *   and reconnects. With `mcp.oauthCallbackUrl` set it parks a pending flow instead.
+ * - `/mcp auth-start <name>` then `/mcp auth-complete <name> <redirect-url>`: the headless
+ *   paste flow; the pending PKCE state lives in that session process, so completion must
+ *   reach the same process.
+ * Commands are sent straight to the agent, outside the conversation queue: they neither
+ * wait behind a running turn nor create a user message, and the session is held active so
+ * the reaper cannot stop the process (and its listener or pending state) mid-flow.
+ */
+import type { RouteServices } from "./route-services.js";
+type OCMcpStatus = {
+    status: "connected";
+} | {
+    status: "disabled";
+} | {
+    status: "failed";
+    error: string;
+} | {
+    status: "needs_auth";
+} | {
+    status: "needs_client_registration";
+    error: string;
+};
+type V2McpStatus = {
+    status: "connected";
+} | {
+    status: "pending";
+} | {
+    status: "disabled";
+} | {
+    status: "failed";
+    error: string;
+} | {
+    status: "needs_auth";
+    error: string;
+};
+interface OmoMcpServer {
+    name: string;
+    status?: string;
+    authStatus?: string;
+}
+interface RouteResult {
+    status: number;
+    body?: unknown;
+}
+/** OmO's loopback listener gives up after 5 minutes; leave room for the reconnect that follows. */
+export declare const MCP_AUTH_COMMAND_TIMEOUT_MS: number;
+/** OmO's runtime states fold onto OpenCode's; lazy servers are usable, so they read as connected. */
+export declare function openCodeMcpStatus(server: OmoMcpServer): OCMcpStatus;
+export declare function v2McpStatus(server: OmoMcpServer): V2McpStatus;
+/** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
+export declare function authorizationUrl(text: string, name: string): string | undefined;
+/**
+ * The redirect `/mcp auth-complete` expects. OpenChamber sends either the bare code (callback
+ * page, v1 paste box) or the whole redirect address; a bare code is rebuilt from the
+ * authorization request's own `redirect_uri` and `state`.
+ */
+export declare function redirectInput(authorization: string, input: string): string | undefined;
+export declare function mcpRoute(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
+export declare function mcpRouteV2(services: RouteServices, method: string, path: string, directory: string, body: () => Promise<unknown>): Promise<RouteResult | undefined>;
+export {};

package/dist/mcp.js

@@ -0,0 +1,494 @@
+/**
+ * OpenCode MCP routes (v1 `/mcp*`, v2 `/api/mcp` and `mcp_*` integrations) backed by OmO's MCP service.
+ *
+ * OpenChamber scopes MCP calls by directory only, while OmO owns MCP per session process.
+ * Everything therefore targets the most recently used LIVE session in the directory; a
+ * dormant session is never revived just to answer an MCP request.
+ *
+ * Status comes from the read-only `get_loaded_surfaces` RPC. Authorization drives OmO's
+ * documented `/mcp` subcommands (docs/mcp.md "Auth"):
+ * - `/mcp auth <name>`: OmO opens a loopback listener and the browser, exchanges the code
+ *   and reconnects. With `mcp.oauthCallbackUrl` set it parks a pending flow instead.
+ * - `/mcp auth-start <name>` then `/mcp auth-complete <name> <redirect-url>`: the headless
+ *   paste flow; the pending PKCE state lives in that session process, so completion must
+ *   reach the same process.
+ * Commands are sent straight to the agent, outside the conversation queue: they neither
+ * wait behind a running turn nor create a user message, and the session is held active so
+ * the reaper cannot stop the process (and its listener or pending state) mid-flow.
+ */
+import { randomUUID } from "node:crypto";
+import { errorBody } from "./http.js";
+/** Bounds how long an HTTP caller waits on a read-only RPC; the transport keeps its own budget. */
+const MCP_READ_WAIT_MS = 5_000;
+/** OmO announces the authorization URL before it waits for the browser. */
+const MCP_AUTH_URL_WAIT_MS = 30_000;
+/** OmO's loopback listener gives up after 5 minutes; leave room for the reconnect that follows. */
+export const MCP_AUTH_COMMAND_TIMEOUT_MS = 10 * 60_000;
+/** A pending paste flow is forgotten after this; OmO's own state is replaced by the next start. */
+const MCP_AUTH_ATTEMPT_TTL_MS = 10 * 60_000;
+/** Names are passed as one slash-command argument, so they must not split or quote. */
+const SERVER_NAME = /^[^\s"'\\]+$/;
+const INTEGRATION_PREFIX = "mcp_";
+const OAUTH_METHOD_ID = "oauth";
+const flows = new Map();
+const admissions = new Map();
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const flowKey = (directory, name) => `${directory}\0${name}`;
+/** OmO's runtime states fold onto OpenCode's; lazy servers are usable, so they read as connected. */
+export function openCodeMcpStatus(server) {
+    if (server.status === "needs_client_registration")
+        return {
+            status: "needs_client_registration",
+            error: "OAuth client registration is required; configure a client ID for this server in OmO",
+        };
+    if (server.status === "needs_auth")
+        return { status: "needs_auth" };
+    if (server.status === "disabled" || server.status === "untrusted")
+        return { status: "disabled" };
+    if (server.status === "degraded")
+        return { status: "failed", error: "MCP server is degraded; see /mcp logs in OmO" };
+    if (server.status !== "connected" && server.authStatus === "notLoggedIn")
+        return { status: "needs_auth" };
+    return { status: "connected" };
+}
+export function v2McpStatus(server) {
+    const status = openCodeMcpStatus(server);
+    if (status.status === "needs_auth")
+        return { status: "needs_auth", error: "Sign-in required" };
+    if (status.status === "needs_client_registration")
+        return { status: "needs_auth", error: status.error };
+    if (status.status === "connected" && server.status === "connecting")
+        return { status: "pending" };
+    return status;
+}
+const oauthCapable = (server) => server.authStatus === "notLoggedIn" || server.authStatus === "oAuth";
+function liveSession(sessions, directory) {
+    const s = sessions.liveSessions(directory)[0];
+    return s?.pi === undefined ? undefined : { s, pi: s.pi };
+}
+async function loadedServers(pi) {
+    const response = await pi.command({ type: "get_loaded_surfaces" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
+    // Older OmO builds have no loaded-surfaces RPC: report no servers rather than a failure.
+    if (!response.success || !isRecord(response.data) || !Array.isArray(response.data.mcpServers))
+        return [];
+    return response.data.mcpServers.flatMap((server) => isRecord(server) && typeof server.name === "string"
+        ? [
+            {
+                name: server.name,
+                ...(typeof server.status === "string" ? { status: server.status } : {}),
+                ...(typeof server.authStatus === "string" ? { authStatus: server.authStatus } : {}),
+            },
+        ]
+        : []);
+}
+async function directoryServers(sessions, directory) {
+    const live = liveSession(sessions, directory);
+    return live === undefined ? [] : loadedServers(live.pi).catch(() => []);
+}
+async function hasMcpCommand(pi) {
+    const response = await pi.command({ type: "get_commands" }, undefined, AbortSignal.timeout(MCP_READ_WAIT_MS));
+    if (!response.success || !isRecord(response.data) || !Array.isArray(response.data.commands))
+        return false;
+    return response.data.commands.some((command) => isRecord(command) && command.name === "mcp" && command.source === "extension");
+}
+/** The URL OmO prints on its own line after naming the server (`auth` and `auth-start` both do). */
+export function authorizationUrl(text, name) {
+    if (!text.includes(name))
+        return undefined;
+    const candidate = /(?:^|\n)(https?:\/\/\S+)/.exec(text)?.[1];
+    if (candidate === undefined)
+        return undefined;
+    try {
+        return new URL(candidate).toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The redirect `/mcp auth-complete` expects. OpenChamber sends either the bare code (callback
+ * page, v1 paste box) or the whole redirect address; a bare code is rebuilt from the
+ * authorization request's own `redirect_uri` and `state`.
+ */
+export function redirectInput(authorization, input) {
+    const pasted = input.trim();
+    if (pasted === "" || /\s/.test(pasted))
+        return undefined;
+    try {
+        const url = new URL(pasted);
+        if (url.searchParams.has("code") || url.searchParams.has("error"))
+            return url.toString();
+    }
+    catch {
+        // Not an address: treat it as the authorization code itself.
+    }
+    const request = new URL(authorization).searchParams;
+    const redirect = request.get("redirect_uri");
+    if (redirect === null)
+        return undefined;
+    const url = new URL(redirect);
+    url.searchParams.set("code", pasted);
+    const state = request.get("state");
+    if (state !== null)
+        url.searchParams.set("state", state);
+    return url.toString();
+}
+/** Only the listener OmO announced for this flow may receive the pasted redirect. */
+function sameCallback(target, authorization) {
+    const announced = new URL(authorization).searchParams.get("redirect_uri");
+    if (announced === null)
+        return false;
+    const expected = new URL(announced);
+    return target.origin === expected.origin && target.pathname === expected.pathname;
+}
+function runMcpCommand(sessions, s, pi, name, args, observe = {}) {
+    const errors = [];
+    const onEvent = (event) => {
+        const entry = event.entry;
+        if (event.type !== "entry_appended" || !isRecord(entry))
+            return;
+        if (entry.type !== "custom" || entry.customType !== "mcp-auth" || typeof entry.data !== "string")
+            return;
+        const done = `MCP server ${name} `;
+        if (entry.data.startsWith(`${done}authorized`) || entry.data.startsWith(`${done}authenticated`))
+            observe.authorized?.();
+        const found = authorizationUrl(entry.data, name);
+        if (found !== undefined)
+            observe.url?.(found);
+    };
+    const onNotify = (request) => {
+        if (request.method !== "notify" || request.notifyType !== "error" || typeof request.message !== "string")
+            return;
+        if (request.message.includes(`MCP server ${name} `) || request.message.includes(`MCP server: ${name}`))
+            errors.push(request.message);
+    };
+    pi.onEvent(onEvent);
+    pi.onExtensionUI(onNotify);
+    return sessions.lifecycle
+        .use(s, () => pi.command({ type: "prompt", message: `/mcp ${args}`, expandPromptTemplates: true }, MCP_AUTH_COMMAND_TIMEOUT_MS))
+        .then((response) => {
+        if (!response.success)
+            throw new Error(response.error ?? "OmO rejected the /mcp command");
+        const disposition = isRecord(response.data) ? response.data.disposition : undefined;
+        if (disposition !== "handled")
+            throw new Error(`OmO did not handle /mcp (disposition: ${String(disposition)})`);
+        if (errors.length > 0)
+            throw new Error(errors.join("\n"));
+    })
+        .finally(() => {
+        pi.off("event", onEvent);
+        pi.off("extension_ui_request", onNotify);
+    });
+}
+function announce(services, directory, name) {
+    services.broadcast(directory, { type: "mcp.tools.changed", properties: { server: name } });
+}
+function pruneFlows() {
+    const now = Date.now();
+    for (const [key, flow] of flows)
+        if (!flow.running && (flow.s.pi !== flow.pi || now - flow.created > MCP_AUTH_ATTEMPT_TTL_MS))
+            flows.delete(key);
+}
+/** Concurrent clicks share one admission, so a second `/mcp auth` never races the first. */
+function admitFlow(services, directory, name, command) {
+    const key = flowKey(directory, name);
+    const pending = admissions.get(key);
+    if (pending !== undefined)
+        return pending.then((admission) => "flow" in admission && admission.flow.command !== command ? inProgress(name) : admission);
+    const admission = startFlow(services, directory, name, command).finally(() => admissions.delete(key));
+    admissions.set(key, admission);
+    return admission;
+}
+const inProgress = (name) => ({
+    error: { status: 409, body: errorBody("McpAuthError", `MCP server ${name} authorization is already in progress`) },
+});
+/** Validates the target and starts (or joins) a flow; never sends a prompt without a `/mcp` command. */
+async function startFlow(services, directory, name, command) {
+    if (!SERVER_NAME.test(name))
+        return { error: { status: 400, body: errorBody("InvalidRequestError", "invalid MCP server name") } };
+    const live = liveSession(services.sessions, directory);
+    if (live === undefined)
+        return {
+            error: {
+                status: 400,
+                body: errorBody("McpUnavailableError", "MCP authorization needs a running OmO session in this directory"),
+            },
+        };
+    const { s, pi } = live;
+    const key = flowKey(directory, name);
+    pruneFlows();
+    const existing = flows.get(key);
+    if (existing?.running && existing.pi === pi)
+        return existing.command === command ? { flow: existing } : inProgress(name);
+    const servers = await loadedServers(pi);
+    if (!servers.some((server) => server.name === name))
+        return { error: { status: 404, body: errorBody("McpServerNotFoundError", `MCP server not found: ${name}`) } };
+    if (!(await hasMcpCommand(pi)))
+        return { error: { status: 400, body: errorBody("UnsupportedError", "This OmO build has no /mcp command") } };
+    const url = Promise.withResolvers();
+    const flow = {
+        s,
+        pi,
+        command,
+        attemptID: randomUUID(),
+        created: Date.now(),
+        url: url.promise,
+        done: Promise.resolve(),
+        running: true,
+        authorized: false,
+    };
+    flow.done = runMcpCommand(services.sessions, s, pi, name, `${command} ${name}`, {
+        url: (found) => {
+            flow.authorizationUrl ??= found;
+            url.resolve(found);
+        },
+        authorized: () => {
+            flow.authorized = true;
+        },
+    })
+        .then(() => {
+        if (flow.authorized)
+            announce(services, directory, name);
+    })
+        .catch((error) => {
+        flow.error = errorMessage(error);
+        throw error;
+    })
+        .finally(() => {
+        flow.running = false;
+    });
+    // The caller that started the flow may already have its URL; a later failure is still reported.
+    void flow.done.catch((error) => console.error(`[mcp] authorization of ${name} failed: ${errorMessage(error)}`));
+    flows.set(key, flow);
+    return { flow };
+}
+async function awaitAuthorizationUrl(flow, name) {
+    const wait = AbortSignal.timeout(MCP_AUTH_URL_WAIT_MS);
+    const timedOut = new Promise((resolve) => wait.addEventListener("abort", () => resolve("timeout")));
+    try {
+        const url = await Promise.race([flow.url, flow.done.then(() => undefined), timedOut]);
+        if (url === "timeout")
+            return { error: `OmO did not produce an authorization URL for ${name}` };
+        if (url === undefined)
+            return { error: `MCP server ${name} finished without a browser step` };
+        return { url };
+    }
+    catch (error) {
+        return { error: errorMessage(error) };
+    }
+}
+async function currentStatus(pi, name) {
+    return (await loadedServers(pi)).find((server) => server.name === name);
+}
+/**
+ * Finishes a flow with the code or redirect the browser produced. A flow still waiting on
+ * OmO's loopback listener receives the redirect there (antechamber always runs beside its
+ * agent); a parked flow is finished with `/mcp auth-complete` in the process that holds its state.
+ */
+async function completeFlow(services, directory, name, input) {
+    const key = flowKey(directory, name);
+    const flow = flows.get(key);
+    const fail = (status, name_, message) => ({
+        error: { status, body: errorBody(name_, message) },
+    });
+    if (flow === undefined || flow.s.pi !== flow.pi || Date.now() - flow.created > MCP_AUTH_ATTEMPT_TTL_MS)
+        return fail(400, "McpAuthError", `No pending authorization for ${name}; start it again`);
+    if (flow.authorized)
+        return { server: await currentStatus(flow.pi, name) };
+    if (flow.error !== undefined)
+        return fail(400, "McpAuthError", `Authorization of ${name} failed (${flow.error}); start it again`);
+    if (typeof input !== "string" || flow.authorizationUrl === undefined)
+        return fail(400, "InvalidRequestError", "code is required");
+    const redirect = redirectInput(flow.authorizationUrl, input);
+    if (redirect === undefined)
+        return fail(400, "InvalidRequestError", "code must be an authorization code or redirect URL");
+    try {
+        if (flow.running && flow.command === "auth") {
+            const target = new URL(redirect);
+            if (!sameCallback(target, flow.authorizationUrl))
+                return fail(400, "McpAuthError", `OmO is waiting for ${name} on its loopback callback; paste that redirect`);
+            const delivered = await fetch(target, { redirect: "manual", signal: AbortSignal.timeout(MCP_READ_WAIT_MS) });
+            if (!delivered.ok) {
+                // OmO ends the flow on a rejected callback; settle it so a retry cannot join the dead flow.
+                await flow.done.catch(() => undefined);
+                return fail(400, "McpAuthError", `OmO rejected the authorization response for ${name}; start it again`);
+            }
+            await flow.done;
+        }
+        else {
+            await runMcpCommand(services.sessions, flow.s, flow.pi, name, `auth-complete ${name} ${redirect}`, {
+                authorized: () => {
+                    flow.authorized = true;
+                },
+            });
+            announce(services, directory, name);
+        }
+    }
+    catch (error) {
+        flow.error = errorMessage(error);
+        return fail(400, "McpAuthError", flow.error);
+    }
+    if (!flow.authorized)
+        return fail(400, "McpAuthError", flow.error ?? `MCP server ${name} did not complete authorization`);
+    return { server: await currentStatus(flow.pi, name) };
+}
+function decodeName(raw) {
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+const invalidName = { status: 400, body: errorBody("InvalidRequestError", "invalid MCP server name") };
+export async function mcpRoute(services, method, path, directory, body) {
+    if (method === "GET" && path === "/mcp") {
+        const servers = await directoryServers(services.sessions, directory);
+        return { status: 200, body: Object.fromEntries(servers.map((server) => [server.name, openCodeMcpStatus(server)])) };
+    }
+    const match = /^\/mcp\/([^/]+)\/auth(\/authenticate|\/callback)?$/.exec(path);
+    if (method !== "POST" || match === null)
+        return undefined;
+    const name = decodeName(match[1]);
+    if (name === undefined)
+        return invalidName;
+    if (match[2] === "/callback") {
+        const payload = await body();
+        const result = await completeFlow(services, directory, name, isRecord(payload) ? payload.code : undefined);
+        if ("error" in result)
+            return result.error;
+        return {
+            status: 200,
+            body: result.server === undefined ? { status: "disabled" } : openCodeMcpStatus(result.server),
+        };
+    }
+    const admitted = await admitFlow(services, directory, name, "auth");
+    if ("error" in admitted)
+        return admitted.error;
+    const { flow } = admitted;
+    if (match[2] === "/authenticate") {
+        try {
+            await flow.done;
+        }
+        catch (error) {
+            return { status: 400, body: errorBody("McpAuthError", errorMessage(error)) };
+        }
+        if (!flow.authorized)
+            return {
+                status: 400,
+                body: errorBody("McpAuthError", `MCP server ${name} is waiting for its authorization code; paste it to finish`),
+            };
+        const server = await currentStatus(flow.pi, name);
+        return { status: 200, body: server === undefined ? { status: "disabled" } : openCodeMcpStatus(server) };
+    }
+    const announced = await awaitAuthorizationUrl(flow, name);
+    if ("error" in announced)
+        return { status: 400, body: errorBody("McpAuthError", announced.error) };
+    return {
+        status: 200,
+        body: { authorizationUrl: announced.url, oauthState: new URL(announced.url).searchParams.get("state") ?? "" },
+    };
+}
+function integrationInfo(server) {
+    return {
+        id: `${INTEGRATION_PREFIX}${server.name}`,
+        name: server.name,
+        metadata: { source: "mcp" },
+        methods: [{ id: OAUTH_METHOD_ID, type: "oauth", label: "Sign in with OAuth" }],
+        connections: [],
+    };
+}
+function attemptTime(flow) {
+    return { created: flow.created, expires: flow.created + MCP_AUTH_ATTEMPT_TTL_MS };
+}
+function flowForAttempt(directory, name, attemptID) {
+    const flow = flows.get(flowKey(directory, name));
+    return flow?.attemptID === attemptID ? flow : undefined;
+}
+export async function mcpRouteV2(services, method, path, directory, body) {
+    const located = (status, data) => ({ status, body: { location: { directory }, data } });
+    if (method === "GET" && path === "/api/mcp") {
+        const servers = await directoryServers(services.sessions, directory);
+        return located(200, servers.map((server) => ({
+            name: server.name,
+            status: v2McpStatus(server),
+            ...(oauthCapable(server) ? { integrationID: `${INTEGRATION_PREFIX}${server.name}` } : {}),
+        })));
+    }
+    if (method === "GET" && path === "/api/integration") {
+        const servers = await directoryServers(services.sessions, directory);
+        return located(200, servers.filter(oauthCapable).map(integrationInfo));
+    }
+    const match = /^\/api\/integration\/mcp_([^/]+)(\/connect\/oauth(?:\/([^/]+)(\/complete)?)?)?$/.exec(path);
+    if (match === null)
+        return undefined;
+    const name = decodeName(match[1]);
+    if (name === undefined)
+        return invalidName;
+    const [, , connect, rawAttempt, complete] = match;
+    if (connect === undefined) {
+        if (method !== "GET")
+            return undefined;
+        const server = (await directoryServers(services.sessions, directory)).find((candidate) => candidate.name === name && oauthCapable(candidate));
+        if (server === undefined)
+            return { status: 404, body: errorBody("NotFoundError", `integration not found: ${INTEGRATION_PREFIX}${name}`) };
+        return located(200, integrationInfo(server));
+    }
+    if (rawAttempt === undefined) {
+        if (method !== "POST")
+            return undefined;
+        const payload = await body();
+        if (isRecord(payload) && payload.methodID !== undefined && payload.methodID !== OAUTH_METHOD_ID)
+            return { status: 404, body: errorBody("IntegrationMethodNotFoundError", "unknown integration method") };
+        const admitted = await admitFlow(services, directory, name, "auth-start");
+        if ("error" in admitted)
+            return admitted.error;
+        const announced = await awaitAuthorizationUrl(admitted.flow, name);
+        if ("error" in announced)
+            return { status: 400, body: errorBody("McpAuthError", announced.error) };
+        return located(200, {
+            attemptID: admitted.flow.attemptID,
+            url: announced.url,
+            instructions: "Approve access in the browser, then paste the final redirect URL (or the code it carries) to finish.",
+            mode: "code",
+            time: attemptTime(admitted.flow),
+        });
+    }
+    const attemptID = decodeName(rawAttempt);
+    const flow = attemptID === undefined ? undefined : flowForAttempt(directory, name, attemptID);
+    const missing = {
+        status: 404,
+        body: errorBody("IntegrationAttemptNotFoundError", `authorization attempt not found: ${rawAttempt}`),
+    };
+    if (complete !== undefined) {
+        if (method !== "POST")
+            return undefined;
+        if (flow === undefined)
+            return missing;
+        const payload = await body();
+        const result = await completeFlow(services, directory, name, isRecord(payload) ? payload.code : undefined);
+        return "error" in result ? result.error : { status: 204 };
+    }
+    if (method === "DELETE") {
+        if (flow !== undefined)
+            flows.delete(flowKey(directory, name));
+        return { status: 204 };
+    }
+    if (method !== "GET")
+        return undefined;
+    if (flow === undefined)
+        return missing;
+    const time = attemptTime(flow);
+    if (flow.authorized)
+        return located(200, { status: "complete", time });
+    if (flow.error !== undefined)
+        return located(200, { status: "failed", message: flow.error, time });
+    if (Date.now() > time.expires)
+        return located(200, { status: "expired", time });
+    return located(200, { status: "pending", time });
+}

package/dist/misc-routes.js

@@ -45,15 +45,14 @@ export async function miscRoute(method, path, url, directory) {
     if (method === "GET" && ["/skill", "/lsp", "/formatter", "/experimental/tool/ids"].includes(path)) {
         return { status: 200, body: [] };
     }
-    if (method === "GET" && ["/provider/auth", "/mcp"].includes(path))
+    if (method === "GET" && path === "/provider/auth")
         return { status: 200, body: {} };
     if ((method === "PUT" && /^\/auth\/[^/]+$/.test(path)) ||
         (method === "POST" && /^\/provider\/[^/]+\/oauth\/(authorize|callback)$/.test(path)) ||
         (method === "PATCH" && path === "/config")) {
         return unsupported("Not supported with OmO; configure providers in OmO");
     }
-    if ((["POST", "DELETE"].includes(method) &&
-        /^\/mcp\/[^/]+\/(connect|disconnect|auth(?:\/(?:callback|authenticate))?)$/.test(path)) ||
+    if ((["POST", "DELETE"].includes(method) && /^\/mcp\/[^/]+\/(connect|disconnect|auth)$/.test(path)) ||
         (method === "POST" && path === "/experimental/control-plane/move-session")) {
         return unsupported("Not supported with OmO; configure MCP and session directories in OmO");
     }

package/dist/monitor-sessions.d.ts

@@ -0,0 +1,48 @@
+import type { ManagedSession } from "./sessions.js";
+import type { OCEvent, OCMessageWithParts } from "./types.js";
+/** Names OmO's terminal extension passes to `pi.rpc.emit` (core/extensions/builtin/monitor-state-event.js). */
+export declare const MONITOR_STATE_EVENT = "terminal_monitor_state";
+export declare const MONITOR_ENDED_EVENT = "terminal_monitor_ended";
+export interface MonitorSnapshot {
+    id: string;
+    description: string;
+    command: string | null;
+    filter: string | null;
+    paused: boolean;
+    persistent: boolean;
+    startedAtMs: number;
+    deadlineMs: number | null;
+    fireCount: number;
+    lastFiredAtMs: number | null;
+}
+interface MonitorEnding {
+    reason: string;
+    exitCode: number | null;
+    endedAtMs: number;
+}
+export declare function parseMonitor(value: unknown): MonitorSnapshot | undefined;
+export declare function monitorSummary(monitor: MonitorSnapshot, ending?: MonitorEnding): string;
+export declare class MonitorSessions {
+    private readonly sessions;
+    private readonly emit;
+    private readonly watches;
+    /** Children the user deleted; a later snapshot of the same watch must not resurrect them. */
+    private readonly dismissed;
+    constructor(sessions: Map<string, ManagedSession>, emit: (directory: string, event: OCEvent) => void);
+    wire(parent: ManagedSession): void;
+    owns(id: string): boolean;
+    messages(id: string): OCMessageWithParts[];
+    observe(parent: ManagedSession, ev: Record<string, unknown>): void;
+    /** The agent process is gone: OmO's in-process watches died with it. */
+    stopParent(parentID: string): void;
+    /** Forget a deleted child, or every child of a deleted parent. */
+    remove(id: string): void;
+    private running;
+    private childID;
+    private applyState;
+    private applyEnded;
+    private end;
+    private create;
+    private publish;
+}
+export {};

package/dist/monitor-sessions.js

@@ -0,0 +1,295 @@
+/**
+ * OmO terminal monitors as read-only child sessions. OpenChamber has no surface for
+ * background watches, but it already lists child sessions under Subagents and gives each
+ * a live dot, so a watch is busy while OmO reports it and idle once it ends.
+ */
+import { getAgentName } from "./agent-name.js";
+import { ocIdFor } from "./session-store.js";
+/** Names OmO's terminal extension passes to `pi.rpc.emit` (core/extensions/builtin/monitor-state-event.js). */
+export const MONITOR_STATE_EVENT = "terminal_monitor_state";
+export const MONITOR_ENDED_EVENT = "terminal_monitor_ended";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function finite(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function text(value) {
+    return typeof value === "string" && value !== "" ? value : null;
+}
+export function parseMonitor(value) {
+    if (!record(value) || typeof value.id !== "string" || value.id === "")
+        return undefined;
+    const startedAtMs = finite(value.startedAtMs);
+    if (startedAtMs === null)
+        return undefined;
+    return {
+        id: value.id,
+        description: text(value.description) ?? value.id,
+        command: text(value.command),
+        filter: text(value.filter),
+        paused: value.paused === true,
+        persistent: value.persistent === true,
+        startedAtMs,
+        deadlineMs: finite(value.deadlineMs),
+        fireCount: finite(value.fireCount) ?? 0,
+        lastFiredAtMs: finite(value.lastFiredAtMs),
+    };
+}
+function endingLabel(ending) {
+    switch (ending.reason) {
+        case "exit":
+            return ending.exitCode === null ? "command exited" : `command exited with code ${ending.exitCode}`;
+        case "timeout":
+            return "deadline reached";
+        case "killed":
+            return "stopped";
+        case "disposed":
+            return "suspended by an OmO shutdown or reload";
+        case "agent-exit":
+            return "OmO process exited";
+        default:
+            return "ended";
+    }
+}
+function iso(ms) {
+    return ms === null ? undefined : new Date(ms).toISOString();
+}
+export function monitorSummary(monitor, ending) {
+    const deadline = monitor.persistent ? "none (persistent)" : iso(monitor.deadlineMs);
+    return [
+        `Status: ${ending ? endingLabel(ending) : monitor.paused ? "paused" : "watching"}`,
+        monitor.filter !== null ? `Filter: ${monitor.filter}` : undefined,
+        `Events: ${monitor.fireCount}`,
+        monitor.lastFiredAtMs !== null ? `Last event: ${iso(monitor.lastFiredAtMs)}` : undefined,
+        `Started: ${iso(monitor.startedAtMs)}`,
+        ending ? `Ended: ${iso(ending.endedAtMs)}` : deadline !== undefined ? `Deadline: ${deadline}` : undefined,
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+}
+export class MonitorSessions {
+    sessions;
+    emit;
+    watches = new Map();
+    /** Children the user deleted; a later snapshot of the same watch must not resurrect them. */
+    dismissed = new Set();
+    constructor(sessions, emit) {
+        this.sessions = sessions;
+        this.emit = emit;
+    }
+    wire(parent) {
+        parent.hasBackgroundWork = () => this.running(parent.info.id);
+    }
+    owns(id) {
+        return this.watches.has(id);
+    }
+    messages(id) {
+        return this.watches.get(id)?.session.messages ?? [];
+    }
+    observe(parent, ev) {
+        if (!record(ev.data))
+            return;
+        if (ev.name === MONITOR_STATE_EVENT && Array.isArray(ev.data.monitors))
+            this.applyState(parent, ev.data.monitors);
+        else if (ev.name === MONITOR_ENDED_EVENT)
+            this.applyEnded(parent, ev.data);
+    }
+    /** The agent process is gone: OmO's in-process watches died with it. */
+    stopParent(parentID) {
+        for (const watch of this.watches.values()) {
+            if (watch.session.info.parentID !== parentID || watch.ending !== undefined)
+                continue;
+            this.end(watch, { reason: "agent-exit", exitCode: null, endedAtMs: Date.now() });
+        }
+    }
+    /** Forget a deleted child, or every child of a deleted parent. */
+    remove(id) {
+        for (const [childID, watch] of this.watches) {
+            if (childID !== id && watch.session.info.parentID !== id)
+                continue;
+            this.watches.delete(childID);
+            this.dismissed.add(childID);
+            if (this.sessions.get(childID) !== watch.session)
+                continue;
+            this.sessions.delete(childID);
+            this.emit(watch.session.info.directory, { type: "session.deleted", properties: { info: watch.session.info } });
+        }
+    }
+    running(parentID) {
+        for (const watch of this.watches.values()) {
+            if (watch.session.info.parentID === parentID && watch.ending === undefined)
+                return true;
+        }
+        return false;
+    }
+    childID(parent, monitorID) {
+        return ocIdFor(`${parent.info.id}/monitor/${monitorID}`);
+    }
+    applyState(parent, entries) {
+        const live = new Set();
+        for (const entry of entries) {
+            const monitor = parseMonitor(entry);
+            if (!monitor)
+                continue;
+            const id = this.childID(parent, monitor.id);
+            live.add(id);
+            if (this.dismissed.has(id))
+                continue;
+            const watch = this.watches.get(id);
+            if (watch === undefined)
+                this.create(parent, id, monitor);
+            else {
+                watch.monitor = monitor;
+                delete watch.ending;
+                this.publish(watch);
+            }
+        }
+        // A snapshot lists every live watch; one that is missing has ended. Its reason may follow.
+        for (const [id, watch] of this.watches) {
+            if (watch.session.info.parentID !== parent.info.id || watch.ending !== undefined || live.has(id))
+                continue;
+            this.end(watch, { reason: "ended", exitCode: null, endedAtMs: Date.now() });
+        }
+    }
+    applyEnded(parent, data) {
+        if (typeof data.id !== "string")
+            return;
+        const watch = this.watches.get(this.childID(parent, data.id));
+        if (!watch)
+            return;
+        const fireCount = finite(data.fireCount);
+        if (fireCount !== null)
+            watch.monitor.fireCount = fireCount;
+        this.end(watch, {
+            reason: typeof data.reason === "string" ? data.reason : "ended",
+            exitCode: finite(data.exitCode),
+            endedAtMs: finite(data.endedAtMs) ?? Date.now(),
+        });
+    }
+    end(watch, ending) {
+        watch.ending = ending;
+        this.publish(watch);
+    }
+    create(parent, id, monitor) {
+        const now = Date.now();
+        const session = {
+            info: {
+                id,
+                parentID: parent.info.id,
+                projectID: parent.info.projectID,
+                directory: parent.info.directory,
+                title: `Monitor: ${monitor.description}`,
+                version: parent.info.version,
+                time: { created: monitor.startedAtMs, updated: now },
+            },
+            pi: undefined,
+            messages: [],
+            model: parent.model,
+            streaming: undefined,
+            status: { type: "idle" },
+            toolByCallId: new Map(),
+            tree: { messageEntries: {} },
+            hasPendingInteraction: () => false,
+            hasRunningChildren: () => false,
+        };
+        const watch = { session, monitor };
+        this.watches.set(id, watch);
+        this.sessions.set(id, session);
+        this.emit(session.info.directory, { type: "session.created", properties: { info: session.info } });
+        this.publish(watch);
+    }
+    publish(watch) {
+        const { session, monitor, ending } = watch;
+        const directory = session.info.directory;
+        const sessionID = session.info.id;
+        const base = sessionID.replace(/^ses_/, "");
+        const model = session.model ?? { providerID: "omo", modelID: "monitor" };
+        const started = monitor.startedAtMs;
+        const command = monitor.command ?? monitor.description;
+        const input = { command, description: monitor.description };
+        const output = monitorSummary(monitor, ending);
+        const tool = {
+            id: `prt_${base}_tool`,
+            sessionID,
+            messageID: `msg_${base}_1`,
+            type: "tool",
+            callID: `call_${base}`,
+            tool: "bash",
+            state: ending
+                ? {
+                    status: "completed",
+                    input,
+                    output,
+                    title: monitor.description,
+                    metadata: { monitor, ending },
+                    time: { start: started, end: ending.endedAtMs },
+                }
+                : {
+                    status: "running",
+                    input,
+                    title: monitor.description,
+                    metadata: { monitor, output },
+                    time: { start: started },
+                },
+        };
+        const messages = [
+            {
+                info: {
+                    id: `msg_${base}_0`,
+                    sessionID,
+                    role: "user",
+                    time: { created: started },
+                    agent: getAgentName(),
+                    model,
+                },
+                parts: [
+                    {
+                        id: `prt_${base}_request`,
+                        sessionID,
+                        messageID: `msg_${base}_0`,
+                        type: "text",
+                        text: "The agent started a background monitor",
+                        synthetic: true,
+                        time: { start: started, end: started },
+                    },
+                ],
+            },
+            {
+                info: {
+                    id: `msg_${base}_1`,
+                    sessionID,
+                    role: "assistant",
+                    time: { created: started, ...(ending ? { completed: ending.endedAtMs } : {}) },
+                    parentID: `msg_${base}_0`,
+                    modelID: model.modelID,
+                    providerID: model.providerID,
+                    mode: getAgentName(),
+                    path: { cwd: directory, root: directory },
+                    cost: 0,
+                    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                    ...(ending ? { finish: "stop" } : {}),
+                },
+                parts: [tool],
+            },
+        ];
+        const before = new Map((session.messages ?? []).map((message) => [message.info.id, JSON.stringify(message)]));
+        session.messages = messages;
+        for (const message of messages) {
+            if (before.get(message.info.id) === JSON.stringify(message))
+                continue;
+            this.emit(directory, { type: "message.updated", properties: { info: message.info } });
+            for (const part of message.parts)
+                this.emit(directory, { type: "message.part.updated", properties: { part } });
+        }
+        const status = ending ? "idle" : "busy";
+        if (session.status.type === status)
+            return;
+        session.status = { type: status };
+        session.info.time.updated = Date.now();
+        this.emit(directory, { type: "session.updated", properties: { info: session.info } });
+        this.emit(directory, { type: "session.status", properties: { sessionID, status: session.status } });
+        if (status === "idle")
+            this.emit(directory, { type: "session.idle", properties: { sessionID } });
+    }
+}

package/dist/pi-event-translation.d.ts

@@ -3,6 +3,7 @@ import type { OCAssistantMessage, OCMessageWithParts, OCModelRef, OCEvent, OCSes
 import type { ManagedSession } from "./sessions.js";
 import type { SessionStore } from "./session-store.js";
 import type { SubagentBridge } from "./subagents.js";
+import type { MonitorSessions } from "./monitor-sessions.js";
 import { type TodoUpdated } from "./todo-bridge.js";
 export interface PiUsage {
     input?: number;
@@ -38,6 +39,7 @@ export declare function compactionMessages(s: ManagedSession, key: string, summa
 interface PiEventServices {
     readonly emit: (directory: string, event: OCEvent | TodoUpdated) => void;
     readonly subagents: SubagentBridge;
+    readonly monitors: MonitorSessions;
     readonly store: Pick<SessionStore, "update">;
     readonly dirtyDiffs: Set<string>;
     readonly ensureMessages: (s: ManagedSession) => OCMessageWithParts[];

package/dist/pi-event-translation.js

@@ -284,6 +284,9 @@ export class PiEventTranslator {
             case "compaction_end":
                 this.onCompactionEvent(s, ev);
                 break;
+            case "extension_event":
+                this.services.monitors.observe(s, ev);
+                break;
             default:
                 break; // turn_start, queue_update — future milestones
         }

package/dist/pi-rpc.js

@@ -93,6 +93,8 @@ export class PiRpcClient extends EventEmitter {
                 ...(process.env.SENPI_RPC_CLIENT_CAPABILITIES ?? "").split(","),
                 "auto_title_sessions",
                 "question",
+                // Extension `pi.rpc.emit` frames, e.g. the terminal extension's monitor state.
+                "extension_events",
             ]
                 .map((value) => value.trim())
                 .filter(Boolean)),

package/dist/routes-v1.js

@@ -3,6 +3,7 @@ import { execFile } from "node:child_process";
 import { homedir } from "node:os";
 import { errorBody, json } from "./http.js";
 import { miscRoute } from "./misc-routes.js";
+import { mcpRoute } from "./mcp.js";
 import { getAgentName } from "./agent-name.js";
 import { nativePromptInput, parsePromptParts } from "./prompt-parts.js";
 import { RequestBodyError } from "./http.js";
@@ -63,6 +64,11 @@ function parseV1Prompt(body, defaultModel) {
 export async function handleV1(services, req, res, url, path, method, directory) {
     if (await handleV1GlobalRoute(services, res, path, method))
         return;
+    const mcp = await mcpRoute(services, method, path, directory, () => services.body(req));
+    if (mcp !== undefined) {
+        json(res, mcp.status, mcp.body);
+        return;
+    }
     // --- sessions ---
     const misc = await miscRoute(method, path, url, directory);
     if (misc !== undefined) {
@@ -376,10 +382,6 @@ export async function handleV1(services, req, res, url, path, method, directory)
         json(res, 200, []);
         return;
     }
-    if (path === "/mcp" && method === "GET") {
-        json(res, 200, {});
-        return;
-    }
     if (path === "/command" && method === "GET") {
         json(res, 200, (await getCommands(directory)).map((command) => ({
             ...command,

package/dist/routes-v2.js

@@ -6,6 +6,7 @@ import { promisify } from "node:util";
 import { errorBody, json, RequestBodyError } from "./http.js";
 import { nativePromptInput, parsePromptParts, v2PromptAttachments, v2PromptParts } from "./prompt-parts.js";
 import { debugLog, miscRoute } from "./misc-routes.js";
+import { mcpRouteV2 } from "./mcp.js";
 import { OPENCODE_API_VERSION } from "./version.js";
 import { toV2Permission } from "./approvals.js";
 import { formQuestionAnswer, questionFormID, toQuestionForm } from "./question-forms.js";
@@ -192,8 +193,12 @@ export async function handleV2(services, req, res, url, path, method, directory)
         res.writeHead(204).end();
         return;
     }
-    if (path === "/api/integration" && method === "GET") {
-        json(res, 200, withLocation([]));
+    const mcp = await mcpRouteV2(services, method, path, directory, () => services.body(req));
+    if (mcp !== undefined) {
+        if (mcp.status === 204)
+            res.writeHead(204).end();
+        else
+            json(res, mcp.status, mcp.body);
         return;
     }
     const integrationMatch = path.match(/^\/api\/integration\/([^/]+)$/);
@@ -226,9 +231,10 @@ export async function handleV2(services, req, res, url, path, method, directory)
         });
         return;
     }
-    // Read-only inventories OpenChamber loads at bootstrap: OmO has no background shells,
-    // web-search providers or MCP servers, so each is an honest empty list (mutations stay 400).
-    if ((path === "/api/shell" || path === "/api/websearch/provider" || path === "/api/mcp") && method === "GET") {
+    // Read-only inventories OpenChamber loads at bootstrap. OmO has no OpenCode-style shells or
+    // web-search providers, so each is an honest empty list (mutations stay 400);
+    // OmO monitors appear as child sessions instead (monitor-sessions.ts).
+    if ((path === "/api/shell" || path === "/api/websearch/provider") && method === "GET") {
         json(res, 200, withLocation([]));
         return;
     }

package/dist/sessions.d.ts

@@ -9,6 +9,7 @@ import { ApprovalBridge, type PendingPermission, type PendingQuestion } from "./
 import type { TodoBridge, Todo, TodoUpdated } from "./todo-bridge.js";
 import { type SessionTreeState } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
+import { MonitorSessions } from "./monitor-sessions.js";
 import { SessionStore, type TitleSource } from "./session-store.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCModelRef, OCPart, OCPromptPart, OCSession, OCSessionStatus, OCToolPart } from "./types.js";
 export { ADAPTER_VERSION } from "./version.js";
@@ -65,6 +66,8 @@ export interface ManagedSession extends ThinkingState {
     /** Hooks wired by the approvals and child-task bridges. */
     hasPendingInteraction: () => boolean;
     hasRunningChildren: () => boolean;
+    /** Live OmO background work (monitors) that keeps the agent process from idle eviction. */
+    hasBackgroundWork?: () => boolean;
 }
 type EventSink = (directory: string, event: OCEvent | TodoUpdated) => void;
 export declare class SessionManager {
@@ -82,6 +85,7 @@ export declare class SessionManager {
     private readonly store;
     readonly lifecycle: SessionLifecycle;
     readonly subagents: SubagentBridge;
+    readonly monitors: MonitorSessions;
     /** directory → last scan freshness (pi dir mtime + wall clock). */
     private scanCache;
     /** freshness of the all-directories scan (see listAll). */
@@ -100,6 +104,8 @@ export declare class SessionManager {
     private wirePi;
     /** pi writes `<ts>_<sessionId>.jsonl` at startup — poll briefly for it. */
     private resolvePiFile;
+    /** Sessions with a running agent in `directory`, most recently used first; never revives a dormant one. */
+    liveSessions(directory: string): ManagedSession[];
     list(directory?: string): OCSession[];
     /**
      * Every restorable session on disk (all directories) plus live ones. Backs the

package/dist/sessions.js

@@ -16,6 +16,7 @@ import { getAgentName, getExposedAgentNames } from "./agent-name.js";
 import { RequestBodyError } from "./http.js";
 import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, readSessionTree, revertConversation, SessionTreeError, unrevertConversation, } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
+import { MonitorSessions } from "./monitor-sessions.js";
 import { sessionDiff } from "./session-diff.js";
 import { announceSessionNotice, slashTitlePrompt } from "./session-commands.js";
 import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionTitle, } from "./session-store.js";
@@ -40,6 +41,7 @@ export class SessionManager {
     store;
     lifecycle;
     subagents;
+    monitors;
     /** directory → last scan freshness (pi dir mtime + wall clock). */
     scanCache = new Map();
     /** freshness of the all-directories scan (see listAll). */
@@ -50,9 +52,11 @@ export class SessionManager {
         this.store = store ?? new SessionStore();
         this.lifecycle = new SessionLifecycle(() => this.sessions.values(), lifecycleOptions);
         this.subagents = new SubagentBridge(this.store, this.sessions, this.emit, (session, raw) => parsePiSessionText(session, getAgentName(), raw));
+        this.monitors = new MonitorSessions(this.sessions, this.emit);
         this.events = new PiEventTranslator({
             emit: this.emit,
             subagents: this.subagents,
+            monitors: this.monitors,
             store: this.store,
             dirtyDiffs: this.dirtyDiffs,
             ensureMessages: (s) => this.ensureMessages(s),
@@ -122,6 +126,7 @@ export class SessionManager {
             this.sessions.set(info.id, managed);
             published = true;
             this.subagents.wire(managed);
+            this.monitors.wire(managed);
             this.lifecycle.touch(managed);
             this.wirePi(managed, pi);
             if (options.model !== undefined)
@@ -236,6 +241,7 @@ export class SessionManager {
             });
             delete s.interruptRequested;
             this.subagents.stopParent(s.info.id);
+            this.monitors.stopParent(s.info.id);
             void this.lifecycle
                 .dormant(s)
                 .catch((error) => console.error("[lifecycle] exit cleanup failed:", error));
@@ -276,6 +282,14 @@ export class SessionManager {
         }
         return undefined;
     }
+    /** Sessions with a running agent in `directory`, most recently used first; never revives a dormant one. */
+    liveSessions(directory) {
+        if (this.disposed)
+            return [];
+        return [...this.sessions.values()]
+            .filter((s) => s.pi !== undefined && s.info.directory === directory)
+            .sort((a, b) => this.lifecycle.lastUsed(b) - this.lifecycle.lastUsed(a));
+    }
     list(directory) {
         this.refreshNativeTitles();
         this.subagents.restoreAll();
@@ -319,8 +333,9 @@ export class SessionManager {
         this.sessions.delete(sessionId);
         this.emit(s.info.directory, { type: "session.deleted", properties: { info: s.info } });
         await this.lifecycle.dormant(s);
-        const piPath = this.subagents.owns(sessionId) ? undefined : (s.piPath ?? s.restored?.piPath);
+        const piPath = this.subagents.owns(sessionId) || this.monitors.owns(sessionId) ? undefined : (s.piPath ?? s.restored?.piPath);
         this.subagents.remove(sessionId);
+        this.monitors.remove(sessionId);
         if (piPath !== undefined) {
             try {
                 unlinkSync(piPath);
@@ -1133,6 +1148,8 @@ export class SessionManager {
     ensureMessages(s) {
         if (this.subagents.owns(s.info.id))
             return this.subagents.messages(s.info.id);
+        if (this.monitors.owns(s.info.id))
+            return this.monitors.messages(s.info.id);
         if (s.messages === undefined) {
             const admissions = s.tree.localShellTurns?.length;
             s.messages = parsePiSessionFile(s, getAgentName());
@@ -1260,6 +1277,7 @@ export class SessionManager {
         if (reg?.connectorOwned === true)
             this.createdSessions.set(sc.piSessionId, sc.directory);
         this.subagents.wire(managed);
+        this.monitors.wire(managed);
         return managed;
     }
     /** Resolve a bare session id (e.g. deep link after restart) via known directories. */

package/dist/types.d.ts

@@ -265,6 +265,11 @@ export type OCEvent = {
 } | {
     type: "server.connected";
     properties: Record<string, unknown>;
+} | {
+    type: "mcp.tools.changed";
+    properties: {
+        server: string;
+    };
 } | {
     type: "session.created";
     properties: {

package/dist/v2.js

@@ -390,6 +390,8 @@ export class V2EventTranslator {
                         sessionID: ev.properties.sessionID,
                     }),
                 ];
+            case "mcp.tools.changed":
+                return [this.frame(directory, "mcp.status.changed", { server: ev.properties.server })];
             default:
                 return [];
         }

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",