@agi-fans/dsh-tui 0.17.0 → 0.19.0

package/lib/session/session-controller.js

@@ -7,34 +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 } 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());
@@ -393,14 +395,19 @@ export class SessionRuntime {
     #tracker;
     #streamAttempts = new LiveAttemptTracker();
     #recentCache = new Map();
+    #recentRowsPath;
+    #upgradeMarkerPath;
+    #recentRowsLoaded = false;
     #refreshInFlight = null;
     #refreshDirty = false;
     #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) => {
@@ -446,10 +453,23 @@ 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);
-                if (notice !== undefined)
-                    tui.notice(notice);
+            // 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) {
+                    const job = event.job;
+                    tui.notice(notice, {
+                        process: true, processSource: `job:${job.id}`,
+                        ...(/^(bash|pwsh)$/u.test(job.kind) && (job.status === 'completed' || job.status === 'failed' || job.status === 'killed')
+                            ? { job: { id: job.id, label: job.label, status: job.status, startedAt: job.startedAt, ...(job.detail === undefined ? {} : { detail: job.detail }) } }
+                            : {}),
+                        ...(job.status === 'failed' || job.status === 'killed' ? { level: 'error' } : {}),
+                    });
+                }
             }));
         }
         this.#off.push(ctx.on('agent/status', (payload) => {
