antechamber 1.0.39 → 1.0.41

package/CHANGELOG.md

@@ -7,6 +7,43 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.41] - 2026-11-09
+
+### Fixed
+
+OpenChamber 2.6.1 against OpenCode 2.2.5 was captured and replayed against antechamber; these close the differences
+that OpenChamber relies on.
+
+- Permission cards on `/api/event` now use OpenCode 2.x's fields (`action`, `resources`, `save`, `source`), and
+  "Allow always" advertises the scope OmO saves for reads, edits, lists, globs, greps and eval. The pending-form list
+  only shows questions from the current project.
+- Session lists honor `parentID=null` and `archived`, so message search indexes existing conversations. A metadata
+  update no longer sends a rename and an agent switch; renames, agent switches, archive and unarchive are announced
+  once, when they really happen, and a new session announces its model.
+- OpenChamber's per-session guidance, checkout info, memory, pinned messages and response style now reach the agent:
+  instruction entries are stored and sent to OmO before the next prompt, removals are announced, and compaction
+  re-sends them. Unread state is kept (`/view` no longer fails), and the inbox lists inputs still waiting for the agent.
+- A reloaded transcript keeps the turn boundaries and compaction records the live one had. `/compact` answers as soon
+  as the compaction starts instead of waiting for it, and slash commands keep their attachments and delivery mode.
+- Rename with AI and other small-model actions work: `/api/experimental/generate/text` runs a one-off OmO turn with
+  no tools and no session. The image-model picker only lists image models, directory search finds folders, open
+  files reload when they change on disk, and project, provider, model, command and Git branch changes reach an open
+  OpenChamber without a reload. Nothing polls: refreshes ride on finished turns, client reads and a watch on Git's
+  HEAD. Usage limits and the debug location list answer like OpenCode instead of 404.
+- Text generation picks its model at agent start, so Rename with AI never changes OmO's saved default model; it is
+  bounded by one deadline and two concurrent runs, and stops when the caller disconnects or the server stops.
+- File watches are 24-hour leases that OpenChamber's renewals extend, so closed editors no longer leave watchers
+  behind; a reverted, forked or compacted conversation gets back the instruction entries it lost; and a turn still
+  running tools no longer shows as finished in a reloaded transcript.
+
+## [1.0.40] - 2026-11-06
+
+### Fixed
+
+- Keep the conversation in order after a `!` shell command. The history refresh that follows a shell command sent
+  every earlier reply to OpenChamber again with the current time as its creation time, so OpenChamber moved those
+  replies after the prompts they answered and placed the shell card among them. Replies now keep their own times.
+
 ## [1.0.39] - 2026-11-04
 
 - fix(v2): give each task batch card its own tool id (#90)

package/dist/approvals.d.ts

@@ -47,7 +47,15 @@ export declare function parsePermissionTitle(title: string): {
     permission: string;
     patterns: string[];
 };
-export declare function toV2Permission(card: PermissionRequest): PermissionV2Request;
+/** OpenCode 2.2.5 names the tool source `{type, messageID, id}` (packages/schema/src/permission.ts); the SDK types predate it. */
+type V2PermissionCard = Omit<PermissionV2Request, "source"> & {
+    source?: {
+        type: "tool";
+        messageID: string;
+        id: string;
+    };
+};
+export declare function toV2Permission(card: PermissionRequest): V2PermissionCard;
 /** Session-scoped dialog lifecycle; RPC select replies are labels, never indices. */
 export declare class ApprovalBridge {
     private sessionID;

package/dist/approvals.js

@@ -91,7 +91,7 @@ export function toV2Permission(card) {
         resources: card.patterns,
         save: card.always,
         metadata: card.metadata,
-        ...(card.tool ? { source: { type: "tool", ...card.tool } } : {}),
+        ...(card.tool ? { source: { type: "tool", messageID: card.tool.messageID, id: card.tool.callID } } : {}),
     };
 }
 /** Session-scoped dialog lifecycle; RPC select replies are labels, never indices. */
@@ -339,7 +339,15 @@ export class ApprovalBridge {
                 id: request.id,
                 sessionID: context.sessionID,
                 ...parsed,
-                always: [],
+                // The UI request carries display patterns, not the native `always` array. Only advertise
+                // scopes whose native parser saves exactly these patterns (or a known blanket scope).
+                always: request.options.includes("Allow always")
+                    ? ["read", "edit", "list", "glob"].includes(parsed.permission)
+                        ? parsed.patterns
+                        : ["grep", "eval"].includes(parsed.permission)
+                            ? ["*"]
+                            : []
+                    : [],
                 metadata: { title: request.title },
                 ...(callID !== undefined ? { tool: { messageID: context.messageID, callID } } : {}),
             };

package/dist/catalog.d.ts

@@ -1,8 +1,9 @@
 /**
  * Model/provider catalog: obtained from a throwaway `pi --mode rpc` process
  * (`get_available_models` + `get_state`), translated into OpenCode v2
- * Provider/Model shapes, cached for the adapter lifetime.
+ * Provider/Model shapes, refreshed from live agents or bounded cold reads.
  */
+import { PiRpcClient } from "./pi-rpc.js";
 interface OCv2Model {
     id: string;
     providerID: string;
@@ -84,5 +85,15 @@ export declare function agentDefaults(cat: Catalog): {
     };
     variant?: string;
 };
-export declare function loadCatalog(directory: string): Promise<Catalog>;
+/**
+ * The configured default plus the provider/model inventory in a fixed order, so a reordering alone is not
+ * reported as a catalog change but a new default is.
+ */
+export declare function catalogFingerprint(catalog: Catalog): string;
+/**
+ * `configured` is the previous snapshot when `client` is a live session's agent: that agent's `get_state.model`
+ * is the session's own selection, not the configured default, so only the model inventory is re-read and the
+ * snapshot's default is kept. Only a fresh `--no-session` agent defines the default.
+ */
+export declare function loadCatalog(directory: string, client?: PiRpcClient, configured?: Catalog): Promise<Catalog>;
 export {};

package/dist/catalog.js

@@ -1,7 +1,7 @@
 /**
  * Model/provider catalog: obtained from a throwaway `pi --mode rpc` process
  * (`get_available_models` + `get_state`), translated into OpenCode v2
- * Provider/Model shapes, cached for the adapter lifetime.
+ * Provider/Model shapes, refreshed from live agents or bounded cold reads.
  */
 import { PiRpcClient } from "./pi-rpc.js";
 import { thinkingVariants } from "./thinking-levels.js";
@@ -44,24 +44,95 @@ function toOCModel(m) {
         ...(variants !== undefined ? { variants } : {}),
     };
 }
