@agi-fans/dsh-tui 0.18.0 → 0.20.0

package/lib/session/session-controller.d.ts

@@ -19,6 +19,8 @@ import type { SessionStatsProjection } from '@deepseek-ai/dsh-session-stats/type
 import type { ContextBreakdownProjection, ContextPressureProjection, TokenUsageProjection } from '@deepseek-ai/dsh-token-meter/client';
 import { type SessionEvent } from '@deepseek-ai/dsh-session';
 import type { GoalProjection } from '@deepseek-ai/dsh-goal/types';
+import type { UserQuestionProjectionView } from '@deepseek-ai/dsh-user-questions';
+export { conversationTurns, type ConversationTurn } from './conversation-turns.ts';
 import type { TuiCommand, TuiRecentSession, TuiService, TuiSessionControls, TuiSessionStats, TuiSubmission, TuiInputImage } from '../definition.ts';
 import type { ContextDiagnostics } from './context-diagnostics.ts';
 /** Projection values consumed as one consistent snapshot when the units exist. */
@@ -30,6 +32,7 @@ export interface TuiStatsProjection {
     plan?: PlanProjection;
     permissions?: PermissionSelection;
     goal?: GoalProjection | null;
+    userQuestions?: UserQuestionProjectionView;
     /** Last logged sandbox-mode override, or null before one; outranks the preset while set. */
     sandboxMode?: 'read-only' | 'workspace-write' | 'danger-full-access' | null;
 }
