antechamber 1.0.41 → 2.0.1

package/dist/session-store.d.ts

@@ -6,7 +6,7 @@
  * so the adapter never needs its own transcript store — only:
  *
  *   1. a scan of that directory to rebuild the sidebar after a restart, and
- *   2. a small registry JSON for adapter-owned metadata that pi does not
+ *   2. a SQLite registry for adapter-owned metadata that pi does not
  *      keep (titles, conversation cursors and child-task metadata).
  *
  * OpenChamber session ids for restored sessions are derived deterministically
@@ -111,23 +111,25 @@ export declare function scanPiSessions(directory: string): ScannedSession[];
 export declare class SessionStore {
     readonly stateDir: string;
     private readonly file;
-    private entries;
-    /** The registry bytes `entries` was parsed from or last written as; equal bytes on disk mean the cache is current. */
-    private raw;
+    private db;
+    private version;
+    private readonly entries;
     private batchState;
     constructor(stateDir?: string);
-    private load;
-    private committed;
-    private readRaw;
-    private parseEntries;
-    private withRegistryLock;
+    private database;
+    private migrate;
+    private upsert;
+    private writeRow;
+    private refresh;
+    private read;
     private persist;
     private mutate;
-    /** Synchronous restoration reads its own changes, then merges them under one short-lived write lock. */
+    /** Stage only touched rows; replay partial updates against the latest rows under SQLite's write lock. */
     batch<T>(action: () => T): T;
     get(ocSessionId: string): SessionRegistryEntry | undefined;
     idFor(piSessionId: string): string | undefined;
     childIds(): string[];
+    private matching;
     set(ocSessionId: string, entry: SessionRegistryEntry): void;
     /** Merge a partial update (e.g. title override, updated timestamp). */
     update(ocSessionId: string, patch: Partial<SessionRegistryEntry>): void;

package/dist/session-store.js

@@ -6,7 +6,7 @@
  * so the adapter never needs its own transcript store — only:
  *
  *   1. a scan of that directory to rebuild the sidebar after a restart, and
- *   2. a small registry JSON for adapter-owned metadata that pi does not
+ *   2. a SQLite registry for adapter-owned metadata that pi does not
  *      keep (titles, conversation cursors and child-task metadata).
  *
  * OpenChamber session ids for restored sessions are derived deterministically
@@ -14,8 +14,9 @@
  * the same OpenChamber id, even if the registry file is lost.
  */
 import { createHash } from "node:crypto";
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, statSync, } from "node:fs";
 import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { piAgentDir } from "./agent-dir.js";
 import { isPromptPart } from "./prompt-parts.js";
 import { defaultStateDir, envSetting } from "./config.js";
@@ -42,9 +43,6 @@ const TITLE_MAX_LINES = 200;
 const TITLE_MAX_CHARS = 60;
 const REGISTRY_DIRECTORY_MODE = 0o700;
 const REGISTRY_FILE_MODE = 0o600;