-export async function loadCatalog(directory) {
-    const pi = new PiRpcClient({ cwd: directory, args: ["--no-session"] });
+function inventory(res) {
+    const providers = new Map();
+    if (res.success && res.data) {
+        for (const m of res.data.models) {
+            let p = providers.get(m.provider);
+            if (!p) {
+                p = { id: m.provider, name: m.provider, source: "config", env: [], options: {}, models: {} };
+                providers.set(m.provider, p);
+            }
+            p.models[m.id] = toOCModel(m);
+        }
+    }
+    return providers;
+}
+/**
+ * Apply the default to the inventory: list it even if get_available_models omitted it (the client drops a
+ * selection it cannot find), and put it first, because OpenChamber's picker defaults to the first listed
+ * provider/model. `active` is a model from a fresh agent's get_state, or the previous snapshot's default.
+ */
+function withDefault(providers, active, thinkingLevel) {
+    const defaults = {};
+    if (active !== null) {
+        defaults[active.providerID] = active.modelID;
+        let p = providers.get(active.providerID);
+        if (p === undefined) {
+            p = { id: active.providerID, name: active.providerID, source: "config", env: [], options: {}, models: {} };
+            providers.set(active.providerID, p);
+        }
+        if (p.models[active.modelID] === undefined)
+            p.models[active.modelID] = active.model;
+    }
+    const sorted = [...providers.values()].sort((a, b) => {
+        const aDef = defaults[a.id] !== undefined ? 0 : 1;
+        const bDef = defaults[b.id] !== undefined ? 0 : 1;
+        return aDef - bDef;
+    });
+    for (const p of sorted) {
+        const def = defaults[p.id];
+        if (!def)
+            continue;
+        const entries = Object.entries(p.models).sort(([a], [b]) => (a === def ? -1 : b === def ? 1 : 0));
+        p.models = Object.fromEntries(entries);
+    }
+    // exactOptionalPropertyTypes: omit `default` rather than set it undefined.
+    if (active === null)
+        return { providers: sorted, defaults };
+    const resolvedDefault = { providerID: active.providerID, modelID: active.modelID };
+    // Only a level the catalog offers as a variant is selectable in the picker.
+    const offered = sorted.find((p) => p.id === active.providerID)?.models[active.modelID]?.variants;
+    return thinkingLevel !== undefined && offered?.[thinkingLevel] !== undefined
+        ? { providers: sorted, defaults, default: resolvedDefault, defaultThinkingLevel: thinkingLevel }
+        : { providers: sorted, defaults, default: resolvedDefault };
+}
+/**
+ * The configured default plus the provider/model inventory in a fixed order, so a reordering alone is not
+ * reported as a catalog change but a new default is.
+ */
+export function catalogFingerprint(catalog) {
+    return JSON.stringify([
+        catalog.default ?? null,
+        catalog.defaultThinkingLevel ?? null,
+        [...catalog.providers]
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map((p) => [
+            p.id,
+            Object.keys(p.models)
+                .sort()
+                .map((id) => [id, p.models[id]]),
+        ]),
+    ]);
+}
+/**
+ * `configured` is the previous snapshot when `client` is a live session's agent: that agent's `get_state.model`
+ * is the session's own selection, not the configured default, so only the model inventory is re-read and the
+ * snapshot's default is kept. Only a fresh `--no-session` agent defines the default.
+ */
+export async function loadCatalog(directory, client, configured) {
+    const pi = client ?? new PiRpcClient({ cwd: directory, args: ["--no-session"] });
     try {
+        if (configured !== undefined) {
+            const modelsRes = await pi.command({ type: "get_available_models" });
+            const def = configured.default;
+            const model = def && configured.providers.find((p) => p.id === def.providerID)?.models[def.modelID];
+            return withDefault(inventory(modelsRes), def && model ? { ...def, model } : null, configured.defaultThinkingLevel);
+        }
         const [modelsRes, firstState] = await Promise.all([
             pi.command({ type: "get_available_models" }),
             pi.command({ type: "get_state" }),
         ]);
-        const providers = new Map();
-        if (modelsRes.success && modelsRes.data) {
-            for (const m of modelsRes.data.models) {
-                let p = providers.get(m.provider);
-                if (!p) {
-                    p = { id: m.provider, name: m.provider, source: "config", env: [], options: {}, models: {} };
-                    providers.set(m.provider, p);
-                }
-                p.models[m.id] = toOCModel(m);
-            }
-        }
         // get_state occasionally races pi's own startup. One retry beats resolving
         // no active model, which is precisely what leaves the UI picker guessing.
         let active = firstState.success ? (firstState.data?.model ?? null) : null;
@@ -74,45 +145,10 @@ export async function loadCatalog(directory) {
         if (active === null) {
             console.error("[catalog] warning: pi reported no active model — /api/model/default will be null and the UI picker falls back to its own default");
         }
-        const defaults = {};
-        let resolvedDefault;
-        if (active !== null) {
-            defaults[active.provider] = active.id;
-            resolvedDefault = { providerID: active.provider, modelID: active.id };
-            // The client drops any selection it cannot find in this catalog and picks
-            // something else instead, so a model get_available_models omitted still
-            // has to be listed here — otherwise the active model is unselectable.
-            let p = providers.get(active.provider);
-            if (p === undefined) {
-                p = { id: active.provider, name: active.provider, source: "config", env: [], options: {}, models: {} };
-                providers.set(active.provider, p);
-            }
-            if (p.models[active.id] === undefined)
-                p.models[active.id] = toOCModel(active);
-        }
-        // OpenChamber's picker defaults to the first listed provider/model — put pi's active config there.
-        const sorted = [...providers.values()].sort((a, b) => {
-            const aDef = defaults[a.id] !== undefined ? 0 : 1;
-            const bDef = defaults[b.id] !== undefined ? 0 : 1;
-            return aDef - bDef;
-        });
-        for (const p of sorted) {
-            const def = defaults[p.id];
-            if (!def)
-                continue;
-            const entries = Object.entries(p.models).sort(([a], [b]) => (a === def ? -1 : b === def ? 1 : 0));
-            p.models = Object.fromEntries(entries);
-        }
-        // exactOptionalPropertyTypes: omit `default` rather than set it undefined.
-        if (resolvedDefault === undefined)
-            return { providers: sorted, defaults };
-        // Only a level the catalog offers as a variant is selectable in the picker.
-        const offered = sorted.find((p) => p.id === resolvedDefault.providerID)?.models[resolvedDefault.modelID]?.variants;
-        return thinkingLevel !== undefined && offered?.[thinkingLevel] !== undefined
-            ? { providers: sorted, defaults, default: resolvedDefault, defaultThinkingLevel: thinkingLevel }
-            : { providers: sorted, defaults, default: resolvedDefault };
+        return withDefault(inventory(modelsRes), active === null ? null : { providerID: active.provider, modelID: active.id, model: toOCModel(active) }, thinkingLevel);
     }
     finally {
-        await pi.dispose();
+        if (client === undefined)
+            await pi.dispose();
     }
 }

package/dist/file-watch.d.ts

@@ -0,0 +1,35 @@
+import type { OCEvent } from "./types.js";
+export declare class FileWatchError extends Error {
+    readonly status: number;
+    readonly kind: string;
+    constructor(status: number, kind: string, message: string);
+}
+export declare class FileWatchRegistry {
+    private emit;
+    private watches;
+    constructor(emit: (directory: string, event: OCEvent) => void);
+    file(directory: string, path: string, required: boolean): Promise<string>;
+    watch(directory: string, file: string, reportedFile: string): void;
+    /**
+     * Watch the file itself, not its directory: on macOS a directory watch goes through FSEvents, which starts
+     * asynchronously and under load missed a write made right after the 204, and missed a delete-and-recreate for
+     * seconds (reproduced: every run failed with eight test processes in parallel). A file watch (kqueue there,
+     * inotify on Linux) starts within a tick. An editor's atomic save replaces the inode and ends the watch with
+     * "rename"; the replacement is watched. A removed file keeps its lease, as OpenCode's does: a stat watch looks for
+     * it until it exists again, then the native watch resumes.
+     */
+    private armFile;
+    /**
+     * Check for the missing file on a timer. Not fs.watchFile: it takes its baseline stat asynchronously and never
+     * reports a file that came back before that stat finished.
+     */
+    private awaitFile;
+    /**
+     * Runs inside a watch listener, where a throw would end the process: fs.watch throws synchronously for a
+     * replacement it cannot open (EACCES, a file gone again, ENOSPC/EMFILE). Such a lease is released instead.
+     */
+    private rearm;
+    private release;
+    unwatch(directory: string, file: string): void;
+    close(): void;
+}

package/dist/file-watch.js

@@ -0,0 +1,163 @@
+import { existsSync, watch } from "node:fs";
+import { realpath, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+export class FileWatchError extends Error {
+    status;
+    kind;
+    constructor(status, kind, message) {
+        super(message);
+        this.status = status;
+        this.kind = kind;
+    }
+}
+const LEASE_MS = 24 * 60 * 60 * 1000;
+const MAX_PER_DIRECTORY = 256;
+/** How often a missing watched file is checked for (existsSync, nothing spawned). */
+const MISSING_POLL_MS = 1000;
+export class FileWatchRegistry {
+    emit;
+    watches = new Map();
+    constructor(emit) {
+        this.emit = emit;
+    }
+    async file(directory, path, required) {
+        const root = await realpath(directory);
+        const target = resolve(root, path);
+        const inside = relative(root, target);
+        if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside))
+            throw new FileWatchError(400, "BadRequestError", "Path must remain inside the selected directory");
+        // Removal uses the registered path even when the file or symlink no longer exists.
+        if (!required)
+            return resolve(directory, path);
+        try {
+            const canonical = await realpath(target);
+            const rel = relative(root, canonical);
+            if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+                throw new FileWatchError(400, "BadRequestError", "Path must remain inside the selected directory");
+            if (!(await stat(canonical)).isFile())
+                throw new FileWatchError(404, "FileNotFoundError", `File not found: ${path}`);
+            return canonical;
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                throw new FileWatchError(404, "FileNotFoundError", `File not found: ${path}`);
+            throw error;
+        }
+    }
+    watch(directory, file, reportedFile) {
+        const files = this.watches.get(directory) ?? new Map();
+        const existing = files.get(reportedFile);
+        if (existing !== undefined) {
+            existing.expires = Date.now() + LEASE_MS;
+            clearTimeout(existing.timer);
+            existing.timer = setTimeout(() => this.unwatch(directory, reportedFile), LEASE_MS);
+            existing.timer.unref();
+            return;
+        }
+        if (files.size >= MAX_PER_DIRECTORY) {
+            const [soonest] = [...files].reduce((a, b) => (b[1].expires < a[1].expires ? b : a));
+            this.unwatch(directory, soonest);
+        }
+        const timer = setTimeout(() => this.unwatch(directory, reportedFile), LEASE_MS);
+        timer.unref();
+        const lease = { watcher: null, missing: null, expires: Date.now() + LEASE_MS, timer };
+        files.set(reportedFile, lease);
+        this.watches.set(directory, files);
+        lease.watcher = this.armFile(directory, file, reportedFile);
+    }
+    /**
+     * Watch the file itself, not its directory: on macOS a directory watch goes through FSEvents, which starts
+     * asynchronously and under load missed a write made right after the 204, and missed a delete-and-recreate for
+     * seconds (reproduced: every run failed with eight test processes in parallel). A file watch (kqueue there,
+     * inotify on Linux) starts within a tick. An editor's atomic save replaces the inode and ends the watch with
+     * "rename"; the replacement is watched. A removed file keeps its lease, as OpenCode's does: a stat watch looks for
+     * it until it exists again, then the native watch resumes.
+     */
+    armFile(directory, file, reportedFile) {
+        const watcher = watch(file, (event) => {
+            const exists = existsSync(file);
+            this.emit(directory, {
+                type: "filesystem.changed",
+                properties: { file: reportedFile, event: exists ? "change" : "unlink" },
+            });
+            const lease = this.watches.get(directory)?.get(reportedFile);
+            // A rename replaced the inode; an absent file ended the watch, whatever the event (macOS reports a write and
+            // a delete arriving together as one "change").
+            if (lease?.watcher !== watcher || (exists && event !== "rename"))
+                return;
+            watcher.close();
+            lease.watcher = null;
+            if (exists)
+                this.rearm(directory, file, reportedFile, lease);
+            else
+                this.awaitFile(directory, file, reportedFile, lease);
+        });
+        watcher.on("error", () => {
+            if (this.watches.get(directory)?.get(reportedFile)?.watcher === watcher)
+                this.unwatch(directory, reportedFile);
+            else
+                watcher.close();
+        });
+        return watcher;
+    }
+    /**
+     * Check for the missing file on a timer. Not fs.watchFile: it takes its baseline stat asynchronously and never
+     * reports a file that came back before that stat finished.
+     */
+    awaitFile(directory, file, reportedFile, lease) {
+        const check = () => {
+            if (!existsSync(file) || this.watches.get(directory)?.get(reportedFile) !== lease)
+                return;
+            if (lease.missing !== null)
+                clearInterval(lease.missing);
+            lease.missing = null;
+            this.emit(directory, { type: "filesystem.changed", properties: { file: reportedFile, event: "change" } });
+            this.rearm(directory, file, reportedFile, lease);
+        };
+        lease.missing = setInterval(check, MISSING_POLL_MS);
+        lease.missing.unref();
+        check();
+    }
+    /**
+     * Runs inside a watch listener, where a throw would end the process: fs.watch throws synchronously for a
+     * replacement it cannot open (EACCES, a file gone again, ENOSPC/EMFILE). Such a lease is released instead.
+     */
+    rearm(directory, file, reportedFile, lease) {
+        try {
+            lease.watcher = this.armFile(directory, file, reportedFile);
+        }
+        catch (error) {
+            // Gone again between the check and the watch: keep the lease and wait for it once more.
+            if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+                this.awaitFile(directory, file, reportedFile, lease);
+                return;
+            }
+            console.error(`[file-watch] stopped watching ${reportedFile}:`, error);
+            this.unwatch(directory, reportedFile);
+        }
+    }
+    release(lease) {
+        clearTimeout(lease.timer);
+        lease.watcher?.close();
+        if (lease.missing !== null)
+            clearInterval(lease.missing);
+    }
+    unwatch(directory, file) {
+        const files = this.watches.get(directory);
+        const entry = files?.get(file);
+        if (entry === undefined)
+            return;
+        this.release(entry);
+        files?.delete(file);
+        if (files?.size === 0)
+            this.watches.delete(directory);
+    }
+    close() {
+        for (const files of this.watches.values()) {
+            for (const entry of files.values()) {
+                this.release(entry);
+            }
+        }
+        this.watches.clear();
+    }
+}