@@ -53,21 +56,6 @@ export declare function sessionStats(events: readonly SessionEvent[], contextWin
  * fallback fold when projections are absent.
  */
 export declare function shouldRefreshSessionInfoAfter(event: SessionEvent): boolean;
-/** One direct human turn that can become a safe fork boundary. */
-export interface ConversationTurn {
-    /** Harness turn number shown to the user. */
-    turn: number;
-    /** Index of the direct user/message event in the immutable log. */
-    messageIndex: number;
-    /** Balanced seed boundary immediately before this turn starts. */
-    branchIndex: number;
-    /** Single-line selector preview. */
-    preview: string;
-    /** Number of image blocks in the selected message. */
-    imageCount: number;
-}
-/** Find direct human messages whose preceding log prefix is safe to seed into a fork. */
-export declare function conversationTurns(events: readonly SessionEvent[]): ConversationTurn[];
 /** Title and latest-human-message preview for durable session discovery. */
 export declare function recentSessionContent(events: readonly SessionEvent[]): {
     title: string;
@@ -86,6 +74,9 @@ export declare function createSubmissionMessage(submission: TuiSubmission, attac
     content: ({
         type: "image";
         attachment: ImageAttachmentRef;
+    } | {
+        type: "file";
+        attachment: import("@deepseek-ai/dsh-attachment").FileAttachmentRef;
     } | {
         type: "text";
         text: string;
@@ -113,12 +104,15 @@ export declare class SessionRuntime {
     start(): Promise<void>;
     /** Submit one human composer value; active turns retain it as a later follow-up. */
     send(input: string | TuiSubmission, agent?: Agent): Promise<void>;
+    openQueue(signal: AbortSignal, agent?: Agent): Promise<void>;
     /** Remove and rehydrate the newest durable human follow-up for queue browsing. */
     editLatestFollowup(agent?: Agent): Promise<TuiSubmission | undefined>;
     /** Execute a plugin-owned slash command, falling back to user-invocable skills. */
     execute(line: string, signal: AbortSignal, images?: readonly TuiInputImage[]): Promise<boolean>;
     /** Fail when a command invocation targets a stale or background Agent. */
     assertActive(agent: Agent): void;
+    /** Shared local metadata document for Session Library and Tree actions. */
+    get sessionLibraryPath(): string;
     /** Immutable recent-session view used by the resume command. */
     get recentSessions(): readonly TuiRecentSession[];
     /** Current model selection for the active Agent. */
@@ -133,8 +127,8 @@ export declare class SessionRuntime {
     resumeSession(agent: Agent, id: string, signal: AbortSignal): Promise<void>;
     /** Rename a live or durable top-level session through the public log-backed title service. */
     renameSession(agent: Agent, id: string, title: string, signal: AbortSignal): Promise<void>;
-    /** Fork before a selected human turn and restore that message as an editable draft. */
-    rewindToTurn(signal: AbortSignal): Promise<void>;
+    /** Browse conversation forks and preview turns before editing or continuing a branch. */
+    openSessionTree(signal: AbortSignal): Promise<void>;
     /** Whole-session figures for the active Agent. */
     stats(agent?: Agent): TuiSessionStats;
     /** Current client-visible context projections, read as one consistent snapshot. */
@@ -152,4 +146,3 @@ export declare class SessionRuntime {
     refreshRecent(): Promise<void>;
     dispose(): Promise<void>;
 }
-export {};

package/lib/session/session-controller.js

@@ -7,6 +7,9 @@
  * @module @agi-fans/dsh-tui/session-controller
  */
 import { randomUUID } from 'node:crypto';
+import { steerAgent } from "./steering.js";
+import { openMessageQueue } from "./message-queue.js";
+import { WorkflowProjection } from "./workflow-projection.js";
 import { join } from 'node:path';
 import { installModelSelection, } from '@deepseek-ai/dsh-agent';
 import { createUserMessage, } from '@deepseek-ai/dsh-llm';
@@ -18,9 +21,12 @@ 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 { conversationTurns } from "./conversation-turns.js";
+import { buildSessionTree, markedSessionTree, sessionTreeFamily } from "./session-tree.js";
+export { conversationTurns } from "./conversation-turns.js";
 import { jobNoticeFor } from "./job-notice.js";
 import { descendantDepth, isSteerableSubagent } from "./subagent-roster.js";
-import { readRecentRows, writeRecentRows } from "./session-library.js";
+import { readRecentRows, writeRecentRows, readSessionLibrary, sessionLibraryPath, setSessionLabel } from "./session-library.js";
 import { readJsonFile, writeJsonAtomic } from "./json-file.js";
 import { SubagentTracker } from "./subagent-tracker.js";
 import { commandPermission } from "../commands/permission.js";
@@ -55,6 +61,9 @@ export function sessionControls(projection) {
             ? (projection?.permissions === undefined ? {} : { permission: projection.permissions.currentValue })
             : { permission: override }),
         ...goalControl(projection?.goal),
+        ...(projection?.userQuestions === undefined ? {} : {
+            pendingQuestions: projection.userQuestions.active.filter(question => question.state === 'continued').length,
+        }),
     };
 }
 /** A completed goal renders nothing, mirroring the projection's own visibility rule. */
@@ -252,37 +261,6 @@ function humanMessageText(event) {
     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. */
-export function conversationTurns(events) {
-    const turns = [];
-    let open;
-    for (let index = 0; index < events.length; index += 1) {
-        const event = events[index];
-        if (event.type === 'turn/start') {
-            open = { turn: event.data.turn, branchIndex: index };
-            continue;
-        }
-        if (event.type === 'turn/end') {
-            if (open?.turn === event.data.turn)
-                open = undefined;
-            continue;
-        }
-        if (open === undefined || event.type !== 'user/message' || event.data.source.kind !== 'user')
-            continue;
-        const text = blocksText(event.data.content, { collapse: true });
-        const imageCount = event.data.content.filter(block => block.type === 'image').length;
-        if (text === '' && imageCount === 0)
-            continue;
-        turns.push({
-            turn: open.turn,
-            messageIndex: index,
-            branchIndex: open.branchIndex,
-            preview: text === '' ? (imageCount === 1 ? 'Image' : `${imageCount} images`) : text,
-            imageCount,
-        });
-    }
-    return turns;
-}
 /** Title and latest-human-message preview for durable session discovery. */
 export function recentSessionContent(events) {
     const generatedTitle = explicitSessionTitle(events);
@@ -342,6 +320,7 @@ export async function createSubmissionMessage(submission, attachments) {
     const content = [
         ...(submission.text === '' ? [] : [{ type: 'text', text: submission.text }]),
         ...refs.map(attachment => ({ type: 'image', attachment })),
+        ...(submission.files ?? []).map(attachment => ({ type: 'file', attachment })),
     ];
     if (content.length === 0)
         throw new Error('Cannot submit an empty message.');
@@ -377,24 +356,29 @@ export async function restoreSubmissionMessage(message, attachments) {
             height: stored.ref.height,
         };
     }));
-    return { text, images };
+    const files = message.content.filter((block) => block.type === 'file').map(block => block.attachment);
+    return { text, images, ...(files.length === 0 ? {} : { files }) };
 }
 /** Own one switchable top-level Agent and project it onto a TuiService. */
 export class SessionRuntime {
+    #workflows = new WorkflowProjection();
     #ctx;
     #tui;
     #active;
     #recent = [];
+    #archivedSessions = new Set();
     #skillCommands = [];
     #started = false;
     #retired = [];
     // Weak: deduplication must not retain disposed session graphs.
     #releasedHandles = new WeakSet();
     #disposed = false;
+    #queueAbort;
     #off = [];
     #tracker;
     #streamAttempts = new LiveAttemptTracker();
     #recentCache = new Map();
+    #libraryPath;
     #recentRowsPath;
     #upgradeMarkerPath;
     #recentRowsLoaded = false;
@@ -406,6 +390,7 @@ export class SessionRuntime {
     constructor(ctx, tui, options = {}) {
         this.#ctx = ctx;
         this.#tui = tui;
+        this.#libraryPath = sessionLibraryPath(options.stateDir);
         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({
@@ -418,12 +403,14 @@ export class SessionRuntime {
             sessions: () => this.#ctx.get('sessions')?.list() ?? [],
             listChildren: rootId => this.#ctx.get('subagents')?.listChildren(SessionId(rootId)),
             publish: (roster) => {
-                this.#tui.setSubagents(roster);
+                this.#tui.setSubagents(this.#workflows.roster(roster));
                 if (this.#inspectedId === undefined)
                     return;
                 this.#tui.setInspectedSubagent(this.#inspectView(this.#inspectedId));
             },
         });
+        this.#off.push(tui.setSteerHandler(text => { steerAgent(this.agent, text); }));
+        this.#off.push(tui.setQueueHandler(signal => this.openQueue(signal)));
         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); }));
@@ -460,14 +447,21 @@ export class SessionRuntime {
                     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);
+                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) => {
             if (payload.agent === this.#active?.handle.agent) {
-                if (this.#inspectedId === undefined)
-                    tui.setStatus(payload.status);
+                tui.setStatus(payload.status, { root: true });
                 return;
             }
             if (payload.agent.id === this.#inspectedId)
@@ -491,9 +485,13 @@ export class SessionRuntime {
                 return;
             }
             if (session === active.handle.agent.session) {
+                if (this.#workflows.apply(event))
+                    tui.setSubagents(this.#workflows.roster(this.#tracker.snapshot()));
                 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))
@@ -543,7 +541,7 @@ export class SessionRuntime {
                 if (session !== this.#active?.handle.agent.session)
                     return;
                 if (key === 'sessionStats' || key === 'tokenUsage' || key === 'contextPressure' || key === 'contextBreakdown'
-                    || key === 'plan' || key === 'permissions' || key === 'goal')
+                    || key === 'plan' || key === 'permissions' || key === 'goal' || key === 'userQuestions')
                     this.#pushSessionInfo();
             }));
         }
@@ -579,7 +577,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()) {
@@ -589,24 +587,37 @@ export class SessionRuntime {
         this.assertActive(agent);
         agent.followup(message);
     }
+    async openQueue(signal, agent = this.#requiredAgent()) {
+        this.assertActive(agent);
+        if (this.#inspectedId !== undefined)
+            throw new Error('Return to the parent session to manage queued messages.');
+        if (this.#queueAbort !== undefined)
+            throw new Error('Message Queue is already open.');
+        const abort = new AbortController();
+        this.#queueAbort = abort;
+        const onAbort = () => { abort.abort(signal.reason); };
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+        try {
+            await openMessageQueue({ agent, tui: this.#tui, signal: abort.signal, assertActive: () => { this.assertActive(agent); },
+                restore: message => restoreSubmissionMessage(message, this.#ctx.get('attachments')) });
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+            if (this.#queueAbort === abort)
+                this.#queueAbort = undefined;
+        }
+    }
     /** Remove and rehydrate the newest durable human follow-up for queue browsing. */
     async editLatestFollowup(agent = this.#requiredAgent()) {
         this.assertActive(agent);
         const message = agent.inbox.nextTurn.findLast(candidate => candidate.source.kind === 'user');
-        if (message === undefined || !agent.inbox.remove(message.id))
+        if (message === undefined)
             return undefined;
-        try {
-            const submission = await restoreSubmissionMessage(message, this.#ctx.get('attachments'));
-            this.assertActive(agent);
-            return submission;
-        }
-        catch (error) {
-            try {
-                agent.inbox.append('next-turn', message);
-            }
-            catch { /* agent retired or message was restored elsewhere */ }
-            throw error;
-        }
+        const submission = await restoreSubmissionMessage(message, this.#ctx.get('attachments'));
+        this.assertActive(agent);
+        return agent.inbox.remove(message.id) ? { ...submission, literal: true } : undefined;
     }
     /** Execute a plugin-owned slash command, falling back to user-invocable skills. */
     async execute(line, signal, images = []) {
@@ -640,9 +651,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;
     }
@@ -651,6 +662,8 @@ export class SessionRuntime {
         if (agent !== this.#requiredAgent())
             throw new Error('the command does not target the active omdsh session');
     }
+    /** Shared local metadata document for Session Library and Tree actions. */
+    get sessionLibraryPath() { return this.#libraryPath; }
     /** Immutable recent-session view used by the resume command. */
     get recentSessions() {
         return this.#recent;
@@ -681,7 +694,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. */
@@ -734,44 +747,143 @@ export class SessionRuntime {
         }
         await this.refreshRecent();
     }
-    /** Fork before a selected human turn and restore that message as an editable draft. */
-    async rewindToTurn(signal) {
+    /** Browse conversation forks and preview turns before editing or continuing a branch. */
+    async openSessionTree(signal) {
         const agent = this.#requiredAgent();
         if (agent.status !== 'idle')
             return;
-        const events = agent.session.snapshotEvents();
-        const turns = conversationTurns(events);
-        if (turns.length === 0) {
-            this.#tui.notice('No conversation turns are available to rewind.');
-            return;
+        const persistence = this.#ctx.get('sessionPersistence');
+        const snapshots = persistence === undefined ? [] : await persistence.list({ signal });
+        const candidates = snapshots.filter(item => item.header.origin !== 'subagent'
+            && item.header.cwd === agent.session.header.cwd).map(item => ({
+            id: String(item.header.id),
+            ...(item.header.isSeeded && item.header.parentSession !== undefined ? { parentId: String(item.header.parentSession) } : {}),
+        }));
+        const current = { id: String(agent.id),
+            ...(agent.session.header.isSeeded && agent.session.header.parentSession !== undefined
+                ? { parentId: String(agent.session.header.parentSession) } : {}) };
+        const headers = [...candidates.filter(item => item.id !== current.id), current];
+        const family = sessionTreeFamily(headers, current.id);
+        const branches = [];
+        for (const header of headers) {
+            if (!family.has(header.id))
+                continue;
+            signal.throwIfAborted();
+            if (header.id === current.id) {
+                const events = agent.session.snapshotEvents();
+                const title = explicitSessionTitle(events.slice(header.parentId === undefined ? 0 : Number(agent.session.inheritedEventCount)));
+                branches.push({ ...header, events, inheritedEventCount: Number(agent.session.inheritedEventCount), ...(title === undefined ? {} : { title }),
+                    ...(agent.session.header.agentPreset === undefined ? {} : { agentPreset: agent.session.header.agentPreset }) });
+            }
+            else if (persistence !== undefined) {
+                const log = await readColdSessionLog(persistence, SessionId(header.id), signal);
+                const title = explicitSessionTitle(log.events.slice(header.parentId === undefined ? 0 : Number(log.inheritedEventCount)));
+                branches.push({ ...header, events: log.events, inheritedEventCount: Number(log.inheritedEventCount), ...(title === undefined ? {} : { title }),
+                    ...(log.header.agentPreset === undefined ? {} : { agentPreset: log.header.agentPreset }) });
+            }
         }
-        const newestFirst = [...turns].reverse();
-        const answer = await this.#tui.prompt({
-            title: 'Rewind Conversation',
-            question: '',
-            detail: 'original session preserved',
-            options: newestFirst.map(turn => ({
-                label: `Turn ${turn.turn}`,
-                value: String(turn.messageIndex),
-                preview: turn.preview,
-                description: turn.imageCount === 0
-                    ? 'Branch before this message'
-                    : `Branch before this message · ${turn.imageCount} ${turn.imageCount === 1 ? 'image' : 'images'}`,
-            })),
-            initialValue: String(newestFirst[0]?.messageIndex),
-            presentation: 'fullscreen-list',
-            optionLayout: 'spacious',
-            filterable: true,
-            allowCustom: false,
-            submitLabel: 'rewind',
-            signal,
-        });
-        if (answer === null)
-            return;
         this.assertActive(agent);
         if (agent.status !== 'idle')
-            throw new Error('Finish or interrupt the active turn before rewinding.');
-        const selected = turns.find(turn => String(turn.messageIndex) === answer);
+            return;
+        const nodes = buildSessionTree(branches, current.id);
+        if (!nodes.some(node => node.kind === 'turn')) {
+            this.#tui.notice('No conversation turns are available in the Session Tree.');
+            return;
+        }
+        const target = nodes.findLast(node => node.sessionId === current.id && node.kind === 'turn')
+            ?? nodes.find(node => node.sessionId === current.id);
+        let markedOnly = false;
+        let selectedId = target?.id;
+        let answer;
+        while (true) {
+            const library = readSessionLibrary(this.#libraryPath);
+            const visible = markedOnly ? markedSessionTree(nodes, library.labels) : nodes;
+            answer = await this.#tui.prompt({
+                title: markedOnly ? 'Session Tree · Marked' : 'Session Tree', question: '', notify: false,
+                emptyText: 'No marked nodes. Alt+B shows the full tree.',
+                options: visible.map(node => {
+                    const label = library.labels[node.id];
+                    return {
+                        label: label === undefined ? node.label : `◆ ${label} · ${node.label}`,
+                        value: node.id, ...(node.parentId === undefined ? {} : { parentValue: node.parentId }),
+                        preview: node.preview, description: node.description,
+                        submitLabel: node.kind === 'turn' ? 'edit from here' : 'continue branch',
+                        ...(node.current ? { badge: { label: 'Current', tone: 'success' } } : {}),
+                    };
+                }),
+                actions: [
+                    { key: 'Alt+Enter', label: 'continue branch', valuePrefix: 'continue:' },
+                    { key: 'Alt+L', label: 'label', valuePrefix: 'label:' },
+                    { key: 'Alt+U', label: 'clear label', valuePrefix: 'unlabel:' },
+                    { key: 'Alt+B', label: markedOnly ? 'full tree' : 'marked nodes', valuePrefix: 'marked:', scope: 'list' },
+                ],
+                ...(selectedId === undefined ? {} : { initialValue: selectedId }), presentation: 'fullscreen-tree', filterable: true, allowCustom: false, signal,
+            });
+            if (answer === null)
+                return;
+            this.assertActive(agent);
+            signal.throwIfAborted();
+            if (agent.status !== 'idle')
+                throw new Error('Finish or interrupt the active turn before navigating the Session Tree.');
+            if (answer === 'marked:') {
+                markedOnly = !markedOnly;
+                continue;
+            }
+            const clear = answer.startsWith('unlabel:');
+            if (clear || answer.startsWith('label:')) {
+                const id = answer.slice(clear ? 'unlabel:'.length : 'label:'.length);
+                const node = visible.find(item => item.id === id);
+                if (node === undefined)
+                    continue;
+                selectedId = id;
+                if (clear) {
+                    setSessionLabel(this.#libraryPath, id, '');
+                    continue;
+                }
+                let draft = library.labels[id] ?? '';
+                let error;
+                while (true) {
+                    const label = await this.#tui.prompt({
+                        title: 'Label Conversation Node', question: `Label for ${node.label}`,
+                        initialInput: draft, detail: error ?? 'Up to 120 characters. Alt+U in the tree clears a label.',
+                        allowCustom: true, notify: false, signal,
+                    });
+                    if (label === null)
+                        break;
+                    this.assertActive(agent);
+                    signal.throwIfAborted();
+                    try {
+                        setSessionLabel(this.#libraryPath, id, label);
+                        break;
+                    }
+                    catch (failure) {
+                        error = failure instanceof Error ? failure.message : String(failure);
+                        draft = label;
+                    }
+                }
+                continue;
+            }
+            break;
+        }
+        const continuing = answer.startsWith('continue:');
+        const node = nodes.find(item => item.id === (continuing ? answer.slice('continue:'.length) : answer));
+        if (node === undefined)
+            throw new Error('The selected conversation node is no longer available.');
+        if (continuing || node.kind === 'branch') {
+            if (node.sessionId === current.id) {
+                this.#tui.notice('This branch is already active.');
+                return;
+            }
+            await this.resumeSession(agent, node.sessionId, signal);
+            this.#tui.notice('Continued the selected conversation branch.');
+            return;
+        }
+        // Draft preparation forks the selected branch; browsing itself never activates it.
+        const source = branches.find(branch => branch.id === node.sessionId);
+        if (source === undefined)
+            throw new Error('The selected conversation branch is no longer available.');
+        const events = source.events;
+        const selected = conversationTurns(events).find(turn => turn.messageIndex === node.messageIndex);
         if (selected === undefined)
             throw new Error('The selected conversation turn is no longer available.');
         const message = events[selected.messageIndex];
@@ -808,9 +920,9 @@ export class SessionRuntime {
             seed: events.slice(0, selected.branchIndex),
             meta: {
                 ...(agent.session.header.cwd === undefined ? {} : { cwd: agent.session.header.cwd }),
-                parentSession: agent.id,
+                parentSession: SessionId(source.id),
                 isSeeded: true,
-                agentPreset: active.agentPreset,
+                agentPreset: source.agentPreset ?? active.agentPreset,
             },
             inheritedEventCount: SessionLogOffset(selected.branchIndex),
             agentOptions: { provider: selection.provider, model: selection.model },
@@ -836,8 +948,9 @@ export class SessionRuntime {
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
         });
-        this.#tui.restoreInput({ text, images });
-        this.#tui.notice(`Rewound to before turn ${selected.turn}. The original session remains available in /resume.`);
+        const files = message.data.content.filter((block) => block.type === 'file').map(block => block.attachment);
+        this.#tui.restoreInput({ text, images, ...(files.length === 0 ? {} : { files }) });
+        this.#tui.notice(`Editing from before turn ${selected.turn}. The original branch remains available in the Session Tree.`);
         await this.#disposeRetired();
         await this.refreshRecent();
     }
@@ -901,6 +1014,34 @@ 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
@@ -966,6 +1107,7 @@ export class SessionRuntime {
         return run;
     }
     async #refreshRecentNow() {
+        this.#archivedSessions = new Set(readSessionLibrary(this.#libraryPath).archived);
         const persistence = this.#ctx.get('sessionPersistence');
         if (persistence === undefined) {
             this.#recent = [];
@@ -1030,6 +1172,7 @@ export class SessionRuntime {
         this.#pushSessionInfo();
     }
     async dispose() {
+        this.#queueAbort?.abort(new Error('session runtime disposed'));
         if (this.#disposed)
             return;
         this.#disposed = true;
@@ -1106,7 +1249,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);
@@ -1114,10 +1257,11 @@ export class SessionRuntime {
         }
         const previous = this.#active;
         const epoch = ++this.#activationEpoch;
+        this.#queueAbort?.abort(new Error('active session changed'));
         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) {
@@ -1178,16 +1322,18 @@ export class SessionRuntime {
             this.#releaseHandle(previous.handle);
     }
     /** Show one active session on the terminal: transcript, tools, controls, model. */
-    #presentAgent(active) {
+    #presentAgent(active, reason = 'open') {
+        this.#workflows.reset(active.handle.agent.session.snapshotEvents());
         const agent = active.handle.agent;
         this.#inspectedId = undefined;
         this.#tui.setInspectedSubagent(undefined);
         this.#tui.setStatus(agent.status);
         this.#tracker.sync();
+        this.#tui.setSubagents(this.#workflows.roster(this.#tracker.snapshot()));
         // 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);
@@ -1304,15 +1450,15 @@ export class SessionRuntime {
         this.#tui.setSession({
             id: agent.id,
             ...(title === undefined ? {} : { title }),
-            recent: this.#recent.filter(row => row.id !== agent.id),
+            recent: this.#recent.filter(row => row.id !== agent.id && !this.#archivedSessions.has(row.id)),
             stats: sessionStats(events, active.contextWindow, projection),
             controls: this.#sessionControls(active, projection),
         });
     }
-    #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() {
@@ -1367,7 +1513,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');