antechamber 0.2.24 → 0.2.26

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.26] - 2026-10-17
+
+### Changed
+
+- Name a subagent card for an `agent()` call made inside eval after its agent type (for example "Explore Agent"),
+  and describe it with the call's label, the task's summary, or the first line of its prompt, instead of a bare "agent".
+- Show subagents an eval cell starts with `tool.task(...)` as subagent cards that open their session, live and after
+  reloading history, including ones started in the background.
+- Show an `agent()` call that OmO refused (for example one with no agent type) as a failed subagent card. OmO
+  records it as a success but starts no task.
+
+## [0.2.25] - 2026-10-17
+
+- feat(tools): show subagents and monitors started inside eval (#30)
+
 ## [0.2.24] - 2026-10-17
 
 ### Fixed
@@ -14,6 +29,11 @@ and this project uses [Semantic Versioning](https://semver.org/).
 - Show completed background bash output and detached eval results in OpenChamber, including after reloading history.
   A card that started background work keeps running until that work finishes.
 
+### Added
+
+- Show subagents and monitors started inside an eval cell as subagent cards that open their session, live and after
+  reloading history. A failed `agent()` call keeps its error.
+
 ## [0.2.23] - 2026-10-17
 
 - feat(monitors): show matched lines in monitor sessions (#32)

package/dist/monitor-sessions.d.ts

@@ -37,6 +37,12 @@ export declare class MonitorSessions {
     observe(parent: ManagedSession, ev: Record<string, unknown>): void;
     /** A hidden `senpi-monitor:notification` custom message: append its lines to each watch it names. */
     notify(parent: ManagedSession, message: Record<string, unknown>): void;
+    /**
+     * The child session of the newest watch a parent started with these monitor arguments.
+     * A monitor call recorded inside eval keeps only its arguments, not the `bash_N` id the
+     * child is keyed by, so command and description identify it.
+     */
+    findChild(parentID: string, args: Record<string, unknown>): string | undefined;
     /** 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. */

package/dist/monitor-sessions.js

@@ -120,6 +120,24 @@ export class MonitorSessions {
             this.publish(watch);
         }
     }
+    /**
+     * The child session of the newest watch a parent started with these monitor arguments.
+     * A monitor call recorded inside eval keeps only its arguments, not the `bash_N` id the
+     * child is keyed by, so command and description identify it.
+     */
+    findChild(parentID, args) {
+        let found;
+        for (const watch of this.watches.values()) {
+            const { monitor } = watch;
+            if (watch.session.info.parentID !== parentID || monitor.command !== args.command)
+                continue;
+            if (typeof args.description === "string" && monitor.description !== args.description)
+                continue;
+            if (found === undefined || monitor.startedAtMs > found.monitor.startedAtMs)
+                found = watch;
+        }
+        return found?.session.info.id;
+    }
     /** The agent process is gone: OmO's in-process watches died with it. */
     stopParent(parentID) {
         for (const watch of this.watches.values()) {

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

@@ -2,7 +2,7 @@
 import type { OCAssistantMessage, OCMessageWithParts, OCModelRef, OCEvent, OCSessionStatus, OCPart } from "./types.js";
 import type { ManagedSession } from "./sessions.js";
 import type { SessionStore } from "./session-store.js";
-import type { SubagentBridge } from "./subagents.js";
+import { type SubagentBridge } from "./subagents.js";
 import { type MonitorSessions } from "./monitor-sessions.js";
 import { type TodoUpdated } from "./todo-bridge.js";
 export interface PiUsage {
@@ -84,6 +84,7 @@ export declare class PiEventTranslator {
     private applyToolResults;
     /** The agent process is gone, and its background shells with it: end cards still waiting on them. */
     settleBackground(s: ManagedSession): void;
+    private onNestedTools;
     /** Complete an ended assistant message whose completion waited on its tools; true when it changed. */
     private completeSettled;
     /** Tool parts that never received a result (abort, crash) must not spin forever. */

package/dist/pi-event-translation.js

@@ -1,7 +1,8 @@
 /** Pi message/part translation and the live event bridge, with explicit manager services. */
 import { randomUUID } from "node:crypto";
+import { evalAgentSession } from "./subagents.js";
 import { MONITOR_NOTIFICATION } from "./monitor-sessions.js";
-import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts, resultText, toolFailed, } from "./tool-map.js";
+import { applyProviderToolResults, finishProviderToolParts, mapTool, nestedToolParts, providerToolParts, resultText, toolFailed, } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
 import { readSessionTree, recordTurn } from "./session-tree.js";
 import { touchedFiles } from "./session-diff.js";
@@ -476,6 +477,7 @@ export class PiEventTranslator {
                 if (output.trim() !== "")
                     part.state.metadata = { ...part.state.metadata, output };
                 this.emitPart(s, part);
+                this.onNestedTools(s, part, partial !== null && typeof partial === "object" && "details" in partial ? partial.details : undefined);
                 return;
             }
             case "tool_execution_end": {
@@ -752,8 +754,11 @@ export class PiEventTranslator {
             // Task expansion replaces the streaming placeholder with one or more
             // cards sharing its callID. Order those cards without reconstructing it.
             const indices = new Map([...streaming.parts].map(([index, part]) => [part.type === "tool" ? part.callID : part.id, index]));
-            owner.parts.sort((a, b) => (indices.get(a.type === "tool" ? a.callID : a.id) ?? Infinity) -
-                (indices.get(b.type === "tool" ? b.callID : b.id) ?? Infinity));
+            const order = (part) => {
+                const parent = part.type === "tool" && part.state.status !== "pending" ? part.state.metadata?.parentCallID : undefined;
+                return (indices.get(typeof parent === "string" ? parent : part.type === "tool" ? part.callID : part.id) ?? Infinity);
+            };
+            owner.parts.sort((a, b) => order(a) - order(b));
         }
     }
     /**
@@ -850,6 +855,12 @@ export class PiEventTranslator {
                 continue;
             }
             const part = callID !== undefined ? s.toolByCallId.get(callID) : undefined;
+            const parent = part ??
+                s.messages
+                    ?.flatMap((message) => message.parts)
+                    .find((item) => item.type === "tool" && item.callID === callID);
+            if (parent !== undefined)
+                this.onNestedTools(s, parent, tr.details);
             if (!part || callID === undefined)
                 continue;
             s.toolByCallId.delete(callID);
@@ -870,6 +881,24 @@ export class PiEventTranslator {
         for (const part of settleBackground(s.messages ?? [], Date.now()))
             this.emitPart(s, part);
     }
+    onNestedTools(s, parent, details) {
+        const nested = nestedToolParts(parent, details, {
+            monitor: (args) => this.services.monitors.findChild(s.info.id, args),
+            agent: (args, claimed, after) => evalAgentSession(s.piSessionId ?? s.restored?.piSessionId, args, claimed, after),
+        });
+        if (nested.length === 0)
+            return;
+        const owner = s.messages?.find((message) => message.info.id === parent.messageID);
+        if (owner === undefined)
+            return;
+        for (const [index, part] of nested.entries()) {
+            const existing = owner.parts.findIndex((item) => item.id === part.id);
+            if (existing >= 0)
+                owner.parts.splice(existing, 1);
+            owner.parts.splice(owner.parts.indexOf(parent) + 1 + index, 0, part);
+            this.emitPart(s, part);
+        }
+    }
     /** Complete an ended assistant message whose completion waited on its tools; true when it changed. */
     completeSettled(s, info) {
         if (!this.awaitingTools.has(info) || info.role !== "assistant" || hasActiveTools(s, info.id))

package/dist/session-history.js

@@ -1,11 +1,11 @@
 /** Reconstruct OpenCode history from pi JSONL session files. */
 import { readFileSync } from "node:fs";
-import { applyProviderToolResults, finishProviderToolParts, mapTool, providerToolParts } from "./tool-map.js";
+import { applyProviderToolResults, finishProviderToolParts, mapTool, nestedToolParts, providerToolParts, } from "./tool-map.js";
 import { TodoBridge } from "./todo-bridge.js";
 import { userMessageModel } from "./thinking-levels.js";
 import { contextMessageID } from "./prompt-parts.js";
 import { bindMessageEntries } from "./session-tree.js";
-import { taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
+import { evalAgentSession, taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
 import { shellTitle, shellUserMessage } from "./session-commands.js";
 import { compactionMessages, piModelId, piStopReason, textOf } from "./pi-event-translation.js";
 import { backgroundID, backgroundMessage, backgroundResult, completeBackgroundEval, finishToolPart, releaseBackground, settleBackground, } from "./background-results.js";
@@ -407,6 +407,18 @@ export function parsePiSessionText(s, agentName, raw) {
             }
             if (callID !== undefined)
                 finishToolPart(part, m, callID, created);
+            const nested = nestedToolParts(part, m.details, {
+                agent: (args, claimed, after) => evalAgentSession(s.piSessionId ?? s.restored?.piSessionId, args, claimed, after),
+            });
+            const owner = out.find((message) => message.info.id === part.messageID);
+            if (owner !== undefined) {
+                for (const card of nested) {
+                    const existing = owner.parts.findIndex((item) => item.id === card.id);
+                    if (existing >= 0)
+                        owner.parts.splice(existing, 1);
+                }
+                owner.parts.splice(owner.parts.indexOf(part) + 1, 0, ...nested);
+            }
         }
         // system / custom entries are not rendered
     }
@@ -475,8 +487,11 @@ export function parsePiSessionText(s, agentName, raw) {
                 sessionID,
                 messageID: message.info.id,
             }));
-        const identities = s.tree.messageParts?.[message.info.id];
-        for (const [index, part] of message.parts.entries()) {
+        const nestedIDs = new Set(message.parts.flatMap((part) => part.type === "tool" && part.state.status !== "pending" && part.state.metadata?.nested === true
+            ? [part.id]
+            : []));
+        const identities = s.tree.messageParts?.[message.info.id]?.filter((identity) => !nestedIDs.has(identity));
+        for (const [index, part] of message.parts.filter((part) => !nestedIDs.has(part.id)).entries()) {
             const identity = identities?.[index];
             if (identity !== undefined)
                 part.id = identity;

package/dist/subagents.d.ts

@@ -1,5 +1,5 @@
 import { type SessionStore } from "./session-store.js";
-import { type ToolResult } from "./tool-map.js";
+import { type EvalAgent, type ToolResult } from "./tool-map.js";
 import type { ManagedSession } from "./sessions.js";
 import type { OCEvent, OCMessageWithParts, OCToolPart } from "./types.js";
 export declare function stripTaskSuffix(text: string): string;
@@ -14,6 +14,13 @@ export declare function findTaskBySession(sessionId: string): {
     path: string;
     data: Record<string, unknown>;
 } | undefined;
+/**
+ * The session of a subagent an eval cell started with `agent()`. The recorded call keeps only its
+ * arguments, so the task record is found by parent, prompt and label: the oldest one created since
+ * the cell started and not yet claimed by an earlier call of the same cell. `null` means the parent
+ * was searched and no record matched; `undefined` means it could not be searched.
+ */
+export declare function evalAgentSession(parentPiId: string | undefined, args: Record<string, unknown>, claimed: Set<string>, after: number): EvalAgent | null | undefined;
 export declare function findTask(id: string, parentPiId: string): {
     path: string;
     data: Record<string, unknown>;

package/dist/subagents.js

@@ -193,6 +193,61 @@ export function findTaskBySession(sessionId) {
     }
     return undefined;
 }
+/**
+ * Whether a recorded argument names a task record's value. Codemode caps recorded strings at 512 code
+ * points and ends a cut one with "…" (call-capture.ts), and a schema agent() call sends its prompt with
+ * JSON instructions appended (agent-bridge.ts toTaskParams), so both match as prefixes.
+ */
+function recordedMatch(recorded, stored) {
+    if (typeof stored !== "string")
+        return false;
+    if (stored === recorded)
+        return true;
+    return recorded.endsWith("…") ? stored.startsWith(recorded.slice(0, -1)) : stored.startsWith(`${recorded}\n\n`);
+}
+/**
+ * The session of a subagent an eval cell started with `agent()`. The recorded call keeps only its
+ * arguments, so the task record is found by parent, prompt and label: the oldest one created since
+ * the cell started and not yet claimed by an earlier call of the same cell. `null` means the parent
+ * was searched and no record matched; `undefined` means it could not be searched.
+ */
+export function evalAgentSession(parentPiId, args, claimed, after) {
+    if (parentPiId === undefined || typeof args.prompt !== "string")
+        return undefined;
+    let best;
+    for (const { id, path } of taskFiles()) {
+        if (claimed.has(id))
+            continue;
+        const data = childRecord(id, path);
+        if (data?.parent_session_id !== parentPiId)
+            continue;
+        const spec = record(data.spawn_spec) ? data.spawn_spec : {};
+        if (!recordedMatch(args.prompt, spec.prompt))
+            continue;
+        if (typeof args.label === "string" && !recordedMatch(args.label, data.name))
+            continue;
+        const created = typeof data.created_at === "string" ? Date.parse(data.created_at) : Number.NaN;
+        // The cell's start is taken when its card opens, a moment after OmO starts it.
+        if (!Number.isFinite(created) || created < after - 5_000)
+            continue;
+        if (best === undefined || created < best.created)
+            best = { id, created, data };
+    }
+    if (best === undefined)
+        return null;
+    claimed.add(best.id);
+    const text = (value) => (typeof value === "string" && value !== "" ? value : undefined);
+    // OmO names an unlabelled task after its id, which says nothing.
+    const name = text(best.data.name);
+    const summary = text(best.data.task_summary);
+    const agentType = text(best.data.agent_type);
+    return {
+        sessionID: ocIdFor(best.id),
+        ...(name !== undefined && name !== best.id ? { name } : {}),
+        ...(summary !== undefined ? { summary } : {}),
+        ...(agentType !== undefined ? { agentType } : {}),
+    };
+}
 export function findTask(id, parentPiId) {
     if (!taskId(id))
         return undefined;

package/dist/tool-map.d.ts

@@ -25,6 +25,28 @@ export declare function resultText(content: unknown): string;
 /** Only edit cards need patch metadata; write cards already preview input.content. */
 export declare function resultMetadata(tool: string, result: ToolResult): Record<string, unknown>;
 export declare function mapTool(omoName: string, args: unknown, result?: ToolResult): MappedTool;
+/**
+ * What an eval cell started that has a session of its own. Its other calls are not shown:
+ * the cell's output already holds what it printed, and OmO records only a one-line preview.
+ */
+export interface NestedSessions {
+    /** The monitor child session for a recorded `monitor` call. */
+    monitor?: (args: Record<string, unknown>) => string | undefined;
+    /** The subagent a recorded `agent()` call started; `claimed` keeps repeated calls apart. */
+    agent?: (args: Record<string, unknown>, claimed: Set<string>, after: number) => EvalAgent | null | undefined;
+}
+/** The task record behind an `agent()` call made inside eval. */
+export interface EvalAgent {
+    sessionID: string;
+    name?: string;
+    summary?: string;
+    agentType?: string;
+}
+/**
+ * Finished eval calls, from the raw RPC capture of installed omo-ai 5.1.33 / senpi runtime, 2026-10-17.
+ * Monitors and `agent()` calls (recorded as `__agent__`) become subagent cards; everything else is skipped.
+ */
+export declare function nestedToolParts(parent: OCToolPart, details: unknown, sessions?: NestedSessions): OCToolPart[];
 /** One card at each call's original block index; result blocks are not cards.
  * Shared by RPC snapshots and history so ids and renderer state survive reloads.
  */

package/dist/tool-map.js

@@ -1,3 +1,4 @@
+import { ocIdFor } from "./session-store.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -134,6 +135,139 @@ export function mapTool(omoName, args, result) {
         ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
     };
 }
+/** "Explore Agent" for an agent type or category, "Subagent" when there is none. */
+function agentTitle(type) {
+    return type === "subagent" ? "Subagent" : `${type.charAt(0).toUpperCase()}${type.slice(1)} Agent`;
+}
+/**
+ * The task id OmO puts in a `task` result: "[task_id: st_x - " when it waited, "(st_x, running" in the
+ * background. The preview is capped at 160 code points, so only an id followed by its delimiter is whole.
+ */
+const TASK_ID = /\[task_id: (st_[A-Za-z0-9_-]+) - |\((st_[A-Za-z0-9_-]+), running\b/;
+/** The prompt's first line, cut at a word boundary near 60 characters. */
+function shortPrompt(prompt) {
+    const line = prompt
+        .split("\n")
+        .find((text) => text.trim() !== "")
+        ?.trim();
+    if (line === undefined || line.length <= 60)
+        return line;
+    const cut = line.slice(0, 60);
+    const space = cut.lastIndexOf(" ");
+    return `${(space > 30 ? cut.slice(0, space) : cut).trimEnd()}…`;
+}
+/**
+ * A subagent-style card, as OpenChamber draws `task`: it opens `sessionID` when there is one.
+ * `agentTitle`/`agentSubtitle` feed the OmO Compatibility extension's `task` header rule.
+ */
+function nestedSubagent(heading, input, sessionID) {
+    return {
+        tool: "task",
+        input: { description: input.description, prompt: input.prompt, subagent_type: input.type },
+        title: input.description.slice(0, 60),
+        metadata: {
+            agentTitle: heading.title,
+            agentSubtitle: heading.subtitle,
+            ...(sessionID !== undefined ? { sessionID } : {}),
+        },
+    };
+}
+/**
+ * Finished eval calls, from the raw RPC capture of installed omo-ai 5.1.33 / senpi runtime, 2026-10-17.
+ * Monitors and `agent()` calls (recorded as `__agent__`) become subagent cards; everything else is skipped.
+ */
+export function nestedToolParts(parent, details, sessions = {}) {
+    if (!record(details) || !Array.isArray(details.toolCalls))
+        return [];
+    const parts = [];
+    const start = parent.state.status === "pending" ? 0 : parent.state.time.start;
+    const claimed = new Set();
+    details.toolCalls.forEach((entry, index) => {
+        let failure;
+        if (!record(entry) ||
+            (entry.name !== "monitor" && entry.name !== "__agent__" && entry.name !== "task") ||
+            typeof entry.ok !== "boolean" ||
+            typeof entry.durationMs !== "number" ||
+            !Number.isFinite(entry.durationMs) ||
+            entry.durationMs < 0)
+            return;
+        const args = record(entry.args) ? entry.args : {};
+        let mapped;
+        if (entry.name === "monitor") {
+            const sessionID = entry.ok ? sessions.monitor?.(args) : undefined;
+            if (sessionID === undefined)
+                return; // nothing to open; the cell's code already shows the call
+            const command = typeof args.command === "string" ? args.command : "";
+            const label = typeof args.description === "string" && args.description !== "" ? args.description : command;
+            mapped = nestedSubagent({ title: "Monitor", subtitle: label }, { description: `Monitor: ${label}`, prompt: command, type: "monitor" }, sessionID);
+        }
+        else if (entry.name === "task") {
+            const text = (value) => (typeof value === "string" && value !== "" ? value : undefined);
+            const prompt = text(args.prompt) ?? "";
+            const match = typeof entry.resultPreview === "string" ? TASK_ID.exec(entry.resultPreview) : null;
+            const taskID = match?.[1] ?? match?.[2];
+            if (taskID !== undefined)
+                claimed.add(taskID);
+            // A long reply pushes the id out of the preview; the task record still names the session.
+            const sessionID = !entry.ok
+                ? undefined
+                : taskID !== undefined
+                    ? ocIdFor(taskID)
+                    : (sessions.agent?.({ prompt, ...(text(args.name) ? { label: args.name } : {}) }, claimed, start) ??
+                        undefined)?.sessionID;
+            const description = text(args.task_summary) ?? text(args.description) ?? shortPrompt(prompt) ?? "subagent";
+            const type = text(args.subagent_type) ?? text(args.category) ?? "subagent";
+            mapped = nestedSubagent({ title: agentTitle(type), subtitle: description }, { description, prompt, type }, sessionID);
+        }
+        else {
+            const prompt = typeof args.prompt === "string" ? args.prompt : "";
+            const found = entry.ok ? sessions.agent?.(args, claimed, start) : undefined;
+            const text = (value) => (typeof value === "string" && value !== "" ? value : undefined);
+            const description = text(args.label) ??
+                text(args.description) ??
+                found?.summary ??
+                found?.name ??
+                shortPrompt(prompt) ??
+                "subagent";
+            const type = text(args.agent) ?? found?.agentType ?? "subagent";
+            mapped = nestedSubagent({
+                title: agentTitle(type),
+                subtitle: description,
+            }, { description, prompt, type }, found?.sessionID);
+            // OmO writes the task record before agent() returns, but records a refused spawn as ok with no record.
+            if (entry.ok && found === null)
+                failure = "OmO started no subagent for this call (agent() needs an agent type or a category)";
+        }
+        const key = typeof entry.callId === "string" ? `id:${encodeURIComponent(entry.callId)}` : `index:${index}`;
+        const callID = `${encodeURIComponent(parent.callID)}:${key}`;
+        const state = {
+            input: mapped.input,
+            title: mapped.title,
+            output: "",
+            metadata: { ...mapped.metadata, nested: true, parentCallID: parent.callID, durationMs: entry.durationMs },
+            time: { start, end: start + entry.durationMs },
+        };
+        const failed = !entry.ok || failure !== undefined;
+        parts.push({
+            id: `prt_${parent.sessionID}_nested_${callID}`,
+            sessionID: parent.sessionID,
+            messageID: parent.messageID,
+            type: "tool",
+            callID: `nested:${callID}`,
+            // OpenChamber 1.24 never styles a task card as failed or shows its error (ToolPart.tsx isTaskTool),
+            // and a failed spawn has no session to open, so it goes out as a plain card that does both.
+            tool: failed && mapped.tool === "task" ? "agent" : mapped.tool,
+            state: !failed
+                ? { ...state, status: "completed" }
+                : {
+                    ...state,
+                    status: "error",
+                    error: failure ?? (typeof entry.error === "string" && entry.error !== "" ? entry.error : "failed"),
+                },
+        });
+    });
+    return parts;
+}
 /** JSON first, then the literal-only Python repr used by older session files.
  * Never execute provider content; invalid or incomplete literals are skipped.
  */

package/extensions/omo-compat/README.md

@@ -6,6 +6,10 @@ extension declare. It has no panel, page, service or permissions.
 
 What it does today:
 
+- **Subagent card headers.** A subagent an eval cell started with `agent()` is shown as a `task` card. Its header
+  reads the agent type and a short description (the call's label, the task's summary, or the prompt's first line)
+  instead of the generic "Agent Task".
+
 - **Eval cell headers.** OpenChamber 1.24 streams live output only for shell
   cards, so antechamber shows OmO eval cells as shell cards. With this extension
   their header reads `JS Eval` (or `Python Eval`) and the cell's summary instead

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",
@@ -21,6 +21,16 @@
           "match": "bash",
           "title": "{metadata.evalTitle}",
           "subtitle": "{metadata.evalSubtitle}"
+        },
+        {
+          "match": "task",
+          "title": "{metadata.agentTitle}",
+          "subtitle": "{metadata.agentSubtitle}"
+        },
+        {
+          "match": "agent",
+          "title": "{metadata.agentTitle}",
+          "subtitle": "{metadata.agentSubtitle}"
         }
       ]
     }

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "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.24",
+  "version": "0.2.26",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",