@agi-fans/dsh-tui 0.22.0 → 0.23.1

package/lib/session/session-controller.js

@@ -6,16 +6,21 @@
  * sessions, projections, command routing, and cleanup stay behind one API.
  * @module @agi-fans/dsh-tui/session-controller
  */
+import { openGoalControls } from "./goal-controls.js";
+import { continuableFailure } from "./generation-continuation.js";
+import { workflowMemberStatus, workflowOptions } from "../views/workflow.js";
 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 { createUserMessage, } from '@deepseek-ai/dsh-llm';
-import { isUserInvocable } from '@deepseek-ai/dsh-skill';
+import { CommandAttachments, encodeCommandAttachments } from "./command-attachments.js";
+export { encodeCommandAttachments } from "./command-attachments.js";
+import { isModelInvocable, isUserInvocable } from '@deepseek-ai/dsh-skill';
+import { BUILTIN_SLASH_COMMANDS } from "../views/autocomplete.js";
 import { readColdSessionLog } from '@deepseek-ai/dsh-session-query';
 import { appendPluginRecord, pluginRecordOf, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
-import { queueHostSubagentPrompt } from '@deepseek-ai/dsh-subagent/internal';
+import { queueHostSubagentPrompt, steerHostSubagentPrompt } 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";
@@ -24,7 +29,7 @@ import { buildSessionTree, markedSessionTree, sessionTreeFamily } from "./sessio
 export { conversationTurns } from "./conversation-turns.js";
 import { jobNoticeFor } from "./job-notice.js";
 import { descendantDepth, isSteerableSubagent } from "./subagent-roster.js";
-import { readRecentRows, writeRecentRows, readSessionLibrary, sessionLibraryPath, setSessionLabel } from "./session-library.js";
+import { readRecentRows, writeRecentRows, readSessionLibrary, sessionArgumentOptions, sessionLibraryPath, setSessionLabel } from "./session-library.js";
 import { currentWorkingDirectory } from "./working-directory.js";
 import { SubagentTracker } from "./subagent-tracker.js";
 import { commandPermission } from "../commands/permission.js";
@@ -33,8 +38,8 @@ import { BTW_PRESET } from "../runtime/btw-policy.js";
 import { reviewFileRecovery } from "../runtime/file-recovery-review.js";
 import { isBlankSession, } from "./session-configuration.js";
 import { stripComposerImageMarkers } from "../input/image-paste.js";
-async function setupAgentContext(agentCtx, agent, selection) {
-    const configured = await configureAgentContext(agentCtx, agent, selection);
+async function setupAgentContext(agentCtx, agent) {
+    const configured = await configureAgentContext(agentCtx, agent);
     await agentCtx.plugin(commandPermission(agent));
     return configured;
 }
@@ -45,10 +50,14 @@ function parseControl(line) {
     return { name: match[1].toLowerCase(), input: match[2]?.trim() ?? '' };
 }
 /** Present only the session controls whose owning Harness plugins are composed. */
-export function sessionControls(projection) {
+export function sessionControls(projection, livePlan) {
     const override = projection?.sandboxMode;
+    // Host pending is a target value, while the UI projection says whether a
+    // change remains. Cancelling a pending change can retain the current target.
+    const plan = livePlan === undefined ? projection?.plan
+        : { active: livePlan.active, pending: livePlan.pending !== undefined && livePlan.pending !== livePlan.active };
     return {
-        ...(projection?.plan === undefined ? {} : { plan: { ...projection.plan } }),
+        ...(plan === undefined ? {} : { plan: { ...plan } }),
         // A logged sandbox override (for example an approved widening) is the mode
         // actually in force; the preset only describes the user's standing choice.
         ...(override == null
@@ -286,15 +295,13 @@ function recentSessionStatus(events) {
     return 'interrupted';
 }
 /** Convert the human-visible part of a skill catalog into slash commands. */
-export function userSkillCommands(skills) {
-    return skills.filter(isUserInvocable).map(skill => ({
-        name: `skill:${skill.name}`,
+export function userSkillCommands(skills, reserved = new Set()) {
+    return skills.filter(skill => isUserInvocable(skill) && !reserved.has(skill.name)).map(skill => ({
+        name: skill.name,
         description: compactDescription(skill.description),
+        skill: { userOnly: !isModelInvocable(skill) },
     }));
 }
-function skillNameFromCommand(name) {
-    return name.startsWith('skill:') ? name.slice('skill:'.length) : name;
-}
 function compactDescription(value, maxLength = 140) {
     const normalized = value.replace(/\s+/gu, ' ').trim();
     return normalized.length <= maxLength ? normalized : normalized.slice(0, maxLength - 1).trimEnd() + '…';
@@ -329,9 +336,16 @@ export async function createSubmissionMessage(submission, attachments) {
                     content.push({ type: 'text', text: segment.text });
                 continue;
             }
-            const attachment = refs[segment.index];
-            if (attachment !== undefined)
-                content.push({ type: 'image', attachment });
+            if (segment.kind === 'file') {
+                const attachment = submission.files?.[segment.index];
+                if (attachment !== undefined)
+                    content.push({ type: 'file', attachment });
+            }
+            else {
+                const attachment = refs[segment.index];
+                if (attachment !== undefined)
+                    content.push({ type: 'image', attachment });
+            }
         }
         // An attachment the composer did not mark in the text still belongs to the
         // message: keep it rather than dropping it with the marker.
@@ -340,22 +354,16 @@ export async function createSubmissionMessage(submission, attachments) {
             if (!placedImages.has(index))
                 content.push({ type: 'image', attachment });
         }
-        for (const attachment of submission.files ?? [])
-            content.push({ type: 'file', attachment });
+        const placedFiles = new Set(submission.segments.flatMap(segment => segment.kind === 'file' ? [segment.index] : []));
+        for (const [index, attachment] of (submission.files ?? []).entries()) {
+            if (!placedFiles.has(index))
+                content.push({ type: 'file', attachment });
+        }
     }
     if (content.length === 0)
         throw new Error('Cannot submit an empty message.');
     return createUserMessage({ content, source: { kind: 'user' } });
 }
-/** Encode composer drafts for `ctx.commands.execute`. */
-export function encodeCommandAttachments(images) {
-    return images.map(image => ({
-        type: 'image',
-        mediaType: image.mediaType,
-        data: Buffer.from(image.data).toString('base64'),
-        ...(image.name === undefined ? {} : { name: image.name }),
-    }));
-}
 /** Rehydrate one durable human inbox message into an editable composer draft. */
 export async function restoreSubmissionMessage(message, attachments) {
     const text = blocksText(message.content);
@@ -378,31 +386,52 @@ export async function restoreSubmissionMessage(message, attachments) {
         };
     }));
     const files = message.content.filter((block) => block.type === 'file').map(block => block.attachment);
-    return { text, images, ...(files.length === 0 ? {} : { files }) };
+    let imageIndex = 0, fileIndex = 0;
+    const segments = message.content.flatMap(block => {
+        if (block.type === 'text')
+            return [{ kind: 'text', text: block.text }];
+        if (block.type === 'image')
+            return [{ kind: 'image', index: imageIndex++ }];
+        if (block.type === 'file')
+            return [{ kind: 'file', index: fileIndex++ }];
+        return [];
+    });
+    return { text, images, ...(files.length === 0 ? {} : { files }),
+        ...(images.length === 0 && files.length === 0 ? {} : { segments }) };
+}
+/** The live selection succeeded, but the profile default still needs saving. */
+export class DefaultModelSaveError extends Error {
+    constructor(selection, cause) {
+        super(`Session model is now ${selection.provider}/${selection.model}. The default model could not be saved.`, { cause });
+        this.name = 'DefaultModelSaveError';
+    }
 }
 /** Own one switchable top-level Agent and project it onto a TuiService. */
 export class SessionRuntime {
+    #commandAttachments;
     #workflows = new WorkflowProjection();
     #ctx;
     #tui;
     #active;
     #recent = [];
     #archivedSessions = new Set();
-    #skillCommands = [];
+    #skills = [];
     /**
      * Live argument vocabularies, keyed by command.
      *
      * A snapshot rather than a callback into the services: completion runs on every
-     * keystroke and must not await a catalog. It is rebuilt whenever the commands
-     * are pushed, which is also when a model or provider list can have changed.
+     * keystroke and must not await a catalog. Session refreshes publish recent
+     * rows immediately and load each provider independently.
      */
     #argumentOptions = new Map();
+    #argumentEpoch = 0;
     #started = false;
     #retired = [];
     // Weak: deduplication must not retain disposed session graphs.
     #releasedHandles = new WeakSet();
     #disposed = false;
     #queueAbort;
+    #workflowAbort;
     #off = [];
     #tracker;
     #streamAttempts = new LiveAttemptTracker();
@@ -413,11 +442,21 @@ export class SessionRuntime {
     #refreshInFlight = null;
     #refreshDirty = false;
     #inspectEpoch = 0;
+    #inspectDeliveryTail = Promise.resolve();
+    #activeInteraction = new AbortController();
+    #pendingSends = new Map();
+    #inspectDeliveries = new Set();
+    #descendantApprovals = new Map();
     #activationEpoch = 0;
     #inspectedId;
     constructor(ctx, tui, options = {}) {
         this.#ctx = ctx;
         this.#tui = tui;
+        const commands = ctx.get('commands');
+        if (commands !== undefined) {
+            this.#commandAttachments = new CommandAttachments(commands);
+            this.#off.push(() => this.#commandAttachments?.dispose());
+        }
         this.#libraryPath = sessionLibraryPath(options.stateDir);
         this.#recentRowsPath = options.stateDir === undefined ? undefined : join(options.stateDir, 'recent-sessions.json');
         this.#tracker = new SubagentTracker({
@@ -436,9 +475,24 @@ export class SessionRuntime {
                 this.#tui.setInspectedSubagent(this.#inspectView(this.#inspectedId));
             },
         });
-        this.#off.push(tui.setSteerHandler(text => { steerAgent(this.agent, text); }));
+        const offGoal = tui.setGoalHandler?.(signal => openGoalControls(ctx, tui, this.#requiredAgent(), AbortSignal.any([signal, this.interactionSignal])));
+        if (offGoal !== undefined)
+            this.#off.push(offGoal);
         this.#off.push(tui.setQueueHandler(signal => this.openQueue(signal)));
+        const offContinue = tui.setContinueHandler?.(async (request) => {
+            const agent = this.#requiredAgent();
+            if (agent.id !== request.sessionId)
+                throw new Error('The continuation belongs to another session.');
+            await this.continueGeneration(agent, request.failureSeq);
+        });
+        if (offContinue !== undefined)
+            this.#off.push(offContinue);
         this.#off.push(tui.onInspectSubagent(id => { void this.#inspectSubagent(id); }));
+        const offWorkflow = tui.onInspectWorkflow?.(id => {
+            void this.openWorkflow(id).catch(error => { this.#tui.notice(error instanceof Error ? error.message : String(error), { level: 'error' }); });
+        });
+        if (offWorkflow !== undefined)
+            this.#off.push(offWorkflow);
         this.#off.push(tui.onInspectClose(() => { this.#closeInspect(); }));
         this.#off.push(tui.onInspectSubmit(submission => { void this.#steerInspected(submission); }));
         tui.setSessionSearch(async (query, signal) => {
@@ -489,6 +543,7 @@ export class SessionRuntime {
         this.#off.push(ctx.on('agent/status', (payload) => {
             if (payload.agent === this.#active?.handle.agent) {
                 tui.setStatus(payload.status, { root: true });
+                this.#pushSessionInfo();
                 return;
             }
             if (payload.agent.id === this.#inspectedId)
@@ -512,8 +567,10 @@ export class SessionRuntime {
                 if (session.id === (this.#inspectedId ?? active.handle.agent.id)) {
                     tui.setWorkingDirectory?.(currentWorkingDirectory(ctx, session));
                 }
-                if (session === active.handle.agent.session)
+                if (session === active.handle.agent.session) {
                     void this.#refreshSkills().catch(error => { ctx.logger.warn(error); });
+                    void this.refreshRecent().catch(error => { ctx.logger.warn(error); });
+                }
             }
             if (session.id === this.#inspectedId) {
                 const child = ctx.get('agents')?.get(session.id);
@@ -560,6 +617,10 @@ export class SessionRuntime {
             if (delta !== undefined)
                 this.#forwardLiveDelta(payload.agent, delta);
         }, { global: true }));
+        this.#off.push(ctx.on('goal/activation-changed', payload => {
+            if (payload.sessionId === this.#active?.handle.agent.session.id)
+                this.#pushSessionInfo();
+        }));
         if (ctx.get('commands') !== undefined) {
             this.#off.push(ctx.on('commands/change', () => { this.#pushCommands(); }));
         }
@@ -585,6 +646,8 @@ export class SessionRuntime {
             }));
         }
     }
+    /** Presentation requests from a replaced root must not survive into its successor. */
+    get interactionSignal() { return this.#activeInteraction.signal; }
     get agent() {
         return this.#active?.handle.agent;
     }
@@ -597,10 +660,48 @@ export class SessionRuntime {
             return false;
         const root = this.#active?.handle.agent;
         if (root !== undefined) {
-            this.#ctx.get('subagents')?.interrupt(SessionId(this.#inspectedId), { kind: 'ancestor', agent: root });
+            try {
+                this.#ctx.get('subagents')?.interrupt(SessionId(this.#inspectedId), { kind: 'ancestor', agent: root });
+            }
+            catch (error) {
+                this.#tui.notice(error instanceof Error ? error.message : String(error), { level: 'error' });
+            }
         }
         return true;
     }
+    #isOwnedDescendant(agent, root) {
+        const agents = this.#ctx.get('agents');
+        if (agents?.get(agent.id) !== agent
+            || descendantDepth(agent.session, root.id, this.#lookupSession) === undefined)
+            return false;
+        // Durable lineage alone also matches an independently resumed runtime root.
+        let child = agent;
+        while (child !== root) {
+            const parentId = child.session.header.parentSession;
+            const parent = parentId === undefined ? undefined : agents.get(parentId);
+            if (parent === undefined || !agents.isOwnedBy(child.id, parent))
+                return false;
+            child = parent;
+        }
+        return true;
+    }
+    /** Accept only live descendants of the active root for shared approval prompts. */
+    beginSubagentApproval(agent) {
+        const root = this.agent;
+        if (root === undefined || !this.#isOwnedDescendant(agent, root))
+            return undefined;
+        this.#tracker.noteSession(agent.session);
+        const abort = new AbortController();
+        this.#descendantApprovals.set(abort, root);
+        const finish = this.#tracker.beginApprovalRequest(agent.id);
+        const off = this.#ctx.on('agent/disposed', event => { if (event.agent === agent)
+            abort.abort(); });
+        return { label: this.#inspectView(agent.id).label, signal: abort.signal, finish: () => {
+                off();
+                this.#descendantApprovals.delete(abort);
+                finish();
+            } };
+    }
     async start() {
         if (this.#started)
             return;
@@ -611,77 +712,266 @@ export class SessionRuntime {
         await this.refreshRecent();
         await this.#activate(await this.#create(defaults), 'initial');
     }
-    /** Submit one human composer value; active turns retain it as a later follow-up. */
+    /** Admit a complete composer value through the selected Harness inbox entry. */
     async send(input, agent = this.#requiredAgent()) {
-        this.assertActive(agent);
         const submission = typeof input === 'string' ? { text: input, images: [] } : input;
-        const message = await createSubmissionMessage(submission, this.#ctx.get('attachments'));
-        this.assertActive(agent);
-        agent.followup(message);
+        await this.#sendSubmission(submission, agent);
     }
-    async openQueue(signal, agent = this.#requiredAgent()) {
+    async #sendSubmission(submission, agent, signal) {
+        const assertDelivery = () => {
+            signal?.throwIfAborted();
+            this.assertActive(agent);
+            if (submission.delivery === 'steer' && agent.status !== 'running') {
+                throw new Error('Steering needs an active turn. Use Enter to send the next message.');
+            }
+        };
+        assertDelivery();
+        this.#pendingSends.set(agent, (this.#pendingSends.get(agent) ?? 0) + 1);
+        try {
+            const message = await createSubmissionMessage(submission, this.#ctx.get('attachments'));
+            assertDelivery();
+            this.#tui.pendingInputs?.prepare?.(submission, message.id);
+            this.#admit(agent, message, submission.delivery);
+        }
+        finally {
+            const remaining = (this.#pendingSends.get(agent) ?? 1) - 1;
+            if (remaining === 0)
+                this.#pendingSends.delete(agent);
+            else
+                this.#pendingSends.set(agent, remaining);
+        }
+    }
+    #admit(agent, message, delivery) {
+        const offset = agent.session.snapshotEvents().length;
+        try {
+            if (delivery === 'steer')
+                agent.steer(message);
+            else
+                agent.followup(message);
+        }
+        catch (error) {
+            // An event subscriber may throw after admission, even after the message was claimed.
+            // Only a pre-admission failure may return the submission to the composer.
+            const accepted = agent.session.snapshotEvents().slice(offset).some(event => event.type === 'agent/inbox/spliced' && event.data.inserted.some(item => item.id === message.id));
+            if (!accepted)
+                throw error;
+            this.#tui.notice(error instanceof Error ? error.message : String(error), { level: 'error' });
+        }
+    }
+    #assertCanRepeat(agent, signal) {
+        signal?.throwIfAborted();
         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('Return to the parent session to continue or resend a prompt.');
+        if (agent.status !== 'idle' || this.#pendingSends.has(agent))
+            throw new Error('Wait for the current work to finish before continuing or resending.');
+        if (agent.inbox.nextTurn.length > 0 || agent.inbox.nextStep.some(message => message.source.kind === 'user')
+            || (this.#tui.pendingInputs?.list().length ?? 0) > 0)
+            throw new Error('Resolve pending input in /queue before continuing or resending.');
+        if (this.#descendantApprovals.size > 0 || this.#ctx.get('sessionProjections')?.snapshot(agent.session).values.userQuestions?.active.some(question => question.state !== 'continued')) {
+            throw new Error('Answer the pending question or approval before continuing or resending.');
+        }
+    }
+    /** Wake an eligible failed generation with empty retry input; never duplicate the original prompt. */
+    async continueGeneration(agent = this.#requiredAgent(), expectedFailure, signal) {
+        this.#assertCanRepeat(agent, signal);
+        await agent.runMaintenance(async (maintenance) => {
+            maintenance.throwIfAborted();
+            this.#assertCanRepeat(agent, signal);
+            const failure = continuableFailure(agent.session.snapshotEvents());
+            if (failure === undefined || expectedFailure !== undefined && expectedFailure !== failure) {
+                throw new Error('No recoverable model failure is available to continue. Use /retry to resend the last prompt.');
+            }
+            this.#admit(agent, createUserMessage({ content: [], source: { kind: 'retry' } }));
+        });
+    }
+    /** Explicitly resend the complete latest human message with a fresh Harness identity. */
+    async retryLastPrompt(agent = this.#requiredAgent(), signal) {
+        this.#assertCanRepeat(agent, signal);
+        return agent.runMaintenance(async (maintenance) => {
+            maintenance.throwIfAborted();
+            this.#assertCanRepeat(agent, signal);
+            const previous = agent.session.snapshotEvents().findLast(event => event.type === 'user/message'
+                && event.data.source.kind === 'user' && event.data.content.length > 0);
+            if (previous?.type !== 'user/message')
+                return false;
+            this.#admit(agent, createUserMessage({ content: previous.data.content, source: { kind: 'user' } }));
+            return true;
+        });
+    }
+    /** Resolve one visible live inbox, retaining its identity across asynchronous UI work. */
+    #queueTarget() {
+        const root = this.#requiredAgent();
+        const inspectedId = this.#inspectedId;
+        if (inspectedId !== undefined && !this.#inspectView(inspectedId).writable)
+            throw new Error('This subagent is read-only.');
+        const agent = inspectedId === undefined ? root : this.#ctx.get('agents')?.get(SessionId(inspectedId));
+        if (agent === undefined)
+            throw new Error('This subagent is not loaded locally. Send it a message to continue before managing its queue.');
+        const check = () => {
+            this.assertActive(root);
+            if (this.#inspectedId !== inspectedId || inspectedId !== undefined && !this.#isOwnedDescendant(agent, root)) {
+                throw new Error('The queue session is no longer active.');
+            }
+        };
+        check();
+        return { agent, check, ...(inspectedId === undefined ? {} : { label: this.#inspectView(inspectedId).label }) };
+    }
+    async openQueue(signal, requestingAgent) {
+        if (requestingAgent !== undefined)
+            this.assertActive(requestingAgent);
+        const target = this.#queueTarget();
+        const { agent } = target;
+        if (this.#queueAbort !== undefined && !this.#queueAbort.signal.aborted)
             throw new Error('Message Queue is already open.');
+        // Validate recall state before opening; child views must never list parent delivery entries.
+        this.#tui.pendingInputs.list();
         const abort = new AbortController();
         this.#queueAbort = abort;
         const onAbort = () => { abort.abort(signal.reason); };
         signal.addEventListener('abort', onAbort, { once: true });
         if (signal.aborted)
             onAbort();
+        const off = this.#ctx.on('agent/disposed', event => { if (event.agent === agent)
+            abort.abort(); });
         try {
-            await openMessageQueue({ agent, tui: this.#tui, signal: abort.signal, assertActive: () => { this.assertActive(agent); },
+            await openMessageQueue({ agent, signal: abort.signal, assertActive: target.check,
+                ...(target.label === undefined ? {} : { ownerLabel: target.label }),
+                tui: {
+                    prompt: request => this.#tui.prompt(request), notice: (text, options) => this.#tui.notice(text, options),
+                    restoreInput: submission => this.#tui.restoreInput(submission, agent.id),
+                    pendingInputs: target.label === undefined ? this.#tui.pendingInputs : { list: () => [], update: () => false },
+                },
                 restore: message => restoreSubmissionMessage(message, this.#ctx.get('attachments')) });
         }
+        catch (error) {
+            if (!abort.signal.aborted)
+                throw error;
+        }
         finally {
+            off();
             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);
+    /** Inspect durable membership; only a currently running, owned local member can be opened. */
+    async openWorkflow(id) {
+        const root = this.#requiredAgent();
+        const inspectedId = this.#inspectedId;
+        this.#workflowAbort?.abort();
+        const abort = new AbortController();
+        this.#workflowAbort = abort;
+        const check = () => {
+            abort.signal.throwIfAborted();
+            this.assertActive(root);
+            if (this.#inspectedId !== inspectedId)
+                throw new Error('The workflow session is no longer active.');
+        };
+        const canOpen = (run, member) => {
+            const child = this.#ctx.get('agents')?.get(SessionId(member.childId));
+            return workflowMemberStatus(run, member) === 'open' && child?.status === 'running'
+                && child.session.header.parentSession === root.id && this.#isOwnedDescendant(child, root) && this.#tracker.owns(child.id);
+        };
+        try {
+            let lastRun;
+            let lastOpen = '';
+            let options = [];
+            const refresh = () => {
+                check();
+                const run = this.#workflows.get(id);
+                if (run === undefined)
+                    throw new Error('This workflow is no longer available.');
+                const open = run.members.filter(member => canOpen(run, member)).map(member => member.seq).join(',');
+                if (run !== lastRun || open !== lastOpen) {
+                    options = workflowOptions(run, member => canOpen(run, member));
+                    lastRun = run;
+                    lastOpen = open;
+                }
+                return options;
+            };
+            let selected;
+            while (!abort.signal.aborted) {
+                const answer = await this.#tui.prompt({ title: 'Workflow',
+                    question: 'Browse phases and members. Only running local members can be opened.',
+                    localize: ['title', 'question'], notify: false, options: refresh(), refreshOptions: refresh,
+                    presentation: 'tree', filterable: true, allowCustom: false, submitLabel: 'open',
+                    emptyText: 'No matching workflow members.', signal: abort.signal,
+                    ...(selected === undefined ? {} : { initialValue: selected }) });
+                if (answer === null)
+                    return;
+                check();
+                selected = answer;
+                const run = this.#workflows.get(id);
+                const member = run?.members.find(member => `member:${member.seq}` === answer);
+                if (run === undefined || member === undefined || !canOpen(run, member)) {
+                    this.#tui.notice('This workflow member is no longer available to open.');
+                    continue;
+                }
+                await this.#inspectSubagent(member.childId);
+                return;
+            }
+        }
+        catch (error) {
+            if (!abort.signal.aborted)
+                throw error;
+        }
+        finally {
+            if (this.#workflowAbort === abort)
+                this.#workflowAbort = undefined;
+        }
+    }
+    /** Rehydrate before withdrawing so navigation or missing attachments leave the inbox intact. */
+    async editLatestFollowup(request) {
+        request?.signal.throwIfAborted();
+        const target = this.#queueTarget();
+        const { agent } = target;
+        if (request?.sessionId !== undefined && request.sessionId !== agent.id)
+            throw new Error('The queue session is no longer active.');
         const message = agent.inbox.nextTurn.findLast(candidate => candidate.source.kind === 'user');
         if (message === undefined)
             return undefined;
         const submission = await restoreSubmissionMessage(message, this.#ctx.get('attachments'));
-        this.assertActive(agent);
-        return agent.inbox.remove(message.id) ? { ...submission, literal: true } : undefined;
+        request?.signal.throwIfAborted();
+        target.check();
+        return agent.inbox.remove(message.id) ? { ...submission, literal: true, delivery: 'queue' } : undefined;
     }
     /** Execute a plugin-owned slash command, falling back to user-invocable skills. */
-    async execute(line, signal, images = []) {
+    async execute(input, signal, images = []) {
+        const submission = typeof input === 'string' ? { text: input, images } : input;
+        const { text: line } = submission;
+        images = submission.images;
         const commandLine = stripComposerImageMarkers(line, images);
         const parsed = parseControl(commandLine);
         if (parsed === undefined)
             return false;
         const commands = this.#ctx.get('commands');
+        const agent = this.#requiredAgent();
+        const staged = this.#commandAttachments?.stage(agent, submission);
         const execution = await (async () => {
             try {
-                return await commands?.execute(this.#requiredAgent(), commandLine, encodeCommandAttachments(images), signal);
+                return await commands?.execute(agent, commandLine, staged?.attachments ?? encodeCommandAttachments(images), signal);
             }
             finally {
+                staged?.dispose();
                 await this.#disposeRetired();
             }
         })();
         if (execution === undefined) {
-            const skill = await this.#findUserSkill(skillNameFromCommand(parsed.name), signal);
+            const skill = await this.#findUserSkill(parsed.name, signal);
+            signal.throwIfAborted();
+            this.assertActive(agent);
             if (skill === undefined)
                 return false;
-            if (images.length > 0) {
-                this.#tui.restoreInput({ text: line, images });
-                this.#tui.notice(`/${parsed.name} does not accept image attachments`, { level: 'error' });
-                return true;
-            }
-            await this.send('/' + skill.name + (parsed.input === '' ? '' : ' ' + parsed.input));
+            await this.#sendSubmission(submission, agent, signal);
             return true;
         }
         const result = execution.result;
-        if (result.kind === 'error' && images.length > 0)
-            this.#tui.restoreInput({ text: line, images });
-        if (result.text !== undefined) {
+        if (result.kind === 'error' && (images.length > 0 || submission.files?.length))
+            this.#tui.restoreInput(submission, agent.session.id);
+        const presented = result.kind === 'success' && result.sourceEventSeq !== undefined
+            && agent.session.snapshotEvents().some(event => event.seq === result.sourceEventSeq && event.type === 'compaction/summary');
+        if (result.text !== undefined && !presented) {
             if (result.kind === 'error')
                 this.#tui.notice(result.text, { level: 'error', focus: true });
             else
@@ -700,10 +990,10 @@ export class SessionRuntime {
     get recentSessions() {
         return this.#recent;
     }
-    /** Current model selection for the active Agent. */
+    /** Current model selection for the active Agent, read from its durable projection. */
     selection(agent = this.#requiredAgent()) {
         this.assertActive(agent);
-        const current = this.#requiredActive().selection.current;
+        const current = agent.model.current();
         if (current === undefined)
             throw new Error('active agent has no model selection');
         return current;
@@ -712,34 +1002,42 @@ export class SessionRuntime {
     async changeSelection(agent, selection, info, options) {
         this.assertActive(agent);
         const active = this.#requiredActive();
-        active.selection.current = selection;
         const resolved = info ?? await this.#resolveModelInfo(selection);
+        this.assertActive(agent);
+        const current = agent.model.current();
+        if (current?.provider !== selection.provider || current.model !== selection.model || current.reasoningEffort !== selection.reasoningEffort) {
+            agent.model.select(selection);
+        }
         active.contextWindow = resolved?.context?.contextWindow;
         const status = modelStatus(selection, resolved);
         active.reasoningEffort = status.reasoningEffort;
-        if (options?.persist !== false) {
-            await this.#ctx.get('agentDefaultModel')?.saveSelection(selection);
-        }
         this.#tui.setModel(status.model, status.reasoningEffort);
         this.#pushSessionInfo();
+        if (options?.persist !== false) {
+            try {
+                await this.#ctx.get('agentDefaultModel')?.saveSelection(selection);
+            }
+            catch (error) {
+                throw new DefaultModelSaveError(selection, error);
+            }
+        }
     }
     /** Start a new top-level session with the current model selection. */
-    async newSession(agent) {
+    async newSession(agent, presetId) {
         this.assertActive(agent);
-        await this.#activate(await this.#create(this.selection(agent)), 'new');
+        await this.#activate(await this.#create(this.selection(agent), presetId), 'new');
         await this.refreshRecent();
     }
     /** Replace the active top-level session with one durable session. */
     async resumeSession(agent, id, signal) {
         this.assertActive(agent);
         const selection = this.selection(agent);
-        const ref = { current: selection, assembled: undefined };
         let configured;
         const handle = await this.#ctx.agents.resume({
             resumeSessionId: SessionId(id),
             agentOptions: { provider: selection.provider, model: selection.model },
             signal,
-            setup: async (agentCtx, agent) => { configured = await setupAgentContext(agentCtx, agent, ref); },
+            setup: async (agentCtx, agent) => { configured = await setupAgentContext(agentCtx, agent); },
         });
         const configuration = configured;
         if (configuration === undefined) {
@@ -748,7 +1046,6 @@ export class SessionRuntime {
         }
         await this.#activate({
             handle,
-            selection: ref,
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
@@ -764,12 +1061,11 @@ export class SessionRuntime {
             return;
         }
         const selection = this.selection(agent);
-        const ref = { current: selection, assembled: undefined };
         const handle = await this.#ctx.agents.resume({
             resumeSessionId: SessionId(id),
             agentOptions: { provider: selection.provider, model: selection.model },
             signal,
-            setup: async (agentCtx, agent) => { await setupAgentContext(agentCtx, agent, ref); },
+            setup: async (agentCtx, agent) => { await setupAgentContext(agentCtx, agent); },
         });
         try {
             this.#ctx.sessionTitle.rename(handle.agent.session, title);
@@ -956,7 +1252,6 @@ export class SessionRuntime {
         }));
         this.assertActive(agent);
         const selection = this.selection(agent);
-        const ref = { current: selection, assembled: undefined };
         const active = this.#requiredActive();
         let configured;
         const handle = await this.#ctx.agents.create({
@@ -971,7 +1266,12 @@ export class SessionRuntime {
             inheritedEventCount: SessionLogOffset(selected.branchIndex),
             agentOptions: { provider: selection.provider, model: selection.model },
             signal,
-            setup: async (agentCtx, agent) => { configured = await setupAgentContext(agentCtx, agent, ref); },
+            setup: async (agentCtx, agent) => {
+                // A pre-turn prefix includes admission but excludes the later inbox claim.
+                // Cancel that inherited work durably before publishing the editable fork.
+                agent.inbox.clear();
+                configured = await setupAgentContext(agentCtx, agent);
+            },
         });
         try {
             this.assertActive(agent);
@@ -987,7 +1287,6 @@ export class SessionRuntime {
         }
         await this.#activate({
             handle,
-            selection: ref,
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
@@ -1095,34 +1394,41 @@ export class SessionRuntime {
     /**
      * Rebuild the argument vocabularies the composer completes.
      *
-     * A snapshot, because completion runs per keystroke: `/model provider/model`,
-     * `/resume <id>` and `/login <provider>` are all names that already exist in
+     * A snapshot, because completion runs per keystroke. `/model provider/model`
+     * and `/resume <id>` are names that already exist in
      * this process, so the reader types toward them instead of opening a picker.
      */
     async #refreshArgumentOptions() {
-        const options = new Map();
+        const epoch = ++this.#argumentEpoch;
         const llm = this.#ctx.get('llm');
-        if (llm !== undefined) {
-            const models = [];
-            const providers = [];
-            for (const provider of llm.listProviders()) {
-                providers.push({ value: provider.id, ...(provider.name === undefined ? {} : { description: provider.name }) });
-                for (const model of await llm.listModels(provider.id)) {
-                    models.push({
-                        value: `${provider.id}/${model.id}`,
-                        ...(model.name === undefined ? {} : { description: model.name }),
-                    });
-                }
+        const providers = llm?.listProviders() ?? [];
+        const previous = this.#argumentOptions.get('model') ?? [];
+        const groups = new Map(providers.map(provider => [provider.id, previous.filter(model => model.value.startsWith(`${provider.id}/`))]));
+        const options = new Map([['resume', sessionArgumentOptions(this.#recent)]]);
+        const publish = () => {
+            if (this.#disposed || epoch !== this.#argumentEpoch)
+                return;
+            options.set('model', providers.flatMap(provider => groups.get(provider.id) ?? []));
+            this.#argumentOptions = options;
+            this.#pushCommands();
+        };
+        publish();
+        await Promise.all(providers.map(async (provider) => {
+            try {
+                const models = await llm?.listModels(provider.id) ?? [];
+                if (this.#disposed || epoch !== this.#argumentEpoch)
+                    return;
+                groups.set(provider.id, models.map(model => ({
+                    value: `${provider.id}/${model.id}`,
+                    ...(model.name === undefined ? {} : { description: model.name }),
+                })));
             }
-            options.set('model', models);
-            options.set('login', providers);
-        }
-        options.set('resume', this.#recent.map(row => ({
-            value: row.id,
-            ...(row.title === undefined ? {} : { description: row.title }),
-        })));
-        this.#argumentOptions = options;
-        this.#pushCommands();
+            catch {
+                // Preserve the last successful catalog. The model picker owns diagnostics.
+                return;
+            }
+            publish();
+        }));
     }
     async refreshRecent() {
         // Coalesce concurrent callers: the recent list is one snapshot, and a
@@ -1140,15 +1446,18 @@ export class SessionRuntime {
                     break;
                 this.#refreshDirty = false;
             }
-        })().finally(() => { this.#refreshInFlight = null; });
+        })().finally(() => {
+            this.#refreshInFlight = null;
+            // Completion must read the newly published rows, not the previous
+            // directory's snapshot while persistence.list() is still pending.
+            queueMicrotask(() => { if (!this.#disposed)
+                void this.#refreshArgumentOptions().catch(() => { }); });
+        });
         this.#refreshInFlight = run;
         return run;
     }
     async #refreshRecentNow() {
         this.#archivedSessions = new Set(readSessionLibrary(this.#libraryPath).archived);
-        // The recent list is what `/resume` completes from, so a refresh of one is a
-        // refresh of the other. Deferred to avoid recursing through #pushCommands.
-        queueMicrotask(() => { void this.#refreshArgumentOptions().catch(() => { }); });
         const persistence = this.#ctx.get('sessionPersistence');
         if (persistence === undefined) {
             this.#recent = [];
@@ -1157,6 +1466,8 @@ export class SessionRuntime {
         }
         const snapshots = (await persistence.list()).filter(snapshot => snapshot.header.origin !== 'subagent')
             .sort((left, right) => right.header.createdAt - left.header.createdAt);
+        const agent = this.agent;
+        const cwd = agent === undefined ? process.cwd() : currentWorkingDirectory(this.#ctx, agent.session);
         // 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.
@@ -1176,6 +1487,10 @@ export class SessionRuntime {
         }
         for (const snapshot of snapshots) {
             const header = snapshot.header;
+            // Scope before opening logs or consulting shared row caches. Other
+            // directories remain available through an explicit session ID.
+            if (header.cwd !== cwd)
+                continue;
             const cached = this.#recentCache.get(header.id);
             if (snapshot.formatStatus === 'migration-required') {
                 // Do not open the log merely to browse it. A previous label is a hint;
@@ -1220,10 +1535,15 @@ export class SessionRuntime {
     }
     async dispose() {
         this.#queueAbort?.abort(new Error('session runtime disposed'));
+        this.#workflowAbort?.abort();
+        for (const abort of this.#descendantApprovals.keys())
+            abort.abort();
         if (this.#disposed)
             return;
         this.#disposed = true;
+        this.#activeInteraction.abort();
         this.#activationEpoch += 1;
+        this.#cancelInspectDeliveries();
         this.#inspectedId = undefined;
         this.#tracker.reset();
         this.#tui.setInspectedSubagent(undefined);
@@ -1243,15 +1563,14 @@ export class SessionRuntime {
             this.#releasedHandles.add(handle);
         await this.#disposeHandles(handles);
     }
-    async #create(selection) {
-        const ref = { current: selection, assembled: undefined };
-        const preset = await this.#ctx.agentPresets.resolve();
+    async #create(selection, presetId) {
+        const preset = await this.#ctx.agentPresets.resolve(presetId);
         let configured;
         const handle = await this.#ctx.agents.create({
             sessionId: SessionId('session-' + randomUUID()),
             meta: { cwd: process.cwd(), agentPreset: preset.id },
             agentOptions: { provider: selection.provider, model: selection.model },
-            setup: async (agentCtx, agent) => { configured = await setupAgentContext(agentCtx, agent, ref); },
+            setup: async (agentCtx, agent) => { configured = await setupAgentContext(agentCtx, agent); },
         });
         const configuration = configured;
         if (configuration === undefined) {
@@ -1260,7 +1579,6 @@ export class SessionRuntime {
         }
         return {
             handle,
-            selection: ref,
             contextWindow: undefined,
             reasoningEffort: undefined,
             agentPreset: configuration.agentPreset,
@@ -1305,6 +1623,9 @@ export class SessionRuntime {
         const previous = this.#active;
         const epoch = ++this.#activationEpoch;
         this.#queueAbort?.abort(new Error('active session changed'));
+        this.#workflowAbort?.abort();
+        this.#activeInteraction.abort();
+        this.#activeInteraction = new AbortController();
         this.#active = next;
         void this.#claimWorkspace(next);
         try {
@@ -1338,6 +1659,8 @@ export class SessionRuntime {
             // and the activation failure remains the actionable error.
             try {
                 if (this.#activationEpoch === epoch) {
+                    this.#activeInteraction.abort();
+                    this.#activeInteraction = new AbortController();
                     this.#active = previous;
                     if (previous !== undefined) {
                         try {
@@ -1370,8 +1693,12 @@ export class SessionRuntime {
     }
     /** Show one active session on the terminal: transcript, tools, controls, model. */
     #presentAgent(active, reason = 'open') {
+        for (const [abort, root] of this.#descendantApprovals)
+            if (root !== active.handle.agent)
+                abort.abort();
         this.#workflows.reset(active.handle.agent.session.snapshotEvents());
         const agent = active.handle.agent;
+        this.#cancelInspectDeliveries();
         this.#inspectedId = undefined;
         this.#tui.setInspectedSubagent(undefined);
         this.#tui.setStatus(agent.status);
@@ -1410,8 +1737,9 @@ export class SessionRuntime {
                 ...(options === undefined ? {} : { complete: (prefix) => matchArgumentOptions(options, prefix) }),
             };
         });
-        const names = new Set(commands.map(command => command.name));
-        for (const skill of this.#skillCommands) {
+        const names = new Set([...commands.map(command => command.name),
+            ...BUILTIN_SLASH_COMMANDS.flatMap(command => [command.name, ...(command.aliases ?? [])])]);
+        for (const skill of userSkillCommands(this.#skills, names)) {
             if (names.has(skill.name))
                 continue;
             commands.push(skill);
@@ -1433,14 +1761,14 @@ export class SessionRuntime {
         const agent = this.agent;
         const skills = this.#ctx.get('skills');
         if (agent === undefined || skills === undefined) {
-            this.#skillCommands = [];
+            this.#skills = [];
         }
         else {
             const cwd = currentWorkingDirectory(this.#ctx, agent.session);
             const list = await skills.list({ cwd, scope: agent, signal });
             if (this.#disposed || this.agent !== agent || currentWorkingDirectory(this.#ctx, agent.session) !== cwd)
                 return;
-            this.#skillCommands = userSkillCommands(list);
+            this.#skills = list;
         }
         this.#pushCommands();
     }
@@ -1487,6 +1815,7 @@ export class SessionRuntime {
             id,
             label: view?.label ?? id,
             phase: view?.phase ?? fallbackPhase,
+            needsApproval: view?.needsApproval === true,
             ...(mode === undefined ? {} : { mode }),
             writable: isSteerableSubagent(mode),
         };
@@ -1512,6 +1841,7 @@ export class SessionRuntime {
     #replaceTranscript(agent, reason = 'refresh') {
         this.#tui.setWorkingDirectory?.(currentWorkingDirectory(this.#ctx, agent.session));
         const events = agent.session.snapshotEvents();
+        this.#tui.pendingInputs?.reconcile?.(agent.id, new Set(events.flatMap(event => event.type === 'agent/inbox/spliced' ? event.data.inserted.map(message => message.id) : [])));
         this.#tracker.observeCatalog(agent.session, events);
         this.#tui.replaceSession(events, this.#ctx.get('tuiToolPresentation')?.session(agent, events), agent.status, reason);
         this.#replayLivePrefix(agent.session.id);
@@ -1525,10 +1855,18 @@ export class SessionRuntime {
         if (agent !== undefined)
             this.#replaceTranscript(agent);
     }
+    #cancelInspectDeliveries() {
+        for (const delivery of this.#inspectDeliveries)
+            delivery.abort();
+        this.#inspectDeliveries.clear();
+    }
     #closeInspect() {
         if (this.#inspectedId === undefined)
             return;
         this.#inspectEpoch += 1;
+        this.#queueAbort?.abort(new Error('viewed session changed'));
+        this.#workflowAbort?.abort();
+        this.#cancelInspectDeliveries();
         this.#inspectedId = undefined;
         this.#tui.setInspectedSubagent(undefined);
         const agent = this.#active?.handle.agent;
@@ -1573,6 +1911,12 @@ export class SessionRuntime {
         }
         if (request !== this.#inspectEpoch)
             return;
+        if (this.#inspectedId !== id) {
+            this.#queueAbort?.abort(new Error('viewed session changed'));
+            this.#workflowAbort?.abort();
+            this.#cancelInspectDeliveries();
+        }
+        this.#tui.pendingInputs?.reconcile?.(id, new Set(events.flatMap(event => event.type === 'agent/inbox/spliced' ? event.data.inserted.map(message => message.id) : [])));
         this.#inspectedId = id;
         if (cwd !== undefined)
             this.#tui.setWorkingDirectory?.(cwd);
@@ -1586,12 +1930,12 @@ export class SessionRuntime {
         const childId = this.#inspectedId;
         const root = this.#active?.handle.agent;
         if (childId === undefined || root === undefined) {
-            this.#tui.restoreInput(submission);
+            this.#tui.restoreInput(submission, childId);
             return;
         }
         const view = this.#inspectView(childId);
         if (!view.writable) {
-            this.#tui.restoreInput(submission);
+            this.#tui.restoreInput(submission, childId);
             this.#tui.notice('This subagent is a completed run and cannot take more messages.');
             return;
         }
@@ -1603,34 +1947,60 @@ export class SessionRuntime {
             : this.#ctx.get('agents')?.get(SessionId(parentId));
         const subagents = this.#ctx.get('subagents');
         if (parent === undefined || subagents === undefined) {
-            this.#tui.restoreInput(submission);
+            this.#tui.restoreInput(submission, childId);
             this.#tui.notice(parent === undefined
                 ? 'The parent of this subagent is not live, so it cannot take a follow-up.'
                 : 'Subagent follow-up is unavailable in this composition.');
             return;
         }
+        const previous = this.#inspectDeliveryTail;
+        let release = () => { };
+        this.#inspectDeliveryTail = new Promise(resolve => { release = resolve; });
+        const delivery = new AbortController();
+        this.#inspectDeliveries.add(delivery);
+        let cancelUpload = () => { };
+        const cancelled = new Promise((_resolve, reject) => {
+            cancelUpload = () => { reject(delivery.signal.reason); };
+            delivery.signal.addEventListener('abort', cancelUpload, { once: true });
+        });
         try {
-            const message = await createSubmissionMessage(submission, this.#ctx.get('attachments'));
-            if (this.#inspectedId !== childId || this.#active?.handle.agent !== root) {
-                this.#tui.restoreInput(submission);
-                return;
-            }
-            await queueHostSubagentPrompt(subagents, parent, SessionId(childId), message.content, { kind: 'user' }, new AbortController().signal);
+            // Recalled messages can include attachments; admission must retain submission order.
+            await Promise.race([previous, cancelled]);
+            delivery.signal.throwIfAborted();
+            // Attachment storage need not support cancellation; release the draft now
+            // and ignore a later upload result before crossing Harness admission.
+            const message = await Promise.race([createSubmissionMessage(submission, this.#ctx.get('attachments')), cancelled]);
+            delivery.signal.removeEventListener('abort', cancelUpload);
+            delivery.signal.throwIfAborted();
+            if (this.#inspectedId !== childId || this.#active?.handle.agent !== root)
+                throw new Error('The viewed session changed before delivery.');
+            const send = submission.delivery === 'steer' ? steerHostSubagentPrompt : queueHostSubagentPrompt;
+            const messageId = await send(subagents, parent, SessionId(childId), message.content, { kind: 'user' }, delivery.signal);
+            this.#tui.pendingInputs?.prepare?.(submission, messageId);
+            this.#tui.pendingInputs?.acknowledge?.(submission);
         }
         catch (error) {
-            this.#tui.restoreInput(submission);
-            this.#tui.notice(error instanceof Error ? error.message : String(error), { level: 'error' });
+            this.#tui.restoreInput(submission, childId);
+            if (!delivery.signal.aborted)
+                this.#tui.notice(error instanceof Error ? error.message : String(error), { level: 'error' });
+        }
+        finally {
+            delivery.signal.removeEventListener('abort', cancelUpload);
+            this.#inspectDeliveries.delete(delivery);
+            release();
         }
     }
     #sessionControls(active, projection) {
-        const controls = sessionControls(projection);
-        const livePlan = this.#ctx.get('planMode')?.get(active.handle.agent);
+        const liveGoal = this.#ctx.get('goals')?.get(active.handle.agent);
+        const controls = sessionControls(projection, this.#ctx.get('planMode')?.get(active.handle.agent));
+        if (controls.goal !== undefined && liveGoal !== undefined && liveGoal.id === projection?.goal?.goal.id && liveGoal.revision === projection?.goal?.goal.revision) {
+            controls.goal.activation = liveGoal.activation;
+        }
+        const failure = active.handle.agent.status === 'idle' ? continuableFailure(active.handle.agent.session.snapshotEvents()) : undefined;
         return {
             ...controls,
+            ...(failure === undefined ? {} : { continuation: failure }),
             agentPreset: active.agentPreset,
-            ...(livePlan === undefined
-                ? {}
-                : { plan: { active: livePlan.active, pending: livePlan.pending !== undefined } }),
         };
     }
     /** Read one client-visible snapshot. Host-only projection state is never consulted. */
@@ -1672,6 +2042,7 @@ export function matchArgumentOptions(options, prefix) {
     if (lower === '')
         return options;
     return options.filter(option => option.value.toLowerCase().includes(lower)
+        || (option.label ?? '').toLowerCase().includes(lower)
         || (option.description ?? '').toLowerCase().includes(lower));
 }
 //# sourceMappingURL=session-controller.js.map