antechamber 0.2.4 → 0.2.6

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.6",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",