@@ -482,6 +502,8 @@ export class SessionRuntime {
                 if (this.#inspectedId === undefined) {
                     tui.event(event, ctx.get('tuiToolPresentation')?.event(active.handle.agent, event));
                 }
+                if (event.type === 'workspace/changes')
+                    this.#serveWorkspaceSummary(ctx, tui, session, event);
                 if (event.type === 'subagent/catalog')
                     this.#tracker.observeCatalog(session, [event]);
                 if (shouldRefreshSessionInfoAfter(event))
@@ -535,6 +557,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;
@@ -560,7 +589,7 @@ export class SessionRuntime {
         if (defaults === undefined)
             throw new Error('agent default model is unavailable');
         await this.refreshRecent();
-        await this.#activate(await this.#create(defaults));
+        await this.#activate(await this.#create(defaults), 'initial');
     }
     /** Submit one human composer value; active turns retain it as a later follow-up. */
     async send(input, agent = this.#requiredAgent()) {
@@ -621,9 +650,9 @@ export class SessionRuntime {
             this.#tui.restoreInput({ text: line, images });
         if (result.text !== undefined) {
             if (result.kind === 'error')
-                this.#tui.notice(result.text, { level: 'error' });
+                this.#tui.notice(result.text, { level: 'error', focus: true });
             else
-                this.#tui.commandOutput(parsed.name, result.text);
+                this.#tui.commandOutput(parsed.name, result.text, { focus: true });
         }
         return true;
     }
@@ -662,7 +691,7 @@ export class SessionRuntime {
     /** Start a new top-level session with the current model selection. */
     async newSession(agent) {
         this.assertActive(agent);
-        await this.#activate(await this.#create(this.selection(agent)));
+        await this.#activate(await this.#create(this.selection(agent)), 'new');
         await this.refreshRecent();
     }
     /** Replace the active top-level session with one durable session. */
@@ -688,7 +717,6 @@ export class SessionRuntime {
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
-            disposeToolPresentation: configuration.disposeToolPresentation,
         });
         await this.refreshRecent();
     }
@@ -817,7 +845,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.`);
@@ -864,15 +891,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();
@@ -892,6 +911,78 @@ export class SessionRuntime {
         this.#pushSessionInfo();
         return outcome;
     }
+    /**
+     * Resolve and attach the changed-file summary a `workspace/changes` event
+     * announces.
+     *
+     * The Harness appends the event and only then files the summary under its
+     * sequence, so a listener running inside that append always reads
+     * `undefined`. The lookup is therefore deferred by one microtask, which runs
+     * after the recorder's own synchronous store, and enriches the turn-only
+     * block the transcript already rendered. A session without the plugin, or a
+     * recorder that has already been disposed, simply keeps the fallback.
+     *
+     * @param ctx - host context carrying the optional service.
+     * @param tui - the mounted presentation service.
+     * @param session - the Session that appended the event.
+     * @param event - the `workspace/changes` event.
+     */
+    #serveWorkspaceSummary(ctx, tui, session, event) {
+        const service = ctx.get('workspaceChanges');
+        if (service === undefined)
+            return;
+        const { id } = session;
+        const { seq, data } = event;
+        queueMicrotask(() => {
+            const summary = service.summary(id, seq);
+            if (summary !== undefined)
+                tui.setWorkspaceSummary(data.turn, summary);
+        });
+    }
+    /**
+     * 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.
@@ -921,24 +1012,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,
@@ -948,12 +1055,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();
     }
@@ -1002,7 +1112,6 @@ export class SessionRuntime {
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
-            disposeToolPresentation: configuration.disposeToolPresentation,
         };
     }
     /**
@@ -1035,7 +1144,7 @@ export class SessionRuntime {
             return undefined;
         }
     }
-    async #activate(next) {
+    async #activate(next, reason = 'open') {
         // Reject a late create before it publishes UI on a disposed tree.
         if (this.#disposed) {
             this.#releaseHandle(next.handle);
@@ -1046,7 +1155,7 @@ export class SessionRuntime {
         this.#active = next;
         void this.#claimWorkspace(next);
         try {
-            this.#presentAgent(next);
+            this.#presentAgent(next, reason);
             const selected = this.selection(next.handle.agent);
             const info = await this.#resolveModelInfo(selected);
             if (this.#disposed || this.#activationEpoch !== epoch) {
@@ -1107,7 +1216,7 @@ export class SessionRuntime {
             this.#releaseHandle(previous.handle);
     }
     /** Show one active session on the terminal: transcript, tools, controls, model. */
-    #presentAgent(active) {
+    #presentAgent(active, reason = 'open') {
         const agent = active.handle.agent;
         this.#inspectedId = undefined;
         this.#tui.setInspectedSubagent(undefined);
@@ -1116,7 +1225,7 @@ export class SessionRuntime {
         // Seed welcome metadata before replaceSession commits the startup header to
         // native scrollback; later updates cannot rewrite that frozen first frame.
         this.#pushSessionInfo();
-        this.#replaceTranscript(agent);
+        this.#replaceTranscript(agent, reason);
         this.#pushTools();
         this.#pushCommands();
         const selected = this.selection(agent);
@@ -1238,27 +1347,10 @@ export class SessionRuntime {
             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) {
+    #replaceTranscript(agent, reason = 'refresh') {
         const events = agent.session.snapshotEvents();
         this.#tracker.observeCatalog(agent.session, events);
-        this.#tui.replaceSession(events, this.#ctx.get('tuiToolPresentation')?.session(agent, events), agent.status);
+        this.#tui.replaceSession(events, this.#ctx.get('tuiToolPresentation')?.session(agent, events), agent.status, reason);
         this.#replayLivePrefix(agent.session.id);
     }
     #replaceVisibleTranscript() {
@@ -1313,7 +1405,7 @@ export class SessionRuntime {
             return;
         this.#inspectedId = id;
         const child = this.#ctx.get('agents')?.get(SessionId(id));
-        this.#tui.replaceSession(events, child === undefined ? undefined : this.#ctx.get('tuiToolPresentation')?.session(child, events), child?.status ?? 'idle');
+        this.#tui.replaceSession(events, child === undefined ? undefined : this.#ctx.get('tuiToolPresentation')?.session(child, events), child?.status ?? 'idle', 'refresh');
         this.#replayLivePrefix(id);
         this.#tui.setInspectedSubagent(this.#inspectView(id, child?.status === 'running' ? 'running' : 'waiting'));
         this.#tui.setStatus(child?.status ?? 'idle');