antechamber 1.0.13 → 1.0.15

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.15] - 2026-10-23
+
+### Fixed
+
+- Stop reaping a session while detached eval cells are still running: idle eviction killed the agent process and
+  every cell in its kernels once the session had been quiet for `ANTECHAMBER_IDLE_TIMEOUT_MS`. A session now stays
+  live while senpi-codemode reports detached cells, and its idle window restarts when the last one settles.
+
+## [1.0.14] - 2026-10-22
+
+### Fixed
+
+- Preselect OmO's real effort in OpenChamber 2.x instead of "Default": `/api/agent` now nests the agent's
+  default model and level as `model: {id, providerID, variant}`, and a reopened session reports the model and
+  level OmO will resume it with, read from its session file, instead of `variant: "default"`.
+
 ## [1.0.13] - 2026-10-22
 
 ### Fixed

package/dist/lifecycle.js

@@ -56,6 +56,7 @@ export class SessionLifecycle {
             !s.hasPendingInteraction() &&
             !s.hasRunningChildren() &&
             !s.hasBackgroundWork?.() &&
+            !s.hasWakeSources?.() &&
             s.piSessionId !== undefined &&
             s.piPath !== undefined);
     }

package/dist/routes-v2.js

@@ -16,9 +16,13 @@ import { announceSessionError, compactSession, getCommands, unsupportedShare } f
 import { defaultV2Model, flattenModels, toV2Message, toV2Session } from "./v2.js";
 import { agentDescriptors, modelRefFromBody, numberParam, OPENCODE_COMPAT_VERSION, promptAsync, runSessionShell, runSessionSlash, sessionDirectory, sessionMetadata, } from "./route-services.js";
 async function v2Agents(services) {
-    return (await agentDescriptors(services)).map((agent) => ({
+    return (await agentDescriptors(services)).map(({ model, variant, ...agent }) => ({
         id: agent.name,
         ...agent,
+        // v2 nests the effort in the agent's ModelRef; OpenChamber 2.x preselects only `model.id` + `model.variant`.
+        ...(model !== undefined
+            ? { model: { id: model.modelID, providerID: model.providerID, ...(variant !== undefined ? { variant } : {}) } }
+            : {}),
         request: { settings: {}, headers: {}, body: {} },
         permissions: agent.permission.map((rule) => ({
             action: rule.permission,

package/dist/session-store.d.ts

@@ -19,8 +19,16 @@ import type { ChildTask } from "./subagents.js";
 export declare function piSessionDir(cwd: string): string;
 /** Deterministic OpenChamber session id for a pi session id. */
 export declare function ocIdFor(piSessionId: string): string;
+/** The model and thinking level OmO resumes a session file with. */
+export interface SessionSelection {
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    thinkingLevel?: string;
+}
 /** One *.jsonl discovered on disk, not (yet) backed by a live pi process. */
-export interface ScannedSession {
+export interface ScannedSession extends SessionSelection {
     piSessionId: string;
     piPath: string;
     directory: string;
@@ -66,12 +74,13 @@ export interface SessionRegistryEntry {
 export declare class SessionPersistenceError extends Error {
     constructor(file: string, cause: unknown);
 }
-/** Native renames append anywhere in the transcript; directory mtimes do not change. */
-export declare function readSessionTitle(piPath: string, piSessionId: string): {
+interface SessionFileMeta extends SessionSelection {
     title: string;
     fallbackTitle: string;
     titleSource: TitleSource;
-};
+}
+/** Native renames and model/thinking changes append anywhere in the transcript; directory mtimes do not change. */
+export declare function readSessionFileMeta(piPath: string, piSessionId: string): SessionFileMeta;
 /**
  * Newest mtime across the sessions root and its per-cwd subdirectories. Cache
  * key for {@link scanAllPiSessions}: a new session file bumps its own cwd
@@ -114,3 +123,4 @@ export declare class SessionStore {
     /** Every directory the registry knows about — used to resolve bare session ids. */
     directories(): string[];
 }
+export {};

package/dist/session-store.js

@@ -84,16 +84,97 @@ function titleFromHead(head, piSessionId) {
     }
     return `pi session ${piSessionId.slice(0, 8)}`;
 }
-const titleCache = new Map();
-/** Native renames append anywhere in the transcript; directory mtimes do not change. */
-export function readSessionTitle(piPath, piSessionId) {
+function modelRef(provider, modelID) {
+    return typeof provider === "string" && provider !== "" && typeof modelID === "string" && modelID !== ""
+        ? { providerID: provider, modelID }
+        : undefined;
+}
+function selectionStep(entry) {
+    if (entry.type === "thinking_level_change")
+        return { kind: "thinking", level: typeof entry.thinkingLevel === "string" ? entry.thinkingLevel : undefined };
+    if (entry.type === "model_change")
+        return {
+            kind: "model",
+            reason: entry.reason,
+            model: modelRef(entry.provider, entry.modelId),
+            original: modelRef(entry.originalProvider, entry.originalModelId),
+        };
+    const message = entry.message;
+    // A failed routing attempt names the virtual model; no model answered it.
+    if (entry.type !== "message" || message?.role !== "assistant" || message.api === "pi-virtual")
+        return undefined;
+    const model = modelRef(message.provider, message.model);
+    return model === undefined ? undefined : { kind: "reply", model };
+}
+/**
+ * OmO resumes at the file's last entry and resolves the model and level along its path, restoring the
+ * pre-fallback model and level across a fallback window. Mirrors senpi's getSessionContextSettings
+ * (dist/core/session-manager.js), except that legacy provider ids are not normalized.
+ */
+function resumeSelection(byId, leafId) {
+    const path = [];
+    const seen = new Set();
+    for (let id = leafId; id !== undefined && !seen.has(id);) {
+        const entry = byId.get(id);
+        if (entry === undefined)
+            break;
+        seen.add(id);
+        if (entry.step !== undefined)
+            path.push(entry.step);
+        id = entry.parentId ?? undefined;
+    }
+    let model;
+    let explicit = false;
+    let inFallback = false;
+    let level;
+    let preFallbackLevel;
+    for (const step of path.reverse()) {
+        if (step.kind === "thinking")
+            level = step.level;
+        else if (step.kind === "model" && step.reason === "fallback") {
+            if (!inFallback) {
+                preFallbackLevel = level;
+                if (step.original !== undefined) {
+                    model = step.original;
+                    explicit = true;
+                }
+            }
+            inFallback = true;
+        }
+        else if (step.kind === "model" && step.reason === "fallback-revert") {
+            if (inFallback)
+                level = preFallbackLevel;
+            inFallback = false;
+        }
+        else if (step.kind === "model") {
+            inFallback = false;
+            if (step.model !== undefined) {
+                model = step.model;
+                explicit = true;
+            }
+        }
+        else if (!inFallback && !(explicit && model?.providerID === step.model.providerID)) {
+            // A reply echoes the wire id; only a reply from another provider overrides an explicit pick.
+            model = step.model;
+            explicit = false;
+        }
+    }
+    if (inFallback)
+        level = preFallbackLevel;
+    return { ...(model !== undefined ? { model } : {}), ...(level !== undefined ? { thinkingLevel: level } : {}) };
+}
+const fileMetaCache = new Map();
+/** Native renames and model/thinking changes append anywhere in the transcript; directory mtimes do not change. */
+export function readSessionFileMeta(piPath, piSessionId) {
     const stat = statSync(piPath);
-    const cached = titleCache.get(piPath);
+    const cached = fileMetaCache.get(piPath);
     if (cached?.mtimeMs === stat.mtimeMs && cached.size === stat.size)
         return cached;
     const raw = readFileSync(piPath, "utf8");
     const fallbackTitle = titleFromHead(raw, piSessionId);
     let native;
+    const byId = new Map();
+    let leafId;
     for (const line of raw.split("\n")) {
         try {
             const entry = JSON.parse(line);
@@ -102,6 +183,14 @@ export function readSessionTitle(piPath, piSessionId) {
                 if (name !== "")
                     native = name;
             }
+            if (entry?.type !== "session" && typeof entry?.id === "string") {
+                const step = selectionStep(entry);
+                byId.set(entry.id, {
+                    parentId: typeof entry.parentId === "string" ? entry.parentId : null,
+                    ...(step !== undefined ? { step } : {}),
+                });
+                leafId = entry.id;
+            }
         }
         catch {
             // Partial trailing writes do not erase the last valid title.
@@ -113,8 +202,9 @@ export function readSessionTitle(piPath, piSessionId) {
         title: native ?? fallbackTitle,
         fallbackTitle,
         titleSource: native === undefined ? "fallback" : "native",
+        ...resumeSelection(byId, leafId),
     };
-    titleCache.set(piPath, metadata);
+    fileMetaCache.set(piPath, metadata);
     return metadata;
 }
 function parseSessionHeader(head) {
@@ -146,7 +236,7 @@ function buildScanned(piPath, directory, header) {
         piSessionId,
         piPath,
         directory,
-        ...readSessionTitle(piPath, piSessionId),
+        ...readSessionFileMeta(piPath, piSessionId),
         created: Number.isNaN(created) ? Math.floor(updated) : created,
         updated: Math.floor(updated),
     };

package/dist/sessions.d.ts

@@ -73,6 +73,8 @@ export interface ManagedSession extends ThinkingState {
     hasRunningChildren: () => boolean;
     /** Live OmO background work (monitors) that keeps the agent process from idle eviction. */
     hasBackgroundWork?: () => boolean;
+    /** Live wake sources OmO publishes over RPC (detached eval cells), which also block idle eviction. */
+    hasWakeSources?: () => boolean;
 }
 type EventSink = (directory: string, event: OCEvent | TodoUpdated) => void;
 export declare class SessionManager {

package/dist/sessions.js

@@ -20,7 +20,7 @@ import { MonitorSessions } from "./monitor-sessions.js";
 import { WorkStatusBridge } from "./work-status.js";
 import { sessionDiff } from "./session-diff.js";
 import { announceSessionNotice, skillCommandText, slashTitlePrompt } from "./session-commands.js";
-import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionTitle, } from "./session-store.js";
+import { ocIdFor, piSessionDir, piSessionsRootMtime, scanAllPiSessions, scanPiSessions, SessionStore, readSessionFileMeta, } from "./session-store.js";
 import { ADAPTER_VERSION } from "./version.js";
 export { ADAPTER_VERSION } from "./version.js";
 const SESSION_SCAN_CACHE_TTL_MS = 5_000;
@@ -30,6 +30,21 @@ const SESSION_TITLE_MAX_CHARS = 60;
 /** OmO's reply when a compaction is aborted (`CompactionCancelledError`). */
 const OMO_COMPACTION_CANCELLED = "Compaction cancelled";
 const COMPACT_CANCEL_RETRIES = 2;
+/**
+ * A dormant session's record as OmO will resume it. OpenChamber 2.x restores a reopened session's effort
+ * from this record and resends it, so the model and level come together from the file; the registry only
+ * fills in when the file records no model.
+ */
+function dormantModel(file, registry) {
+    if (file.model !== undefined)
+        return { model: file.model, variant: file.thinkingLevel ?? "default" };
+    if (registry === undefined)
+        return undefined;
+    return {
+        model: { providerID: registry.providerID, modelID: registry.modelID },
+        variant: registry.variant ?? "default",
+    };
+}
 export class SessionManager {
     emit;
     defaultDirectory;
@@ -134,6 +149,7 @@ export class SessionManager {
             published = true;
             this.subagents.wire(managed);
             this.monitors.wire(managed);
+            this.workStatus.wire(managed);
             this.lifecycle.touch(managed);
             this.wirePi(managed, pi);
             if (options.model !== undefined)
@@ -215,9 +231,15 @@ export class SessionManager {
     refreshNativeTitle(s) {
         if (s.pi !== undefined || s.restored === undefined || !existsSync(s.restored.piPath))
             return;
-        const metadata = readSessionTitle(s.restored.piPath, s.restored.piSessionId);
+        const metadata = readSessionFileMeta(s.restored.piPath, s.restored.piSessionId);
         if (metadata.titleSource === "native")
             this.applyNativeTitle(s, metadata.title);
+        // Not revived here yet, so nothing cached overrides what OmO will resume with, which another client may change.
+        const resumed = s.thinkingLevel === undefined ? dormantModel(metadata, undefined) : undefined;
+        if (resumed !== undefined) {
+            s.model = resumed.model;
+            s.info.model = { id: resumed.model.modelID, providerID: resumed.model.providerID, variant: resumed.variant };
+        }
     }
     wirePi(s, pi) {
         s.unwirePi?.();
@@ -1218,6 +1240,7 @@ export class SessionManager {
             s.piPath = restored.piPath;
             s.piSessionId = restored.piSessionId;
             this.applyPiModel(s, state.data.model?.provider, state.data.model?.id);
+            this.syncRecordVariant(s);
             this.refreshMessageCache(s);
             this.persistMeta(s);
             delete s.restored;
@@ -1346,6 +1369,7 @@ export class SessionManager {
         const titleSource = reg?.titleSource ??
             (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 info = {
             id: ocId,
             projectID: sc.directory,
@@ -1359,9 +1383,9 @@ export class SessionManager {
             ...(reg?.metadata !== undefined ? { metadata: reg.metadata } : {}),
             ...(reg?.parentID !== undefined ? { parentID: reg.parentID } : {}),
             ...(reg?.parentMessageID !== undefined ? { parentMessageID: reg.parentMessageID } : {}),
-            ...(reg?.model !== undefined
+            ...(resumed !== undefined
                 ? {
-                    model: { id: reg.model.modelID, providerID: reg.model.providerID, variant: reg.model.variant ?? "default" },
+                    model: { id: resumed.model.modelID, providerID: resumed.model.providerID, variant: resumed.variant },
                 }
                 : {}),
             ...(reg?.tree?.revert ? { revert: { messageID: reg.tree.revert.messageID } } : {}),
@@ -1379,7 +1403,7 @@ export class SessionManager {
             pi: undefined,
             messages: undefined,
             status: { type: "idle" },
-            model: reg?.model !== undefined ? { providerID: reg.model.providerID, modelID: reg.model.modelID } : undefined,
+            model: resumed?.model,
             streaming: undefined,
             toolByCallId: new Map(),
             restored: { piSessionId: sc.piSessionId, piPath: sc.piPath },
@@ -1391,6 +1415,7 @@ export class SessionManager {
             this.createdSessions.set(sc.piSessionId, sc.directory);
         this.subagents.wire(managed);
         this.monitors.wire(managed);
+        this.workStatus.wire(managed);
         return managed;
     }
     /** Resolve a bare session id (e.g. deep link after restart) via known directories. */
@@ -1403,7 +1428,7 @@ export class SessionManager {
                 piSessionId: reg.piSessionId,
                 piPath: reg.piPath,
                 directory: reg.directory,
-                ...readSessionTitle(reg.piPath, reg.piSessionId),
+                ...readSessionFileMeta(reg.piPath, reg.piSessionId),
                 created: reg.created,
                 updated: reg.updated,
             });

package/dist/work-status.d.ts

@@ -70,6 +70,8 @@ export declare class WorkStatusBridge {
     private readonly work;
     constructor(monitors: MonitorSessions);
     private state;
+    /** Evicting the agent process would kill its detached eval cells, so a live wake source keeps it. */
+    wire(s: ManagedSession): void;
     observe(s: ManagedSession, ev: Record<string, unknown>): void;
     /** The agent process exited: its in-process wake sources and timers died with it. */
     stopParent(sessionID: string): void;

package/dist/work-status.js

@@ -138,6 +138,10 @@ export class WorkStatusBridge {
         }
         return work;
     }
+    /** Evicting the agent process would kill its detached eval cells, so a live wake source keeps it. */
+    wire(s) {
+        s.hasWakeSources = () => (this.work.get(s.info.id)?.wakeSources.size ?? 0) > 0;
+    }
     observe(s, ev) {
         if (ev.name === WAKE_SOURCE_STATE_EVENT) {
             const source = parseWakeSource(ev.data);

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "OpenChamber extension: displays OmO tool calls the way OmO means them when OpenChamber runs on antechamber",
   "private": true,
   "type": "module",

package/extensions/omo-dag/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-graph",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "OpenChamber extension: live, interactive graph of the OmO sub-agents behind the current session",
   "private": true,
   "type": "module",

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "OpenChamber 2.x Work Status section: OmO todo phases, monitors, eval cells and background work of the current session",
   "private": true,
   "type": "module",

package/package.json

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