@antst/dashi 0.1.0-alpha.20 → 0.1.0-alpha.21

package/lib/terminal-guard.d.ts

@@ -0,0 +1,14 @@
+import { type Terminal } from '@earendil-works/pi-tui';
+export interface TerminalSession {
+    drainInput(): Promise<void>;
+    render(force: boolean): void;
+    start(): void;
+    stop(preserveScreen: boolean): void;
+}
+export interface TerminalGuard {
+    dispose(): Promise<void>;
+    start(): void;
+    withCookedTerminal(operation: () => Promise<void>): Promise<void>;
+}
+export declare function createProcessTerminal(onWheel?: (lines: number) => void): Terminal;
+export declare function createTerminalGuard(session: TerminalSession): TerminalGuard;

package/lib/terminal-guard.js

@@ -0,0 +1,76 @@
+import { ProcessTerminal } from '@earendil-works/pi-tui';
+import { filterWheelInput } from './mouse-input.js';
+export function createProcessTerminal(onWheel) {
+    const terminal = new ProcessTerminal();
+    if (onWheel === undefined)
+        return terminal;
+    return {
+        get columns() { return terminal.columns; },
+        get kittyProtocolActive() { return terminal.kittyProtocolActive; },
+        get rows() { return terminal.rows; },
+        clearFromCursor: () => { terminal.clearFromCursor(); },
+        clearLine: () => { terminal.clearLine(); },
+        clearScreen: () => { terminal.clearScreen(); },
+        drainInput: (maxMs, idleMs) => terminal.drainInput(maxMs, idleMs),
+        hideCursor: () => { terminal.hideCursor(); },
+        moveBy: lines => { terminal.moveBy(lines); },
+        setProgress: active => { terminal.setProgress(active); },
+        setTitle: title => { terminal.setTitle(title); },
+        showCursor: () => { terminal.showCursor(); },
+        start(onInput, onResize) {
+            terminal.start(data => {
+                const filtered = filterWheelInput(data);
+                if (typeof filtered === 'string')
+                    onInput(filtered);
+                else
+                    onWheel(filtered);
+            }, onResize);
+        },
+        stop: () => { terminal.stop(); },
+        write: data => { terminal.write(data); },
+    };
+}
+export function createTerminalGuard(session) {
+    let phase = 'fresh';
+    let disposal;
+    const stopActive = async () => {
+        try {
+            await session.drainInput();
+        }
+        finally {
+            session.stop(true);
+        }
+    };
+    return {
+        start() {
+            if (phase !== 'fresh')
+                return;
+            phase = 'active';
+            session.start();
+        },
+        dispose() {
+            if (disposal !== undefined)
+                return disposal;
+            const wasActive = phase === 'active';
+            phase = 'released';
+            disposal = wasActive ? stopActive() : Promise.resolve();
+            return disposal;
+        },
+        async withCookedTerminal(operation) {
+            if (phase !== 'active')
+                return;
+            phase = 'cooked';
+            await stopActive();
+            try {
+                await operation();
+            }
+            finally {
+                if (phase === 'cooked') {
+                    phase = 'active';
+                    session.start();
+                    session.render(true);
+                }
+            }
+        },
+    };
+}

package/lib/tool-presentation.d.ts

@@ -0,0 +1,14 @@
+import type { ToolDefinition, ToolResult } from '@deepseek-ai/dsh-tools';
+import type { ToolCard } from './state.js';
+export interface PresentedCall {
+    readonly args: unknown;
+    readonly card: ToolCard;
+}
+export interface ToolPresenter {
+    call(name: string, rawArguments: string): PresentedCall;
+    result(name: string, args: unknown, result: ToolResult, prior: ToolCard): ToolCard;
+}
+/** Bound a card body without hiding how much was omitted. */
+export declare function boundedBody(text: string): string;
+/** Bind DSH's live tool definitions to a pure, bounded terminal card projection. */
+export declare function createToolPresenter(get: (name: string) => ToolDefinition | undefined): ToolPresenter;

package/lib/tool-presentation.js

