antechamber 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-10-14
+
+### Added
+
+- Sessions now report `cost` (USD) from OmO's per-message usage, live and from
+  history, on v1 session payloads and v2 session reads. Subagent sessions carry
+  their own cost, so OpenChamber's work-status panel shows the session total
+  with its session/subagents breakdown.
+
+### Fixed
+
+- `/compact` now shows progress and its result. The session turns busy while
+  OmO compacts, and the summary appears as a `/compact` turn with a summary
+  reply, live and after reload. The compact RPC now waits up to OmO's own
+  30-minute compaction budget instead of giving up after 60 seconds, which left
+  the compaction running unseen until a later abort reported it cancelled.
+- Reverting no longer adds a "Conversation reverted. Files were not changed."
+  card to the transcript; OpenChamber's own reverted-message dock (driven by
+  `session.revert`) already shows the state.
+- Sessions opened with a slash command (for example `/skill:plan Build the
+  importer`) now get a generated title. OmO skips titling slash-led prompts, so
+  the adapter passes the command's arguments as the native `sessionTitlePrompt`.
+
 ## [0.1.0] - 2026-10-14
 
 First standalone release under the `antechamber` name.

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

@@ -1,5 +1,5 @@
 /** Pi message/part translation and the live event bridge, with explicit manager services. */
-import type { OCAssistantMessage, OCMessageWithParts, OCEvent, OCSessionStatus, OCPart } from "./types.js";
+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";
@@ -24,6 +24,20 @@ export declare function piStopReason(stopReason: string | undefined, errorMessag
 export declare function textOf(content: Array<Record<string, unknown>> | undefined): string;
 export declare function newPart(kind: "text" | "reasoning", sessionID: string, messageID: string): OCPart;
 export declare function applyUsage(msg: OCAssistantMessage, usage: PiUsage | undefined): void;
+/**
+ * Recompute the session's own spend from its loaded assistant messages. Subagent
+ * spend stays on the child sessions: OpenChamber sums the parentID subtree, so
+ * folding it in here would count it twice. Returns whether the value changed.
+ */
+export declare function syncSessionCost(s: ManagedSession): boolean;
+/**
+ * An OmO compaction as OpenCode shows one: a user turn holding a `compaction`
+ * part (OpenChamber renders it as `/compact`) answered by a `summary` message.
+ * IDs derive from the compaction's first kept entry, which the live
+ * `compaction_end` result and the persisted entry share, so a history reload
+ * reconciles with the live messages instead of duplicating them.
+ */
+export declare function compactionMessages(s: ManagedSession, key: string, summary: string, created: number, model: OCModelRef | undefined): [OCMessageWithParts, OCMessageWithParts];
 interface PiEventServices {
     readonly emit: (directory: string, event: OCEvent | TodoUpdated) => void;
     readonly subagents: SubagentBridge;

package/dist/pi-event-translation.js

@@ -66,6 +66,69 @@ export function applyUsage(msg, usage) {
     if (usage.cost?.total !== undefined)
         msg.cost = usage.cost.total;
 }
+/**
+ * Recompute the session's own spend from its loaded assistant messages. Subagent
+ * spend stays on the child sessions: OpenChamber sums the parentID subtree, so
+ * folding it in here would count it twice. Returns whether the value changed.
+ */
+export function syncSessionCost(s) {
+    if (s.messages === undefined)
+        return false;
+    let cost = 0;
+    for (const message of s.messages)
+        if (message.info.role === "assistant")
+            cost += message.info.cost;
+    if ((s.info.cost ?? 0) === cost)
+        return false; // absent means zero; avoid no-op updates
+    s.info.cost = cost;
+    return true;
+}
+/**
+ * An OmO compaction as OpenCode shows one: a user turn holding a `compaction`
+ * part (OpenChamber renders it as `/compact`) answered by a `summary` message.
+ * IDs derive from the compaction's first kept entry, which the live
+ * `compaction_end` result and the persisted entry share, so a history reload
+ * reconciles with the live messages instead of duplicating them.
+ */
+export function compactionMessages(s, key, summary, created, model) {
+    const sessionID = s.info.id;
+    const userID = `msg_compaction_${key}`;
+    const summaryID = `${userID}_summary`;
+    const served = model ?? { providerID: "unknown", modelID: "unknown" };
+    return [
+        {
+            info: { id: userID, sessionID, role: "user", time: { created }, agent: getAgentName(), model: served },
+            parts: [{ id: `prt_compaction_${key}`, sessionID, messageID: userID, type: "compaction", auto: false }],
+        },
+        {
+            info: {
+                id: summaryID,
+                sessionID,
+                role: "assistant",
+                time: { created, completed: created },
+                parentID: userID,
+                modelID: served.modelID,
+                providerID: served.providerID,
+                mode: getAgentName(),
+                path: { cwd: s.info.directory, root: s.info.directory },
+                cost: 0,
+                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+                finish: "stop",
+                summary: true,
+            },
+            parts: [
+                {
+                    id: `prt_compaction_${key}_summary`,
+                    sessionID,
+                    messageID: summaryID,
+                    type: "text",
+                    text: summary,
+                    time: { start: created, end: created },
+                },
+            ],
+        },
+    ];
+}
 /** Translates per-session events; registry and lifecycle operations stay with SessionManager. */
 export class PiEventTranslator {
     services;
@@ -289,6 +352,8 @@ export class PiEventTranslator {
                     s.streaming.message.time.completed = Date.now();
                     this.services.emit(dir, { type: "message.updated", properties: { info: s.streaming.message } });
                     this.finishStreaming(s);
+                    if (syncSessionCost(s))
+                        this.services.emit(dir, { type: "session.updated", properties: { info: s.info } });
                 }
                 break;
             }
@@ -309,8 +374,41 @@ export class PiEventTranslator {
                     },
                 });
                 break;
