@agi-fans/dsh-tui 0.16.0 → 0.18.0

package/lib/session/session-controller.js

@@ -7,32 +7,36 @@
  * @module @agi-fans/dsh-tui/session-controller
  */
 import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
 import { installModelSelection, } from '@deepseek-ai/dsh-agent';
 import { createUserMessage, } from '@deepseek-ai/dsh-llm';
 import { isUserInvocable } from '@deepseek-ai/dsh-skill';
+import { SessionAlreadyOwnedError } from '@deepseek-ai/dsh-session-persistence';
 import { readColdSessionLog } from '@deepseek-ai/dsh-session-query';
-import { SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
+import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { queueHostSubagentPrompt } from '@deepseek-ai/dsh-subagent/internal';
 import { firstVisibleStreamTime } from "../views/stream-time.js";
 import { LiveAttemptTracker } from "./live-attempt-tracker.js";
+import { blocksText } from "./content-text.js";
 import { jobNoticeFor } from "./job-notice.js";
-import { descendantDepth, isSteerableSubagent, SubagentRoster } from "./subagent-roster.js";
+import { descendantDepth, isSteerableSubagent } from "./subagent-roster.js";
+import { readRecentRows, writeRecentRows } from "./session-library.js";
+import { readJsonFile, writeJsonAtomic } from "./json-file.js";
+import { SubagentTracker } from "./subagent-tracker.js";
 import { commandPermission } from "../commands/permission.js";
-import { isBlankSession, toolPresentationForPreset, } from "./session-configuration.js";
+import { isBlankSession, } from "./session-configuration.js";
 import { stripComposerImageMarkers } from "../input/image-paste.js";
 async function setupAgentContext(agentCtx, agent, selection) {
     installModelSelection(agentCtx, selection);
     const agentPresets = agentCtx.get('agentPresets');
     const sessionProjections = agentCtx.get('sessionProjections');
-    const tools = agentCtx.get('tools');
-    if (agentPresets === undefined || sessionProjections === undefined || tools === undefined) {
+    if (agentPresets === undefined || sessionProjections === undefined) {
         throw new Error('agent configuration services are unavailable');
     }
     const agentPreset = sessionProjections.stateOf(agent.session, 'agentPreset') ?? agentPresets.defaultId;
     const mounted = await agentPresets.mount(agentCtx, agentPreset);
-    const disposeToolPresentation = tools.presentAs(toolPresentationForPreset(mounted.id));
     await agentCtx.plugin(commandPermission(agent));
-    return { agentPreset: mounted.id, disposeToolPresentation };
+    return { agentPreset: mounted.id };
 }
 function parseControl(line) {
     const match = /^\/([a-z][a-z0-9_-]*(?::[a-z0-9][a-z0-9_-]*)?)(?:\s+(.*))?$/su.exec(line.trim());
@@ -245,12 +249,7 @@ function explicitSessionTitle(events) {
 function humanMessageText(event) {
     if (event.type !== 'user/message' || event.data.source.kind !== 'user')
         return undefined;
-    const text = event.data.content
-        .filter((block) => block.type === 'text')
-        .map(block => block.text)
-        .join(' ')
-        .replace(/\s+/gu, ' ')
-        .trim();
+    const text = blocksText(event.data.content, { collapse: true });
     return text === '' ? undefined : text;
 }
 /** Find direct human messages whose preceding log prefix is safe to seed into a fork. */
@@ -270,12 +269,7 @@ export function conversationTurns(events) {
         }
         if (open === undefined || event.type !== 'user/message' || event.data.source.kind !== 'user')
             continue;
-        const text = event.data.content
-            .filter((block) => block.type === 'text')
-            .map(block => block.text)
-            .join('\n')
-            .replace(/\s+/gu, ' ')
-            .trim();
+        const text = blocksText(event.data.content, { collapse: true });
         const imageCount = event.data.content.filter(block => block.type === 'image').length;
         if (text === '' && imageCount === 0)
             continue;
@@ -364,10 +358,7 @@ export function encodeCommandAttachments(images) {
 }
 /** Rehydrate one durable human inbox message into an editable composer draft. */
 export async function restoreSubmissionMessage(message, attachments) {
-    const text = message.content
-        .filter((block) => block.type === 'text')
-        .map(block => block.text)
-        .join('\n');
+    const text = blocksText(message.content);
     const refs = message.content
         .filter((block) => block.type === 'image')
         .map(block => block.attachment);
@@ -401,19 +392,38 @@ export class SessionRuntime {
     #releasedHandles = new WeakSet();
     #disposed = false;
     #off = [];
-    #subagents = new SubagentRoster();
-    #publishedSubagents;
+    #tracker;
     #streamAttempts = new LiveAttemptTracker();
     #recentCache = new Map();
+    #recentRowsPath;
+    #upgradeMarkerPath;
+    #recentRowsLoaded = false;
     #refreshInFlight = null;
     #refreshDirty = false;
-    #subagentEpoch = 0;
     #inspectEpoch = 0;
     #activationEpoch = 0;
     #inspectedId;
-    constructor(ctx, tui) {
+    constructor(ctx, tui, options = {}) {
         this.#ctx = ctx;
         this.#tui = tui;
+        this.#recentRowsPath = options.stateDir === undefined ? undefined : join(options.stateDir, 'recent-sessions.json');
+        this.#upgradeMarkerPath = options.stateDir === undefined ? undefined : join(options.stateDir, 'sessions-upgraded.json');
+        this.#tracker = new SubagentTracker({
+            rootId: () => this.#active?.handle.agent.id,
+            depth: (session) => {
+                const rootId = this.#active?.handle.agent.id;
+                return rootId === undefined ? undefined : descendantDepth(session, rootId, this.#lookupSession);
+            },
+            agentStatus: id => this.#ctx.get('agents')?.get(SessionId(id))?.status,
+            sessions: () => this.#ctx.get('sessions')?.list() ?? [],
+            listChildren: rootId => this.#ctx.get('subagents')?.listChildren(SessionId(rootId)),
+            publish: (roster) => {
+                this.#tui.setSubagents(roster);
+                if (this.#inspectedId === undefined)
+                    return;
+                this.#tui.setInspectedSubagent(this.#inspectView(this.#inspectedId));
+            },
+        });
         this.#off.push(tui.onInspectSubagent(id => { void this.#inspectSubagent(id); }));
         this.#off.push(tui.onInspectClose(() => { this.#closeInspect(); }));
         this.#off.push(tui.onInspectSubmit(submission => { void this.#steerInspected(submission); }));
@@ -443,8 +453,13 @@ export class SessionRuntime {
         }
         const jobs = this.#ctx.get('jobs');
         if (jobs !== undefined) {
-            this.#off.push(jobs.onJobDone((snapshot, owner) => {
-                const notice = jobNoticeFor(snapshot, owner, this.#active?.handle.agent);
+            // Settlements speak session ids, so the owning Agent is resolved here;
+            // a job whose owner is gone has no notice to show.
+            this.#off.push(jobs.events.subscribe({ owners: 'scope' }, (event) => {
+                if (event.type !== 'settled')
+                    return;
+                const owner = event.job.owner === undefined ? undefined : this.#ctx.get('agents')?.get(event.job.owner);
+                const notice = jobNoticeFor(event.job, owner, this.#active?.handle.agent);
                 if (notice !== undefined)
                     tui.notice(notice);
             }));
@@ -457,16 +472,13 @@ export class SessionRuntime {
             }
             if (payload.agent.id === this.#inspectedId)
                 tui.setStatus(payload.status);
-            this.#noteSubagentStatus(payload.agent.session, payload.status);
+            this.#tracker.noteStatus(payload.agent.session, payload.status);
         }));
         this.#off.push(ctx.on('session/created', (session) => {
-            this.#noteSubagentSession(session);
+            this.#tracker.noteSession(session);
         }));
         this.#off.push(ctx.on('session/disposed', (session) => {
-            if (!this.#subagents.owns(session.id))
-                return;
-            this.#subagents.setAgentStatus(session.id, 'gone');
-            this.#pushSubagents();
+            this.#tracker.noteGone(session);
         }));
         this.#off.push(ctx.on('session/event', (session, event) => {
             const active = this.#active;
@@ -475,7 +487,7 @@ export class SessionRuntime {
             if (session.id === this.#inspectedId) {
                 const child = ctx.get('agents')?.get(session.id);
                 tui.event(event, child === undefined ? undefined : ctx.get('tuiToolPresentation')?.event(child, event));
-                this.#noteSubagentEvent(session, event);
+                this.#tracker.noteEvent(session, event);
                 return;
             }
             if (session === active.handle.agent.session) {
@@ -483,14 +495,14 @@ export class SessionRuntime {
                     tui.event(event, ctx.get('tuiToolPresentation')?.event(active.handle.agent, event));
                 }
                 if (event.type === 'subagent/catalog')
-                    this.#observeCatalogChildren(session, [event]);
+                    this.#tracker.observeCatalog(session, [event]);
                 if (shouldRefreshSessionInfoAfter(event))
                     this.#pushSessionInfo();
                 if (event.type === 'session/title')
                     void this.refreshRecent();
                 return;
             }
-            this.#noteSubagentEvent(session, event);
+            this.#tracker.noteEvent(session, event);
         }));
         // Format v2 moved live assistant increments off the session log. The
         // durable `session/event` firehose now carries only settlements; chunk