package/dist/misc-routes.js

@@ -93,6 +93,7 @@ export async function miscRoute(method, path, url, directory) {
     const dirs = url.searchParams.get("dirs") !== "false" && url.searchParams.get("type") !== "file";
     const onlyDirs = url.searchParams.get("type") === "directory";
     const files = [];
+    const matchedDirs = new Set();
     let visited = 0;
     const lowerQuery = query.toLowerCase();
     async function visit(directory, depth) {
@@ -107,12 +108,21 @@ export async function miscRoute(method, path, url, directory) {
                 continue;
             const absolute = resolve(directory, entry.name);
             const path = relative(root, absolute).split(sep).join("/");
+            if (onlyDirs && entry.isFile() && path.toLowerCase().includes(lowerQuery)) {
+                matchedDirs.add("/");
+                const segments = path.split("/");
+                for (let i = 1; i < segments.length; i++)
+                    matchedDirs.add(`${segments.slice(0, i).join("/")}/`);
+            }
             if (((entry.isFile() && !onlyDirs) || (entry.isDirectory() && dirs)) && path.toLowerCase().includes(lowerQuery))
-                files.push(path);
+                if (onlyDirs)
+                    matchedDirs.add(`${path}/`);
+                else
+                    files.push(path);
             if (entry.isDirectory() && entry.name !== "node_modules")
                 await visit(absolute, depth + 1);
         }
     }
     await visit(root, 0);
-    return { status: 200, body: files.sort() };
+    return { status: 200, body: onlyDirs ? [...matchedDirs].sort().slice(0, limit) : files.sort() };
 }

