@antst/dashi 0.1.0-alpha.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Starikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# @antst/dashi
+
+dashi is a terminal UI for DeepSeek Harness (DSH). Install it as a bundle
+via `@antst/dashi-app`, not as a standalone dependency:
+
+Install the exact validated DSH release and start dashi:
+
+```sh
+pnpm install @deepseek-ai/dsh@0.1.2-rc.1
+dsh plugin --profile dashi add @antst/dashi-app
+dsh --profile dashi
+```
+
+Npm is unsupported for prerelease DSH because it cannot constrain a scoped
+package family to one prerelease.
+When upgrading DSH, remove `node_modules` and the lockfile before installing so
+pnpm cannot retain stale peer-only DSH packages.
+dashi validates each DSH release before adopting it, and its packages pin DSH
+dependencies exactly.
+
+Status: pre-release alpha. Interfaces and behavior may change between
+alpha versions; the validated DSH version is `0.1.2-rc.1`.
+
+Full documentation, source, and issue tracker:
+https://forgejo.antst.net/ai/dashi

package/lib/application.d.ts

@@ -0,0 +1,43 @@
+import { type Renderer } from './renderer.js';
+import { type ActivatableOverlayValue, type DecisionAnswer, type DraftAttachment, type PendingDecision, type OverlayOption, type UiAction, type ViewState } from './state.js';
+export interface ShellBindings {
+    readonly dispatch: (action: UiAction) => void;
+    readonly readState: () => ViewState;
+}
+export interface TerminalShellOptions {
+    readonly accessible?: boolean;
+    readonly beforeExit?: () => Promise<void>;
+    readonly activateOverlay?: (value: ActivatableOverlayValue) => Promise<void>;
+    readonly attach?: (path: string) => Promise<DraftAttachment | undefined>;
+    readonly complete?: (query: string, caret: number) => Promise<readonly OverlayOption[]>;
+    readonly createView?: (bindings: ShellBindings) => Renderer;
+    readonly cyclePermission?: () => Promise<void>;
+    readonly cwd: string;
+    readonly exit: (code: number) => void;
+    readonly externalEdit?: (text: string, cwd: string) => Promise<string>;
+    readonly initialAttachments?: readonly DraftAttachment[];
+    readonly initialCells?: ViewState['cells'];
+    readonly initialHasMore?: boolean;
+    readonly initialPrompts?: ViewState['prompts'];
+    readonly initialRoot?: ViewState['root'];
+    readonly interrupt?: () => void;
+    readonly inline: boolean;
+    readonly loadHistory?: (rootId: string) => Promise<void>;
+    readonly onReleased?: () => void;
+    readonly pasteImage?: () => Promise<DraftAttachment>;
+    readonly search?: (query: string, rootId: string) => Promise<void>;
+    readonly submit?: (text: string, mode: 'next-turn' | 'steer', attachments: readonly DraftAttachment[]) => Promise<void> | void;
+    readonly suspend?: () => Promise<void>;
+    readonly writeError?: (message: string) => void;
+}
+export interface TerminalShell {
+    cancelDecision(id: string): void;
+    dispatch(action: UiAction): void;
+    dispose(): Promise<void>;
+    fail(error: unknown): Promise<void>;
+    readState(): ViewState;
+    requestDecision(decision: PendingDecision): Promise<DecisionAnswer>;
+    start(): void;
+    whenIdle(): Promise<void>;
+}
+export declare function createTerminalShell(options: TerminalShellOptions): TerminalShell;

package/lib/application.js