@@ -535,6 +547,13 @@ export class SessionRuntime {
                     this.#pushSessionInfo();
             }));
         }
+        // One-time per session format, off the first render: stored logs an earlier
+        // release wrote get their current-format generation here rather than on the
+        // next listing or search that has to decode them.
+        ctx.inject(['sessionPersistence'], (persistenceCtx) => {
+            void this.#upgradeStoredSessions(persistenceCtx.sessionPersistence)
+                .catch((error) => { persistenceCtx.logger.warn(error); });
+        });
     }
     get agent() {
         return this.#active?.handle.agent;
@@ -688,7 +707,6 @@ export class SessionRuntime {
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
-            disposeToolPresentation: configuration.disposeToolPresentation,
         });
         await this.refreshRecent();
     }
@@ -760,10 +778,7 @@ export class SessionRuntime {
         if (message?.type !== 'user/message' || message.data.source.kind !== 'user') {
             throw new Error('The selected conversation turn is no longer available.');
         }
-        const text = message.data.content
-            .filter((block) => block.type === 'text')
-            .map(block => block.text)
-            .join('\n');
+        const text = blocksText(message.data.content);
         const imageRefs = message.data.content
             .filter((block) => block.type === 'image')
             .map(block => block.attachment);
@@ -820,7 +835,6 @@ export class SessionRuntime {
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
-            disposeToolPresentation: configuration.disposeToolPresentation,
         });
         this.#tui.restoreInput({ text, images });
         this.#tui.notice(`Rewound to before turn ${selected.turn}. The original session remains available in /resume.`);