package/dist/pi-event-translation.js

@@ -202,6 +202,24 @@ export class PiEventTranslator {
         }
         delete s.compactingFromIdle;
         delete s.info.time.compacting;
+        // A compaction the run never finished must not stay "running": a later Compact would join it and report
+        // success for work that will never happen.
+        if (s.compactionID !== undefined) {
+            const inputID = s.compactionID;
+            const reason = s.compactionReason ?? "manual";
+            delete s.compactionID;
+            delete s.compactionReason;
+            delete s.heldCompactionEnd;
+            this.services.emit(s.info.directory, {
+                type: "session.compaction.failed",
+                properties: {
+                    sessionID: s.info.id,
+                    inputID,
+                    reason,
+                    error: { name: "CompactionError", data: { message: error.data.message } },
+                },
+            });
+        }
     }
     setStatus(s, status) {
         s.status = status;
@@ -211,6 +229,14 @@ export class PiEventTranslator {
         });
         if (status.type === "idle") {
             s.info.time.idle = Date.now();
+            // Restored as time.idle after a restart, so /view can still accept the watermark a client saw.
+            s.tree.lastIdle = s.info.time.idle;
+            try {
+                this.services.persistMeta(s);
+            }
+            catch (error) {
+                console.error(`[session] could not save the idle time of ${s.info.id}:`, error);
+            }
             const last = s.messages?.findLast((message) => message.info.role === "assistant" && !message.info.id.startsWith("msg_background_"));
             s.info.outcome =
                 s.interruptRequested || (last?.info.role === "assistant" && last.info.error?.name === "MessageAbortedError")
@@ -323,6 +349,7 @@ export class PiEventTranslator {
                 this.onMessageEvent(s, ev);
                 break;
             case "compaction_start":
+            case "compaction_progress":
             case "compaction_end":
                 this.onCompactionEvent(s, ev);
                 break;
@@ -641,7 +668,8 @@ export class PiEventTranslator {
                 }
                 // An auto-compaction can fall between steps; its summary is a new step.
                 this.completeAwaitingTools(s);
-                s.compactionID = id("compaction");
+                s.compactionID ??= id("msg");
+                s.compactionReason = typeof ev.reason === "string" ? ev.reason : "manual";
                 this.services.emit(s.info.directory, {
                     type: "session.compaction.started",
                     properties: {
@@ -658,6 +686,15 @@ export class PiEventTranslator {
                     this.setStatus(s, { type: "busy" });
                 }
                 return;
+            case "compaction_progress":
+                // Extension compaction feedback carries actual partial summary fragments
+                // (senpi/dist/core/agent-session.js _updateExtensionCompactionFeedback).
+                if (s.compactionID !== undefined && typeof ev.delta === "string" && ev.delta !== "")
+                    this.services.emit(s.info.directory, {
+                        type: "session.compaction.delta",
+                        properties: { sessionID: s.info.id, text: ev.delta },
+                    });
+                return;
             case "compaction_end": {
                 const retry = s.compactRetry;
                 if (ev.aborted === true && retry !== undefined && retry.left > 0 && (s.abortRequests ?? 0) === retry.aborts) {
@@ -666,8 +703,9 @@ export class PiEventTranslator {
                 }
                 delete s.info.time.compacting;
                 const result = ev.result;
-                const inputID = s.compactionID ?? id("compaction");
+                const inputID = s.compactionID ?? id("msg");
                 delete s.compactionID;
+                delete s.compactionReason;
                 this.services.emit(s.info.directory, ev.aborted === true || typeof result?.summary !== "string"
                     ? {
                         type: "session.compaction.failed",
@@ -702,6 +740,10 @@ export class PiEventTranslator {
                                 key = entry.id;
                         }
                     }
+                    if (key !== undefined) {
+                        s.tree.messageEntries[inputID] ??= key;
+                        (s.tree.compactionReasons ??= {})[key] = ev.reason === "manual" ? "manual" : "auto";
+                    }
                     for (const message of compactionMessages(s, key ?? id("compaction"), result.summary, Date.now(), s.model, s.thinkingLevel)) {
                         if (messages.some((item) => item.info.id === message.info.id))
                             continue;

package/dist/route-services.d.ts

@@ -6,14 +6,21 @@ import type { ModelSelection } from "./thinking-levels.js";
 import type { OCEvent, OCMessageWithParts, OCPromptPart } from "./types.js";
 import type { TodoUpdated } from "./todo-bridge.js";
 import type { SelfUpdateResult } from "./self-update.js";
+import type { FileWatchRegistry } from "./file-watch.js";
+import type { getCommands } from "./session-commands.js";
+import type { TextGeneration } from "./text-generation.js";
 export interface RouteServices {
     readonly sessions: SessionManager;
     readonly defaultDirectory: string;
     readonly url: string;
     readonly body: (req: IncomingMessage) => Promise<unknown>;
-    readonly catalog: () => Promise<Catalog>;
+    readonly catalog: (directory?: string, refresh?: boolean) => Promise<Catalog>;
     readonly broadcast: (directory: string, event: OCEvent | TodoUpdated) => void;
     readonly selfUpdate: () => Promise<SelfUpdateResult>;
+    readonly fileWatches: FileWatchRegistry;
+    readonly commands: (directory: string) => ReturnType<typeof getCommands>;
+    readonly vcsBranch: (directory: string) => Promise<string | undefined>;
+    readonly textGeneration: TextGeneration;
 }
 export declare const OPENCODE_COMPAT_VERSION: string | null;
 export declare function numberParam(value: string | null): number | undefined;