@agi-fans/dsh-tui 0.1.0

package/lib/session-controller.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Active-agent/session runtime shared by the runner and command plugins.
+ *
+ * This is the deep module between Harness runtime services and the TUI:
+ * Agent creation, replacement, persistence lookup, model selection, recent
+ * sessions, projections, command routing, and cleanup stay behind one API.
+ * @module @agi-fans/dsh-tui/session-controller
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type Agent, type ModelSelection } from '@deepseek-ai/dsh-agent';
+import { type LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
+import type { ImageAttachmentRef, SaveImageAttachment } from '@deepseek-ai/dsh-attachment';
+import type { PermissionSelect } from '@deepseek-ai/dsh-permission-presets/types';
+import type { PlanProjection } from '@deepseek-ai/dsh-plan-mode/types';
+import { type SkillSummary } from '@deepseek-ai/dsh-skill';
+import type { SessionStatsProjection } from '@deepseek-ai/dsh-session-stats/types';
+import type { ContextPressureProjection, TokenUsageProjection } from '@deepseek-ai/dsh-token-meter/client';
+import { type SessionEvent } from '@deepseek-ai/dsh-session';
+import type { TuiCommand, TuiRecentSession, TuiService, TuiSessionControls, TuiSessionStats, TuiSubmission } from './definition.ts';
+/** Projection values consumed as one consistent snapshot when the units exist. */
+export interface TuiStatsProjection {
+    sessionStats?: SessionStatsProjection;
+    tokenUsage?: TokenUsageProjection;
+    contextPressure?: ContextPressureProjection;
+    plan?: PlanProjection;
+    permissions?: PermissionSelect;
+}
+/** Present only the session controls whose owning Harness plugins are composed. */
+export declare function sessionControls(projection?: TuiStatsProjection): TuiSessionControls;
+/** Composer projection of a Harness model selection and its adapter default. */
+export declare function modelStatus(selection: ModelSelection, info?: Pick<LlmResolvedModelInfo, 'reasoning'>): {
+    model: string;
+    reasoningEffort?: string;
+};
+/** Fold a complete log as the capability-absence fallback for projections. */
+export declare function sessionStats(events: readonly SessionEvent[], contextWindow?: number, projection?: TuiStatsProjection): TuiSessionStats;
+/** Title and latest-human-message preview for durable session discovery. */
+export declare function recentSessionContent(events: readonly SessionEvent[]): {
+    title: string;
+    preview?: string;
+} | undefined;
+/** Convert the human-visible part of a skill catalog into slash commands. */
+export declare function userSkillCommands(skills: readonly SkillSummary[]): TuiCommand[];
+interface SubmissionAttachmentStore {
+    validateImage(input: SaveImageAttachment): Promise<void>;
+    saveImage(input: SaveImageAttachment): Promise<ImageAttachmentRef>;
+}
+/** Validate all drafts, persist them, then build one atomic mixed user message. */
+export declare function createSubmissionMessage(submission: TuiSubmission, attachments?: SubmissionAttachmentStore): Promise<{
+    content: ({
+        type: "image";
+        attachment: ImageAttachmentRef;
+    } | {
+        type: "text";
+        text: string;
+    })[];
+    source: {
+        kind: "user";
+    };
+} & Pick<import("@deepseek-ai/dsh-llm").UserMessage, "id" | "role">>;
+/** Own one switchable top-level Agent and project it onto a TuiService. */
+export declare class SessionRuntime {
+    #private;
+    constructor(ctx: Context, tui: TuiService);
+    get agent(): Agent | undefined;
+    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>;
+    /** Execute a plugin-owned slash command, falling back to user-invocable skills. */
+    execute(line: string, signal: AbortSignal): Promise<boolean>;
+    /** Fail when a command invocation targets a stale or background Agent. */
+    assertActive(agent: Agent): void;
+    /** Immutable recent-session view used by the resume command. */
+    get recentSessions(): readonly TuiRecentSession[];
+    /** Current model selection for the active Agent. */
+    selection(agent?: Agent): ModelSelection;
+    /** Replace the active Agent's selection and persist it as the next default. */
+    changeSelection(agent: Agent, selection: ModelSelection, info?: LlmResolvedModelInfo): Promise<void>;
+    /** Start a new top-level session with the current model selection. */
+    newSession(agent: Agent): Promise<void>;
+    /** Replace the active top-level session with one durable session. */
+    resumeSession(agent: Agent, id: string, signal: AbortSignal): Promise<void>;
+    /** Whole-session figures for the active Agent. */
+    stats(agent?: Agent): TuiSessionStats;
+    /** Effective reasoning effort after applying the selected model's adapter default. */
+    reasoningEffort(agent?: Agent): string | undefined;
+    /** Harness-owned collaboration and permission controls for the active Agent. */
+    controls(agent?: Agent): TuiSessionControls;
+    refreshRecent(): Promise<void>;
+    dispose(): Promise<void>;
+}
+export {};

package/lib/session-controller.js

@@ -0,0 +1,571 @@
+/**
+ * Active-agent/session runtime shared by the runner and command plugins.
+ *
+ * This is the deep module between Harness runtime services and the TUI:
+ * Agent creation, replacement, persistence lookup, model selection, recent
+ * sessions, projections, command routing, and cleanup stay behind one API.
+ * @module @agi-fans/dsh-tui/session-controller
+ */
+import { randomUUID } from 'node:crypto';
+import { installModelSelection, } from '@deepseek-ai/dsh-agent';
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { isTokenDelta } from '@deepseek-ai/dsh-llm/message';
+import { isUserInvocable } from '@deepseek-ai/dsh-skill';
+import { SessionId } from '@deepseek-ai/dsh-session';
+function parseControl(line) {
+    const match = /^\/([a-z][a-z0-9_-]*(?::[a-z0-9][a-z0-9_-]*)?)(?:\s+(.*))?$/su.exec(line.trim());
+    if (match === null || match[1] === undefined)
+        return undefined;
+    return { name: match[1].toLowerCase(), input: match[2]?.trim() ?? '' };
+}
+/** Present only the session controls whose owning Harness plugins are composed. */
+export function sessionControls(projection) {
+    return {
+        ...(projection?.plan === undefined ? {} : { plan: { ...projection.plan } }),
+        ...(projection?.permissions === undefined ? {} : { permission: projection.permissions.currentValue }),
+    };
+}
+/** Composer projection of a Harness model selection and its adapter default. */
+export function modelStatus(selection, info) {
+    const effort = selection.reasoningEffort ?? info?.reasoning?.defaultEffort;
+    return {
+        model: selection.model,
+        ...(effort === undefined ? {} : { reasoningEffort: String(effort) }),
+    };
+}
+/** Fold a complete log as the capability-absence fallback for projections. */
+export function sessionStats(events, contextWindow, projection) {
+    let turns = 0;
+    let steps = 0;
+    let llmMs = 0;
+    let toolMs = 0;
+    let ttftMs = 0;
+    let ttftSteps = 0;
+    let decodeMs = 0;
+    let decodeTokens = 0;
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    let contextTokens;
+    let first;
+    let last;
+    let lastTurn;
+    let openStep;
+    const pendingCalls = new Map();
+    for (const event of events) {
+        first ??= event.time;
+        last = event.time;
+        switch (event.type) {
+            case 'step/start':
+                openStep = { turn: event.data.turn, step: event.data.step, startTime: event.time };
+                break;
+            case 'assistant/chunk':
+                if (openStep !== undefined
+                    && openStep.turn === event.data.turn
+                    && openStep.step === event.data.step
+                    && openStep.firstTokenTime === undefined
+                    && isTokenDelta(event.data.chunk)) {
+                    openStep.firstTokenTime = event.time;
+                }
+                break;
+            case 'assistant/message': {
+                const usage = event.data.usage;
+                if (usage !== undefined) {
+                    const read = usage.cacheReadTokens ?? 0;
+                    const write = usage.cacheWriteTokens ?? 0;
+                    const billedInput = usage.inputTokens + read + write;
+                    inputTokens += billedInput;
+                    outputTokens += usage.outputTokens;
+                    cacheReadTokens += read;
+                    cacheWriteTokens += write;
+                    contextTokens = billedInput + usage.outputTokens;
+                }
+                if (openStep === undefined || openStep.turn !== event.data.turn || openStep.step !== event.data.step)
+                    break;
+                llmMs += Math.max(0, event.time - openStep.startTime);
+                if (openStep.firstTokenTime !== undefined) {
+                    ttftMs += Math.max(0, openStep.firstTokenTime - openStep.startTime);
+                    ttftSteps += 1;
+                    if (usage !== undefined) {
+                        decodeMs += Math.max(0, event.time - openStep.firstTokenTime);
+                        decodeTokens += usage.outputTokens;
+                    }
+                }
+                openStep = undefined;
+                break;
+            }
+            case 'tool/call':
+                pendingCalls.set(event.data.callId, event.time);
+                break;
+            case 'tool/result': {
+                const source = event.data.message.source;
+                if (source.kind !== 'tool')
+                    break;
+                const dispatched = pendingCalls.get(source.callId);
+                if (dispatched === undefined)
+                    break;
+                toolMs += Math.max(0, event.time - dispatched);
+                pendingCalls.delete(source.callId);
+                break;
+            }
+            case 'step/end':
+                turns += lastTurn === event.data.turn ? 0 : 1;
+                steps += 1;
+                lastTurn = event.data.turn;
+                openStep = undefined;
+                break;
+            case 'turn/end':
+                pendingCalls.clear();
+                break;
+        }
+    }
+    const projectedStats = projection?.sessionStats;
+    const projectedUsage = projection?.tokenUsage;
+    const pressure = projection?.contextPressure;
+    const projectedInput = projectedUsage === undefined
+        ? undefined
+        : projectedUsage.uncachedInputTokens + projectedUsage.cacheReadTokens + projectedUsage.cacheWriteTokens;
+    const projectedContext = pressure?.projectedTokens ?? pressure?.pressureTokens ?? contextTokens;
+    const projectedWindow = pressure?.contextWindow ?? contextWindow;
+    return {
+        turns: projectedStats?.turns ?? turns,
+        steps: projectedStats?.steps ?? steps,
+        llmMs: projectedStats?.llmMs ?? llmMs,
+        toolMs: projectedStats?.toolMs ?? toolMs,
+        ttftMs: projectedStats?.ttftMs ?? ttftMs,
+        ttftSteps: projectedStats?.ttftSteps ?? ttftSteps,
+        decodeMs: projectedStats?.decodeMs ?? decodeMs,
+        decodeTokens: projectedStats?.decodeTokens ?? decodeTokens,
+        inputTokens: projectedInput ?? inputTokens,
+        outputTokens: projectedUsage?.outputTokens ?? outputTokens,
+        cacheReadTokens: projectedUsage?.cacheReadTokens ?? cacheReadTokens,
+        cacheWriteTokens: projectedUsage?.cacheWriteTokens ?? cacheWriteTokens,
+        ...(projectedContext === undefined ? {} : { contextTokens: projectedContext }),
+        ...(projectedWindow === undefined ? {} : { contextWindow: projectedWindow }),
+        ...(first === undefined || last === undefined ? {} : { elapsedMs: Math.max(0, last - first) }),
+    };
+}
+function explicitSessionTitle(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const event = events[i];
+        if (event?.type === 'session/title')
+            return event.data.title;
+    }
+    return undefined;
+}
+function humanMessageText(event) {
+    if (event.type !== 'user/message' || event.data.source.kind !== 'user')
+        return undefined;
+    const text = event.data.content
+        .filter((block) => block.type === 'text')
+        .map(block => block.text)
+        .join(' ')
+        .replace(/\s+/gu, ' ')
+        .trim();
+    return text === '' ? undefined : text;
+}
+/** Title and latest-human-message preview for durable session discovery. */
+export function recentSessionContent(events) {
+    const generatedTitle = explicitSessionTitle(events);
+    const firstMessage = events.map(humanMessageText).find((text) => text !== undefined);
+    if (firstMessage === undefined)
+        return undefined;
+    let lastMessage;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        lastMessage = humanMessageText(events[index]);
+        if (lastMessage !== undefined)
+            break;
+    }
+    const title = generatedTitle ?? firstMessage;
+    return {
+        title,
+        ...(lastMessage === undefined || lastMessage === title ? {} : { preview: lastMessage }),
+    };
+}
+function recentSessionStatus(events) {
+    const end = events.findLast(event => event.type === 'turn/end');
+    if (end?.type !== 'turn/end')
+        return undefined;
+    if (end.data.reason.kind === 'completed')
+        return 'done';
+    if (end.data.reason.kind === 'error')
+        return 'failed';
+    if (end.data.reason.kind === 'blocked' || end.data.reason.kind === 'max-tokens')
+        return 'blocked';
+    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}`,
+        description: compactDescription(skill.description),
+    }));
+}
+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() + '…';
+}
+/** Validate all drafts, persist them, then build one atomic mixed user message. */
+export async function createSubmissionMessage(submission, attachments) {
+    const inputs = submission.images.map(image => ({
+        data: image.data,
+        mediaType: image.mediaType,
+        ...(image.name === undefined ? {} : { name: image.name }),
+    }));
+    if (inputs.length > 0 && attachments === undefined)
+        throw new Error('Attachment storage is not configured.');
+    const refs = [];
+    if (attachments !== undefined) {
+        for (const input of inputs)
+            await attachments.validateImage(input);
+        for (const input of inputs)
+            refs.push(await attachments.saveImage(input));
+    }
+    const content = [
+        ...(submission.text === '' ? [] : [{ type: 'text', text: submission.text }]),
+        ...refs.map(attachment => ({ type: 'image', attachment })),
+    ];
+    if (content.length === 0)
+        throw new Error('Cannot submit an empty message.');
+    return createUserMessage({ content, source: { kind: 'user' } });
+}
+/** Own one switchable top-level Agent and project it onto a TuiService. */
+export class SessionRuntime {
+    #ctx;
+    #tui;
+    #active;
+    #recent = [];
+    #skillCommands = [];
+    #started = false;
+    #retired = [];
+    #disposed = false;
+    #off = [];
+    constructor(ctx, tui) {
+        this.#ctx = ctx;
+        this.#tui = tui;
+        this.#off.push(ctx.on('agent/status', (payload) => {
+            if (payload.agent === this.#active?.handle.agent)
+                tui.setStatus(payload.status);
+        }));
+        this.#off.push(ctx.on('session/event', (session, event) => {
+            const active = this.#active;
+            if (active === undefined || session !== active.handle.agent.session)
+                return;
+            tui.event(event, ctx.get('tuiToolPresentation')?.event(active.handle.agent, event));
+            this.#pushSessionInfo();
+            if (event.type === 'session/title')
+                void this.refreshRecent();
+        }));
+        if (ctx.get('commands') !== undefined) {
+            this.#off.push(ctx.on('commands/change', () => { this.#pushCommands(); }));
+        }
+        if (ctx.get('skills') !== undefined) {
+            this.#off.push(ctx.on('skills/change', () => { void this.#refreshSkills(); }));
+        }
+        if (ctx.get('tools') !== undefined) {
+            this.#off.push(ctx.on('tools/change', () => {
+                this.#pushTools();
+                const active = this.#active;
+                if (active !== undefined)
+                    this.#replaceTranscript(active.handle.agent);
+            }));
+        }
+        const projections = ctx.get('sessionProjections');
+        if (projections !== undefined) {
+            this.#off.push(projections.onChanged((session, key) => {
+                if (session !== this.#active?.handle.agent.session)
+                    return;
+                if (key === 'sessionStats' || key === 'tokenUsage' || key === 'contextPressure'
+                    || key === 'plan' || key === 'permissions')
+                    this.#pushSessionInfo();
+            }));
+        }
+    }
+    get agent() {
+        return this.#active?.handle.agent;
+    }
+    async start() {
+        if (this.#started)
+            return;
+        this.#started = true;
+        const defaults = this.#ctx.get('agentDefaultModel')?.currentSelection();
+        if (defaults === undefined)
+            throw new Error('agent default model is unavailable');
+        await this.#activate(await this.#create(defaults));
+        await this.refreshRecent();
+    }
+    /** Submit one human composer value; active turns retain it as a later follow-up. */
+    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);
+    }
+    /** Execute a plugin-owned slash command, falling back to user-invocable skills. */
+    async execute(line, signal) {
+        const parsed = parseControl(line);
+        if (parsed === undefined)
+            return false;
+        const commands = this.#ctx.get('commands');
+        const execution = await (async () => {
+            try {
+                return await commands?.execute(this.#requiredAgent(), line, signal);
+            }
+            finally {
+                await this.#disposeRetired();
+            }
+        })();
+        if (execution === undefined) {
+            const skill = await this.#findUserSkill(skillNameFromCommand(parsed.name), signal);
+            if (skill === undefined)
+                return false;
+            await this.send('/' + skill.name + (parsed.input === '' ? '' : ' ' + parsed.input));
+            return true;
+        }
+        const result = execution.result;
+        if (result.text !== undefined) {
+            if (result.kind === 'error')
+                this.#tui.notice(result.text, 'error');
+            else
+                this.#tui.commandOutput(parsed.name, result.text);
+        }
+        return true;
+    }
+    /** Fail when a command invocation targets a stale or background Agent. */
+    assertActive(agent) {
+        if (agent !== this.#requiredAgent())
+            throw new Error('the command does not target the active omdsh session');
+    }
+    /** Immutable recent-session view used by the resume command. */
+    get recentSessions() {
+        return this.#recent;
+    }
+    /** Current model selection for the active Agent. */
+    selection(agent = this.#requiredAgent()) {
+        this.assertActive(agent);
+        const current = this.#requiredActive().selection.current;
+        if (current === undefined)
+            throw new Error('active agent has no model selection');
+        return current;
+    }
+    /** Replace the active Agent's selection and persist it as the next default. */
+    async changeSelection(agent, selection, info) {
+        this.assertActive(agent);
+        const active = this.#requiredActive();
+        active.selection.current = selection;
+        const resolved = info ?? await this.#resolveModelInfo(selection);
+        active.contextWindow = resolved?.context?.contextWindow;
+        const status = modelStatus(selection, resolved);
+        active.reasoningEffort = status.reasoningEffort;
+        this.#tui.setModel(status.model, status.reasoningEffort);
+        this.#pushSessionInfo();
+        await this.#ctx.get('agentDefaultModel')?.saveSelection(selection);
+    }
+    /** 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.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 };
+        const handle = await this.#ctx.agents.resume({
+            resumeSessionId: SessionId(id),
+            agentOptions: { provider: selection.provider, model: selection.model },
+            signal,
+            setup: agentCtx => { installModelSelection(agentCtx, ref); },
+        });
+        await this.#activate({ handle, selection: ref, contextWindow: undefined, reasoningEffort: undefined });
+        await this.refreshRecent();
+    }
+    /** Whole-session figures for the active Agent. */
+    stats(agent = this.#requiredAgent()) {
+        this.assertActive(agent);
+        return this.#stats(this.#requiredActive());
+    }
+    /** Effective reasoning effort after applying the selected model's adapter default. */
+    reasoningEffort(agent = this.#requiredAgent()) {
+        this.assertActive(agent);
+        return this.#requiredActive().reasoningEffort;
+    }
+    /** Harness-owned collaboration and permission controls for the active Agent. */
+    controls(agent = this.#requiredAgent()) {
+        this.assertActive(agent);
+        return sessionControls(this.#projection(this.#requiredActive()));
+    }
+    async refreshRecent() {
+        const persistence = this.#ctx.get('sessionPersistence');
+        if (persistence === undefined) {
+            this.#recent = [];
+            this.#pushSessionInfo();
+            return;
+        }
+        const headers = (await persistence.list()).filter(header => header.origin !== 'subagent')
+            .sort((left, right) => right.createdAt - left.createdAt);
+        const rows = [];
+        for (const header of headers) {
+            try {
+                const inspected = await persistence.inspect(header.id);
+                const status = recentSessionStatus(inspected.events);
+                const content = recentSessionContent(inspected.events);
+                if (content === undefined)
+                    continue;
+                rows.push({
+                    id: header.id,
+                    ...content,
+                    createdAt: header.createdAt,
+                    updatedAt: inspected.events.at(-1)?.time ?? header.createdAt,
+                    eventCount: inspected.events.length,
+                    ...(status === undefined ? {} : { status }),
+                });
+                if (rows.length >= 8)
+                    break;
+            }
+            catch {
+                rows.push({ id: header.id, title: '(unavailable session)', createdAt: header.createdAt });
+                if (rows.length >= 8)
+                    break;
+            }
+        }
+        this.#recent = rows;
+        this.#pushSessionInfo();
+    }
+    async dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        for (const off of this.#off.splice(0).reverse())
+            off();
+        await Promise.allSettled(this.#retired.splice(0).map(handle => handle.dispose()));
+        await this.#active?.handle.dispose();
+        this.#active = undefined;
+    }
+    async #create(selection) {
+        const ref = { current: selection, assembled: undefined };
+        const handle = await this.#ctx.agents.create({
+            sessionId: SessionId('session-' + randomUUID()),
+            meta: { cwd: process.cwd() },
+            agentOptions: { provider: selection.provider, model: selection.model },
+            setup: agentCtx => { installModelSelection(agentCtx, ref); },
+        });
+        return { handle, selection: ref, contextWindow: undefined, reasoningEffort: undefined };
+    }
+    async #resolveModelInfo(selection) {
+        try {
+            return await this.#ctx.get('llm')?.resolveModelInfo(selection.provider, selection.model);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async #activate(next) {
+        const previous = this.#active;
+        this.#active = next;
+        const agent = next.handle.agent;
+        this.#tui.setStatus(agent.status);
+        this.#replaceTranscript(agent);
+        this.#pushTools();
+        const selected = this.selection(agent);
+        const info = await this.#resolveModelInfo(selected);
+        next.contextWindow = info?.context?.contextWindow;
+        const status = modelStatus(selected, info);
+        next.reasoningEffort = status.reasoningEffort;
+        this.#tui.setModel(status.model, status.reasoningEffort);
+        await this.#refreshSkills();
+        this.#pushSessionInfo();
+        if (previous !== undefined)
+            this.#retired.push(previous.handle);
+    }
+    #pushCommands() {
+        const agent = this.agent;
+        const runtime = agent === undefined ? [] : (this.#ctx.get('commands')?.list(agent) ?? []);
+        const commands = runtime.map(command => ({
+            name: command.name,
+            description: command.description,
+            ...(command.input?.hint === undefined ? {} : { inputHint: command.input.hint }),
+        }));
+        const names = new Set(commands.map(command => command.name));
+        for (const skill of this.#skillCommands) {
+            if (names.has(skill.name))
+                continue;
+            commands.push(skill);
+            names.add(skill.name);
+        }
+        this.#tui.setCommands(commands);
+    }
+    #pushTools() {
+        const agent = this.agent;
+        const tools = agent === undefined
+            ? []
+            : (this.#ctx.get('tools')?.schemas(agent).map(schema => ({
+                name: schema.name,
+                description: schema.description,
+            })) ?? []);
+        this.#tui.setTools(tools);
+    }
+    async #refreshSkills(signal) {
+        const agent = this.agent;
+        const skills = this.#ctx.get('skills');
+        if (agent === undefined || skills === undefined) {
+            this.#skillCommands = [];
+        }
+        else {
+            const list = await skills.list({ cwd: agent.session.header.cwd, scope: agent, signal });
+            this.#skillCommands = userSkillCommands(list);
+        }
+        this.#pushCommands();
+    }
+    async #findUserSkill(name, signal) {
+        const agent = this.#requiredAgent();
+        const skills = this.#ctx.get('skills');
+        if (skills === undefined)
+            return undefined;
+        const list = await skills.list({ cwd: agent.session.header.cwd, scope: agent, signal });
+        return list.find(skill => skill.name === name && isUserInvocable(skill));
+    }
+    #pushSessionInfo() {
+        const active = this.#active;
+        if (active === undefined)
+            return;
+        const agent = active.handle.agent;
+        const projection = this.#projection(active);
+        this.#tui.setSession({
+            id: agent.id,
+            recent: this.#recent.filter(row => row.id !== agent.id),
+            stats: this.#stats(active, projection),
+            controls: sessionControls(projection),
+        });
+    }
+    #replaceTranscript(agent) {
+        const events = agent.session.events;
+        this.#tui.replaceSession(events, this.#ctx.get('tuiToolPresentation')?.session(agent, events));
+    }
+    /** Read one consistent projection cut, with the complete-log fold as fallback. */
+    #projection(active) {
+        return this.#ctx.get('sessionProjections')?.snapshot(active.handle.agent.session).values;
+    }
+    #stats(active, projection = this.#projection(active)) {
+        const agent = active.handle.agent;
+        return sessionStats(agent.session.events, active.contextWindow, projection);
+    }
+    #requiredActive() {
+        if (this.#active === undefined)
+            throw new Error('no active session');
+        return this.#active;
+    }
+    #requiredAgent() {
+        return this.#requiredActive().handle.agent;
+    }
+    async #disposeRetired() {
+        await Promise.allSettled(this.#retired.splice(0).map(handle => handle.dispose()));
+    }
+}
+//# sourceMappingURL=session-controller.js.map