@@ -867,15 +881,7 @@ export class SessionRuntime {
         const active = this.#requiredActive();
         if (active.agentPreset === id)
             return active.agentPreset;
-        const previousPreset = active.agentPreset;
         const preset = await this.#ctx.agentPresets.recompose(agent.ctx, id);
-        try {
-            this.#replaceToolPresentation(active, toolPresentationForPreset(preset.id));
-        }
-        catch (error) {
-            await this.#ctx.agentPresets.recompose(agent.ctx, previousPreset);
-            throw error;
-        }
         active.agentPreset = preset.id;
         agent.session.append('agent-preset/selected', { agentPreset: preset.id });
         this.#pushTools();
@@ -895,6 +901,50 @@ export class SessionRuntime {
         this.#pushSessionInfo();
         return outcome;
     }
+    /**
+     * Publish a current-format generation for every stored session an earlier
+     * release wrote. A read open never upgrades a log, so without this pass
+     * every listing and search keeps decoding the historical corpus — the pass
+     * runs once per session format, in the background, and skips a session
+     * another live process owns.
+     */
+    async #upgradeStoredSessions(persistence) {
+        const markerPath = this.#upgradeMarkerPath;
+        if (markerPath === undefined)
+            return;
+        const marker = readJsonFile(markerPath);
+        if (typeof marker?.sessionFormat === 'number' && marker.sessionFormat >= SESSION_FORMAT_VERSION)
+            return;
+        const before = await persistence.list();
+        const revisions = new Map(before.map(snapshot => [String(snapshot.header.id), snapshot.revision]));
+        const active = this.#active?.handle.agent.id;
+        for (const snapshot of before) {
+            if (this.#disposed)
+                return;
+            if (String(snapshot.header.id) === active)
+                continue;
+            try {
+                const handle = await persistence.open(snapshot.header.id, 'write');
+                await handle.close();
+            }
+            catch (error) {
+                // Another process owns it, or the log is unreadable: leave it alone.
+                if (!(error instanceof SessionAlreadyOwnedError))
+                    this.#ctx.logger.debug(error);
+            }
+        }
+        if (this.#disposed)
+            return;
+        let upgraded = 0;
+        for (const snapshot of await persistence.list()) {
+            if (revisions.get(String(snapshot.header.id)) !== snapshot.revision)
+                upgraded += 1;
+        }
+        writeJsonAtomic(markerPath, { sessionFormat: SESSION_FORMAT_VERSION });
+        if (upgraded > 0) {
+            this.#tui.notice(`Upgraded ${upgraded} stored session${upgraded === 1 ? '' : 's'} to the current format.`);
+        }
+    }
     async refreshRecent() {
         // Coalesce concurrent callers: the recent list is one snapshot, and a
         // burst of title/status events must not queue a read of every stored log.
@@ -924,24 +974,40 @@ export class SessionRuntime {
         }
         const snapshots = (await persistence.list()).filter(snapshot => snapshot.header.origin !== 'subagent')
             .sort((left, right) => right.header.createdAt - left.header.createdAt);
+        // A stored row stays valid while its revision holds, so a cold process
+        // renders labels for unchanged sessions without reading their logs; only a
+        // new or changed session pays a read.
+        if (!this.#recentRowsLoaded && this.#recentRowsPath !== undefined) {
+            this.#recentRowsLoaded = true;
+            for (const [id, memo] of readRecentRows(this.#recentRowsPath))
+                this.#recentCache.set(id, memo);
+        }
         const rows = [];
+        let memoChanged = false;
         const liveIds = new Set(snapshots.map(snapshot => snapshot.header.id));
-        for (const id of this.#recentCache.keys())
-            if (!liveIds.has(id))
-                this.#recentCache.delete(id);
+        for (const id of this.#recentCache.keys()) {
+            if (liveIds.has(id))
+                continue;
+            this.#recentCache.delete(id);
+            memoChanged = true;
+        }
         for (const snapshot of snapshots) {
             const header = snapshot.header;
             const cached = this.#recentCache.get(header.id);
             if (cached?.revision === snapshot.revision) {
-                rows.push(cached.row);
+                if (cached.row !== null)
+                    rows.push(cached.row);
                 continue;
             }
             try {
                 const log = await readColdSessionLog(persistence, header.id);
                 const status = recentSessionStatus(log.events);
                 const content = recentSessionContent(log.events);
-                if (content === undefined)
+                if (content === undefined) {
+                    this.#recentCache.set(header.id, { revision: snapshot.revision, row: null });
+                    memoChanged = true;
                     continue;
+                }
                 const row = {
                     id: header.id,
                     ...content,
@@ -951,12 +1017,15 @@ export class SessionRuntime {
                     ...(status === undefined ? {} : { status }),
                 };
                 this.#recentCache.set(header.id, { revision: snapshot.revision, row });
+                memoChanged = true;
                 rows.push(row);
             }
             catch {
                 rows.push({ id: header.id, title: '(unavailable session)', createdAt: header.createdAt });
             }
         }
+        if (memoChanged && this.#recentRowsPath !== undefined)
+            writeRecentRows(this.#recentRowsPath, this.#recentCache);
         this.#recent = rows;
         this.#pushSessionInfo();
     }
@@ -964,10 +1033,9 @@ export class SessionRuntime {
         if (this.#disposed)
             return;
         this.#disposed = true;
-        this.#subagentEpoch += 1;
         this.#activationEpoch += 1;
         this.#inspectedId = undefined;
-        this.#subagents.reset();
+        this.#tracker.reset();
         this.#tui.setInspectedSubagent(undefined);
         this.#tui.setSubagents(undefined);
         this.#tui.setSessionSearch();
@@ -1006,9 +1074,30 @@ export class SessionRuntime {
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
-            disposeToolPresentation: configuration.disposeToolPresentation,
         };
     }
+    /**
+     * Claim the activated session into the cwd workspace so grouped session
+     * surfaces (the harness web sidebar) file it instead of leaving it
+     * ungrouped. Best-effort like `#resolveModelInfo`: the registry is an
+     * optional service and a failed claim must not disturb activation.
+     */
+    async #claimWorkspace(active) {
+        const registry = this.#ctx.get('workspaceRegistry');
+        if (registry === undefined)
+            return;
+        try {
+            const { session } = active.handle.agent;
+            const cwd = session.header.cwd;
+            if (cwd === undefined)
+                return;
+            const workspace = await registry.resolveByPath(cwd) ?? await registry.create(cwd);
+            await workspace.attachSession(session.id);
+        }
+        catch {
+            // The workspace claim is cosmetic interop; the session itself is fine.
+        }
+    }
     async #resolveModelInfo(selection) {
         try {
             return await this.#ctx.get('llm')?.resolveModelInfo(selection.provider, selection.model);
@@ -1026,6 +1115,7 @@ export class SessionRuntime {
         const previous = this.#active;
         const epoch = ++this.#activationEpoch;
         this.#active = next;
+        void this.#claimWorkspace(next);
         try {
             this.#presentAgent(next);
             const selected = this.selection(next.handle.agent);
@@ -1093,7 +1183,7 @@ export class SessionRuntime {
         this.#inspectedId = undefined;
         this.#tui.setInspectedSubagent(undefined);
         this.#tui.setStatus(agent.status);
-        this.#syncSubagents();
+        this.#tracker.sync();
         // Seed welcome metadata before replaceSession commits the startup header to
         // native scrollback; later updates cannot rewrite that frozen first frame.
         this.#pushSessionInfo();
@@ -1163,45 +1253,6 @@ export class SessionRuntime {
         return list.find(skill => skill.name === name && isUserInvocable(skill));
     }
     #lookupSession = (id) => this.#ctx.get('sessions')?.get(SessionId(id));
-    #subagentDepth(session) {
-        const rootId = this.#active?.handle.agent.id;
-        if (rootId === undefined)
-            return undefined;
-        return descendantDepth(session, rootId, this.#lookupSession);
-    }
-    #noteSubagentSession(session) {
-        const depth = this.#subagentDepth(session);
-        if (depth === undefined)
-            return;
-        const parentId = session.header.parentSession;
-        this.#subagents.remember({
-            id: session.id,
-            ...(parentId === undefined ? {} : { parentId }),
-            depth,
-            phase: this.#ctx.get('agents')?.get(session.id)?.status === 'running' ? 'running' : 'starting',
-        });
-        this.#pushSubagents();
-    }
-    #noteSubagentEvent(session, event) {
-        const depth = this.#subagentDepth(session);
-        if (depth === undefined)
-            return;
-        this.#subagents.apply(session, depth, event, this.#ctx.get('agents')?.get(session.id)?.status);
-        this.#pushSubagents();
-    }
-    /**
-     * Add the direct children a Session's durable catalog declares.
-     *
-     * The live roster is built from `session/created` and child events, so a
-     * resumed parent would otherwise show nothing: its children are neither
-     * loaded nor replayed. Catalog facts are durable, so a restored roster still
-     * lists those children, and `#inspectSubagent` opens each transcript from
-     * disk. Children the live path already knows keep their own state.
-     */
-    #observeCatalogChildren(session, events) {
-        if (this.#subagents.observeCatalog(session.id, events))
-            this.#pushSubagents();
-    }
     /** Route live output only to the visible session; background frames remain buffered for inspection. */
     #forwardLiveDelta(agent, delta) {
         const active = this.#active;
@@ -1229,57 +1280,8 @@ export class SessionRuntime {
                 this.#tui.streamDelta(delta);
         }
     }
-    #noteSubagentStatus(session, status) {
-        if (this.#subagents.owns(session.id)) {
-            this.#subagents.setAgentStatus(session.id, status);
-            this.#pushSubagents();
-            return;
-        }
-        const depth = this.#subagentDepth(session);
-        if (depth === undefined)
-            return;
-        this.#subagents.hydrate(session, depth, this.#ctx.get('agents')?.get(session.id)?.status ?? status);
-        this.#pushSubagents();
-    }
-    #syncSubagents() {
-        const root = this.#active?.handle.agent;
-        const epoch = this.#subagentEpoch + 1;
-        this.#subagentEpoch = epoch;
-        if (root === undefined) {
-            this.#subagents.reset();
-            this.#tui.setSubagents(undefined);
-            return;
-        }
-        this.#subagents.reset(root.id);
-        for (const session of this.#ctx.get('sessions')?.list() ?? []) {
-            const depth = descendantDepth(session, root.id, this.#lookupSession);
-            if (depth === undefined)
-                continue;
-            this.#subagents.hydrate(session, depth, this.#ctx.get('agents')?.get(session.id)?.status);
-        }
-        this.#pushSubagents();
-        const listed = this.#ctx.get('subagents')?.listChildren(root.id);
-        if (listed === undefined)
-            return;
-        void listed.then((entries) => {
-            if (epoch !== this.#subagentEpoch || this.#active?.handle.agent !== root)
-                return;
-            for (const entry of entries) {
-                if (entry.kind !== 'child')
-                    continue;
-                this.#subagents.remember({
-                    id: entry.id,
-                    depth: 1,
-                    mode: entry.mode,
-                    ...(entry.label === undefined ? {} : { label: entry.label }),
-                    phase: entry.activity === 'running' ? 'running' : 'waiting',
-                });
-            }
-            this.#pushSubagents();
-        }, () => undefined);
-    }
     #inspectView(id, fallbackPhase = 'waiting') {
-        const view = this.#subagents.snapshot()?.agents.find(agent => agent.id === id);
+        const view = this.#tracker.snapshot()?.agents.find(agent => agent.id === id);
         const mode = view?.mode;
         return {
             id,
@@ -1289,51 +1291,27 @@ export class SessionRuntime {
             writable: isSteerableSubagent(mode),
         };
     }
-    #pushSubagents() {
-        const roster = this.#subagents.snapshot();
-        if (roster === this.#publishedSubagents)
-            return;
-        this.#publishedSubagents = roster;
-        this.#tui.setSubagents(roster);
-        if (this.#inspectedId === undefined)
-            return;
-        this.#tui.setInspectedSubagent(this.#inspectView(this.#inspectedId));
-    }
     #pushSessionInfo() {
         const active = this.#active;
         if (active === undefined)
             return;
         const agent = active.handle.agent;
         const projection = this.#projection(active);
-        const title = explicitSessionTitle(agent.session.snapshotEvents());
+        // One snapshot feeds both folds; each append invalidates the session's
+        // cached snapshot, so a second call would pay another O(log) copy.
+        const events = agent.session.snapshotEvents();
+        const title = explicitSessionTitle(events);
         this.#tui.setSession({
             id: agent.id,
             ...(title === undefined ? {} : { title }),
             recent: this.#recent.filter(row => row.id !== agent.id),
-            stats: this.#stats(active, projection),
+            stats: sessionStats(events, active.contextWindow, projection),
             controls: this.#sessionControls(active, projection),
         });
     }
-    #replaceToolPresentation(active, mode) {
-        const previousMode = toolPresentationForPreset(active.agentPreset);
-        active.disposeToolPresentation();
-        try {
-            const tools = active.handle.agent.ctx.get('tools');
-            if (tools === undefined)
-                throw new Error('tool registry is unavailable');
-            active.disposeToolPresentation = tools.presentAs(mode);
-        }
-        catch (error) {
-            const tools = active.handle.agent.ctx.get('tools');
-            if (tools === undefined)
-                throw error;
-            active.disposeToolPresentation = tools.presentAs(previousMode);
-            throw error;
-        }
-    }
     #replaceTranscript(agent) {
         const events = agent.session.snapshotEvents();
-        this.#observeCatalogChildren(agent.session, events);
+        this.#tracker.observeCatalog(agent.session, events);
         this.#tui.replaceSession(events, this.#ctx.get('tuiToolPresentation')?.session(agent, events), agent.status);
         this.#replayLivePrefix(agent.session.id);
     }
@@ -1361,7 +1339,7 @@ export class SessionRuntime {
     async #inspectSubagent(id) {
         const request = this.#inspectEpoch + 1;
         this.#inspectEpoch = request;
-        if (!this.#subagents.owns(id)) {
+        if (!this.#tracker.owns(id)) {
             this.#tui.notice('That subagent is no longer available.', { level: 'error' });
             return;
         }
@@ -1408,7 +1386,7 @@ export class SessionRuntime {
             return;
         }
         const live = this.#ctx.get('sessions')?.get(SessionId(childId));
-        const rosterParent = this.#subagents.snapshot()?.agents.find(agent => agent.id === childId)?.parentId;
+        const rosterParent = this.#tracker.snapshot()?.agents.find(agent => agent.id === childId)?.parentId;
         const parentId = live?.header.parentSession ?? rosterParent;
         const parent = parentId === undefined || parentId === root.id
             ? root