antechamber 1.0.39 → 1.0.41

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/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 {};

package/dist/text-generation.js

@@ -0,0 +1,93 @@
+import { PiRpcClient } from "./pi-rpc.js";
+/**
+ * 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 const GENERATION_DEADLINE_MS = 15 * 60 * 1000;
+/** Own the auxiliary agents separately from user sessions, with no admission queue. */
+export class TextGeneration {
+    active = new Map();
+    stopped = false;
+    async generate(directory, prompt, model, signal) {
+        if (this.stopped)
+            throw new Error("Text generation is stopping");
+        if (this.active.size >= 2)
+            throw new Error("Text generation is at capacity");
+        const cancellation = new AbortController();
+        const result = generateText(directory, prompt, model, signal ? AbortSignal.any([signal, cancellation.signal]) : cancellation.signal);
+        this.active.set(cancellation, result);
+        try {
+            return await result;
+        }
+        finally {
+            this.active.delete(cancellation);
+        }
+    }
+    async dispose() {
+        this.stopped = true;
+        for (const cancellation of this.active.keys())
+            cancellation.abort(new Error("Text generation is stopping"));
+        await Promise.allSettled(this.active.values());
+    }
+}
+/** Run a model turn in an agent with no persistent session, never in a user's chat. */
+export async function generateText(directory, prompt, model, caller) {
+    caller?.throwIfAborted();
+    // Startup overrides initialize agent state without persisting the default, unlike set_model.
+    // senpi dist/cli/args.js:93-104 -> main.js:561-576,843 -> core/sdk.js:125,292-298.
+    const pi = new PiRpcClient({
+        cwd: directory,
+        args: ["--no-session", "--no-tools", ...(model ? ["--provider", model.providerID, "--model", model.id] : [])],
+    });
+    const cancellation = new AbortController();
+    const signal = caller ? AbortSignal.any([caller, cancellation.signal]) : cancellation.signal;
+    // This budget covers startup/model resolution, admission, the turn, and the result read.
+    const timer = setTimeout(() => cancellation.abort(new Error("Text generation timed out")), GENERATION_DEADLINE_MS);
+    try {
+        const finished = new Promise((resolve, reject) => {
+            const cleanup = () => {
+                pi.off("event", onEvent);
+                signal.removeEventListener("abort", onAbort);
+            };
+            const onAbort = () => {
+                cleanup();
+                reject(signal.reason);
+            };
+            const onEvent = (event) => {
+                if (event.type !== "agent_end")
+                    return;
+                cleanup();
+                resolve();
+            };
+            pi.onEvent(onEvent);
+            signal.addEventListener("abort", onAbort, { once: true });
+        });
+        // A prompt RPC may acknowledge admission before the agent finishes; agent_end
+        // is the completion boundary before reading the resulting entries.
+        const admitted = pi.command({ type: "prompt", message: prompt }, undefined, signal).then((response) => {
+            if (!response.success)
+                throw new Error(response.error ?? "Text generation failed");
+        });
+        await Promise.all([admitted, finished]);
+        const history = await pi.command({ type: "get_entries" }, undefined, signal);
+        if (!history.success || !Array.isArray(history.data?.entries))
+            throw new Error("Text generation produced no readable history");
+        const assistant = history.data.entries.findLast((entry) => entry.type === "message" && entry.message?.role === "assistant");
+        const content = assistant?.message?.content;
+        const text = typeof content === "string"
+            ? content
+            : content
+                ?.filter((part) => part.type === "text")
+                .map((part) => part.text ?? "")
+                .join("");
+        if (!text)
+            throw new Error("Text generation produced no text");
+        return text;
+    }
+    finally {
+        clearTimeout(timer);
+        cancellation.abort();
+        await pi.dispose();
+    }
+}

package/dist/types.d.ts

@@ -48,6 +48,7 @@ export interface OCSession {
         created: number;
         updated: number;
         idle?: number;
+        viewed?: number;
         compacting?: number;
         /** Epoch ms — presence marks the session archived (SDK v2 session.update). */
         archived?: number;
@@ -67,6 +68,8 @@ export interface OCUserMessage {
     };
     /** No-reply context admitted without a turn (v2 lists it as `type: "synthetic"`). */
     synthetic?: boolean;
+    /** Human-readable label for a v2 synthetic notice. */
+    description?: string;
     /** Client metadata sent with the prompt (OpenChamber 2.x). */
     metadata?: Record<string, unknown>;
 }
@@ -291,6 +294,33 @@ export type OCEvent = {
     properties: {
         server: string;
     };
+} | {
+    type: "filesystem.changed";
+    properties: {
+        file: string;
+        event: "change" | "unlink";
+    };
+} | {
+    type: "project.updated";
+    properties: {
+        id: string;
+        canonical: string;
+        time: {
+            created: number;
+            updated: number;
+            active: number;
+        };
+        sandboxes: string[];
+        vcs: string;
+    };
+} | {
+    type: "provider.updated" | "model.updated" | "command.updated";
+    properties: Record<string, never>;
+} | {
+    type: "vcs.branch.updated";
+    properties: {
+        branch?: string;
+    };
 } | {
     type: "session.created";
     properties: {
@@ -301,6 +331,30 @@ export type OCEvent = {
     properties: {
         info: OCSession;
     };
+} | {
+    type: "session.renamed";
+    properties: {
+        sessionID: string;
+        title: string;
+    };
+} | {
+    type: "session.agent.selected";
+    properties: {
+        sessionID: string;
+        agent: string;
+        previous?: string;
+    };
+} | {
+    type: "session.archived" | "session.unarchived";
+    properties: {
+        sessionID: string;
+    };
+} | {
+    type: "session.viewed";
+    properties: {
+        sessionID: string;
+        idle: number;
+    };
 } | {
     type: "session.revert.staged";
     properties: {
@@ -327,6 +381,12 @@ export type OCEvent = {
         reason: string;
         inputID: string;
     };
+} | {
+    type: "session.compaction.delta";
+    properties: {
+        sessionID: string;
+        text: string;
+    };
 } | {
     type: "session.compaction.ended";
     properties: {

package/dist/v2.d.ts

@@ -123,6 +123,8 @@ export interface V2Session {
     time: {
         created: number;
         updated: number;
+        idle?: number;
+        viewed?: number;
         archived?: number;
     };
     title: string;
@@ -148,7 +150,12 @@ export interface V2Message {
         completed?: number;
         streamed?: number;
     };
-    type: "user" | "assistant" | "synthetic";
+    type: "user" | "assistant" | "synthetic" | "idle" | "compaction";
+    status?: "running" | "completed" | "failed";
+    reason?: string;
+    summary?: string;
+    outcome?: "succeeded" | "failed" | "interrupted";
+    description?: string;
     text?: string;
     files?: Array<Record<string, unknown>>;
     agents?: Array<Record<string, unknown>>;