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

package/lib/index.js

@@ -0,0 +1,325 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { exitOnStdinEnd } from '@deepseek-ai/dsh-cmdline';
+import { createTerminalShell } from './application.js';
+import { sessionOverlay } from './catalogs.js';
+import { readClipboardImage } from './clipboard-image.js';
+import { editDraftExternally } from './external-editor.js';
+import { FLAG_HELP, VERSION_LINE } from './help.js';
+import { formatSessionList, isSessionId, parseSessionListArgs, sessionMatches, sessionNotFound, } from './session-list.js';
+import { createSessionRuntime, LaunchArgumentError, } from './session-runtime.js';
+import { TuiRoot } from './tui-root.js';
+export const name = 'dashi';
+export const inject = [
+    'agentPresets', 'agents', 'attachments', 'authorization', 'cmdlineArgs', 'commands', 'credentials', 'fs', 'jobs', 'loader', 'permissionPresets', 'subagents',
+    'pluginInventory', 'sessionController', 'sandboxPolicy', 'sessionProjections', 'sessionQuery', 'sessions', 'settings', 'shell', 'skills', 'systemPrompt', 'tools',
+];
+function parseArgs(args) {
+    let accessible = false;
+    let argumentError;
+    let agentPreset, sessionId;
+    let forkSession = false;
+    let inline = true;
+    let name;
+    let effort;
+    let model;
+    let permission;
+    let provider;
+    let tools;
+    let disallowedTools;
+    let resume;
+    let resumeAll = false;
+    let resumePicker = false;
+    let systemPrompt, appendSystemPrompt;
+    let useContinue = false;
+    let verbose = false;
+    const images = [];
+    const prompt = [];
+    for (let index = 0; index < args.length; index++) {
+        const argument = args[index];
+        if (argument === '--accessible')
+            accessible = true;
+        else if (argument === '--inline')
+            inline = true;
+        else if (argument === '--fullscreen')
+            inline = false;
+        else if (['--name', '-n', '--agent', '--image', '--effort', '--model', '--permission', '--provider', '--tools', '--disallowedTools',
+            '--system-prompt', '--system-prompt-file', '--append-system-prompt', '--append-system-prompt-file',
+            '--session-id'].includes(argument ?? '')) {
+            const value = args[++index];
+            if (value === undefined || value === '')
+                return undefined;
+            if (argument === '--name' || argument === '-n')
+                name = value;
+            else if (argument === '--agent')
+                agentPreset = value;
+            else if (argument === '--image')
+                images.push(value);
+            else if (argument === '--effort')
+                effort = value;
+            else if (argument === '--model')
+                model = value;
+            else if (argument === '--permission')
+                permission = value;
+            else if (argument === '--session-id')
+                sessionId = value;
+            else if (argument === '--tools' || argument === '--disallowedTools') {
+                const names = value.split(',').map(name => name.trim());
+                if (names.includes(''))
+                    return undefined;
+                if (argument === '--tools')
+                    tools = names;
+                else
+                    disallowedTools = names;
+            }
+            else if (argument?.includes('system-prompt') === true) {
+                let text = value;
+                if (argument.endsWith('-file')) {
+                    try {
+                        text = readFileSync(value, 'utf8');
+                    }
+                    catch (error) {
+                        argumentError = error instanceof Error ? error.message : String(error);
+                    }
+                }
+                if (argument.startsWith('--append'))
+                    appendSystemPrompt = text;
+                else
+                    systemPrompt = text;
+            }
+            else
+                provider = value;
+        }
+        else if (argument === '--resume' || argument === '-r') {
+            const value = args[index + 1];
+            if (value === '')
+                return undefined;
+            if (value === undefined || value.startsWith('-'))
+                resumePicker = true;
+            else
+                resume = args[++index];
+        }
+        else if (argument === '--all')
+            resumeAll = true;
+        else if (argument === '--continue' || argument === '-c')
+            useContinue = true;
+        else if (argument === '--fork-session')
+            forkSession = true;
+        else if (argument === '--verbose')
+            verbose = true;
+        else if (argument === '--yolo' || argument === '--dangerously-skip-permissions') {
+            permission = 'danger-full-access';
+        }
+        else if (argument?.startsWith('-') === true)
+            return undefined;
+        else if (argument !== undefined)
+            prompt.push(argument);
+    }
+    if (resume !== undefined && (resumePicker || useContinue) || resumePicker && useContinue
+        || name !== undefined && (resume !== undefined || resumePicker || useContinue)
+        || resumeAll && resume === undefined && !resumePicker || resumeAll && useContinue
+        || provider !== undefined && model === undefined
+        || sessionId !== undefined && (!isSessionId(sessionId) || resume !== undefined || resumePicker || useContinue)
+        || agentPreset !== undefined && (resume !== undefined || resumePicker || useContinue)
+        || forkSession && resume === undefined && !resumePicker && !useContinue)
+        return undefined;
+    return {
+        accessible,
+        ...(argumentError === undefined ? {} : { argumentError }),
+        ...(appendSystemPrompt === undefined ? {} : { appendSystemPrompt }),
+        continue: useContinue,
+        ...(agentPreset === undefined ? {} : { agentPreset }), forkSession, inline,
+        resumeAll,
+        resumePicker,
+        ...(images.length === 0 ? {} : { images }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(model === undefined ? {} : { model }),
+        ...(name === undefined ? {} : { name }),
+        ...(permission === undefined ? {} : { permission }),
+        ...(prompt.length === 0 ? {} : { prompt: prompt.join(' ') }),
+        ...(provider === undefined ? {} : { provider }),
+        ...(tools === undefined ? {} : { tools }),
+        ...(disallowedTools === undefined ? {} : { disallowedTools }),
+        ...(resume === undefined ? {} : { resume }), ...(sessionId === undefined ? {} : { sessionId }),
+        ...(systemPrompt === undefined ? {} : { systemPrompt }), verbose,
+    };
+}
+function packageVersion(path) {
+    const manifest = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof manifest.version === 'string' ? manifest.version : 'unknown';
+}
+function runningDshVersions() {
+    try {
+        const entry = realpathSync(process.argv[1] ?? '');
+        const manifest = resolve(dirname(entry), '../package.json');
+        const version = packageVersion(manifest);
+        try {
+            return [version, packageVersion(createRequire(manifest).resolve('@deepseek-ai/dsh-base/package.json'))];
+        }
+        catch {
+            return [version, 'unknown'];
+        }
+    }
+    catch {
+        return ['unknown', 'unknown'];
+    }
+}
+function warnDshVersion() {
+    const [version, baseVersion] = runningDshVersions();
+    if (baseVersion !== version) {
+        process.stderr.write(`dashi: warning: DSH ${version} loads @deepseek-ai/dsh-base ${baseVersion}; versions must match\n`);
+    }
+}
+function installSessionList(ctx, options, ready, exit) {
+    const abort = new AbortController();
+    let listing;
+    const announce = ready.onReady(() => {
+        warnDshVersion();
+        listing = ctx.sessionController.list({}, abort.signal).then(({ items }) => {
+            const cwd = options.all ? undefined : resolve(options.cwd ?? process.cwd());
+            process.stdout.write(`${formatSessionList(items, cwd, options.json)}\n`);
+            exit(0);
+        }).catch((error) => {
+            process.stderr.write(`dashi: sessions list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            exit(1);
+        });
+    });
+    ctx.effect(() => async () => {
+        announce();
+        abort.abort();
+        await listing;
+    }, 'dashi.sessions-list');
+}
+export function apply(ctx) {
+    const exit = ctx.get('appExit');
+    const ready = ctx.get('appReady');
+    const cmdline = ctx.get('cmdlineArgs');
+    if (exit === undefined || ready === undefined || cmdline === undefined) {
+        throw new Error('dashi: the launcher must provide ctx.appExit, ctx.appReady, and ctx.cmdlineArgs');
+    }
+    const args = cmdline.get();
+    if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) {
+        process.stdout.write(`${VERSION_LINE}\n\nUsage: dashi [options] [prompt]\n\n${FLAG_HELP.join('\n')}\n`);
+        exit(0);
+        return;
+    }
+    if (args[0] === 'sessions') {
+        const options = parseSessionListArgs(args);
+        if (options === undefined) {
+            process.stderr.write(`dashi: unsupported arguments: ${args.join(' ')}\n`);
+            exit(2);
+            return;
+        }
+        installSessionList(ctx, options, ready, exit);
+        return;
+    }
+    const parsed = parseArgs(args);
+    if (parsed === undefined) {
+        process.stderr.write(`dashi: unsupported arguments: ${args.join(' ')}\n`);
+        exit(2);
+        return;
+    }
+    const tuiRoot = new TuiRoot(ctx);
+    let shell;
+    let runtime;
+    let boot;
+    const stdoutError = (error) => { void shell?.fail(error); };
+    process.stdout.on('error', stdoutError);
+    const changed = ctx.on('tui/root-changed', (_previous, current) => {
+        if (current === undefined)
+            shell?.dispatch({ type: 'root-cleared' });
+    });
+    const announce = ready.onReady(() => {
+        warnDshVersion();
+        boot = (async () => {
+            if (parsed.argumentError !== undefined)
+                throw new LaunchArgumentError(parsed.argumentError);
+            const cwd = process.cwd();
+            const makeRuntime = (options) => createSessionRuntime(ctx, options, tuiRoot, action => { shell?.dispatch(action); }, {
+                cancel: id => { shell?.cancelDecision(id); },
+                request: decision => shell?.requestDecision(decision)
+                    ?? Promise.reject(new Error('dashi terminal is not ready')),
+            });
+            const sendPrompt = () => {
+                if (parsed.prompt !== undefined)
+                    shell?.dispatch({ type: 'composer-changed', text: parsed.prompt });
+                if (parsed.prompt !== undefined)
+                    shell?.dispatch({ type: 'submit' });
+            };
+            let pickerItems = parsed.resumePicker
+                ? (await ctx.sessionController.list({}, new AbortController().signal)).items : undefined;
+            if (parsed.resume !== undefined && !isSessionId(parsed.resume)) {
+                const matches = sessionMatches((await ctx.sessionController.list({}, new AbortController().signal)).items, parsed.resume, parsed.resumeAll ? undefined : cwd);
+                const [match] = matches;
+                if (match === undefined)
+                    throw sessionNotFound(parsed.resume);
+                if (matches.length > 1)
+                    pickerItems = matches;
+                else
+                    runtime = await makeRuntime({ ...parsed, cwd, resume: String(match.sessionId) });
+            }
+            else if (!parsed.resumePicker)
+                runtime = await makeRuntime({ ...parsed, cwd });
+            const initial = runtime;
+            shell = createTerminalShell({
+                accessible: parsed.accessible,
+                activateOverlay: async (value) => {
+                    if (runtime !== undefined)
+                        return runtime.activate(value);
+                    if (value.kind !== 'resume')
+                        return;
+                    runtime = await makeRuntime({ ...parsed, continue: false, cwd, resume: value.sessionId });
+                    shell?.dispatch({ type: 'root-bound', cells: runtime.initialCells, hasMore: runtime.initialHasMore,
+                        prompts: runtime.initialPrompts, root: runtime.root });
+                    for (const attachment of runtime.initialAttachments)
+                        shell?.dispatch({ type: 'attachment-added', attachment });
+                    runtime.start();
+                    sendPrompt();
+                },
+                attach: path => runtime?.attach(path) ?? Promise.resolve(undefined),
+                beforeExit: () => runtime?.shutdown() ?? Promise.resolve(),
+                complete: (query, caret) => runtime?.complete(query, caret) ?? Promise.resolve([]),
+                cwd,
+                cyclePermission: () => runtime?.cyclePermission() ?? Promise.resolve(),
+                exit,
+                externalEdit: editDraftExternally,
+                ...(initial === undefined ? {} : {
+                    initialAttachments: initial.initialAttachments, initialCells: initial.initialCells, initialHasMore: initial.initialHasMore,
+                    initialPrompts: initial.initialPrompts, initialRoot: initial.root,
+                }),
+                ...(parsed.verbose ? { initialToolMode: 'expanded' } : {}),
+                inline: parsed.inline || parsed.accessible,
+                interrupt: () => { runtime?.interrupt(); },
+                loadHistory: rootId => runtime?.loadHistory(rootId) ?? Promise.resolve(),
+                onReleased: () => { process.stdout.write(`${runtime?.summary ?? ''}\n`); },
+                pasteImage: readClipboardImage,
+                search: (query, rootId) => runtime?.search(query, rootId) ?? Promise.resolve(),
+                statusLine: () => runtime?.statusLine,
+                submit: (text, mode, attachments) => runtime?.submit(text, mode, attachments),
+            });
+            shell.start();
+            if (pickerItems !== undefined) {
+                shell.dispatch({ type: 'open-overlay', overlay: sessionOverlay(pickerItems, '', parsed.resumeAll ? undefined : cwd) });
+            }
+            else {
+                runtime?.start();
+                sendPrompt();
+            }
+        })().catch(async (error) => {
+            process.stderr.write(`dashi: startup failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            await runtime?.shutdown();
+            await shell?.dispose();
+            exit(error instanceof LaunchArgumentError ? 2 : 1);
+        });
+    });
+    ctx.effect(() => async () => {
+        announce();
+        changed();
+        await boot;
+        await runtime?.shutdown();
+        await shell?.dispose();
+        process.stdout.off('error', stdoutError);
+    }, 'dashi.profile-boot');
+    exitOnStdinEnd(ctx, 'dashi.stdin');
+}

package/lib/input.d.ts

@@ -0,0 +1,17 @@
+import { type TUI } from '@earendil-works/pi-tui';
+import { type ComposerCursor, type UiAction, type ViewState } from './state.js';
+export interface InputBindings {
+    readonly dispatch: (action: UiAction) => void;
+    readonly insertNewline?: () => void;
+    readonly insertText?: (text: string) => void;
+    readonly readComposerCursor?: () => ComposerCursor;
+    readonly readState: () => ViewState;
+}
+export declare function droppedPaths(data: string, cwd: string, inspect?: (path: string) => {
+    isDirectory(): boolean;
+}): {
+    readonly images: readonly string[];
+    readonly text: string;
+} | undefined;
+export declare function caretOffset(text: string, cursor: ComposerCursor): number;
+export declare function installInput(tui: TUI, bindings: InputBindings): () => void;

package/lib/input.js

@@ -0,0 +1,267 @@
+import { statSync } from 'node:fs';
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { formatFileMention } from '@deepseek-ai/dsh-file-reference/grammar';
+import { isKeyRelease, matchesKey } from '@earendil-works/pi-tui';
+import { isImagePath } from './image-input.js';
+import { PAGE_CELLS } from './state.js';
+export function droppedPaths(data, cwd, inspect = statSync) {
+    const [start, end] = ['\u001B[200~', '\u001B[201~'];
+    if (!data.startsWith(start) || !data.endsWith(end))
+        return undefined;
+    const token = /(?:[^\s'\\]+|'[^']*'|\\[\s\S])+/gu;
+    const source = data.slice(start.length, -end.length);
+    const chunks = source.match(token) ?? [];
+    if (chunks.length === 0 || source.replace(token, '').trim() !== '')
+        return undefined;
+    const paths = chunks.map(chunk => chunk.replace(/'([^']*)'|\\([\s\S])/gu, (_match, quoted, escaped) => quoted ?? escaped ?? ''));
+    try {
+        const entries = paths.map(value => {
+            const absolute = resolve(cwd, value);
+            const directory = inspect(absolute).isDirectory();
+            if (!directory && isImagePath(absolute))
+                return { absolute };
+            const local = relative(resolve(cwd), absolute);
+            const mention = formatFileMention({ kind: directory ? 'directory' : 'file', path: local !== '' && !isAbsolute(local) && local !== '..' && !local.startsWith(`..${sep}`) ? local : absolute }, false);
+            if (mention === undefined)
+                throw new Error('path cannot be mentioned');
+            return { absolute, mention };
+        });
+        const mentions = entries.flatMap(entry => entry.mention === undefined ? [] : [entry.mention]);
+        return { images: entries.flatMap(entry => entry.mention === undefined ? [entry.absolute] : []), text: mentions.length === 0 ? '' : `${mentions.join(' ')} ` };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function caretOffset(text, cursor) {
+    const lines = text.split('\n');
+    let offset = 0;
+    for (let line = 0; line < cursor.line; line++)
+        offset += (lines[line]?.length ?? 0) + 1;
+    return Math.min(text.length, offset + cursor.col);
+}
+export function installInput(tui, bindings) {
+    return tui.addInputListener((data) => {
+        if (data.includes('\u001B[200~')) {
+            const state = bindings.readState();
+            const decision = state.decisions[0];
+            const question = decision?.kind === 'question' ? decision.questions[decision.index] : undefined;
+            const customQuestion = question !== undefined && decision?.kind === 'question'
+                && decision.cursor === question.options.length;
+            const completion = state.overlay?.kind === 'list' && state.overlay.purpose === 'completion';
+            const dropped = decision === undefined && state.overlay === undefined && state.search === undefined && droppedPaths(data, state.root?.cwd ?? state.cwd);
+            if (dropped) {
+                bindings.insertText?.(dropped.text);
+                for (const path of dropped.images)
+                    bindings.dispatch({ type: 'attachment-path', path });
+                return { consume: true };
+            }
+            return customQuestion || state.search !== undefined || completion
+                || decision === undefined && state.overlay === undefined ? undefined : { consume: true };
+        }
+        if (isKeyRelease(data))
+            return { consume: true };
+        const state = bindings.readState();
+        const ctrlC = matchesKey(data, 'ctrl+c');
+        const ctrlD = matchesKey(data, 'ctrl+d');
+        if ((state.rewindArmed && !matchesKey(data, 'escape')) || (state.exitArmed && !ctrlC && !ctrlD)) {
+            bindings.dispatch({ type: 'disarm-exit' });
+        }
+        if (ctrlC) {
+            bindings.dispatch({ type: 'ctrl-c' });
+            return { consume: true };
+        }
+        const decision = bindings.readState().decisions[0];
+        if (decision !== undefined) {
+            const question = decision.kind === 'question' ? decision.questions[decision.index] : undefined;
+            const custom = question !== undefined && decision.cursor === question.options.length;
+            if (matchesKey(data, 'escape'))
+                bindings.dispatch({ type: 'decision-cancel' });
+            else if (matchesKey(data, 'up'))
+                bindings.dispatch({ type: 'decision-move', offset: -1 });
+            else if (matchesKey(data, 'down'))
+                bindings.dispatch({ type: 'decision-move', offset: 1 });
+            else if (matchesKey(data, 'enter'))
+                bindings.dispatch({ type: 'decision-submit' });
+            else if (custom)
+                return undefined;
+            else if (matchesKey(data, 'space'))
+                bindings.dispatch({ type: 'decision-toggle' });
+            else {
+                for (let number = 1; number <= 9; number++) {
+                    if (!matchesKey(data, String(number)))
+                        continue;
+                    bindings.dispatch({ type: 'decision-number', number });
+                    break;
+                }
+            }
+            return { consume: true };
+        }
+        if (matchesKey(data, 'f1')) {
+            bindings.dispatch({ type: 'help' });
+            return { consume: true };
+        }
+        const search = bindings.readState().search;
+        if (search !== undefined) {
+            if (matchesKey(data, 'escape'))
+                bindings.dispatch({ type: 'search-close' });
+            else if (matchesKey(data, 'enter') || matchesKey(data, 'down')) {
+                bindings.dispatch({ type: 'search-move', offset: 1 });
+            }
+            else if (matchesKey(data, 'shift+enter') || matchesKey(data, 'up')) {
+                bindings.dispatch({ type: 'search-move', offset: -1 });
+            }
+            else
+                return undefined;
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+f')) {
+            bindings.dispatch({ type: 'search-open', scope: 'transcript' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+b')) {
+            bindings.dispatch({ type: 'open-details' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'shift+tab')) {
+            bindings.dispatch({ type: 'cycle-permission' });
+            return { consume: true };
+        }
+        const overlay = bindings.readState().overlay;
+        if (overlay !== undefined) {
+            if (matchesKey(data, 'escape'))
+                bindings.dispatch({ type: 'overlay-close' });
+            else if (overlay.kind === 'history' && matchesKey(data, 'up'))
+                bindings.dispatch({ type: 'history-move', offset: -1 });
+            else if (overlay.kind === 'history' && matchesKey(data, 'down'))
+                bindings.dispatch({ type: 'history-move', offset: 1 });
+            else if (overlay.kind === 'history' && matchesKey(data, '/'))
+                bindings.dispatch({ type: 'search-open', scope: 'history' });
+            else if (overlay.kind === 'history' && matchesKey(data, 'y'))
+                bindings.dispatch({ type: 'history-copy' });
+            else if (overlay.kind === 'info' && matchesKey(data, 'pageUp'))
+                bindings.dispatch({ type: 'overlay-move', offset: -PAGE_CELLS });
+            else if (overlay.kind === 'info' && matchesKey(data, 'pageDown'))
+                bindings.dispatch({ type: 'overlay-move', offset: PAGE_CELLS });
+            else if (matchesKey(data, 'up'))
+                bindings.dispatch({ type: 'overlay-move', offset: -1 });
+            else if (matchesKey(data, 'down'))
+                bindings.dispatch({ type: 'overlay-move', offset: 1 });
+            else if (matchesKey(data, 'ctrl+o'))
+                bindings.dispatch({ type: 'toggle-tool-mode' });
+            else if (matchesKey(data, 'enter'))
+                bindings.dispatch({ type: 'overlay-submit', execute: true });
+            else if (matchesKey(data, 'tab'))
+                bindings.dispatch({ type: 'overlay-submit' });
+            else if (overlay.kind === 'list' && overlay.purpose === 'completion') {
+                bindings.dispatch({ type: 'overlay-close' });
+                return undefined;
+            }
+            else {
+                for (let number = 1; number <= 9; number++) {
+                    if (!matchesKey(data, String(number)))
+                        continue;
+                    bindings.dispatch({ type: 'overlay-number', number });
+                    break;
+                }
+            }
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+v')) {
+            bindings.dispatch({ type: 'clipboard-paste' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'pageUp')) {
+            bindings.dispatch(bindings.readState().inline
+                ? { type: 'open-history' }
+                : { type: 'scroll', direction: 'page-up' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'pageDown')) {
+            bindings.dispatch({ type: 'scroll', direction: 'page-down' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+home')) {
+            bindings.dispatch(bindings.readState().inline
+                ? { type: 'open-history' }
+                : { type: 'scroll', direction: 'home' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+end')) {
+            bindings.dispatch({ type: 'scroll', direction: 'end' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'tab')) {
+            const state = bindings.readState();
+            const cursor = bindings.readComposerCursor?.() ?? { col: state.composer.length, line: 0 };
+            bindings.dispatch({ type: 'request-completion', caret: caretOffset(state.composer, cursor) });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+r')) {
+            bindings.dispatch({ type: 'request-search' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'up') && !bindings.readState().composer.includes('\n')) {
+            bindings.dispatch({ type: 'recall-move', offset: -1 });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'down') && bindings.readState().recall !== undefined) {
+            bindings.dispatch({ type: 'recall-move', offset: 1 });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+o')) {
+            bindings.dispatch({ type: 'toggle-tool-mode' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+t')) {
+            bindings.dispatch({ type: 'toggle-send-mode' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+s')) {
+            const state = bindings.readState();
+            bindings.dispatch({
+                type: 'stash-toggle', cursor: bindings.readComposerCursor?.() ?? { col: state.composer.length, line: 0 },
+            });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+g')) {
+            bindings.dispatch({ type: 'external-edit' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'backspace')) {
+            const state = bindings.readState();
+            if (state.composer === '' && state.attachments.length > 0) {
+                bindings.dispatch({ type: 'attachment-remove', index: state.attachments.length - 1 });
+                return { consume: true };
+            }
+        }
+        if (data === '\n' || matchesKey(data, 'ctrl+j')
+            || matchesKey(data, 'shift+enter') || matchesKey(data, 'alt+enter')) {
+            bindings.insertNewline?.();
+            return { consume: true };
+        }
+        if (matchesKey(data, 'enter')) {
+            bindings.dispatch({ type: 'submit' });
+            return { consume: true };
+        }
+        if (ctrlD && bindings.readState().composer === '') {
+            bindings.dispatch({ type: 'ctrl-d' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+l')) {
+            bindings.dispatch({ type: 'redraw' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'ctrl+z')) {
+            bindings.dispatch({ type: 'suspend' });
+            return { consume: true };
+        }
+        if (matchesKey(data, 'escape')) {
+            bindings.dispatch({ type: 'escape' });
+            return { consume: true };
+        }
+        if (bindings.readState().exitArmed)
+            bindings.dispatch({ type: 'disarm-exit' });
+        return undefined;
+    });
+}

package/lib/memory.d.ts

@@ -0,0 +1,3 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { Overlay } from './state.js';
+export declare function memoryOverlay(agent: Agent): Overlay;

package/lib/memory.js

@@ -0,0 +1,27 @@
+import { resolve } from 'node:path';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+export function memoryOverlay(agent) {
+    const cwd = agent.session.header.cwd ?? process.cwd();
+    let root = cwd;
+    const active = new Map();
+    for (const seq of agent.session.surface.nodes) {
+        const event = agent.session.eventAt(seq);
+        if (event?.type !== 'user/message' || event.data.source.kind !== 'agent-instructions')
+            continue;
+        const source = event.data.source, identity = source.baselineIdentity === undefined
+            ? undefined : JSON.parse(source.baselineIdentity);
+        if (typeof identity?.projectRoot === 'string')
+            root = resolve(cwd, identity.projectRoot);
+        for (const change of source.changes) {
+            if (change.action === 'remove')
+                active.delete(change.scope);
+            else
+                active.set(change.scope, { path: change.path, scope: change.scope.split('\0')[0] ?? change.scope });
+        }
+    }
+    return { cursor: 0, kind: 'list', options: [...active.values()].map(item => {
+            const homePath = /^(?:~\/\.dsh|\$DSH_HOME)\/(.*)$/u.exec(item.path)?.[1];
+            return { detail: `scope ${item.scope}`, label: item.path,
+                value: { kind: 'open-file', path: resolve(homePath === undefined ? root : resolveDshHome(), homePath ?? item.path) } };
+        }), purpose: 'memory', title: 'Memory' };
+}

package/lib/mouse-input.d.ts

@@ -0,0 +1 @@
+export declare function filterWheelInput(data: string): -3 | 3 | string;

package/lib/mouse-input.js

@@ -0,0 +1,6 @@
+export function filterWheelInput(data) {
+    if (!data.startsWith('\u001B[<'))
+        return data;
+    const match = /^(64|65);\d+;\d+M$/u.exec(data.slice(3));
+    return match?.[1] === '64' ? 3 : match?.[1] === '65' ? -3 : data;
+}

package/lib/presentation.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionJob } from '@deepseek-ai/dsh-api-session-controller';
+import type { SessionId } from '@deepseek-ai/dsh-session';
+import type { JobView, SubagentView } from './state.js';
+/** Web-equivalent context occupancy; undefined until both DSH projection fields exist. */
+export declare function contextPercent(value: unknown): number | undefined;
+export declare function jobViews(jobs: readonly SessionJob[]): readonly JobView[];
+/** Read DSH's direct-child catalog and projection-backed summary facts. */
+export declare function subagentViews(ctx: Context, parentId: SessionId, signal: AbortSignal): Promise<readonly SubagentView[]>;