-const REGISTRY_LOCK_RETRY_MS = 10;
-const REGISTRY_LOCK_STALE_MS = 5_000;
-const registryLockWaiter = new Int32Array(new SharedArrayBuffer(4));
 function readHead(path, bytes = SNIFF_BYTES) {
     const fd = openSync(path, "r");
     try {
@@ -359,7 +357,7 @@ export function scanPiSessions(directory) {
 }
 /**
  * Persistent oc-session-id → metadata registry (title overrides, known pi
- * paths). Atomic writes, lazy load, corrupt file degrades to an empty map.
+ * paths). Legacy JSON records are validated at migration; SQLite writes are atomic.
  */
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -512,140 +510,231 @@ function errorCode(error) {
 export class SessionStore {
     stateDir;
     file;
-    entries;
-    /** The registry bytes `entries` was parsed from or last written as; equal bytes on disk mean the cache is current. */
-    raw;
+    db;
+    version;
+    entries = new Map();
     batchState;
     constructor(stateDir) {
         const dir = stateDir ?? envSetting("STATE_DIR") ?? defaultStateDir();
         this.stateDir = dir;
-        this.file = join(dir, "sessions.json");
+        this.file = join(dir, "sessions.sqlite");
     }
-    load() {
-        if (this.batchState !== undefined) {
-            // Shallow: changes replace whole entries, and get() clones an entry before handing it out.
-            this.batchState.entries ??= new Map(this.committed());
-            return this.batchState.entries;
-        }
-        return this.committed();
-    }
-    committed() {
-        if (this.entries !== undefined)
-            return this.entries;
-        this.raw = this.readRaw();
-        this.entries = this.parseEntries(this.raw);
-        return this.entries;
-    }
-    readRaw() {
-        try {
-            return readFileSync(this.file);
-        }
-        catch {
+    database(write = false) {
+        if (this.db !== undefined)
+            return this.db;
+        const legacy = join(this.stateDir, "sessions.json");
+        if (!write && !existsSync(this.file) && !existsSync(legacy))
             return undefined;
-        }
-    }
-    parseEntries(raw) {
-        const entries = new Map();
-        if (raw === undefined)
-            return entries;
+        let db;
         try {
-            const parsed = JSON.parse(raw.toString("utf8"));
-            if (!record(parsed))
-                return entries;
-            for (const [id, value] of Object.entries(parsed))
-                if (registryEntry(value))
-                    entries.set(id, value);
+            mkdirSync(this.stateDir, { recursive: true, mode: REGISTRY_DIRECTORY_MODE });
+            chmodSync(this.stateDir, REGISTRY_DIRECTORY_MODE);
+            // SQLite inherits the database mode for WAL/SHM; set it before enabling WAL.
+            closeSync(openSync(this.file, "a", REGISTRY_FILE_MODE));
+            chmodSync(this.file, REGISTRY_FILE_MODE);
+            db = new DatabaseSync(this.file);
+            db.exec("PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL;");
+            db.exec(`CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY, payload TEXT NOT NULL, pi_session_id TEXT NOT NULL,
+        directory TEXT NOT NULL, parent_id TEXT, has_task INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS sessions_pi ON sessions(pi_session_id);
+      CREATE INDEX IF NOT EXISTS sessions_directory ON sessions(directory);
+      CREATE INDEX IF NOT EXISTS sessions_children ON sessions(parent_id) WHERE has_task = 1;
+      CREATE TABLE IF NOT EXISTS registry_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);`);
+            this.migrate(db, legacy);
+            for (const suffix of ["-wal", "-shm"]) {
+                const path = this.file + suffix;
+                if (existsSync(path))
+                    chmodSync(path, REGISTRY_FILE_MODE);
+            }
+            this.db = db;
+            return db;
         }
-        catch {
-            /* corrupt — start empty */
+        catch (error) {
+            db?.close();
+            throw new SessionPersistenceError(this.file, error);
         }
-        return entries;
     }
-    withRegistryLock(action) {
-        const lock = `${this.file}.lock`;
-        let fd;
+    migrate(db, legacy) {
+        const meta = (key) => db.prepare("SELECT value FROM registry_meta WHERE key = ?").get(key)?.value;
+        const setMeta = (key, value) => db
+            .prepare("INSERT INTO registry_meta VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value")
+            .run(key, value);
+        db.prepare("INSERT OR IGNORE INTO registry_meta VALUES ('created_at', ?)").run(String(Date.now()));
+        if (!existsSync(legacy))
+            return;
+        db.exec("BEGIN IMMEDIATE");
+        let backup;
+        let merged = 0;
         try {
-            mkdirSync(this.stateDir, { recursive: true, mode: REGISTRY_DIRECTORY_MODE });
-            chmodSync(this.stateDir, REGISTRY_DIRECTORY_MODE);
-            for (;;) {
+            const imported = meta("legacy_backup");
+            const parse = () => {
                 try {
-                    fd = openSync(lock, "wx", REGISTRY_FILE_MODE);
-                    break;
+                    const parsed = JSON.parse(readFileSync(legacy, "utf8"));
+                    return record(parsed) ? parsed : undefined;
                 }
                 catch (error) {
-                    if (errorCode(error) !== "EEXIST")
+                    if (!(error instanceof SyntaxError))
                         throw error;
-                    try {
-                        if (Date.now() - statSync(lock).mtimeMs >= REGISTRY_LOCK_STALE_MS) {
-                            unlinkSync(lock);
+                    // Preserve malformed JSON untouched; a later repair can still be imported.
+                    return undefined;
+                }
+            };
+            if (typeof imported === "string" && !existsSync(imported))
+                backup = imported;
+            else if (imported === undefined && db.prepare("SELECT 1 FROM sessions LIMIT 1").get() === undefined) {
+                const parsed = parse();
+                if (parsed !== undefined) {
+                    const upsert = this.upsert(db);
+                    for (const [id, entry] of Object.entries(parsed))
+                        if (registryEntry(entry))
+                            this.writeRow(upsert, id, entry);
+                    backup = `${legacy}.migrated-${Date.now()}-${process.pid}`;
+                    setMeta("legacy_backup", backup);
+                    setMeta("reconciled_at", String(Date.now()));
+                }
+            }
+            else {
+                // A sessions.json next to a populated registry was written by an older antechamber after the migration (a
+                // rollback). Sessions it changed since then are newer than the rows here; older entries, including ones
+                // deleted since, stay as the registry has them.
+                const since = Number(meta("reconciled_at") ?? /\.migrated-(\d+)-/.exec(String(imported))?.[1] ?? meta("created_at") ?? Infinity);
+                const parsed = parse();
+                if (parsed !== undefined) {
+                    const upsert = this.upsert(db);
+                    for (const [id, entry] of Object.entries(parsed)) {
+                        if (!registryEntry(entry) || !(entry.updated > since))
+                            continue;
+                        const current = this.read(db, id);
+                        if (current !== undefined && current.updated >= entry.updated)
                             continue;
-                        }
+                        this.writeRow(upsert, id, entry);
+                        merged += 1;
                     }
-                    catch (staleLockError) {
-                        if (errorCode(staleLockError) !== "ENOENT")
-                            throw staleLockError;
-                        continue;
+                    if (merged > 0) {
+                        backup = `${legacy}.merged-${Date.now()}-${process.pid}`;
+                        setMeta("reconciled_at", String(Date.now()));
                     }
-                    Atomics.wait(registryLockWaiter, 0, 0, REGISTRY_LOCK_RETRY_MS);
                 }
             }
-            return action();
+            db.exec("COMMIT");
         }
         catch (error) {
-            throw new SessionPersistenceError(this.file, error);
+            db.exec("ROLLBACK");
+            throw error;
         }
-        finally {
-            if (fd !== undefined) {
-                closeSync(fd);
-                unlinkSync(lock);
+        if (merged > 0)
+            this.entries.clear();
+        if (merged > 0)
+            console.warn(`[session-store] merged ${merged} sessions an older antechamber wrote to ${legacy}`);
+        // The durable marker handles a crash after COMMIT but before rename, including an empty import.
+        // Never overwrite an existing backup or import the same legacy file after sessions are deleted.
+        if (backup !== undefined && !existsSync(backup)) {
+            try {
+                chmodSync(legacy, REGISTRY_FILE_MODE);
+                renameSync(legacy, backup);
+            }
+            catch (error) {
+                if (errorCode(error) !== "ENOENT")
+                    throw error;
             }
         }
     }
-    persist(entries) {
-        const obj = Object.fromEntries([...entries].map(([id, entry]) => [id, persistedEntry(entry)]));
-        const tmp = `${this.file}.${process.pid}.tmp`;
-        const data = Buffer.from(JSON.stringify(obj));
-        writeFileSync(tmp, data, { mode: REGISTRY_FILE_MODE });
-        chmodSync(tmp, REGISTRY_FILE_MODE);
-        renameSync(tmp, this.file);
-        return data;
-    }
-    mutate(change) {
-        if (this.batchState !== undefined) {
-            this.batchState.changes.push(change);
-            change(this.load());
-            return;
+    upsert(db) {
+        return db.prepare(`INSERT INTO sessions (id, payload, pi_session_id, directory, parent_id, has_task)
+      VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET
+      payload=excluded.payload, pi_session_id=excluded.pi_session_id, directory=excluded.directory,
+      parent_id=excluded.parent_id, has_task=excluded.has_task`);
+    }
+    writeRow(statement, id, entry) {
+        statement.run(id, JSON.stringify(persistedEntry(entry)), entry.piSessionId, entry.directory, entry.parentID ?? null, entry.task === undefined ? 0 : 1);
+    }
+    refresh(db) {
+        const version = db.prepare("PRAGMA data_version").get()?.data_version;
+        if (typeof version !== "number" && typeof version !== "bigint")
+            throw new Error("Invalid SQLite data_version");
+        if (this.version !== version) {
+            this.entries.clear();
+            this.version = version;
         }
-        this.withRegistryLock(() => {
-            // Another process may have written since; only parse again when the bytes differ.
-            const raw = this.readRaw();
-            const entries = this.entries !== undefined && raw !== undefined && this.raw !== undefined && raw.equals(this.raw)
-                ? new Map(this.entries)
-                : this.parseEntries(raw);
-            const written = change(entries) ? this.persist(entries) : raw;
-            this.entries = entries;
-            this.raw = written;
-        });
     }
-    /** Synchronous restoration reads its own changes, then merges them under one short-lived write lock. */
+    read(db, id) {
+        const cached = this.entries.get(id);
+        if (cached !== undefined)
+            return cached;
+        const payload = db.prepare("SELECT payload FROM sessions WHERE id = ?").get(id)?.payload;
+        if (typeof payload !== "string")
+            return undefined;
+        const entry = JSON.parse(payload);
+        if (!registryEntry(entry))
+            return undefined;
+        this.entries.set(id, entry);
+        return entry;
+    }
+    persist(changes) {
+        try {
+            mkdirSync(this.stateDir, { recursive: true, mode: REGISTRY_DIRECTORY_MODE });
+            chmodSync(this.stateDir, REGISTRY_DIRECTORY_MODE);
+            const db = this.database(true);
+            db.exec("BEGIN IMMEDIATE");
+            const changed = new Map();
+            try {
+                this.refresh(db);
+                for (const { id, apply } of changes) {
+                    const previous = changed.has(id) ? changed.get(id) : this.read(db, id);
+                    const next = apply(previous);
+                    if (next !== undefined || previous !== undefined)
+                        changed.set(id, next);
+                }
+                const upsert = this.upsert(db);
+                const remove = db.prepare("DELETE FROM sessions WHERE id = ?");
+                for (const [id, entry] of changed) {
+                    if (entry === undefined)
+                        remove.run(id);
+                    else
+                        this.writeRow(upsert, id, entry);
+                }
+                db.exec("COMMIT");
+            }
+            catch (error) {
+                db.exec("ROLLBACK");
+                throw error;
+            }
+            for (const [id, entry] of changed) {
+                if (entry === undefined)
+                    this.entries.delete(id);
+                else
+                    this.entries.set(id, entry);
+            }
+        }
+        catch (error) {
+            if (error instanceof SessionPersistenceError)
+                throw error;
+            throw new SessionPersistenceError(this.file, error);
+        }
+    }
+    mutate(id, apply) {
+        const batch = this.batchState;
+        if (batch === undefined)
+            this.persist([{ id, apply }]);
+        else {
+            const previous = this.get(id);
+            batch.changes.push({ id, apply });
+            batch.entries.set(id, apply(previous));
+        }
+    }
+    /** Stage only touched rows; replay partial updates against the latest rows under SQLite's write lock. */
     batch(action) {
         if (this.batchState !== undefined)
             return action();
-        const changes = [];
-        const batch = { entries: undefined, isolated: new WeakSet(), changes };
+        const batch = { entries: new Map(), changes: [] };
         this.batchState = batch;
         try {
             const result = action();
             this.batchState = undefined;
-            if (batch.changes.length !== 0) {
-                this.mutate((entries) => {
-                    let changed = false;
-                    for (const change of batch.changes)
-                        if (change(entries))
-                            changed = true;
-                    return changed;
-                });
-            }
+            if (batch.changes.length !== 0)
+                this.persist(batch.changes);
             return result;
         }
         finally {
@@ -653,49 +742,70 @@ export class SessionStore {
         }
     }
     get(ocSessionId) {
-        const entries = this.load();
-        const entry = entries.get(ocSessionId);
-        if (this.batchState === undefined || entry === undefined || this.batchState.isolated.has(entry))
+        const batch = this.batchState;
+        if (batch?.entries.has(ocSessionId))
+            return batch.entries.get(ocSessionId);
+        const db = this.database();
+        if (db === undefined)
+            return undefined;
+        this.refresh(db);
+        const entry = this.read(db, ocSessionId);
+        if (batch === undefined)
             return entry;
-        const staged = structuredClone(entry);
-        entries.set(ocSessionId, staged);
-        this.batchState.isolated.add(staged);
+        const staged = entry === undefined ? undefined : structuredClone(entry);
+        batch.entries.set(ocSessionId, staged);
         return staged;
     }
     idFor(piSessionId) {
-        return [...this.load()].find(([, entry]) => entry.piSessionId === piSessionId)?.[0];
+        return this.matching("SELECT id FROM sessions WHERE pi_session_id = ? ORDER BY rowid", [piSessionId], (entry) => entry.piSessionId === piSessionId)[0];
     }
     childIds() {
-        return [...this.load()]
-            .filter(([, entry]) => entry.task !== undefined && entry.parentID !== undefined)
-            .map(([id]) => id);
+        return this.matching("SELECT id FROM sessions WHERE has_task = 1 AND parent_id IS NOT NULL ORDER BY rowid", [], (entry) => entry.task !== undefined && entry.parentID !== undefined);
+    }
+    matching(query, parameters, matches) {
+        const db = this.database();
+        if (db !== undefined)
+            this.refresh(db);
+        const ids = new Set();
+        for (const row of db?.prepare(query).all(...parameters) ?? [])
+            if (typeof row.id === "string")
+                ids.add(row.id);
+        if (this.batchState === undefined)
+            return [...ids];
+        for (const id of this.batchState?.entries.keys() ?? [])
+            ids.add(id);
+        return [...ids].filter((id) => {
+            const entry = this.get(id);
+            return entry !== undefined && matches(entry);
+        });
     }
     set(ocSessionId, entry) {
         const saved = this.batchState === undefined ? entry : structuredClone(entry);
-        this.mutate((entries) => {
-            entries.set(ocSessionId, this.batchState === undefined ? saved : structuredClone(saved));
-            return true;
-        });
+        this.mutate(ocSessionId, () => (this.batchState === undefined ? saved : structuredClone(saved)));
     }
     /** Merge a partial update (e.g. title override, updated timestamp). */
     update(ocSessionId, patch) {
         const saved = this.batchState === undefined ? patch : structuredClone(patch);
-        this.mutate((entries) => {
-            const previous = entries.get(ocSessionId);
-            if (previous === undefined)
-                return false;
-            entries.set(ocSessionId, {
+        this.mutate(ocSessionId, (previous) => previous === undefined
+            ? undefined
+            : {
                 ...previous,
                 ...(this.batchState === undefined ? saved : structuredClone(saved)),
             });
-            return true;
-        });
     }
     remove(ocSessionId) {
-        this.mutate((entries) => entries.delete(ocSessionId));
+        this.mutate(ocSessionId, () => undefined);
     }
     /** Every directory the registry knows about — used to resolve bare session ids. */
     directories() {
-        return [...new Set([...this.load().values()].map((e) => e.directory))];
+        const db = this.database();
+        const directories = new Set();
+        for (const row of db?.prepare("SELECT DISTINCT directory FROM sessions").all() ?? [])
+            if (typeof row.directory === "string")
+                directories.add(row.directory);
+        if (this.batchState === undefined)
+            return [...directories];
+        const ids = this.matching("SELECT id FROM sessions", [], () => true);
+        return [...new Set(ids.map((id) => this.get(id).directory))];
     }
 }

package/dist/session-tree.js

@@ -332,8 +332,8 @@ function entryForMessage(s, tree, messageID) {
 }
 /**
  * The last entry of an assistant reply: the reply, or the latest result of its own tool calls.
- * OpenChamber 2.x /btw names a final reply (no tool calls); 1.24's /btw can name any completed
- * step, whose tool results belong to the same OpenChamber message.
+ * A final reply has no tool calls. When an API caller selects a tool-bearing
+ * reply, its completed tool results belong to the same message.
  */
 function replyEnd(tree, reply, leafId) {
     const content = reply.message?.content;

package/dist/sse.d.ts

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

package/dist/sse.js

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

package/dist/tool-map.js

@@ -257,9 +257,7 @@ export function nestedToolParts(parent, details, sessions = {}) {
             messageID: parent.messageID,
             type: "tool",
             callID: `nested:${callID}`,
-            // OpenChamber 1.24 never styles a task card as failed or shows its error (ToolPart.tsx isTaskTool),
-            // and a failed spawn has no session to open, so it goes out as a plain card that does both.
-            tool: failed && mapped.tool === "task" ? "agent" : mapped.tool,
+            tool: mapped.tool,
             state: !failed
                 ? { ...state, status: "completed" }
                 : {

package/dist/work-status.js

@@ -1,5 +1,5 @@
 /**
- * Background work of one session for the OmO Work status section (extensions/omo-work):
+ * Background work of one session for the OmO Work status section (extensions/antechamber):
  * todo phases, terminal monitors, detached eval cells, background terminal sessions and the
  * goal continuation timer. OpenChamber 2.x has no native surface for any of these.
  *