@@ -0,0 +1,156 @@
+const HEAD_LINES = 12;
+const TAIL_LINES = 8;
+const MAX_LINE_CHARS = 2_000;
+function short(value) {
+    const chars = [...value];
+    return chars.length <= MAX_LINE_CHARS ? value : `${chars.slice(0, MAX_LINE_CHARS).join('')}…`;
+}
+/** Bound a card body without hiding how much was omitted. */
+export function boundedBody(text) {
+    const lines = text.replaceAll('\r\n', '\n').split('\n').map(short);
+    if (lines.length <= HEAD_LINES + TAIL_LINES)
+        return lines.join('\n');
+    const omitted = lines.length - HEAD_LINES - TAIL_LINES;
+    return [...lines.slice(0, HEAD_LINES), `… ${omitted} lines omitted …`, ...lines.slice(-TAIL_LINES)].join('\n');
+}
+function blockText(blocks) {
+    return blocks.map((block) => {
+        if (block.type === 'text' || block.type === 'reasoning')
+            return block.text;
+        if (block.type === 'image')
+            return '[image]';
+        return `[${String(block.type ?? 'content')}]`;
+    }).join('\n');
+}
+function displayValue(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, undefined, 2) ?? '';
+    }
+    catch {
+        return '[unrenderable input]';
+    }
+}
+function decode(raw) {
+    try {
+        return raw === '' ? {} : JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function generic(title, body = '') {
+    return { card: 'generic', title: short(title), ...(body === '' ? {} : { body: boundedBody(body) }) };
+}
+function lines(text) {
+    const normalized = text.replaceAll('\r\n', '\n');
+    const values = normalized.split('\n');
+    if (values.at(-1) === '')
+        values.pop();
+    return values;
+}
+function compactDiff(path, oldText, newText) {
+    const before = oldText === null ? [] : lines(oldText);
+    const after = lines(newText);
+    let prefix = 0;
+    while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix])
+        prefix++;
+    let suffix = 0;
+    while (suffix < before.length - prefix && suffix < after.length - prefix
+        && before[before.length - suffix - 1] === after[after.length - suffix - 1])
+        suffix++;
+    const removed = before.length - prefix - suffix;
+    const added = after.length - prefix - suffix;
+    const contextBefore = before.slice(Math.max(0, prefix - 3), prefix).map(value => `  ${value}`);
+    const removedLines = before.slice(prefix, before.length - suffix).map(value => `- ${value}`);
+    const addedLines = after.slice(prefix, after.length - suffix).map(value => `+ ${value}`);
+    const contextAfter = before.slice(before.length - suffix, before.length - suffix + 3).map(value => `  ${value}`);
+    return {
+        added,
+        lines: boundedBody([...contextBefore, ...removedLines, ...addedLines, ...contextAfter].join('\n')).split('\n'),
+        path: short(path),
+        removed,
+    };
+}
+function diffs(view) {
+    return view.diffs.slice(0, 50).map(diff => compactDiff(diff.path, diff.oldText, diff.newText));
+}
+function callCard(view) {
+    switch (view.card) {
+        case 'generic': {
+            const body = [view.content === undefined ? '' : blockText(view.content),
+                view.rawInput === undefined ? '' : displayValue(view.rawInput)].filter(Boolean).join('\n');
+            return { ...generic(view.title, body), card: 'generic' };
+        }
+        case 'terminal':
+            return {
+                card: 'terminal', title: short(view.title),
+                ...(view.description === undefined ? {} : { body: boundedBody(view.description) }),
+                ...(view.cwd === undefined ? {} : { status: `cwd ${short(view.cwd)}` }),
+            };
+        case 'diff': return { card: 'diff', title: short(view.title), diffs: diffs(view) };
+    }
+}
+function searchBody(view) {
+    if (view.shape === 'paths')
+        return view.paths.join('\n');
+    return view.files.flatMap(file => [file.path, ...file.matches.map(match => `${match.lineNumber}: ${match.line}`)]).join('\n');
+}
+function resultCard(view, prior, raw) {
+    const title = short(view.title ?? prior.title);
+    switch (view.card) {
+        case 'generic': return generic(title, view.content === undefined ? raw : blockText(view.content));
+        case 'terminal':
+            return {
+                card: 'terminal', title,
+                ...((view.output ?? raw) === '' ? {} : { body: boundedBody(view.output ?? raw) }),
+                ...(view.exitCode === undefined && view.signal === undefined ? {} : {
+                    status: view.exitCode === undefined ? `signal ${short(view.signal ?? '')}` : `exit ${String(view.exitCode)}`,
+                }),
+            };
+        case 'diff': return { card: 'diff', title, diffs: diffs(view) };
+        case 'search': return {
+            card: 'search', title, body: boundedBody(searchBody(view)),
+            status: `${String(view.total)} ${view.shape === 'paths' ? 'paths' : 'matches'}${view.truncated ? ' · truncated' : ''}`,
+        };
+        case 'read': return {
+            card: 'read', title, body: boundedBody(view.lines.map(line => `${line.number}  ${line.text}`).join('\n')),
+            status: `${short(view.path)} · ${String(view.lines.length)}/${String(view.totalLines)} lines`,
+        };
+        case 'web': {
+            const body = view.kind === 'search'
+                ? [view.answer ?? '', ...view.sources.map(source => `${source.title ?? source.url} · ${source.url}`)].filter(Boolean).join('\n')
+                : raw;
+            const status = view.kind === 'search'
+                ? `${String(view.sources.length)} sources${view.truncated ? ' · truncated' : ''}`
+                : `${String(view.statusCode)} · ${short(view.url)}${view.truncated ? ' · truncated' : ''}`;
+            return { card: 'web', title, ...(body === '' ? {} : { body: boundedBody(body) }), status };
+        }
+    }
+}
+/** Bind DSH's live tool definitions to a pure, bounded terminal card projection. */
+export function createToolPresenter(get) {
+    return {
+        call(name, rawArguments) {
+            const args = decode(rawArguments);
+            try {
+                const view = get(name)?.presentCall?.(args);
+                return { args, card: view === undefined ? generic(name, displayValue(args)) : callCard(view) };
+            }
+            catch {
+                return { args, card: generic(name, displayValue(args)) };
+            }
+        },
+        result(name, args, result, prior) {
+            const raw = blockText(result.content);
+            try {
+                const view = get(name)?.presentResult?.(args, result);
+                return view === undefined ? generic(prior.title, raw) : resultCard(view, prior, raw);
+            }
+            catch {
+                return generic(prior.title, raw);
+            }
+        },
+    };
+}

