antechamber 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project uses [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [1.0.5] - 2026-10-20
+
+### Fixed
+
+- Reduce startup CPU usage and boot delays for large session histories by committing restoration metadata
+  in one registry write, while preserving restored costs, child sessions and independent registry writers.
+
+## [1.0.4] - 2026-10-20
+
+### Fixed
+
+- Keep subagents with colliding task IDs in different sessions separate, and recover a foreign child
+  archive from its own retained transcript.
+
 ## [1.0.3] - 2026-10-20
 
 ### Added

package/dist/session-store.d.ts

@@ -91,12 +91,15 @@ export declare class SessionStore {
     readonly stateDir: string;
     private readonly file;
     private entries;
+    private batchState;
     constructor(stateDir?: string);
     private load;
     private readEntries;
     private withRegistryLock;
     private persist;
     private mutate;
+    /** Synchronous restoration reads its own changes, then merges them under one short-lived write lock. */
+    batch<T>(action: () => T): T;
     get(ocSessionId: string): SessionRegistryEntry | undefined;
     idFor(piSessionId: string): string | undefined;
     childIds(): string[];

package/dist/session-store.js

@@ -378,12 +378,15 @@ export class SessionStore {
     stateDir;
     file;
     entries;
+    batchState;
     constructor(stateDir) {
         const dir = stateDir ?? envSetting("STATE_DIR") ?? defaultStateDir();
         this.stateDir = dir;
         this.file = join(dir, "sessions.json");
     }
     load() {
+        if (this.batchState !== undefined)
+            return this.batchState.entries;
         if (this.entries !== undefined)
             return this.entries;
         this.entries = this.readEntries();
@@ -452,6 +455,11 @@ export class SessionStore {
         renameSync(tmp, this.file);
     }
     mutate(change) {
+        if (this.batchState !== undefined) {
+            this.batchState.changes.push(change);
+            change(this.batchState.entries);
+            return;
+        }
         this.withRegistryLock(() => {
             const entries = this.readEntries();
             if (change(entries))
@@ -459,6 +467,31 @@ export class SessionStore {
             this.entries = entries;
         });
     }
+    /** Synchronous restoration reads its own changes, then merges them under one short-lived write lock. */
+    batch(action) {
+        if (this.batchState !== undefined)
+            return action();
+        const changes = [];
+        const batch = { entries: structuredClone(this.load()), 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;
+                });
+            }
+            return result;
+        }
+        finally {
+            this.batchState = undefined;
+        }
+    }
     get(ocSessionId) {
         return this.load().get(ocSessionId);
     }
@@ -471,18 +504,23 @@ export class SessionStore {
             .map(([id]) => id);
     }
     set(ocSessionId, entry) {
+        const saved = this.batchState === undefined ? entry : structuredClone(entry);
         this.mutate((entries) => {
-            entries.set(ocSessionId, entry);
+            entries.set(ocSessionId, this.batchState === undefined ? saved : structuredClone(saved));
             return true;
         });
     }
     /** 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, { ...previous, ...patch });
+            entries.set(ocSessionId, {
+                ...previous,
+                ...(this.batchState === undefined ? saved : structuredClone(saved)),
+            });
             return true;
         });
     }

package/dist/sessions.js

@@ -308,14 +308,18 @@ export class SessionManager {
             .sort((a, b) => this.lifecycle.lastUsed(b) - this.lifecycle.lastUsed(a));
     }
     list(directory) {
-        this.refreshNativeTitles();
-        this.subagents.restoreAll();
-        if (directory !== undefined) {
-            this.ensureScanned(directory);
-            return [...this.sessions.values()].filter((s) => s.info.directory === directory).map((s) => this.sessionInfo(s));
-        }
-        // Unfiltered: keep the old semantics — live sessions only.
-        return [...this.sessions.values()].filter((s) => s.restored === undefined).map((s) => this.sessionInfo(s));
+        return this.store.batch(() => {
+            this.refreshNativeTitles();
+            this.subagents.restoreAll();
+            if (directory !== undefined) {
+                this.ensureScanned(directory);
+                return [...this.sessions.values()]
+                    .filter((s) => s.info.directory === directory)
+                    .map((s) => this.sessionInfo(s));
+            }
+            // Unfiltered: keep the old semantics — live sessions only.
+            return [...this.sessions.values()].filter((s) => s.restored === undefined).map((s) => this.sessionInfo(s));
+        });
     }
     /**
      * Every restorable session on disk (all directories) plus live ones. Backs the
@@ -323,10 +327,12 @@ export class SessionManager {
      * global/recent view; `list(directory)` stays the per-project source of truth.
      */
     listAll() {
-        this.refreshNativeTitles();
-        this.ensureAllScanned();
-        this.subagents.restoreAll();
-        return [...this.sessions.values()].map((s) => this.sessionInfo(s));
+        return this.store.batch(() => {
+            this.refreshNativeTitles();
+            this.ensureAllScanned();
+            this.subagents.restoreAll();
+            return [...this.sessions.values()].map((s) => this.sessionInfo(s));
+        });
     }
     sessionInfo(s) {
         if (s.restored !== undefined)
@@ -334,18 +340,20 @@ export class SessionManager {
         return s.info;
     }
     get(sessionId) {
-        if (this.disposed)
-            return undefined;
-        const live = this.sessions.get(sessionId);
-        if (live !== undefined) {
-            this.refreshNativeTitles();
-            this.sessionInfo(live);
-            return live;
-        }
-        const restored = this.subagents.restore(sessionId) ?? this.resolveRestored(sessionId);
-        if (restored !== undefined)
-            this.sessionInfo(restored);
-        return restored;
+        return this.store.batch(() => {
+            if (this.disposed)
+                return undefined;
+            const live = this.sessions.get(sessionId);
+            if (live !== undefined) {
+                this.refreshNativeTitles();
+                this.sessionInfo(live);
+                return live;
+            }
+            const restored = this.subagents.restore(sessionId) ?? this.resolveRestored(sessionId);
+            if (restored !== undefined)
+                this.sessionInfo(restored);
+            return restored;
+        });
     }
     async remove(sessionId) {
         return this.lifecycle.run(() => this.removeLive(sessionId));

package/dist/subagents.d.ts

@@ -1,6 +1,6 @@
-import { type SessionStore } from "./session-store.js";
-import { type EvalAgent, type ToolResult } from "./tool-map.js";
+import { SessionStore } from "./session-store.js";
 import type { ManagedSession } from "./sessions.js";
+import { type EvalAgent, type ToolResult } from "./tool-map.js";
 import type { OCEvent, OCMessageWithParts, OCToolPart } from "./types.js";
 export declare function stripTaskSuffix(text: string): string;
 /** One stable renderer part per item, with the batch defaults inherited. */
@@ -9,8 +9,10 @@ export declare function taskParts(template: OCToolPart, args: Record<string, unk
 export declare function updateTaskParts(parts: OCToolPart[], result: ToolResult, ended: boolean, now: number): void;
 /** Wake messages carry arrays of completion envelopes, not a flat details object. */
 export declare function taskCompletions(value: unknown): Record<string, unknown>[];
-/** Reverse lookup of a child session id, for tasks whose spawn never surfaced as a `task` tool call. */
-export declare function findTaskBySession(sessionId: string): {
+/** Keep bookmarks for known tasks; a bare native id is only safe while it has one parent. */
+export declare function taskSessionId(id: string, parentPiId: string, store?: SessionStore): string;
+/** Reverse lookup never resolves an unbound, ambiguous bare id by store enumeration order. */
+export declare function findTaskBySession(sessionId: string, store?: SessionStore): {
     path: string;
     data: Record<string, unknown>;
 } | undefined;
@@ -53,6 +55,7 @@ export declare class SubagentBridge {
     private readonly taskParents;
     constructor(store: SessionStore, sessions: Map<string, ManagedSession>, emit: (directory: string, event: OCEvent) => void, parse: ParseHistory);
     private archive;
+    private sessionId;
     wire(parent: ManagedSession): void;
     start(parent: ManagedSession, original: OCToolPart, args: Record<string, unknown>): void;
     result(parent: ManagedSession, callID: string, result: ToolResult, ended: boolean): boolean;

package/dist/subagents.js

@@ -3,7 +3,7 @@ import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, rea
 import { basename, dirname, join } from "node:path";
 import { piAgentDir } from "./agent-dir.js";
 import { syncSessionCost } from "./pi-event-translation.js";
-import { ocIdFor, SessionPersistenceError } from "./session-store.js";
+import { ocIdFor, SessionPersistenceError, SessionStore } from "./session-store.js";
 import { mapTool, resultText, toolMappers } from "./tool-map.js";
 import { ADAPTER_VERSION } from "./version.js";
 // macOS watches directories through FSEvents, which goes live asynchronously after
@@ -106,7 +106,12 @@ export function updateTaskParts(parts, result, ended, now) {
         const metadata = {
             ...previous,
             task: data,
-            ...(taskId(data.task_id) ? { sessionID: ocIdFor(data.task_id), taskID: data.task_id } : {}),
+            ...(taskId(data.task_id)
+                ? {
+                    sessionID: previous?.taskID === data.task_id ? previous.sessionID : ocIdFor(data.task_id),
+                    taskID: data.task_id,
+                }
+                : {}),
         };
         // Preserve a final result for the fallback even after the parent JSONL is gone.
         if (ended && output !== "" && !active(data.status))
@@ -206,16 +211,42 @@ function childRecord(id, path) {
     const data = jsonObject(path);
     return data?.task_id === id && typeof data.parent_session_id === "string" ? data : undefined;
 }
-/** Reverse lookup of a child session id, for tasks whose spawn never surfaced as a `task` tool call. */
-export function findTaskBySession(sessionId) {
+/** Keep bookmarks for known tasks; a bare native id is only safe while it has one parent. */
+export function taskSessionId(id, parentPiId, store = new SessionStore()) {
+    for (const sessionID of store.childIds()) {
+        const task = store.get(sessionID)?.task;
+        if (task?.id === id && task.parentPiId === parentPiId)
+            return sessionID;
+    }
+    const legacyID = ocIdFor(id);
+    const legacy = store.get(legacyID);
+    if (legacy !== undefined) {
+        if (legacy.deleted && legacy.parentID === (store.idFor(parentPiId) ?? ocIdFor(parentPiId)))
+            return legacyID;
+        return ocIdFor(`${parentPiId}:${id}`);
+    }
+    const qualifiedID = ocIdFor(`${parentPiId}:${id}`);
+    if (store.get(qualifiedID))
+        return qualifiedID;
+    for (const root of taskStores()) {
+        const data = childRecord(id, join(root, "tasks", `${id}.json`));
+        if (data && data.parent_session_id !== parentPiId)
+            return qualifiedID;
+    }
+    return legacyID;
+}
+/** Reverse lookup never resolves an unbound, ambiguous bare id by store enumeration order. */
+export function findTaskBySession(sessionId, store = new SessionStore()) {
+    let found;
     for (const { id, path } of taskFiles()) {
-        if (ocIdFor(id) !== sessionId)
-            continue;
         const data = childRecord(id, path);
-        if (data)
-            return { path, data };
+        if (!data || taskSessionId(id, String(data.parent_session_id), store) !== sessionId)
+            continue;
+        if (found && found.data.parent_session_id !== data.parent_session_id)
+            return undefined;
+        found = { path, data };
     }
-    return undefined;
+    return found;
 }
 /**
  * Whether a recorded argument names a task record's value. Codemode caps recorded strings at 512 code
@@ -266,7 +297,7 @@ export function evalAgentSession(parentPiId, args, claimed, after) {
     const summary = text(best.data.task_summary);
     const agentType = text(best.data.agent_type);
     return {
-        sessionID: ocIdFor(best.id),
+        sessionID: taskSessionId(best.id, parentPiId),
         ...(name !== undefined && name !== best.id ? { name } : {}),
         ...(summary !== undefined ? { summary } : {}),
         ...(agentType !== undefined ? { agentType } : {}),
@@ -283,6 +314,35 @@ export function findTask(id, parentPiId) {
     }
     return undefined;
 }
+function transcriptSessionId(raw) {
+    try {
+        const header = JSON.parse(raw.split("\n", 1)[0] ?? "");
+        return record(header) && header.type === "session" && typeof header.id === "string" ? header.id : undefined;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}
+function transcriptSessionIdFromFile(path) {
+    let fd;
+    try {
+        fd = openSync(path, "r");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && ["ENOENT", "ENOTDIR", "EACCES"].includes(String(error.code)))
+            return undefined;
+        throw error;
+    }
+    try {
+        const buffer = Buffer.alloc(4096);
+        return transcriptSessionId(buffer.subarray(0, readSync(fd, buffer, 0, buffer.length, 0)).toString("utf8"));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
 /** Byte offsets and a byte carry retain split UTF-8 characters and torn JSON lines. */
 export class JsonlTail {
     offset = 0;
@@ -339,8 +399,14 @@ export class SubagentBridge {
         this.emit = emit;
         this.parse = parse;
     }
-    archive(id) {
-        return join(this.store.stateDir, "children", `${id}.jsonl`);
+    archive(child) {
+        const previous = this.store.get(child.session.info.id)?.piPath;
+        const directory = join(this.store.stateDir, "children");
+        return ((previous !== undefined && dirname(previous) === directory ? previous : undefined) ??
+            join(directory, `${child.session.info.id === ocIdFor(child.task.id) ? child.task.id : child.session.info.id}.jsonl`));
+    }
+    sessionId(parent, id) {
+        return taskSessionId(id, parent.piSessionId ?? parent.restored?.piSessionId ?? "", this.store);
     }
     wire(parent) {
         parent.hasRunningChildren = () => [...this.children.values()].some((child) => child.session.info.parentID === parent.info.id && child.session.status.type === "busy");
@@ -373,7 +439,7 @@ export class SubagentBridge {
         if (message.customType !== "omo-senpi:wake")
             return;
         for (const data of taskCompletions(message.details)) {
-            const id = ocIdFor(String(data.task_id));
+            const id = this.sessionId(parent, String(data.task_id));
             // A registry-only child (after a restart) or a task with no card (spawned from
             // `eval`) is not loaded yet; restore() covers both.
             if (!this.children.has(id))
@@ -399,11 +465,14 @@ export class SubagentBridge {
         for (const row of ev.data.tasks) {
             if (!record(row) || !taskId(row.task_id))
                 continue;
-            const id = ocIdFor(row.task_id);
+            if (typeof row.parent_session_id === "string" &&
+                row.parent_session_id !== (parent.piSessionId ?? parent.restored?.piSessionId))
+                continue;
+            const id = this.sessionId(parent, row.task_id);
             if (!this.children.has(id))
                 this.restore(id);
             const child = this.children.get(id);
-            if (!child)
+            if (!child || child.session.info.parentID !== parent.info.id)
                 continue;
             const data = snapshotState(row);
             // OmO re-sends every row ~150 ms after each progress event of any task; only changes matter.
@@ -440,12 +509,13 @@ export class SubagentBridge {
             if (part.type !== "tool" || part.tool !== "task" || part.state.status === "pending")
                 continue;
             const metadata = part.state.metadata;
-            if (!taskId(metadata?.taskID))
+            if (!metadata || !taskId(metadata.taskID))
                 continue;
             const id = metadata.taskID;
             const details = record(metadata.task) ? metadata.task : {};
-            let child = this.children.get(ocIdFor(id));
-            if (!child && this.deleted(ocIdFor(id)))
+            const sessionID = this.sessionId(parent, id);
+            let child = this.children.get(sessionID);
+            if (!child && this.deleted(sessionID))
                 continue;
             if (!child) {
                 child = this.create(parent, {
@@ -461,16 +531,17 @@ export class SubagentBridge {
                     child.task.details = { ...child.task.details, ...details };
             }
             child.live ||= live;
+            metadata.sessionID = child.session.info.id;
             if (terminal(details.status) && part.state.status !== "running")
                 child.task.terminalAt = part.state.time.end;
             child.parts.set(part.id, part);
             this.refresh(child, true);
         }
     }
-    create(parent, task) {
-        const archived = this.store.get(ocIdFor(task.id))?.archived;
+    create(parent, task, id = taskSessionId(task.id, task.parentPiId, this.store)) {
+        const archived = this.store.get(id)?.archived;
         const session = this.managedSession({
-            id: ocIdFor(task.id),
+            id,
             parentID: parent.info.id,
             projectID: parent.info.projectID,
             directory: parent.info.directory,
@@ -504,7 +575,7 @@ export class SubagentBridge {
             return this.removed.has(id) ? undefined : this.adopt(id);
         if (entry.deleted || !entry.task || !entry.parentID)
             return undefined;
-        const child = this.create(this.detachedParent(entry.parentID, entry.directory, entry), entry.task);
+        const child = this.create(this.detachedParent(entry.parentID, entry.directory, entry), entry.task, id);
         child.session.info.title = entry.title ?? child.session.info.title;
         this.refresh(child, false);
         return child.session;
@@ -513,7 +584,7 @@ export class SubagentBridge {
      * Tasks spawned outside a `task` tool call (e.g. `agent()` inside an `eval`
      * cell) never produce a card, so their session is built from the task record.
      */
-    adopt(id, found = findTaskBySession(id)) {
+    adopt(id, found = findTaskBySession(id, this.store)) {
         if (!found)
             return undefined;
         const parentPi = String(found.data.parent_session_id);
@@ -532,7 +603,7 @@ export class SubagentBridge {
                 ...(typeof found.data.agent_type === "string" ? { subagent_type: found.data.agent_type } : {}),
             },
             details: found.data,
-        });
+        }, id);
         this.refresh(child, false);
         return child.session;
     }
@@ -554,9 +625,9 @@ export class SubagentBridge {
     childIdsByPi() {
         const byPi = new Map();
         for (const id of this.store.childIds()) {
-            const piSessionId = this.store.get(id)?.piSessionId;
-            if (piSessionId)
-                byPi.set(piSessionId, id);
+            const entry = this.store.get(id);
+            if (entry?.piSessionId && !entry.deleted)
+                byPi.set(entry.piSessionId, id);
         }
         return byPi;
     }
@@ -589,16 +660,16 @@ export class SubagentBridge {
             this.restore(id);
         const childByPi = this.childIdsByPi();
         for (const { id, path } of taskFiles()) {
-            const sessionId = ocIdFor(id);
-            if (this.children.has(sessionId) || this.removed.has(sessionId) || this.store.get(sessionId))
-                continue;
-            let parentPi = this.taskParents.get(id);
+            let parentPi = this.taskParents.get(path);
             if (parentPi === undefined) {
                 const parent = childRecord(id, path)?.parent_session_id;
                 if (typeof parent !== "string")
                     continue;
-                this.taskParents.set(id, (parentPi = parent));
+                this.taskParents.set(path, (parentPi = parent));
             }
+            const sessionId = taskSessionId(id, parentPi, this.store);
+            if (this.children.has(sessionId) || this.removed.has(sessionId) || this.store.get(sessionId))
+                continue;
             if (!this.parentFor(parentPi, childByPi))
                 continue;
             const data = childRecord(id, path);
@@ -641,7 +712,7 @@ export class SubagentBridge {
         }
     }
     refresh(child, publish, useRecord = true) {
-        const archive = this.archive(child.task.id);
+        const archive = this.archive(child);
         const found = this.reconcileTaskRecord(child, useRecord);
         // OmO stops in-process workers with their parent and leaves them `running` but `persisted_only`
         // until the revived parent reconciles them (omo-task.js `DK`/`jK`); they are not running.
@@ -695,32 +766,52 @@ export class SubagentBridge {
         // A resumed live task can be newer than its archive; completed history prefers the archive.
         const liveRun = running || previousStatus === "busy";
         let raw = liveRun ? undefined : optionalFile(archive);
+        const expected = (child.livePath === undefined ? undefined : transcriptSessionIdFromFile(child.livePath)) ??
+            (typeof child.task.details.child_session_id === "string" && child.task.details.child_session_id !== ""
+                ? child.task.details.child_session_id
+                : undefined);
+        const legacyArchive = join(this.store.stateDir, "children", `${child.task.id}.jsonl`);
+        if (!liveRun && raw === undefined && expected !== undefined) {
+            for (const path of [join(this.store.stateDir, "children", `native-${ocIdFor(expected)}.jsonl`), legacyArchive]) {
+                const retained = optionalFile(path);
+                if (retained !== undefined && transcriptSessionId(retained) === expected) {
+                    raw = retained;
+                    break;
+                }
+            }
+        }
+        const foreign = raw !== undefined && expected !== undefined && transcriptSessionId(raw) !== expected;
+        if (foreign && raw !== undefined) {
+            const displaced = transcriptSessionId(raw);
+            if (displaced !== undefined) {
+                const retained = join(this.store.stateDir, "children", `native-${ocIdFor(displaced)}.jsonl`);
+                // This may be the other child's only history; retain it before repairing the shared path.
+                if (!existsSync(retained))
+                    this.saveArchive(retained, raw);
+            }
+            raw = undefined;
+        }
         if (running && child.recordPath)
             this.watch(child, child.recordPath);
         if (raw === undefined && child.livePath !== undefined) {
             if (running)
                 this.watch(child, child.livePath);
             child.tail.read(child.livePath);
-            if (child.tail.text !== "")
+            if (child.tail.text !== "" && (expected === undefined || transcriptSessionId(child.tail.text) === expected))
                 raw = child.tail.text;
         }
         if (raw !== undefined) {
-            const headerLine = raw.split("\n", 1)[0];
-            try {
-                const header = JSON.parse(headerLine ?? "");
-                if (record(header) && typeof header.id === "string")
-                    child.session.piSessionId = header.id;
-            }
-            catch (error) {
-                if (!(error instanceof SyntaxError))
-                    throw error;
-            }
+            const piSessionId = transcriptSessionId(raw);
+            if (piSessionId !== undefined)
+                child.session.piSessionId = piSessionId;
             child.session.messages = this.parse(child.session, raw);
             this.discover(child.session, child.session.messages);
-            if (!running && terminal(child.task.details.status) && (liveRun || !existsSync(archive)))
+            if (!running && terminal(child.task.details.status) && (liveRun || foreign || !existsSync(archive)))
                 this.saveArchive(archive, raw);
         }
         else {
+            if (expected !== undefined)
+                child.session.piSessionId = expected;
             child.session.messages = this.fallback(child);
         }
         child.loaded = true;
@@ -836,7 +927,7 @@ export class SubagentBridge {
         try {
             this.store.set(info.id, {
                 piSessionId: child.session.piSessionId ?? child.task.id,
-                piPath: this.archive(child.task.id),
+                piPath: this.archive(child),
                 directory: info.directory,
                 title: info.title,
                 parentID: info.parentID,
@@ -924,9 +1015,10 @@ export class SubagentBridge {
         this.store.set(id, {
             deleted: true,
             piSessionId: child.session.piSessionId ?? child.task.id,
-            piPath: this.archive(child.task.id),
+            piPath: this.archive(child),
             directory: info.directory,
             ...(info.parentID !== undefined ? { parentID: info.parentID } : {}),
+            task: child.task,
             created: info.time.created,
             updated: info.time.updated,
         });

package/extensions/omo-compat/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-compat",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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/docs/DESIGN.md

@@ -36,16 +36,20 @@ exceeds that bound, the service keeps the root and a valid task prefix, removes
 edges to omitted tasks, and returns `truncated.omittedNodes`; the panel
 validates that field and displays the count.
 
-The connector names sub-agent sessions `ses_<md5(task_id)>` and root sessions
-`ses_<md5(piSessionId)>` (`ocIdFor` in `src/session-store.ts`). The graph
-uses the same function, so a node's `sessionId` is exactly the id
-`openSession` needs, even for runs missing from the registry.
+The connector names root sessions `ses_<md5(piSessionId)>` (`ocIdFor` in
+`src/session-store.ts`). Sub-agent links use their recorded registry ID when
+available. Unregistered tasks use `ses_<md5(task_id)>` while the task ID has
+one parent, or `ses_<md5(parent_session_id + ":" + task_id)>` when it collides
+across parents. Discovery retains both colliding task records, and the graph
+uses the same identity rules so `openSession` opens the correct child.
+Legacy deletion tombstones retain their owning parent's bare identity, even
+when they predate task metadata in the registry.
 
 ## Graph model (`src/graph.ts`)
 
 - **Run**: every task whose `root_session_id` equals the resolved root. The
   root is resolved from the open session: it is either a root itself, a
-  sub-agent (`ses_<md5(task_id)>`, so the run is that task's root), or a
+  sub-agent (resolved through its parent-qualified identity or registry), or a
   registry entry.
 - **Spawn edges**: `parent_session_id` → task. A task launched from inside a
   sub-agent has that sub-agent's own session id as its parent (its

package/extensions/omo-dag/package.json

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

package/extensions/omo-dag/service/main.js

@@ -54,6 +54,7 @@ function normalizeRegistry(raw) {
   for (const [id, value] of Object.entries(raw)) {
     if (!isObject(value)) continue;
     const entry = {};
+    if (value.deleted === true) entry.deleted = true;
     if (text(value.piSessionId) !== void 0) entry.piSessionId = text(value.piSessionId);
     if (text(value.parentID) !== void 0) entry.parentID = text(value.parentID);
     if (text(value.title) !== void 0) entry.title = text(value.title);
@@ -65,6 +66,20 @@ function normalizeRegistry(raw) {
 function ocIdFor(piSessionId) {
   return `ses_${createHash("md5").update(piSessionId).digest("hex")}`;
 }
+function taskSessionId(task, tasks, registry) {
+  const registered = Object.entries(registry).find(
+    ([, entry]) => entry.task?.id === task.task_id && entry.task.parentPiId === task.parent_session_id
+  );
+  if (registered) return registered[0];
+  const legacy = ocIdFor(task.task_id);
+  const parent = Object.entries(registry).find(([, entry]) => entry.piSessionId === task.parent_session_id)?.[0];
+  if (registry[legacy]?.deleted && registry[legacy]?.parentID === (parent ?? ocIdFor(task.parent_session_id ?? "")))
+    return legacy;
+  const qualified = ocIdFor(`${task.parent_session_id}:${task.task_id}`);
+  if (registry[legacy] !== void 0 || registry[qualified] !== void 0 || tasks.some((other) => other.task_id === task.task_id && other.parent_session_id !== task.parent_session_id))
+    return qualified;
+  return legacy;
+}
 var ACTIVE = /* @__PURE__ */ new Set(["running", "starting"]);
 var WAITING = /* @__PURE__ */ new Set(["queued", "pending", "suspended"]);
 var FAILED = /* @__PURE__ */ new Set(["failed", "error", "lost", "denied", "plan_error"]);
@@ -108,7 +123,7 @@ ${task.spawn_spec?.instructions ?? ""}`;
 }
 function resolveSession(sessionId, tasks, registry) {
   const entry = registry[sessionId];
-  const focusTask = tasks.find((t) => ocIdFor(t.task_id) === sessionId) ?? (entry?.task?.id ? tasks.find((t) => t.task_id === entry.task?.id) : void 0);
+  const focusTask = tasks.find((t) => taskSessionId(t, tasks, registry) === sessionId);
   let rootPi;
   if (focusTask) rootPi = focusTask.root_session_id ?? focusTask.parent_session_id ?? entry?.task?.parentPiId;
   else if (entry?.task?.parentPiId) rootPi = entry.task.parentPiId;
@@ -183,7 +198,7 @@ function buildGraph(sessionId, tasks, registry) {
     return {
       id: t.task_id,
       kind: "task",
-      sessionId: ocIdFor(t.task_id),
+      sessionId: taskSessionId(t, tasks, registry),
       title: firstLine(t.task_summary ?? t.description ?? t.name, 90) ?? t.task_id,
       state,
       rawStatus: String(t.status ?? "unknown"),
@@ -322,7 +337,7 @@ var TaskStore = class {
         const path = join(dir, "tasks", file);
         if (!isRegularFile(path)) continue;
         const task = this.tasks.read(path, normalizeTask);
-        if (task) out.set(task.task_id, task);
+        if (task) out.set(JSON.stringify([task.parent_session_id, task.task_id]), task);
       }
     }
     return [...out.values()];

package/extensions/omo-work/package.json

@@ -1,6 +1,6 @@
 {
   "name": "antechamber-omo-work",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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.3",
+  "version": "1.0.5",
   "description": "OpenCode-compatible HTTP/SSE server that lets OpenChamber drive the pi coding agent (and OmO) over RPC",
   "type": "module",
   "license": "MIT",