+            case "compaction_start": {
+                s.info.time.compacting = Date.now();
+                this.services.emit(dir, { type: "session.updated", properties: { info: s.info } });
+                // A manual /compact runs no agent turn, so nothing else marks the session busy.
+                if (s.status.type === "idle") {
+                    s.compactingFromIdle = true;
+                    this.setStatus(s, { type: "busy" });
+                }
+                break;
+            }
+            case "compaction_end": {
+                delete s.info.time.compacting;
+                const result = ev.result;
+                if (ev.aborted !== true && typeof result?.summary === "string" && typeof result.firstKeptEntryId === "string") {
+                    const messages = this.services.ensureMessages(s);
+                    for (const message of compactionMessages(s, result.firstKeptEntryId, result.summary, Date.now(), s.model)) {
+                        if (messages.some((item) => item.info.id === message.info.id))
+                            continue;
+                        // Keep a hidden redo branch after the new turn, as appendMessage does.
+                        const boundary = messages.findIndex((item) => item.info.id === s.tree.revert?.messageID);
+                        messages.splice(boundary < 0 ? messages.length : boundary, 0, message);
+                        this.services.emit(dir, { type: "message.updated", properties: { info: message.info } });
+                        for (const part of message.parts)
+                            this.emitPart(s, part);
+                    }
+                }
+                this.services.emit(dir, { type: "session.updated", properties: { info: s.info } });
+                if (s.compactingFromIdle) {
+                    delete s.compactingFromIdle;
+                    this.setStatus(s, { type: "idle" });
+                }
+                break;
+            }
             default:
-                break; // turn_start, queue_update, compaction_* — future milestones
+                break; // turn_start, queue_update — future milestones
         }
     }
     finishStreaming(s) {

package/dist/pi-rpc.d.ts

@@ -15,6 +15,12 @@ export interface PiRpcCommand {
     [key: string]: unknown;
 }
 export declare const RPC_COMMAND_TIMEOUT_MS = 60000;
+/**
+ * `compact` answers only when the summary is written. OmO bounds one compaction by
+ * its SUMMARIZATION_MAX_DURATION_CAP_MS (30 min); the generic 60 s budget gave up
+ * long before a large session finished, leaving the run orphaned.
+ */
+export declare const COMPACT_RPC_TIMEOUT_MS: number;
 export declare const MAX_JSONL_FRAME_BYTES: number;
 export type PiRpcResponse<T = unknown> = {
     readonly id: string;

package/dist/pi-rpc.js

@@ -14,6 +14,12 @@ import { randomUUID } from "node:crypto";
 import { systemClock } from "./lifecycle.js";
 import { agentBinary, envSetting } from "./config.js";
 export const RPC_COMMAND_TIMEOUT_MS = 60_000;
+/**
+ * `compact` answers only when the summary is written. OmO bounds one compaction by
+ * its SUMMARIZATION_MAX_DURATION_CAP_MS (30 min); the generic 60 s budget gave up
+ * long before a large session finished, leaving the run orphaned.
+ */
+export const COMPACT_RPC_TIMEOUT_MS = 31 * 60_000;
 export const MAX_JSONL_FRAME_BYTES = 64 * 1024 * 1024;
 const PROCESS_KILL_GRACE_MS = 5_000;
 export class PiRpcClient extends EventEmitter {

package/dist/session-commands.d.ts

@@ -61,6 +61,14 @@ export declare const unsupportedShare: {
 export declare function shellTitle(command: string): string;
 export declare function getCommands(directory: string): Promise<CommandDescriptor[]>;
 export declare function parseSlashCommand(value: unknown): SlashCommandInput | undefined;
+/**
+ * OmO never auto-titles a first prompt that starts with "/", so a session opened
+ * with `/skill:plan Build the importer` kept its first-message title. Title from
+ * the command's arguments instead; a bare command has nothing to title from.
+ */
+export declare function slashTitlePrompt(text: string): {
+    sessionTitlePrompt?: string;
+};
 export declare function slashCommandPrompt(input: SlashCommandInput): string;
 export declare function runSlashCommand(sessions: SessionManager, sessionId: string, input: SlashCommandInput): Promise<OCMessageWithParts | undefined>;
 export declare function parseShellCommand(value: unknown): string | undefined;

package/dist/session-commands.js

@@ -114,6 +114,15 @@ export function parseSlashCommand(value) {
     const messageID = typeof value.messageID === "string" && value.messageID !== "" ? value.messageID : undefined;
     return { command: value.command, arguments: value.arguments, ...(messageID ? { messageID } : {}) };
 }
+/**
+ * OmO never auto-titles a first prompt that starts with "/", so a session opened
+ * with `/skill:plan Build the importer` kept its first-message title. Title from
+ * the command's arguments instead; a bare command has nothing to title from.
+ */
+export function slashTitlePrompt(text) {
+    const match = /^\s*\/\S+\s+([\s\S]*\S)/.exec(text);
+    return match?.[1] !== undefined && !match[1].startsWith("/") ? { sessionTitlePrompt: match[1] } : {};
+}
 export function slashCommandPrompt(input) {
     return input.arguments === "" ? `/${input.command}` : `/${input.command} ${input.arguments}`;
 }

package/dist/session-history.js

@@ -5,7 +5,7 @@ import { TodoBridge } from "./todo-bridge.js";
 import { bindMessageEntries } from "./session-tree.js";
 import { taskParts, updateTaskParts, taskCompletions } from "./subagents.js";
 import { shellTitle, shellUserMessage } from "./session-commands.js";
-import { piModelId, piStopReason, textOf } from "./pi-event-translation.js";
+import { compactionMessages, piModelId, piStopReason, textOf } from "./pi-event-translation.js";
 function entryTime(e) {
     if (typeof e.timestamp === "number")
         return e.timestamp;
@@ -131,6 +131,11 @@ export function parsePiSessionText(s, agentName, raw) {
             currentModel = { providerID: e.provider, modelID: e.modelId };
             continue;
         }
+        if (e.type === "compaction" && typeof e.summary === "string" && typeof e.firstKeptEntryId === "string") {
+            // Not a run boundary: an automatic compaction can sit between steps of one turn.
+            out.push(...compactionMessages(s, e.firstKeptEntryId, e.summary, entryTime(e), currentModel));
+            continue;
+        }
         if (e.type !== "message")
             continue;
         const m = e.message;

package/dist/session-tree.d.ts

@@ -56,4 +56,3 @@ export declare function forkConversation(s: ManagedSession, pi: PiRpcClient, tre
 export declare function revertConversation(s: ManagedSession, pi: PiRpcClient, tree: Entries, messageID: string): Promise<boolean>;
 export declare function unrevertConversation(s: ManagedSession, pi: PiRpcClient): Promise<boolean>;
 export declare function navigate(pi: PiRpcClient, targetId: string | null, signal?: AbortSignal): Promise<string | null>;
-export declare function revertNotice(s: ManagedSession): OCMessageWithParts | undefined;

package/dist/session-tree.js

@@ -285,40 +285,3 @@ export async function navigate(pi, targetId, signal) {
         throw new SessionTreeError("Conversation navigation was cancelled");
     return response.data.leafId;
 }
-export function revertNotice(s) {
-    const revert = s.tree.revert;
-    if (!revert)
-        return undefined;
-    const boundary = s.messages?.find((message) => message.info.id === revert.messageID);
-    const boundaryIndex = s.messages?.findIndex((message) => message.info.id === revert.messageID) ?? 0;
-    const parent = s.messages
-        ?.slice(0, boundaryIndex)
-        .reverse()
-        .find((message) => message.info.role === "user");
-    const messageID = `msg_revert_${revert.messageID}`;
-    const created = (boundary?.info.time.created ?? s.info.time.updated) - 1;
-    return {
-        info: {
-            id: messageID,
-            sessionID: s.info.id,
-            role: "assistant",
-            time: { created, completed: created },
-            parentID: parent?.info.id ?? "",
-            modelID: s.model?.modelID ?? "unknown",
-            providerID: s.model?.providerID ?? "unknown",
-            mode: "info",
-            path: { cwd: s.info.directory, root: s.info.directory },
-            cost: 0,
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        },
-        parts: [
-            {
-                id: `prt_revert_${revert.messageID}`,
-                sessionID: s.info.id,
-                messageID,
-                type: "text",
-                text: "Conversation reverted. Files were not changed.",
-            },
-        ],
-    };
-}

package/dist/sessions.d.ts

@@ -40,6 +40,8 @@ export interface ManagedSession extends ThinkingState {
     /** undefined while dormant; resolved via get_state on create/revive. */
     model: OCModelRef | undefined;
     streaming: StreamingState | undefined;
+    /** A manual compaction started while idle; its end returns the session to idle. */
+    compactingFromIdle?: boolean;
     /** Cancels the adapter-owned user bash waiter and its OmO execution. */
     cancelShell?: (interrupted?: boolean) => void;
     /**
@@ -119,7 +121,6 @@ export declare class SessionManager {
     fork(sessionId: string, messageID?: string): Promise<OCSession>;
     revert(sessionId: string, messageID: string): Promise<OCSession>;
     unrevert(sessionId: string): Promise<OCSession>;
-    private removeRevertNotice;
     reloadMessages(sessionId: string, signal?: AbortSignal): Promise<OCMessageWithParts[] | undefined>;
     /** Called only within the conversation operation queue, including RPC refreshes. */
     private reloadMessagesLive;

package/dist/sessions.js

@@ -2,20 +2,20 @@
  * Session registry: one OpenCode session maps to one `pi --mode rpc` process.
  * Composes the live event bridge and restored-session history reconstruction.
  */
-import { id, PiEventTranslator } from "./pi-event-translation.js";
+import { id, PiEventTranslator, syncSessionCost } from "./pi-event-translation.js";
 import { parsePiSessionFile, parsePiSessionText } from "./session-history.js";
 import { existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { PiRpcClient, RPC_COMMAND_TIMEOUT_MS } from "./pi-rpc.js";
+import { COMPACT_RPC_TIMEOUT_MS, PiRpcClient, RPC_COMMAND_TIMEOUT_MS, } from "./pi-rpc.js";
 import { stopSessionHosts } from "./session-hosts.js";
 import { setThinkingLevel } from "./thinking-levels.js";
 import { SessionLifecycle } from "./lifecycle.js";
 import { ApprovalBridge, extensionUiRequestFrom } from "./approvals.js";
 import { getAgentName } from "./agent-name.js";
-import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, readSessionTree, revertConversation, revertNotice, SessionTreeError, unrevertConversation, } from "./session-tree.js";
+import { bindMessageEntries, durableShellTree, forkConversation, getEntries, navigate, readSessionTree, revertConversation, SessionTreeError, unrevertConversation, } from "./session-tree.js";
 import { SubagentBridge } from "./subagents.js";
 import { sessionDiff } from "./session-diff.js";
-import { announceSessionNotice } from "./session-commands.js";
+import { announceSessionNotice, slashTitlePrompt } from "./session-commands.js";
 import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionPersistenceError, SessionStore, readSessionTitle, } from "./session-store.js";
 import { ADAPTER_VERSION } from "./version.js";
 export { ADAPTER_VERSION } from "./version.js";
@@ -324,11 +324,7 @@ export class SessionManager {
                 properties: { sessionID: s.info.id, todos: s.todoBridge.todos },
             });
         }
-        const notice = revertNotice(s);
-        if (!notice)
-            return messages;
-        const boundary = messages.findIndex((message) => message.info.id === s.tree.revert?.messageID);
-        return [...messages.slice(0, boundary), notice, ...messages.slice(boundary)];
+        return messages;
     }
     /** Append to canonical history, before the hidden redo branch while reverted. */
     appendMessage(sessionId, message) {
@@ -440,40 +436,24 @@ export class SessionManager {
     async revert(sessionId, messageID) {
         return this.treeSession(sessionId, async (s, pi) => {
             const tree = await this.syncTree(s, true);
-            const previousNotice = revertNotice(s);
+            // OpenChamber renders its own reverted-message dock from session.revert.
             if (!(await revertConversation(s, pi, tree, messageID)))
                 return s.info;
-            this.removeRevertNotice(s, previousNotice);
             this.persistMeta(s);
             this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
-            const notice = revertNotice(s);
-            if (notice) {
-                this.emit(s.info.directory, { type: "message.updated", properties: { info: notice.info } });
-                for (const part of notice.parts)
-                    this.events.emitPart(s, part);
-            }
             return s.info;
         });
     }
     async unrevert(sessionId) {
         return this.treeSession(sessionId, async (s, pi) => {
             await this.syncTree(s, true);
-            const previousNotice = revertNotice(s);
             if (!(await unrevertConversation(s, pi)))
                 return s.info;
-            this.removeRevertNotice(s, previousNotice);
             this.persistMeta(s);
             this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
             return s.info;
         });
     }
-    removeRevertNotice(s, notice) {
-        if (notice)
-            this.emit(s.info.directory, {
-                type: "message.removed",
-                properties: { sessionID: s.info.id, messageID: notice.info.id },
-            });
-    }
     async reloadMessages(sessionId, signal) {
         const s = this.get(sessionId);
         if (!s)
@@ -620,7 +600,8 @@ export class SessionManager {
             if (pi === undefined)
                 throw new Error(`session cannot be resumed: ${sessionId}`);
             this.lifecycle.touch(s);
-            const response = await pi.command(command, RPC_COMMAND_TIMEOUT_MS, signal, onDispatch);
+            const timeout = command.type === "compact" ? COMPACT_RPC_TIMEOUT_MS : RPC_COMMAND_TIMEOUT_MS;
+            const response = await pi.command(command, timeout, signal, onDispatch);
             if (!signal?.aborted && response.success && (command.type === "compact" || command.type === "bash"))
                 await this.reloadMessagesLive(s, signal);
             return response;
@@ -744,7 +725,6 @@ export class SessionManager {
                     });
                 }
             }
-            this.removeRevertNotice(s, revertNotice(s));
             delete s.tree.revert;
             delete s.info.revert;
             bindMessageEntries(s, await getEntries(pi));
@@ -829,6 +809,7 @@ export class SessionManager {
             message: text,
             streamingBehavior: delivery === "queue" ? "followUp" : "steer",
             clientMessageId: userMsg.id,
+            ...slashTitlePrompt(text),
         })
             .catch((error) => {
             rejectInput();
@@ -969,6 +950,8 @@ export class SessionManager {
             this.subagents.discover(s, s.messages);
             if (admissions)
                 this.persistMeta(s);
+            if (syncSessionCost(s))
+                this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
         }
         return s.messages;
     }

package/dist/subagents.js

@@ -2,6 +2,7 @@
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, watch, writeFileSync, } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { piAgentDir } from "./agent-dir.js";
+import { syncSessionCost } from "./pi-event-translation.js";
 import { ocIdFor, SessionPersistenceError } from "./session-store.js";
 import { mapTool, resultText, toolMappers } from "./tool-map.js";
 import { ADAPTER_VERSION } from "./version.js";
@@ -457,6 +458,9 @@ export class SubagentBridge {
             child.session.messages = this.fallback(child);
         }
         child.loaded = true;
+        // Each child reports only its own spend; OpenChamber sums the subtree by parentID.
+        if (syncSessionCost(child.session))
+            this.emit(child.session.info.directory, { type: "session.updated", properties: { info: child.session.info } });
         child.session.status = { type: running ? "busy" : "idle" };
         if (!running)
             this.closeWatchers(child);

package/dist/types.d.ts

@@ -17,6 +17,8 @@ export interface OCSession {
     revert?: {
         messageID: string;
     };
+    /** USD spent by this session's own assistant messages; OpenChamber adds child sessions via parentID. */
+    cost?: number;
     time: {
         created: number;
         updated: number;
@@ -68,6 +70,8 @@ export interface OCAssistantMessage {
             message: string;
         };
     };
+    /** Marks a compaction summary (OpenCode `AssistantMessage.summary`). */
+    summary?: boolean;
 }
 export type OCMessage = OCUserMessage | OCAssistantMessage;
 export interface OCTextPart {
@@ -144,7 +148,15 @@ export interface OCToolPart {
     tool: string;
     state: OCToolState;
 }
-export type OCPart = OCTextPart | OCReasoningPart | OCToolPart;
+/** OpenChamber renders a user message holding this part as `/compact`. */
+export interface OCCompactionPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "compaction";
+    auto: boolean;
+}
+export type OCPart = OCTextPart | OCReasoningPart | OCToolPart | OCCompactionPart;
 export interface OCMessageWithParts {
     info: OCMessage;
     parts: OCPart[];

package/dist/v2.js

@@ -89,7 +89,7 @@ export function toV2Session(info, opts = {}) {
         id: info.id,
         projectID: info.projectID,
         agent: opts.agent ?? getAgentName(),
-        cost: 0,
+        cost: info.cost ?? 0,
         tokens: zeroTokens(),
         time: {
             created: info.time.created,
@@ -109,10 +109,7 @@ export function toV2Session(info, opts = {}) {
 }
 /** v2 user message (list + prompt response): the UI reads `.text`. */
 export function toV2UserMessage(info) {
-    const text = info.parts
-        .filter((p) => p.type === "text")
-        .map((p) => p.text)
-        .join("");
+    const text = info.parts.map((p) => (p.type === "text" ? p.text : p.type === "compaction" ? "/compact" : "")).join("");
     return {
         id: info.info.id,
         time: { created: info.info.time.created },
@@ -142,7 +139,7 @@ export function toV2AssistantMessage(info) {
                 },
             });
         }
-        else {
+        else if (part.type === "tool") {
             content.push(toolContent(part));
         }
     }
@@ -412,6 +409,16 @@ export class V2EventTranslator {
         ];
     }
     onPartUpdated(directory, part, delta) {
+        if (part.type === "compaction")
+            // Like shell turns, the server creates this user turn; there is no optimistic prompt.
+            return [
+                this.frame(directory, "session.prompted", {
+                    sessionID: part.sessionID,
+                    messageID: part.messageID,
+                    prompt: { text: "/compact" },
+                    delivery: "queue",
+                }),
+            ];
         return part.type === "tool" ? this.onToolPart(directory, part) : this.onTextPart(directory, part, delta);
     }
     onTextPart(directory, part, delta) {

package/package.json

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