package/lib/transcript.d.ts

@@ -0,0 +1,14 @@
+import type { StreamChunk, UserMessage } from '@deepseek-ai/dsh-llm';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+import type { TerminalCell } from './state.js';
+import { type ToolPresenter } from './tool-presentation.js';
+interface FoldOptions {
+    readonly truncatedStart?: boolean;
+}
+/** Project DSH-owned pending injections beside the durable transcript. */
+export declare function pendingShellCells(messages: readonly UserMessage[]): readonly TerminalCell[];
+/** Fold one transient DSH Assistant frame into the current pending cells. */
+export declare function foldAssistantStream(current: readonly TerminalCell[], turn: number, step: number, chunk: StreamChunk): readonly TerminalCell[];
+/** Fold one chronological DSH event slice into terminal-owned presentation cells. */
+export declare function foldCells(events: readonly SessionEvent[], presenter?: ToolPresenter | undefined, options?: FoldOptions): readonly TerminalCell[];
+export {};

package/lib/transcript.js

@@ -0,0 +1,336 @@
+import { createToolPresenter } from './tool-presentation.js';
+function blockText(blocks, kind) {
+    return blocks.filter((block) => block.type === kind)
+        .map(block => block.text).join('');
+}
+function messageText(blocks) {
+    const parts = [];
+    for (const block of blocks) {
+        if (block.type === 'text')
+            parts.push(block.text);
+        else if (block.type === 'image')
+            parts.push('[image]');
+        else if (block.type !== 'reasoning' && block.type !== 'tool-call' && block.type !== 'tool-result') {
+            parts.push(`[${String(block.type ?? 'content')}]`);
+        }
+    }
+    return parts.join('');
+}
+function isDashiShell(message) {
+    const source = message.source;
+    return source.kind === 'plugin' && source.plugin === 'dashi' && source.form === 'notice'
+        && messageText(message.content).startsWith('$ ');
+}
+function shellCell(message, pending) {
+    return {
+        key: `shell:${String(message.id)}`, kind: 'shell', pending, text: messageText(message.content),
+    };
+}
+function collapsedContextCell(message, key) {
+    const source = message.source;
+    const form = source.form;
+    if (source.kind !== 'agent-instructions'
+        && (source.kind !== 'plugin' || !['instructions', 'catalog', 'snapshot', 'notice', 'recall'].includes(String(form)))) {
+        return undefined;
+    }
+    const text = messageText(message.content);
+    const lines = text.split(/\r?\n/u);
+    const first = form === 'notice' && typeof source.summary === 'string' ? source.summary : lines[0] ?? '';
+    return {
+        collapsed: true,
+        detail: `${String(form)} · ${first.trim()} · ${String(lines.length)} lines`,
+        key,
+        kind: 'context',
+        text,
+    };
+}
+/** Project DSH-owned pending injections beside the durable transcript. */
+export function pendingShellCells(messages) {
+    return messages.filter(isDashiShell).map(message => shellCell(message, true));
+}
+function outcome(reason) {
+    switch (reason.kind) {
+        case 'completed': return 'completed';
+        case 'aborted': return `interrupted (${reason.reason.kind})`;
+        case 'blocked': return 'blocked';
+        case 'error': return `${reason.error.message} [${reason.error.code}]`;
+        case 'max-tokens': return 'maximum output reached';
+        case 'interrupted': return 'interrupted by an earlier crash';
+        default: return String(reason.kind ?? 'unknown outcome');
+    }
+}
+function todoText(event) {
+    const glyph = { completed: '✓', in_progress: '●', pending: '○' };
+    const lines = event.data.todos.map(todo => `${glyph[todo.status]} ${todo.content}`);
+    return `Todos\n${lines.join('\n')}`;
+}
+function compactText(summary) {
+    if (summary === undefined)
+        return 'Conversation compacted';
+    const items = summary.data.shadowedSeqs.length;
+    return `Compacted ${String(items)} item${items === 1 ? '' : 's'} · ${String(summary.data.shadowedTokenCount)} tokens`;
+}
+function compactSource(event) {
+    if (event.surfaceOp === undefined || event.surfaceOp === 'append' || event.surfaceOp.op !== 'replace')
+        return undefined;
+    const source = event.data.source;
+    if (source.kind !== 'plugin' || source.plugin !== 'compact' || typeof source.compactionId !== 'string')
+        return undefined;
+    return {
+        compactionId: source.compactionId,
+        ...(typeof source.sourceCommandId === 'string' ? { sourceCommandId: source.sourceCommandId } : {}),
+    };
+}
+function putAssistant(cells, assistants, turn, step, kind, text, complete) {
+    const key = `${turn}:${step}`;
+    const pair = assistants.get(key) ?? {};
+    const slot = kind === 'text' ? pair.text : pair.reasoning;
+    const cellKind = kind === 'text' ? 'assistant' : 'reasoning';
+    if (slot === undefined) {
+        const next = cells.length;
+        cells.push({
+            key: `assistant:${key}:${kind}`,
+            kind: cellKind,
+            ...(!complete && kind === 'text' ? { pending: true } : {}),
+            text,
+            ...(complete && kind === 'reasoning' ? { collapsed: true } : {}),
+        });
+        if (kind === 'text')
+            pair.text = next;
+        else
+            pair.reasoning = next;
+        assistants.set(key, pair);
+        return;
+    }
+    const previous = cells[slot];
+    if (previous === undefined)
+        return;
+    const { pending: _pending, ...settled } = previous;
+    cells[slot] = {
+        ...(complete ? settled : previous),
+        text: complete ? text : previous.text + text,
+        ...(complete && kind === 'reasoning' ? { collapsed: true } : {}),
+    };
+}
+/** Fold one transient DSH Assistant frame into the current pending cells. */
+export function foldAssistantStream(current, turn, step, chunk) {
+    const cells = [...current];
+    const pair = {};
+    cells.forEach((cell, slot) => {
+        if (cell.kind === 'assistant')
+            pair.text = slot;
+        else if (cell.kind === 'reasoning')
+            pair.reasoning = slot;
+    });
+    const assistants = new Map([[`${turn}:${step}`, pair]]);
+    if (chunk.type === 'text-delta')
+        putAssistant(cells, assistants, turn, step, 'text', chunk.text, false);
+    else if (chunk.type === 'reasoning-delta')
+        putAssistant(cells, assistants, turn, step, 'reasoning', chunk.text, false);
+    else if (chunk.type === 'block-end' && (chunk.block.type === 'text' || chunk.block.type === 'reasoning')) {
+        putAssistant(cells, assistants, turn, step, chunk.block.type, chunk.block.text, true);
+    }
+    return cells;
+}
+/** Fold one chronological DSH event slice into terminal-owned presentation cells. */
+export function foldCells(events, presenter = createToolPresenter(() => undefined), options = {}) {
+    const toolPresenter = presenter ?? createToolPresenter(() => undefined);
+    const cells = [];
+    const assistants = new Map();
+    const calls = new Map();
+    const commands = new Map();
+    const inheritedPendingCommands = new Set();
+    const compactions = new Map();
+    const openTurns = new Set();
+    let planSlot;
+    let todoSlot;
+    let truncatedPrefix = options.truncatedStart === true;
+    for (const event of events) {
+        switch (event.type) {
+            case 'system/message':
+                break;
+            case 'turn/start':
+                truncatedPrefix = false;
+                openTurns.add(event.data.turn);
+                if (todoSlot !== undefined) {
+                    const previous = cells[todoSlot];
+                    if (previous !== undefined)
+                        cells[todoSlot] = { ...previous, collapsed: true, text: 'Todos · previous revision' };
+                    todoSlot = undefined;
+                }
+                break;
+            case 'user/message': {
+                const compact = compactSource(event);
+                if (compact !== undefined) {
+                    const text = compactText(compactions.get(compact.compactionId));
+                    const slot = compact.sourceCommandId === undefined ? undefined : commands.get(compact.sourceCommandId);
+                    const command = slot === undefined ? undefined : cells[slot];
+                    if (slot !== undefined && command?.kind === 'command')
+                        cells[slot] = { ...command, text: `${command.text}\n${text}` };
+                    else
+                        cells.push({ key: `${event.seq}:compaction`, kind: 'compaction', text });
+                    break;
+                }
+                const text = messageText(event.data.content);
+                const context = collapsedContextCell(event.data, `${event.seq}:context`);
+                cells.push(isDashiShell(event.data)
+                    ? shellCell(event.data, false)
+                    : context ?? {
+                        key: `${event.seq}:user`,
+                        kind: event.data.source.kind === 'user' ? 'user' : 'context',
+                        text,
+                    });
+                break;
+            }
+            case 'assistant/message': {
+                const { message, step, turn } = event.data;
+                const text = blockText(message.content, 'text');
+                const reasoning = blockText(message.content, 'reasoning');
+                if (reasoning !== '')
+                    putAssistant(cells, assistants, turn, step, 'reasoning', reasoning, true);
+                if (text !== '')
+                    putAssistant(cells, assistants, turn, step, 'text', text, true);
+                break;
+            }
+            case 'tool/call': {
+                const id = String(event.data.callId);
+                if (calls.has(id)) {
+                    cells.push({ key: `${event.seq}:error`, kind: 'error', text: `duplicate tool call ${id}` });
+                    break;
+                }
+                const presented = toolPresenter.call(event.data.name, event.data.arguments);
+                if (event.data.name === 'exit_plan_mode') {
+                    const previous = planSlot === undefined ? undefined : cells[planSlot];
+                    if (planSlot !== undefined && previous !== undefined)
+                        cells[planSlot] = { ...previous, collapsed: true };
+                    planSlot = cells.length;
+                }
+                calls.set(id, { args: presented.args, name: event.data.name, slot: cells.length });
+                cells.push({
+                    key: `tool:${id}`,
+                    kind: 'tool',
+                    pending: true,
+                    text: presented.card.title,
+                    tool: presented.card,
+                });
+                break;
+            }
+            case 'todo/write': {
+                const previous = todoSlot === undefined ? undefined : cells[todoSlot];
+                if (todoSlot !== undefined && previous !== undefined)
+                    cells[todoSlot] = { ...previous, collapsed: true, text: 'Todos · previous revision' };
+                todoSlot = cells.length;
+                cells.push({ key: `${event.seq}:todos`, kind: 'todo', text: todoText(event) });
+                break;
+            }
+            case 'compaction/summary':
+                compactions.set(String(event.data.compactionId), event);
+                break;
+            case 'tool/result': {
+                const id = String(event.data.message.source.callId);
+                const call = calls.get(id);
+                if (call === undefined || cells[call.slot] === undefined) {
+                    if (truncatedPrefix)
+                        break;
+                    cells.push({ key: `${event.seq}:error`, kind: 'error', text: `tool result ${id} has no matching call` });
+                    break;
+                }
+                const block = event.data.message.content[0];
+                if (block === undefined) {
+                    cells.push({ key: `${event.seq}:error`, kind: 'error', text: `tool result ${id} has no content` });
+                    break;
+                }
+                const result = {
+                    content: block.content,
+                    isError: block.isError || event.data.error !== undefined,
+                    ...(event.data.meta === undefined ? {} : { meta: event.data.meta }),
+                };
+                const previous = cells[call.slot];
+                if (previous === undefined)
+                    break;
+                const card = toolPresenter.result(call.name, call.args, result, previous.tool ?? {
+                    card: 'generic', title: call.name,
+                });
+                cells[call.slot] = {
+                    ...previous,
+                    text: card.title,
+                    tool: card,
+                    pending: false,
+                    ...(result.isError ? { kind: 'error' } : {}),
+                };
+                break;
+            }
+            case 'command/run': {
+                const id = String(event.data.commandId);
+                if (commands.has(id)) {
+                    cells.push({ key: `${event.seq}:error`, kind: 'error', text: `duplicate command ${id}` });
+                    break;
+                }
+                commands.set(id, cells.length);
+                cells.push({
+                    key: `command:${id}`,
+                    kind: 'command',
+                    pending: true,
+                    startedAt: event.time,
+                    text: `/${event.data.name}${event.data.args ?? ''}`,
+                });
+                break;
+            }
+            case 'session/end-seed':
+                // Fork includes post-turn log events through the next turn/start
+                // (api/session-controller/src/commands.ts:229-231). A command/run is
+                // appended before its handler (interaction/commands/src/index.ts:345-350),
+                // so the child can inherit that run but never its parent-only done event.
+                for (const slot of commands.values()) {
+                    if (cells[slot]?.pending === true)
+                        inheritedPendingCommands.add(slot);
+                }
+                break;
+            case 'command/done': {
+                const id = String(event.data.commandId);
+                const slot = commands.get(id);
+                if (slot === undefined) {
+                    if (truncatedPrefix)
+                        break;
+                    cells.push({ key: `${event.seq}:error`, kind: 'error', text: `command result ${id} has no matching run` });
+                    break;
+                }
+                const previous = cells[slot];
+                if (previous === undefined || previous.kind !== 'command') {
+                    cells.push({ key: `${event.seq}:error`, kind: 'error', text: `command result ${id} has no matching run` });
+                    break;
+                }
+                inheritedPendingCommands.delete(slot);
+                cells[slot] = {
+                    ...previous,
+                    ...(previous.startedAt === undefined ? {} : { elapsedMs: Math.max(0, event.time - previous.startedAt) }),
+                    pending: false,
+                    text: `${previous.text}${event.data.text === undefined ? '' : `\n${event.data.text}`}${event.data.kind === 'error' ? '\nfailed' : ''}`,
+                };
+                break;
+            }
+            case 'turn/end':
+                if (event.data.reason.kind === 'interrupted')
+                    break;
+                if (!openTurns.delete(event.data.turn)) {
+                    if (!truncatedPrefix) {
+                        cells.push({ key: `${event.seq}:error`, kind: 'error', text: `turn ${event.data.turn} ended without starting` });
+                    }
+                }
+                else {
+                    cells.push({
+                        key: `${event.seq}:outcome`,
+                        kind: event.data.reason.kind === 'error' ? 'error' : 'outcome',
+                        text: outcome(event.data.reason),
+                    });
+                }
+                truncatedPrefix = false;
+                break;
+            default:
+                break;
+        }
+    }
+    return inheritedPendingCommands.size === 0
+        ? cells
+        : cells.filter((_cell, slot) => !inheritedPendingCommands.has(slot));
+}

