antechamber 1.0.40 → 2.0.1

package/dist/sessions.d.ts

@@ -12,7 +12,7 @@ import { SubagentBridge } from "./subagents.js";
 import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
 import { OmoShells } from "./omo-shells.js";
-import { SessionStore, type TitleSource } from "./session-store.js";
+import { SessionStore, type InstructionEntryState, 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";
 interface StreamingState {
@@ -33,6 +33,9 @@ export interface ManagedSession extends ThinkingState {
         accepted: boolean;
         delivered: boolean;
     }>;
+    instructions?: Record<string, InstructionEntryState>;
+    /** Suppress model-selection events until the session creation record has its final model. */
+    initializing?: boolean;
     tree: SessionTreeState;
     info: OCSession;
     /** undefined while dormant (restored from disk, no pi process spawned yet). */
@@ -51,6 +54,8 @@ export interface ManagedSession extends ThinkingState {
     /** A manual compaction started while idle; its end returns the session to idle. */
     compactingFromIdle?: boolean;
     compactionID?: string;
+    /** The native reason of the running compaction, for its failure event. */
+    compactionReason?: string;
     /** Retries sessionRpc still owes a `compact` command that OmO cancels on its own. */
     compactRetry?: {
         left: number;
@@ -142,6 +147,8 @@ export declare class SessionManager {
      * global/recent view; `list(directory)` stays the per-project source of truth.
      */
     listAll(): OCSession[];
+    /** Reuse an already-running agent for directory-scoped catalog reads. Never revives a dormant session. */
+    liveClient(directory: string): PiRpcClient | undefined;
     private sessionInfo;
     get(sessionId: string): ManagedSession | undefined;
     remove(sessionId: string): Promise<boolean>;
@@ -158,7 +165,77 @@ export declare class SessionManager {
         metadata?: Record<string, unknown> | undefined;
         agent?: string | undefined;
     }): Promise<OCSession | undefined>;
+    /** Mark only the idle boundary that the caller actually observed. */
+    view(sessionId: string, idle: number): void;
+    putInstruction(sessionId: string, key: string, value: unknown): void;
+    removeInstruction(sessionId: string, key: string): void;
     messages(sessionId: string): OCMessageWithParts[] | undefined;
+    compaction(sessionId: string, messageID: string): {
+        id: string;
+        type: "compaction";
+        time: {
+            created: number;
+        };
+        status: "completed";
+        reason: "auto" | "manual";
+        summary: string;
+    } | {
+        id: string;
+        type: "compaction";
+        time: {
+            created: number;
+        };
+        status: "running";
+        reason: "manual";
+        summary: string;
+    } | undefined;
+    /** Synchronous admission owns the ID before any native work can yield to another request. */
+    admitCompaction(sessionId: string, messageID: string): {
+        kind: "conflict";
+        item?: never;
+    } | {
+        kind: "existing";
+        item: {
+            id: string;
+            type: "compaction";
+            time: {
+                created: number;
+            };
+            status: "completed";
+            reason: "auto" | "manual";
+            summary: string;
+        } | {
+            id: string;
+            type: "compaction";
+            time: {
+                created: number;
+            };
+            status: "running";
+            reason: "manual";
+            summary: string;
+        };
+    } | {
+        kind: "admitted";
+        item: {
+            id: string;
+            type: "compaction";
+            time: {
+                created: number;
+            };
+            status: "completed";
+            reason: "auto" | "manual";
+            summary: string;
+        } | {
+            id: string;
+            type: "compaction";
+            time: {
+                created: number;
+            };
+            status: "running";
+            reason: "manual";
+            summary: string;
+        };
+    };
     /** Append to canonical history, before the hidden redo branch while reverted. */
     appendMessage(sessionId: string, message: OCMessageWithParts): void;
     private operation;
@@ -212,6 +289,13 @@ export declare class SessionManager {
     private preparePrompt;
     private publishPrompt;
     private promptLive;
+    /**
+     * What the model has is read from the active native branch, not stored beside it: each delivery carries the
+     * full delivered map in `details`, so after a revert, unrevert, fork or compaction the last delivery still in
+     * context says exactly what to send again. Deliveries before a compaction's kept range are no longer in context
+     * (OpenCode rewinds its instruction state the same way, core/session/projector.ts).
+     */
+    private deliverInstructions;
     /**
      * No-reply context (v2 synthetic, v1 noReply) joins the native conversation without a turn:
      * OmO appends it now when idle, or after the running turn, so the next prompt carries it.

package/dist/sessions.js

@@ -87,7 +87,9 @@ export class SessionManager {
         this.workStatus = new WorkStatusBridge(this.monitors);
         this.shells = new OmoShells(this.sessions, this.monitors, this.workStatus, this.emit);
         this.events = new PiEventTranslator({
-            emit: this.emit,
+            emit: (directory, event) => {
+                this.emit(directory, event);
+            },
             subagents: this.subagents,
             monitors: this.monitors,
             workStatus: this.workStatus,
@@ -161,6 +163,7 @@ export class SessionManager {
             messages: [],
             status: { type: "idle" },
             model: undefined,
+            initializing: true,
             streaming: undefined,
             toolByCallId: new Map(),
             hasPendingInteraction: () => false,
@@ -179,13 +182,11 @@ export class SessionManager {
             this.wireDormant(managed);
             this.lifecycle.touch(managed);
             this.wirePi(managed, pi);
+            this.applyPiModel(managed, state.data.model?.provider, state.data.model?.id);
             if (options.model !== undefined)
                 await this.setModel(info.id, options.model);
             this.emit(directory, { type: "session.created", properties: { info } });
-            // Announce pi's real model *after* session.created, so the client already
-            // knows the session when the switch marker lands in its transcript.
-            if (options.model === undefined)
-                this.applyPiModel(managed, state.data.model?.provider, state.data.model?.id);
+            delete managed.initializing;
             // Bind pi's session file so the session survives adapter restarts. pi
             // reports the path directly; fall back to a background scan for older pi
             // versions, and re-bind after the first prompt (pi persists lazily).
@@ -250,6 +251,7 @@ export class SessionManager {
         s.info.time.updated = Date.now();
         this.persistMeta(s);
         this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
+        this.emit(s.info.directory, { type: "session.renamed", properties: { sessionID: s.info.id, title } });
     }
     refreshNativeTitles() {
         for (const s of this.sessions.values())
@@ -394,6 +396,14 @@ export class SessionManager {
             return [...this.sessions.values()].map((s) => this.sessionInfo(s));
         });
     }
+    /** Reuse an already-running agent for directory-scoped catalog reads. Never revives a dormant session. */
+    liveClient(directory) {
+        for (const session of this.sessions.values()) {
+            if (session.info.directory === directory && session.pi !== undefined)
+                return session.pi;
+        }
+        return undefined;
+    }
     sessionInfo(s) {
         if (s.restored !== undefined)
             this.ensureMessages(s);
@@ -458,6 +468,9 @@ export class SessionManager {
             return undefined;
         if (patch.agent !== undefined && !getExposedAgentNames().includes(patch.agent))
             throw new RequestBodyError(400, `unknown agent: ${patch.agent}`);
+        const previousTitle = s.info.title;
+        const previousAgent = s.info.agent ?? getAgentName();
+        const wasArchived = s.info.time.archived !== undefined;
         if (typeof patch.title === "string" && patch.title.trim() !== "") {
             const title = patch.title.trim().replace(/\s+/g, " ");
             if (s.pi !== undefined) {
@@ -483,8 +496,58 @@ export class SessionManager {
         if (!this.subagents.save(s.info.id))
             this.persistMeta(s);
         this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
+        if (s.info.title !== previousTitle)
+            this.emit(s.info.directory, {
+                type: "session.renamed",
+                properties: { sessionID: sessionId, title: s.info.title },
+            });
+        if ((s.info.agent ?? getAgentName()) !== previousAgent)
+            this.emit(s.info.directory, {
+                type: "session.agent.selected",
+                properties: { sessionID: sessionId, agent: s.info.agent ?? getAgentName(), previous: previousAgent },
+            });
+        if ((s.info.time.archived !== undefined) !== wasArchived)
+            this.emit(s.info.directory, {
+                type: s.info.time.archived !== undefined ? "session.archived" : "session.unarchived",
+                properties: { sessionID: sessionId },
+            });
         return s.info;
     }
+    /** Mark only the idle boundary that the caller actually observed. */
+    view(sessionId, idle) {
+        const s = this.get(sessionId);
+        if (s === undefined ||
+            s.info.time.idle === undefined ||
+            idle > s.info.time.idle ||
+            (s.info.time.viewed !== undefined && s.info.time.viewed >= idle))
+            return;
+        s.info.time.viewed = idle;
+        this.persistMeta(s);
+        this.emit(s.info.directory, { type: "session.viewed", properties: { sessionID: sessionId, idle } });
+    }
+    putInstruction(sessionId, key, value) {
+        const s = this.get(sessionId);
+        if (s === undefined)
+            throw new Error(`unknown session: ${sessionId}`);
+        const previous = s.instructions?.[key];
+        if (previous?.removed !== true &&
+            previous !== undefined &&
+            JSON.stringify(previous.value) === JSON.stringify(value))
+            return;
+        (s.instructions ??= {})[key] = { value };
+        this.persistMeta(s);
+    }
+    removeInstruction(sessionId, key) {
+        const s = this.get(sessionId);
+        if (s === undefined)
+            throw new Error(`unknown session: ${sessionId}`);
+        const instructions = s.instructions;
+        const previous = instructions?.[key];
+        if (instructions === undefined || previous === undefined || previous.removed)
+            return;
+        instructions[key] = { value: null, removed: true };
+        this.persistMeta(s);
+    }
     messages(sessionId) {
         const s = this.get(sessionId);
         if (!s)
@@ -499,6 +562,61 @@ export class SessionManager {
         }
         return messages;
     }
+    compaction(sessionId, messageID) {
+        const s = this.get(sessionId);
+        if (s === undefined)
+            return undefined;
+        const history = this.ensureMessages(s);
+        const index = history.findIndex((message) => message.parts.some((part) => part.type === "compaction") &&
+            (message.info.id === messageID ||
+                s.tree.messageEntries[messageID] === message.info.id.replace(/^msg_compaction_/, "")));
+        const message = history[index];
+        const summary = history[index + 1];
+        if (message !== undefined && summary?.info.role === "assistant" && summary.info.summary) {
+            const entryID = message.info.id.replace(/^msg_compaction_/, "");
+            const admittedID = Object.keys(s.tree.messageEntries).find((key) => key !== message.info.id && s.tree.messageEntries[key] === entryID) ?? message.info.id;
+            const content = summary.parts.find((part) => part.type === "text");
+            return {
+                id: admittedID,
+                type: "compaction",
+                time: { created: s.tree.compactionAdmissions?.[admittedID] ?? message.info.time.created },
+                status: "completed",
+                reason: s.tree.compactionReasons?.[entryID] ?? "manual",
+                summary: content?.type === "text" ? content.text : "",
+            };
+        }
+        if (s.compactionID !== messageID)
+            return undefined;
+        return {
+            id: messageID,
+            type: "compaction",
+            time: { created: s.tree.compactionAdmissions?.[messageID] ?? s.info.time.compacting ?? Date.now() },
+            status: "running",
+            reason: "manual",
+            summary: "",
+        };
+    }
+    /** Synchronous admission owns the ID before any native work can yield to another request. */
+    admitCompaction(sessionId, messageID) {
+        const s = this.get(sessionId);
+        if (s === undefined)
+            throw new SessionTreeError(`unknown session: ${sessionId}`);
+        const history = this.ensureMessages(s);
+        const owner = history.find((message) => message.info.id === messageID);
+        if ((owner !== undefined && !owner.parts.some((part) => part.type === "compaction")) ||
+            Object.keys(s.tree.idleBoundaries ?? {}).some((key) => `msg_idle_${key.replace(/^msg_/, "")}` === messageID))
+            return { kind: "conflict" };
+        const exact = this.compaction(sessionId, messageID);
+        if (exact !== undefined)
+            return { kind: "existing", item: exact };
+        if (s.tree.messageEntries[messageID] !== undefined)
+            return { kind: "conflict" };
+        if (s.compactionID !== undefined)
+            return { kind: "existing", item: this.compaction(sessionId, s.compactionID) };
+        s.compactionID = messageID;
+        (s.tree.compactionAdmissions ??= {})[messageID] = Date.now();
+        return { kind: "admitted", item: this.compaction(sessionId, messageID) };
+    }
     /** Append to canonical history, before the hidden redo branch while reverted. */
     appendMessage(sessionId, message) {
         const s = this.get(sessionId);
@@ -626,6 +744,8 @@ export class SessionManager {
             child.info.agent = s.info.agent ?? getAgentName();
             if (s.info.metadata !== undefined)
                 child.info.metadata = structuredClone(s.info.metadata);
+            if (s.instructions !== undefined)
+                child.instructions = structuredClone(s.instructions);
             const childTree = await getEntries(pi);
             child.tree.leafId = childTree.leafId;
             this.ensureMessages(child);
@@ -979,10 +1099,11 @@ export class SessionManager {
         s.model = model;
         s.info.model = { id: modelId, providerID: provider, variant: s.thinkingLevel ?? "default" };
         this.persistMeta(s);
-        this.emit(s.info.directory, {
-            type: "model.changed",
-            properties: { sessionID: s.info.id, model, ...(previous !== undefined ? { previous } : {}) },
-        });
+        if (!s.initializing)
+            this.emit(s.info.directory, {
+                type: "model.changed",
+                properties: { sessionID: s.info.id, model, ...(previous !== undefined ? { previous } : {}) },
+            });
         return true;
     }
     async prompt(sessionId, text, model, noReply = false, messageID, delivery = "steer", parts, metadata) {
@@ -1035,6 +1156,9 @@ export class SessionManager {
             agent: getAgentName(),
             model: userMessageModel(s.model ?? model ?? { providerID: "unknown", modelID: "unknown" }, s.thinkingLevel),
             ...(context ? { synthetic: true } : {}),
+            ...(context && s.tree.promptDescriptions?.[messageID ?? ""] !== undefined
+                ? { description: s.tree.promptDescriptions[messageID ?? ""] }
+                : {}),
             ...(metadata !== undefined ? { metadata } : {}),
         };
         if (metadata !== undefined)
@@ -1052,12 +1176,18 @@ export class SessionManager {
             (s.tree.promptParts ??= {})[userMsg.id] = [...inputParts];
         s.messages?.push({ info: userMsg, parts });
         s.info.time.updated = Date.now();
+        const previousTitle = s.info.title;
         if (!context && s.info.title === "New session" && s.titleSource !== "user" && s.titleSource !== "native") {
             s.info.title = text.trim().replace(/\s+/g, " ").slice(0, SESSION_TITLE_MAX_CHARS) || "New session";
             s.titleSource = "fallback";
         }
         this.persistMeta(s);
         this.emit(s.info.directory, { type: "session.updated", properties: { info: s.info } });
+        if (s.info.title !== previousTitle)
+            this.emit(s.info.directory, {
+                type: "session.renamed",
+                properties: { sessionID: s.info.id, title: s.info.title },
+            });
         this.emit(s.info.directory, { type: "message.updated", properties: { info: userMsg } });
         // Echo the user text part: the reducer replaces the client's sessionID-less
         // optimistic part (same type, new id) in place — without this echo a page
@@ -1069,6 +1199,10 @@ export class SessionManager {
     async promptLive(s, text, model, noReply = false, messageID, delivery = "steer", parts, metadata) {
         const pi = await this.preparePrompt(s, model);
         const native = nativePromptInput(text, parts ?? []);
+        // OpenChamber treats instruction writes as best effort, so a rejected delivery must not fail the prompt;
+        // the entries stay undelivered and are offered again before the next prompt.
+        if (!noReply)
+            await this.deliverInstructions(s, pi).catch((error) => console.error(`[instructions] delivery to ${s.info.id} failed:`, error));
         const userMsg = this.publishPrompt(s, text, model, messageID, parts, metadata, noReply);
         if (noReply) {
             await this.admitContext(s, pi, userMsg, native.message);
@@ -1078,6 +1212,53 @@ export class SessionManager {
             return;
         await this.bindPromptState(s);
     }
+    /**
+     * What the model has is read from the active native branch, not stored beside it: each delivery carries the
+     * full delivered map in `details`, so after a revert, unrevert, fork or compaction the last delivery still in
+     * context says exactly what to send again. Deliveries before a compaction's kept range are no longer in context
+     * (OpenCode rewinds its instruction state the same way, core/session/projector.ts).
+     */
+    async deliverInstructions(s, pi) {
+        const instructions = Object.entries(s.instructions ?? {});
+        if (instructions.length === 0)
+            return;
+        const delivered = deliveredInstructions(branchEntries(await getEntries(pi)));
+        const pending = instructions
+            .filter(([key, entry]) => entry.removed
+            ? key in delivered
+            : !(key in delivered) || JSON.stringify(entry.value) !== JSON.stringify(delivered[key]))
+            .sort(([left], [right]) => left.localeCompare(right));
+        if (pending.length === 0)
+            return;
+        const text = pending
+            .map(([key, entry]) => {
+            if (entry.removed)
+                return `The context under "${key}" no longer applies. Disregard it.`;
+            const block = `<context key="${key}">\n${typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value, null, 2)}\n</context>`;
+            return key in delivered
+                ? `The context under "${key}" changed and supersedes the previous value:\n${block}`
+                : block;
+        })
+            .join("\n\n");
+        const snapshot = { ...delivered };
+        for (const [key, entry] of pending) {
+            if (entry.removed)
+                delete snapshot[key];
+            else
+                snapshot[key] = entry.value;
+        }
+        const result = await pi.command({
+            type: "send_custom_message",
+            customType: INSTRUCTIONS_CUSTOM_TYPE,
+            content: [{ type: "text", text }],
+            display: false,
+            details: { instructions: snapshot },
+            triggerTurn: false,
+        });
+        if (!result.success)
+            throw new Error(result.error ?? "instruction delivery rejected");
+        await this.bindPromptState(s);
+    }
     /**
      * No-reply context (v2 synthetic, v1 noReply) joins the native conversation without a turn:
      * OmO appends it now when idle, or after the running turn, so the next prompt carries it.
@@ -1494,6 +1675,7 @@ export class SessionManager {
             (reg?.title && reg.title !== "New session" && reg.title !== sc.fallbackTitle ? "user" : "fallback");
         const useRegistry = titleSource === "user" || (sc.titleSource !== "native" && titleSource === "generated");
         const resumed = dormantModel(sc, reg?.model);
+        const tree = durableShellTree(reg?.tree ?? { messageEntries: {} });
         const info = {
             id: ocId,
             projectID: sc.directory,
@@ -1518,10 +1700,12 @@ export class SessionManager {
                 created: sc.created,
                 updated: Math.max(sc.updated, reg?.updated ?? 0),
                 ...(reg?.archived ? { archived: reg.archived } : {}),
+                ...(reg?.viewed !== undefined ? { viewed: reg.viewed } : {}),
+                ...(tree.lastIdle !== undefined ? { idle: tree.lastIdle } : {}),
             },
         };
         const managed = {
-            tree: durableShellTree(reg?.tree ?? { messageEntries: {} }),
+            tree,
             titleSource: useRegistry ? titleSource : (sc.titleSource ?? "fallback"),
             info,
             pi: undefined,
@@ -1534,6 +1718,7 @@ export class SessionManager {
             hasPendingInteraction: () => false,
             hasRunningChildren: () => false,
             ...(reg?.lastStop !== undefined ? { lastStop: reg.lastStop } : {}),
+            ...(reg?.instructions !== undefined ? { instructions: structuredClone(reg.instructions) } : {}),
         };
         this.sessions.set(ocId, managed);
         if (reg?.connectorOwned === true)
@@ -1608,7 +1793,9 @@ export class SessionManager {
             ...(s.info.title !== "New session" ? { title: s.info.title } : {}),
             ...(s.titleSource !== undefined ? { titleSource: s.titleSource } : {}),
             ...(s.info.time.archived !== undefined ? { archived: s.info.time.archived } : {}),
+            ...(s.info.time.viewed !== undefined ? { viewed: s.info.time.viewed } : {}),
             ...(s.info.metadata !== undefined ? { metadata: s.info.metadata } : {}),
+            ...(s.instructions !== undefined ? { instructions: s.instructions } : {}),
             ...(s.info.agent !== undefined ? { agent: s.info.agent } : {}),
             ...(s.info.parentID !== undefined ? { parentID: s.info.parentID } : {}),
             ...(s.info.parentMessageID !== undefined ? { parentMessageID: s.info.parentMessageID } : {}),
@@ -1629,6 +1816,47 @@ export class SessionManager {
     }
     /** Keep the existing event entry point for RPC wiring and test harnesses. */
     onPiEvent(s, ev) {
+        const interrupted = s.interruptRequested;
         this.events.onPiEvent(s, ev);
+        if (ev.type === "agent_idle" && s.info.time.idle !== undefined) {
+            recordTurn(s);
+            const last = s.messages?.findLast((message) => message.info.role === "assistant" &&
+                !message.info.summary &&
+                !message.info.id.startsWith("msg_background_") &&
+                !s.localMessageIds?.has(message.info.id));
+            if (last?.info.role === "assistant") {
+                const error = interrupted ? { name: "MessageAbortedError", data: { message: "Cancelled" } } : last.info.error;
+                const outcome = interrupted ? "interrupted" : (s.info.outcome ?? "succeeded");
+                s.info.outcome = outcome;
+                (s.tree.idleBoundaries ??= {})[last.info.id] = {
+                    at: s.info.time.idle,
+                    outcome,
+                    ...(error !== undefined ? { error } : {}),
+                };
+            }
+            this.persistMeta(s);
+        }
     }
 }
+const INSTRUCTIONS_CUSTOM_TYPE = "antechamber.instructions";
+/** The instruction map the model holds on this branch: the last delivery inside the newest compaction's kept range. */
+function deliveredInstructions(branch) {
+    let start = 0;
+    for (let index = branch.length - 1; index >= 0; index--) {
+        const entry = branch[index];
+        if (entry.type !== "compaction")
+            continue;
+        const kept = branch.findIndex((candidate) => candidate.id === entry.firstKeptEntryId);
+        start = kept >= 0 ? kept : index + 1;
+        break;
+    }
+    for (let index = branch.length - 1; index >= start; index--) {
+        const entry = branch[index];
+        if (entry?.type !== "custom_message" || entry.customType !== INSTRUCTIONS_CUSTOM_TYPE)
+            continue;
+        const details = entry.details;
+        if (details?.instructions !== null && typeof details?.instructions === "object")
+            return { ...details.instructions };
+    }
+    return {};
+}

package/dist/sse.d.ts

@@ -3,9 +3,7 @@ import type { ServerResponse } from "node:http";
 import type { OCEvent } from "./types.js";
 import type { TodoUpdated } from "./todo-bridge.js";
 export type SSESubscriber = {
-    flavor: "v1" | "v2";
     directory?: string;
-    global: boolean;
 };
 /** The session an event belongs to, when it names one. */
 export declare function eventSessionID(event: OCEvent | TodoUpdated): string | undefined;

package/dist/sse.js

@@ -48,9 +48,7 @@ export class SSE {
             : event.type === "todo.updated"
                 ? [{ id: `evt_${randomUUID()}`, type: event.type, location: { directory }, data: event.properties }]
                 : this.v2events.translate(directory, event);
-        const records = v2Frames.length === 0
-            ? [this.record(directory, { v1: event })]
-            : v2Frames.map((v2, index) => this.record(directory, index === 0 ? { v1: event, v2 } : { v2 }));
+        const records = v2Frames.map((v2) => this.record(directory, { v2 }));
         for (const record of records)
             this.retain(record);
         for (const [res, subscriber] of this.clients) {
@@ -59,7 +57,7 @@ export class SSE {
                 continue;
             }
             for (const record of records) {
-                if (!subscriber.global && subscriber.directory !== directory)
+                if (subscriber.directory !== undefined && subscriber.directory !== directory)
                     continue;
                 if (!this.writeRecord(res, subscriber, record))
                     break;
@@ -102,22 +100,14 @@ export class SSE {
             this.clients.delete(res);
         });
         // OpenCode emits server.connected on subscribe; OpenChamber waits for it.
-        const connected = subscriber.flavor === "v2"
-            ? {
-                id: `evt_${Date.now()}`,
-                created: Date.now(),
-                type: "server.connected",
-                location: { directory: subscriber.directory ?? this.options.defaultDirectory },
-                data: {},
-            }
-            : { type: "server.connected", properties: {} };
-        const initial = subscriber.flavor === "v1" && subscriber.global
-            ? {
-                directory: subscriber.directory ?? this.options.defaultDirectory,
-                payload: { id: `evt_${randomUUID()}`, ...connected },
-            }
-            : connected;
-        write(res, `data: ${JSON.stringify(initial)}\n\n`);
+        const connected = {
+            id: `evt_${Date.now()}`,
+            created: Date.now(),
+            type: "server.connected",
+            location: { directory: subscriber.directory ?? this.options.defaultDirectory },
+            data: {},
+        };
+        write(res, `data: ${JSON.stringify(connected)}\n\n`);
         const cursor = Number(lastEventID);
         if (!Number.isSafeInteger(cursor) || cursor < 0)
             return;
@@ -135,35 +125,12 @@ export class SSE {
             this.replay.shift();
     }
     writeRecord(res, subscriber, record) {
-        if (!subscriber.global && subscriber.directory !== record.directory)
+        if (subscriber.directory !== undefined && subscriber.directory !== record.directory)
             return true;
-        const data = subscriber.flavor === "v2"
-            ? record.v2
-            : record.v1 === undefined
-                ? undefined
-                : subscriber.global
-                    ? {
-                        directory: record.directory,
-                        project: record.directory,
-                        payload: {
-                            id: `evt_${record.id}`,
-                            ...record.v1,
-                            properties: {
-                                ...record.v1.properties,
-                                ...(record.v1.type === "session.created" ||
-                                    record.v1.type === "session.updated" ||
-                                    record.v1.type === "session.deleted"
-                                    ? { sessionID: record.v1.properties.info.id }
-                                    : {}),
-                            },
-                        },
-                    }
-                    : record.v1;
+        const data = record.v2;
         if (data === undefined)
             return true;
-        const frame = subscriber.flavor === "v1" && !subscriber.global
-            ? `data: ${JSON.stringify(data)}\n\n`
-            : `id: ${record.id}\ndata: ${JSON.stringify(data)}\n\n`;
+        const frame = `id: ${record.id}\ndata: ${JSON.stringify(data)}\n\n`;
         return this.writeSSE(res, frame);
     }
 }

package/dist/text-generation.d.ts

@@ -0,0 +1,20 @@
+type Model = {
+    providerID: string;
+    id: string;
+};
+/**
+ * A hang guard, not a budget: OpenChamber sizes its own small-model deadline by prompt length up to 900 s
+ * (server/lib/small-model/index.js generationBudgetMs) and its disconnect cancels the run here, and OpenCode's
+ * generate.text has no server deadline. This only has to outlast the longest budget a caller may give.
+ */
+export declare const GENERATION_DEADLINE_MS: number;
+/** Own the auxiliary agents separately from user sessions, with no admission queue. */
+export declare class TextGeneration {
+    private readonly active;
+    private stopped;
+    generate(directory: string, prompt: string, model?: Model, signal?: AbortSignal): Promise<string>;
+    dispose(): Promise<void>;
+}
+/** Run a model turn in an agent with no persistent session, never in a user's chat. */
+export declare function generateText(directory: string, prompt: string, model?: Model, caller?: AbortSignal): Promise<string>;
+export {};