antechamber 1.0.40 → 1.0.41

package/dist/server.js

@@ -1,16 +1,23 @@
 /** HTTP/SSE composition root for the OpenCode API backed by pi. */
 import { createHash, randomBytes } from "node:crypto";
+import { execFile } from "node:child_process";
+import { watch } from "node:fs";
 import { createServer } from "node:http";
+import { basename, dirname, resolve } from "node:path";
+import { promisify } from "node:util";
 import { disposeMcpAgents, mcpSurfacesChanged } from "./mcp.js";
 import { debugLog } from "./misc-routes.js";
 import { SessionManager } from "./sessions.js";
-import { loadCatalog } from "./catalog.js";
+import { catalogFingerprint, loadCatalog } from "./catalog.js";
 import { Http } from "./http.js";
 import { SSE } from "./sse.js";
 import { handleV1 } from "./routes-v1.js";
 import { handleV2 } from "./routes-v2.js";
 import { selfUpdate } from "./self-update.js";
 import { handleWorkStatus } from "./work-status.js";
+import { FileWatchRegistry } from "./file-watch.js";
+import { getCommands } from "./session-commands.js";
+import { TextGeneration } from "./text-generation.js";
 export { isLoopbackHost, serverPassword } from "./http.js";
 export class AdapterServer {
     options;
@@ -22,26 +29,149 @@ export class AdapterServer {
     webSocketEvents = [];
     nextWebSocketEventID = 0;
     catalogPromise;
+    catalogExpiresAt = 0;
+    catalogColdExpiresAt = 0;
+    commandSnapshots = new Map();
+    commandColdReads = new Map();
+    branchSnapshots = new Map();
+    branchWatchers = new Map();
+    branchChecks = new Map();
+    projectDirectories = new Set();
+    fileWatches = new FileWatchRegistry((directory, event) => this.broadcast(directory, event));
+    pendingRefreshes = new Set();
+    textGeneration = new TextGeneration();
+    stopping = false;
     actualPort;
     /** Bearer token for the `/antechamber/work-status` routes, published in the run record for the OmO Work extension. */
     extensionToken = randomBytes(32).toString("base64url");
     http = new Http(() => this.url, this.extensionToken);
     constructor(options) {
         this.options = options;
+        this.projectDirectories.add(options.defaultDirectory);
         this.sse = new SSE(options, this.sseClients, (id) => this.sessions.monitors.owns(id));
         this.sessions = new SessionManager((directory, event) => this.broadcast(directory, event), undefined, options.defaultDirectory);
         this.sessions.onMcpSurfacesChanged = () => mcpSurfacesChanged((directory, event) => this.broadcast(directory, event));
         this.server = createServer((req, res) => void this.route(req, res));
         this.server.on("upgrade", (req, socket, head) => this.handleUpgrade(req, socket, head));
     }
-    catalog() {
-        this.catalogPromise ??= loadCatalog(this.options.defaultDirectory).catch((err) => {
-            this.catalogPromise = undefined;
+    catalog(directory = this.options.defaultDirectory, client, mode = "cached") {
+        // A live session's agent can only refresh an existing snapshot: its get_state reports that session's
+        // selected model, so the first snapshot (and the configured default) always comes from a fresh agent.
+        const pi = this.catalogPromise === undefined ? undefined : (client ?? this.sessions.liveClient(directory));
+        if (this.catalogPromise !== undefined &&
+            (this.catalogExpiresAt === Infinity ||
+                (mode !== "settled" &&
+                    (Date.now() < this.catalogExpiresAt ||
+                        (pi === undefined && (mode === "cached" || Date.now() < this.catalogColdExpiresAt))))))
+            return this.catalogPromise;
+        const previous = this.catalogPromise;
+        this.catalogExpiresAt = Infinity;
+        this.catalogColdExpiresAt = Date.now() + 60_000;
+        this.catalogPromise = (pi === undefined || previous === undefined
+            ? loadCatalog(directory)
+            : previous.then((last) => loadCatalog(directory, pi, last)))
+            .then(async (current) => {
+            this.catalogExpiresAt = Date.now() + 5_000;
+            this.catalogColdExpiresAt = Date.now() + 60_000;
+            if (previous !== undefined) {
+                const last = await previous;
+                if (catalogFingerprint(last) !== catalogFingerprint(current)) {
+                    this.broadcast(directory, { type: "provider.updated", properties: {} });
+                    this.broadcast(directory, { type: "model.updated", properties: {} });
+                }
+            }
+            return current;
+        })
+            .catch((err) => {
+            this.catalogExpiresAt = Date.now() + 5_000;
             console.error("[catalog] failed to load models from pi:", err);
-            return { providers: [], defaults: {} };
+            if (previous === undefined) {
+                // An unsuccessful first read established no snapshot to rate-limit or refresh.
+                this.catalogPromise = undefined;
+                this.catalogColdExpiresAt = 0;
+            }
+            return previous ?? { providers: [], defaults: {} };
         });
         return this.catalogPromise;
     }
+    async commands(directory, client, refresh = false) {
+        const pi = client ?? this.sessions.liveClient(directory);
+        const cold = this.commandColdReads.get(directory);
+        if (pi === undefined && cold !== undefined && Date.now() < cold.expiresAt)
+            return cold.promise;
+        const request = getCommands(directory, pi, refresh);
+        if (pi === undefined)
+            this.commandColdReads.set(directory, { expiresAt: Date.now() + 60_000, promise: request });
+        const commands = await request;
+        const previous = this.commandSnapshots.get(directory);
+        this.commandSnapshots.set(directory, commands);
+        this.commandColdReads.set(directory, { expiresAt: Date.now() + 60_000, promise: Promise.resolve(commands) });
+        if (previous !== undefined && JSON.stringify(previous) !== JSON.stringify(commands))
+            this.broadcast(directory, { type: "command.updated", properties: {} });
+        return commands;
+    }
+    watchBranch(directory) {
+        if (this.stopping)
+            return Promise.resolve(undefined);
+        const existing = this.branchWatchers.get(directory);
+        if (existing !== undefined)
+            return existing;
+        const pending = promisify(execFile)("git", ["rev-parse", "--git-path", "HEAD"], {
+            cwd: directory,
+            timeout: 3000,
+        })
+            .then(({ stdout }) => {
+            if (this.stopping)
+                return undefined;
+            const head = resolve(directory, stdout.trim());
+            const watcher = watch(dirname(head), (_event, name) => {
+                if (this.stopping || (name !== null && name.toString() !== basename(head)))
+                    return;
+                void this.vcsBranch(directory);
+            });
+            watcher.on("error", () => {
+                watcher.close();
+                this.branchWatchers.delete(directory);
+            });
+            watcher.unref();
+            return watcher;
+        })
+            .catch(() => {
+            this.branchWatchers.delete(directory);
+            return undefined;
+        });
+        this.branchWatchers.set(directory, pending);
+        return pending;
+    }
+    vcsBranch(directory) {
+        const pending = this.branchChecks.get(directory) ?? Promise.resolve();
+        const current = pending.then(() => this.readBranch(directory));
+        this.branchChecks.set(directory, current.then(() => undefined));
+        return current;
+    }
+    async readBranch(directory) {
+        if (this.stopping)
+            return this.branchSnapshots.get(directory);
+        await this.watchBranch(directory);
+        let branch;
+        try {
+            const { stdout } = await promisify(execFile)("git", ["symbolic-ref", "--short", "HEAD"], {
+                cwd: directory,
+                timeout: 3000,
+            });
+            branch = stdout.trim() || undefined;
+        }
+        catch {
+            branch = undefined;
+        }
+        if (this.branchSnapshots.has(directory) && this.branchSnapshots.get(directory) !== branch)
+            this.broadcast(directory, {
+                type: "vcs.branch.updated",
+                properties: branch === undefined ? {} : { branch },
+            });
+        this.branchSnapshots.set(directory, branch);
+        return branch;
+    }
     async start() {
         await new Promise((resolve, reject) => {
             this.server.once("error", reject);
@@ -58,10 +188,20 @@ export class AdapterServer {
         return `http://${host}:${port}`;
     }
     async stop() {
+        this.stopping = true;
+        await this.textGeneration.dispose();
+        await Promise.all([...this.pendingRefreshes]);
+        const branchWatchers = [...this.branchWatchers.values()];
+        this.branchWatchers.clear();
+        await Promise.all(this.branchChecks.values());
+        for (const watcher of await Promise.all([...branchWatchers, ...this.branchWatchers.values()]))
+            watcher?.close();
+        this.branchWatchers.clear();
         // Stop admission before ending SSE: its clients can reconnect while the
         // session RPC groups and private task hosts are still being disposed.
         const closed = new Promise((resolve) => this.server.close(() => resolve()));
         this.sse.close();
+        this.fileWatches.close();
         for (const socket of this.webSocketClients)
             socket.destroy();
         this.webSocketClients.clear();
@@ -78,6 +218,38 @@ export class AdapterServer {
     // SSE
     // ---------------------------------------------------------------
     broadcast(directory, event) {
+        if (event.type === "session.idle" && !this.stopping) {
+            const session = this.sessions.get(event.properties.sessionID);
+            if (session?.pi !== undefined) {
+                const reads = [
+                    ...(this.catalogPromise === undefined ? [] : [this.catalog(session.info.directory, session.pi, "settled")]),
+                    ...(this.commandSnapshots.has(session.info.directory)
+                        ? [this.commands(session.info.directory, session.pi, true)]
+                        : []),
+                ];
+                if (reads.length > 0) {
+                    const refresh = Promise.all(reads)
+                        .then(() => undefined)
+                        .catch((error) => console.error("[catalog] live refresh failed:", error));
+                    this.pendingRefreshes.add(refresh);
+                    void refresh.finally(() => this.pendingRefreshes.delete(refresh));
+                }
+            }
+        }
+        if (event.type === "session.created" && !this.projectDirectories.has(directory)) {
+            this.projectDirectories.add(directory);
+            const now = Date.now();
+            this.broadcast(directory, {
+                type: "project.updated",
+                properties: {
+                    id: directory,
+                    canonical: directory,
+                    time: { created: now, updated: now, active: now },
+                    sandboxes: [],
+                    vcs: "git",
+                },
+            });
+        }
         this.sse.broadcast(directory, event);
         this.broadcastWebSocket(directory, event);
     }
@@ -211,9 +383,13 @@ export class AdapterServer {
             defaultDirectory: this.options.defaultDirectory,
             url: this.url,
             body: (request) => this.http.body(request),
-            catalog: () => this.catalog(),
+            catalog: (dir, refresh) => this.catalog(dir, undefined, refresh === true ? "read" : "cached"),
             broadcast: (dir, event) => this.broadcast(dir, event),
             selfUpdate: this.options.selfUpdate ?? (() => selfUpdate()),
+            fileWatches: this.fileWatches,
+            commands: (dir) => this.commands(dir),
+            vcsBranch: (dir) => this.vcsBranch(dir),
+            textGeneration: this.textGeneration,
         };
         if (path === "/api" || path.startsWith("/api/")) {
             await handleV2(services, req, res, url, path, method, directory);

package/dist/session-commands.d.ts

@@ -1,3 +1,4 @@
+import { PiRpcClient } from "./pi-rpc.js";
 import type { OCPromptPart } from "./types.js";
 import type { ManagedSession, SessionManager } from "./sessions.js";
 import type { OCAssistantMessage, OCEvent, OCMessageWithParts, OCToolPart, OCTextPart, OCUserMessage } from "./types.js";
@@ -11,6 +12,7 @@ type SlashCommandInput = {
     arguments: string;
     messageID?: string;
     parts?: OCPromptPart[];
+    delivery?: "steer" | "queue";
 };
 type ShellResult = {
     output: string;
@@ -63,7 +65,7 @@ export declare const unsupportedShare: {
     };
 };
 export declare function shellTitle(command: string): string;
-export declare function getCommands(directory: string): Promise<CommandDescriptor[]>;
+export declare function getCommands(directory: string, client?: PiRpcClient, refresh?: boolean): Promise<CommandDescriptor[]>;
 export declare function parseSlashCommand(value: unknown): SlashCommandInput | undefined;
 /**
  * OmO never auto-titles a first prompt that starts with "/", so a session opened

package/dist/session-commands.js

@@ -91,19 +91,19 @@ function mapCommands(data) {
 }
 const COMMAND_CACHE_TTL_MS = 5_000;
 const commandCache = new Map();
-export function getCommands(directory) {
+export function getCommands(directory, client, refresh = false) {
     const now = Date.now();
     for (const [key, entry] of commandCache) {
         if (entry.expiresAt <= now)
             commandCache.delete(key);
     }
     const existing = commandCache.get(directory);
-    if (existing)
+    if (existing && (!refresh || existing.expiresAt === Infinity))
         return existing.promise;
     const entry = {
         expiresAt: Infinity,
         promise: (async () => {
-            const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+            const pi = client ?? new PiRpcClient({ cwd: directory, args: ["--no-session"] });
             try {
                 const response = await pi.command({ type: "get_commands" });
                 if (!response.success)
@@ -111,13 +111,16 @@ export function getCommands(directory) {
                 return mapCommands(response.data);
             }
             finally {
-                await pi.dispose();
+                if (client === undefined)
+                    await pi.dispose();
             }
         })().then((commands) => {
-            entry.expiresAt = Date.now() + COMMAND_CACHE_TTL_MS;
+            if (commandCache.get(directory) === entry)
+                entry.expiresAt = Date.now() + COMMAND_CACHE_TTL_MS;
             return commands;
         }, (error) => {
-            commandCache.delete(directory);
+            if (commandCache.get(directory) === entry)
+                commandCache.delete(directory);
             throw error;
         }),
     };
@@ -133,11 +136,14 @@ export function parseSlashCommand(value) {
     const messageID = typeof value.messageID === "string" && value.messageID !== "" ? value.messageID : undefined;
     const parts = parsePromptParts(value.parts);
     nativePromptInput("", parts);
+    if (value.delivery !== undefined && value.delivery !== "steer" && value.delivery !== "queue")
+        return undefined;
     return {
         command: value.command,
         arguments: value.arguments,
         ...(messageID ? { messageID } : {}),
         ...(parts.length > 0 ? { parts } : {}),
+        ...(value.delivery !== undefined ? { delivery: value.delivery } : {}),
     };
 }
 /**
@@ -168,7 +174,7 @@ function slashCommandPrompt(input) {
 }
 export async function runSlashCommand(sessions, sessionId, input) {
     const text = slashCommandPrompt(input);
-    await sessions.prompt(sessionId, text, undefined, false, input.messageID, "steer", input.parts ? [{ type: "text", text }, ...input.parts] : undefined);
+    await sessions.prompt(sessionId, text, undefined, false, input.messageID, input.delivery ?? "steer", input.parts ? [{ type: "text", text }, ...input.parts] : undefined);
     await sessions.reloadMessages(sessionId);
     const messages = sessions.messages(sessionId) ?? [];
     return messages.findLast((message) => message.info.role === "assistant") ?? messages[messages.length - 1];

package/dist/session-history.js

@@ -208,6 +208,9 @@ export function parsePiSessionText(s, agentName, raw) {
                     agent: agentName,
                     model: userMessageModel(currentModel, currentThinkingLevel),
                     synthetic: true,
+                    ...(s.tree.promptDescriptions?.[contextID] !== undefined
+                        ? { description: s.tree.promptDescriptions[contextID] }
+                        : {}),
                 },
                 parts: [
                     {

package/dist/session-store.d.ts

@@ -39,6 +39,10 @@ export interface ScannedSession extends SessionSelection {
     updated: number;
 }
 export type TitleSource = "user" | "native" | "fallback" | "generated";
+export interface InstructionEntryState {
+    value: unknown;
+    removed?: true;
+}
 /** Adapter-owned metadata that pi's files do not carry. */
 export interface SessionRegistryEntry {
     /** Created by this connector, rather than discovered from another OmO client. */
@@ -50,6 +54,7 @@ export interface SessionRegistryEntry {
     parentMessageID?: string;
     agent?: string;
     metadata?: Record<string, unknown>;
+    instructions?: Record<string, InstructionEntryState>;
     task?: ChildTask;
     piSessionId: string;
     piPath: string;
@@ -58,6 +63,8 @@ export interface SessionRegistryEntry {
     titleSource?: TitleSource;
     /** Archive timestamp (absent/0 = live) — OpenChamber's archive toggle. */
     archived?: number;
+    /** Last idle watermark acknowledged by a viewer. */
+    viewed?: number;
     /**
      * Last model pi was known to run. pi's JSONL header does not carry it, so
      * without this a dormant session would advertise no model at all until it is

package/dist/session-store.js

@@ -387,12 +387,31 @@ function sessionTreeState(value) {
     if (value.promptMetadata !== undefined &&
         (!record(value.promptMetadata) || !Object.values(value.promptMetadata).every((metadata) => record(metadata))))
         return false;
+    if (value.promptDescriptions !== undefined && !stringRecord(value.promptDescriptions))
+        return false;
+    if (value.compactionReasons !== undefined &&
+        (!stringRecord(value.compactionReasons) ||
+            !Object.values(value.compactionReasons).every((reason) => reason === "manual" || reason === "auto")))
+        return false;
     if (value.messageParts !== undefined &&
         (!record(value.messageParts) ||
             !Object.values(value.messageParts).every((parts) => Array.isArray(parts) && parts.every((part) => typeof part === "string"))))
         return false;
     if (value.shellDispatch !== undefined && !booleanRecord(value.shellDispatch))
         return false;
+    const finite = (item) => typeof item === "number" && Number.isFinite(item);
+    if (value.lastIdle !== undefined && !finite(value.lastIdle))
+        return false;
+    if (value.compactionAdmissions !== undefined &&
+        (!record(value.compactionAdmissions) || !Object.values(value.compactionAdmissions).every(finite)))
+        return false;
+    if (value.idleBoundaries !== undefined &&
+        (!record(value.idleBoundaries) ||
+            !Object.values(value.idleBoundaries).every((boundary) => record(boundary) &&
+                finite(boundary.at) &&
+                ["succeeded", "failed", "interrupted"].includes(boundary.outcome) &&
+                (boundary.error === undefined || record(boundary.error)))))
+        return false;
     if (value.leafId !== undefined && value.leafId !== null && typeof value.leafId !== "string")
         return false;
     if (value.fileSize !== undefined && (typeof value.fileSize !== "number" || !Number.isFinite(value.fileSize)))
@@ -448,6 +467,13 @@ function registryEntry(value) {
         return false;
     if (value.metadata !== undefined && !record(value.metadata))
         return false;
+    if (value.instructions !== undefined &&
+        (!record(value.instructions) ||
+            !Object.entries(value.instructions).every(([key, entry]) => /^[a-z0-9][a-z0-9._-]*$/.test(key) &&
+                record(entry) &&
+                "value" in entry &&
+                (entry.removed === undefined || entry.removed === true))))
+        return false;
     if (value.task !== undefined && !childTask(value.task))
         return false;
     if (value.title !== undefined && typeof value.title !== "string")
@@ -456,6 +482,8 @@ function registryEntry(value) {
         return false;
     if (value.archived !== undefined && (typeof value.archived !== "number" || !Number.isFinite(value.archived)))
         return false;
+    if (value.viewed !== undefined && (typeof value.viewed !== "number" || !Number.isFinite(value.viewed)))
+        return false;
     if (value.model !== undefined &&
         (!record(value.model) || typeof value.model.providerID !== "string" || typeof value.model.modelID !== "string"))
         return false;

package/dist/session-tree.d.ts

@@ -1,6 +1,6 @@
 import { type PiRpcClient } from "./pi-rpc.js";
 import type { ManagedSession } from "./sessions.js";
-import type { OCMessageWithParts } from "./types.js";
+import type { OCAssistantMessage, OCMessageWithParts, OCSession } from "./types.js";
 import type { OCPromptPart } from "./types.js";
 export interface SessionTreeState {
     messageEntries: Record<string, string>;
@@ -10,6 +10,10 @@ export interface SessionTreeState {
     promptParts?: Record<string, OCPromptPart[]>;
     /** Client prompt metadata; native RPC does not store it. */
     promptMetadata?: Record<string, Record<string, unknown>>;
+    /** Client-provided synthetic notice labels; native RPC stores only the context text. */
+    promptDescriptions?: Record<string, string>;
+    /** Native compaction reasons by the durable compaction entry ID. */
+    compactionReasons?: Record<string, "manual" | "auto">;
     /** Actual transport dispatch, not inferred from a card's terminal state. */
     shellDispatch?: Record<string, boolean>;
     /** Identity-only dispatched admissions; never rendered without a native entry. */
@@ -25,6 +29,16 @@ export interface SessionTreeState {
         previousLeafId: string | null;
         targetId: string | null;
     };
+    /** Execution boundaries observed over RPC, retained with the durable message identities. */
+    idleBoundaries?: Record<string, {
+        at: number;
+        outcome: NonNullable<OCSession["outcome"]>;
+        error?: NonNullable<OCAssistantMessage["error"]>;
+    }>;
+    /** The last idle time, restored as time.idle so /view accepts a watermark seen before a restart. */
+    lastIdle?: number;
+    /** When each compaction was admitted, keyed by its admitted message ID. */
+    compactionAdmissions?: Record<string, number>;
 }
 export interface TreeEntry {
     type: string;

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.