package/lib/tui-root.d.ts

@@ -0,0 +1,20 @@
+import { Service, type Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+export interface TuiRootContext {
+    current(): Agent | undefined;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        tuiRoot: TuiRootContext;
+    }
+    interface Events {
+        'tui/root-changed'(previous: Agent | undefined, current: Agent | undefined): void;
+    }
+}
+export declare class TuiRoot extends Service implements TuiRootContext {
+    private agent;
+    constructor(ctx: Context);
+    current(): Agent | undefined;
+    bind(agent: Agent): void;
+    clear(expected?: Agent): void;
+}

package/lib/tui-root.js

@@ -0,0 +1,25 @@
+import { Service } from '@deepseek-ai/cordis';
+export class TuiRoot extends Service {
+    agent;
+    constructor(ctx) {
+        super(ctx, 'tuiRoot');
+        ctx.on('agent/disposed', ({ agent }) => { this.clear(agent); }, { global: true });
+    }
+    current() {
+        return this.agent;
+    }
+    bind(agent) {
+        if (this.agent === agent)
+            return;
+        const previous = this.agent;
+        this.agent = agent;
+        this.ctx.emit('tui/root-changed', previous, agent);
+    }
+    clear(expected) {
+        if (this.agent === undefined || (expected !== undefined && this.agent !== expected))
+            return;
+        const previous = this.agent;
+        this.agent = undefined;
+        this.ctx.emit('tui/root-changed', previous, undefined);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antst/dashi",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.21",
   "description": "A terminal UI for DeepSeek Harness",
   "publishConfig": {
     "access": "public"