@@ -0,0 +1,260 @@
+import { createRenderer } from './renderer.js';
+import { initialViewState, reduce, } from './state.js';
+import { createTerminalGuard } from './terminal-guard.js';
+function suspendProcess() {
+    return new Promise((resolve, reject) => {
+        const resumed = () => { resolve(); };
+        process.once('SIGCONT', resumed);
+        try {
+            process.kill(process.pid, 'SIGTSTP');
+        }
+        catch (error) {
+            process.off('SIGCONT', resumed);
+            reject(error);
+        }
+    });
+}
+export function createTerminalShell(options) {
+    let state = initialViewState(options.cwd, options.inline, options.initialRoot, options.initialCells, options.initialPrompts, options.initialHasMore, options.initialAttachments);
+    let accepting = true;
+    let failed = false;
+    let queue = Promise.resolve();
+    const pending = new Map();
+    const bindings = {
+        dispatch: action => { dispatch(action); },
+        readState: () => state,
+    };
+    const renderer = options.createView?.(bindings) ?? createRenderer({
+        ...bindings, ...(options.accessible === undefined ? {} : { accessible: options.accessible }), inline: options.inline,
+    });
+    const guard = createTerminalGuard(renderer);
+    const writeError = options.writeError ?? (message => { process.stderr.write(message); });
+    let exitTimer;
+    let released = false;
+    const release = async () => {
+        if (exitTimer !== undefined)
+            clearTimeout(exitTimer);
+        exitTimer = undefined;
+        await guard.dispose();
+        if (released)
+            return;
+        released = true;
+        options.onReleased?.();
+    };
+    async function run(effect) {
+        switch (effect.type) {
+            case 'activate-overlay':
+                await options.activateOverlay?.(effect.value);
+                return;
+            case 'attach': {
+                try {
+                    const attachment = await options.attach?.(effect.path);
+                    if (attachment !== undefined)
+                        dispatch({
+                            type: 'attachment-added', attachment, source: effect.source, text: effect.text,
+                        });
+                }
+                catch (error) {
+                    dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
+            case 'bell':
+                if (options.accessible !== true)
+                    renderer.bell();
+                return;
+            case 'clipboard-image': {
+                try {
+                    const attachment = await options.pasteImage?.();
+                    if (attachment !== undefined)
+                        dispatch({ type: 'attachment-added', attachment });
+                }
+                catch (error) {
+                    dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
+            case 'complete': {
+                const items = await options.complete?.(effect.query, effect.caret) ?? [];
+                dispatch({ type: 'completion-ready', options: items, query: effect.query });
+                return;
+            }
+            case 'copy': {
+                const result = renderer.copy(effect.text);
+                if (result === 'too-large')
+                    dispatch({ type: 'runtime-error', message: 'Copy is limited to 64 KiB.' });
+                else if (result === 'unsupported')
+                    dispatch({ type: 'runtime-error', message: 'This terminal does not support OSC 52 copy.' });
+                return;
+            }
+            case 'cycle-permission':
+                await options.cyclePermission?.();
+                return;
+            case 'exit':
+                accepting = false;
+                await options.beforeExit?.();
+                await release();
+                options.exit(0);
+                return;
+            case 'exit-timer':
+                if (exitTimer !== undefined)
+                    clearTimeout(exitTimer);
+                exitTimer = effect.armed ? setTimeout(() => { dispatch({ type: 'disarm-exit' }); }, 2_000) : undefined;
+                return;
+            case 'external-edit': {
+                try {
+                    let edited;
+                    await guard.withCookedTerminal(async () => {
+                        edited = await options.externalEdit?.(effect.text, effect.cwd);
+                    });
+                    if (edited !== undefined)
+                        dispatch({ type: 'composer-set', text: edited });
+                }
+                catch (error) {
+                    dispatch({ type: 'runtime-error', message: error instanceof Error ? error.message : String(error) });
+                }
+                return;
+            }
+            case 'interrupt':
+                options.interrupt?.();
+                return;
+            case 'load-history':
+                await options.loadHistory?.(effect.rootId);
+                return;
+            case 'redraw':
+                renderer.render(effect.force);
+                return;
+            case 'reject-decision': {
+                const settlement = pending.get(effect.id);
+                if (settlement === undefined)
+                    return;
+                pending.delete(effect.id);
+                if (settlement.kind === 'approval') {
+                    settlement.resolve(effect.reason === 'terminal' ? 'rejected' : 'cancelled');
+                }
+                else {
+                    const error = new Error(effect.reason === 'terminal'
+                        ? 'the terminal closed before the user answered'
+                        : 'the question was withdrawn before the user answered');
+                    error.name = 'UserQuestionError';
+                    error.code = effect.reason === 'terminal' ? 'ASK_CANCELLED' : 'ASK_ABORTED';
+                    settlement.reject(error);
+                }
+                return;
+            }
+            case 'set-composer':
+                renderer.setComposer(effect.text, effect.cursor);
+                return;
+            case 'search':
+                await options.search?.(effect.query, effect.rootId);
+                return;
+            case 'settle-decision': {
+                const settlement = pending.get(effect.id);
+                if (settlement === undefined)
+                    return;
+                pending.delete(effect.id);
+                settlement.resolve(effect.answer);
+                return;
+            }
+            case 'submit':
+                await options.submit?.(effect.text, effect.mode, effect.attachments);
+                return;
+            case 'suspend':
+                await guard.withCookedTerminal(options.suspend ?? suspendProcess);
+        }
+    }
+    async function fail(error) {
+        if (failed)
+            return;
+        failed = true;
+        accepting = false;
+        const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+        writeError(`dashi: terminal failure\n${detail}\n`);
+        try {
+            const [next, effects] = reduce(state, { type: 'terminal-lost' });
+            state = next;
+            for (const effect of effects)
+                await run(effect);
+            try {
+                await options.beforeExit?.();
+            }
+            catch (cleanupError) {
+                const cleanupDetail = cleanupError instanceof Error
+                    ? cleanupError.stack ?? cleanupError.message
+                    : String(cleanupError);
+                writeError(`dashi: cleanup failure\n${cleanupDetail}\n`);
+            }
+            await release();
+        }
+        finally {
+            options.exit(1);
+        }
+    }
+    function dispatch(action) {
+        if (!accepting)
+            return;
+        const [next, effects] = reduce(state, action);
+        state = next;
+        if (effects.length === 0)
+            return;
+        queue = queue.then(async () => {
+            for (const effect of effects)
+                await run(effect);
+        }).catch(fail);
+    }
+    async function whenIdle() {
+        for (;;) {
+            const observed = queue;
+            await observed;
+            if (queue === observed)
+                return;
+        }
+    }
+    return {
+        cancelDecision(id) {
+            dispatch({ type: 'decision-withdrawn', id });
+        },
+        dispatch,
+        async dispose() {
+            const [next, effects] = reduce(state, { type: 'terminal-lost' });
+            state = next;
+            for (const effect of effects)
+                await run(effect);
+            accepting = false;
+            await queue;
+            try {
+                await options.beforeExit?.();
+            }
+            finally {
+                await release();
+            }
+        },
+        fail,
+        readState: () => state,
+        requestDecision(decision) {
+            if (!accepting)
+                return Promise.reject(new Error('dashi terminal is closing'));
+            if (pending.has(decision.id))
+                return Promise.reject(new Error(`duplicate decision ${decision.id}`));
+            let resolve;
+            let reject;
+            const promise = new Promise((accept, decline) => {
+                resolve = accept;
+                reject = decline;
+            });
+            pending.set(decision.id, { kind: decision.kind, reject, resolve });
+            dispatch({ type: 'decision-enqueued', decision });
+            return promise;
+        },
+        start() {
+            try {
+                guard.start();
+                renderer.render(true);
+            }
+            catch (error) {
+                void fail(error);
+            }
+        },
+        whenIdle,
+    };
+}

package/lib/at-trigger.d.ts

@@ -0,0 +1,8 @@
+export interface AtTrigger {
+    readonly end: number;
+    readonly query: string;
+    readonly quoted: boolean;
+    readonly start: number;
+}
+/** Terminal copy of the @ branch in DSH ui-input-trigger core/detect. */
+export declare function detectAtTrigger(draft: string, caret: number): AtTrigger | undefined;

package/lib/at-trigger.js

@@ -0,0 +1,13 @@
+import { activeAtToken } from '@deepseek-ai/dsh-file-reference/grammar';
+/** Terminal copy of the @ branch in DSH ui-input-trigger core/detect. */
+export function detectAtTrigger(draft, caret) {
+    const token = activeAtToken(draft, caret);
+    if (token === undefined)
+        return undefined;
+    return {
+        end: caret,
+        query: token.query,
+        quoted: token.quoted,
+        start: caret - token.prefix.length,
+    };
+}

package/lib/catalogs.d.ts

@@ -0,0 +1,23 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { AgentPreset } from '@deepseek-ai/dsh-agent-presets';
+import type { ModelCatalog, ModelSelection, SessionSummary } from '@deepseek-ai/dsh-api-session-controller';
+import type { SessionSearchHit } from '@deepseek-ai/dsh-session-query';
+import type { Overlay, OverlayOption, RootView } from './state.js';
+/** Build command and skill completion rows for one exact root. */
+export declare function completionOptions(ctx: Context, agent: Agent, input: string, caret?: number, signal?: AbortSignal): Promise<readonly OverlayOption[]>;
+/** Build the cold session picker without adopting any candidate. */
+export declare function sessionOverlay(items: readonly SessionSummary[], currentId: string, cwd?: string): Overlay;
+/** Flatten DSH's provider/model/effort catalog into one terminal picker. */
+export declare function modelOverlay(catalog: ModelCatalog, selected?: ModelSelection): Overlay;
+/** Build the preset picker from the native preset service. */
+export declare function permissionOverlay(ctx: Context, agent: Agent): Overlay;
+/** Read DSH-owned root facts for /status in one projection cut. */
+export declare function statusOverlay(ctx: Context, agent: Agent, root: RootView): Overlay;
+/** Show DSH's heuristic next-request composition without treating it as an exact total. */
+export declare function contextOverlay(ctx: Context, agent: Agent): Overlay;
+/** Build the native agent-preset picker; broken presets are visible elsewhere, not selectable here. */
+export declare function agentPresetOverlay(presets: readonly AgentPreset[], current: string, blank: boolean): Overlay;
+/** Build bounded same-cwd prompt-search rows from DSH query hits. */
+export declare function searchOverlay(items: readonly SessionSearchHit[], rootId: string): Overlay;
+export declare function currentModel(ctx: Context, agent: Agent): ModelSelection | undefined;

package/lib/catalogs.js

@@ -0,0 +1,218 @@
+import { formatFileMention } from '@deepseek-ai/dsh-file-reference/grammar';
+import { isUserInvocable } from '@deepseek-ai/dsh-skill';
+import { detectAtTrigger } from './at-trigger.js';
+import { slashCompletionQuery } from './completion-trigger.js';
+import { isImagePath } from './image-input.js';
+import { sessionTitle } from './session-list.js';
+function matchRank(name, query) {
+    const candidate = name.toLocaleLowerCase();
+    const needle = query.toLocaleLowerCase();
+    return candidate.startsWith(needle) ? 0 : candidate.includes(needle) ? 1 : 2;
+}
+function selectedModel(ctx, agent) {
+    const selection = ctx.sessionProjections.snapshot(agent.session, ['modelSelection']).values.modelSelection;
+    return selection?.next ?? selection?.lastUsed ?? undefined;
+}
+/** Build command and skill completion rows for one exact root. */
+export async function completionOptions(ctx, agent, input, caret = input.length, signal) {
+    const at = detectAtTrigger(input, caret);
+    if (at !== undefined) {
+        const service = ctx.get('fileReferences');
+        if (service === undefined)
+            return [];
+        const candidates = await service.list(agent, at.query, signal ?? new AbortController().signal);
+        return candidates.flatMap((candidate) => {
+            const mention = formatFileMention(candidate, at.quoted);
+            if (mention === undefined)
+                return [];
+            const text = `${input.slice(0, at.start)}${mention}${input.slice(at.end)}`;
+            const image = candidate.kind === 'file' && isImagePath(candidate.path);
+            return [{
+                    detail: candidate.kind === 'directory' ? 'directory' : image ? 'attach image' : 'file',
+                    group: 'Files',
+                    label: `${candidate.path}${candidate.kind === 'directory' ? '/' : ''}`,
+                    value: image
+                        ? {
+                            kind: 'attach',
+                            path: candidate.path,
+                            source: input,
+                            text: `${input.slice(0, at.start)}${input.slice(at.end)}`,
+                        }
+                        : { kind: 'insert', text },
+                }];
+        });
+    }
+    const query = slashCompletionQuery(input);
+    if (query === undefined)
+        return [];
+    const commands = ctx.commands.list(agent)
+        .filter(command => matchRank(command.name, query) < 2)
+        .sort((left, right) => matchRank(left.name, query) - matchRank(right.name, query)
+        || left.name.localeCompare(right.name))
+        .map(command => ({
+        detail: command.description,
+        group: 'Commands',
+        label: `/${command.name}${command.input?.hint === undefined ? '' : ` ${command.input.hint}`}`,
+        ...(command.input?.hint === undefined ? { submitOnEnter: true } : {}),
+        value: { kind: 'insert', text: `/${command.name} ` },
+    }));
+    const skills = (await ctx.skills.list({ cwd: agent.session.header.cwd, scope: agent, signal }))
+        .filter(isUserInvocable)
+        .filter(skill => matchRank(skill.name, query) < 2)
+        .sort((left, right) => matchRank(left.name, query) - matchRank(right.name, query)
+        || left.name.localeCompare(right.name))
+        .map(skill => ({
+        detail: skill.description,
+        group: 'Skills',
+        label: `/${skill.name}`,
+        value: { kind: 'insert', text: `/${skill.name} ` },
+    }));
+    return [...commands, ...skills];
+}
+/** Build the cold session picker without adopting any candidate. */
+export function sessionOverlay(items, currentId, cwd) {
+    return {
+        cursor: 0,
+        kind: 'list',
+        options: items.filter(item => item.origin === undefined && (cwd === undefined || item.cwd === cwd)).map(item => ({
+            active: String(item.sessionId) === currentId,
+            detail: `${item.cwd ?? 'cwd unavailable'} · ${new Date(item.updatedAt).toISOString()}`,
+            label: `${sessionTitle(item) ?? 'Untitled'} · ${String(item.sessionId)}`,
+            value: { kind: 'resume', sessionId: String(item.sessionId) },
+        })),
+        purpose: 'resume',
+        title: 'Resume session',
+    };
+}
+/** Flatten DSH's provider/model/effort catalog into one terminal picker. */
+export function modelOverlay(catalog, selected) {
+    const options = [];
+    for (const group of catalog.groups) {
+        for (const model of group.models) {
+            const efforts = model.reasoning?.efforts ?? [];
+            if (efforts.length === 0) {
+                options.push({
+                    active: selected?.provider === group.id && selected.model === model.id,
+                    label: `${group.name} · ${model.name}`,
+                    value: { kind: 'model', model: model.id, provider: group.id },
+                    ...(model.description === undefined ? {} : { detail: model.description }),
+                });
+                continue;
+            }
+            for (const effort of efforts) {
+                options.push({
+                    active: selected?.provider === group.id && selected.model === model.id
+                        && (selected.reasoningEffort ?? model.reasoning?.defaultEffort) === effort.id,
+                    label: `${group.name} · ${model.name} · ${effort.name}`,
+                    value: { kind: 'model', effort: effort.id, model: model.id, provider: group.id },
+                    ...(effort.description ?? model.description) === undefined
+                        ? {} : { detail: effort.description ?? model.description },
+                });
+            }
+        }
+    }
+    return { cursor: Math.max(0, options.findIndex(option => option.active === true)), kind: 'list', options, purpose: 'model', title: 'Model' };
+}
+/** Build the preset picker from the native preset service. */
+export function permissionOverlay(ctx, agent) {
+    const current = ctx.permissionPresets.current(agent.session);
+    const options = ctx.permissionPresets.names.map((preset) => {
+        const option = ctx.permissionPresets.optionOf(preset);
+        const spec = ctx.permissionPresets.resolve(preset);
+        return {
+            active: preset === current,
+            confirmDetail: [`Sandbox: ${spec.sandbox}`, `Approval: ${spec.approval}`],
+            danger: spec.approval === 'never',
+            label: option.name,
+            value: { kind: 'permission', preset },
+            ...(option.description === undefined ? {} : { detail: option.description }),
+        };
+    });
+    return {
+        cursor: Math.max(0, options.findIndex(option => option.active)),
+        kind: 'list', options, purpose: 'permission', title: 'Permission preset',
+    };
+}
+function number(value) {
+    return typeof value === 'number' ? value.toLocaleString('en-US') : 'unavailable';
+}
+/** Read DSH-owned root facts for /status in one projection cut. */
+export function statusOverlay(ctx, agent, root) {
+    const values = ctx.sessionProjections.snapshot(agent.session, [
+        'modelSelection', 'permissions', 'tokenUsage', 'contextPressure', 'contextBreakdown',
+    ]).values;
+    const model = values.modelSelection?.next ?? values.modelSelection?.lastUsed;
+    const usage = values.tokenUsage;
+    const pressure = values.contextPressure;
+    const breakdown = values.contextBreakdown;
+    return {
+        kind: 'info',
+        lines: [
+            `UUID: ${root.id}`,
+            `Title: ${root.title ?? 'Untitled'}`,
+            `Cwd: ${root.cwd}`,
+            root.parent === undefined
+                ? 'Lineage: root session'
+                : `Lineage: forked from ${root.parent} at turn ${String(root.parentTurn ?? 'unknown')}`,
+            `Model: ${model === null || model === undefined ? root.model : `${model.provider}/${model.model}`}`,
+            `Effort: ${model?.reasoningEffort ?? root.effort ?? 'default'}`,
+            `Permission: ${ctx.permissionPresets.current(agent.session)}`,
+            `Usage: input ${number(usage?.uncachedInputTokens)} · output ${number(usage?.outputTokens)} · cache read ${number(usage?.cacheReadTokens)} · cache write ${number(usage?.cacheWriteTokens)}`,
+            `Context: ${number(pressure?.projectedTokens)} / ${number(pressure?.contextWindow)} tokens`,
+            `Composition: system ${number(breakdown?.systemTokens)} · tools ${number(breakdown?.toolsTokens)} · messages ${number(breakdown?.messageTokens)}`,
+        ],
+        title: 'Status',
+    };
+}
+/** Show DSH's heuristic next-request composition without treating it as an exact total. */
+export function contextOverlay(ctx, agent) {
+    const breakdown = ctx.sessionProjections.snapshot(agent.session, ['contextBreakdown'])
+        .values.contextBreakdown;
+    return {
+        kind: 'info',
+        lines: [
+            `System prompt: ${number(breakdown?.systemTokens)} tokens`,
+            `Tool schemas: ${number(breakdown?.toolsTokens)} tokens`,
+            `Messages: ${number(breakdown?.messageTokens)} tokens`,
+            'These are DSH heuristic estimates for the next request, not a provider-reported total.',
+        ],
+        title: 'Context',
+    };
+}
+/** Build the native agent-preset picker; broken presets are visible elsewhere, not selectable here. */
+export function agentPresetOverlay(presets, current, blank) {
+    const options = presets.filter(preset => preset.broken === undefined).map(preset => ({
+        active: preset.id === current,
+        label: preset.name ?? preset.id,
+        value: { kind: 'agent-preset', preset: preset.id },
+        ...(preset.description === undefined ? {} : { detail: preset.description }),
+    }));
+    return {
+        cursor: Math.max(0, options.findIndex(option => option.active)),
+        kind: 'list',
+        notice: blank ? 'The current session is blank.' : 'Choosing a preset starts a new session.',
+        options,
+        purpose: 'agents',
+        title: 'Agent preset',
+    };
+}
+/** Build bounded same-cwd prompt-search rows from DSH query hits. */
+export function searchOverlay(items, rootId) {
+    return {
+        cursor: 0,
+        kind: 'list',
+        options: items.map(item => ({
+            detail: `${String(item.header.id)} · ${item.header.cwd ?? 'cwd unavailable'}`,
+            label: item.bestMatch.snippet.replaceAll(/\s+/gu, ' ').trim(),
+            value: {
+                kind: 'search-result', rootId, seq: item.bestMatch.seq,
+                sessionId: String(item.header.id),
+            },
+        })),
+        purpose: 'search',
+        title: 'Prompt search',
+    };
+}
+export function currentModel(ctx, agent) {
+    return selectedModel(ctx, agent);
+}

package/lib/clipboard-image.d.ts

@@ -0,0 +1,3 @@
+import type { DraftAttachment } from './state.js';
+/** Read a PNG from an installed platform clipboard helper. */
+export declare function readClipboardImage(platform?: NodeJS.Platform, path?: string): Promise<DraftAttachment>;